mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-11-30 07:10:07 +00:00
ed8ecd84d1
Updated the Metal viewer runtime options to more closely match the other viewers: - default to adaptive tessellation - default to patch type coloring - present end cap options as: Linear/Regular/Gregory - exposed switches for patch refinement options: smooth corner, single crease, inf sharp - updated fvar linear interpolation labels and methods to match glFVarViewer - updated iOS Main.storyboard GUI to match
506 lines
21 KiB
Plaintext
506 lines
21 KiB
Plaintext
//
|
|
// Copyright 2015 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"
|
|
#import <opensubdiv/far/patchDescriptor.h>
|
|
|
|
using namespace OpenSubdiv::OPENSUBDIV_VERSION;
|
|
|
|
enum {
|
|
kHUD_CB_DISPLAY_CONTROL_MESH_EDGES,
|
|
kHUD_CB_DISPLAY_CONTROL_MESH_VERTS,
|
|
kHUD_CB_ANIMATE_VERTICES,
|
|
kHUD_CB_DISPLAY_PATCH_COLOR, //Unused
|
|
kHUD_CB_DISPLAY_PATCH_CVs, //Unused
|
|
kHUD_CB_VIEW_LOD,
|
|
kHUD_CB_FRACTIONAL_SPACING,
|
|
kHUD_CB_PATCH_CULL,
|
|
kHUD_CB_BACK_CULL,
|
|
kHUD_CB_PATCH_INDEX_BUFFER,
|
|
kHUD_CB_FREEZE,
|
|
kHUD_CB_SMOOTH_CORNER_PATCH,
|
|
kHUD_CB_SINGLE_CREASE_PATCH,
|
|
kHUD_CB_INFINITE_SHARP_PATCH,
|
|
kHUD_CB_ADAPTIVE,
|
|
kHUD_CB_DISPLAY_PATCH_COUNTS
|
|
};
|
|
|
|
@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(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(!hud.KeyDown(key))
|
|
[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;
|
|
|
|
int _showPatchCounts;
|
|
}
|
|
|
|
-(void)viewDidLoad {
|
|
|
|
_device = MTLCreateSystemDefaultDevice();
|
|
_commandQueue = [_device newCommandQueue];
|
|
|
|
_osdRenderer = [[OSDRenderer alloc] initWithDelegate:self];
|
|
_osdRenderer.displayControlMeshEdges = false;
|
|
|
|
_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 = 1;
|
|
|
|
self.view->hud.UIScale = 1.0;
|
|
_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 value, int ID) {
|
|
switch(ID) {
|
|
case kHUD_CB_FREEZE:
|
|
self.osdRenderer.freeze = value;
|
|
break;
|
|
case kHUD_CB_VIEW_LOD:
|
|
self.osdRenderer.useScreenspaceTessellation = value;
|
|
break;
|
|
case kHUD_CB_PATCH_CULL:
|
|
self.osdRenderer.usePatchClipCulling = value;
|
|
|
|
break;
|
|
case kHUD_CB_ANIMATE_VERTICES:
|
|
self.osdRenderer.animateVertices = value;
|
|
break;
|
|
case kHUD_CB_FRACTIONAL_SPACING:
|
|
self.osdRenderer.useFractionalTessellation = value;
|
|
break;
|
|
case kHUD_CB_SMOOTH_CORNER_PATCH:
|
|
self.osdRenderer.useSmoothCornerPatch = value;
|
|
break;
|
|
case kHUD_CB_SINGLE_CREASE_PATCH:
|
|
self.osdRenderer.useSingleCreasePatch = value;
|
|
break;
|
|
case kHUD_CB_DISPLAY_CONTROL_MESH_EDGES:
|
|
self.osdRenderer.displayControlMeshEdges = value;
|
|
break;
|
|
case kHUD_CB_DISPLAY_CONTROL_MESH_VERTS:
|
|
self.osdRenderer.displayControlMeshVertices = value;
|
|
break;
|
|
case kHUD_CB_BACK_CULL:
|
|
self.osdRenderer.usePatchBackfaceCulling = value;
|
|
self.osdRenderer.usePrimitiveBackfaceCulling = value;
|
|
break;
|
|
case kHUD_CB_PATCH_INDEX_BUFFER:
|
|
self.osdRenderer.usePatchIndexBuffer = value;
|
|
break;
|
|
case kHUD_CB_ADAPTIVE:
|
|
self.osdRenderer.useAdaptive = value;
|
|
break;
|
|
case kHUD_CB_INFINITE_SHARP_PATCH:
|
|
self.osdRenderer.useInfinitelySharpPatch = value;
|
|
break;
|
|
case kHUD_CB_DISPLAY_PATCH_COUNTS:
|
|
_showPatchCounts = value;
|
|
break;
|
|
default:
|
|
assert("Unknown checkbox ID" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackKernel = [=](int kernelType) {
|
|
switch((KernelType)kernelType) {
|
|
case kCPU:
|
|
case kMetal:
|
|
self.osdRenderer.kernelType = (KernelType)(kernelType);
|
|
break;
|
|
default:
|
|
assert("Unknown kernelType" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackFVarLinearInterp = [=](int fVarLinearInterp) {
|
|
switch((FVarLinearInterp)fVarLinearInterp) {
|
|
case kFVarLinearNone:
|
|
case kFVarLinearCornersOnly:
|
|
case kFVarLinearCornersPlus1:
|
|
case kFVarLinearCornersPlus2:
|
|
case kFVarLinearBoundaries:
|
|
case kFVarLinearAll:
|
|
self.osdRenderer.fVarLinearInterp = (FVarLinearInterp)fVarLinearInterp;
|
|
}
|
|
};
|
|
|
|
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 callbackShadingMode = [=](int shadingMode) {
|
|
switch((ShadingMode)shadingMode) {
|
|
case kShadingMaterial:
|
|
case kShadingFaceVaryingColor:
|
|
case kShadingPatchType:
|
|
case kShadingPatchDepth:
|
|
case kShadingPatchCoord:
|
|
case kShadingNormal:
|
|
self.osdRenderer.shadingMode = (ShadingMode)shadingMode;
|
|
break;
|
|
default:
|
|
assert("Unknown shadingMode" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackEndCap = [=](int endCap) {
|
|
switch((EndCap)endCap) {
|
|
case kEndCapBilinearBasis:
|
|
case kEndCapBSplineBasis:
|
|
case kEndCapGregoryBasis:
|
|
case kEndCapLegacyGregory:
|
|
self.osdRenderer.endCapMode = (EndCap)endCap;
|
|
break;
|
|
default:
|
|
assert("Unknown endCap" && 0);
|
|
}
|
|
};
|
|
|
|
auto callbackLevel = [=](int level) {
|
|
self.osdRenderer.refinementLevel = level;
|
|
};
|
|
|
|
auto callbackModel = [=](int modelIndex) {
|
|
assert(modelIndex >= 0);
|
|
assert((NSUInteger)modelIndex < self.osdRenderer.loadedModels.count);
|
|
|
|
self.osdRenderer.currentModel = self.osdRenderer.loadedModels[modelIndex];
|
|
};
|
|
|
|
int y = 10;
|
|
hud.AddCheckBox("Control edges (H)",
|
|
_osdRenderer.displayControlMeshEdges,
|
|
10, y, callbackCheckbox,
|
|
kHUD_CB_DISPLAY_CONTROL_MESH_EDGES, 'h');
|
|
y += 20;
|
|
hud.AddCheckBox("Control vertices (J)",
|
|
_osdRenderer.displayControlMeshVertices,
|
|
10, y, callbackCheckbox,
|
|
kHUD_CB_DISPLAY_CONTROL_MESH_VERTS, 'j');
|
|
y += 20;
|
|
hud.AddCheckBox("Animate vertices (M)", _osdRenderer.animateVertices,
|
|
10, y, callbackCheckbox, kHUD_CB_ANIMATE_VERTICES, 'm');
|
|
y += 20;
|
|
hud.AddCheckBox("Screen space LOD (V)", _osdRenderer.useScreenspaceTessellation,
|
|
10, y, callbackCheckbox, kHUD_CB_VIEW_LOD, 'v');
|
|
y += 20;
|
|
hud.AddCheckBox("Fractional spacing (T)", _osdRenderer.useFractionalTessellation,
|
|
10, y, callbackCheckbox, kHUD_CB_FRACTIONAL_SPACING, 't');
|
|
y += 20;
|
|
hud.AddCheckBox("Frustum Patch Culling (F)", _osdRenderer.usePatchClipCulling,
|
|
10, y, callbackCheckbox, kHUD_CB_PATCH_CULL, 'f');
|
|
y += 20;
|
|
hud.AddCheckBox("Backface Culling (B)", _osdRenderer.usePatchBackfaceCulling,
|
|
10, y, callbackCheckbox, kHUD_CB_BACK_CULL, 'b');
|
|
|
|
y += 20;
|
|
hud.AddCheckBox("Patch Index Buffer (D)", _osdRenderer.usePatchIndexBuffer,
|
|
10, y, callbackCheckbox, kHUD_CB_PATCH_INDEX_BUFFER, 'd');
|
|
|
|
y += 20;
|
|
hud.AddCheckBox("Freeze (spc)", _osdRenderer.freeze,
|
|
10, y, callbackCheckbox, kHUD_CB_FREEZE, ' ');
|
|
y += 20;
|
|
|
|
int displaystyle_pulldown = hud.AddPullDown("DisplayStyle (W)", 200, 10, 250,
|
|
callbackDisplayStyle, 'w');
|
|
hud.AddPullDownButton(displaystyle_pulldown, "Wire", kDisplayStyleWire,
|
|
_osdRenderer.displayStyle == kDisplayStyleWire);
|
|
hud.AddPullDownButton(displaystyle_pulldown, "Shaded", kDisplayStyleShaded,
|
|
_osdRenderer.displayStyle == kDisplayStyleShaded);
|
|
hud.AddPullDownButton(displaystyle_pulldown, "Wire+Shaded", kDisplayStyleWireOnShaded,
|
|
_osdRenderer.displayStyle == kDisplayStyleWireOnShaded);
|
|
|
|
int shading_pulldown = hud.AddPullDown("Shading (C)", 200, 70, 250,
|
|
callbackShadingMode, 'c');
|
|
|
|
hud.AddPullDownButton(shading_pulldown, "Material",
|
|
kShadingMaterial,
|
|
_osdRenderer.shadingMode == kShadingMaterial);
|
|
hud.AddPullDownButton(shading_pulldown, "FaceVarying Color",
|
|
kShadingFaceVaryingColor,
|
|
_osdRenderer.shadingMode == kShadingFaceVaryingColor);
|
|
hud.AddPullDownButton(shading_pulldown, "Patch Type",
|
|
kShadingPatchType,
|
|
_osdRenderer.shadingMode == kShadingPatchType);
|
|
hud.AddPullDownButton(shading_pulldown, "Patch Depth",
|
|
kShadingPatchDepth,
|
|
_osdRenderer.shadingMode == kShadingPatchDepth);
|
|
hud.AddPullDownButton(shading_pulldown, "Patch Coord",
|
|
kShadingPatchCoord,
|
|
_osdRenderer.shadingMode == kShadingPatchCoord);
|
|
hud.AddPullDownButton(shading_pulldown, "Normal",
|
|
kShadingNormal,
|
|
_osdRenderer.shadingMode == kShadingNormal);
|
|
|
|
int compute_pulldown = hud.AddPullDown("Compute (K)", 475, 10, 175, callbackKernel, 'k');
|
|
hud.AddPullDownButton(compute_pulldown, "CPU", kCPU, _osdRenderer.kernelType == kCPU);
|
|
hud.AddPullDownButton(compute_pulldown, "Metal", kMetal, _osdRenderer.kernelType == kMetal);
|
|
|
|
int fVarLinearInterp_pulldown = hud.AddPullDown("FVar Linear Interpolation (L)",
|
|
650, 10, 300, callbackFVarLinearInterp, 'l');
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "None (edge only)",
|
|
kFVarLinearNone,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearNone);
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "Corners Only",
|
|
kFVarLinearCornersOnly,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearCornersOnly);
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "Corners 1 (edge corner)",
|
|
kFVarLinearCornersPlus1,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearCornersPlus1);
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "Corners 2 (edge corner prop)",
|
|
kFVarLinearCornersPlus2,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearCornersPlus2);
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "Boundaries (always sharp)",
|
|
kFVarLinearBoundaries,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearBoundaries);
|
|
hud.AddPullDownButton(fVarLinearInterp_pulldown, "All (bilinear)",
|
|
kFVarLinearAll,
|
|
_osdRenderer.fVarLinearInterp == kFVarLinearAll);
|
|
|
|
{
|
|
hud.AddCheckBox("Adaptive (`)", _osdRenderer.useAdaptive,
|
|
10, 190, callbackCheckbox, kHUD_CB_ADAPTIVE, '`');
|
|
hud.AddCheckBox("Smooth Corner Patch (O)", _osdRenderer.useSmoothCornerPatch,
|
|
10, 210, callbackCheckbox, kHUD_CB_SMOOTH_CORNER_PATCH, 'o');
|
|
hud.AddCheckBox("Single Crease Patch (S)", _osdRenderer.useSingleCreasePatch,
|
|
10, 230, callbackCheckbox, kHUD_CB_SINGLE_CREASE_PATCH, 's');
|
|
hud.AddCheckBox("Inf Sharp Patch (I)", _osdRenderer.useInfinitelySharpPatch,
|
|
10, 250, callbackCheckbox, kHUD_CB_INFINITE_SHARP_PATCH, 'i');
|
|
|
|
int endcap_pulldown = hud.AddPullDown(
|
|
"End cap (E)", 10, 270, 200, callbackEndCap, 'e');
|
|
hud.AddPullDownButton(endcap_pulldown,"Linear",
|
|
kEndCapBilinearBasis,
|
|
_osdRenderer.endCapMode == kEndCapBilinearBasis);
|
|
hud.AddPullDownButton(endcap_pulldown, "Regular",
|
|
kEndCapBSplineBasis,
|
|
_osdRenderer.endCapMode == kEndCapBSplineBasis);
|
|
hud.AddPullDownButton(endcap_pulldown, "Gregory",
|
|
kEndCapGregoryBasis,
|
|
_osdRenderer.endCapMode == kEndCapGregoryBasis);
|
|
if (true || _osdRenderer.legacyGregoryEnabled) {
|
|
hud.AddPullDownButton(endcap_pulldown, "LegacyGregory",
|
|
kEndCapLegacyGregory,
|
|
_osdRenderer.endCapMode == kEndCapLegacyGregory);
|
|
}
|
|
}
|
|
|
|
for (int i = 1; i < 11; ++i) {
|
|
char level[16];
|
|
sprintf(level, "Lv. %d", i);
|
|
hud.AddRadioButton(3, level, i==2, 10, 310+i*20, callbackLevel, i, '0'+(i%10));
|
|
}
|
|
|
|
int shapes_pulldown = hud.AddPullDown("Shape (N)", -300, 10, 300, callbackModel, 'n');
|
|
for (int i = 0; i < (int)_osdRenderer.loadedModels.count; ++i) {
|
|
hud.AddPullDownButton(shapes_pulldown, _osdRenderer.loadedModels[i].UTF8String,i);
|
|
}
|
|
|
|
hud.AddCheckBox("Show patch counts (,)", _showPatchCounts, -420, -20, callbackCheckbox, kHUD_CB_DISPLAY_PATCH_COUNTS, ',');
|
|
|
|
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()) {
|
|
if(_showPatchCounts) {
|
|
int x = -420;
|
|
int y = -180;
|
|
hud.DrawString(x, y, "Quads : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::QUADS]); y += 20;
|
|
hud.DrawString(x, y, "Triangles : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::TRIANGLES]); y += 20;
|
|
hud.DrawString(x, y, "Regular : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::REGULAR]); y+= 20;
|
|
hud.DrawString(x, y, "Loop : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::LOOP]); y+= 20;
|
|
if (_osdRenderer.legacyGregoryEnabled) {
|
|
hud.DrawString(x, y, "Gregory : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::GREGORY]); y+= 20;
|
|
hud.DrawString(x, y, "Boundary Gregory : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::GREGORY_BOUNDARY]); y+= 20;
|
|
}
|
|
hud.DrawString(x, y, "Gregory Basis : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::GREGORY_BASIS]); y+= 20;
|
|
hud.DrawString(x, y, "Gregory Triangle : %d",
|
|
_osdRenderer.patchCounts[Far::PatchDescriptor::GREGORY_TRIANGLE]); y+= 20;
|
|
}
|
|
|
|
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;
|
|
self.view->hud.Rebuild(self.view.bounds.size.width, self.view.bounds.size.height, 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
|