Nebula
Loading...
Searching...
No Matches
config.h
Go to the documentation of this file.
1#pragma once
2//------------------------------------------------------------------------------
12#include "core/types.h"
13#include "util/string.h"
14#include "core/rttimacros.h"
15
16#define NEBULA_WHOLE_BUFFER_SIZE (~0ull)
17#define NEBULA_ALL_MIPS (-1)
18#define NEBULA_ALL_LAYERS (-1)
19namespace CoreGraphics
20{
22
24{
25 struct
26 {
28 bool primRestart : 1;
29 };
30 byte key;
31
32 void operator=(const InputAssemblyKey& rhs) { this->key = rhs.key; }
33 bool operator==(const InputAssemblyKey& rhs) const { return this->key == rhs.key; }
34 bool operator!=(const InputAssemblyKey& rhs) const { return this->key != rhs.key; }
35 bool operator>(const InputAssemblyKey& rhs) const { return this->key > rhs.key; }
36 bool operator<(const InputAssemblyKey& rhs) const { return this->key < rhs.key; }
37};
38
50
58
80
81enum class ImageBits
82{
83 None = 0,
84 Auto = 1, // Special value to be used only by framescript
85 ColorBits = (1 << 1),
86 DepthBits = (1 << 2),
87 StencilBits = (1 << 3),
88 MetaBits = (1 << 4),
89 Plane0Bits = (1 << 5),
90 Plane1Bits = (1 << 6),
91 Plane2Bits = (1 << 7)
92};
95
109
111{
114 ComputePipeline, // Compute pipeline is not the compute queue, it's just resources available for compute shaders
116};
117
118//------------------------------------------------------------------------------
121inline ShaderVisibility
123{
124 Util::Array<Util::String> components = str.Tokenize("|");
126 IndexT i;
127 for (i = 0; i < components.Size(); i++)
128 {
129 const Util::String& component = components[i];
130 if (component == "VS") ret |= VertexShaderVisibility;
131 else if (component == "HS") ret |= HullShaderVisibility;
132 else if (component == "DS") ret |= DomainShaderVisibility;
133 else if (component == "GS") ret |= GeometryShaderVisibility;
134 else if (component == "PS") ret |= PixelShaderVisibility;
135 else if (component == "CS") ret |= ComputeShaderVisibility;
136 else if (component == "TS") ret |= TaskShaderVisibility;
137 else if (component == "MS") ret |= MeshShaderVisibility;
138 else if (component == "RGS") ret |= RayGenerationShaderVisibility;
139 else if (component == "RAS") ret |= RayAnyHitShaderVisibility;
140 else if (component == "RCS") ret |= RayClosestHitShaderVisibility;
141 else if (component == "RMS") ret |= RayMissShaderVisibility;
142 else if (component == "RIS") ret |= RayIntersectionShaderVisibility;
143 else if (component == "CAS") ret |= CallableShaderVisibility;
144 }
145
146 return ret;
147}
148
149//------------------------------------------------------------------------------
152inline QueueType
154{
155 if (str == "Graphics") return GraphicsQueueType;
156 else if (str == "Compute") return ComputeQueueType;
157 else if (str == "Transfer") return TransferQueueType;
158 else if (str == "Sparse") return SparseQueueType;
159 return GraphicsQueueType;
160}
161
162//------------------------------------------------------------------------------
165inline const char*
167{
168 switch (type)
169 {
171 return "Graphics";
172 case ComputeQueueType:
173 return "Compute";
175 return "Transfer";
176 case SparseQueueType:
177 return "Sparse";
178 default:
179 return "Graphics";
180 }
181}
182
183
185{
188};
189
191{
193 Top, // Top of pipe
194 Bottom, // Bottom of pipe
195 Indirect, // Indirect dispatch/draw fetching stage
196 Index, // Index fetch (automatically vertex shader)
197 Vertex, // Vertex fetch stage (automatically vertex shader)
198 UniformGraphics, // Uniform read on graphics queue
199 UniformCompute, // Uniform read on compute queue
200 InputAttachment, // Input attachment read (automatically pixel shader)
201 ReadOnlyAccess = InputAttachment, // All of the above enums are read-only
218 ColorRead, // Color output read
219 ColorWrite, // Color output write
220 DepthStencilRead, // Depth-Stencil output read
221 DepthStencilWrite, // Depth-Stencil output write
228 TransferRead, // Memory transfering read
229 TransferWrite, // Memory transfering write
230 HostRead, // Host operations read
231 HostWrite, // Host operations write
232 MemoryRead, // Memory operations read
233 MemoryWrite, // Memory operations write
234 AccelerationStructureRead, // Read acceleration structure
235 AccelerationStructureWrite, // Write acceleration structure
236 ImageInitial, // Special pipeline stage for initial images
237 Present // Special pipeline stage for present images
238};
239
241
242//------------------------------------------------------------------------------
245inline PipelineStage
247{
248 if (str == "Top") return PipelineStage::Top;
249 else if (str == "Bottom") return PipelineStage::Bottom;
250 else if (str == "IndirectRead") return PipelineStage::Indirect;
251 else if (str == "IndexRead") return PipelineStage::Index;
252 else if (str == "VertexRead") return PipelineStage::Vertex;
253 else if (str == "UniformGraphicsRead") return PipelineStage::UniformGraphics;
254 else if (str == "UniformComputeRead") return PipelineStage::UniformCompute;
255 else if (str == "InputAttachmentRead") return PipelineStage::InputAttachment;
256 else if (str == "VertexShaderRead") return PipelineStage::VertexShaderRead;
257 else if (str == "VertexShaderWrite") return PipelineStage::VertexShaderWrite;
258 else if (str == "HullShaderRead") return PipelineStage::HullShaderRead;
259 else if (str == "HullShaderWrite") return PipelineStage::HullShaderWrite;
260 else if (str == "DomainShaderRead") return PipelineStage::DomainShaderRead;
261 else if (str == "DomainShaderWrite") return PipelineStage::DomainShaderWrite;
262 else if (str == "GeometryShaderRead") return PipelineStage::GeometryShaderRead;
263 else if (str == "GeometryShaderWrite") return PipelineStage::GeometryShaderWrite;
264 else if (str == "PixelShaderRead") return PipelineStage::PixelShaderRead;
265 else if (str == "PixelShaderWrite") return PipelineStage::PixelShaderWrite;
266 else if (str == "ComputeShaderRead") return PipelineStage::ComputeShaderRead;
267 else if (str == "ComputeShaderWrite") return PipelineStage::ComputeShaderWrite;
268 else if (str == "ColorAttachmentRead") return PipelineStage::ColorRead;
269 else if (str == "ColorAttachmentWrite") return PipelineStage::ColorWrite;
270 else if (str == "DepthAttachmentRead") return PipelineStage::DepthStencilRead;
271 else if (str == "DepthAttachmentWrite") return PipelineStage::DepthStencilWrite;
272 else if (str == "TransferRead") return PipelineStage::TransferRead;
273 else if (str == "TransferWrite") return PipelineStage::TransferWrite;
274 else if (str == "HostRead") return PipelineStage::HostRead;
275 else if (str == "HostWrite") return PipelineStage::HostWrite;
276 else if (str == "MemoryRead") return PipelineStage::MemoryRead;
277 else if (str == "MemoryWrite") return PipelineStage::MemoryWrite;
278 else if (str == "Present") return PipelineStage::Present;
279 else
280 {
281 n_error("Invalid pipeline stage '%s'\n", str.AsCharPtr());
283 }
284}
285
286//------------------------------------------------------------------------------
289inline bool
310
311
312//------------------------------------------------------------------------------
316inline PipelineStage
318{
319 bool isGraphics = false;
320 switch (sourceStage)
321 {
332 switch (queue)
333 {
335 return sourceStage;
341 }
351 switch (queue)
352 {
354 return sourceStage;
360 }
363 switch (queue)
364 {
367 return sourceStage;
371 }
372 }
373
374 return sourceStage;
375}
376
377} // namespace CoreGraphics
378
379
380#define SHADER_POSTEFFECT_DEFAULT_FEATURE_MASK "Alt0"
381
382#if !PUBLIC_BUILD
383#define NEBULA_GRAPHICS_DEBUG 1
384#define NEBULA_MARKER_BLUE Math::vec4(0.8f, 0.8f, 1.0f, 1.0f)
385#define NEBULA_MARKER_RED Math::vec4(1.0f, 0.8f, 0.8f, 1.0f)
386#define NEBULA_MARKER_GREEN Math::vec4(0.8f, 1.0f, 0.8f, 1.0f)
387#define NEBULA_MARKER_DARK_GREEN Math::vec4(0.6f, 0.8f, 0.6f, 1.0f)
388#define NEBULA_MARKER_DARK_DARK_GREEN Math::vec4(0.5f, 0.7f, 0.5f, 1.0f)
389#define NEBULA_MARKER_PINK Math::vec4(1.0f, 0.8f, 0.9f, 1.0f)
390#define NEBULA_MARKER_PURPLE Math::vec4(0.9f, 0.7f, 0.9f, 1.0f)
391#define NEBULA_MARKER_ORANGE Math::vec4(1.0f, 0.9f, 0.8f, 1.0f)
392#define NEBULA_MARKER_TURQOISE Math::vec4(0.8f, 0.9f, 1.0f, 1.0f)
393#define NEBULA_MARKER_GRAY Math::vec4(0.9f, 0.9f, 0.9f, 1.0f)
394#define NEBULA_MARKER_BLACK Math::vec4(0.001f)
395#define NEBULA_MARKER_WHITE Math::vec4(1)
396
397#define NEBULA_MARKER_COMPUTE NEBULA_MARKER_BLUE
398#define NEBULA_MARKER_GRAPHICS NEBULA_MARKER_GREEN
399#define NEBULA_MARKER_TRANSFER NEBULA_MARKER_RED
400
401#endif
402
403//------------------------------------------------------------------------------
404#if __VULKAN__
405 #define COREGRAPHICS_TRIANGLE_FRONT_FACE_CCW (1)
406 // define the same descriptor set slots as we do in the shaders
407 #define NEBULA_TICK_GROUP 0 // set per tick (once for all views) by the system
408 #define NEBULA_FRAME_GROUP 1 // set per frame (once per view) by the system
409 #define NEBULA_PASS_GROUP 2 // set per pass by the system
410 #define NEBULA_BATCH_GROUP 3 // set per batch (material settings or system stuff)
411 #define NEBULA_INSTANCE_GROUP 4 // set a batch-internal copy of some specific settings
412 #define NEBULA_SYSTEM_GROUP 5 // set a batch-internal copy of some specific settings
413 #define NEBULA_DYNAMIC_OFFSET_GROUP 6 // set once per shader and is offset for each instance
414 #define NEBULA_NUM_GROUPS (NEBULA_DYNAMIC_OFFSET_GROUP + 1)
415
416 #define MAX_INPUT_ATTACHMENTS 32
417
418 #define SHADER_MODEL_5 (1)
419 #ifdef _DEBUG
420 #define NEBULA_VULKAN_DEBUG (1)
421 #else
422 #define NEBULA_VULKAN_DEBUG (0)
423 #endif
424 #define PROJECTION_HANDEDNESS_LH (0)
425#if __X64__
426 #define VK_DEVICE_SIZE_CONV(x) uint64_t(x)
427#else
428 #define VK_DEVICE_SIZE_CONV(x) uint32_t(x)
429#endif
430#endif
431//------------------------------------------------------------------------------
Nebula's dynamic array class.
Definition array.h:60
const SizeT Size() const
get number of elements in array
Definition array.h:880
void __cdecl n_error(const char *msg,...)
This function is called when a serious situation is encountered which requires abortion of the applic...
Definition debug.cc:138
Acceleration structures are used to enable ray tracing on the GPU by dividing the scene into a BVH.
Definition accelerationstructure.h:24
ImageLayout
Definition config.h:97
@ General
Definition config.h:99
@ ShaderRead
Definition config.h:103
@ ColorRenderTexture
Definition config.h:100
@ TransferSource
Definition config.h:104
@ TransferDestination
Definition config.h:105
@ DepthStencilRead
Definition config.h:102
@ DepthStencilRenderTexture
Definition config.h:101
@ Present
Definition config.h:107
@ Undefined
Definition config.h:98
@ Preinitialized
Definition config.h:106
QueryType
Definition config.h:52
@ TimestampsQueryType
Definition config.h:55
@ NumQueryTypes
Definition config.h:56
@ StatisticsQueryType
Definition config.h:54
@ OcclusionQueryType
Definition config.h:53
const char * QueueNameFromQueueType(const QueueType type)
Definition config.h:166
QueueType
Definition config.h:40
@ ComputeQueueType
Definition config.h:42
@ NumQueueTypes
Definition config.h:46
@ InvalidQueueType
Definition config.h:48
@ SparseQueueType
Definition config.h:44
@ GraphicsQueueType
Definition config.h:41
@ TransferQueueType
Definition config.h:43
ShaderVisibility
Definition config.h:60
@ AllGraphicsVisibility
Definition config.h:67
@ InvalidVisibility
Definition config.h:61
@ VertexShaderVisibility
Definition config.h:62
@ RayMissShaderVisibility
Definition config.h:74
@ RayGenerationShaderVisibility
Definition config.h:71
@ HullShaderVisibility
Definition config.h:63
@ ComputeShaderVisibility
Definition config.h:70
@ TaskShaderVisibility
Definition config.h:68
@ MeshShaderVisibility
Definition config.h:69
@ CallableShaderVisibility
Definition config.h:76
@ RayAnyHitShaderVisibility
Definition config.h:72
@ GeometryShaderVisibility
Definition config.h:65
@ RayIntersectionShaderVisibility
Definition config.h:75
@ DomainShaderVisibility
Definition config.h:64
@ RayClosestHitShaderVisibility
Definition config.h:73
@ AllVisibility
Definition config.h:77
@ PixelShaderVisibility
Definition config.h:66
bool PipelineStageWrites(const PipelineStage stage)
Definition config.h:290
PipelineStage PipelineStageFromString(const Util::String &str)
Definition config.h:246
uint64 ConstantBufferOffset
Definition config.h:21
ShaderPipeline
Definition config.h:111
@ ComputePipeline
Definition config.h:114
@ InvalidPipeline
Definition config.h:112
@ GraphicsPipeline
Definition config.h:113
@ RayTracingPipeline
Definition config.h:115
ImageBits
Definition config.h:82
@ Auto
Definition config.h:84
@ Plane2Bits
Definition config.h:91
@ DepthBits
Definition config.h:86
@ Plane1Bits
Definition config.h:90
@ MetaBits
Definition config.h:88
@ Plane0Bits
Definition config.h:89
@ ColorBits
Definition config.h:85
@ StencilBits
Definition config.h:87
BarrierDomain
Definition config.h:185
@ Global
Definition config.h:186
@ Pass
Definition config.h:187
PipelineStage
Definition config.h:191
@ VertexShaderWrite
Definition config.h:203
@ Indirect
Definition config.h:195
@ HullShaderWrite
Definition config.h:205
@ AllShadersWrite
Definition config.h:217
@ InputAttachment
Definition config.h:200
@ Bottom
Definition config.h:194
@ ColorWrite
Definition config.h:219
@ TaskShaderRead
Definition config.h:224
@ MeshShaderWrite
Definition config.h:227
@ GeometryShaderWrite
Definition config.h:209
@ AccelerationStructureRead
Definition config.h:234
@ HostWrite
Definition config.h:231
@ VertexShaderRead
Definition config.h:202
@ MemoryRead
Definition config.h:232
@ TaskShaderWrite
Definition config.h:225
@ MemoryWrite
Definition config.h:233
@ HullShaderRead
Definition config.h:204
@ GeometryShaderRead
Definition config.h:208
@ ImageInitial
Definition config.h:236
@ UniformGraphics
Definition config.h:198
@ RayTracingShaderWrite
Definition config.h:223
@ ComputeShaderWrite
Definition config.h:215
@ Index
Definition config.h:196
@ ColorRead
Definition config.h:218
@ HostRead
Definition config.h:230
@ Top
Definition config.h:193
@ DepthStencilRead
Definition config.h:220
@ AllShadersRead
Definition config.h:216
@ DepthStencilWrite
Definition config.h:221
@ DomainShaderWrite
Definition config.h:207
@ Vertex
Definition config.h:197
@ GraphicsShadersWrite
Definition config.h:213
@ TransferRead
Definition config.h:228
@ AccelerationStructureWrite
Definition config.h:235
@ InvalidStage
Definition config.h:192
@ UniformCompute
Definition config.h:199
@ GraphicsShadersRead
Definition config.h:212
@ ReadOnlyAccess
Definition config.h:201
@ PixelShaderWrite
Definition config.h:211
@ MeshShaderRead
Definition config.h:226
@ Present
Definition config.h:237
@ RayTracingShaderRead
Definition config.h:222
@ DomainShaderRead
Definition config.h:206
@ PixelShaderRead
Definition config.h:210
@ ComputeShaderRead
Definition config.h:214
@ TransferWrite
Definition config.h:229
PipelineStage ConvertToQueue(const CoreGraphics::PipelineStage sourceStage, const CoreGraphics::QueueType queue)
Demotes an input source stage to a QueueType.
Definition config.h:317
QueueType QueueTypeFromString(const Util::String &str)
Definition config.h:153
ShaderVisibility ShaderVisibilityFromString(const Util::String &str)
Definition config.h:122
static constexpr Id24 Index(const Id32 id)
Definition idgenerationpool.h:70
@ None
Definition resourceloader.h:51
#define __ImplementEnumComparisonOperators(type)
#define __ImplementEnumBitOperators(type)
This defines the macros for Nebula's RTTI mechanism (__DeclareClass, __ImplementClass,...
Nebula's universal string class.
Definition String.cs:8
const char * AsCharPtr() const
return contents as character pointer
Definition string.h:542
SizeT Tokenize(const String &whiteSpace, Array< String > &outTokens) const
tokenize string into a provided String array (faster if tokens array can be reused)
Definition string.cc:203
unsigned int uint
Definition types.h:31
uint64_t uint64
Definition types.h:36
int IndexT
Definition types.h:48
Definition config.h:24
uint topo
Definition config.h:27
byte key
Definition config.h:30
void operator=(const InputAssemblyKey &rhs)
Definition config.h:32
bool operator<(const InputAssemblyKey &rhs) const
Definition config.h:36
bool operator!=(const InputAssemblyKey &rhs) const
Definition config.h:34
bool primRestart
Definition config.h:28
bool operator==(const InputAssemblyKey &rhs) const
Definition config.h:33
bool operator>(const InputAssemblyKey &rhs) const
Definition config.h:35