1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// d3d-util.h
#pragma once
#include <stdint.h>
#include "slang-com-helper.h"
#include "slang-com-ptr.h"
#include "core/slang-basic.h"
#include "../flag-combiner.h"
#include "slang-gfx.h"
#include <D3Dcommon.h>
#include <DXGIFormat.h>
#include <dxgi.h>
#include <d3d12.h>
#if defined(__ID3D12Device5_FWD_DEFINED__) && defined(__ID3D12GraphicsCommandList4_FWD_DEFINED__)
# define SLANG_GFX_HAS_DXR_SUPPORT 1
#else
# define SLANG_GFX_HAS_DXR_SUPPORT 0
typedef ISlangUnknown ID3D12Device5;
typedef ISlangUnknown ID3D12GraphicsCommandList4;
#endif
namespace gfx {
class D3DUtil
{
public:
enum UsageType
{
USAGE_UNKNOWN, ///< Generally used to mark an error
USAGE_TARGET, ///< Format should be used when written as target
USAGE_DEPTH_STENCIL, ///< Format should be used when written as depth stencil
USAGE_SRV, ///< Format if being read as srv
USAGE_COUNT_OF,
};
enum UsageFlag
{
USAGE_FLAG_MULTI_SAMPLE = 0x1, ///< If set will be used form multi sampling (such as MSAA)
USAGE_FLAG_SRV = 0x2, ///< If set means will be used as a shader resource view (SRV)
};
/// Get primitive topology as D3D primitive topology
static D3D_PRIMITIVE_TOPOLOGY getPrimitiveTopology(PrimitiveTopology prim);
static D3D12_PRIMITIVE_TOPOLOGY_TYPE getPrimitiveType(PrimitiveType type);
static D3D12_PRIMITIVE_TOPOLOGY_TYPE getPrimitiveType(PrimitiveTopology topology);
static D3D12_COMPARISON_FUNC getComparisonFunc(ComparisonFunc func);
static D3D12_DEPTH_STENCILOP_DESC translateStencilOpDesc(DepthStencilOpDesc desc);
/// Calculate size taking into account alignment. Alignment must be a power of 2
static UInt calcAligned(UInt size, UInt alignment) { return (size + alignment - 1) & ~(alignment - 1); }
/// Compile HLSL code to DXBC
static Slang::Result compileHLSLShader(char const* sourcePath, char const* source, char const* entryPointName, char const* dxProfileName, Slang::ComPtr<ID3DBlob>& shaderBlobOut);
/// Given a slang pixel format returns the equivalent DXGI_ pixel format. If the format is not known, will return DXGI_FORMAT_UNKNOWN
static DXGI_FORMAT getMapFormat(Format format);
/// Given the usage, flags, and format will return the most suitable format. Will return DXGI_UNKNOWN if combination is not possible
static DXGI_FORMAT calcFormat(UsageType usage, DXGI_FORMAT format);
/// Calculate appropriate format for creating a buffer for usage and flags
static DXGI_FORMAT calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format);
/// True if the type is 'typeless'
static bool isTypeless(DXGI_FORMAT format);
/// Returns number of bits used for color channel for format (for channels with multiple sizes, returns smallest ie RGB565 -> 5)
static Int getNumColorChannelBits(DXGI_FORMAT fmt);
/// Append text in in, into wide char array
static void appendWideChars(const char* in, Slang::List<wchar_t>& out);
static SlangResult createFactory(DeviceCheckFlags flags, Slang::ComPtr<IDXGIFactory>& outFactory);
/// Get the dxgiModule
static HMODULE getDxgiModule();
/// Find adapters
static SlangResult findAdapters(DeviceCheckFlags flags, const Slang::UnownedStringSlice& adapaterName, IDXGIFactory* dxgiFactory, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
/// Find adapters
static SlangResult findAdapters(DeviceCheckFlags flags, const Slang::UnownedStringSlice& adapaterName, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
/// True if the adapter is warp
static bool isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapter);
static bool isUAVBinding(slang::BindingType bindingType);
static int getShaderModelFromProfileName(const char* profile);
static uint32_t getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect);
static uint32_t getPlaneSliceCount(DXGI_FORMAT format);
static D3D12_INPUT_CLASSIFICATION getInputSlotClass(InputSlotClass slotClass);
static D3D12_FILL_MODE getFillMode(FillMode mode);
static D3D12_CULL_MODE getCullMode(CullMode mode);
static D3D12_BLEND_OP getBlendOp(BlendOp op);
static D3D12_BLEND getBlendFactor(BlendFactor factor);
static uint32_t getSubresourceIndex(
uint32_t mipIndex,
uint32_t arrayIndex,
uint32_t planeIndex,
uint32_t mipLevelCount,
uint32_t arraySize);
static uint32_t getSubresourceMipLevel(uint32_t subresourceIndex, uint32_t mipLevelCount);
static D3D12_RESOURCE_STATES getResourceState(ResourceState state);
};
#if SLANG_GFX_HAS_DXR_SUPPORT
struct D3DAccelerationStructureInputsBuilder
{
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS desc = {};
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO prebuildInfo = {};
Slang::List<D3D12_RAYTRACING_GEOMETRY_DESC> geomDescs;
Slang::Result build(
const IAccelerationStructure::BuildInputs& buildInputs,
IDebugCallback* callback);
private:
D3D12_RAYTRACING_GEOMETRY_FLAGS translateGeometryFlags(
IAccelerationStructure::GeometryFlags::Enum flags)
{
return (D3D12_RAYTRACING_GEOMETRY_FLAGS)flags;
}
};
#endif
} // renderer_test
|
