public AmtDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo createInfo)
{
if (createInfo == null)
{
throw new ArgumentNullException(nameof(createInfo));
}
var resources = new List <AmtPipelineResourceBinding>();
if (createInfo.Bindings != null)
{
foreach (var binding in createInfo.Bindings)
{
var resource = new AmtPipelineResourceBinding
{
Binding = binding.Binding,
Stage = binding.StageFlags,
DescriptorCount = binding.DescriptorCount,
DescriptorType = binding.DescriptorType
};
resources.Add(resource);
}
}
PipelineResources = resources.ToArray();
}
public GLDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo pCreateInfo)
{
if (pCreateInfo.Bindings != null)
{
var highestBinding = 0U;
var uniforms = new List <GLUniformBinding>();
foreach (var binding in pCreateInfo.Bindings)
{
highestBinding = Math.Max(binding.Binding, highestBinding);
var uniform = new GLUniformBinding {
Binding = binding.Binding,
DescriptorType = binding.DescriptorType,
DescriptorCount = binding.DescriptorCount,
StageFlags = binding.StageFlags,
};
uniforms.Add(uniform);
}
var count = highestBinding + 1;
Uniforms = new GLUniformBinding[count];
foreach (var uni in uniforms)
{
Uniforms[uni.Binding] = uni;
}
}
else
{
Uniforms = new GLUniformBinding[0];
}
}
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 Result CreateDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgDescriptorSetLayout pSetLayout)
{
if (pCreateInfo == null)
{
throw new ArgumentNullException(nameof(pCreateInfo));
}
pSetLayout = new GLDescriptorSetLayout(pCreateInfo);
return(Result.SUCCESS);
}
public GLDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo pCreateInfo)
{
var bindings = new List <GLUniformBinding>();
if (pCreateInfo.Bindings != null)
{
foreach (var binding in pCreateInfo.Bindings)
{
var uniform = new GLUniformBinding {
Binding = binding.Binding,
DescriptorType = binding.DescriptorType,
DescriptorCount = binding.DescriptorCount,
StageFlags = binding.StageFlags,
};
bindings.Add(uniform);
}
}
Uniforms = bindings.ToArray();
}
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 Result CreateDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgDescriptorSetLayout pSetLayout)
{
pSetLayout = new AmtDescriptorSetLayout(pCreateInfo);
return(Result.SUCCESS);
}
public Result CreateDescriptorSetLayout(MgDescriptorSetLayoutCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgDescriptorSetLayout pSetLayout)
{
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 []
//{
//},
});
}
// Allocate one region of memory for the uniform buffer
private void InitializeUniforms()
{
MgBufferCreateInfo pCreateInfo = new MgBufferCreateInfo
{
Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT,
Size = MaxBytesPerFrame,
};
IMgBuffer buffer;
var err = mConfiguration.Device.CreateBuffer(pCreateInfo, null, out buffer);
Debug.Assert(err == Result.SUCCESS);
//dynamicConstantBuffer = device.CreateBuffer(MaxBytesPerFrame, (MTLResourceOptions)0);
//dynamicConstantBuffer.Label = "UniformBuffer";
MgMemoryRequirements uniformsMemReqs;
mConfiguration.Device.GetBufferMemoryRequirements(buffer, out uniformsMemReqs);
const MgMemoryPropertyFlagBits uniformPropertyFlags = MgMemoryPropertyFlagBits.HOST_COHERENT_BIT;
uint uniformMemoryTypeIndex;
mConfiguration.Partition.GetMemoryType(
uniformsMemReqs.MemoryTypeBits, uniformPropertyFlags, out uniformMemoryTypeIndex);
var uniformMemAlloc = new MgMemoryAllocateInfo
{
MemoryTypeIndex = uniformMemoryTypeIndex,
AllocationSize = uniformsMemReqs.Size,
};
IMgDeviceMemory deviceMemory;
var result = mConfiguration.Device.AllocateMemory(uniformMemAlloc, null, out deviceMemory);
Debug.Assert(result == Result.SUCCESS);
buffer.BindBufferMemory(mConfiguration.Device, deviceMemory, 0);
mUniforms = new BufferInfo
{
Buffer = buffer,
DeviceMemory = deviceMemory,
Offset = 0,
Length = MaxBytesPerFrame,
};
IMgDescriptorSetLayout pSetLayout;
var dslCreateInfo = new MgDescriptorSetLayoutCreateInfo
{
Bindings = new MgDescriptorSetLayoutBinding[]
{
new MgDescriptorSetLayoutBinding
{
Binding = 0,
DescriptorCount = 1,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC,
StageFlags = MgShaderStageFlagBits.VERTEX_BIT,
},
},
};
err = mConfiguration.Device.CreateDescriptorSetLayout(dslCreateInfo, null, out pSetLayout);
var poolCreateInfo = new Magnesium.MgDescriptorPoolCreateInfo
{
MaxSets = 1,
PoolSizes = new MgDescriptorPoolSize[] {
new MgDescriptorPoolSize
{
DescriptorCount = 1,
Type = MgDescriptorType.COMBINED_IMAGE_SAMPLER,
},
},
};
err = mConfiguration.Device.CreateDescriptorPool(poolCreateInfo, null, out mDescriptorPool);
IMgDescriptorSet[] dSets;
MgDescriptorSetAllocateInfo pAllocateInfo = new MgDescriptorSetAllocateInfo
{
DescriptorPool = mDescriptorPool,
DescriptorSetCount = 1,
SetLayouts = new IMgDescriptorSetLayout[]
{
pSetLayout,
},
};
mConfiguration.Device.AllocateDescriptorSets(pAllocateInfo, out dSets);
mUniformDescriptorSet = dSets[0];
MgWriteDescriptorSet[] writes = new MgWriteDescriptorSet[]
{
new MgWriteDescriptorSet
{
DescriptorCount = 1,
DescriptorType = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC,
DstSet = mUniformDescriptorSet,
BufferInfo = new MgDescriptorBufferInfo[]
{
new MgDescriptorBufferInfo
{
Buffer = mUniforms.Buffer,
Offset = mUniforms.Offset,
Range = mUniforms.Length,
},
},
DstBinding = 0,
}
};
mConfiguration.Device.UpdateDescriptorSets(writes, null);
mSetLayout = pSetLayout;
}
