public int CalculateArrayIndex(GLUniformBlockEntry entry)
{
int bindingPoint = 0;
var mapGroup = mGroups[entry.FirstBinding];
// ROW-ORDER
bindingPoint += entry.Token.X;
bindingPoint += (mapGroup.ArrayStride * entry.Token.Y);
bindingPoint += (mapGroup.MatrixStride * entry.Token.Z);
var arrayOffset = mLayout.Ranges[entry.FirstBinding];
bindingPoint += arrayOffset.First;
return(bindingPoint);
}
public void Preamble()
{
// PRIVATE IMPLEMENTATION UNIT TESTING
mContainer = new Container();
mContainer.Register <IMgQueue, GLCmdQueue>(Reuse.Singleton);
mContainer.Register <IGLCmdStateRenderer, GLCmdStateRenderer>(Reuse.Singleton);
mContainer.Register <IGLCmdBlendEntrypoint, MockGLCmdBlendEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdStencilEntrypoint, MockGLCmdStencilEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdRasterizationEntrypoint, MockGLCmdRasterizationEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdDepthEntrypoint, MockGLCmdDepthEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdScissorsEntrypoint, MockGLCmdScissorsEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdDrawEntrypoint, MockGLCmdDrawEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdClearEntrypoint, MockGLCmdClearEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLErrorHandler, MockGLErrorHandler>(Reuse.Singleton);
mContainer.Register <IGLNextCmdShaderProgramCache, GLNextCmdShaderProgramCache>(Reuse.Singleton);
mContainer.Register <IGLCmdShaderProgramEntrypoint, MockGLCmdShaderProgramEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLBlitOperationEntrypoint, MockGLBlitOperationEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLSemaphoreEntrypoint, MockGLSemaphoreEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdImageEntrypoint, MockGLCmdImageEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdBlitEncoder, GLCmdBlitEncoder>(Reuse.Singleton);
mContainer.Register <GLCmdBlitBag>(Reuse.Singleton);
mContainer.Register <IGLCmdComputeEncoder, GLCmdComputeEncoder>(Reuse.Singleton);
mContainer.Register <IGLCmdGraphicsEncoder, GLCmdGraphicsEncoder>(Reuse.Singleton);
mContainer.Register <GLCmdGraphicsBag>(Reuse.Singleton);
mContainer.Register <IGLCmdVBOEntrypoint, MockGLCmdVBOEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLDescriptorSetBinder, GLNextDescriptorSetBinder>(Reuse.Singleton);
mContainer.Register <IGLCmdEncoderContextSorter, GLCmdIncrementalContextSorter>(Reuse.Singleton);
mContainer.Register <GLCmdCommandEncoder>(Reuse.Singleton);
mContainer.Register <GLInternalCache>(Reuse.Singleton);
mContainer.Register <IMgPipeline, GLGraphicsPipeline>(Reuse.Singleton);
mContainer.Register <IGLGraphicsPipelineCompiler, MockGLGraphicsPipelineCompiler>(Reuse.Singleton);
mContainer.Register <IGLGraphicsPipelineEntrypoint, MockGLGraphicsPipelineEntrypoint>(Reuse.Singleton);
queue = mContainer.Resolve <IMgQueue>();
var cmdEncoder = mContainer.Resolve <GLCmdCommandEncoder>();
cmdBuf = new Magnesium.OpenGL.Internals.GLCmdCommandBuffer(true, cmdEncoder);
framebuffer = new Magnesium.OpenGL.Internals.GLFramebuffer();
renderpass = new GLRenderPass(new MgAttachmentDescription[] { });
vertexBuffer = new MockGLBuffer
{
BufferId = 1,
Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT,
};
indexBuffer = new MockGLBuffer
{
BufferId = 2,
Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT,
};
var layout = new MockGLPipelineLayout
{
};
mContainer.RegisterInstance <IGLPipelineLayout>(layout, Reuse.Singleton);
var blockEntries = new GLUniformBlockEntry[]
{
};
var arrayMapper = new Magnesium.OpenGL.Internals.GLInternalCacheArrayMapper(layout, blockEntries);
mContainer.RegisterInstance <GLInternalCacheArrayMapper>(arrayMapper, Reuse.Singleton);
var entrypoint = mContainer.Resolve <IGLGraphicsPipelineEntrypoint>();
var internalCache = mContainer.Resolve <GLInternalCache>();
var info = new MgGraphicsPipelineCreateInfo
{
VertexInputState = new MgPipelineVertexInputStateCreateInfo
{
VertexAttributeDescriptions = new[]
{
new MgVertexInputAttributeDescription
{
Binding = 0,
Location = 0,
Format = MgFormat.R8G8B8A8_SNORM,
}
},
VertexBindingDescriptions = new[]
{
new MgVertexInputBindingDescription
{
Binding = 0,
InputRate = MgVertexInputRate.VERTEX,
Stride = 32,
}
}
},
RasterizationState = new MgPipelineRasterizationStateCreateInfo
{
PolygonMode = MgPolygonMode.FILL,
},
InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo
{
Topology = MgPrimitiveTopology.TRIANGLE_LIST,
}
};
pipeline = new Magnesium.OpenGL.Internals.GLGraphicsPipeline(entrypoint, 1, info, internalCache, layout);
var stateRenderer = mContainer.Resolve <IGLCmdStateRenderer>();
stateRenderer.Initialize();
}
public void Pass_01()
{
var shaderEntrypoint = new MockGLCmdShaderProgramEntrypoint();
var shaderCache = new GLNextCmdShaderProgramCache(shaderEntrypoint);
var pipelineLayout = new MockGLPipelineLayout
{
Ranges = new Dictionary <int, GLBindingPointOffsetInfo>(),
NoOfBindingPoints = 4,
NoOfExpectedDynamicOffsets = 0,
NoOfStorageBuffers = 1,
OffsetDestinations = new GLDynamicOffsetInfo[] { }
};
var parentPool = new MockGLDescriptorPool
{
UniformBuffers = new MockGLDescriptorPoolResource <GLBufferDescriptor>
{
Items = new GLBufferDescriptor[]
{
// NEED FOUR
new GLBufferDescriptor
{
},
new GLBufferDescriptor
{
},
new GLBufferDescriptor
{
},
new GLBufferDescriptor
{
},
}
},
StorageBuffers = new MockGLDescriptorPoolResource <GLBufferDescriptor>
{
Items = new GLBufferDescriptor[]
{
// NEED FOUR
new GLBufferDescriptor
{
},
}
}
};
var ds = new MockGLDescriptorSet
{
Parent = parentPool,
IsValidDescriptorSet = true,
Resources = new GLDescriptorPoolResourceInfo[]
{
new GLDescriptorPoolResourceInfo
{
Binding = 0,
DescriptorCount = 4,
GroupType = GLDescriptorBindingGroup.UniformBuffer,
Ticket = new GLPoolResourceTicket
{
First = 0,
Last = 3,
Count = 4,
}
},
new GLDescriptorPoolResourceInfo
{
Binding = 1,
DescriptorCount = 1,
GroupType = GLDescriptorBindingGroup.StorageBuffer,
Ticket = new GLPoolResourceTicket
{
First = 0,
Last = 0,
Count = 1,
}
},
}
};
var dynamicOffsets = new uint[4];
const int FIRST_BINDING = 0;
var blockEntries = new GLUniformBlockEntry[]
{
new GLUniformBlockEntry
{
BlockName = "UBO",
ActiveIndex = 0,
FirstBinding = 0,
Stride = 2,
Token = new GLUniformBlockInfo
{
BindingIndex = 0,
Prefix = "UBO",
X = 0,
Y = 0,
Z = 0,
},
},
new GLUniformBlockEntry
{
BlockName = "UBO",
ActiveIndex = 1,
FirstBinding = 0,
Stride = 2,
Token = new GLUniformBlockInfo
{
BindingIndex = 1,
Prefix = "UBO",
X = 1,
Y = 0,
Z = 0,
},
},
new GLUniformBlockEntry
{
BlockName = "UBO",
ActiveIndex = 2,
FirstBinding = 0,
Stride = 2,
Token = new GLUniformBlockInfo
{
BindingIndex = 2,
Prefix = "UBO",
X = 2,
Y = 0,
Z = 0,
},
},
new GLUniformBlockEntry
{
BlockName = "UBO",
ActiveIndex = 3,
FirstBinding = 0,
Stride = 2,
Token = new GLUniformBlockInfo
{
BindingIndex = 3,
Prefix = "UBO",
X = 3,
Y = 0,
Z = 0,
},
},
};
pipelineLayout.Ranges[FIRST_BINDING] = new GLBindingPointOffsetInfo
{
Binding = FIRST_BINDING,
First = 0,
Last = 3,
};
var arrayMapper = new Internals.GLInternalCacheArrayMapper(pipelineLayout, blockEntries);
var internalCache = new Internals.GLInternalCache(pipelineLayout, blockEntries, arrayMapper);
const int PROGRAM_ID = 5;
shaderCache.SetProgramID(MgPipelineBindPoint.GRAPHICS, PROGRAM_ID, internalCache, pipelineLayout);
Assert.AreEqual(PROGRAM_ID, shaderEntrypoint.ProgramID);
Assert.AreEqual(blockEntries.Length, shaderEntrypoint.NoOfSetUniformCalls);
var param = new Internals.GLCmdDescriptorSetParameter
{
Bindpoint = MgPipelineBindPoint.GRAPHICS,
Layout = pipelineLayout,
DescriptorSet = ds,
DynamicOffsets = dynamicOffsets,
};
shaderCache.BindDescriptorSets(param);
Assert.AreEqual(blockEntries.Length, shaderEntrypoint.Count);
Assert.IsNotNull(shaderEntrypoint.UniformBuffers);
Assert.AreEqual(blockEntries.Length, shaderEntrypoint.UniformBuffers.Length);
Assert.IsNotNull(shaderEntrypoint.UniformOffsets);
Assert.AreEqual(blockEntries.Length, shaderEntrypoint.UniformOffsets.Length);
Assert.IsNotNull(shaderEntrypoint.UniformSizes);
Assert.AreEqual(blockEntries.Length, shaderEntrypoint.UniformSizes.Length);
}
