448 lines
13 KiB
Objective-C
448 lines
13 KiB
Objective-C
//
|
|
// SpectrumViewSK.m
|
|
// Cog
|
|
//
|
|
// Created by Christopher Snowhill on 2/12/22.
|
|
//
|
|
|
|
#import "SpectrumViewSK.h"
|
|
|
|
#import "NSView+Visibility.h"
|
|
|
|
#import <Metal/Metal.h>
|
|
|
|
#import "analyzer.h"
|
|
|
|
#import "Logging.h"
|
|
|
|
#define LOWER_BOUND -80
|
|
|
|
static void *kSpectrumViewSKContext = &kSpectrumViewSKContext;
|
|
|
|
extern NSString *CogPlaybackDidBeginNotficiation;
|
|
extern NSString *CogPlaybackDidPauseNotficiation;
|
|
extern NSString *CogPlaybackDidResumeNotficiation;
|
|
extern NSString *CogPlaybackDidStopNotficiation;
|
|
|
|
@interface SpectrumViewSK () {
|
|
VisualizationController *visController;
|
|
NSTimer *timer;
|
|
BOOL paused;
|
|
BOOL stopped;
|
|
BOOL isListening;
|
|
BOOL bandsReset;
|
|
BOOL cameraControlEnabled;
|
|
BOOL observersAdded;
|
|
BOOL isOccluded;
|
|
|
|
NSColor *backgroundColor;
|
|
ddb_analyzer_t _analyzer;
|
|
ddb_analyzer_draw_data_t _draw_data;
|
|
|
|
SCNVector3 cameraPosition2d;
|
|
SCNVector3 cameraEulerAngles2d;
|
|
SCNVector3 cameraPosition3d;
|
|
SCNVector3 cameraEulerAngles3d;
|
|
|
|
float visAudio[4096], visFFT[2048];
|
|
}
|
|
@end
|
|
|
|
@implementation SpectrumViewSK
|
|
|
|
+ (SpectrumViewSK *)createGuardWithFrame:(NSRect)frame {
|
|
if (![NSUserDefaults.standardUserDefaults boolForKey:@"spectrumSceneKit"])
|
|
return nil;
|
|
|
|
do {
|
|
if(@available(macOS 11.0, *)) {
|
|
// macOS 11 and newer seems to be safe
|
|
break;
|
|
} else if(@available(macOS 10.15, *)) {
|
|
// macOS 10.15.7 has a SceneKit bug with PBR noise
|
|
return nil;
|
|
} else {
|
|
// macOS 10.12 through 10.14.x seem to be safe too
|
|
break;
|
|
}
|
|
} while(0);
|
|
|
|
return [[SpectrumViewSK alloc] initWithFrame:frame];
|
|
}
|
|
|
|
@synthesize isListening;
|
|
|
|
- (id)initWithFrame:(NSRect)frame {
|
|
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
|
|
|
|
if(!device) return nil;
|
|
|
|
NSDictionary *sceneOptions = @{
|
|
SCNPreferredRenderingAPIKey: @(SCNRenderingAPIMetal),
|
|
SCNPreferredDeviceKey: device,
|
|
SCNPreferLowPowerDeviceKey: @(NO)
|
|
};
|
|
|
|
self = [super initWithFrame:frame options:sceneOptions];
|
|
if(self) {
|
|
[self setup];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)updateVisListening {
|
|
if(self.isListening && (![self visibleInWindow] || isOccluded || paused || stopped)) {
|
|
[self stopTimer];
|
|
self.isListening = NO;
|
|
} else if(!self.isListening && ([self visibleInWindow] && !isOccluded && !stopped && !paused)) {
|
|
[self startTimer];
|
|
self.isListening = YES;
|
|
}
|
|
}
|
|
|
|
- (void)setOccluded:(BOOL)occluded {
|
|
isOccluded = occluded;
|
|
[self updateVisListening];
|
|
}
|
|
|
|
- (void)windowChangedOcclusionState:(NSNotification *)notification {
|
|
if([notification object] == self.window) {
|
|
BOOL curOccluded = !self.window;
|
|
if(!curOccluded) {
|
|
curOccluded = !(self.window.occlusionState & NSWindowOcclusionStateVisible);
|
|
}
|
|
if(curOccluded != isOccluded) {
|
|
[self setOccluded:curOccluded];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
ofObject:(id)object
|
|
change:(NSDictionary<NSKeyValueChangeKey, id> *)change
|
|
context:(void *)context {
|
|
if(context == kSpectrumViewSKContext) {
|
|
if([keyPath isEqualToString:@"self.window.visible"]) {
|
|
[self updateVisListening];
|
|
} else {
|
|
[self updateControls];
|
|
}
|
|
} else {
|
|
[super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
|
|
}
|
|
}
|
|
|
|
- (void)updateControls {
|
|
BOOL projectionMode = cameraControlEnabled ? NO : [[NSUserDefaults standardUserDefaults] boolForKey:@"spectrumProjectionMode"];
|
|
SCNNode *rootNode = [[self scene] rootNode];
|
|
SCNNode *cameraNode = [rootNode childNodeWithName:@"camera" recursively:NO];
|
|
SCNCamera *camera = [cameraNode camera];
|
|
if (projectionMode) {
|
|
cameraNode.eulerAngles = cameraEulerAngles2d;
|
|
cameraNode.position = cameraPosition2d;
|
|
camera.usesOrthographicProjection = YES;
|
|
camera.orthographicScale = 0.6;
|
|
} else {
|
|
cameraNode.eulerAngles = cameraEulerAngles3d;
|
|
cameraNode.position = cameraPosition3d;
|
|
camera.usesOrthographicProjection = NO;
|
|
camera.orthographicScale = 1.0;
|
|
}
|
|
|
|
NSValueTransformer *colorToValueTransformer = [NSValueTransformer valueTransformerForName:@"ColorToValueTransformer"];
|
|
|
|
NSColor *barColor = [colorToValueTransformer transformedValue:[[NSUserDefaults standardUserDefaults] dataForKey:@"spectrumBarColor"]];
|
|
NSColor *dotColor = [colorToValueTransformer transformedValue:[[NSUserDefaults standardUserDefaults] dataForKey:@"spectrumDotColor"]];
|
|
|
|
{
|
|
SCNNode *barNode = [rootNode childNodeWithName:@"cylinder0" recursively:NO];
|
|
SCNGeometry *geometry = [barNode geometry];
|
|
NSArray<SCNMaterial *> *materials = [geometry materials];
|
|
SCNMaterial *material = materials[0];
|
|
material.diffuse.contents = barColor;
|
|
material.emission.contents = barColor;
|
|
}
|
|
|
|
{
|
|
SCNNode *dotNode = [rootNode childNodeWithName:@"sphere0" recursively:NO];
|
|
SCNGeometry *geometry = [dotNode geometry];
|
|
NSArray<SCNMaterial *> *materials = [geometry materials];
|
|
SCNMaterial *material = materials[0];
|
|
material.diffuse.contents = dotColor;
|
|
material.emission.contents = dotColor;
|
|
}
|
|
}
|
|
|
|
- (void)enableCameraControl {
|
|
[self setAllowsCameraControl:YES];
|
|
cameraControlEnabled = YES;
|
|
[self updateControls];
|
|
}
|
|
|
|
- (void)setup {
|
|
visController = [NSClassFromString(@"VisualizationController") sharedController];
|
|
timer = nil;
|
|
stopped = YES;
|
|
paused = NO;
|
|
isListening = NO;
|
|
cameraControlEnabled = NO;
|
|
|
|
[self setBackgroundColor:[NSColor clearColor]];
|
|
|
|
SCNScene *theScene = [SCNScene sceneNamed:@"Scenes.scnassets/Spectrum.scn"];
|
|
[self setScene:theScene];
|
|
|
|
[self setAntialiasingMode:SCNAntialiasingModeMultisampling8X];
|
|
|
|
SCNNode *rootNode = [[self scene] rootNode];
|
|
SCNNode *cameraNode = [rootNode childNodeWithName:@"camera" recursively:NO];
|
|
cameraPosition2d = SCNVector3Make(0.0, 0.5, 1.0);
|
|
cameraEulerAngles2d = SCNVector3Zero;
|
|
// Save initial camera position from SceneKit file.
|
|
cameraPosition3d = cameraNode.position;
|
|
cameraEulerAngles3d = cameraNode.eulerAngles;
|
|
[self updateControls];
|
|
|
|
bandsReset = NO;
|
|
[self drawBaseBands];
|
|
|
|
//[self colorsDidChange:nil];
|
|
|
|
BOOL freqMode = [[NSUserDefaults standardUserDefaults] boolForKey:@"spectrumFreqMode"];
|
|
|
|
ddb_analyzer_init(&_analyzer);
|
|
_analyzer.db_lower_bound = LOWER_BOUND;
|
|
_analyzer.min_freq = 10;
|
|
_analyzer.max_freq = 22000;
|
|
_analyzer.peak_hold = 10;
|
|
_analyzer.view_width = 1000;
|
|
_analyzer.fractional_bars = 1;
|
|
_analyzer.octave_bars_step = 2;
|
|
_analyzer.max_of_stereo_data = 1;
|
|
_analyzer.freq_is_log = 0;
|
|
_analyzer.mode = freqMode ? DDB_ANALYZER_MODE_FREQUENCIES : DDB_ANALYZER_MODE_OCTAVE_NOTE_BANDS;
|
|
|
|
[self addObservers];
|
|
}
|
|
|
|
- (void)addObservers {
|
|
if(!observersAdded) {
|
|
NSUserDefaultsController *sharedUserDefaultsController = [NSUserDefaultsController sharedUserDefaultsController];
|
|
[sharedUserDefaultsController addObserver:self forKeyPath:@"values.spectrumProjectionMode" options:0 context:kSpectrumViewSKContext];
|
|
[sharedUserDefaultsController addObserver:self forKeyPath:@"values.spectrumBarColor" options:0 context:kSpectrumViewSKContext];
|
|
[sharedUserDefaultsController addObserver:self forKeyPath:@"values.spectrumDotColor" options:0 context:kSpectrumViewSKContext];
|
|
|
|
[self addObserver:self forKeyPath:@"self.window.visible" options:0 context:kSpectrumViewSKContext];
|
|
|
|
NSNotificationCenter *defaultCenter = [NSNotificationCenter defaultCenter];
|
|
[defaultCenter addObserver:self
|
|
selector:@selector(playbackDidBegin:)
|
|
name:CogPlaybackDidBeginNotficiation
|
|
object:nil];
|
|
[defaultCenter addObserver:self
|
|
selector:@selector(playbackDidPause:)
|
|
name:CogPlaybackDidPauseNotficiation
|
|
object:nil];
|
|
[defaultCenter addObserver:self
|
|
selector:@selector(playbackDidResume:)
|
|
name:CogPlaybackDidResumeNotficiation
|
|
object:nil];
|
|
[defaultCenter addObserver:self
|
|
selector:@selector(playbackDidStop:)
|
|
name:CogPlaybackDidStopNotficiation
|
|
object:nil];
|
|
|
|
[defaultCenter addObserver:self
|
|
selector:@selector(windowChangedOcclusionState:)
|
|
name:NSWindowDidChangeOcclusionStateNotification
|
|
object:nil];
|
|
|
|
observersAdded = YES;
|
|
}
|
|
}
|
|
|
|
- (void)dealloc {
|
|
ddb_analyzer_dealloc(&_analyzer);
|
|
ddb_analyzer_draw_data_dealloc(&_draw_data);
|
|
|
|
[self removeObservers];
|
|
}
|
|
|
|
- (void)removeObservers {
|
|
if(observersAdded) {
|
|
NSUserDefaultsController *sharedUserDefaultsController = [NSUserDefaultsController sharedUserDefaultsController];
|
|
[sharedUserDefaultsController removeObserver:self forKeyPath:@"values.spectrumProjectionMode" context:kSpectrumViewSKContext];
|
|
[sharedUserDefaultsController removeObserver:self forKeyPath:@"values.spectrumBarColor" context:kSpectrumViewSKContext];
|
|
[sharedUserDefaultsController removeObserver:self forKeyPath:@"values.spectrumDotColor" context:kSpectrumViewSKContext];
|
|
|
|
[self removeObserver:self forKeyPath:@"self.window.visible" context:kSpectrumViewSKContext];
|
|
|
|
NSNotificationCenter *defaultCenter = [NSNotificationCenter defaultCenter];
|
|
[defaultCenter removeObserver:self
|
|
name:CogPlaybackDidBeginNotficiation
|
|
object:nil];
|
|
[defaultCenter removeObserver:self
|
|
name:CogPlaybackDidPauseNotficiation
|
|
object:nil];
|
|
[defaultCenter removeObserver:self
|
|
name:CogPlaybackDidResumeNotficiation
|
|
object:nil];
|
|
[defaultCenter removeObserver:self
|
|
name:CogPlaybackDidStopNotficiation
|
|
object:nil];
|
|
|
|
[defaultCenter removeObserver:self
|
|
name:NSWindowDidChangeOcclusionStateNotification
|
|
object:nil];
|
|
|
|
observersAdded = NO;
|
|
}
|
|
}
|
|
|
|
- (void)repaint {
|
|
[self updateVisListening];
|
|
|
|
if(stopped) {
|
|
[self drawBaseBands];
|
|
return;
|
|
}
|
|
|
|
[self->visController copyVisPCM:&visAudio[0] visFFT:&visFFT[0] latencyOffset:0];
|
|
|
|
ddb_analyzer_process(&_analyzer, [self->visController readSampleRate] / 2.0, 1, visFFT, 2048);
|
|
ddb_analyzer_tick(&_analyzer);
|
|
ddb_analyzer_get_draw_data(&_analyzer, 11.0, 1.0, &_draw_data);
|
|
|
|
[self drawAnalyzer];
|
|
}
|
|
|
|
- (void)startTimer {
|
|
[self stopTimer];
|
|
timer = [NSTimer timerWithTimeInterval:1.0 / 60.0
|
|
target:self
|
|
selector:@selector(timerRun:)
|
|
userInfo:nil
|
|
repeats:YES];
|
|
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
|
|
}
|
|
|
|
- (void)stopTimer {
|
|
[timer invalidate];
|
|
timer = nil;
|
|
}
|
|
|
|
- (void)timerRun:(NSTimer *)timer {
|
|
[self repaint];
|
|
}
|
|
|
|
- (void)startPlayback {
|
|
[self playbackDidBegin:nil];
|
|
}
|
|
|
|
- (void)playbackDidBegin:(NSNotification *)notification {
|
|
stopped = NO;
|
|
paused = NO;
|
|
[self updateVisListening];
|
|
}
|
|
|
|
- (void)playbackDidPause:(NSNotification *)notification {
|
|
stopped = NO;
|
|
paused = YES;
|
|
[self updateVisListening];
|
|
}
|
|
|
|
- (void)playbackDidResume:(NSNotification *)notification {
|
|
stopped = NO;
|
|
paused = NO;
|
|
[self updateVisListening];
|
|
}
|
|
|
|
- (void)playbackDidStop:(NSNotification *)notification {
|
|
stopped = YES;
|
|
paused = NO;
|
|
bandsReset = NO;
|
|
[self updateVisListening];
|
|
[self repaint];
|
|
}
|
|
|
|
- (void)drawBaseBands {
|
|
if(bandsReset) return;
|
|
|
|
SCNScene *scene = [self scene];
|
|
SCNNode *rootNode = [scene rootNode];
|
|
NSArray<SCNNode *> *nodes = [rootNode childNodes];
|
|
|
|
for(int i = 0; i < 11; ++i) {
|
|
SCNNode *node = nodes[i + 1];
|
|
SCNNode *dotNode = nodes[i + 1 + 11];
|
|
SCNVector3 position = node.position;
|
|
position.y = 0.0;
|
|
node.scale = SCNVector3Make(1.0, 0.0, 1.0);
|
|
node.position = position;
|
|
|
|
position = dotNode.position;
|
|
position.y = 0.072;
|
|
dotNode.position = position;
|
|
}
|
|
|
|
bandsReset = YES;
|
|
}
|
|
|
|
- (void)drawAnalyzerOctaveBands {
|
|
const int maxBars = (int)(ceilf((float)(_draw_data.bar_count) / 11.0));
|
|
const int barStep = (int)(floorf((float)(_draw_data.bar_count) / 11.0));
|
|
|
|
ddb_analyzer_draw_bar_t *bar = _draw_data.bars;
|
|
|
|
SCNScene *scene = [self scene];
|
|
SCNNode *rootNode = [scene rootNode];
|
|
NSArray<SCNNode *> *nodes = [rootNode childNodes];
|
|
|
|
for(int i = 0; i < 11; ++i) {
|
|
float maxValue = 0.0;
|
|
float maxMax = 0.0;
|
|
for(int j = 0; j < maxBars; ++j) {
|
|
const int barBase = i * barStep;
|
|
const int barIndex = barBase + j;
|
|
if(barIndex < _draw_data.bar_count) {
|
|
if(bar[barIndex].bar_height > maxValue) {
|
|
maxValue = bar[barIndex].bar_height;
|
|
}
|
|
if(bar[barIndex].peak_ypos > maxMax) {
|
|
maxMax = bar[barIndex].peak_ypos;
|
|
}
|
|
}
|
|
}
|
|
SCNNode *node = nodes[i + 1];
|
|
SCNNode *dotNode = nodes[i + 1 + 11];
|
|
SCNVector3 position = node.position;
|
|
position.y = maxValue * 0.5;
|
|
node.scale = SCNVector3Make(1.0, maxValue, 1.0);
|
|
node.position = position;
|
|
|
|
position = dotNode.position;
|
|
position.y = maxMax + 0.072;
|
|
dotNode.position = position;
|
|
}
|
|
|
|
bandsReset = NO;
|
|
}
|
|
|
|
- (void)drawAnalyzer {
|
|
[self drawAnalyzerOctaveBands];
|
|
}
|
|
|
|
- (void)mouseDown:(NSEvent *)event {
|
|
if(cameraControlEnabled) return;
|
|
|
|
BOOL freqMode = ![[NSUserDefaults standardUserDefaults] boolForKey:@"spectrumFreqMode"];
|
|
[[NSUserDefaults standardUserDefaults] setBool:freqMode forKey:@"spectrumFreqMode"];
|
|
|
|
_analyzer.mode = freqMode ? DDB_ANALYZER_MODE_FREQUENCIES : DDB_ANALYZER_MODE_OCTAVE_NOTE_BANDS;
|
|
_analyzer.mode_did_change = 1;
|
|
|
|
[self repaint];
|
|
}
|
|
|
|
@end
|