public void SetIndices(IntPtr indices, IndexFormat format, int count, int elementOffset)
{
int elementSizeInBytes = FormatHelpers.GetIndexFormatElementByteSize(format);
SetData(indices, elementSizeInBytes * count, elementOffset * elementSizeInBytes);
IndexType = VkFormats.VeldridToVkIndexFormat(format);
}
public VkSamplerState(
VkDevice device,
SamplerAddressMode addressU,
SamplerAddressMode addressV,
SamplerAddressMode addressW,
SamplerFilter filter,
int maxAnisotropy,
RgbaFloat borderColor,
DepthComparison comparison,
int minimumLod,
int maximumLod,
int lodBias)
{
_device = device;
AddressU = addressU;
AddressV = addressV;
AddressW = addressW;
Filter = filter;
MaximumAnisotropy = maxAnisotropy;
BorderColor = borderColor;
Comparison = comparison;
MinimumLod = minimumLod;
MaximumLod = maximumLod;
LodBias = lodBias;
VkSamplerCreateInfo samplerCI = VkSamplerCreateInfo.New();
samplerCI.addressModeU = VkFormats.VeldridToVkSamplerAddressMode(addressU);
samplerCI.addressModeV = VkFormats.VeldridToVkSamplerAddressMode(addressV);
samplerCI.addressModeW = VkFormats.VeldridToVkSamplerAddressMode(addressW);
VkFormats.GetFilterProperties(
filter,
out VkFilter minFilter,
out VkFilter magFilter,
out VkSamplerMipmapMode mipmapMode,
out bool anisotropyEnable,
out bool compareEnable);
samplerCI.minFilter = minFilter;
samplerCI.magFilter = magFilter;
samplerCI.mipmapMode = mipmapMode;
samplerCI.maxAnisotropy = maxAnisotropy;
samplerCI.anisotropyEnable = anisotropyEnable;
samplerCI.compareEnable = compareEnable;
samplerCI.minLod = minimumLod;
samplerCI.maxLod = maximumLod;
samplerCI.mipLodBias = lodBias;
samplerCI.compareOp = VkFormats.VeldridToVkDepthComparison(comparison);
samplerCI.borderColor = VkBorderColor.FloatOpaqueWhite;
VkResult result = vkCreateSampler(_device, ref samplerCI, null, out VkSampler sampler);
CheckResult(result);
Sampler = sampler;
}
public VkTexture2D(
VkDevice device,
int mipLevels,
int width,
int height,
VkFormat vkFormat,
VkImage existingImage)
{
_device = device;
MipLevels = mipLevels;
_width = width;
_height = height;
Format = vkFormat;
_veldridFormat = VkFormats.VkToVeldridPixelFormat(vkFormat);
_image = existingImage;
}
public VkRasterizerState(FaceCullingMode cullMode, TriangleFillMode fillMode, bool isDepthClipEnabled, bool isScissorTestEnabled)
{
CullMode = cullMode;
FillMode = fillMode;
IsDepthClipEnabled = isDepthClipEnabled;
IsScissorTestEnabled = isScissorTestEnabled;
VkPipelineRasterizationStateCreateInfo rasterizerStateCI = VkPipelineRasterizationStateCreateInfo.New();
rasterizerStateCI.cullMode = VkFormats.VeldridToVkCullMode(cullMode);
rasterizerStateCI.polygonMode = VkFormats.VeldridToVkFillMode(fillMode);
rasterizerStateCI.depthClampEnable = !isDepthClipEnabled; // TODO: Same as OpenGL (?)
rasterizerStateCI.frontFace = VkFrontFace.Clockwise;
RasterizerStateCreateInfo = rasterizerStateCI;
}
public VkCubemapTexture(
VkDevice device,
VkPhysicalDevice physicalDevice,
VkDeviceMemoryManager memoryManager,
VkRenderContext rc,
IntPtr pixelsFront,
IntPtr pixelsBack,
IntPtr pixelsLeft,
IntPtr pixelsRight,
IntPtr pixelsTop,
IntPtr pixelsBottom,
int width,
int height,
PixelFormat format)
{
_device = device;
_physicalDevice = physicalDevice;
_rc = rc;
_memoryManager = memoryManager;
Width = width;
Height = height;
_format = format;
_vkFormat = VkFormats.VeldridToVkPixelFormat(_format);
vkGetPhysicalDeviceImageFormatProperties(
_physicalDevice,
_vkFormat,
VkImageType.Image2D,
VkImageTiling.Linear,
VkImageUsageFlags.Sampled,
VkImageCreateFlags.CubeCompatible,
out VkImageFormatProperties linearProps);
vkGetPhysicalDeviceImageFormatProperties(
_physicalDevice,
_vkFormat,
VkImageType.Image2D,
VkImageTiling.Optimal,
VkImageUsageFlags.Sampled,
VkImageCreateFlags.CubeCompatible,
out VkImageFormatProperties optimalProps);
bool useSingleStagingBuffer = linearProps.maxArrayLayers >= 6;
VkImageCreateInfo imageCI = VkImageCreateInfo.New();
imageCI.imageType = VkImageType.Image2D;
imageCI.flags = VkImageCreateFlags.CubeCompatible;
imageCI.format = _vkFormat;
imageCI.extent.width = (uint)width;
imageCI.extent.height = (uint)height;
imageCI.extent.depth = 1;
imageCI.mipLevels = 1;
imageCI.arrayLayers = 6;
imageCI.samples = VkSampleCountFlags.Count1;
imageCI.tiling = useSingleStagingBuffer ? VkImageTiling.Linear : VkImageTiling.Optimal;
imageCI.usage = VkImageUsageFlags.Sampled | VkImageUsageFlags.TransferDst;
imageCI.initialLayout = VkImageLayout.Preinitialized;
VkResult result = vkCreateImage(_device, ref imageCI, null, out _image);
CheckResult(result);
vkGetImageMemoryRequirements(_device, _image, out VkMemoryRequirements memReqs);
uint memoryType = FindMemoryType(_physicalDevice, memReqs.memoryTypeBits, VkMemoryPropertyFlags.DeviceLocal);
_memory = memoryManager.Allocate(memoryType, memReqs.size, memReqs.alignment);
vkBindImageMemory(_device, _image, _memory.DeviceMemory, _memory.Offset);
if (useSingleStagingBuffer)
{
CopyDataSingleStagingBuffer(pixelsFront, pixelsBack, pixelsLeft, pixelsRight, pixelsTop, pixelsBottom, memReqs);
}
else
{
CopyDataMultiImage(pixelsFront, pixelsBack, pixelsLeft, pixelsRight, pixelsTop, pixelsBottom);
}
TransitionImageLayout(_image, (uint)MipLevels, 0, 6, VkImageLayout.TransferDstOptimal, VkImageLayout.ShaderReadOnlyOptimal);
_imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
}
public void SetIndices(IntPtr indices, IndexFormat format, int count)
{
SetData(indices, FormatHelpers.GetIndexFormatElementByteSize(format) * count);
IndexType = VkFormats.VeldridToVkIndexFormat(format);
}
public VkTexture2D(
VkDevice device,
VkPhysicalDevice physicalDevice,
VkDeviceMemoryManager memoryManager,
VkRenderContext rc,
int mipLevels,
int width,
int height,
PixelFormat veldridFormat,
DeviceTextureCreateOptions createOptions)
{
_device = device;
_physicalDevice = physicalDevice;
_memoryManager = memoryManager;
_rc = rc;
MipLevels = mipLevels;
_width = width;
_height = height;
_createOptions = createOptions;
if (createOptions == DeviceTextureCreateOptions.DepthStencil)
{
Format = VkFormat.D16Unorm;
}
else
{
Format = VkFormats.VeldridToVkPixelFormat(veldridFormat);
}
_veldridFormat = veldridFormat;
VkImageCreateInfo imageCI = VkImageCreateInfo.New();
imageCI.mipLevels = (uint)mipLevels;
imageCI.arrayLayers = 1;
imageCI.imageType = VkImageType.Image2D;
imageCI.extent.width = (uint)width;
imageCI.extent.height = (uint)height;
imageCI.extent.depth = 1;
imageCI.initialLayout = VkImageLayout.Preinitialized; // TODO: Use proper VkImageLayout values and transitions.
imageCI.usage = VkImageUsageFlags.TransferDst | VkImageUsageFlags.Sampled;
if (createOptions == DeviceTextureCreateOptions.RenderTarget)
{
imageCI.usage |= VkImageUsageFlags.ColorAttachment;
}
else if (createOptions == DeviceTextureCreateOptions.DepthStencil)
{
imageCI.usage |= VkImageUsageFlags.DepthStencilAttachment;
}
imageCI.tiling = createOptions == DeviceTextureCreateOptions.DepthStencil ? VkImageTiling.Optimal : VkImageTiling.Optimal;
imageCI.format = Format;
imageCI.samples = VkSampleCountFlags.Count1;
VkResult result = vkCreateImage(device, ref imageCI, null, out _image);
CheckResult(result);
vkGetImageMemoryRequirements(_device, _image, out VkMemoryRequirements memoryRequirements);
VkMemoryBlock memoryToken = memoryManager.Allocate(
FindMemoryType(
_physicalDevice,
memoryRequirements.memoryTypeBits,
VkMemoryPropertyFlags.DeviceLocal),
memoryRequirements.size,
memoryRequirements.alignment);
_memory = memoryToken;
vkBindImageMemory(_device, _image, _memory.DeviceMemory, _memory.Offset);
}
protected override void PlatformSetPrimitiveTopology(PrimitiveTopology primitiveTopology)
{
_primitiveTopology = VkFormats.VeldridToVkPrimitiveTopology(primitiveTopology);
}
private VkPipeline CreateNewGraphicsPipeline(ref VkPipelineCacheKey cacheKey)
{
VkGraphicsPipelineCreateInfo pipelineCI = VkGraphicsPipelineCreateInfo.New();
// RenderPass
pipelineCI.renderPass = cacheKey.RenderPass;
pipelineCI.subpass = 0;
pipelineCI.layout = cacheKey.PipelineLayout;
// DynamicState
VkPipelineDynamicStateCreateInfo dynamicStateCI = VkPipelineDynamicStateCreateInfo.New();
VkDynamicState *dynamicStates = stackalloc VkDynamicState[2];
dynamicStates[0] = VkDynamicState.Viewport;
dynamicStates[1] = VkDynamicState.Scissor;
dynamicStateCI.dynamicStateCount = 2;
dynamicStateCI.pDynamicStates = dynamicStates;
pipelineCI.pDynamicState = &dynamicStateCI;
// ColorBlendState
VkPipelineColorBlendAttachmentState colorBlendAttachementState = new VkPipelineColorBlendAttachmentState();
colorBlendAttachementState.colorWriteMask = VkColorComponentFlags.R | VkColorComponentFlags.G | VkColorComponentFlags.B | VkColorComponentFlags.A;
colorBlendAttachementState.blendEnable = cacheKey.BlendState.IsBlendEnabled;
colorBlendAttachementState.srcColorBlendFactor = VkFormats.VeldridToVkBlendFactor(cacheKey.BlendState.SourceColorBlend);
colorBlendAttachementState.dstColorBlendFactor = VkFormats.VeldridToVkBlendFactor(cacheKey.BlendState.DestinationColorBlend);
colorBlendAttachementState.colorBlendOp = VkFormats.VeldridToVkBlendOp(cacheKey.BlendState.ColorBlendFunction);
colorBlendAttachementState.srcAlphaBlendFactor = VkFormats.VeldridToVkBlendFactor(cacheKey.BlendState.SourceAlphaBlend);
colorBlendAttachementState.dstAlphaBlendFactor = VkFormats.VeldridToVkBlendFactor(cacheKey.BlendState.DestinationAlphaBlend);
colorBlendAttachementState.alphaBlendOp = VkFormats.VeldridToVkBlendOp(cacheKey.BlendState.AlphaBlendFunction);
VkPipelineColorBlendStateCreateInfo colorBlendStateCI = VkPipelineColorBlendStateCreateInfo.New();
if (cacheKey.Framebuffer.ColorTexture != null)
{
colorBlendStateCI.attachmentCount = 1;
colorBlendStateCI.pAttachments = &colorBlendAttachementState;
colorBlendStateCI.blendConstants_0 = cacheKey.BlendState.BlendFactor.R;
colorBlendStateCI.blendConstants_1 = cacheKey.BlendState.BlendFactor.G;
colorBlendStateCI.blendConstants_2 = cacheKey.BlendState.BlendFactor.B;
colorBlendStateCI.blendConstants_3 = cacheKey.BlendState.BlendFactor.A;
pipelineCI.pColorBlendState = &colorBlendStateCI;
}
// DepthStencilState
VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = VkPipelineDepthStencilStateCreateInfo.New();
depthStencilStateCI.depthCompareOp = VkFormats.VeldridToVkDepthComparison(cacheKey.DepthStencilState.DepthComparison);
depthStencilStateCI.depthWriteEnable = cacheKey.DepthStencilState.IsDepthWriteEnabled;
depthStencilStateCI.depthTestEnable = cacheKey.DepthStencilState.IsDepthEnabled;
pipelineCI.pDepthStencilState = &depthStencilStateCI;
// MultisampleState
VkPipelineMultisampleStateCreateInfo multisampleStateCI = VkPipelineMultisampleStateCreateInfo.New();
multisampleStateCI.rasterizationSamples = VkSampleCountFlags.Count1;
pipelineCI.pMultisampleState = &multisampleStateCI;
// RasterizationState
VkPipelineRasterizationStateCreateInfo rasterizationStateCI = ((VkRasterizerState)cacheKey.RasterizerState).RasterizerStateCreateInfo;
rasterizationStateCI.lineWidth = 1f;
pipelineCI.pRasterizationState = &rasterizationStateCI;
// ViewportState
VkPipelineViewportStateCreateInfo viewportStateCI = VkPipelineViewportStateCreateInfo.New();
viewportStateCI.viewportCount = 1;
viewportStateCI.scissorCount = 1;
pipelineCI.pViewportState = &viewportStateCI;
// InputAssemblyState
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = VkPipelineInputAssemblyStateCreateInfo.New();
inputAssemblyStateCI.topology = cacheKey.PrimitiveTopology;
pipelineCI.pInputAssemblyState = &inputAssemblyStateCI;
// VertexInputState
VkPipelineVertexInputStateCreateInfo vertexInputStateCI = VkPipelineVertexInputStateCreateInfo.New();
VertexInputDescription[] inputDescriptions = cacheKey.ShaderSet.InputLayout.InputDescriptions;
uint bindingCount = (uint)inputDescriptions.Length;
uint attributeCount = (uint)inputDescriptions.Sum(desc => desc.Elements.Length);
VkVertexInputBindingDescription * bindingDescs = stackalloc VkVertexInputBindingDescription[(int)bindingCount];
VkVertexInputAttributeDescription *attributeDescs = stackalloc VkVertexInputAttributeDescription[(int)attributeCount];
int targetIndex = 0;
int targetLocation = 0;
for (int binding = 0; binding < inputDescriptions.Length; binding++)
{
VertexInputDescription inputDesc = inputDescriptions[binding];
bindingDescs[targetIndex] = new VkVertexInputBindingDescription()
{
binding = (uint)binding,
inputRate = (inputDesc.Elements[0].StorageClassifier == VertexElementInputClass.PerInstance) ? VkVertexInputRate.Instance : VkVertexInputRate.Vertex,
stride = ((VkVertexBuffer)cacheKey.VertexBindings[binding]).Stride
};
uint currentOffset = 0;
for (int location = 0; location < inputDesc.Elements.Length; location++)
{
VertexInputElement inputElement = inputDesc.Elements[location];
attributeDescs[targetIndex] = new VkVertexInputAttributeDescription()
{
format = VkFormats.VeldridToVkVertexElementFormat(inputElement.ElementFormat),
binding = (uint)binding,
location = (uint)(targetLocation + location),
offset = currentOffset
};
targetIndex += 1;
currentOffset += inputElement.SizeInBytes;
}
targetLocation += inputDesc.Elements.Length;
}
vertexInputStateCI.vertexBindingDescriptionCount = bindingCount;
vertexInputStateCI.pVertexBindingDescriptions = bindingDescs;
vertexInputStateCI.vertexAttributeDescriptionCount = attributeCount;
vertexInputStateCI.pVertexAttributeDescriptions = attributeDescs;
pipelineCI.pVertexInputState = &vertexInputStateCI;
// ShaderStage
StackList <VkPipelineShaderStageCreateInfo> shaderStageCIs = new StackList <VkPipelineShaderStageCreateInfo>();
VkPipelineShaderStageCreateInfo vertexStage = VkPipelineShaderStageCreateInfo.New();
vertexStage.stage = VkShaderStageFlags.Vertex;
vertexStage.module = cacheKey.ShaderSet.VertexShader.ShaderModule;
vertexStage.pName = CommonStrings.main;
shaderStageCIs.Add(vertexStage);
VkPipelineShaderStageCreateInfo fragmentStage = VkPipelineShaderStageCreateInfo.New();
fragmentStage.stage = VkShaderStageFlags.Fragment;
fragmentStage.module = cacheKey.ShaderSet.FragmentShader.ShaderModule;
fragmentStage.pName = CommonStrings.main;
shaderStageCIs.Add(fragmentStage);
if (cacheKey.ShaderSet.TessellationControlShader != null)
{
VkPipelineShaderStageCreateInfo tcStage = VkPipelineShaderStageCreateInfo.New();
tcStage.stage = VkShaderStageFlags.TessellationControl;
tcStage.module = cacheKey.ShaderSet.TessellationControlShader.ShaderModule;
tcStage.pName = CommonStrings.main;
shaderStageCIs.Add(tcStage);
}
if (cacheKey.ShaderSet.TessellationEvaluationShader != null)
{
VkPipelineShaderStageCreateInfo teStage = VkPipelineShaderStageCreateInfo.New();
teStage.stage = VkShaderStageFlags.TessellationEvaluation;
teStage.module = cacheKey.ShaderSet.TessellationEvaluationShader.ShaderModule;
teStage.pName = CommonStrings.main;
shaderStageCIs.Add(teStage);
}
if (cacheKey.ShaderSet.GeometryShader != null)
{
VkPipelineShaderStageCreateInfo geometryStage = VkPipelineShaderStageCreateInfo.New();
geometryStage.stage = VkShaderStageFlags.Geometry;
geometryStage.module = cacheKey.ShaderSet.GeometryShader.ShaderModule;
geometryStage.pName = CommonStrings.main;
shaderStageCIs.Add(geometryStage);
}
pipelineCI.stageCount = shaderStageCIs.Count;
pipelineCI.pStages = (VkPipelineShaderStageCreateInfo *)shaderStageCIs.Data;
VkResult result = vkCreateGraphicsPipelines(_device, VkPipelineCache.Null, 1, ref pipelineCI, null, out VkPipeline ret);
CheckResult(result);
return(ret);
}
