1992 lines
58 KiB
Plaintext
1992 lines
58 KiB
Plaintext
import slang;
|
|
|
|
public namespace gfx
|
|
{
|
|
public typedef slang.Result Result;
|
|
|
|
public typedef intptr_t Int;
|
|
public typedef uintptr_t UInt;
|
|
public typedef uint64_t DeviceAddress;
|
|
public typedef int GfxIndex;
|
|
public typedef int GfxCount;
|
|
public typedef intptr_t Size;
|
|
public typedef intptr_t Offset;
|
|
|
|
public static const uint64_t kTimeoutInfinite = 0xFFFFFFFFFFFFFFFF;
|
|
|
|
public enum class StructType
|
|
{
|
|
D3D12ExtendedDesc,
|
|
};
|
|
|
|
public enum class StageType
|
|
{
|
|
Unknown,
|
|
Vertex,
|
|
Hull,
|
|
Domain,
|
|
Geometry,
|
|
Fragment,
|
|
Compute,
|
|
RayGeneration,
|
|
Intersection,
|
|
AnyHit,
|
|
ClosestHit,
|
|
Miss,
|
|
Callable,
|
|
Amplification,
|
|
Mesh,
|
|
CountOf,
|
|
};
|
|
|
|
public enum class DeviceType
|
|
{
|
|
Unknown,
|
|
Default,
|
|
DirectX11,
|
|
DirectX12,
|
|
OpenGl,
|
|
Vulkan,
|
|
Metal,
|
|
CPU,
|
|
CUDA,
|
|
CountOf,
|
|
};
|
|
|
|
public enum class ProjectionStyle
|
|
{
|
|
Unknown,
|
|
OpenGl,
|
|
DirectX,
|
|
Vulkan,
|
|
Metal,
|
|
CountOf,
|
|
};
|
|
|
|
public enum class BindingStyle
|
|
{
|
|
Unknown,
|
|
DirectX,
|
|
OpenGl,
|
|
Vulkan,
|
|
Metal,
|
|
CPU,
|
|
CUDA,
|
|
CountOf,
|
|
};
|
|
|
|
public enum class AccessFlag
|
|
{
|
|
None,
|
|
Read,
|
|
Write,
|
|
};
|
|
|
|
public static const GfxCount kMaxRenderTargetCount = 8;
|
|
|
|
// Defines how linking should be performed for a shader program.
|
|
public enum class LinkingStyle
|
|
{
|
|
// Compose all entry-points in a single program, then compile all entry-points together with the same
|
|
// set of root shader arguments.
|
|
SingleProgram,
|
|
|
|
// Link and compile each entry-point individually, potentially with different specializations.
|
|
SeparateEntryPointCompilation
|
|
};
|
|
|
|
public enum class ShaderModuleSourceType
|
|
{
|
|
SlangSource, // a slang source string in memory.
|
|
SlangModuleBinary, // a slang module binary code in memory.
|
|
SlangSourceFile, // a slang source from file.
|
|
SlangModuleBinaryFile, // a slang module binary code from file.
|
|
};
|
|
|
|
public struct ShaderProgramDesc2
|
|
{
|
|
public ShaderModuleSourceType sourceType = ShaderModuleSourceType::SlangSource;
|
|
public void *sourceData = nullptr;
|
|
public Size sourceDataSize = 0;
|
|
|
|
// Number of entry points to include in the shader program. 0 means include all entry points
|
|
// defined in the module.
|
|
public GfxCount entryPointCount = 0;
|
|
// Names of entry points to include in the shader program. The size of the array must be
|
|
// `entryPointCount`.
|
|
public NativeString* entryPointNames = nullptr;
|
|
};
|
|
|
|
[COM("9d32d0ad-915c-4ffd-91e2-508554a04a76")]
|
|
public interface IShaderProgram
|
|
{
|
|
public slang::TypeReflection* findTypeByName(NativeString name);
|
|
};
|
|
|
|
public enum class Format
|
|
{
|
|
// D3D formats omitted: 19-22, 44-47, 65-66, 68-70, 73, 76, 79, 82, 88-89, 92-94, 97, 100-114
|
|
// These formats are omitted due to lack of a corresponding Vulkan format. D24_UNORM_S8_UINT (DXGI_FORMAT 45)
|
|
// has a matching Vulkan format but is also omitted as it is only supported by Nvidia.
|
|
Unknown,
|
|
|
|
R32G32B32A32_TYPELESS,
|
|
R32G32B32_TYPELESS,
|
|
R32G32_TYPELESS,
|
|
R32_TYPELESS,
|
|
|
|
R16G16B16A16_TYPELESS,
|
|
R16G16_TYPELESS,
|
|
R16_TYPELESS,
|
|
|
|
R8G8B8A8_TYPELESS,
|
|
R8G8_TYPELESS,
|
|
R8_TYPELESS,
|
|
B8G8R8A8_TYPELESS,
|
|
|
|
R32G32B32A32_FLOAT,
|
|
R32G32B32_FLOAT,
|
|
R32G32_FLOAT,
|
|
R32_FLOAT,
|
|
|
|
R16G16B16A16_FLOAT,
|
|
R16G16_FLOAT,
|
|
R16_FLOAT,
|
|
|
|
R64_UINT,
|
|
|
|
R32G32B32A32_UINT,
|
|
R32G32B32_UINT,
|
|
R32G32_UINT,
|
|
R32_UINT,
|
|
|
|
R16G16B16A16_UINT,
|
|
R16G16_UINT,
|
|
R16_UINT,
|
|
|
|
R8G8B8A8_UINT,
|
|
R8G8_UINT,
|
|
R8_UINT,
|
|
|
|
R64_SINT,
|
|
|
|
R32G32B32A32_SINT,
|
|
R32G32B32_SINT,
|
|
R32G32_SINT,
|
|
R32_SINT,
|
|
|
|
R16G16B16A16_SINT,
|
|
R16G16_SINT,
|
|
R16_SINT,
|
|
|
|
R8G8B8A8_SINT,
|
|
R8G8_SINT,
|
|
R8_SINT,
|
|
|
|
R16G16B16A16_UNORM,
|
|
R16G16_UNORM,
|
|
R16_UNORM,
|
|
|
|
R8G8B8A8_UNORM,
|
|
R8G8B8A8_UNORM_SRGB,
|
|
R8G8_UNORM,
|
|
R8_UNORM,
|
|
B8G8R8A8_UNORM,
|
|
B8G8R8A8_UNORM_SRGB,
|
|
B8G8R8X8_UNORM,
|
|
B8G8R8X8_UNORM_SRGB,
|
|
|
|
R16G16B16A16_SNORM,
|
|
R16G16_SNORM,
|
|
R16_SNORM,
|
|
|
|
R8G8B8A8_SNORM,
|
|
R8G8_SNORM,
|
|
R8_SNORM,
|
|
|
|
D32_FLOAT,
|
|
D16_UNORM,
|
|
|
|
B4G4R4A4_UNORM,
|
|
B5G6R5_UNORM,
|
|
B5G5R5A1_UNORM,
|
|
|
|
R9G9B9E5_SHAREDEXP,
|
|
R10G10B10A2_TYPELESS,
|
|
R10G10B10A2_UNORM,
|
|
R10G10B10A2_UINT,
|
|
R11G11B10_FLOAT,
|
|
|
|
BC1_UNORM,
|
|
BC1_UNORM_SRGB,
|
|
BC2_UNORM,
|
|
BC2_UNORM_SRGB,
|
|
BC3_UNORM,
|
|
BC3_UNORM_SRGB,
|
|
BC4_UNORM,
|
|
BC4_SNORM,
|
|
BC5_UNORM,
|
|
BC5_SNORM,
|
|
BC6H_UF16,
|
|
BC6H_SF16,
|
|
BC7_UNORM,
|
|
BC7_UNORM_SRGB,
|
|
|
|
_Count,
|
|
};
|
|
|
|
public struct FormatInfo
|
|
{
|
|
public GfxCount channelCount; ///< The amount of channels in the format. Only set if the channelType is set
|
|
public uint8_t channelType; ///< One of SlangScalarType None if type isn't made up of elements of type. TODO: Change to uint32_t?
|
|
|
|
public Size blockSizeInBytes; ///< The size of a block in bytes.
|
|
public GfxCount pixelsPerBlock; ///< The number of pixels contained in a block.
|
|
public GfxCount blockWidth; ///< The width of a block in pixels.
|
|
public GfxCount blockHeight; ///< The height of a block in pixels.
|
|
};
|
|
|
|
public enum class InputSlotClass
|
|
{
|
|
PerVertex, PerInstance
|
|
};
|
|
|
|
public struct InputElementDesc
|
|
{
|
|
public NativeString semanticName; ///< The name of the corresponding parameter in shader code.
|
|
public GfxIndex semanticIndex; ///< The index of the corresponding parameter in shader code. Only needed if multiple parameters share a semantic name.
|
|
public Format format; ///< The format of the data being fetched for this element.
|
|
public Offset offset; ///< The offset in bytes of this element from the start of the corresponding chunk of vertex stream data.
|
|
public GfxIndex bufferSlotIndex; ///< The index of the vertex stream to fetch this element's data from.
|
|
};
|
|
|
|
public struct VertexStreamDesc
|
|
{
|
|
public Size stride; ///< The stride in bytes for this vertex stream.
|
|
public InputSlotClass slotClass; ///< Whether the stream contains per-vertex or per-instance data.
|
|
public GfxCount instanceDataStepRate; ///< How many instances to draw per chunk of data.
|
|
};
|
|
|
|
public enum class PrimitiveType
|
|
{
|
|
Point, Line, Triangle, Patch
|
|
};
|
|
|
|
public enum class PrimitiveTopology
|
|
{
|
|
TriangleList, TriangleStrip, PointList, LineList, LineStrip
|
|
};
|
|
|
|
public enum class ResourceState
|
|
{
|
|
Undefined,
|
|
General,
|
|
PreInitialized,
|
|
VertexBuffer,
|
|
IndexBuffer,
|
|
ConstantBuffer,
|
|
StreamOutput,
|
|
ShaderResource,
|
|
UnorderedAccess,
|
|
RenderTarget,
|
|
DepthRead,
|
|
DepthWrite,
|
|
Present,
|
|
IndirectArgument,
|
|
CopySource,
|
|
CopyDestination,
|
|
ResolveSource,
|
|
ResolveDestination,
|
|
AccelerationStructure,
|
|
AccelerationStructureBuildInput,
|
|
_Count
|
|
};
|
|
|
|
public struct ResourceStateSet
|
|
{
|
|
public uint64_t m_bitFields;
|
|
|
|
[mutating]
|
|
public void add(ResourceState state) { m_bitFields |= (1LL << (uint32_t)state); }
|
|
|
|
public bool contains(ResourceState state) { return (m_bitFields & (1LL << (uint32_t)state)) != 0; }
|
|
public __init() { m_bitFields = 0; }
|
|
public __init(ResourceState state) { add(state); }
|
|
};
|
|
|
|
public ResourceStateSet operator &(ResourceStateSet val, ResourceStateSet that)
|
|
{
|
|
ResourceStateSet result;
|
|
result.m_bitFields = val.m_bitFields & that.m_bitFields;
|
|
return result;
|
|
}
|
|
|
|
/// Describes how memory for the resource should be allocated for CPU access.
|
|
public enum class MemoryType
|
|
{
|
|
DeviceLocal,
|
|
Upload,
|
|
ReadBack,
|
|
};
|
|
|
|
public enum class InteropHandleAPI
|
|
{
|
|
Unknown,
|
|
D3D12, // A D3D12 object pointer.
|
|
Vulkan, // A general Vulkan object handle.
|
|
CUDA, // A general CUDA object handle.
|
|
Win32, // A general Win32 HANDLE.
|
|
FileDescriptor, // A file descriptor.
|
|
DeviceAddress, // A device address.
|
|
D3D12CpuDescriptorHandle, // A D3D12_CPU_DESCRIPTOR_HANDLE value.
|
|
Metal, // A general Metal object handle.
|
|
};
|
|
|
|
public struct InteropHandle
|
|
{
|
|
public InteropHandleAPI api = InteropHandleAPI::Unknown;
|
|
public uint64_t handleValue = 0LLU;
|
|
};
|
|
|
|
// Declare opaque type
|
|
public struct InputLayoutDesc
|
|
{
|
|
public InputElementDesc *inputElements;
|
|
public GfxCount inputElementCount;
|
|
public VertexStreamDesc *vertexStreams;
|
|
public GfxCount vertexStreamCount;
|
|
};
|
|
|
|
[COM("45223711-a84b-455c-befa-4937421e8e2e")]
|
|
public interface IInputLayout
|
|
{
|
|
};
|
|
|
|
/// The type of resource.
|
|
/// NOTE! The order needs to be such that all texture types are at or after Texture1D (otherwise isTexture won't work correctly)
|
|
public enum class ResourceType
|
|
{
|
|
Unknown, ///< Unknown
|
|
Buffer, ///< A buffer (like a constant/index/vertex buffer)
|
|
Texture1D, ///< A 1d texture
|
|
Texture2D, ///< A 2d texture
|
|
Texture3D, ///< A 3d texture
|
|
TextureCube, ///< A cubemap consists of 6 Texture2D like faces
|
|
_Count,
|
|
};
|
|
|
|
/// Base class for Descs
|
|
public struct ResourceDescBase
|
|
{
|
|
public ResourceType type = ResourceType::Unknown;
|
|
public ResourceState defaultState = ResourceState::Undefined;
|
|
public ResourceStateSet allowedStates = {};
|
|
public MemoryType memoryType = MemoryType::DeviceLocal;
|
|
public InteropHandle existingHandle = {};
|
|
public bool isShared = false;
|
|
};
|
|
|
|
[COM("a0e39f34-8398-4522-95c2-ebc0f984ef3f")]
|
|
public interface IResource
|
|
{
|
|
public ResourceType getType();
|
|
public Result getNativeResourceHandle(out InteropHandle outHandle);
|
|
public Result getSharedHandle(out InteropHandle outHandle);
|
|
public Result setDebugName(NativeString name);
|
|
public NativeString getDebugName();
|
|
};
|
|
|
|
public struct MemoryRange
|
|
{
|
|
// TODO: Change to Offset/Size?
|
|
public uint64_t offset;
|
|
public uint64_t size;
|
|
};
|
|
|
|
public struct BufferResourceDesc : ResourceDescBase
|
|
{
|
|
public Size sizeInBytes = 0; ///< Total size in bytes
|
|
public Size elementSize = 0; ///< Get the element stride. If > 0, this is a structured buffer
|
|
public Format format = Format::Unknown;
|
|
};
|
|
|
|
[COM("1b274efe-5e37-492b-826e-7ee7e8f5a49b")]
|
|
public interface IBufferResource : IResource
|
|
{
|
|
public BufferResourceDesc *getDesc();
|
|
public DeviceAddress getDeviceAddress();
|
|
public Result map(MemoryRange *rangeToRead, void **outPointer);
|
|
public Result unmap(MemoryRange* writtenRange);
|
|
};
|
|
|
|
public struct DepthStencilClearValue
|
|
{
|
|
public float depth = 1.0f;
|
|
public uint32_t stencil = 0;
|
|
};
|
|
|
|
public struct ColorClearValue
|
|
{
|
|
public float4 values;
|
|
|
|
[mutating]
|
|
public void setValue(uint4 uintVal)
|
|
{
|
|
values = reinterpret<float4, uint4>(uintVal);
|
|
}
|
|
|
|
[mutating]
|
|
public void setValue(float4 floatVal)
|
|
{
|
|
values = floatVal;
|
|
}
|
|
};
|
|
|
|
public struct ClearValue
|
|
{
|
|
public ColorClearValue color;
|
|
public DepthStencilClearValue depthStencil;
|
|
};
|
|
|
|
public struct BufferRange
|
|
{
|
|
public Offset offset; ///< Offset in bytes.
|
|
public Size size; ///< Size in bytes.
|
|
};
|
|
|
|
public enum class TextureAspect : uint32_t
|
|
{
|
|
Default = 0,
|
|
Color = 0x00000001,
|
|
Depth = 0x00000002,
|
|
Stencil = 0x00000004,
|
|
MetaData = 0x00000008,
|
|
Plane0 = 0x00000010,
|
|
Plane1 = 0x00000020,
|
|
Plane2 = 0x00000040,
|
|
|
|
DepthStencil = 0x6,
|
|
};
|
|
|
|
public struct SubresourceRange
|
|
{
|
|
public TextureAspect aspectMask;
|
|
public GfxIndex mipLevel;
|
|
public GfxCount mipLevelCount;
|
|
public GfxIndex baseArrayLayer; // For Texture3D, this is WSlice.
|
|
public GfxCount layerCount; // For cube maps, this is a multiple of 6.
|
|
};
|
|
|
|
public static const Size kRemainingTextureSize = 0xFFFFFFFF;
|
|
public struct TextureResourceSampleDesc
|
|
{
|
|
public GfxCount numSamples; ///< Number of samples per pixel
|
|
public int quality; ///< The quality measure for the samples
|
|
};
|
|
|
|
public struct TextureResourceDesc : ResourceDescBase
|
|
{
|
|
public int3 size;
|
|
|
|
public GfxCount arraySize = 0; ///< Array size
|
|
|
|
public GfxCount numMipLevels = 0; ///< Number of mip levels - if 0 will create all mip levels
|
|
public Format format; ///< The resources format
|
|
public TextureResourceSampleDesc sampleDesc; ///< How the resource is sampled
|
|
public ClearValue* optimalClearValue;
|
|
};
|
|
|
|
/// Data for a single subresource of a texture.
|
|
///
|
|
/// Each subresource is a tensor with `1 <= rank <= 3`,
|
|
/// where the rank is deterined by the base shape of the
|
|
/// texture (Buffer, 1D, 2D, 3D, or Cube). For the common
|
|
/// case of a 2D texture, `rank == 2` and each subresource
|
|
/// is a 2D image.
|
|
///
|
|
/// Subresource tensors must be stored in a row-major layout,
|
|
/// so that the X axis strides over texels, the Y axis strides
|
|
/// over 1D rows of texels, and the Z axis strides over 2D
|
|
/// "layers" of texels.
|
|
///
|
|
/// For a texture with multiple mip levels or array elements,
|
|
/// each mip level and array element is stores as a distinct
|
|
/// subresource. When indexing into an array of subresources,
|
|
/// the index of a subresoruce for mip level `m` and array
|
|
/// index `a` is `m + a*mipLevelCount`.
|
|
///
|
|
public struct SubresourceData
|
|
{
|
|
/// Pointer to texel data for the subresource tensor.
|
|
public void *data;
|
|
|
|
/// Stride in bytes between rows of the subresource tensor.
|
|
///
|
|
/// This is the number of bytes to add to a pointer to a texel
|
|
/// at (X,Y,Z) to get to a texel at (X,Y+1,Z).
|
|
///
|
|
/// Devices may not support all possible values for `strideY`.
|
|
/// In particular, they may only support strictly positive strides.
|
|
///
|
|
public gfx::Size strideY;
|
|
|
|
/// Stride in bytes between layers of the subresource tensor.
|
|
///
|
|
/// This is the number of bytes to add to a pointer to a texel
|
|
/// at (X,Y,Z) to get to a texel at (X,Y,Z+1).
|
|
///
|
|
/// Devices may not support all possible values for `strideZ`.
|
|
/// In particular, they may only support strictly positive strides.
|
|
///
|
|
public gfx::Size strideZ;
|
|
};
|
|
|
|
[COM("cf88a31c-6187-46c5-a4b7-eb-58-c7-33-40-17")]
|
|
public interface ITextureResource : IResource
|
|
{
|
|
public TextureResourceDesc* getDesc();
|
|
};
|
|
|
|
public enum class ComparisonFunc : uint8_t
|
|
{
|
|
Never = 0x0,
|
|
Less = 0x1,
|
|
Equal = 0x2,
|
|
LessEqual = 0x3,
|
|
Greater = 0x4,
|
|
NotEqual = 0x5,
|
|
GreaterEqual = 0x6,
|
|
Always = 0x7,
|
|
};
|
|
|
|
public enum class TextureFilteringMode
|
|
{
|
|
Point,
|
|
Linear,
|
|
};
|
|
|
|
public enum class TextureAddressingMode
|
|
{
|
|
Wrap,
|
|
ClampToEdge,
|
|
ClampToBorder,
|
|
MirrorRepeat,
|
|
MirrorOnce,
|
|
};
|
|
|
|
public enum class TextureReductionOp
|
|
{
|
|
Average,
|
|
Comparison,
|
|
Minimum,
|
|
Maximum,
|
|
};
|
|
|
|
public struct SamplerStateDesc
|
|
{
|
|
public TextureFilteringMode minFilter;
|
|
public TextureFilteringMode magFilter;
|
|
public TextureFilteringMode mipFilter;
|
|
public TextureReductionOp reductionOp;
|
|
public TextureAddressingMode addressU;
|
|
public TextureAddressingMode addressV;
|
|
public TextureAddressingMode addressW;
|
|
public float mipLODBias;
|
|
public uint32_t maxAnisotropy;
|
|
public ComparisonFunc comparisonFunc;
|
|
public float4 borderColor;
|
|
public float minLOD;
|
|
public float maxLOD;
|
|
public __init()
|
|
{
|
|
minFilter = TextureFilteringMode::Linear;
|
|
magFilter = TextureFilteringMode::Linear;
|
|
mipFilter = TextureFilteringMode::Linear;
|
|
reductionOp = TextureReductionOp::Average;
|
|
addressU = TextureAddressingMode::Wrap;
|
|
addressV = TextureAddressingMode::Wrap;
|
|
addressW = TextureAddressingMode::Wrap;
|
|
mipLODBias = 0.0f;
|
|
maxAnisotropy = 1;
|
|
comparisonFunc = ComparisonFunc::Never;
|
|
borderColor = float4(1.0f, 1.0f, 1.0f, 1.0f);
|
|
minLOD = -float.maxValue;
|
|
maxLOD = float.maxValue;
|
|
}
|
|
};
|
|
|
|
[COM("8b8055df-9377-401d-91ff-3f-a3-bf-66-64-f4")]
|
|
public interface ISamplerState
|
|
{
|
|
/// Returns a native API handle representing this sampler state object.
|
|
/// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE.
|
|
/// When using Vulkan, this will be a VkSampler.
|
|
public Result getNativeHandle(InteropHandle *outNativeHandle);
|
|
};
|
|
|
|
public enum class ResourceViewType
|
|
{
|
|
Unknown,
|
|
|
|
RenderTarget,
|
|
DepthStencil,
|
|
ShaderResource,
|
|
UnorderedAccess,
|
|
AccelerationStructure,
|
|
|
|
CountOf_,
|
|
};
|
|
|
|
public struct RenderTargetDesc
|
|
{
|
|
// The resource shape of this render target view.
|
|
public ResourceType shape;
|
|
};
|
|
|
|
public struct ResourceViewDesc
|
|
{
|
|
public ResourceViewType type;
|
|
public Format format;
|
|
|
|
// Required fields for `RenderTarget` and `DepthStencil` views.
|
|
public RenderTargetDesc renderTarget;
|
|
// Specifies the range of a texture resource for a ShaderRsource/UnorderedAccess/RenderTarget/DepthStencil view.
|
|
public SubresourceRange subresourceRange;
|
|
// Specifies the range of a buffer resource for a ShaderResource/UnorderedAccess view.
|
|
public BufferRange bufferRange;
|
|
};
|
|
|
|
[COM("7b6c4926-0884-408c-ad8a-50-3a-8e-23-98-a4")]
|
|
public interface IResourceView
|
|
{
|
|
public ResourceViewDesc* getViewDesc();
|
|
|
|
/// Returns a native API handle representing this resource view object.
|
|
/// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE or a buffer device address depending
|
|
/// on the type of the resource view.
|
|
/// When using Vulkan, this will be a VkImageView, VkBufferView, VkAccelerationStructure or a VkBuffer
|
|
/// depending on the type of the resource view.
|
|
public Result getNativeHandle(InteropHandle *outNativeHandle);
|
|
};
|
|
|
|
public enum class AccelerationStructureKind
|
|
{
|
|
TopLevel,
|
|
BottomLevel
|
|
};
|
|
|
|
// The public enum values are intentionally consistent with
|
|
// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.
|
|
public enum AccelerationStructureBuildFlags
|
|
{
|
|
None,
|
|
AllowUpdate = 1,
|
|
AllowCompaction = 2,
|
|
PreferFastTrace = 4,
|
|
PreferFastBuild = 8,
|
|
MinimizeMemory = 16,
|
|
PerformUpdate = 32
|
|
};
|
|
|
|
public enum class GeometryType
|
|
{
|
|
Triangles, ProcedurePrimitives
|
|
};
|
|
|
|
public struct GeometryFlags
|
|
{
|
|
// The public enum values are intentionally consistent with
|
|
// D3D12_RAYTRACING_GEOMETRY_FLAGS.
|
|
public enum Enum
|
|
{
|
|
None,
|
|
Opaque = 1,
|
|
NoDuplicateAnyHitInvocation = 2
|
|
};
|
|
};
|
|
|
|
public struct TriangleDesc
|
|
{
|
|
public DeviceAddress transform3x4;
|
|
public Format indexFormat;
|
|
public Format vertexFormat;
|
|
public GfxCount indexCount;
|
|
public GfxCount vertexCount;
|
|
public DeviceAddress indexData;
|
|
public DeviceAddress vertexData;
|
|
public Size vertexStride;
|
|
};
|
|
|
|
public struct ProceduralAABB
|
|
{
|
|
public float minX;
|
|
public float minY;
|
|
public float minZ;
|
|
public float maxX;
|
|
public float maxY;
|
|
public float maxZ;
|
|
};
|
|
|
|
public struct ProceduralAABBDesc
|
|
{
|
|
/// Number of AABBs.
|
|
public GfxCount count;
|
|
|
|
/// Pointer to an array of `ProceduralAABB` values in device memory.
|
|
public DeviceAddress data;
|
|
|
|
/// Stride in bytes of the AABB values array.
|
|
public Size stride;
|
|
};
|
|
|
|
public struct GeometryDesc
|
|
{
|
|
public GeometryType type;
|
|
public GeometryFlags::Enum flags;
|
|
public TriangleDesc triangles;
|
|
public property ProceduralAABBDesc proceduralAABBs
|
|
{
|
|
get { return reinterpret<ProceduralAABBDesc, TriangleDesc>(triangles); }
|
|
set { triangles = reinterpret<TriangleDesc, ProceduralAABBDesc>(newValue); }
|
|
}
|
|
};
|
|
|
|
// The public enum values are kept consistent with D3D12_RAYTRACING_INSTANCE_FLAGS
|
|
// and VkGeometryInstanceFlagBitsKHR.
|
|
public enum GeometryInstanceFlags
|
|
{
|
|
None = 0,
|
|
TriangleFacingCullDisable = 0x00000001,
|
|
TriangleFrontCounterClockwise = 0x00000002,
|
|
ForceOpaque = 0x00000004,
|
|
NoOpaque = 0x00000008
|
|
};
|
|
|
|
// TODO: Should any of these be changed?
|
|
// The layout of this public struct is intentionally consistent with D3D12_RAYTRACING_INSTANCE_DESC
|
|
// and VkAccelerationStructureInstanceKHR.
|
|
public struct InstanceDesc
|
|
{
|
|
public float transform[3][4];
|
|
public uint32_t instanceID24_mask8;
|
|
public property uint32_t instanceID { get { return instanceID24_mask8 & 0xFFFFFF; } set { instanceID24_mask8 = (instanceID24_mask8 & 0xFF000000) | (newValue & 0xFFFFFF); } }
|
|
public property uint32_t instanceMask { get { return instanceID24_mask8 >> 24; } set { instanceID24_mask8 = (newValue << 24) | (instanceID24_mask8 & 0x00FFFFFF); } }
|
|
|
|
public uint32_t instanceContributionToHitGroupIndex24_flags8;
|
|
public property uint32_t instanceContributionToHitGroupIndex
|
|
{
|
|
get { return instanceContributionToHitGroupIndex24_flags8 & 0xFFFFFF; }
|
|
set { instanceContributionToHitGroupIndex24_flags8 = (instanceContributionToHitGroupIndex24_flags8 & 0xFF000000) | (newValue & 0xFFFFFF); }
|
|
}
|
|
public property GeometryInstanceFlags flags
|
|
{
|
|
get { return (GeometryInstanceFlags)(instanceContributionToHitGroupIndex24_flags8 >> 24); }
|
|
set { instanceContributionToHitGroupIndex24_flags8 = ((uint32_t)newValue << 24) | (instanceContributionToHitGroupIndex24_flags8 & 0x00FFFFFF); }
|
|
}
|
|
public DeviceAddress accelerationStructure;
|
|
};
|
|
|
|
public struct AccelerationStructurePrebuildInfo
|
|
{
|
|
public Size resultDataMaxSize;
|
|
public Size scratchDataSize;
|
|
public Size updateScratchDataSize;
|
|
};
|
|
|
|
public struct AccelerationStructureBuildInputs
|
|
{
|
|
public AccelerationStructureKind kind;
|
|
|
|
public AccelerationStructureBuildFlags flags;
|
|
|
|
public GfxCount descCount;
|
|
|
|
/// Array of `InstanceDesc` values in device memory.
|
|
/// Used when `kind` is `TopLevel`.
|
|
public DeviceAddress instanceDescs;
|
|
|
|
/// Array of `GeometryDesc` values.
|
|
/// Used when `kind` is `BottomLevel`.
|
|
public GeometryDesc *geometryDescs;
|
|
};
|
|
|
|
public struct AccelerationStructureCreateDesc
|
|
{
|
|
public AccelerationStructureKind kind;
|
|
public NativeRef<IBufferResource> buffer;
|
|
public Offset offset;
|
|
public Size size;
|
|
};
|
|
|
|
public struct AccelerationStructureBuildDesc
|
|
{
|
|
public AccelerationStructureBuildInputs inputs;
|
|
public NativeRef<IAccelerationStructure> source;
|
|
public NativeRef<IAccelerationStructure> dest;
|
|
public DeviceAddress scratchData;
|
|
};
|
|
|
|
[COM("a5cdda3c-1d4e-4df7-8ef2-b7-3f-ce-04-de-3b")]
|
|
public interface IAccelerationStructure : IResourceView
|
|
{
|
|
public DeviceAddress getDeviceAddress();
|
|
};
|
|
|
|
public struct FenceDesc
|
|
{
|
|
public uint64_t initialValue;
|
|
public bool isShared;
|
|
};
|
|
|
|
[COM("7fe1c283-d3f4-48ed-aaf3-01-51-96-4e-7c-b5")]
|
|
public interface IFence
|
|
{
|
|
/// Returns the currently signaled value on the device.
|
|
public Result getCurrentValue(uint64_t *outValue);
|
|
|
|
/// Signals the fence from the host with the specified value.
|
|
public Result setCurrentValue(uint64_t value);
|
|
|
|
public Result getSharedHandle(InteropHandle *outHandle);
|
|
public Result getNativeHandle(InteropHandle *outNativeHandle);
|
|
};
|
|
|
|
public struct ShaderOffset
|
|
{
|
|
public Int uniformOffset = 0; // TODO: Change to Offset?
|
|
public GfxIndex bindingRangeIndex = 0;
|
|
public GfxIndex bindingArrayIndex = 0;
|
|
}
|
|
|
|
public enum class ShaderObjectContainerType
|
|
{
|
|
None, Array, StructuredBuffer
|
|
};
|
|
|
|
[COM("c1fa997e-5ca2-45ae-9bcb-c4-35-9e-85-05-85")]
|
|
public interface IShaderObject
|
|
{
|
|
public slang::TypeLayoutReflection* getElementTypeLayout();
|
|
public ShaderObjectContainerType getContainerType();
|
|
public GfxCount getEntryPointCount();
|
|
public Result getEntryPoint(GfxIndex index, out Optional<IShaderObject> entryPoint);
|
|
public Result setData(ShaderOffset *offset, void *data, Size size);
|
|
public Result getObject(ShaderOffset *offset, out Optional<IShaderObject> object);
|
|
public Result setObject(ShaderOffset* offset, IShaderObject object);
|
|
public Result setResource(ShaderOffset* offset, IResourceView resourceView);
|
|
public Result setSampler(ShaderOffset* offset, ISamplerState sampler);
|
|
public Result setCombinedTextureSampler(ShaderOffset* offset, IResourceView textureView, ISamplerState sampler);
|
|
|
|
/// Manually overrides the specialization argument for the sub-object binding at `offset`.
|
|
/// Specialization arguments are passed to the shader compiler to specialize the type
|
|
/// of interface-typed shader parameters.
|
|
public Result setSpecializationArgs(
|
|
ShaderOffset* offset,
|
|
slang::SpecializationArg *args,
|
|
GfxCount count);
|
|
|
|
public Result getCurrentVersion(
|
|
ITransientResourceHeap transientHeap,
|
|
out IShaderObject outObject);
|
|
|
|
public void* getRawData();
|
|
|
|
public Size getSize();
|
|
|
|
/// Use the provided constant buffer instead of the internally created one.
|
|
public Result setConstantBufferOverride(IBufferResource constantBuffer);
|
|
};
|
|
|
|
public enum class StencilOp : uint8_t
|
|
{
|
|
Keep,
|
|
Zero,
|
|
Replace,
|
|
IncrementSaturate,
|
|
DecrementSaturate,
|
|
Invert,
|
|
IncrementWrap,
|
|
DecrementWrap,
|
|
};
|
|
|
|
public enum class FillMode : uint8_t
|
|
{
|
|
Solid,
|
|
Wireframe,
|
|
};
|
|
|
|
public enum class CullMode : uint8_t
|
|
{
|
|
None,
|
|
Front,
|
|
Back,
|
|
};
|
|
|
|
public enum class FrontFaceMode : uint8_t
|
|
{
|
|
CounterClockwise,
|
|
Clockwise,
|
|
};
|
|
|
|
public struct DepthStencilOpDesc
|
|
{
|
|
public StencilOp stencilFailOp = StencilOp::Keep;
|
|
public StencilOp stencilDepthFailOp = StencilOp::Keep;
|
|
public StencilOp stencilPassOp = StencilOp::Keep;
|
|
public ComparisonFunc stencilFunc = ComparisonFunc::Always;
|
|
public __init()
|
|
{
|
|
stencilFailOp = StencilOp::Keep;
|
|
stencilDepthFailOp = StencilOp::Keep;
|
|
stencilPassOp = StencilOp::Keep;
|
|
stencilFunc = ComparisonFunc::Always;
|
|
}
|
|
};
|
|
|
|
public struct DepthStencilDesc
|
|
{
|
|
public bool depthTestEnable = false;
|
|
public bool depthWriteEnable = true;
|
|
public ComparisonFunc depthFunc = ComparisonFunc::Less;
|
|
|
|
public bool stencilEnable = false;
|
|
public uint32_t stencilReadMask = 0xFFFFFFFF;
|
|
public uint32_t stencilWriteMask = 0xFFFFFFFF;
|
|
public DepthStencilOpDesc frontFace;
|
|
public DepthStencilOpDesc backFace;
|
|
|
|
public uint32_t stencilRef = 0;
|
|
|
|
public __init()
|
|
{
|
|
depthTestEnable = false;
|
|
depthWriteEnable = true;
|
|
depthFunc = ComparisonFunc::Less;
|
|
stencilEnable = false;
|
|
stencilReadMask = 0xFFFFFFFF;
|
|
stencilWriteMask = 0xFFFFFFFF;
|
|
stencilRef = 0;
|
|
}
|
|
};
|
|
|
|
public struct RasterizerDesc
|
|
{
|
|
public FillMode fillMode = FillMode::Solid;
|
|
public CullMode cullMode = CullMode::None;
|
|
public FrontFaceMode frontFace = FrontFaceMode::CounterClockwise;
|
|
public int32_t depthBias = 0;
|
|
public float depthBiasClamp = 0.0f;
|
|
public float slopeScaledDepthBias = 0.0f;
|
|
public bool depthClipEnable = true;
|
|
public bool scissorEnable = false;
|
|
public bool multisampleEnable = false;
|
|
public bool antialiasedLineEnable = false;
|
|
public bool enableConservativeRasterization = false;
|
|
public uint32_t forcedSampleCount = 0;
|
|
|
|
public __init()
|
|
{
|
|
fillMode = FillMode::Solid;
|
|
cullMode = CullMode::None;
|
|
frontFace = FrontFaceMode::CounterClockwise;
|
|
depthBias = 0;
|
|
depthBiasClamp = 0.0f;
|
|
slopeScaledDepthBias = 0.0f;
|
|
depthClipEnable = true;
|
|
scissorEnable = false;
|
|
multisampleEnable = false;
|
|
antialiasedLineEnable = false;
|
|
enableConservativeRasterization = false;
|
|
forcedSampleCount = 0;
|
|
}
|
|
};
|
|
|
|
public enum class LogicOp
|
|
{
|
|
NoOp,
|
|
};
|
|
|
|
public enum class BlendOp
|
|
{
|
|
Add,
|
|
Subtract,
|
|
ReverseSubtract,
|
|
Min,
|
|
Max,
|
|
};
|
|
|
|
public enum class BlendFactor
|
|
{
|
|
Zero,
|
|
One,
|
|
SrcColor,
|
|
InvSrcColor,
|
|
SrcAlpha,
|
|
InvSrcAlpha,
|
|
DestAlpha,
|
|
InvDestAlpha,
|
|
DestColor,
|
|
InvDestColor,
|
|
SrcAlphaSaturate,
|
|
BlendColor,
|
|
InvBlendColor,
|
|
SecondarySrcColor,
|
|
InvSecondarySrcColor,
|
|
SecondarySrcAlpha,
|
|
InvSecondarySrcAlpha,
|
|
};
|
|
|
|
public enum RenderTargetWriteMask
|
|
{
|
|
EnableNone = 0,
|
|
EnableRed = 0x01,
|
|
EnableGreen = 0x02,
|
|
EnableBlue = 0x04,
|
|
EnableAlpha = 0x08,
|
|
EnableAll = 0x0F,
|
|
};
|
|
|
|
public struct AspectBlendDesc
|
|
{
|
|
public BlendFactor srcFactor = BlendFactor::One;
|
|
public BlendFactor dstFactor = BlendFactor::Zero;
|
|
public BlendOp op = BlendOp::Add;
|
|
|
|
__init()
|
|
{
|
|
srcFactor = BlendFactor::One;
|
|
dstFactor = BlendFactor::Zero;
|
|
op = BlendOp::Add;
|
|
}
|
|
};
|
|
|
|
public struct TargetBlendDesc
|
|
{
|
|
public AspectBlendDesc color;
|
|
public AspectBlendDesc alpha;
|
|
public bool enableBlend;
|
|
public LogicOp logicOp;
|
|
public RenderTargetWriteMask writeMask;
|
|
public __init()
|
|
{
|
|
enableBlend = false;
|
|
logicOp = LogicOp::NoOp;
|
|
writeMask = RenderTargetWriteMask::EnableAll;
|
|
}
|
|
};
|
|
|
|
public struct BlendDesc
|
|
{
|
|
public TargetBlendDesc targets[kMaxRenderTargetCount] = {};
|
|
public GfxCount targetCount = 0;
|
|
|
|
public bool alphaToCoverageEnable = false;
|
|
};
|
|
|
|
public struct FramebufferTargetLayout
|
|
{
|
|
public Format format;
|
|
public GfxCount sampleCount;
|
|
};
|
|
|
|
public struct FramebufferLayoutDesc
|
|
{
|
|
public GfxCount renderTargetCount;
|
|
public FramebufferTargetLayout *renderTargets;
|
|
public FramebufferTargetLayout *depthStencil;
|
|
};
|
|
|
|
[COM("0a838785-c13a-4832-ad88-64-06-b5-4b-5e-ba")]
|
|
public interface IFramebufferLayout
|
|
{
|
|
};
|
|
|
|
public struct GraphicsPipelineStateDesc
|
|
{
|
|
public NativeRef<IShaderProgram> program;
|
|
|
|
public NativeRef<IInputLayout> inputLayout;
|
|
public NativeRef<IFramebufferLayout> framebufferLayout;
|
|
public PrimitiveType primitiveType;
|
|
public DepthStencilDesc depthStencil;
|
|
public RasterizerDesc rasterizer;
|
|
public BlendDesc blend;
|
|
|
|
public __init()
|
|
{
|
|
program = {IShaderProgram()};
|
|
inputLayout = {IInputLayout()};
|
|
framebufferLayout = {IFramebufferLayout()};
|
|
primitiveType = PrimitiveType::Triangle;
|
|
depthStencil = {};
|
|
rasterizer = {};
|
|
blend = {};
|
|
}
|
|
};
|
|
|
|
public struct ComputePipelineStateDesc
|
|
{
|
|
public NativeRef<IShaderProgram> program;
|
|
public void *d3d12RootSignatureOverride;
|
|
};
|
|
|
|
public enum RayTracingPipelineFlags
|
|
{
|
|
None = 0,
|
|
SkipTriangles = 1,
|
|
SkipProcedurals = 2,
|
|
};
|
|
|
|
public struct HitGroupDesc
|
|
{
|
|
public NativeString hitGroupName;
|
|
public NativeString closestHitEntryPoint;
|
|
public NativeString anyHitEntryPoint;
|
|
public NativeString intersectionEntryPoint;
|
|
};
|
|
|
|
public struct RayTracingPipelineStateDesc
|
|
{
|
|
public NativeRef<IShaderProgram> program;
|
|
public GfxCount hitGroupCount = 0;
|
|
public HitGroupDesc *hitGroups;
|
|
public int maxRecursion = 0;
|
|
public Size maxRayPayloadSize = 0;
|
|
public Size maxAttributeSizeInBytes = 8;
|
|
public RayTracingPipelineFlags flags = RayTracingPipelineFlags::None;
|
|
};
|
|
|
|
// Specifies the bytes to overwrite into a record in the shader table.
|
|
public struct ShaderRecordOverwrite
|
|
{
|
|
public Offset offset; // Offset within the shader record.
|
|
public Size size; // Number of bytes to overwrite.
|
|
public uint8_t data[8]; // Content to overwrite.
|
|
};
|
|
|
|
public struct ShaderTableDesc
|
|
{
|
|
public GfxCount rayGenShaderCount;
|
|
public NativeString* rayGenShaderEntryPointNames;
|
|
public ShaderRecordOverwrite *rayGenShaderRecordOverwrites;
|
|
|
|
public GfxCount missShaderCount;
|
|
public NativeString *missShaderEntryPointNames;
|
|
public ShaderRecordOverwrite *missShaderRecordOverwrites;
|
|
|
|
public GfxCount hitGroupCount;
|
|
public NativeString *hitGroupNames;
|
|
public ShaderRecordOverwrite *hitGroupRecordOverwrites;
|
|
|
|
NativeRef<IShaderProgram> program;
|
|
};
|
|
|
|
[COM("a721522c-df31-4c2f-a5e7-3b-e0-12-4b-31-78")]
|
|
public interface IShaderTable
|
|
{
|
|
|
|
};
|
|
|
|
[COM("0ca7e57d-8a90-44f3-bdb1-fe-9b-35-3f-5a-72")]
|
|
public interface IPipelineState
|
|
{
|
|
Result getNativeHandle(InteropHandle *outHandle);
|
|
};
|
|
|
|
public struct ScissorRect
|
|
{
|
|
public int32_t minX;
|
|
public int32_t minY;
|
|
public int32_t maxX;
|
|
public int32_t maxY;
|
|
};
|
|
|
|
public struct Viewport
|
|
{
|
|
public float originX = 0.0f;
|
|
public float originY = 0.0f;
|
|
public float extentX = 0.0f;
|
|
public float extentY = 0.0f;
|
|
public float minZ = 0.0f;
|
|
public float maxZ = 1.0f;
|
|
};
|
|
|
|
public struct FramebufferDesc
|
|
{
|
|
public GfxCount renderTargetCount;
|
|
public NativeRef<IResourceView> *renderTargetViews;
|
|
public NativeRef<IResourceView> depthStencilView;
|
|
public NativeRef<IFramebufferLayout> layout;
|
|
};
|
|
|
|
[COM("0f0c0d9a-4ef3-4e18-9ba9-34-60-ea-69-87-95")]
|
|
public interface IFramebuffer
|
|
{
|
|
};
|
|
|
|
public enum class WindowHandleType
|
|
{
|
|
Unknown,
|
|
Win32Handle,
|
|
XLibHandle,
|
|
};
|
|
|
|
public struct WindowHandle
|
|
{
|
|
public WindowHandleType type;
|
|
public void* handleValues[2];
|
|
public static WindowHandle fromHwnd(void *hwnd)
|
|
{
|
|
WindowHandle handle = {WindowHandleType::Unknown, {nullptr, nullptr}};
|
|
handle.type = WindowHandleType::Win32Handle;
|
|
handle.handleValues[0] = hwnd;
|
|
return handle;
|
|
}
|
|
public static WindowHandle fromXWindow(void *xdisplay, uint32_t xwindow)
|
|
{
|
|
WindowHandle handle = {WindowHandleType::Unknown, {nullptr, nullptr}};
|
|
handle.type = WindowHandleType::XLibHandle;
|
|
handle.handleValues[0] = xdisplay;
|
|
handle.handleValues[1] = (void*)xwindow;
|
|
return handle;
|
|
}
|
|
};
|
|
|
|
public enum FaceMask
|
|
{
|
|
Front = 1, Back = 2
|
|
};
|
|
|
|
public enum class TargetLoadOp
|
|
{
|
|
Load, Clear, DontCare
|
|
};
|
|
public enum class TargetStoreOp
|
|
{
|
|
Store, DontCare
|
|
};
|
|
public struct TargetAccessDesc
|
|
{
|
|
public TargetLoadOp loadOp;
|
|
public TargetLoadOp stencilLoadOp;
|
|
public TargetStoreOp storeOp;
|
|
public TargetStoreOp stencilStoreOp;
|
|
public ResourceState initialState;
|
|
public ResourceState finalState;
|
|
};
|
|
public struct RenderPassLayoutDesc
|
|
{
|
|
public NativeRef<IFramebufferLayout> framebufferLayout;
|
|
public GfxCount renderTargetCount;
|
|
public TargetAccessDesc *renderTargetAccess;
|
|
public TargetAccessDesc *depthStencilAccess;
|
|
};
|
|
|
|
[COM("daab0b1a-f45d-4ae9-bf2c-e0-bb-76-7d-fa-d1")]
|
|
public interface IRenderPassLayout
|
|
{
|
|
};
|
|
|
|
public enum class QueryType
|
|
{
|
|
Timestamp,
|
|
AccelerationStructureCompactedSize,
|
|
AccelerationStructureSerializedSize,
|
|
AccelerationStructureCurrentSize,
|
|
};
|
|
|
|
public struct QueryPoolDesc
|
|
{
|
|
public QueryType type;
|
|
public GfxCount count;
|
|
};
|
|
|
|
[COM("c2cc3784-12da-480a-a874-8b-31-96-1c-a4-36")]
|
|
public interface IQueryPool
|
|
{
|
|
public Result getResult(GfxIndex queryIndex, GfxCount count, uint64_t *data);
|
|
public Result reset();
|
|
};
|
|
|
|
[COM("77ea6383-be3d-40aa-8b45-fd-f0-d7-5b-fa-34")]
|
|
public interface ICommandEncoder
|
|
{
|
|
public void endEncoding();
|
|
public void writeTimestamp(IQueryPool queryPool, GfxIndex queryIndex);
|
|
};
|
|
|
|
public struct IndirectDispatchArguments
|
|
{
|
|
public GfxCount ThreadGroupCountX;
|
|
public GfxCount ThreadGroupCountY;
|
|
public GfxCount ThreadGroupCountZ;
|
|
};
|
|
|
|
public struct IndirectDrawArguments
|
|
{
|
|
public GfxCount VertexCountPerInstance;
|
|
public GfxCount InstanceCount;
|
|
public GfxIndex StartVertexLocation;
|
|
public GfxIndex StartInstanceLocation;
|
|
};
|
|
|
|
public struct IndirectDrawIndexedArguments
|
|
{
|
|
public GfxCount IndexCountPerInstance;
|
|
public GfxCount InstanceCount;
|
|
public GfxIndex StartIndexLocation;
|
|
public GfxIndex BaseVertexLocation;
|
|
public GfxIndex StartInstanceLocation;
|
|
};
|
|
|
|
public struct SamplePosition
|
|
{
|
|
public int8_t x;
|
|
public int8_t y;
|
|
};
|
|
|
|
public enum ClearResourceViewFlags
|
|
{
|
|
None = 0,
|
|
ClearDepth = 1,
|
|
ClearStencil = 2,
|
|
FloatClearValues = 4
|
|
};
|
|
|
|
[COM("F99A00E9-ED50-4088-8A0E-3B26755031EA")]
|
|
public interface IResourceCommandEncoder : ICommandEncoder
|
|
{
|
|
public void copyBuffer(
|
|
IBufferResource dst,
|
|
Offset dstOffset,
|
|
IBufferResource src,
|
|
Offset srcOffset,
|
|
Size size);
|
|
/// Copies texture from src to dst. If dstSubresource and srcSubresource has mipLevelCount = 0
|
|
/// and layerCount = 0, the entire resource is being copied and dstOffset, srcOffset and extent
|
|
/// arguments are ignored.
|
|
public void copyTexture(
|
|
ITextureResource dst,
|
|
ResourceState dstState,
|
|
SubresourceRange dstSubresource,
|
|
int3 dstOffset,
|
|
NativeRef<ITextureResource> src,
|
|
ResourceState srcState,
|
|
SubresourceRange srcSubresource,
|
|
int3 srcOffset,
|
|
int3 extent);
|
|
|
|
/// Copies texture to a buffer. Each row is aligned to kTexturePitchAlignment.
|
|
public void copyTextureToBuffer(
|
|
IBufferResource dst,
|
|
Offset dstOffset,
|
|
Size dstSize,
|
|
Size dstRowStride,
|
|
ITextureResource src,
|
|
ResourceState srcState,
|
|
SubresourceRange srcSubresource,
|
|
int3 srcOffset,
|
|
int3 extent);
|
|
public void uploadTextureData(
|
|
ITextureResource dst,
|
|
SubresourceRange subResourceRange,
|
|
int3 offset,
|
|
int3 extent,
|
|
SubresourceData *subResourceData,
|
|
GfxCount subResourceDataCount);
|
|
public void uploadBufferData(IBufferResource dst, Offset offset, Size size, void *data);
|
|
public void textureBarrier(
|
|
GfxCount count, NativeRef<ITextureResource> *textures, ResourceState src, ResourceState dst);
|
|
public void textureSubresourceBarrier(
|
|
ITextureResource texture,
|
|
SubresourceRange subresourceRange,
|
|
ResourceState src,
|
|
ResourceState dst);
|
|
public void bufferBarrier(
|
|
GfxCount count, NativeRef<IBufferResource> *buffers, ResourceState src, ResourceState dst);
|
|
public void clearResourceView(
|
|
IResourceView view, ClearValue *clearValue, ClearResourceViewFlags flags);
|
|
public void resolveResource(
|
|
ITextureResource source,
|
|
ResourceState sourceState,
|
|
SubresourceRange sourceRange,
|
|
ITextureResource dest,
|
|
ResourceState destState,
|
|
SubresourceRange destRange);
|
|
public void resolveQuery(
|
|
IQueryPool queryPool,
|
|
GfxIndex index,
|
|
GfxCount count,
|
|
IBufferResource buffer,
|
|
Offset offset);
|
|
public void beginDebugEvent(NativeString name, float rgbColor[3]);
|
|
public void endDebugEvent();
|
|
};
|
|
|
|
[COM("7A8D56D0-53E6-4AD6-85F7-D14DC110FDCE")]
|
|
public interface IRenderCommandEncoder : IResourceCommandEncoder
|
|
{
|
|
// Sets the current pipeline state. This method returns a transient shader object for
|
|
// writing shader parameters. This shader object will not retain any resources or
|
|
// sub-shader-objects bound to it. The user must be responsible for ensuring that any
|
|
// resources or shader objects that is set into `outRootShaderObject` stays alive during
|
|
// the execution of the command buffer.
|
|
public Result bindPipeline(IPipelineState state, out IShaderObject outRootShaderObject);
|
|
|
|
// Sets the current pipeline state along with a pre-created mutable root shader object.
|
|
public Result bindPipelineWithRootObject(IPipelineState state, NativeRef<IShaderObject> rootObject);
|
|
|
|
public void setViewports(GfxCount count, Viewport *viewports);
|
|
public void setScissorRects(GfxCount count, ScissorRect *scissors);
|
|
|
|
public void setPrimitiveTopology(PrimitiveTopology topology);
|
|
public void setVertexBuffers(
|
|
GfxIndex startSlot,
|
|
GfxCount slotCount,
|
|
NativeRef<IBufferResource>* buffers,
|
|
Offset *offsets);
|
|
|
|
public void setIndexBuffer(IBufferResource buffer, Format indexFormat, Offset offset);
|
|
public void draw(GfxCount vertexCount, GfxIndex startVertex);
|
|
public void drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0);
|
|
public void drawIndirect(
|
|
GfxCount maxDrawCount,
|
|
IBufferResource argBuffer,
|
|
Offset argOffset,
|
|
NativeRef<IBufferResource> countBuffer,
|
|
Offset countOffset = 0);
|
|
public void drawIndexedIndirect(
|
|
GfxCount maxDrawCount,
|
|
IBufferResource argBuffer,
|
|
Offset argOffset,
|
|
NativeRef<IBufferResource> countBuffer,
|
|
Offset countOffset = 0);
|
|
public void setStencilReference(uint32_t referenceValue);
|
|
public Result setSamplePositions(
|
|
GfxCount samplesPerPixel, GfxCount pixelCount, SamplePosition *samplePositions);
|
|
public void drawInstanced(
|
|
GfxCount vertexCount,
|
|
GfxCount instanceCount,
|
|
GfxIndex startVertex,
|
|
GfxIndex startInstanceLocation);
|
|
public void drawIndexedInstanced(
|
|
GfxCount indexCount,
|
|
GfxCount instanceCount,
|
|
GfxIndex startIndexLocation,
|
|
GfxIndex baseVertexLocation,
|
|
GfxIndex startInstanceLocation);
|
|
};
|
|
|
|
[COM("88AA9322-82F7-4FE6-A68A-29C7FE798737")]
|
|
public interface IComputeCommandEncoder : IResourceCommandEncoder
|
|
{
|
|
// Sets the current pipeline state. This method returns a transient shader object for
|
|
// writing shader parameters. This shader object will not retain any resources or
|
|
// sub-shader-objects bound to it. The user must be responsible for ensuring that any
|
|
// resources or shader objects that is set into `outRooShaderObject` stays alive during
|
|
// the execution of the command buffer.
|
|
public Result bindPipeline(IPipelineState state, out Optional<IShaderObject> outRootShaderObject);
|
|
|
|
// Sets the current pipeline state along with a pre-created mutable root shader object.
|
|
public Result bindPipelineWithRootObject(IPipelineState state, IShaderObject rootObject);
|
|
|
|
public void dispatchCompute(int x, int y, int z);
|
|
public void dispatchComputeIndirect(IBufferResource cmdBuffer, Offset offset);
|
|
};
|
|
|
|
public enum class AccelerationStructureCopyMode
|
|
{
|
|
Clone, Compact
|
|
};
|
|
|
|
public struct AccelerationStructureQueryDesc
|
|
{
|
|
public QueryType queryType;
|
|
|
|
public NativeRef<IQueryPool> queryPool;
|
|
|
|
public GfxIndex firstQueryIndex;
|
|
};
|
|
|
|
[COM("9a672b87-5035-45e3-967c-1f-85-cd-b3-63-4f")]
|
|
public interface IRayTracingCommandEncoder : IResourceCommandEncoder
|
|
{
|
|
public void buildAccelerationStructure(
|
|
AccelerationStructureBuildDesc *desc,
|
|
GfxCount propertyQueryCount,
|
|
AccelerationStructureQueryDesc *queryDescs);
|
|
public void copyAccelerationStructure(
|
|
NativeRef<IAccelerationStructure> dest,
|
|
NativeRef<IAccelerationStructure> src,
|
|
AccelerationStructureCopyMode mode);
|
|
public void queryAccelerationStructureProperties(
|
|
GfxCount accelerationStructureCount,
|
|
NativeRef<IAccelerationStructure> *accelerationStructures,
|
|
GfxCount queryCount,
|
|
AccelerationStructureQueryDesc *queryDescs);
|
|
public void serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure source);
|
|
public void deserializeAccelerationStructure(IAccelerationStructure dest, DeviceAddress source);
|
|
|
|
public Result bindPipeline(IPipelineState state, out IShaderObject rootObject);
|
|
// Sets the current pipeline state along with a pre-created mutable root shader object.
|
|
public Result bindPipelineWithRootObject(IPipelineState state, IShaderObject rootObject);
|
|
|
|
/// Issues a dispatch command to start ray tracing workload with a ray tracing pipeline.
|
|
/// `rayGenShaderIndex` specifies the index into the shader table that identifies the ray generation shader.
|
|
public void dispatchRays(
|
|
GfxIndex rayGenShaderIndex,
|
|
NativeRef<IShaderTable> shaderTable,
|
|
GfxCount width,
|
|
GfxCount height,
|
|
GfxCount depth);
|
|
};
|
|
|
|
[COM("5d56063f-91d4-4723-a7a7-7a-15-af-93-eb-48")]
|
|
public interface ICommandBuffer
|
|
{
|
|
// Only one encoder may be open at a time. User must call `ICommandEncoder::endEncoding`
|
|
// before calling other `encode*Commands` methods.
|
|
// Once `endEncoding` is called, the `ICommandEncoder` object becomes obsolete and is
|
|
// invalid for further use. To continue recording, the user must request a new encoder
|
|
// object by calling one of the `encode*Commands` methods again.
|
|
public void encodeRenderCommands(
|
|
IRenderPassLayout renderPass,
|
|
IFramebuffer framebuffer,
|
|
out IRenderCommandEncoder outEncoder);
|
|
|
|
public void encodeComputeCommands(out Optional<IComputeCommandEncoder> encoder);
|
|
|
|
public void encodeResourceCommands(out Optional<IResourceCommandEncoder> outEncoder);
|
|
|
|
public void encodeRayTracingCommands(out Optional<IRayTracingCommandEncoder> outEncoder);
|
|
|
|
public void close();
|
|
|
|
public Result getNativeHandle(out InteropHandle outHandle);
|
|
};
|
|
|
|
public enum class QueueType
|
|
{
|
|
Graphics
|
|
};
|
|
public struct CommandQueueDesc
|
|
{
|
|
public QueueType type;
|
|
};
|
|
|
|
[COM("14e2bed0-0ad0-4dc8-b341-06-3f-e7-2d-bf-0e")]
|
|
public interface ICommandQueue
|
|
{
|
|
public const CommandQueueDesc* getDesc();
|
|
|
|
public void executeCommandBuffers(
|
|
GfxCount count,
|
|
NativeRef<ICommandBuffer> *commandBuffers,
|
|
Optional<IFence> fenceToSignal,
|
|
uint64_t newFenceValue);
|
|
|
|
public Result getNativeHandle(out InteropHandle outHandle);
|
|
|
|
public void waitOnHost();
|
|
|
|
/// Queues a device side wait for the given fences.
|
|
public Result waitForFenceValuesOnDevice(GfxCount fenceCount, NativeRef<IFence> *fences, uint64_t *waitValues);
|
|
};
|
|
|
|
public enum TransientResourceHeapFlags
|
|
{
|
|
None = 0,
|
|
AllowResizing = 0x1,
|
|
};
|
|
|
|
public struct TransientResourceHeapDesc
|
|
{
|
|
public TransientResourceHeapFlags flags;
|
|
public Size constantBufferSize;
|
|
public GfxCount samplerDescriptorCount;
|
|
public GfxCount uavDescriptorCount;
|
|
public GfxCount srvDescriptorCount;
|
|
public GfxCount constantBufferDescriptorCount;
|
|
public GfxCount accelerationStructureDescriptorCount;
|
|
};
|
|
|
|
[COM("cd48bd29-ee72-41b8-bcff-0a-2b-3a-aa-6d-0b")]
|
|
public interface ITransientResourceHeap
|
|
{
|
|
// Waits until GPU commands issued before last call to `finish()` has been completed, and resets
|
|
// all transient resources holds by the heap.
|
|
// This method must be called before using the transient heap to issue new GPU commands.
|
|
// In most situations this method should be called at the beginning of each frame.
|
|
public Result synchronizeAndReset();
|
|
|
|
// Must be called when the application has done using this heap to issue commands. In most situations
|
|
// this method should be called at the end of each frame.
|
|
public Result finish();
|
|
|
|
// Command buffers are one-time use. Once it is submitted to the queue via
|
|
// `executeCommandBuffers` a command buffer is no longer valid to be used any more. Command
|
|
// buffers must be closed before submission. The current D3D12 implementation has a limitation
|
|
// that only one command buffer maybe recorded at a time. User must finish recording a command
|
|
// buffer before creating another command buffer.
|
|
public Result createCommandBuffer(out Optional<ICommandBuffer> outCommandBuffer);
|
|
};
|
|
|
|
public struct SwapchainDesc
|
|
{
|
|
public Format format;
|
|
public GfxCount width, height;
|
|
public GfxCount imageCount;
|
|
public NativeRef<ICommandQueue> queue;
|
|
public bool enableVSync;
|
|
};
|
|
|
|
[COM("be91ba6c-0784-4308-a1-00-19-c3-66-83-44-b2")]
|
|
public interface ISwapchain
|
|
{
|
|
public const SwapchainDesc* getDesc();
|
|
|
|
/// Returns the back buffer image at `index`.
|
|
public Result getImage(GfxIndex index, out ITextureResource outResource);
|
|
|
|
/// Present the next image in the swapchain.
|
|
public Result present();
|
|
|
|
/// Returns the index of next back buffer image that will be presented in the next
|
|
/// `present` call. If the swapchain is invalid/out-of-date, this method returns -1.
|
|
public int acquireNextImage();
|
|
|
|
/// Resizes the back buffers of this swapchain. All render target views and framebuffers
|
|
/// referencing the back buffer images must be freed before calling this method.
|
|
public Result resize(GfxCount width, GfxCount height);
|
|
|
|
// Check if the window is occluded.
|
|
public bool isOccluded();
|
|
|
|
// Toggle full screen mode.
|
|
public Result setFullScreenMode(bool mode);
|
|
};
|
|
|
|
public struct DeviceInfo
|
|
{
|
|
public DeviceType deviceType;
|
|
|
|
public BindingStyle bindingStyle;
|
|
|
|
public ProjectionStyle projectionStyle;
|
|
|
|
/// An projection matrix that ensures x, y mapping to pixels
|
|
/// is the same on all targets
|
|
public float identityProjectionMatrix[16];
|
|
|
|
/// The name of the graphics API being used by this device.
|
|
public NativeString apiName;
|
|
|
|
/// The name of the graphics adapter.
|
|
public NativeString adapterName;
|
|
|
|
/// The clock frequency used in timestamp queries.
|
|
public uint64_t timestampFrequency;
|
|
};
|
|
|
|
public enum class DebugMessageType
|
|
{
|
|
Info, Warning, Error
|
|
};
|
|
public enum class DebugMessageSource
|
|
{
|
|
Layer, Driver, Slang
|
|
};
|
|
|
|
[COM("B219D7E8-255A-2572-D46C-A0E5D99CEB90")]
|
|
public interface IDebugCallback
|
|
{
|
|
public void handleMessage(DebugMessageType type, DebugMessageSource source, NativeString message);
|
|
};
|
|
|
|
public struct SlangDesc
|
|
{
|
|
public NativeRef<slang::IGlobalSession> slangGlobalSession = {slang::IGlobalSession()}; // (optional) A slang global session object. If null will create automatically.
|
|
|
|
public slang::SlangMatrixLayoutMode defaultMatrixLayoutMode = slang::SlangMatrixLayoutMode::SLANG_MATRIX_LAYOUT_ROW_MAJOR;
|
|
|
|
public NativeString *searchPaths = nullptr;
|
|
public GfxCount searchPathCount = 0;
|
|
|
|
public slang::PreprocessorMacroDesc *preprocessorMacros = nullptr;
|
|
public GfxCount preprocessorMacroCount = 0;
|
|
|
|
public NativeString targetProfile = ""; // (optional) Target shader profile. If null this will be set to platform dependent default.
|
|
public slang::SlangFloatingPointMode floatingPointMode = slang::SlangFloatingPointMode::SLANG_FLOATING_POINT_MODE_DEFAULT;
|
|
public slang::SlangOptimizationLevel optimizationLevel = slang::SlangOptimizationLevel::SLANG_OPTIMIZATION_LEVEL_DEFAULT;
|
|
public slang::SlangTargetFlags targetFlags = slang::SlangTargetFlags.None;
|
|
public slang::SlangLineDirectiveMode lineDirectiveMode = slang::SlangLineDirectiveMode::SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
|
|
};
|
|
|
|
public struct ShaderCacheDesc
|
|
{
|
|
// The root directory for the shader cache. If not set, shader cache is disabled.
|
|
public NativeString shaderCachePath = "";
|
|
// The maximum number of entries stored in the cache.
|
|
public GfxCount maxEntryCount = 0;
|
|
};
|
|
|
|
public struct DeviceInteropHandles
|
|
{
|
|
public InteropHandle handles[3] = {};
|
|
};
|
|
|
|
public struct DeviceDesc
|
|
{
|
|
// The underlying API/Platform of the device.
|
|
public DeviceType deviceType = DeviceType::Default;
|
|
// The device's handles (if they exist) and their associated API. For D3D12, this contains a single InteropHandle
|
|
// for the ID3D12Device. For Vulkan, the first InteropHandle is the VkInstance, the second is the VkPhysicalDevice,
|
|
// and the third is the VkDevice. For CUDA, this only contains a single value for the CUDADevice.
|
|
public DeviceInteropHandles existingDeviceHandles = {};
|
|
// Name to identify the adapter to use
|
|
public NativeString adapter = "";
|
|
// Number of required features.
|
|
public GfxCount requiredFeatureCount = 0;
|
|
// Array of required feature names, whose size is `requiredFeatureCount`.
|
|
public NativeString *requiredFeatures = nullptr;
|
|
// A command dispatcher object that intercepts and handles actual low-level API call.
|
|
void *apiCommandDispatcher = nullptr;
|
|
// The slot (typically UAV) used to identify NVAPI intrinsics. If >=0 NVAPI is required.
|
|
public GfxIndex nvapiExtnSlot = -1;
|
|
// Configurations for the shader cache.
|
|
public ShaderCacheDesc shaderCache = {};
|
|
// Configurations for Slang compiler.
|
|
public SlangDesc slang = {};
|
|
|
|
public GfxCount extendedDescCount = 0;
|
|
public void **extendedDescs = nullptr;
|
|
};
|
|
|
|
[COM("715bdf26-5135-11eb-AE93-02-42-AC-13-00-02")]
|
|
public interface IDevice
|
|
{
|
|
public Result getNativeDeviceHandles(out DeviceInteropHandles outHandles);
|
|
|
|
public bool hasFeature(NativeString feature);
|
|
|
|
/// Returns a list of features supported by the renderer.
|
|
public Result getFeatures(NativeString *outFeatures, Size bufferSize, GfxCount *outFeatureCount);
|
|
|
|
public Result getFormatSupportedResourceStates(Format format, ResourceStateSet *outStates);
|
|
|
|
public Result getSlangSession(NativeRef<slang::ISession>* outSlangSession);
|
|
|
|
public Result createTransientResourceHeap(
|
|
TransientResourceHeapDesc *desc,
|
|
out Optional<ITransientResourceHeap> outHeap);
|
|
|
|
/// Create a texture resource.
|
|
///
|
|
/// If `initData` is non-null, then it must point to an array of
|
|
/// `ITextureResource::SubresourceData` with one element for each
|
|
/// subresource of the texture being created.
|
|
///
|
|
/// The number of subresources in a texture is:
|
|
///
|
|
/// effectiveElementCount * mipLevelCount
|
|
///
|
|
/// where the effective element count is computed as:
|
|
///
|
|
/// effectiveElementCount = (isArray ? arrayElementCount : 1) * (isCube ? 6 : 1);
|
|
///
|
|
public Result createTextureResource(
|
|
TextureResourceDesc* desc,
|
|
SubresourceData *initData,
|
|
out ITextureResource outResource);
|
|
|
|
public Result createTextureFromNativeHandle(
|
|
InteropHandle handle,
|
|
TextureResourceDesc* srcDesc,
|
|
out ITextureResource outResource);
|
|
|
|
public Result createTextureFromSharedHandle(
|
|
InteropHandle handle,
|
|
TextureResourceDesc *srcDesc,
|
|
Size size,
|
|
out ITextureResource outResource);
|
|
|
|
/// Create a buffer resource
|
|
public Result createBufferResource(
|
|
BufferResourceDesc* desc,
|
|
void *initData,
|
|
out Optional<IBufferResource> outResource);
|
|
|
|
public Result createBufferFromNativeHandle(
|
|
InteropHandle handle,
|
|
BufferResourceDesc* srcDesc,
|
|
out IBufferResource outResource);
|
|
|
|
public Result createBufferFromSharedHandle(
|
|
InteropHandle handle,
|
|
BufferResourceDesc* srcDesc,
|
|
out IBufferResource outResource);
|
|
|
|
public Result createSamplerState(SamplerStateDesc* desc, out ISamplerState outSampler);
|
|
|
|
public Result createTextureView(
|
|
ITextureResource texture, ResourceViewDesc* desc, out IResourceView outView);
|
|
|
|
public Result createBufferView(
|
|
IBufferResource buffer,
|
|
Optional<IBufferResource> counterBuffer,
|
|
ResourceViewDesc* desc,
|
|
out Optional<IResourceView> outView);
|
|
|
|
public Result createFramebufferLayout(FramebufferLayoutDesc* desc, out IFramebufferLayout outFrameBuffer);
|
|
|
|
public Result createFramebuffer(FramebufferDesc* desc, out IFramebuffer outFrameBuffer);
|
|
|
|
public Result createRenderPassLayout(
|
|
RenderPassLayoutDesc* desc,
|
|
out IRenderPassLayout outRenderPassLayout);
|
|
|
|
public Result createSwapchain(
|
|
SwapchainDesc* desc, WindowHandle window, out ISwapchain outSwapchain);
|
|
|
|
public Result createInputLayout(
|
|
InputLayoutDesc* desc, out IInputLayout outLayout);
|
|
|
|
public Result createCommandQueue(CommandQueueDesc* desc, out Optional<ICommandQueue> outQueue);
|
|
|
|
public Result createShaderObject(
|
|
slang::TypeReflection *type,
|
|
ShaderObjectContainerType container,
|
|
out IShaderObject outObject);
|
|
|
|
public Result createMutableShaderObject(
|
|
slang::TypeReflection *type,
|
|
ShaderObjectContainerType container,
|
|
out IShaderObject outObject);
|
|
|
|
public Result createShaderObjectFromTypeLayout(
|
|
slang::TypeLayoutReflection *typeLayout, out IShaderObject outObject);
|
|
|
|
public Result createMutableShaderObjectFromTypeLayout(
|
|
slang::TypeLayoutReflection *typeLayout, out IShaderObject outObject);
|
|
|
|
public Result createMutableRootShaderObject(
|
|
IShaderProgram program,
|
|
out IShaderObject outObject);
|
|
|
|
public Result createShaderTable(ShaderTableDesc* desc, out IShaderTable outTable);
|
|
|
|
public Result createProgram(
|
|
void *desc,
|
|
out IShaderProgram outProgram,
|
|
out slang::ISlangBlob outDiagnosticBlob);
|
|
|
|
public Result createProgram2(
|
|
ShaderProgramDesc2 *desc,
|
|
out Optional<IShaderProgram> outProgram,
|
|
out Optional<slang::ISlangBlob> outDiagnosticBlob);
|
|
|
|
public Result createGraphicsPipelineState(
|
|
GraphicsPipelineStateDesc *desc,
|
|
out Optional<IPipelineState> outState);
|
|
|
|
public Result createComputePipelineState(
|
|
ComputePipelineStateDesc* desc,
|
|
out Optional<IPipelineState> outState);
|
|
|
|
public Result createRayTracingPipelineState(
|
|
RayTracingPipelineStateDesc *desc, out Optional<IPipelineState> outState);
|
|
|
|
/// Read back texture resource and stores the result in `outBlob`.
|
|
public Result readTextureResource(
|
|
ITextureResource resource,
|
|
ResourceState state,
|
|
out slang::ISlangBlob outBlob,
|
|
out Size outRowPitch,
|
|
out Size outPixelSize);
|
|
|
|
public Result readBufferResource(
|
|
IBufferResource buffer,
|
|
Offset offset,
|
|
Size size,
|
|
out Optional<slang::ISlangBlob> outBlob);
|
|
|
|
/// Get the type of this renderer
|
|
public DeviceInfo* getDeviceInfo();
|
|
|
|
public Result createQueryPool(
|
|
QueryPoolDesc* desc, out IQueryPool outPool);
|
|
|
|
public Result getAccelerationStructurePrebuildInfo(
|
|
AccelerationStructureBuildInputs* buildInputs,
|
|
out AccelerationStructurePrebuildInfo outPrebuildInfo);
|
|
|
|
public Result createAccelerationStructure(
|
|
AccelerationStructureCreateDesc* desc,
|
|
out IAccelerationStructure outView);
|
|
|
|
public Result createFence(FenceDesc* desc, out IFence outFence);
|
|
|
|
/// Wait on the host for the fences to signals.
|
|
/// `timeout` is in nanoseconds, can be set to `kTimeoutInfinite`.
|
|
public Result waitForFences(
|
|
GfxCount fenceCount,
|
|
NativeRef<IFence>* fences,
|
|
uint64_t *values,
|
|
bool waitForAll,
|
|
uint64_t timeout);
|
|
|
|
public Result getTextureAllocationInfo(
|
|
TextureResourceDesc* desc, out Size outSize, out Size outAlignment);
|
|
|
|
public Result getTextureRowAlignment(out Size outAlignment);
|
|
};
|
|
|
|
public struct ShaderCacheStats
|
|
{
|
|
public GfxCount hitCount;
|
|
public GfxCount missCount;
|
|
public GfxCount entryCount;
|
|
};
|
|
|
|
[COM("715bdf26-5135-11eb-AE93-02-42-AC-13-00-02")]
|
|
public interface IShaderCache
|
|
{
|
|
public Result clearShaderCache();
|
|
public Result getShaderCacheStats(out ShaderCacheStats outStats);
|
|
public Result resetShaderCacheStats();
|
|
};
|
|
|
|
#define SLANG_GFX_IMPORT [DllImport("gfx")]
|
|
/// Checks if format is compressed
|
|
SLANG_GFX_IMPORT public bool gfxIsCompressedFormat(Format format);
|
|
|
|
/// Checks if format is typeless
|
|
SLANG_GFX_IMPORT public bool gfxIsTypelessFormat(Format format);
|
|
|
|
/// Gets information about the format
|
|
SLANG_GFX_IMPORT public Result gfxGetFormatInfo(Format format, FormatInfo *outInfo);
|
|
|
|
/// Given a type returns a function that can conpublic struct it, or nullptr if there isn't one
|
|
SLANG_GFX_IMPORT public Result gfxCreateDevice(const Ptr<DeviceDesc> desc, out Optional<IDevice> outDevice);
|
|
|
|
/// Reports current set of live objects in gfx.
|
|
/// Currently this only calls D3D's ReportLiveObjects.
|
|
SLANG_GFX_IMPORT public Result gfxReportLiveObjects();
|
|
|
|
/// Sets a callback for receiving debug messages.
|
|
/// The layer does not hold a strong reference to the callback object.
|
|
/// The user is responsible for holding the callback object alive.
|
|
SLANG_GFX_IMPORT public Result gfxSetDebugCallback(IDebugCallback callback);
|
|
|
|
/// Enables debug layer. The debug layer will check all `gfx` calls and verify that uses are valid.
|
|
SLANG_GFX_IMPORT public void gfxEnableDebugLayer();
|
|
|
|
SLANG_GFX_IMPORT public NativeString gfxGetDeviceTypeName(DeviceType type);
|
|
|
|
public bool succeeded(Result code)
|
|
{
|
|
return code >= 0;
|
|
}
|
|
|
|
}
|