public void Draw(MTKView view)
{
// Update
var time = clock.ElapsedMilliseconds / 1000.0f;
var viewProj = Matrix4.Mult(this.view, this.proj);
var worldViewProj = Matrix4.CreateRotationX(time) * Matrix4.CreateRotationY(time * 2) * Matrix4.CreateRotationZ(time * .7f) * viewProj;
worldViewProj = Matrix4.Transpose(worldViewProj);
int rawsize = Marshal.SizeOf <Matrix4>();
var rawdata = new byte[rawsize];
GCHandle pinnedUniforms = GCHandle.Alloc(worldViewProj, GCHandleType.Pinned);
IntPtr ptr = pinnedUniforms.AddrOfPinnedObject();
Marshal.Copy(ptr, rawdata, 0, rawsize);
pinnedUniforms.Free();
Marshal.Copy(rawdata, 0, constantBuffer.Contents + rawsize, rawsize);
// Create a new command buffer for each renderpass to the current drawable
IMTLCommandBuffer commandBuffer = commandQueue.CommandBuffer();
// Call the view's completion handler which is required by the view since it will signal its semaphore and set up the next buffer
var drawable = view.CurrentDrawable;
// Obtain a renderPassDescriptor generated from the view's drawable textures
MTLRenderPassDescriptor renderPassDescriptor = view.CurrentRenderPassDescriptor;
// If we have a valid drawable, begin the commands to render into it
if (renderPassDescriptor != null)
{
// Create a render command encoder so we can render into something
IMTLRenderCommandEncoder renderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
renderEncoder.SetDepthStencilState(depthState);
// Set context state
renderEncoder.SetRenderPipelineState(pipelineState);
renderEncoder.SetVertexBuffer(vertexBuffer, 0, 0);
renderEncoder.SetVertexBuffer(constantBuffer, (nuint)Marshal.SizeOf <Matrix4>(), 1);
renderEncoder.SetFragmentTexture(this.texture, 0);
renderEncoder.SetFragmentSamplerState(this.sampler, 0);
// Tell the render context we want to draw our primitives
renderEncoder.DrawPrimitives(MTLPrimitiveType.Triangle, 0, (nuint)vertexData.Length);
// We're done encoding commands
renderEncoder.EndEncoding();
// Schedule a present once the framebuffer is complete using the current drawable
commandBuffer.PresentDrawable(drawable);
}
// Finalize rendering here & push the command buffer to the GPU
commandBuffer.Commit();
}
public void Draw(MTKView view)
{
// Update
this.time += this.clock.ElapsedMilliseconds / 1000.0f;
if (this.time > 2)
{
this.time = 0;
clock.Restart();
this.mipmapping++;
if (this.mipmapping >= this.texture.MipmapLevelCount)
{
this.mipmapping = 0;
}
SetConstantBuffer(this.mipmapping, this.constantBuffer);
}
// Create a new command buffer for each renderpass to the current drawable
IMTLCommandBuffer commandBuffer = commandQueue.CommandBuffer();
// Call the view's completion handler which is required by the view since it will signal its semaphore and set up the next buffer
var drawable = view.CurrentDrawable;
// Obtain a renderPassDescriptor generated from the view's drawable textures
MTLRenderPassDescriptor renderPassDescriptor = view.CurrentRenderPassDescriptor;
// If we have a valid drawable, begin the commands to render into it
if (renderPassDescriptor != null)
{
// Create a render command encoder so we can render into something
IMTLRenderCommandEncoder renderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
// Set context state
renderEncoder.SetDepthStencilState(depthState);
renderEncoder.SetRenderPipelineState(pipelineState);
renderEncoder.SetVertexBuffer(vertexBuffer, 0, 0);
renderEncoder.SetFragmentBuffer(constantBuffer, (nuint)sizeof(float), 1);
renderEncoder.SetFragmentTexture(this.texture, 0);
renderEncoder.SetFragmentSamplerState(this.sampler, 0);
// Tell the render context we want to draw our primitives
renderEncoder.DrawPrimitives(MTLPrimitiveType.Triangle, 0, (uint)vertexData.Length);
// We're done encoding commands
renderEncoder.EndEncoding();
// Schedule a present once the framebuffer is complete using the current drawable
commandBuffer.PresentDrawable(drawable);
}
// Finalize rendering here & push the command buffer to the GPU
commandBuffer.Commit();
}
public void Draw(MTKView view)
{
// Update
var time = clock.ElapsedMilliseconds / 1000.0f;
var viewProj = Matrix4.Mult(this.view, this.proj);
var world = Matrix4.CreateRotationX(time) * Matrix4.CreateRotationY(time * 2) * Matrix4.CreateRotationZ(time * .7f);
var worldViewProj = world * viewProj;
var worldInverse = Matrix4.Invert(world);
param.World = Matrix4.Transpose(world);
param.WorldInverseTranspose = worldInverse;
param.WorldViewProjection = Matrix4.Transpose(worldViewProj);
SetConstantBuffer(this.param, constantBuffer);
// Create a new command buffer for each renderpass to the current drawable
IMTLCommandBuffer commandBuffer = commandQueue.CommandBuffer();
// Call the view's completion handler which is required by the view since it will signal its semaphore and set up the next buffer
var drawable = view.CurrentDrawable;
// Obtain a renderPassDescriptor generated from the view's drawable textures
MTLRenderPassDescriptor renderPassDescriptor = view.CurrentRenderPassDescriptor;
// If we have a valid drawable, begin the commands to render into it
if (renderPassDescriptor != null)
{
// Create a render command encoder so we can render into something
IMTLRenderCommandEncoder renderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
// Set context state
renderEncoder.SetDepthStencilState(depthState);
renderEncoder.SetRenderPipelineState(pipelineState);
renderEncoder.SetVertexBuffer(vertexBuffer, 0, 0);
renderEncoder.SetVertexBuffer(constantBuffer, (nuint)Marshal.SizeOf(this.param), 1);
renderEncoder.SetFragmentBuffer(constantBuffer, (nuint)Marshal.SizeOf(this.param), 1);
renderEncoder.SetFragmentTexture(this.texture, 0);
renderEncoder.SetFragmentSamplerState(this.sampler, 0);
// Tell the render context we want to draw our primitives
renderEncoder.DrawIndexedPrimitives(MTLPrimitiveType.Triangle, (uint)indexDataArray.Length, MTLIndexType.UInt16, indexBuffer, 0);
// We're done encoding commands
renderEncoder.EndEncoding();
// Schedule a present once the framebuffer is complete using the current drawable
commandBuffer.PresentDrawable(drawable);
}
// Finalize rendering here & push the command buffer to the GPU
commandBuffer.Commit();
}
public void Draw(MTKView view)
{
// Update
var time = clock.ElapsedMilliseconds / 1000.0f;
var viewProj = Matrix4.Mult(this.view, this.proj);
var worldViewProj = Matrix4.CreateRotationY(time * 2) * Matrix4.Scale(0.0015f) * viewProj;
worldViewProj = Matrix4.Transpose(worldViewProj);
this.param.WorldViewProjection = worldViewProj;
SetConstantBuffer(this.param, constantBuffer);
// Create a new command buffer for each renderpass to the current drawable
IMTLCommandBuffer commandBuffer = commandQueue.CommandBuffer();
// Call the view's completion handler which is required by the view since it will signal its semaphore and set up the next buffer
var drawable = view.CurrentDrawable;
// Obtain a renderPassDescriptor generated from the view's drawable textures
MTLRenderPassDescriptor renderPassDescriptor = view.CurrentRenderPassDescriptor;
// If we have a valid drawable, begin the commands to render into it
if (renderPassDescriptor != null)
{
// Create a render command encoder so we can render into something
IMTLRenderCommandEncoder renderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
// Set context state
renderEncoder.SetDepthStencilState(depthState);
renderEncoder.SetRenderPipelineState(pipelineState);
renderEncoder.SetVertexBuffer(objMesh.VertexBuffers[0].Buffer, objMesh.VertexBuffers[0].Offset, 0);
renderEncoder.SetVertexBuffer(constantBuffer, (nuint)Marshal.SizeOf <Matrix4>(), 1);
renderEncoder.SetFragmentTexture(this.texture, 0);
renderEncoder.SetFragmentSamplerState(this.sampler, 0);
for (int i = 0; i < objMesh.Submeshes.Length; i++)
{
MTKSubmesh submesh = objMesh.Submeshes[i];
renderEncoder.DrawIndexedPrimitives(submesh.PrimitiveType, submesh.IndexCount, submesh.IndexType, submesh.IndexBuffer.Buffer, submesh.IndexBuffer.Offset);
}
// We're done encoding commands
renderEncoder.EndEncoding();
// Schedule a present once the framebuffer is complete using the current drawable
commandBuffer.PresentDrawable(drawable);
}
// Finalize rendering here & push the command buffer to the GPU
commandBuffer.Commit();
}
private void PlatformSetPipelineLayout(PipelineLayout pipelineLayout)
{
for (var i = 0; i < pipelineLayout.Description.StaticSamplerStates.Length; i++)
{
var staticSamplerState = pipelineLayout.Description.StaticSamplerStates[i];
switch (staticSamplerState.Visibility)
{
case ShaderStageVisibility.Vertex:
_commandEncoder.SetVertexSamplerState(pipelineLayout.DeviceSamplerStates[i], (nuint)staticSamplerState.ShaderRegister);
break;
case ShaderStageVisibility.Pixel:
_commandEncoder.SetFragmentSamplerState(pipelineLayout.DeviceSamplerStates[i], (nuint)staticSamplerState.ShaderRegister);
break;
case ShaderStageVisibility.All:
_commandEncoder.SetVertexSamplerState(pipelineLayout.DeviceSamplerStates[i], (nuint)staticSamplerState.ShaderRegister);
_commandEncoder.SetFragmentSamplerState(pipelineLayout.DeviceSamplerStates[i], (nuint)staticSamplerState.ShaderRegister);
break;
}
}
}
public void Draw(MTKView view)
{
// Update
var time = clock.ElapsedMilliseconds / 1000.0f;
var viewProj = Matrix4.Mult(this.view, this.proj);
var worldViewProj = Matrix4.CreateRotationX(time) * Matrix4.CreateRotationY(time * 2) * Matrix4.CreateRotationZ(time * .7f) * viewProj;
worldViewProj = Matrix4.Transpose(worldViewProj);
this.cubeParameters.WorldViewProjection = worldViewProj;
this.SetConstantBuffer(this.cubeParameters, this.cubeConstantBuffer);
// Create a new command buffer for each renderpass to the current drawable
IMTLCommandBuffer commandBuffer = commandQueue.CommandBuffer();
// Call the view's completion handler which is required by the view since it will signal its semaphore and set up the next buffer
var drawable = view.CurrentDrawable;
// Obtain a renderPassDescriptor generated from the view's drawable textures
MTLRenderPassDescriptor renderPassDescriptor = view.CurrentRenderPassDescriptor;
renderPassDescriptor.ColorAttachments[0].Texture = this.colorFrameBufferTexture;
renderPassDescriptor.ColorAttachments[0].ClearColor = new MTLClearColor(0.5f, 0.75f, 1, 1);
// If we have a valid drawable, begin the commands to render into it
if (renderPassDescriptor != null)
{
//--------------------------------
// Draw Triangle
//--------------------------------
// Create a render command encoder so we can render into something
IMTLRenderCommandEncoder triangleRenderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
triangleRenderEncoder.SetDepthStencilState(depthStencilState);
triangleRenderEncoder.SetRenderPipelineState(trianglePipelineState);
triangleRenderEncoder.SetVertexBuffer(triangleVertexBuffer, 0, 0);
// Tell the render context we want to draw our primitives
triangleRenderEncoder.DrawPrimitives(MTLPrimitiveType.Triangle, 0, (nuint)triangleVertexData.Length);
triangleRenderEncoder.EndEncoding();
//--------------------------------
// Draw Cube
//--------------------------------
renderPassDescriptor.ColorAttachments[0].Texture = drawable.Texture;
renderPassDescriptor.ColorAttachments[0].ClearColor = mtkView.ClearColor;
IMTLRenderCommandEncoder cubeRenderEncoder = commandBuffer.CreateRenderCommandEncoder(renderPassDescriptor);
cubeRenderEncoder.SetDepthStencilState(depthStencilState);
// Set context state
cubeRenderEncoder.SetRenderPipelineState(cubePipelineState);
cubeRenderEncoder.SetVertexBuffer(cubeVertexBuffer, 0, 0);
cubeRenderEncoder.SetVertexBuffer(cubeConstantBuffer, (nuint)Marshal.SizeOf(this.cubeParameters), 1);
cubeRenderEncoder.SetFragmentTexture(this.colorFrameBufferTexture, 0);
cubeRenderEncoder.SetFragmentSamplerState(this.sampler, 0);
// Tell the render context we want to draw our primitives
cubeRenderEncoder.DrawPrimitives(MTLPrimitiveType.Triangle, 0, (nuint)cubeVertexData.Length);
// We're done encoding commands
cubeRenderEncoder.EndEncoding();
// Schedule a present once the framebuffer is complete using the current drawable
commandBuffer.PresentDrawable(drawable);
}
// Finalize rendering here & push the command buffer to the GPU
commandBuffer.Commit();
}
private void PlatformSetPixelShaderSampler(int slot, SamplerState sampler)
{
_deviceCommandEncoder.SetFragmentSamplerState(sampler.DeviceSamplerState, (nuint)slot);
}
