public void SetBlendState(H1BlendStateDescription blendState, Int32 numRenderTargets)
{
BlendStateDescription blendStateRef = BlendStateDescription.Default();
blendStateRef.AlphaToCoverageEnable = blendState.AlphaToCoverageEnable;
blendStateRef.IndependentBlendEnable = blendState.IndependentBlendEnable;
for (Int32 i = 0; i < numRenderTargets; ++i)
{
RenderTargetBlendDescription rtBlendDescDest = blendStateRef.RenderTarget[i];
H1RenderTargetBlendDescription rtBlendDescSrc = blendState.RenderTargets[i];
rtBlendDescDest.IsBlendEnabled = rtBlendDescSrc.BlendEnable;
rtBlendDescDest.LogicOpEnable = rtBlendDescSrc.LogicOpEnable;
rtBlendDescDest.SourceBlend = H1RHIDefinitionHelper.ConvertToBlend(rtBlendDescSrc.SrcBlend);
rtBlendDescDest.DestinationBlend = H1RHIDefinitionHelper.ConvertToBlend(rtBlendDescSrc.DestBlend);
rtBlendDescDest.BlendOperation = H1RHIDefinitionHelper.ConvertToBlendOp(rtBlendDescSrc.BlendOp);
rtBlendDescDest.SourceAlphaBlend = H1RHIDefinitionHelper.ConvertToBlend(rtBlendDescSrc.SrcBlendAlpha);
rtBlendDescDest.DestinationAlphaBlend = H1RHIDefinitionHelper.ConvertToBlend(rtBlendDescSrc.DestBlendAlpha);
rtBlendDescDest.AlphaBlendOperation = H1RHIDefinitionHelper.ConvertToBlendOp(rtBlendDescSrc.BlendOpAlpha);
rtBlendDescDest.LogicOp = H1RHIDefinitionHelper.ConvertToLogicOp(rtBlendDescSrc.LogicOp);
rtBlendDescDest.RenderTargetWriteMask = H1RHIDefinitionHelper.ConvertToColorWriteMaskFlags(rtBlendDescSrc.RenderTargetWriteMask);
}
// newly assign the created blend state
m_GraphicsPipelineStateDesc.BlendState = blendStateRef;
}
public Boolean InitStaticSampler(Int32 register, H1SamplerDescription samplerDesc, ShaderVisibility visibility)
{
if (m_NumInitializedStaticSamplers > m_NumSamplers)
{
return(false); // there are no available to initialize static samplers
}
StaticSamplerDescription staticSamplerDesc = m_SamplerArray[m_NumInitializedStaticSamplers];
staticSamplerDesc = new StaticSamplerDescription(visibility, register, 0); // initialize static sampler description
staticSamplerDesc.Filter = H1RHIDefinitionHelper.ConvertToFilter(samplerDesc.Filter);
staticSamplerDesc.AddressU = H1RHIDefinitionHelper.ConvertToTextureAddressMode(samplerDesc.AddressU);
staticSamplerDesc.AddressV = H1RHIDefinitionHelper.ConvertToTextureAddressMode(samplerDesc.AddressV);
staticSamplerDesc.AddressW = H1RHIDefinitionHelper.ConvertToTextureAddressMode(samplerDesc.AddressW);
staticSamplerDesc.MipLODBias = samplerDesc.MipLODBias;
staticSamplerDesc.MaxAnisotropy = samplerDesc.MaxAnisotropy;
staticSamplerDesc.ComparisonFunc = H1RHIDefinitionHelper.ConvertToComparisonFunc(samplerDesc.ComparisonFunc);
staticSamplerDesc.BorderColor = StaticBorderColor.OpaqueWhite;
staticSamplerDesc.MinLOD = samplerDesc.MinLOD;
staticSamplerDesc.MaxLOD = samplerDesc.MaxLOD;
if (staticSamplerDesc.AddressU == TextureAddressMode.Border ||
staticSamplerDesc.AddressV == TextureAddressMode.Border ||
staticSamplerDesc.AddressW == TextureAddressMode.Border)
{
//@TODO - warning for the case, different border color with 'samplerDesc'
}
return(true);
}
public void SetDepthStencilState(H1DepthStencilDescription depthStencilDesc)
{
DepthStencilStateDescription newDepthStencilStateDesc = DepthStencilStateDescription.Default();
newDepthStencilStateDesc.IsDepthEnabled = depthStencilDesc.DepthEnable;
newDepthStencilStateDesc.DepthWriteMask = H1RHIDefinitionHelper.ConvertToDepthWriteMask(depthStencilDesc.DepthWriteMask);
newDepthStencilStateDesc.DepthComparison = H1RHIDefinitionHelper.ConvertToComparisonFunc(depthStencilDesc.DepthFunc);
newDepthStencilStateDesc.IsStencilEnabled = depthStencilDesc.StencilEnable;
newDepthStencilStateDesc.StencilReadMask = depthStencilDesc.StencilReadMask;
newDepthStencilStateDesc.StencilWriteMask = depthStencilDesc.StencilWriteMask;
newDepthStencilStateDesc.FrontFace = new DepthStencilOperationDescription();
newDepthStencilStateDesc.FrontFace.DepthFailOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.FrontFace.StencilDepthFailOp);
newDepthStencilStateDesc.FrontFace.FailOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.FrontFace.StencilFailOp);
newDepthStencilStateDesc.FrontFace.PassOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.FrontFace.StencilPassOp);
newDepthStencilStateDesc.FrontFace.Comparison = H1RHIDefinitionHelper.ConvertToComparisonFunc(depthStencilDesc.FrontFace.StencilFunc);
newDepthStencilStateDesc.BackFace = new DepthStencilOperationDescription();
newDepthStencilStateDesc.BackFace.DepthFailOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.BackFace.StencilDepthFailOp);
newDepthStencilStateDesc.BackFace.FailOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.BackFace.StencilFailOp);
newDepthStencilStateDesc.BackFace.PassOperation = H1RHIDefinitionHelper.ConvertToStencilOp(depthStencilDesc.BackFace.StencilPassOp);
newDepthStencilStateDesc.BackFace.Comparison = H1RHIDefinitionHelper.ConvertToComparisonFunc(depthStencilDesc.BackFace.StencilFunc);
m_GraphicsPipelineStateDesc.DepthStencilState = newDepthStencilStateDesc;
}
public void SetRasterizerState(H1RasterizerDescription rasterizerDesc)
{
RasterizerStateDescription newRasterizerStateDesc = RasterizerStateDescription.Default();
newRasterizerStateDesc.FillMode = H1RHIDefinitionHelper.ConvertToFillMode(rasterizerDesc.FillMode);
newRasterizerStateDesc.CullMode = H1RHIDefinitionHelper.ConvertToCullMode(rasterizerDesc.CullMode);
newRasterizerStateDesc.IsFrontCounterClockwise = rasterizerDesc.FrontCounterClockwise;
newRasterizerStateDesc.DepthBias = rasterizerDesc.DepthBias;
newRasterizerStateDesc.DepthBiasClamp = rasterizerDesc.DepthBiasClamp;
newRasterizerStateDesc.SlopeScaledDepthBias = rasterizerDesc.SlopeScaledDepthBias;
newRasterizerStateDesc.IsDepthClipEnabled = rasterizerDesc.DepthClipEnable;
newRasterizerStateDesc.IsMultisampleEnabled = rasterizerDesc.MultiSampleEnable;
newRasterizerStateDesc.IsAntialiasedLineEnabled = rasterizerDesc.AntialiasedLineEnable;
newRasterizerStateDesc.ForcedSampleCount = rasterizerDesc.ForcedSampleCount;
if (rasterizerDesc.ConservativeRasterMode == H1ConservativeRasterizationMode.On)
{
newRasterizerStateDesc.ConservativeRaster = ConservativeRasterizationMode.On;
}
else
{
newRasterizerStateDesc.ConservativeRaster = ConservativeRasterizationMode.Off;
}
// assign the newly created rasterizer state desc
m_GraphicsPipelineStateDesc.RasterizerState = newRasterizerStateDesc;
}
void ConstructPlatformDependentMembers(Int64 bufferLocation, H1PixelFormat format, Int32 sizeInBytes)
{
m_IBVDesc = new IndexBufferView()
{
BufferLocation = bufferLocation,
Format = H1RHIDefinitionHelper.ConvertToFormat(format),
SizeInBytes = sizeInBytes,
};
}
void ConstructPlatformDependentMembers()
{
m_Device = H1Global <H1ManagedRenderer> .Instance.Device;
m_CurrentHeap = null;
m_CurrentHandle.Ptr = null;
// set descriptor size
m_DescriptorSize = m_Device.GetDescriptorHandleIncrementSize(H1RHIDefinitionHelper.ConvertToDescriptorHeapType(m_HeapType));
}
public void SetRenderTargetFormats(H1PixelFormat[] rtvFormats, H1PixelFormat dsvFormat, Int32 msaaCount, Int32 msaaQuality)
{
for (Int32 i = 0; i < rtvFormats.Count(); ++i)
{
m_GraphicsPipelineStateDesc.RenderTargetFormats[i] = H1RHIDefinitionHelper.ConvertToFormat(rtvFormats[i]);
}
for (Int32 i = rtvFormats.Count(); i < m_GraphicsPipelineStateDesc.RenderTargetCount; ++i)
{
m_GraphicsPipelineStateDesc.RenderTargetFormats[i] = SharpDX.DXGI.Format.Unknown;
}
m_GraphicsPipelineStateDesc.RenderTargetCount = rtvFormats.Count();
m_GraphicsPipelineStateDesc.DepthStencilFormat = H1RHIDefinitionHelper.ConvertToFormat(dsvFormat);
m_GraphicsPipelineStateDesc.SampleDescription.Count = msaaCount;
m_GraphicsPipelineStateDesc.SampleDescription.Quality = msaaQuality;
}
public H1InputLayout(H1VertexStream[] streams)
{
foreach (H1VertexStream stream in streams)
{
H1InputElementDescription inputElement = new H1InputElementDescription();
inputElement.SemanticName = stream.SemanticName;
inputElement.SemanticIndex = stream.SemanticIndex;
inputElement.Format = H1RHIDefinitionHelper.ConvertToPixelFormat(stream.VertexElementType);
inputElement.InputSlot = Convert.ToInt32(stream.Offset);
m_InputElements.Add(inputElement);
}
// create platform-dependent input-layout
CreateInputLayout();
}
static void CreatePlatformDependent(Vector4 clearValue, H1Texture2D.Description desc, H1SubresourceData initialData, ref H1GpuTexture2D result)
{
// get device for directX 12
Device deviceDX12 = H1Global <H1ManagedRenderer> .Instance.Device;
H1GpuResourceDesc desc12 = H1RHIDefinitionHelper.Texture2DDescToGpuResourceDesc(desc);
H1HeapType heapType = H1RHIDefinitionHelper.GetHeapTypeFromTexture2DDesc(desc);
H1ResourceStates resourceStates = H1RHIDefinitionHelper.GetResourceStatesFromTexture2DDesc(desc);
// generate resource
//if (result != null)
// result.Resource.CreateResource(heapType, desc12, resourceStates);
// generate RHI resource description (need resource description for generating UAV or SRV or etc.)
result.CreateResourceDescription(desc12);
}
public static ResourceDescription ConvertToResourceDescDx12(H1GpuResourceDesc resourceDesc)
{
ResourceDescription result = new ResourceDescription();
result.Dimension = (ResourceDimension)DimensionMapper[Convert.ToInt32(resourceDesc.Dimension)];
result.Alignment = resourceDesc.Alignment;
result.Width = resourceDesc.Width;
result.Height = Convert.ToInt32(resourceDesc.Height);
result.MipLevels = Convert.ToInt16(resourceDesc.MipLevels);
result.SampleDescription.Count = Convert.ToInt32(resourceDesc.SampleDesc.Count);
result.SampleDescription.Quality = Convert.ToInt32(resourceDesc.SampleDesc.Quality);
result.Format = H1RHIDefinitionHelper.ConvertToFormat(resourceDesc.Format);
result.Flags = (ResourceFlags)ResourceFlagsMapper[Convert.ToInt32(resourceDesc.Flags)];
result.DepthOrArraySize = Convert.ToInt16(resourceDesc.DepthOrArraySize);
return(result);
}
public virtual Boolean CreateResourceDescription(H1GpuResourceDesc desc)
{
// API level specific resource description
m_Description.Alignment = desc.Alignment;
m_Description.DepthOrArraySize = Convert.ToInt16(desc.DepthOrArraySize);
m_Description.Dimension = (ResourceDimension)H1GpuResource.DimensionMapper[Convert.ToInt32(desc.Dimension)];
m_Description.Flags = H1RHIDefinitionHelper.FormatToResourceFlags(desc.Flags);
m_Description.Format = H1RHIDefinitionHelper.ConvertToFormat(desc.Format);
m_Description.Width = Convert.ToInt32(desc.Width);
m_Description.Height = Convert.ToInt32(desc.Height);
m_Description.Layout = (TextureLayout)H1GpuResource.TextureLayoutMapper[Convert.ToInt32(desc.Layout)];
m_Description.MipLevels = Convert.ToInt16(desc.MipLevels);
m_Description.SampleDescription.Count = Convert.ToInt32(desc.SampleDesc.Count);
m_Description.SampleDescription.Quality = Convert.ToInt32(desc.SampleDesc.Quality);
return(true);
}
Int32 CreateResourcePlatformDependent(H1HeapType heapType, H1GpuResourceDesc resourceDesc, H1ResourceStates defaultUsage)
{
HeapProperties heapProps = new HeapProperties();
heapProps.CPUPageProperty = CpuPageProperty.Unknown;
heapProps.MemoryPoolPreference = MemoryPool.Unknown;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
// convert to H1HeapType to HeapType for dx12
switch (heapType)
{
case H1HeapType.Default:
heapProps.Type = HeapType.Default;
break;
case H1HeapType.Readback:
heapProps.Type = HeapType.Readback;
break;
case H1HeapType.Upload:
heapProps.Type = HeapType.Upload;
break;
}
// convert H1ResourceDesc to ResourceDesc for dx12
ResourceDescription resourceDescDX12 = ConvertToResourceDescDx12(resourceDesc);
ResourceStates defaultStates = (ResourceStates)ResourceStateMapper[Convert.ToInt32(defaultUsage)];
Device deviceDX11 = H1Global <H1ManagedRenderer> .Instance.Device;
m_GpuResource = deviceDX11.CreateCommittedResource(heapProps, HeapFlags.None, resourceDescDX12, defaultStates);
Int32 elementSize = Convert.ToInt32(H1RHIDefinitionHelper.ElementTypeToSize(resourceDesc.Format));
if (elementSize == 0)
{
throw new InvalidOperationException("there is no appropriate format is implemented in ElementTypeToSize()!");
}
Int32 totalSizeInBytes = elementSize * Convert.ToInt32(resourceDesc.Width * resourceDesc.Height * resourceDesc.DepthOrArraySize);
return(totalSizeInBytes);
}
public Boolean SetInputLayout(H1InputLayout inputLayout)
{
List <InputElement> inputElements = new List <InputElement>();
foreach (H1InputElementDescription element in inputLayout.InputElements)
{
InputElement inputElement = new InputElement();
inputElement.SemanticName = element.SemanticName;
inputElement.SemanticIndex = element.SemanticIndex;
inputElement.Format = H1RHIDefinitionHelper.ConvertToFormat(element.Format);
inputElement.Slot = element.InputSlot;
inputElements.Add(inputElement);
}
m_GraphicsPipelineStateDesc.InputLayout = new InputLayoutDescription(inputElements.ToArray());
return(true);
}
protected DescriptorHeap RequestNewHeap(H1DescriptorHeapType type)
{
DescriptorHeapType typeInDX12 = H1RHIDefinitionHelper.ConvertToDescriptorHeapType(type);
// @TODO - need to be thread-safe
DescriptorHeapDescription desc = new DescriptorHeapDescription();
desc.Type = typeInDX12;
desc.DescriptorCount = NumDescriptorsPerHeap;
// this part is none, but for usage in command context, you need to create new descriptor for shader-visible by UserDescriptorHeap or DynamicDescriptorHeap
desc.Flags = DescriptorHeapFlags.None;
desc.NodeMask = 1;
DescriptorHeap newHeap = m_Device.CreateDescriptorHeap(desc);
m_DescriptorHeapPool.Add(newHeap);
return(newHeap);
}
void CreateInputLayout()
{
// @TODO - need to modify input element description from H1VertexStream
// platform-specific implementation
List <InputElement> inputElements = new List <InputElement>();
foreach (var stream in m_InputElements)
{
InputElement element = new InputElement();
element.SemanticName = stream.SemanticName;
element.SemanticIndex = stream.SemanticIndex;
element.Format = H1RHIDefinitionHelper.ConvertToFormat(stream.Format);
// watch out - I use multiple vertex buffer instead of big vertex buffer indicating by alignbyteoffset
element.Slot = stream.InputSlot;
inputElements.Add(element);
}
// create input layout based on the resultant list of input elements
m_InputLayoutDesc = new InputLayoutDescription(inputElements.ToArray());
}
public override Boolean CreateView()
{
// the description is in invalid state, please check
if (!m_bHasDesc)
{
return(false);
}
// get the device
Device deviceDX12 = H1Global <H1ManagedRenderer> .Instance.Device;
// get the descriptor handle
if (m_DescriptorHandle.Ptr == null)
{
m_DescriptorHandle = H1Global <H1ManagedRenderer> .Instance.Gen2Layer.AllocateDescriptor(H1DescriptorHeapType.ConstantBufferView_ShaderResourceView_UnorderedAccessView);
}
// convert platform-independent description to platform-dependent description
m_SRVDesc.Format = H1RHIDefinitionHelper.ConvertToFormat(m_Description.Format);
m_SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
// depending on view dimension types, create the corresponding description
switch (m_Description.ViewDimension)
{
case H1ShaderResourceViewDimension.Buffer:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Buffer;
// if the buffer description is not filled up, invalid description
if (m_Description.Buffer == null)
{
return(false);
}
m_SRVDesc.Buffer.FirstElement = m_Description.Buffer.FirstElement;
m_SRVDesc.Buffer.ElementCount = m_Description.Buffer.NumElement;
m_SRVDesc.Buffer.StructureByteStride = m_Description.Buffer.StructuredByteStride;
switch (m_Description.Buffer.Flags)
{
case H1BufferShaderResourceViewFlags.None:
m_SRVDesc.Buffer.Flags = BufferShaderResourceViewFlags.None;
break;
case H1BufferShaderResourceViewFlags.Raw:
m_SRVDesc.Buffer.Flags = BufferShaderResourceViewFlags.Raw;
break;
}
break;
}
case H1ShaderResourceViewDimension.Texture1D:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Texture1D;
if (m_Description.Texture1D == null)
{
return(false);
}
m_SRVDesc.Texture1D.MostDetailedMip = m_Description.Texture1D.MostDetailedMip;
m_SRVDesc.Texture1D.MipLevels = m_Description.Texture1D.MipLevels;
m_SRVDesc.Texture1D.ResourceMinLODClamp = m_Description.Texture1D.ResourceMinLODClamp;
break;
}
case H1ShaderResourceViewDimension.Texture1DArray:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Texture1DArray;
if (m_Description.Texture1DArray == null)
{
return(false);
}
m_SRVDesc.Texture1DArray.MostDetailedMip = m_Description.Texture1DArray.MostDetailedMip;
m_SRVDesc.Texture1DArray.MipLevels = m_Description.Texture1DArray.MipLevels;
m_SRVDesc.Texture1DArray.FirstArraySlice = m_Description.Texture1DArray.FirstArraySlice;
m_SRVDesc.Texture1DArray.ArraySize = m_Description.Texture1DArray.ArraySize;
m_SRVDesc.Texture1DArray.ResourceMinLODClamp = m_Description.Texture1DArray.ResourceMinLODClamp;
break;
}
case H1ShaderResourceViewDimension.Texture2D:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Texture2D;
if (m_Description.Texture2D == null)
{
return(false);
}
m_SRVDesc.Texture2D.MostDetailedMip = m_Description.Texture2D.MostDetailedMip;
m_SRVDesc.Texture2D.MipLevels = m_Description.Texture2D.MipLevels;
m_SRVDesc.Texture2D.PlaneSlice = m_Description.Texture2D.PlaneSlice;
m_SRVDesc.Texture2D.ResourceMinLODClamp = m_Description.Texture2D.ResourceMinLODClamp;
break;
}
case H1ShaderResourceViewDimension.Texture2DArray:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Texture2DArray;
if (m_Description.Texture2DArray == null)
{
return(false);
}
m_SRVDesc.Texture2DArray.MostDetailedMip = m_Description.Texture2DArray.MostDetailedMip;
m_SRVDesc.Texture2DArray.MipLevels = m_Description.Texture2DArray.MipLevels;
m_SRVDesc.Texture2DArray.PlaneSlice = m_Description.Texture2DArray.PlaneSlice;
m_SRVDesc.Texture2DArray.ResourceMinLODClamp = m_Description.Texture2DArray.ResourceMinLODClamp;
m_SRVDesc.Texture2DArray.FirstArraySlice = m_Description.Texture2DArray.FirstArraySlice;
m_SRVDesc.Texture2DArray.ArraySize = m_Description.Texture2DArray.ArraySize;
break;
}
case H1ShaderResourceViewDimension.Texture3D:
{
m_SRVDesc.Dimension = ShaderResourceViewDimension.Texture3D;
if (m_Description.Texture3D == null)
{
return(false);
}
m_SRVDesc.Texture3D.MostDetailedMip = m_Description.Texture3D.MostDetailedMip;
m_SRVDesc.Texture3D.MipLevels = m_Description.Texture3D.MipLevels;
m_SRVDesc.Texture3D.ResourceMinLODClamp = m_Description.Texture3D.ResourceMinLODClamp;
break;
}
default:
// @TODO - not implemented yet!
return(false);
}
// create view descriptor
deviceDX12.CreateShaderResourceView(m_ResourceRef.GpuResource, m_SRVDesc, m_DescriptorHandle);
return(true);
}
public override Boolean CreateView()
{
// the description is in invalid state, please check
if (!m_bHasDesc)
{
return(false);
}
// get the device
Device deviceDX12 = H1Global <H1ManagedRenderer> .Instance.Device;
// get the descriptor handle
if (m_DescriptorHandle.Ptr == null)
{
m_DescriptorHandle = H1Global <H1ManagedRenderer> .Instance.Gen2Layer.AllocateDescriptor(H1DescriptorHeapType.ConstantBufferView_ShaderResourceView_UnorderedAccessView);
}
// convert platform-independent description to platform-dependent description
m_RTVDesc.Format = H1RHIDefinitionHelper.ConvertToFormat(m_Description.Format);
// depending on view dimension types, create the corresponding description
switch (m_Description.ViewDimension)
{
case H1RenderTargetViewDimension.Buffer:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Buffer;
// if the buffer description is not filled up, invalid description
if (m_Description.Buffer == null)
{
return(false);
}
m_RTVDesc.Buffer.FirstElement = m_Description.Buffer.FirstElement;
m_RTVDesc.Buffer.ElementCount = m_Description.Buffer.NumElements;
break;
}
case H1RenderTargetViewDimension.Texture1D:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Texture1D;
if (m_Description.Texture1D == null)
{
return(false);
}
m_RTVDesc.Texture1D.MipSlice = m_Description.Texture1D.MipSlice;
break;
}
case H1RenderTargetViewDimension.Texture1DArray:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Texture1DArray;
if (m_Description.Texture1DArray == null)
{
return(false);
}
m_RTVDesc.Texture1DArray.MipSlice = m_Description.Texture1DArray.MipSlice;
m_RTVDesc.Texture1DArray.FirstArraySlice = m_Description.Texture1DArray.FirstArraySlice;
m_RTVDesc.Texture1DArray.ArraySize = m_Description.Texture1DArray.ArraySize;
break;
}
case H1RenderTargetViewDimension.Texture2D:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Texture2D;
if (m_Description.Texture2D == null)
{
return(false);
}
m_RTVDesc.Texture2D.MipSlice = m_Description.Texture2D.MipSlice;
m_RTVDesc.Texture2D.PlaneSlice = m_Description.Texture2D.PlaneSlice;
break;
}
case H1RenderTargetViewDimension.Texture2DArray:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
if (m_Description.Texture2DArray == null)
{
return(false);
}
m_RTVDesc.Texture2DArray.MipSlice = m_Description.Texture2DArray.MipSlice;
m_RTVDesc.Texture2DArray.PlaneSlice = m_Description.Texture2DArray.PlaneSlice;
m_RTVDesc.Texture2DArray.FirstArraySlice = m_Description.Texture2DArray.FirstArraySlice;
m_RTVDesc.Texture2DArray.ArraySize = m_Description.Texture2DArray.ArraySize;
break;
}
case H1RenderTargetViewDimension.Texture3D:
{
m_RTVDesc.Dimension = RenderTargetViewDimension.Texture3D;
if (m_Description.Texture3D == null)
{
return(false);
}
m_RTVDesc.Texture3D.MipSlice = m_Description.Texture3D.MipSlice;
m_RTVDesc.Texture3D.FirstDepthSlice = m_Description.Texture3D.FirstWSlice;
m_RTVDesc.Texture3D.DepthSliceCount = m_Description.Texture3D.WSize;
break;
}
default:
// @TODO - not implemented yet!
return(false);
}
// create view descriptor
deviceDX12.CreateRenderTargetView(m_ResourceRef.GpuResource, m_RTVDesc, m_DescriptorHandle);
return(true);
}
public static H1DX12Texture2D Create(Device device, Vector4 clearValue, H1Texture2D.Description desc, H1SubresourceData[] initialData)
{
// converting description to DX12 description
ResourceDescription desc12 = new ResourceDescription
{
Format = H1RHIDefinitionHelper.ConvertToFormat(desc.Format),
Width = Convert.ToInt32(desc.Width),
Height = Convert.ToInt32(desc.Height),
DepthOrArraySize = Convert.ToInt16(desc.ArraySize),
MipLevels = Convert.ToInt16(desc.MipLevels),
Flags = ResourceFlags.None,
Layout = TextureLayout.Unknown,
Dimension = ResourceDimension.Texture2D,
};
desc12.SampleDescription.Count = Convert.ToInt32(desc.SampleDesc.Count);
desc12.SampleDescription.Quality = Convert.ToInt32(desc.SampleDesc.Quality);
HeapProperties heapProperties = new HeapProperties(HeapType.Default);
ResourceStates resourceUsage = ResourceStates.CopyDestination;
ClearValue value = H1GlobalDX12Definitions.GetDXGIFormatClearValue(desc12.Format, (desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0);
Boolean allowClearValue = desc12.Dimension == ResourceDimension.Buffer;
if (desc.Usage == H1Usage.Immutable)
{
heapProperties = new HeapProperties(HeapType.Default);
resourceUsage = ResourceStates.CopyDestination;
}
else if (desc.Usage == H1Usage.Staging)
{
heapProperties = new HeapProperties(HeapType.Readback);
resourceUsage = ResourceStates.CopyDestination;
}
else if (desc.Usage == H1Usage.Dynamic)
{
heapProperties = new HeapProperties(HeapType.Upload);
resourceUsage = ResourceStates.GenericRead;
}
if (desc.CPUAccessFlags != 0)
{
if (desc.CPUAccessFlags == Convert.ToUInt32(H1CPUAccessFlag.Write))
{
heapProperties = new HeapProperties(HeapType.Upload);
resourceUsage = ResourceStates.GenericRead;
}
else if (desc.CPUAccessFlags == Convert.ToUInt32(H1CPUAccessFlag.Read))
{
heapProperties = new HeapProperties(HeapType.Readback);
resourceUsage = ResourceStates.CopyDestination;
}
else
{
return(null);
}
}
if (clearValue != null)
{
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0)
{
value.DepthStencil.Depth = clearValue.X;
value.DepthStencil.Stencil = Convert.ToByte(clearValue.Y);
}
else
{
value.Color = clearValue;
}
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.UnorderedAccess)) != 0)
{
desc12.Flags |= ResourceFlags.AllowUnorderedAccess;
resourceUsage = ResourceStates.UnorderedAccess;
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0)
{
desc12.Flags |= ResourceFlags.AllowDepthStencil;
allowClearValue = true;
resourceUsage = ResourceStates.DepthWrite;
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.RenderTarget)) != 0)
{
desc12.Flags |= ResourceFlags.AllowRenderTarget;
allowClearValue = true;
resourceUsage = ResourceStates.RenderTarget;
}
Resource resource = device.CreateCommittedResource(
heapProperties,
HeapFlags.None,
desc12,
resourceUsage,
allowClearValue ? value : default(ClearValue?));
H1DX12Texture2D newTexture = new H1DX12Texture2D();
newTexture.m_Resource = new H1DX12Resource(resource, resourceUsage, resource.Description, initialData, Convert.ToUInt32(desc12.DepthOrArraySize * desc12.MipLevels));
return(newTexture);
}
public void SetPrimitiveTopologyType(H1PrimitiveTopologyType primitiveTopologyType)
{
m_GraphicsPipelineStateDesc.PrimitiveTopologyType = H1RHIDefinitionHelper.ConvertToPrimitiveTopologyType(primitiveTopologyType);
}
