public void BuildStructure2()
{
var mock = new MockGLDescriptorSetLayout
{
Uniforms = new GLUniformBinding[]
{
new GLUniformBinding
{
Binding = 0,
DescriptorType = Magnesium.MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = 1,
},
new GLUniformBinding
{
Binding = 1,
DescriptorType = Magnesium.MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = 2,
},
}
};
var createInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new IMgDescriptorSetLayout[]
{
mock
},
};
var result = new GLNextPipelineLayout(createInfo);
Assert.IsNotNull(result);
Assert.AreEqual(3, result.NoOfBindingPoints);
}
void SetupDescriptorSetLayout()
{
var descriptorLayout = new MgDescriptorSetLayoutCreateInfo
{
Bindings = new[]
{
new MgDescriptorSetLayoutBinding
{
DescriptorCount = 1,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
ImmutableSamplers = null,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
Binding = 0,
}
},
};
var err = mConfiguration.Device.CreateDescriptorSetLayout(descriptorLayout, null, out mDescriptorSetLayout);
Debug.Assert(err == Result.SUCCESS);
var pPipelineLayoutCreateInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new IMgDescriptorSetLayout[]
{
mDescriptorSetLayout,
}
};
err = mConfiguration.Device.CreatePipelineLayout(pPipelineLayoutCreateInfo, null, out mPipelineLayout);
Debug.Assert(err == Result.SUCCESS);
}
public EffectLayout CreateEffectLayout(IMgDevice device)
{
var pDsCreateInfo = new MgDescriptorSetLayoutCreateInfo
{
Bindings = new[]
{
// WORLD DATA
// CAMERAS
// LIGHTS
new MgDescriptorSetLayoutBinding
{
Binding = 0,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = 1,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
},
// MATERIALS
new MgDescriptorSetLayoutBinding
{
Binding = 1,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = mSettings.NoOfMaterialsPerGroup,
StageFlags = MgShaderStageFlagBits.FRAGMENT_BIT,
},
// TEXTURES
new MgDescriptorSetLayoutBinding
{
Binding = 5,
DescriptorType = MgDescriptorType.COMBINED_IMAGE_SAMPLER,
DescriptorCount = mSettings.NoOfTexturesPerGroup,
StageFlags = MgShaderStageFlagBits.FRAGMENT_BIT,
},
}
};
var err = device.CreateDescriptorSetLayout(pDsCreateInfo, null, out IMgDescriptorSetLayout dsLayout);
if (err != Result.SUCCESS)
{
throw new InvalidOperationException("CreateDescriptorSetLayout failed");
}
var pCreateInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new[]
{
dsLayout,
}
};
err = device.CreatePipelineLayout(pCreateInfo, null, out IMgPipelineLayout layout);
if (err != Result.SUCCESS)
{
throw new InvalidOperationException("CreatePipelineLayout failed");
}
return(new EffectLayout(dsLayout, layout));
}
public AmtPipelineLayout(MgPipelineLayoutCreateInfo createInfo)
{
if (createInfo == null)
{
throw new ArgumentNullException(nameof(createInfo));
}
FragmentStage = new AmtPipelineLayoutStageResource(MgShaderStageFlagBits.FRAGMENT_BIT, createInfo);
VertexStage = new AmtPipelineLayoutStageResource(MgShaderStageFlagBits.VERTEX_BIT, createInfo);
ComputeStage = new AmtPipelineLayoutStageResource(MgShaderStageFlagBits.COMPUTE_BIT, createInfo);
}
public void BuildStructure4()
{
var mock = new MockGLDescriptorSetLayout
{
Uniforms = new GLUniformBinding[]
{
new GLUniformBinding
{
Binding = 0,
DescriptorType = Magnesium.MgDescriptorType.UNIFORM_BUFFER_DYNAMIC,
DescriptorCount = 1,
},
new GLUniformBinding
{
Binding = 1,
DescriptorType = Magnesium.MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = 2,
},
}
};
var createInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new IMgDescriptorSetLayout[]
{
mock
},
};
var result = new GLNextPipelineLayout(createInfo);
Assert.IsNotNull(result);
Assert.AreEqual(3, result.NoOfBindingPoints);
Assert.AreEqual(2, result.Ranges.Keys.Count);
{
var g1 = result.Ranges[0];
Assert.AreEqual(0, g1.Binding);
Assert.AreEqual(0, g1.First);
Assert.AreEqual(0, g1.Last);
}
{
var g1 = result.Ranges[1];
Assert.AreEqual(1, g1.Binding);
Assert.AreEqual(1, g1.First);
Assert.AreEqual(2, g1.Last);
}
}
public AmtPipelineLayoutStageResource(
MgShaderStageFlagBits mask,
MgPipelineLayoutCreateInfo createInfo)
{
var vertBuffers = new SortedList <uint, AmtPipelineLayoutBufferBinding>();
var textures = new SortedList <uint, AmtPipelineLayoutTextureBinding>();
var samplers = new SortedList <uint, AmtPipelineLayoutSamplerBinding>();
Stage = mask;
foreach (var setLayout in createInfo.SetLayouts)
{
var bSetLayout = (AmtDescriptorSetLayout)setLayout;
Initialise(mask, bSetLayout, null, vertBuffers, textures, samplers);
}
ConvertToArrays(vertBuffers, textures, samplers);
}
public GLNextPipelineLayout(MgPipelineLayoutCreateInfo pCreateInfo)
{
if (pCreateInfo.SetLayouts.Length == 1)
{
var layout = (IGLDescriptorSetLayout)pCreateInfo.SetLayouts[0];
Bindings = layout.Uniforms;
}
else
{
Bindings = new GLUniformBinding[0];
}
NoOfBindingPoints = 0U;
NoOfStorageBuffers = 0U;
NoOfExpectedDynamicOffsets = 0U;
Ranges = new SortedDictionary <uint, GLBindingPointOffsetInfo>();
OffsetDestinations = ExtractBindingsInformation();
SetupOffsetRangesByBindings();
}
public Result CreatePipelineLayout(MgPipelineLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgPipelineLayout pPipelineLayout)
{
if (pCreateInfo == null)
{
throw new ArgumentNullException("pCreateInfo");
}
if (pCreateInfo.SetLayouts == null)
{
throw new ArgumentNullException("pCreateInfo.SetLayouts");
}
if (pCreateInfo.SetLayouts.Length > 1)
{
throw new NotSupportedException("DESKTOPGL - SetLayouts must be <= 1");
}
pPipelineLayout = new GLNextPipelineLayout(pCreateInfo);
return(Result.SUCCESS);
}
void setupDescriptorSetLayout()
{
var descriptorLayout = new MgDescriptorSetLayoutCreateInfo
{
Bindings = new MgDescriptorSetLayoutBinding[]
{
// Binding 0 : Vertex shader uniform buffer
new MgDescriptorSetLayoutBinding
{
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
Binding = 0,
DescriptorCount = 1,
},
// Binding 1 : Fragment shader image sampler
new MgDescriptorSetLayoutBinding
{
DescriptorType = MgDescriptorType.COMBINED_IMAGE_SAMPLER,
StageFlags = MgShaderStageFlagBits.FRAGMENT_BIT,
Binding = 1,
DescriptorCount = 1,
},
},
};
var device = mManager.Configuration.Device;
Debug.Assert(device != null);
var err = device.CreateDescriptorSetLayout(descriptorLayout, null, out mDescriptorSetLayout);
Debug.Assert(err == Result.SUCCESS);
MgPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new [] { mDescriptorSetLayout },
};
err = device.CreatePipelineLayout(pPipelineLayoutCreateInfo, null, out mPipelineLayout);
Debug.Assert(err == Result.SUCCESS);
}
public void BuildStructure0()
{
var mock = new MockGLDescriptorSetLayout
{
Uniforms = new GLUniformBinding[]
{
}
};
var createInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new IMgDescriptorSetLayout[]
{
mock
},
};
var result = new GLNextPipelineLayout(createInfo);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.NoOfBindingPoints);
}
public Result CreatePipelineLayout(MgPipelineLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgPipelineLayout pPipelineLayout)
{
pPipelineLayout = new AmtPipelineLayout(pCreateInfo);
return(Result.SUCCESS);
}
public Result CreatePipelineLayout(MgPipelineLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgPipelineLayout pPipelineLayout)
{
throw new NotImplementedException();
}
public GltfScene Load(IMgDevice device, IMgEffectFramework framework, string modelFilePath)
{
var model = Interface.LoadModel(modelFilePath);
var baseDir = Path.GetDirectoryName(modelFilePath);
var buffers = ExtractBuffers(model, baseDir);
var request = new MgStorageBlockAllocationRequest();
const int MAX_NO_OF_CAMERAS = 1;
var cameraAllocationInfo = new GltfBucketAllocationInfo <CameraUBO>
{
BucketSize = MAX_NO_OF_CAMERAS,
Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT,
MemoryPropertyFlags = MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT,
};
var cameraSlots = cameraAllocationInfo.Prepare(model.Cameras != null ? model.Cameras.Length : 0, request);
var accessors = ExtractAccessors(model);
var bufferViews = ExtractBufferViews(model);
const int MAX_NO_OF_MATERIALS = 16;
var materialAllocationInfo = new GltfBucketAllocationInfo <MaterialUBO>
{
BucketSize = MAX_NO_OF_MATERIALS,
Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT,
MemoryPropertyFlags = MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT,
};
var images = ExtractImages(baseDir, model.Images, bufferViews, buffers);
var samplers = ExtractSamplers(device, model.Samplers);
const int MAX_NO_OF_LIGHTS = 4;
const int MAX_NO_OF_TEXTURES = 16;
// var textures = AllocateTextures(MAX_NO_OF_TEXTURES, model.Textures, images);
var materialSlots = materialAllocationInfo.Prepare(model.Materials != null ? model.Materials.Length : 0, request);
var materialChunks = ExtractMaterials(materialSlots.BucketSize, model.Materials);
var meshes = ExtractMeshes(model, accessors, materialSlots);
PadMeshes(meshes);
var meshLocations = AllocateMeshes(request, meshes, accessors, bufferViews);
var nodes = ExtractNodes(model, cameraSlots);
var pDsCreateInfo = new MgDescriptorSetLayoutCreateInfo
{
Bindings = new[]
{
// CAMERA
new MgDescriptorSetLayoutBinding
{
Binding = 0,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = MAX_NO_OF_CAMERAS,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
},
// LIGHTS
new MgDescriptorSetLayoutBinding
{
Binding = 1,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = MAX_NO_OF_LIGHTS,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
},
// MATERIALS
new MgDescriptorSetLayoutBinding
{
Binding = 2,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER,
DescriptorCount = MAX_NO_OF_MATERIALS,
StageFlags = MgShaderStageFlagBits.FRAGMENT_BIT,
},
// TEXTURES
new MgDescriptorSetLayoutBinding
{
Binding = 3,
DescriptorType = MgDescriptorType.COMBINED_IMAGE_SAMPLER,
DescriptorCount = MAX_NO_OF_TEXTURES,
StageFlags = MgShaderStageFlagBits.FRAGMENT_BIT,
},
}
};
var err = device.CreateDescriptorSetLayout(pDsCreateInfo, null, out IMgDescriptorSetLayout dsLayout);
if (err != Result.SUCCESS)
{
throw new InvalidOperationException("CreatePipelineLayout failed");
}
var pCreateInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new[]
{
dsLayout,
}
};
err = device.CreatePipelineLayout(pCreateInfo, null, out IMgPipelineLayout layout);
if (err != Result.SUCCESS)
{
throw new InvalidOperationException("CreatePipelineLayout failed");
}
var pbrEffect = new EffectPipelineDictionary();
var pbrFactory = new PbrEffectVariantFactory(mPbrEffectPath);
var instanceDrawGroups = new Dictionary <GltfInstancedGroupKey, GltfInstanceDrawGroup>();
foreach (var node in nodes)
{
if (node.Mesh.HasValue)
{
var options = new EffectVariantOptions
{
};
var meshIndex = node.Mesh.Value;
var mesh = meshes[meshIndex];
options.FrontFace =
node.IsMirrored
? MgFrontFace.CLOCKWISE
: MgFrontFace.COUNTER_CLOCKWISE;
foreach (var primitive in mesh.Primitives)
{
options.Topology = primitive.Topology;
var materialItem = materialChunks[primitive.Material.BucketIndex].Items[primitive.Material.Offset];
options.CullMode =
materialItem.DoubleSided
? MgCullModeFlagBits.NONE
: MgCullModeFlagBits.BACK_BIT;
var key = new EffectVariantKey
{
Definition = PerVertexDefinitionEncoder.Encode(primitive.FinalDefinition),
Options = EffectVariantEncoder.Encode(options),
};
if (!pbrEffect.TryGetValue(key, out EffectVariant found))
{
var vertexInput = new PerVertexInputPipelineState(primitive.FinalDefinition);
found = pbrFactory.Initialize(device, layout, framework.Renderpass, vertexInput, options);
pbrEffect.Add(key, found);
}
AppendToGroup(instanceDrawGroups, node, meshIndex, primitive, key, found);
}
}
}
var stride = Marshal.SizeOf(typeof(PerInstance));
var perInstances = new List <GltfInstanceRenderGroup>();
foreach (var group in instanceDrawGroups.Values)
{
var slotInfo = new MgStorageBlockAllocationInfo
{
MemoryPropertyFlags = MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT,
Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT,
ElementByteSize = (uint)stride,
Size = (ulong)(group.Members.Count * stride),
};
var instanceGroup = new GltfInstanceRenderGroup
{
Variant = group.Variant,
StorageIndex = request.Insert(slotInfo),
Members = group.Members.ToArray(),
};
perInstances.Add(instanceGroup);
}
var storage = mBuilder.Build(
new MgOptimizedStorageCreateInfo
{
Allocations = request.ToArray()
}
);
// MAP DATA
var finalMaterials = new List <GltfMaterialInfo>();
for (var i = 0; i < materialChunks.Length; i += 1)
{
var slot = materialSlots.Slots[i];
var chunk = materialChunks[i];
for (var j = 0; j < chunk.Items.Length; j += 1)
{
var values = chunk.Items[j];
var mat = new GltfMaterialInfo
{
StorageIndex = slot,
BucketIndex = i,
SetOffset = j,
Values = values,
};
}
}
return(new GltfScene
{
//Cameras = new []
//{
//},
DescriptorSets = new IMgDescriptorSet[]
{
},
Effects = new []
{
new Effect
{
DescriptorSetLayout = dsLayout,
Layout = layout,
Variants = pbrEffect,
}
},
//Meshes = new[]
//{
//},
Materials = finalMaterials.ToArray(),
//Nodes = new []
//{
//},
PerInstances = perInstances.ToArray(),
Samplers = samplers,
Storage = storage,
//Textures = new []
//{
//},
});
}
void InitializeGraphicsPipeline()
{
using (var shaderSrc = System.IO.File.OpenRead("Fragment.metal"))
using (var fragMemory = new System.IO.MemoryStream())
using (var vertMemory = new System.IO.MemoryStream())
{
shaderSrc.CopyTo(fragMemory);
// Magnesium uses like open files i.e. open the stream and let it process the data
fragMemory.Seek(0, System.IO.SeekOrigin.Begin);
// Load the fragment program into the library
IMgShaderModule fragmentProgram = null;
//IMTLFunction fragmentProgram = defaultLibrary.CreateFunction("lighting_fragment");
MgShaderModuleCreateInfo fragCreateInfo = new MgShaderModuleCreateInfo
{
Code = fragMemory,
CodeSize = new UIntPtr((ulong)fragMemory.Length),
};
var err = mConfiguration.Device.CreateShaderModule(fragCreateInfo, null, out fragmentProgram);
Debug.Assert(err == Result.SUCCESS);
// REWIND AFTER USE
shaderSrc.Seek(0, System.IO.SeekOrigin.Begin);
shaderSrc.CopyTo(vertMemory);
vertMemory.Seek(0, System.IO.SeekOrigin.Begin);
// Load the vertex program into the library
//IMTLFunction vertexProgram = defaultLibrary.CreateFunction("lighting_vertex");
MgShaderModuleCreateInfo vertCreateInfo = new MgShaderModuleCreateInfo
{
Code = vertMemory,
CodeSize = new UIntPtr((ulong)vertMemory.Length),
};
IMgShaderModule vertexProgram = null;
err = mConfiguration.Device.CreateShaderModule(vertCreateInfo, null, out vertexProgram);
Debug.Assert(err == Result.SUCCESS);
IMgPipelineLayout pipelineLayout;
MgPipelineLayoutCreateInfo plCreateInfo = new MgPipelineLayoutCreateInfo
{
SetLayouts = new IMgDescriptorSetLayout[]
{
mSetLayout,
},
};
err = mConfiguration.Device.CreatePipelineLayout(plCreateInfo, null, out pipelineLayout);
mPipelineLayout = pipelineLayout;
var vertexStride = Marshal.SizeOf <Vector3>();
IMgPipeline[] pipelines;
var pCreateInfos = new MgGraphicsPipelineCreateInfo[]
{
new MgGraphicsPipelineCreateInfo
{
Stages = new MgPipelineShaderStageCreateInfo[]
{
new MgPipelineShaderStageCreateInfo
{
Module = fragmentProgram,
Stage = MgShaderStageFlagBits.FRAGMENT_BIT,
Name = "lighting_fragment",
},
new MgPipelineShaderStageCreateInfo
{
Module = vertexProgram,
Stage = MgShaderStageFlagBits.VERTEX_BIT,
Name = "lighting_vertex",
},
},
InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo
{
Topology = MgPrimitiveTopology.TRIANGLE_LIST,
},
DepthStencilState = new MgPipelineDepthStencilStateCreateInfo
{
DepthCompareOp = MgCompareOp.LESS,
DepthWriteEnable = true,
DepthTestEnable = true,
},
MultisampleState = new MgPipelineMultisampleStateCreateInfo
{
// TODO : METALSample uses 4 bits, have to investigated multisampling in
// Vulkan ( => Magnesium) for correct code
RasterizationSamples = MgSampleCountFlagBits.COUNT_1_BIT,
},
RasterizationState = new MgPipelineRasterizationStateCreateInfo
{
FrontFace = MgFrontFace.COUNTER_CLOCKWISE,
PolygonMode = MgPolygonMode.FILL,
CullMode = MgCullModeFlagBits.BACK_BIT,
},
VertexInputState = new MgPipelineVertexInputStateCreateInfo
{
VertexBindingDescriptions = new MgVertexInputBindingDescription[]
{
new MgVertexInputBindingDescription
{
Binding = 0,
InputRate = MgVertexInputRate.VERTEX,
Stride = (uint)(2 * vertexStride),
},
},
VertexAttributeDescriptions = new MgVertexInputAttributeDescription[]
{
new MgVertexInputAttributeDescription
{
Binding = 0,
Location = 0,
Format = MgFormat.R32G32B32_SFLOAT,
Offset = 0,
},
new MgVertexInputAttributeDescription
{
Binding = 0,
Location = 1,
Format = MgFormat.R32G32B32_SFLOAT,
Offset = (uint)vertexStride,
},
},
},
ViewportState = new MgPipelineViewportStateCreateInfo
{
Viewports = new MgViewport[]
{
mGraphicsDevice.CurrentViewport,
},
Scissors = new MgRect2D[]
{
mGraphicsDevice.Scissor,
}
},
//DynamicState = new MgPipelineDynamicStateCreateInfo
//{
// DynamicStates = new MgDynamicState[]
// {
// MgDynamicState.VIEWPORT,
// MgDynamicState.SCISSOR,
// }
//},
RenderPass = mGraphicsDevice.Renderpass,
Layout = pipelineLayout,
},
};
err = mConfiguration.Device.CreateGraphicsPipelines(
null, pCreateInfos, null, out pipelines);
Debug.Assert(err == Result.SUCCESS);
fragmentProgram.DestroyShaderModule(mConfiguration.Device, null);
vertexProgram.DestroyShaderModule(mConfiguration.Device, null);
mPipelineState = pipelines[0];
}
GenerateRenderingCommandBuffers();
}
