468 lines
19 KiB
Plaintext
468 lines
19 KiB
Plaintext
//
|
|
// Copyright 2013 Pixar
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "Apache License")
|
|
// with the following modification; you may not use this file except in
|
|
// compliance with the Apache License and the following modification to it:
|
|
// Section 6. Trademarks. is deleted and replaced with:
|
|
//
|
|
// 6. Trademarks. This License does not grant permission to use the trade
|
|
// names, trademarks, service marks, or product names of the Licensor
|
|
// and its affiliates, except as required to comply with Section 4(c) of
|
|
// the License and to reproduce the content of the NOTICE file.
|
|
//
|
|
// You may obtain a copy of the Apache License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the Apache License with the above modification is
|
|
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the Apache License for the specific
|
|
// language governing permissions and limitations under the Apache License.
|
|
//
|
|
|
|
#import "ViewController.h"
|
|
|
|
|
|
enum {
|
|
kHUD_RB_COLOR,
|
|
kHUD_RB_SCHEME,
|
|
kHUD_RB_LEVEL,
|
|
kHUD_RB_DISPLACEMENT,
|
|
kHUD_RB_NORMAL
|
|
};
|
|
|
|
enum {
|
|
kHUD_SL_MIPMAPBIAS,
|
|
kHUD_SL_DISPLACEMENT,
|
|
};
|
|
|
|
enum {
|
|
kHUD_CB_DISPLAY_OCCLUSION,
|
|
kHUD_CB_DISPLAY_SPECULAR,
|
|
kHUD_CB_ANIMATE_VERTICES,
|
|
kHUD_CB_VIEW_LOD,
|
|
kHUD_CB_FRACTIONAL_SPACING,
|
|
kHUD_CB_PATCH_CULL,
|
|
kHUD_CB_FREEZE,
|
|
kHUD_CB_ADAPTIVE,
|
|
kHUD_CB_SEAMLESS_MIPMAP,
|
|
};
|
|
|
|
@implementation OSDView {
|
|
bool _mouseDown;
|
|
NSPoint _lastMouse;
|
|
}
|
|
|
|
-(void)mouseDown:(NSEvent *)event {
|
|
if(event.buttonNumber == 0) {
|
|
_lastMouse = [event locationInWindow];
|
|
_mouseDown = !hud.MouseClick(_lastMouse.x, (self.bounds.size.height - _lastMouse.y));
|
|
}
|
|
[super mouseDown:event];
|
|
}
|
|
|
|
-(void)mouseUp:(NSEvent *)event {
|
|
if(event.buttonNumber == 0) {
|
|
_mouseDown = false;
|
|
_lastMouse = [event locationInWindow];
|
|
hud.MouseRelease();
|
|
}
|
|
[super mouseUp:event];
|
|
}
|
|
|
|
-(void)mouseDragged:(NSEvent *)event {
|
|
auto mouse = [NSEvent mouseLocation];
|
|
hud.MouseMotion(mouse.x, mouse.y);
|
|
|
|
if(_mouseDown) {
|
|
CGPoint delta;
|
|
delta.x = mouse.x - _lastMouse.x;
|
|
delta.y = mouse.y - _lastMouse.y;
|
|
_lastMouse = mouse;
|
|
|
|
_controller.osdRenderer.camera->rotationX += delta.x / 2.0;
|
|
_controller.osdRenderer.camera->rotationY -= delta.y / 2.0;
|
|
}
|
|
[super mouseDragged:event];
|
|
}
|
|
|
|
-(void)keyDown:(NSEvent *)event {
|
|
const auto key = [event.charactersIgnoringModifiers characterAtIndex:0];
|
|
if (hud.KeyDown(key)) {
|
|
return;
|
|
} else if(key == '=') {
|
|
_controller.osdRenderer.tessellationLevel = std::min(_controller.osdRenderer.tessellationLevel + 1, 16);
|
|
} else if (key == '-') {
|
|
_controller.osdRenderer.tessellationLevel = std::max(_controller.osdRenderer.tessellationLevel - 1, 0);
|
|
} else if (key == 'f') {
|
|
[_controller.osdRenderer fitFrame];
|
|
} else {
|
|
[super keyDown:event];
|
|
}
|
|
}
|
|
|
|
-(void)scrollWheel:(NSEvent *)event {
|
|
_controller.osdRenderer.camera->dollyDistance += event.deltaY / 100.0;
|
|
}
|
|
|
|
-(BOOL)acceptsFirstResponder {
|
|
return true;
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
|
|
|
|
#define FRAME_HISTORY 30
|
|
@implementation ViewController {
|
|
id<MTLDevice> _device;
|
|
id<MTLCommandQueue> _commandQueue;
|
|
dispatch_semaphore_t _frameSemaphore;
|
|
OSDRenderer* _osdRenderer;
|
|
|
|
unsigned _currentFrame;
|
|
double _frameBeginTimestamp[FRAME_HISTORY];
|
|
|
|
NSMagnificationGestureRecognizer* _magnificationGesture;
|
|
}
|
|
|
|
-(void)viewDidLoad {
|
|
|
|
_device = MTLCreateSystemDefaultDevice();
|
|
_commandQueue = [_device newCommandQueue];
|
|
|
|
_osdRenderer = [[OSDRenderer alloc] initWithDelegate:self];
|
|
|
|
_frameSemaphore = dispatch_semaphore_create(3);
|
|
|
|
self.view.device = _device;
|
|
self.view.delegate = self;
|
|
self.view.depthStencilPixelFormat = MTLPixelFormatDepth32Float;
|
|
self.view.clearColor = MTLClearColorMake(0.4245, 0.4167, 0.4245, 1);
|
|
self.view.controller = self;
|
|
self.view.sampleCount = 2;
|
|
|
|
|
|
_osdRenderer.camera->aspectRatio = self.view.bounds.size.width / self.view.bounds.size.height;
|
|
|
|
_currentFrame = 0;
|
|
|
|
auto renderPipelineDescriptor = [MTLRenderPipelineDescriptor new];
|
|
renderPipelineDescriptor.colorAttachments[0].pixelFormat = self.view.colorPixelFormat;
|
|
renderPipelineDescriptor.depthAttachmentPixelFormat = self.view.depthStencilPixelFormat;
|
|
renderPipelineDescriptor.sampleCount = self.view.sampleCount;
|
|
|
|
auto depthStencilDescriptor = [MTLDepthStencilDescriptor new];
|
|
depthStencilDescriptor.depthWriteEnabled = false;
|
|
depthStencilDescriptor.depthCompareFunction = MTLCompareFunctionAlways;
|
|
|
|
auto& hud = self.view->hud;
|
|
hud.Init(_device, renderPipelineDescriptor, depthStencilDescriptor, self.view.bounds.size.width, self.view.bounds.size.height, self.view.drawableSize.width, self.view.drawableSize.height);
|
|
|
|
|
|
auto callbackCheckbox = [=](bool checked, int ID) {
|
|
switch(ID) {
|
|
case kHUD_CB_FREEZE:
|
|
self.osdRenderer.freeze = checked;
|
|
break;
|
|
case kHUD_CB_ADAPTIVE:
|
|
self.osdRenderer.useAdaptive = checked;
|
|
break;
|
|
case kHUD_CB_VIEW_LOD:
|
|
self.osdRenderer.useScreenspaceTessellation = checked;
|
|
break;
|
|
case kHUD_CB_PATCH_CULL:
|
|
self.osdRenderer.usePatchClipCulling = checked;
|
|
break;
|
|
case kHUD_CB_ANIMATE_VERTICES:
|
|
self.osdRenderer.animateVertices = checked;
|
|
break;
|
|
case kHUD_CB_DISPLAY_SPECULAR:
|
|
self.osdRenderer.displaySpecular = checked;
|
|
break;
|
|
case kHUD_CB_DISPLAY_OCCLUSION:
|
|
self.osdRenderer.displayOcclusion = checked;
|
|
break;
|
|
case kHUD_CB_FRACTIONAL_SPACING:
|
|
self.osdRenderer.useFractionalTessellation = checked;
|
|
break;
|
|
case kHUD_CB_SEAMLESS_MIPMAP:
|
|
self.osdRenderer.useSeamlessMipmap = checked;
|
|
break;
|
|
default:
|
|
assert("Unknown checkbox ID" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackScheme = [=](int scheme) {
|
|
return;
|
|
};
|
|
|
|
auto callbackLevel = [=](int level) {
|
|
self.osdRenderer.refinementLevel = level;
|
|
};
|
|
|
|
auto callbackKernel = [=](int kernelType) {
|
|
switch((KernelType)kernelType) {
|
|
case kCPU:
|
|
case kMetal:
|
|
self.osdRenderer.kernelType = (KernelType)(kernelType);
|
|
break;
|
|
default:
|
|
assert("Unknown kernelType" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackDisplayStyle = [=](int displayStyle) {
|
|
switch((DisplayStyle)displayStyle) {
|
|
case kDisplayStyleWire:
|
|
case kDisplayStyleShaded:
|
|
case kDisplayStyleWireOnShaded:
|
|
self.osdRenderer.displayStyle = (DisplayStyle)displayStyle;
|
|
break;
|
|
default:
|
|
assert("Unknown displayStyle" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackColor = [=](int colorMode) {
|
|
switch((ColorMode)colorMode) {
|
|
case kColorModeNone:
|
|
case kColorModeNormal:
|
|
case kColorModePatchType:
|
|
case kColorModePatchCoord:
|
|
case kColorModePtexNearest:
|
|
case kColorModePtexBilinear:
|
|
case kColorModePtexHWBilinear:
|
|
case kColorModePtexBiQuadratic:
|
|
self.osdRenderer.colorMode = (ColorMode)colorMode;
|
|
break;
|
|
default:
|
|
assert("Unknown colorMode" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackDisplacement = [=](int displacementMode) {
|
|
switch((DisplacementMode)displacementMode) {
|
|
case kDisplacementModeNone:
|
|
case kDisplacementModeBilinear:
|
|
case kDisplacementModeHWBilinear:
|
|
case kDisplacementModeBiQuadratic:
|
|
self.osdRenderer.displacementMode = (DisplacementMode)displacementMode;
|
|
break;
|
|
default:
|
|
assert("Unknown displacementMode" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackNormal = [=](int normalMode) {
|
|
switch((NormalMode)normalMode) {
|
|
case kNormalModeBiQuadraticWG:
|
|
case kNormalModeBiQuadratic:
|
|
case kNormalModeScreenspace:
|
|
case kNormalModeHWScreenspace:
|
|
case kNormalModeSurface:
|
|
self.osdRenderer.normalMode = (NormalMode)normalMode;
|
|
break;
|
|
default:
|
|
assert("Unknown normalMode" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackSlider = [=](float sliderValue, int sliderID) {
|
|
switch(sliderID) {
|
|
case kHUD_SL_DISPLACEMENT:
|
|
self.osdRenderer.displacementScale = sliderValue;
|
|
break;
|
|
case kHUD_SL_MIPMAPBIAS:
|
|
self.osdRenderer.mipmapBias = sliderValue;
|
|
break;
|
|
default:
|
|
assert("Unknown slider ID" && 0);
|
|
}
|
|
};
|
|
|
|
if (_osdRenderer.ptexOcclusionFilename != NULL) {
|
|
hud.AddCheckBox("Ambient Occlusion (A)", _osdRenderer.ptexOcclusionFilename,
|
|
-200, 570, callbackCheckbox, kHUD_CB_DISPLAY_OCCLUSION, 'a');
|
|
}
|
|
if (_osdRenderer.ptexSpecularFilename != NULL)
|
|
hud.AddCheckBox("Specular (S)", _osdRenderer.ptexSpecularFilename,
|
|
-200, 590, callbackCheckbox, kHUD_CB_DISPLAY_SPECULAR, 's');
|
|
|
|
// if (_osdRenderer.ptexColorFilename || g_diffuseEnvironmentMap) {
|
|
// hud.AddCheckBox("IBL (I)", g_ibl,
|
|
// -200, 610, callbackCheckbox, HUD_CB_IBL, 'i');
|
|
// }
|
|
|
|
hud.AddCheckBox("Animate vertices (M)", _osdRenderer.animateVertices,
|
|
10, 30, callbackCheckbox, kHUD_CB_ANIMATE_VERTICES, 'm');
|
|
hud.AddCheckBox("Screen space LOD (V)", _osdRenderer.useScreenspaceTessellation,
|
|
10, 50, callbackCheckbox, kHUD_CB_VIEW_LOD, 'v');
|
|
hud.AddCheckBox("Fractional spacing (T)", _osdRenderer.useFractionalTessellation,
|
|
10, 70, callbackCheckbox, kHUD_CB_FRACTIONAL_SPACING, 't');
|
|
hud.AddCheckBox("Frustum Patch Culling (B)", _osdRenderer.usePatchClipCulling,
|
|
10, 90, callbackCheckbox, kHUD_CB_PATCH_CULL, 'b');
|
|
hud.AddCheckBox("Freeze (spc)", _osdRenderer.freeze,
|
|
10, 110, callbackCheckbox, kHUD_CB_FREEZE, ' ');
|
|
// hud.AddCheckBox("Bloom (Y)", g_bloom,
|
|
// 10, 130, callbackCheckbox, HUD_CB_BLOOM, 'y');
|
|
|
|
hud.AddRadioButton(kHUD_RB_SCHEME, "CATMARK", true, 10, 190, callbackScheme, 0);
|
|
|
|
// Ptex without Adaptive is not supported
|
|
// hud.AddCheckBox("Adaptive (`)", _osdRenderer.useAdaptive,
|
|
// 10, 300, callbackCheckbox, kHUD_CB_ADAPTIVE, '`');
|
|
|
|
for (int i = 1; i < 8; ++i) {
|
|
char level[16];
|
|
sprintf(level, "Lv. %d", i);
|
|
hud.AddRadioButton(kHUD_RB_LEVEL, level, _osdRenderer.refinementLevel == i,
|
|
10, 320+i*20, callbackLevel, i, '0'+i);
|
|
}
|
|
|
|
int compute_pulldown = hud.AddPullDown("Compute (K)", 475, 10, 300, callbackKernel, 'k');
|
|
hud.AddPullDownButton(compute_pulldown, "CPU", kCPU);
|
|
hud.AddPullDownButton(compute_pulldown, "Metal", kMetal);
|
|
|
|
int shading_pulldown = hud.AddPullDown("Shading (W)", 250, 10, 250, callbackDisplayStyle, 'w');
|
|
hud.AddPullDownButton(shading_pulldown, "Wire", kDisplayStyleWire, _osdRenderer.displayStyle == kDisplayStyleWire);
|
|
hud.AddPullDownButton(shading_pulldown, "Shaded", kDisplayStyleShaded, _osdRenderer.displayStyle == kDisplayStyleShaded);
|
|
hud.AddPullDownButton(shading_pulldown, "Wire+Shaded", kDisplayStyleWireOnShaded, _osdRenderer.displayStyle ==kDisplayStyleWireOnShaded);
|
|
|
|
hud.AddLabel("Color (C)", -200, 10);
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "None", (_osdRenderer.colorMode == kColorModeNone),
|
|
-200, 30, callbackColor, kColorModeNone, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Ptex Nearest", (_osdRenderer.colorMode == kColorModePtexNearest),
|
|
-200, 50, callbackColor, kColorModePtexNearest, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Ptex HW bilinear", (_osdRenderer.colorMode == kColorModePtexHWBilinear),
|
|
-200, 70, callbackColor, kColorModePtexHWBilinear, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Ptex bilinear", (_osdRenderer.colorMode == kColorModePtexBilinear),
|
|
-200, 90, callbackColor, kColorModePtexBilinear, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Ptex biquadratic", (_osdRenderer.colorMode == kColorModePtexBiQuadratic),
|
|
-200, 110, callbackColor, kColorModePtexBiQuadratic, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Patch type", (_osdRenderer.colorMode == kColorModePatchType),
|
|
-200, 130, callbackColor, kColorModePatchType, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Patch coord", (_osdRenderer.colorMode == kColorModePatchCoord),
|
|
-200, 150, callbackColor, kColorModePatchCoord, 'c');
|
|
hud.AddRadioButton(kHUD_RB_COLOR, "Normal", (_osdRenderer.colorMode == kColorModeNormal),
|
|
-200, 170, callbackColor, kColorModeNormal, 'c');
|
|
|
|
if (_osdRenderer.ptexDisplacementFilename) {
|
|
hud.AddLabel("Displacement (D)", -200, 200);
|
|
hud.AddRadioButton(kHUD_RB_DISPLACEMENT, "None",
|
|
(_osdRenderer.displacementMode == kDisplacementModeNone),
|
|
-200, 220, callbackDisplacement, kDisplacementModeNone, 'd');
|
|
hud.AddRadioButton(kHUD_RB_DISPLACEMENT, "HW bilinear",
|
|
(_osdRenderer.displacementMode == kDisplacementModeHWBilinear),
|
|
-200, 240, callbackDisplacement, kDisplacementModeHWBilinear, 'd');
|
|
hud.AddRadioButton(kHUD_RB_DISPLACEMENT, "Bilinear",
|
|
(_osdRenderer.displacementMode == kDisplacementModeBilinear),
|
|
-200, 260, callbackDisplacement, kDisplacementModeBilinear, 'd');
|
|
hud.AddRadioButton(kHUD_RB_DISPLACEMENT, "Biquadratic",
|
|
(_osdRenderer.displacementMode == kDisplacementModeBiQuadratic),
|
|
-200, 280, callbackDisplacement, kDisplacementModeBiQuadratic, 'd');
|
|
|
|
{
|
|
int y = 310;
|
|
hud.AddLabel("Normal (N)", -200, y); y += 20;
|
|
hud.AddRadioButton(kHUD_RB_NORMAL, "Surface",
|
|
(_osdRenderer.normalMode == kNormalModeSurface),
|
|
-200, y, callbackNormal, kNormalModeSurface, 'n'); y += 20;
|
|
// hud.AddRadioButton(kHUD_RB_NORMAL, "Facet", //We can't really do NORMAL_FACET
|
|
// (_osdRenderer.normalMode == NORMAL_FACET),
|
|
// -200, y, callbackNormal, NORMAL_FACET, 'n'); y += 20;
|
|
hud.AddRadioButton(kHUD_RB_NORMAL, "HW Screen space",
|
|
(_osdRenderer.normalMode == kNormalModeHWScreenspace),
|
|
-200, y, callbackNormal, kNormalModeHWScreenspace, 'n'); y += 20;
|
|
hud.AddRadioButton(kHUD_RB_NORMAL, "Screen space",
|
|
(_osdRenderer.normalMode == kNormalModeScreenspace),
|
|
-200, y, callbackNormal, kNormalModeScreenspace, 'n'); y += 20;
|
|
hud.AddRadioButton(kHUD_RB_NORMAL, "Biquadratic",
|
|
(_osdRenderer.normalMode == kNormalModeBiQuadratic),
|
|
-200, y, callbackNormal, kNormalModeBiQuadratic, 'n'); y += 20;
|
|
hud.AddRadioButton(kHUD_RB_NORMAL, "Biquadratic WG",
|
|
(_osdRenderer.normalMode == kNormalModeBiQuadraticWG),
|
|
-200, y, callbackNormal, kNormalModeBiQuadraticWG, 'n'); y += 20;
|
|
}
|
|
}
|
|
|
|
hud.AddSlider("Mipmap Bias", 0, 5, 0,
|
|
-200, 450, 20, false, callbackSlider, kHUD_SL_MIPMAPBIAS);
|
|
hud.AddSlider("Displacement", 0, 5, 1,
|
|
-200, 490, 20, false, callbackSlider, kHUD_SL_DISPLACEMENT);
|
|
hud.AddCheckBox("Seamless Mipmap", _osdRenderer.useSeamlessMipmap,
|
|
-200, 530, callbackCheckbox, kHUD_CB_SEAMLESS_MIPMAP, 'j');
|
|
|
|
hud.Rebuild(self.view.bounds.size.width, self.view.bounds.size.height, self.view.drawableSize.width, self.view.drawableSize.height);
|
|
}
|
|
|
|
-(void)drawInMTKView:(MTKView *)view {
|
|
dispatch_semaphore_wait(_frameSemaphore, DISPATCH_TIME_FOREVER);
|
|
|
|
auto commandBuffer = [_commandQueue commandBuffer];
|
|
|
|
double avg = 0;
|
|
for(int i = 0; i < FRAME_HISTORY; i++)
|
|
avg += _frameBeginTimestamp[i];
|
|
avg /= FRAME_HISTORY;
|
|
|
|
auto renderEncoder = [_osdRenderer drawFrame:commandBuffer];
|
|
|
|
auto& hud = self.view->hud;
|
|
if(hud.IsVisible()) {
|
|
hud.DrawString(10, -120, "Tess level : %d", _osdRenderer.tessellationLevel);
|
|
hud.DrawString(10, -20, "FPS = %3.1f", 1.0 / avg);
|
|
|
|
//Disable Culling & Force Fill mode when drawing the UI
|
|
[renderEncoder setTriangleFillMode:MTLTriangleFillModeFill];
|
|
[renderEncoder setCullMode:MTLCullModeNone];
|
|
self.view->hud.Flush(renderEncoder);
|
|
};
|
|
|
|
[renderEncoder endEncoding];
|
|
|
|
__weak auto blockSemaphore = _frameSemaphore;
|
|
unsigned frameId = _currentFrame % FRAME_HISTORY;
|
|
auto frameBeginTime = CACurrentMediaTime();
|
|
[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull c) {
|
|
dispatch_semaphore_signal(blockSemaphore);
|
|
_frameBeginTimestamp[frameId] = CACurrentMediaTime() - frameBeginTime;
|
|
}];
|
|
|
|
[commandBuffer presentDrawable:view.currentDrawable];
|
|
[commandBuffer commit];
|
|
|
|
_currentFrame++;
|
|
}
|
|
|
|
-(void)mtkView:(MTKView *)view drawableSizeWillChange:(CGSize)size {
|
|
_osdRenderer.camera->aspectRatio = size.width / size.height;
|
|
}
|
|
|
|
-(void)setupDepthStencilState:(MTLDepthStencilDescriptor *)descriptor for:(OSDRenderer *)renderer {
|
|
|
|
}
|
|
|
|
-(void)setupRenderPipelineState:(MTLRenderPipelineDescriptor *)descriptor for:(OSDRenderer *)renderer {
|
|
descriptor.depthAttachmentPixelFormat = self.view.depthStencilPixelFormat;
|
|
descriptor.colorAttachments[0].pixelFormat = self.view.colorPixelFormat;
|
|
descriptor.sampleCount = self.view.sampleCount;
|
|
}
|
|
|
|
-(id<MTLCommandQueue>)commandQueueFor:(OSDRenderer *)renderer {
|
|
return _commandQueue;
|
|
}
|
|
|
|
-(id<MTLDevice>)deviceFor:(OSDRenderer *)renderer {
|
|
return _device;
|
|
}
|
|
|
|
-(MTLRenderPassDescriptor *)renderPassDescriptorFor:(OSDRenderer *)renderer {
|
|
return self.view.currentRenderPassDescriptor;
|
|
}
|
|
@end
|