#include <inttypes.h>
#include <stddef.h>
#include "slang-image-format-defs.h"
#include "slang-deprecated.h"

slang.h 的引用(Include)关系图:

此图展示该文件直接或间接的被哪些文件引用了:

类
struct	slang::CompilerOptionValue

struct	slang::CompilerOptionEntry

struct	SlangUUID

struct	ISlangUnknown

class	ISlangCastable

class	ISlangClonable

struct	ISlangBlob

struct	SlangTerminatedChars

struct	ISlangFileSystem

struct	ISlangSharedLibrary_Dep1

struct	ISlangSharedLibrary

struct	ISlangSharedLibraryLoader

struct	ISlangFileSystemExt

struct	ISlangMutableFileSystem

struct	ISlangWriter

struct	ISlangProfiler

union	SlangReflectionGenericArg

命名空间
namespace	slang

宏定义
#define	SLANG_COMPILER

#define	SLANG_VC 0

#define	SLANG_CLANG 0

#define	SLANG_SNC 0

#define	SLANG_GHS 0

#define	SLANG_GCC 0

#define	SLANG_PLATFORM

#define	SLANG_WINRT 0

#define	SLANG_XBOXONE 0

#define	SLANG_WIN64 0

#define	SLANG_X360 0

#define	SLANG_WIN32 0

#define	SLANG_ANDROID 0

#define	SLANG_LINUX 0

#define	SLANG_IOS 0

#define	SLANG_OSX 0

#define	SLANG_PS3 0

#define	SLANG_PS4 0

#define	SLANG_PSP2 0

#define	SLANG_WIIU 0

#define	SLANG_WASM 0

#define	SLANG_GCC_FAMILY (SLANG_CLANG \|\| SLANG_SNC \|\| SLANG_GHS \|\| SLANG_GCC)

#define	SLANG_WINDOWS_FAMILY (SLANG_WINRT \|\| SLANG_WIN32 \|\| SLANG_WIN64)

#define	SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE \|\| SLANG_X360 \|\| SLANG_WINDOWS_FAMILY)

#define	SLANG_LINUX_FAMILY (SLANG_LINUX \|\| SLANG_ANDROID)

#define	SLANG_APPLE_FAMILY (SLANG_IOS \|\| SLANG_OSX) /* equivalent to #if __APPLE__ */

#define	SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY \|\| SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */

#define	SLANG_ENABLE_DXVK 0

#define	SLANG_ENABLE_VKD3D 0

#define	SLANG_ENABLE_DIRECTX 0

#define	SLANG_ENABLE_DXGI_DEBUG 0

#define	SLANG_ENABLE_DXBC_SUPPORT 0

#define	SLANG_ENABLE_PIX 0

#define	SLANG_NO_THROW

#define	SLANG_STDCALL

#define	SLANG_MCALL SLANG_STDCALL

#define	SLANG_DYNAMIC

#define	SLANG_DLL_EXPORT __attribute__((__visibility__("default")))

#define	SLANG_API SLANG_DLL_EXPORT

#define	SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)

#define	SLANG_FORCE_INLINE inline

#define	SLANG_NO_INLINE

#define	SLANG_COMPILE_TIME_ASSERT(x) static_assert(x)

#define	SLANG_BREAKPOINT(id) (((int)0) = int(id));

#define	SLANG_COUNT_OF(x) (SlangSSizeT(sizeof(x) / sizeof(0 [x])))

#define	SLANG_INLINE inline
	SLANG_INLINE exists to have a way to inline consistent with SLANG_ALWAYS_INLINE

#define	SLANG_HAS_EXCEPTIONS 1

#define	SLANG_STRINGIZE_HELPER(X) #X

#define	SLANG_STRINGIZE(X) SLANG_STRINGIZE_HELPER(X)

#define	SLANG_CONCAT_HELPER(X, Y) X##Y

#define	SLANG_CONCAT(X, Y) SLANG_CONCAT_HELPER(X, Y)

#define	SLANG_UNUSED(v) (void)v;

#define	SLANG_MAYBE_UNUSED

#define	SLANG_INT64(x) (x##ll)

#define	SLANG_UINT64(x) (x##ull)

#define	SLANG_EXTERN_C

#define	SLANG_PROCESSOR_ARM 0

#define	SLANG_PROCESSOR_ARM_64 0

#define	SLANG_PROCESSOR_X86 0

#define	SLANG_PROCESSOR_X86_64 0

#define	SLANG_PROCESSOR_POWER_PC 0

#define	SLANG_PROCESSOR_POWER_PC_64 0

#define	SLANG_PROCESSOR_WASM 0

#define	SLANG_PROCESSOR_FAMILY_X86 (SLANG_PROCESSOR_X86_64 \| SLANG_PROCESSOR_X86)

#define	SLANG_PROCESSOR_FAMILY_ARM (SLANG_PROCESSOR_ARM \| SLANG_PROCESSOR_ARM_64)

#define	SLANG_PROCESSOR_FAMILY_POWER_PC (SLANG_PROCESSOR_POWER_PC_64 \| SLANG_PROCESSOR_POWER_PC)

#define	SLANG_PTR_IS_64 (SLANG_PROCESSOR_ARM_64 \| SLANG_PROCESSOR_X86_64 \| SLANG_PROCESSOR_POWER_PC_64)

#define	SLANG_PTR_IS_32 (SLANG_PTR_IS_64 ^ 1)

#define	SLANG_LITTLE_ENDIAN 0

#define	SLANG_BIG_ENDIAN 0

#define	SLANG_UNALIGNED_ACCESS 0

#define	SLANG_HAS_BACKTRACE 0

#define	SLANG_DEPRECATED [[deprecated]]

#define	SLANG_FAILED(status) ((status) < 0)

#define	SLANG_SUCCEEDED(status) ((status) >= 0)

#define	SLANG_GET_RESULT_FACILITY(r) ((int32_t)(((r) >> 16) & 0x7fff))
	Get the facility the result is associated with

#define	SLANG_GET_RESULT_CODE(r) ((int32_t)((r) & 0xffff))
	Get the result code for the facility

#define	SLANG_MAKE_ERROR(fac, code) ((((int32_t)(fac)) << 16) \| ((int32_t)(code)) \| int32_t(0x80000000))

#define	SLANG_MAKE_SUCCESS(fac, code) ((((int32_t)(fac)) << 16) \| ((int32_t)(code)))

#define	SLANG_FACILITY_WIN_GENERAL 0
	Facilities compatible with windows COM - only use if known code is compatible

#define	SLANG_FACILITY_WIN_INTERFACE 4

#define	SLANG_FACILITY_WIN_API 7

#define	SLANG_FACILITY_BASE 0x200

#define	SLANG_FACILITY_CORE SLANG_FACILITY_BASE

#define	SLANG_FACILITY_INTERNAL SLANG_FACILITY_BASE + 1

#define	SLANG_FACILITY_EXTERNAL_BASE 0x210
	Base for external facilities. Facilities should be unique across modules.

#define	SLANG_OK 0

#define	SLANG_FAIL SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, 0x4005)

#define	SLANG_MAKE_WIN_GENERAL_ERROR(code) SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, code)

#define	SLANG_E_NOT_IMPLEMENTED SLANG_MAKE_WIN_GENERAL_ERROR(0x4001)
	Functionality is not implemented

#define	SLANG_E_NO_INTERFACE SLANG_MAKE_WIN_GENERAL_ERROR(0x4002)
	Interface not be found

#define	SLANG_E_ABORT SLANG_MAKE_WIN_GENERAL_ERROR(0x4004)
	Operation was aborted (did not correctly complete)

#define	SLANG_E_INVALID_HANDLE SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 6)
	Indicates that a handle passed in as parameter to a method is invalid.

#define	SLANG_E_INVALID_ARG SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0x57)
	Indicates that an argument passed in as parameter to a method is invalid.

#define	SLANG_E_OUT_OF_MEMORY SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0xe)
	Operation could not complete - ran out of memory

#define	SLANG_MAKE_CORE_ERROR(code) SLANG_MAKE_ERROR(SLANG_FACILITY_CORE, code)

#define	SLANG_E_BUFFER_TOO_SMALL SLANG_MAKE_CORE_ERROR(1)

#define	SLANG_E_UNINITIALIZED SLANG_MAKE_CORE_ERROR(2)

#define	SLANG_E_PENDING SLANG_MAKE_CORE_ERROR(3)

#define	SLANG_E_CANNOT_OPEN SLANG_MAKE_CORE_ERROR(4)
	Indicates a file/resource could not be opened

#define	SLANG_E_NOT_FOUND SLANG_MAKE_CORE_ERROR(5)
	Indicates a file/resource could not be found

#define	SLANG_E_INTERNAL_FAIL SLANG_MAKE_CORE_ERROR(6)
	An unhandled internal failure (typically from unhandled exception)

#define	SLANG_E_NOT_AVAILABLE SLANG_MAKE_CORE_ERROR(7)
	Could not complete because some underlying feature (hardware or software) was not available

#define	SLANG_E_TIME_OUT SLANG_MAKE_CORE_ERROR(8)
	Could not complete because the operation times out.

#define	SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)

#define	SLANG_CLASS_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)

#define	SLANG_IID_PPV_ARGS(ppType)

#define	SLANG_UUID_ISlangUnknown ISlangUnknown::getTypeGuid()

#define	SLANG_UUID_ISlangBlob ISlangBlob::getTypeGuid()

#define	SLANG_UUID_ISlangFileSystem ISlangFileSystem::getTypeGuid()

#define	SLANG_UUID_ISlangSharedLibrary_Dep1 ISlangSharedLibrary_Dep1::getTypeGuid()

#define	SLANG_UUID_ISlangSharedLibrary ISlangSharedLibrary::getTypeGuid()

#define	SLANG_UUID_ISlangSharedLibraryLoader ISlangSharedLibraryLoader::getTypeGuid()

#define	SLANG_UUID_ISlangFileSystemExt ISlangFileSystemExt::getTypeGuid()

#define	SLANG_UUID_ISlangMutableFileSystem ISlangMutableFileSystem::getTypeGuid()

#define	SLANG_UUID_ISlangWriter ISlangWriter::getTypeGuid()

#define	SLANG_UUID_ISlangProfiler ISlangProfiler::getTypeGuid()

#define	SLANG_RESOURCE_SHAPE

#define	SLANG_FORMAT(NAME, DESC) SLANG_IMAGE_FORMAT_##NAME,

#define	SLANG_UNBOUNDED_SIZE (~size_t(0))

#define	SLANG_UNKNOWN_SIZE (SLANG_UNBOUNDED_SIZE - 1)

#define	SLANG_ERROR_INSUFFICIENT_BUFFER SLANG_E_BUFFER_TOO_SMALL

#define	SLANG_ERROR_INVALID_PARAMETER SLANG_E_INVALID_ARG

类型定义
typedef uint32_t	SlangUInt32

typedef int32_t	SlangInt32

typedef int32_t	SlangInt

typedef uint32_t	SlangUInt

typedef int32_t	SlangSSizeT

typedef uint32_t	SlangSizeT

typedef bool	SlangBool

typedef int	SlangSeverityIntegral
	Severity of a diagnostic generated by the compiler. Values come from the enum below, with higher values representing more severe conditions, and all values >= SLANG_SEVERITY_ERROR indicating compilation failure.

typedef int	SlangDiagnosticFlags

typedef int	SlangBindableResourceIntegral

typedef int	SlangCompileTargetIntegral

typedef int	SlangContainerFormatIntegral

typedef int	SlangPassThroughIntegral

typedef int	SlangArchiveTypeIntegral

typedef unsigned int	SlangCompileFlags

typedef unsigned int	SlangTargetFlags
	Flags to control code generation behavior of a compilation target

typedef unsigned int	SlangFloatingPointModeIntegral
	Options to control floating-point precision guarantees for a target.

typedef unsigned int	SlangFpDenormalModeIntegral
	Options to control floating-point denormal handling mode for a target.

typedef unsigned int	SlangLineDirectiveModeIntegral
	Options to control emission of `#line` directives

typedef int	SlangSourceLanguageIntegral

typedef unsigned int	SlangProfileIDIntegral

typedef SlangInt32	SlangCapabilityIDIntegral

typedef unsigned int	SlangMatrixLayoutModeIntegral

typedef SlangUInt32	SlangStageIntegral

typedef SlangUInt32	SlangScopeIntegral

typedef SlangUInt32	SlangCooperativeMatrixUseIntegral

typedef SlangUInt32	SlangCooperativeVectorMatrixLayoutIntegral

typedef SlangUInt32	SlangDebugInfoLevelIntegral

typedef SlangUInt32	SlangDebugInfoFormatIntegral

typedef SlangUInt32	SlangOptimizationLevelIntegral

typedef int32_t	SlangResult

typedef void(*	SlangFuncPtr) (void)

typedef unsigned int	SlangPathTypeIntegral

typedef void(*	FileSystemContentsCallBack) (SlangPathType pathType, const char name, void userData)

typedef unsigned int	SlangWriterChannelIntegral

typedef unsigned int	SlangWriterModeIntegral

typedef slang::IGlobalSession	SlangSession
	An instance of the Slang library.

typedef struct SlangProgramLayout	SlangProgramLayout

typedef struct slang::ICompileRequest	SlangCompileRequest
	A request for one or more compilation actions to be performed.

typedef void(*	SlangDiagnosticCallback) (char const message, void userData)
	Callback type used for diagnostic output.

typedef struct SlangEntryPoint	SlangEntryPoint

typedef struct SlangEntryPointLayout	SlangEntryPointLayout

typedef struct SlangReflectionDecl	SlangReflectionDecl

typedef struct SlangReflectionModifier	SlangReflectionModifier

typedef struct SlangReflectionType	SlangReflectionType

typedef struct SlangReflectionTypeLayout	SlangReflectionTypeLayout

typedef struct SlangReflectionVariable	SlangReflectionVariable

typedef struct SlangReflectionVariableLayout	SlangReflectionVariableLayout

typedef struct SlangReflectionTypeParameter	SlangReflectionTypeParameter

typedef struct SlangReflectionUserAttribute	SlangReflectionUserAttribute

typedef SlangReflectionUserAttribute	SlangReflectionAttribute

typedef struct SlangReflectionFunction	SlangReflectionFunction

typedef struct SlangReflectionGeneric	SlangReflectionGeneric

typedef SlangProgramLayout	SlangReflection

typedef SlangEntryPointLayout	SlangReflectionEntryPoint

typedef unsigned int	SlangTypeKindIntegral

typedef unsigned int	SlangScalarTypeIntegral

typedef unsigned int	SlangDeclKindIntegral

typedef unsigned int	SlangResourceShapeIntegral

typedef unsigned int	SlangResourceAccessIntegral

typedef unsigned int	SlangParameterCategoryIntegral

typedef SlangUInt32	SlangBindingTypeIntegral

typedef SlangUInt32	SlangLayoutRulesIntegral

typedef SlangUInt32	SlangModifierIDIntegral

typedef SlangUInt32	SlangImageFormatIntegral

typedef SlangReflectionVariableLayout	SlangReflectionParameter

枚举
enum	SlangSeverity : SlangSeverityIntegral { SLANG_SEVERITY_DISABLED = 0 , SLANG_SEVERITY_NOTE = 1 , SLANG_SEVERITY_WARNING = 2 , SLANG_SEVERITY_ERROR = 3 , SLANG_SEVERITY_FATAL = 4 , SLANG_SEVERITY_INTERNAL }

enum	{ SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS = 0x01 , SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS = 0x02 }

enum	SlangBindableResourceType : SlangBindableResourceIntegral { SLANG_NON_BINDABLE = 0 , SLANG_TEXTURE = 1 , SLANG_SAMPLER = 2 , SLANG_UNIFORM_BUFFER = 3 , SLANG_STORAGE_BUFFER = 4 }

enum	SlangCompileTarget : SlangCompileTargetIntegral { SLANG_TARGET_UNKNOWN = 0 , SLANG_TARGET_NONE = 1 , SLANG_GLSL = 2 , SLANG_GLSL_VULKAN_DEPRECATED = 3 , SLANG_GLSL_VULKAN_ONE_DESC_DEPRECATED = 4 , SLANG_HLSL = 5 , SLANG_SPIRV = 6 , SLANG_SPIRV_ASM = 7 , SLANG_DXBC = 8 , SLANG_DXBC_ASM = 9 , SLANG_DXIL = 10 , SLANG_DXIL_ASM = 11 , SLANG_C_SOURCE = 12 , SLANG_CPP_SOURCE = 13 , SLANG_HOST_EXECUTABLE = 14 , SLANG_SHADER_SHARED_LIBRARY = 15 , SLANG_SHADER_HOST_CALLABLE = 16 , SLANG_CUDA_SOURCE = 17 , SLANG_PTX = 18 , SLANG_CUDA_OBJECT_CODE = 19 , SLANG_OBJECT_CODE = 20 , SLANG_HOST_CPP_SOURCE = 21 , SLANG_HOST_HOST_CALLABLE = 22 , SLANG_CPP_PYTORCH_BINDING = 23 , SLANG_METAL = 24 , SLANG_METAL_LIB = 25 , SLANG_METAL_LIB_ASM = 26 , SLANG_HOST_SHARED_LIBRARY = 27 , SLANG_WGSL = 28 , SLANG_WGSL_SPIRV_ASM = 29 , SLANG_WGSL_SPIRV = 30 , SLANG_HOST_VM = 31 , SLANG_CPP_HEADER = 32 , SLANG_CUDA_HEADER = 33 , SLANG_HOST_OBJECT_CODE = 34 , SLANG_HOST_LLVM_IR = 35 , SLANG_SHADER_LLVM_IR = 36 , SLANG_TARGET_COUNT_OF }

enum	SlangContainerFormat : SlangContainerFormatIntegral { SLANG_CONTAINER_FORMAT_NONE = 0 , SLANG_CONTAINER_FORMAT_SLANG_MODULE = 1 }

enum	SlangPassThrough : SlangPassThroughIntegral { SLANG_PASS_THROUGH_NONE = 0 , SLANG_PASS_THROUGH_FXC = 1 , SLANG_PASS_THROUGH_DXC = 2 , SLANG_PASS_THROUGH_GLSLANG = 3 , SLANG_PASS_THROUGH_SPIRV_DIS = 4 , SLANG_PASS_THROUGH_CLANG = 5 , SLANG_PASS_THROUGH_VISUAL_STUDIO = 6 , SLANG_PASS_THROUGH_GCC = 7 , SLANG_PASS_THROUGH_GENERIC_C_CPP = 8 , SLANG_PASS_THROUGH_NVRTC = 9 , SLANG_PASS_THROUGH_LLVM = 10 , SLANG_PASS_THROUGH_SPIRV_OPT = 11 , SLANG_PASS_THROUGH_METAL = 12 , SLANG_PASS_THROUGH_TINT = 13 , SLANG_PASS_THROUGH_SPIRV_LINK = 14 , SLANG_PASS_THROUGH_COUNT_OF }

enum	SlangArchiveType : SlangArchiveTypeIntegral { SLANG_ARCHIVE_TYPE_UNDEFINED = 0 , SLANG_ARCHIVE_TYPE_ZIP = 1 , SLANG_ARCHIVE_TYPE_RIFF = 2 , SLANG_ARCHIVE_TYPE_RIFF_DEFLATE = 3 , SLANG_ARCHIVE_TYPE_RIFF_LZ4 = 4 , SLANG_ARCHIVE_TYPE_COUNT_OF }

enum	{ SLANG_COMPILE_FLAG_NO_MANGLING = 1 << 3 , SLANG_COMPILE_FLAG_NO_CODEGEN = 1 << 4 , SLANG_COMPILE_FLAG_OBFUSCATE = 1 << 5 , SLANG_COMPILE_FLAG_NO_CHECKING = 0 , SLANG_COMPILE_FLAG_SPLIT_MIXED_TYPES = 0 }

enum	{ SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES = 1 << 4 , SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM = 1 << 8 , SLANG_TARGET_FLAG_DUMP_IR = 1 << 9 , SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY = 1 << 10 }

enum	SlangFloatingPointMode : SlangFloatingPointModeIntegral { SLANG_FLOATING_POINT_MODE_DEFAULT = 0 , SLANG_FLOATING_POINT_MODE_FAST = 1 , SLANG_FLOATING_POINT_MODE_PRECISE = 2 }

enum	SlangFpDenormalMode : SlangFpDenormalModeIntegral { SLANG_FP_DENORM_MODE_ANY = 0 , SLANG_FP_DENORM_MODE_PRESERVE = 1 , SLANG_FP_DENORM_MODE_FTZ = 2 }

enum	SlangLineDirectiveMode : SlangLineDirectiveModeIntegral { SLANG_LINE_DIRECTIVE_MODE_DEFAULT , SLANG_LINE_DIRECTIVE_MODE_NONE = 1 , SLANG_LINE_DIRECTIVE_MODE_STANDARD = 2 , SLANG_LINE_DIRECTIVE_MODE_GLSL = 3 , SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP = 4 }

enum	SlangSourceLanguage : SlangSourceLanguageIntegral { SLANG_SOURCE_LANGUAGE_UNKNOWN = 0 , SLANG_SOURCE_LANGUAGE_SLANG = 1 , SLANG_SOURCE_LANGUAGE_HLSL = 2 , SLANG_SOURCE_LANGUAGE_GLSL = 3 , SLANG_SOURCE_LANGUAGE_C = 4 , SLANG_SOURCE_LANGUAGE_CPP = 5 , SLANG_SOURCE_LANGUAGE_CUDA = 6 , SLANG_SOURCE_LANGUAGE_SPIRV = 7 , SLANG_SOURCE_LANGUAGE_METAL = 8 , SLANG_SOURCE_LANGUAGE_WGSL = 9 , SLANG_SOURCE_LANGUAGE_LLVM = 10 , SLANG_SOURCE_LANGUAGE_COUNT_OF }

enum	SlangProfileID : SlangProfileIDIntegral { SLANG_PROFILE_UNKNOWN = 0 }

enum	SlangCapabilityID : SlangCapabilityIDIntegral { SLANG_CAPABILITY_UNKNOWN = 0 }

enum	SlangMatrixLayoutMode : SlangMatrixLayoutModeIntegral { SLANG_MATRIX_LAYOUT_MODE_UNKNOWN = 0 , SLANG_MATRIX_LAYOUT_ROW_MAJOR = 1 , SLANG_MATRIX_LAYOUT_COLUMN_MAJOR = 2 }

enum	SlangStage : SlangStageIntegral { SLANG_STAGE_NONE = 0 , SLANG_STAGE_VERTEX = 1 , SLANG_STAGE_HULL = 2 , SLANG_STAGE_DOMAIN = 3 , SLANG_STAGE_GEOMETRY = 4 , SLANG_STAGE_FRAGMENT = 5 , SLANG_STAGE_COMPUTE = 6 , SLANG_STAGE_RAY_GENERATION = 7 , SLANG_STAGE_INTERSECTION = 8 , SLANG_STAGE_ANY_HIT = 9 , SLANG_STAGE_CLOSEST_HIT = 10 , SLANG_STAGE_MISS = 11 , SLANG_STAGE_CALLABLE = 12 , SLANG_STAGE_MESH = 13 , SLANG_STAGE_AMPLIFICATION = 14 , SLANG_STAGE_DISPATCH = 15 , SLANG_STAGE_COUNT , SLANG_STAGE_PIXEL = SLANG_STAGE_FRAGMENT }

enum	SlangScope : SlangScopeIntegral { SLANG_SCOPE_NONE , SLANG_SCOPE_THREAD , SLANG_SCOPE_WAVE , SLANG_SCOPE_THREAD_GROUP }

enum	SlangCooperativeMatrixUse : SlangCooperativeMatrixUseIntegral { SLANG_COOPERATIVE_MATRIX_USE_A = 0 , SLANG_COOPERATIVE_MATRIX_USE_B = 1 , SLANG_COOPERATIVE_MATRIX_USE_ACCUMULATOR = 2 }

enum	SlangCooperativeVectorMatrixLayout : SlangCooperativeVectorMatrixLayoutIntegral { SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR = 0 , SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR = 1 , SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL = 2 , SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL = 3 }

enum	SlangDebugInfoLevel : SlangDebugInfoLevelIntegral { SLANG_DEBUG_INFO_LEVEL_NONE = 0 , SLANG_DEBUG_INFO_LEVEL_MINIMAL = 1 , SLANG_DEBUG_INFO_LEVEL_STANDARD = 2 , SLANG_DEBUG_INFO_LEVEL_MAXIMAL = 3 }

enum	SlangDebugInfoFormat : SlangDebugInfoFormatIntegral { SLANG_DEBUG_INFO_FORMAT_DEFAULT = 0 , SLANG_DEBUG_INFO_FORMAT_C7 = 1 , SLANG_DEBUG_INFO_FORMAT_PDB = 2 , SLANG_DEBUG_INFO_FORMAT_STABS = 3 , SLANG_DEBUG_INFO_FORMAT_COFF = 4 , SLANG_DEBUG_INFO_FORMAT_DWARF = 5 , SLANG_DEBUG_INFO_FORMAT_COUNT_OF }

enum	SlangOptimizationLevel : SlangOptimizationLevelIntegral { SLANG_OPTIMIZATION_LEVEL_NONE = 0 , SLANG_OPTIMIZATION_LEVEL_DEFAULT = 1 , SLANG_OPTIMIZATION_LEVEL_HIGH = 2 , SLANG_OPTIMIZATION_LEVEL_MAXIMAL = 3 }

enum	SlangEmitSpirvMethod { SLANG_EMIT_SPIRV_DEFAULT = 0 , SLANG_EMIT_SPIRV_VIA_GLSL = 1 , SLANG_EMIT_SPIRV_DIRECTLY = 2 }

enum	SlangEmitCPUMethod { SLANG_EMIT_CPU_DEFAULT = 0 , SLANG_EMIT_CPU_VIA_CPP = 1 , SLANG_EMIT_CPU_VIA_LLVM = 2 }

enum	SlangDiagnosticColor { SLANG_DIAGNOSTIC_COLOR_AUTO = 0 , SLANG_DIAGNOSTIC_COLOR_ALWAYS = 1 , SLANG_DIAGNOSTIC_COLOR_NEVER = 2 }

enum class	slang::CompilerOptionName { slang::MacroDefine = 0 , slang::DepFile = 1 , slang::EntryPointName = 2 , slang::Specialize = 3 , slang::Help = 4 , slang::HelpStyle = 5 , slang::Include = 6 , slang::Language = 7 , slang::MatrixLayoutColumn = 8 , slang::MatrixLayoutRow = 9 , slang::ZeroInitialize = 10 , slang::IgnoreCapabilities = 11 , slang::RestrictiveCapabilityCheck = 12 , slang::ModuleName = 13 , slang::Output = 14 , slang::Profile = 15 , slang::Stage = 16 , slang::Target = 17 , slang::Version = 18 , slang::WarningsAsErrors = 19 , slang::DisableWarnings = 20 , slang::EnableWarning = 21 , slang::DisableWarning = 22 , slang::DumpWarningDiagnostics = 23 , slang::InputFilesRemain = 24 , slang::EmitIr = 25 , slang::ReportDownstreamTime = 26 , slang::ReportPerfBenchmark = 27 , slang::ReportCheckpointIntermediates = 28 , slang::SkipSPIRVValidation = 29 , slang::SourceEmbedStyle = 30 , slang::SourceEmbedName = 31 , slang::SourceEmbedLanguage = 32 , slang::DisableShortCircuit = 33 , slang::MinimumSlangOptimization = 34 , slang::DisableNonEssentialValidations = 35 , slang::DisableSourceMap = 36 , slang::UnscopedEnum = 37 , slang::PreserveParameters = 38 , slang::Capability = 39 , slang::DefaultImageFormatUnknown = 40 , slang::DisableDynamicDispatch = 41 , slang::DisableSpecialization = 42 , slang::FloatingPointMode = 43 , slang::DebugInformation = 44 , slang::LineDirectiveMode = 45 , slang::Optimization = 46 , slang::Obfuscate = 47 , slang::VulkanBindShift = 48 , slang::VulkanBindGlobals = 49 , slang::VulkanInvertY = 50 , slang::VulkanUseDxPositionW = 51 , slang::VulkanUseEntryPointName = 52 , slang::VulkanUseGLLayout = 53 , slang::VulkanEmitReflection = 54 , slang::GLSLForceScalarLayout = 55 , slang::EnableEffectAnnotations = 56 , slang::EmitSpirvViaGLSL = 57 , slang::EmitSpirvDirectly = 58 , slang::SPIRVCoreGrammarJSON = 59 , slang::IncompleteLibrary = 60 , slang::CompilerPath = 61 , slang::DefaultDownstreamCompiler = 62 , slang::DownstreamArgs = 63 , slang::PassThrough = 64 , slang::DumpRepro = 65 , slang::DumpReproOnError = 66 , slang::ExtractRepro = 67 , slang::LoadRepro = 68 , slang::LoadReproDirectory = 69 , slang::ReproFallbackDirectory = 70 , slang::DumpAst = 71 , slang::DumpIntermediatePrefix = 72 , slang::DumpIntermediates = 73 , slang::DumpIr = 74 , slang::DumpIrIds = 75 , slang::PreprocessorOutput = 76 , slang::OutputIncludes = 77 , slang::ReproFileSystem = 78 , slang::REMOVED_SerialIR = 79 , slang::SkipCodeGen = 80 , slang::ValidateIr = 81 , slang::VerbosePaths = 82 , slang::VerifyDebugSerialIr = 83 , slang::NoCodeGen = 84 , slang::FileSystem = 85 , slang::Heterogeneous = 86 , slang::NoMangle = 87 , slang::NoHLSLBinding = 88 , slang::NoHLSLPackConstantBufferElements = 89 , slang::ValidateUniformity = 90 , slang::AllowGLSL = 91 , slang::EnableExperimentalPasses = 92 , slang::BindlessSpaceIndex = 93 , slang::SPIRVResourceHeapStride = 94 , slang::SPIRVSamplerHeapStride = 95 , slang::ArchiveType = 96 , slang::CompileCoreModule = 97 , slang::Doc = 98 , slang::IrCompression = 99 , slang::LoadCoreModule = 100 , slang::ReferenceModule = 101 , slang::SaveCoreModule = 102 , slang::SaveCoreModuleBinSource = 103 , slang::TrackLiveness = 104 , slang::LoopInversion = 105 , slang::ParameterBlocksUseRegisterSpaces = 106 , slang::LanguageVersion = 107 , slang::TypeConformance = 108 , slang::EnableExperimentalDynamicDispatch = 109 , slang::EmitReflectionJSON = 110 , slang::CountOfParsableOptions = 111 , slang::DebugInformationFormat = 112 , slang::VulkanBindShiftAll = 113 , slang::GenerateWholeProgram = 114 , slang::UseUpToDateBinaryModule = 115 , slang::EmbedDownstreamIR = 116 , slang::ForceDXLayout = 117 , slang::EmitSpirvMethod = 118 , slang::SaveGLSLModuleBinSource = 119 , slang::SkipDownstreamLinking = 120 , slang::DumpModule = 121 , slang::GetModuleInfo = 122 , slang::GetSupportedModuleVersions = 123 , slang::EmitSeparateDebug = 124 , slang::DenormalModeFp16 = 125 , slang::DenormalModeFp32 = 126 , slang::DenormalModeFp64 = 127 , slang::UseMSVCStyleBitfieldPacking = 128 , slang::ForceCLayout = 129 , slang::ExperimentalFeature = 130 , slang::ReportDetailedPerfBenchmark = 131 , slang::ValidateIRDetailed = 132 , slang::DumpIRBefore = 133 , slang::DumpIRAfter = 134 , slang::EmitCPUMethod = 135 , slang::EmitCPUViaCPP = 136 , slang::EmitCPUViaLLVM = 137 , slang::LLVMTargetTriple = 138 , slang::LLVMCPU = 139 , slang::LLVMFeatures = 140 , slang::EnableRichDiagnostics = 141 , slang::ReportDynamicDispatchSites = 142 , slang::EnableMachineReadableDiagnostics = 143 , slang::DiagnosticColor = 144 , slang::TraceCoverage = 145 , slang::TraceCoverageBinding , slang::TraceCoverageReservedSpace , slang::CountOf }

enum class	slang::CompilerOptionValueKind { slang::Int = 0 , slang::String = 1 }

enum	SlangPathType : SlangPathTypeIntegral { SLANG_PATH_TYPE_DIRECTORY = 0 , SLANG_PATH_TYPE_FILE = 1 }

enum class	OSPathKind : uint8_t { None = 0 , Direct = 1 , OperatingSystem = 2 }

enum class	PathKind { Simplified = 0 , Canonical = 1 , Display = 2 , OperatingSystem = 3 , CountOf }

enum	SlangWriterChannel : SlangWriterChannelIntegral { SLANG_WRITER_CHANNEL_DIAGNOSTIC = 0 , SLANG_WRITER_CHANNEL_STD_OUTPUT = 1 , SLANG_WRITER_CHANNEL_STD_ERROR = 2 , SLANG_WRITER_CHANNEL_COUNT_OF }

enum	SlangWriterMode : SlangWriterModeIntegral { SLANG_WRITER_MODE_TEXT = 0 , SLANG_WRITER_MODE_BINARY = 1 }

enum	SlangReflectionGenericArgType { SLANG_GENERIC_ARG_TYPE = 0 , SLANG_GENERIC_ARG_INT = 1 , SLANG_GENERIC_ARG_BOOL = 2 }

enum	SlangTypeKind : SlangTypeKindIntegral { SLANG_TYPE_KIND_NONE = 0 , SLANG_TYPE_KIND_STRUCT = 1 , SLANG_TYPE_KIND_ARRAY = 2 , SLANG_TYPE_KIND_MATRIX = 3 , SLANG_TYPE_KIND_VECTOR = 4 , SLANG_TYPE_KIND_SCALAR = 5 , SLANG_TYPE_KIND_CONSTANT_BUFFER = 6 , SLANG_TYPE_KIND_RESOURCE = 7 , SLANG_TYPE_KIND_SAMPLER_STATE = 8 , SLANG_TYPE_KIND_TEXTURE_BUFFER = 9 , SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER = 10 , SLANG_TYPE_KIND_PARAMETER_BLOCK = 11 , SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER = 12 , SLANG_TYPE_KIND_INTERFACE = 13 , SLANG_TYPE_KIND_OUTPUT_STREAM = 14 , SLANG_TYPE_KIND_MESH_OUTPUT = 15 , SLANG_TYPE_KIND_SPECIALIZED = 16 , SLANG_TYPE_KIND_FEEDBACK = 17 , SLANG_TYPE_KIND_POINTER = 18 , SLANG_TYPE_KIND_DYNAMIC_RESOURCE = 19 , SLANG_TYPE_KIND_ENUM = 20 , SLANG_TYPE_KIND_COUNT }

enum	SlangScalarType : SlangScalarTypeIntegral { SLANG_SCALAR_TYPE_NONE = 0 , SLANG_SCALAR_TYPE_VOID = 1 , SLANG_SCALAR_TYPE_BOOL = 2 , SLANG_SCALAR_TYPE_INT32 = 3 , SLANG_SCALAR_TYPE_UINT32 = 4 , SLANG_SCALAR_TYPE_INT64 = 5 , SLANG_SCALAR_TYPE_UINT64 = 6 , SLANG_SCALAR_TYPE_FLOAT16 = 7 , SLANG_SCALAR_TYPE_FLOAT32 = 8 , SLANG_SCALAR_TYPE_FLOAT64 = 9 , SLANG_SCALAR_TYPE_INT8 = 10 , SLANG_SCALAR_TYPE_UINT8 = 11 , SLANG_SCALAR_TYPE_INT16 = 12 , SLANG_SCALAR_TYPE_UINT16 = 13 , SLANG_SCALAR_TYPE_INTPTR = 14 , SLANG_SCALAR_TYPE_UINTPTR = 15 , SLANG_SCALAR_TYPE_BFLOAT16 = 16 , SLANG_SCALAR_TYPE_FLOAT_E4M3 = 17 , SLANG_SCALAR_TYPE_FLOAT_E5M2 = 18 }

enum	SlangDeclKind : SlangDeclKindIntegral { SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION = 0 , SLANG_DECL_KIND_STRUCT = 1 , SLANG_DECL_KIND_FUNC = 2 , SLANG_DECL_KIND_MODULE = 3 , SLANG_DECL_KIND_GENERIC = 4 , SLANG_DECL_KIND_VARIABLE = 5 , SLANG_DECL_KIND_NAMESPACE = 6 , SLANG_DECL_KIND_ENUM = 7 }

enum	SlangResourceShape : SlangResourceShapeIntegral { SLANG_RESOURCE_BASE_SHAPE_MASK = 0x0F , SLANG_RESOURCE_NONE = 0x00 , SLANG_TEXTURE_1D = 0x01 , SLANG_TEXTURE_2D = 0x02 , SLANG_TEXTURE_3D = 0x03 , SLANG_TEXTURE_CUBE = 0x04 , SLANG_TEXTURE_BUFFER = 0x05 , SLANG_STRUCTURED_BUFFER = 0x06 , SLANG_BYTE_ADDRESS_BUFFER = 0x07 , SLANG_RESOURCE_UNKNOWN = 0x08 , SLANG_ACCELERATION_STRUCTURE = 0x09 , SLANG_TEXTURE_SUBPASS = 0x0A , SLANG_RESOURCE_EXT_SHAPE_MASK = 0x1F0 , SLANG_TEXTURE_FEEDBACK_FLAG = 0x10 , SLANG_TEXTURE_SHADOW_FLAG = 0x20 , SLANG_TEXTURE_ARRAY_FLAG = 0x40 , SLANG_TEXTURE_MULTISAMPLE_FLAG = 0x80 , SLANG_TEXTURE_COMBINED_FLAG = 0x100 , SLANG_TEXTURE_1D_ARRAY = SLANG_TEXTURE_1D \| SLANG_TEXTURE_ARRAY_FLAG , SLANG_TEXTURE_2D_ARRAY = SLANG_TEXTURE_2D \| SLANG_TEXTURE_ARRAY_FLAG , SLANG_TEXTURE_CUBE_ARRAY = SLANG_TEXTURE_CUBE \| SLANG_TEXTURE_ARRAY_FLAG , SLANG_TEXTURE_2D_MULTISAMPLE = SLANG_TEXTURE_2D \| SLANG_TEXTURE_MULTISAMPLE_FLAG , SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY , SLANG_TEXTURE_SUBPASS_MULTISAMPLE = SLANG_TEXTURE_SUBPASS \| SLANG_TEXTURE_MULTISAMPLE_FLAG }

enum	SlangResourceAccess : SlangResourceAccessIntegral { SLANG_RESOURCE_ACCESS_NONE = 0 , SLANG_RESOURCE_ACCESS_READ = 1 , SLANG_RESOURCE_ACCESS_READ_WRITE = 2 , SLANG_RESOURCE_ACCESS_RASTER_ORDERED = 3 , SLANG_RESOURCE_ACCESS_APPEND = 4 , SLANG_RESOURCE_ACCESS_CONSUME = 5 , SLANG_RESOURCE_ACCESS_WRITE = 6 , SLANG_RESOURCE_ACCESS_FEEDBACK = 7 , SLANG_RESOURCE_ACCESS_UNKNOWN = 0x7FFFFFFF }

enum	SlangParameterCategory : SlangParameterCategoryIntegral { SLANG_PARAMETER_CATEGORY_NONE = 0 , SLANG_PARAMETER_CATEGORY_MIXED = 1 , SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER = 2 , SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE = 3 , SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS = 4 , SLANG_PARAMETER_CATEGORY_VARYING_INPUT = 5 , SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT = 6 , SLANG_PARAMETER_CATEGORY_SAMPLER_STATE = 7 , SLANG_PARAMETER_CATEGORY_UNIFORM = 8 , SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT = 9 , SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT = 10 , SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER = 11 , SLANG_PARAMETER_CATEGORY_REGISTER_SPACE = 12 , SLANG_PARAMETER_CATEGORY_GENERIC = 13 , SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD = 14 , SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES = 15 , SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD = 16 , SLANG_PARAMETER_CATEGORY_SHADER_RECORD = 17 , SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM = 18 , SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM = 19 , SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE = 20 , SLANG_PARAMETER_CATEGORY_SUBPASS = 21 , SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT = 22 , SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE = 23 , SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD = 24 , SLANG_PARAMETER_CATEGORY_COUNT , SLANG_PARAMETER_CATEGORY_METAL_BUFFER = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER , SLANG_PARAMETER_CATEGORY_METAL_TEXTURE = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE , SLANG_PARAMETER_CATEGORY_METAL_SAMPLER = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE , SLANG_PARAMETER_CATEGORY_VERTEX_INPUT = SLANG_PARAMETER_CATEGORY_VARYING_INPUT , SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT , SLANG_PARAMETER_CATEGORY_COUNT_V1 = SLANG_PARAMETER_CATEGORY_SUBPASS }

enum	SlangBindingType : SlangBindingTypeIntegral { SLANG_BINDING_TYPE_UNKNOWN = 0 , SLANG_BINDING_TYPE_SAMPLER = 1 , SLANG_BINDING_TYPE_TEXTURE = 2 , SLANG_BINDING_TYPE_CONSTANT_BUFFER = 3 , SLANG_BINDING_TYPE_PARAMETER_BLOCK = 4 , SLANG_BINDING_TYPE_TYPED_BUFFER = 5 , SLANG_BINDING_TYPE_RAW_BUFFER = 6 , SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER = 7 , SLANG_BINDING_TYPE_INPUT_RENDER_TARGET = 8 , SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA = 9 , SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE = 10 , SLANG_BINDING_TYPE_VARYING_INPUT = 11 , SLANG_BINDING_TYPE_VARYING_OUTPUT = 12 , SLANG_BINDING_TYPE_EXISTENTIAL_VALUE = 13 , SLANG_BINDING_TYPE_PUSH_CONSTANT = 14 , SLANG_BINDING_TYPE_MUTABLE_FLAG = 0x100 , SLANG_BINDING_TYPE_MUTABLE_TETURE , SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER , SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER , SLANG_BINDING_TYPE_BASE_MASK = 0x00FF , SLANG_BINDING_TYPE_EXT_MASK = 0xFF00 }

enum	SlangLayoutRules : SlangLayoutRulesIntegral { SLANG_LAYOUT_RULES_DEFAULT = 0 , SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2 = 1 , SLANG_LAYOUT_RULES_DEFAULT_STRUCTURED_BUFFER = 2 , SLANG_LAYOUT_RULES_DEFAULT_CONSTANT_BUFFER = 3 }

enum	SlangModifierID : SlangModifierIDIntegral { SLANG_MODIFIER_SHARED = 0 , SLANG_MODIFIER_NO_DIFF = 1 , SLANG_MODIFIER_STATIC = 2 , SLANG_MODIFIER_CONST = 3 , SLANG_MODIFIER_EXPORT = 4 , SLANG_MODIFIER_EXTERN = 5 , SLANG_MODIFIER_DIFFERENTIABLE = 6 , SLANG_MODIFIER_MUTATING = 7 , SLANG_MODIFIER_IN = 8 , SLANG_MODIFIER_OUT = 9 , SLANG_MODIFIER_INOUT = 10 }

enum	SlangImageFormat : SlangImageFormatIntegral

函数
SLANG_API const char *	spGetBuildTagString ()
	Get the build version 'tag' string. The string is the same as produced via `git describe --tags --match v*` for the project. If such a version could not be determined at build time then the contents will be 0.0.0-unknown. Any string can be set by passing -DSLANG_VERSION_FULL=whatever during the cmake invocation.

变量
constexpr SlangTargetFlags	kDefaultTargetFlags

详细描述

The Slang API provides services to compile, reflect, and specialize code written in the Slang shading language.

宏定义说明

◆ SLANG_ANDROID

#define SLANG_ANDROID 0

◆ SLANG_API

#define SLANG_API SLANG_DLL_EXPORT

◆ SLANG_APPLE_FAMILY

#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX) /* equivalent to #if __APPLE__ */

◆ SLANG_BIG_ENDIAN

#define SLANG_BIG_ENDIAN 0

◆ SLANG_BREAKPOINT

#define SLANG_BREAKPOINT ( id ) (*((int*)0) = int(id));

◆ SLANG_CLANG

#define SLANG_CLANG 0

◆ SLANG_CLASS_GUID

#define SLANG_CLASS_GUID	(	a,
		b,
		c,
		d0,
		d1,
		d2,
		d3,
		d4,
		d5,
		d6,
		d7 )

值:

    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid()   \
    {                                                             \
        return {a, b, c, d0, d1, d2, d3, d4, d5, d6, d7};         \
    }

◆ SLANG_COM_INTERFACE

#define SLANG_COM_INTERFACE	(	a,
		b,
		c,
		d0,
		d1,
		d2,
		d3,
		d4,
		d5,
		d6,
		d7 )

值:

public:                                                              \
    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid()      \
    {                                                                \
        return {a, b, c, d0, d1, d2, d3, d4, d5, d6, d7};            \
    }

◆ SLANG_COMPILE_TIME_ASSERT

#define SLANG_COMPILE_TIME_ASSERT ( x ) static_assert(x)

◆ SLANG_COMPILER

#define SLANG_COMPILER

◆ SLANG_CONCAT

#define SLANG_CONCAT	(		X,
			Y ) SLANG_CONCAT_HELPER(X, Y)

◆ SLANG_CONCAT_HELPER

#define SLANG_CONCAT_HELPER	(		X,
			Y ) X##Y

◆ SLANG_COUNT_OF

#define SLANG_COUNT_OF ( x ) (SlangSSizeT(sizeof(x) / sizeof(0 [x])))

◆ SLANG_DEPRECATED

#define SLANG_DEPRECATED [[deprecated]]

◆ SLANG_DLL_EXPORT

#define SLANG_DLL_EXPORT __attribute__((__visibility__("default")))

◆ SLANG_DYNAMIC

#define SLANG_DYNAMIC

◆ SLANG_E_ABORT

#define SLANG_E_ABORT SLANG_MAKE_WIN_GENERAL_ERROR(0x4004)

Operation was aborted (did not correctly complete)

◆ SLANG_E_BUFFER_TOO_SMALL

#define SLANG_E_BUFFER_TOO_SMALL SLANG_MAKE_CORE_ERROR(1)

◆ SLANG_E_CANNOT_OPEN

#define SLANG_E_CANNOT_OPEN SLANG_MAKE_CORE_ERROR(4)

Indicates a file/resource could not be opened

◆ SLANG_E_INTERNAL_FAIL

#define SLANG_E_INTERNAL_FAIL SLANG_MAKE_CORE_ERROR(6)

An unhandled internal failure (typically from unhandled exception)

◆ SLANG_E_INVALID_ARG

#define SLANG_E_INVALID_ARG SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0x57)

Indicates that an argument passed in as parameter to a method is invalid.

◆ SLANG_E_INVALID_HANDLE

#define SLANG_E_INVALID_HANDLE SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 6)

Indicates that a handle passed in as parameter to a method is invalid.

◆ SLANG_E_NO_INTERFACE

#define SLANG_E_NO_INTERFACE SLANG_MAKE_WIN_GENERAL_ERROR(0x4002)

Interface not be found

◆ SLANG_E_NOT_AVAILABLE

#define SLANG_E_NOT_AVAILABLE SLANG_MAKE_CORE_ERROR(7)

Could not complete because some underlying feature (hardware or software) was not available

◆ SLANG_E_NOT_FOUND

#define SLANG_E_NOT_FOUND SLANG_MAKE_CORE_ERROR(5)

Indicates a file/resource could not be found

◆ SLANG_E_NOT_IMPLEMENTED

#define SLANG_E_NOT_IMPLEMENTED SLANG_MAKE_WIN_GENERAL_ERROR(0x4001)

Functionality is not implemented

◆ SLANG_E_OUT_OF_MEMORY

#define SLANG_E_OUT_OF_MEMORY SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0xe)

Operation could not complete - ran out of memory

◆ SLANG_E_PENDING

#define SLANG_E_PENDING SLANG_MAKE_CORE_ERROR(3)

Returned from an async method meaning the output is invalid (thus an error), but a result for the request is pending, and will be returned on a subsequent call with the async handle.

◆ SLANG_E_TIME_OUT

#define SLANG_E_TIME_OUT SLANG_MAKE_CORE_ERROR(8)

Could not complete because the operation times out.

◆ SLANG_E_UNINITIALIZED

#define SLANG_E_UNINITIALIZED SLANG_MAKE_CORE_ERROR(2)

Used to identify a Result that has yet to be initialized. It defaults to failure such that if used incorrectly will fail, as similar in concept to using an uninitialized variable.

◆ SLANG_ENABLE_DIRECTX

#define SLANG_ENABLE_DIRECTX 0

◆ SLANG_ENABLE_DXBC_SUPPORT

#define SLANG_ENABLE_DXBC_SUPPORT 0

◆ SLANG_ENABLE_DXGI_DEBUG

#define SLANG_ENABLE_DXGI_DEBUG 0

◆ SLANG_ENABLE_DXVK

#define SLANG_ENABLE_DXVK 0

◆ SLANG_ENABLE_PIX

#define SLANG_ENABLE_PIX 0

◆ SLANG_ENABLE_VKD3D

#define SLANG_ENABLE_VKD3D 0

◆ SLANG_ERROR_INSUFFICIENT_BUFFER

#define SLANG_ERROR_INSUFFICIENT_BUFFER SLANG_E_BUFFER_TOO_SMALL

◆ SLANG_ERROR_INVALID_PARAMETER

#define SLANG_ERROR_INVALID_PARAMETER SLANG_E_INVALID_ARG

◆ SLANG_EXTERN_C

#define SLANG_EXTERN_C

◆ SLANG_FACILITY_BASE

#define SLANG_FACILITY_BASE 0x200

Base facility -> so as to not clash with HRESULT values (values in 0x200 range do not appear used)

◆ SLANG_FACILITY_CORE

#define SLANG_FACILITY_CORE SLANG_FACILITY_BASE

Facilities numbers must be unique across a project to make the resulting result a unique number. It can be useful to have a consistent short name for a facility, as used in the name prefix

◆ SLANG_FACILITY_EXTERNAL_BASE

#define SLANG_FACILITY_EXTERNAL_BASE 0x210

Base for external facilities. Facilities should be unique across modules.

◆ SLANG_FACILITY_INTERNAL

#define SLANG_FACILITY_INTERNAL SLANG_FACILITY_BASE + 1

◆ SLANG_FACILITY_WIN_API

#define SLANG_FACILITY_WIN_API 7

◆ SLANG_FACILITY_WIN_GENERAL

#define SLANG_FACILITY_WIN_GENERAL 0

Facilities compatible with windows COM - only use if known code is compatible

◆ SLANG_FACILITY_WIN_INTERFACE

#define SLANG_FACILITY_WIN_INTERFACE 4

◆ SLANG_FAIL

#define SLANG_FAIL SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, 0x4005)

SLANG_FAIL is the generic failure code - meaning a serious error occurred and the call couldn't complete

◆ SLANG_FAILED

#define SLANG_FAILED ( status ) ((status) < 0)

Use to test if a result was failure. Never use result != SLANG_OK to test for failure, as there may be successful codes != SLANG_OK.

◆ SLANG_FORCE_INLINE

#define SLANG_FORCE_INLINE inline

◆ SLANG_FORMAT

#define SLANG_FORMAT	(		NAME,
			DESC ) SLANG_IMAGE_FORMAT_##NAME,

◆ SLANG_GCC

#define SLANG_GCC 0

◆ SLANG_GCC_FAMILY

#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)

◆ SLANG_GET_RESULT_CODE

#define SLANG_GET_RESULT_CODE ( r ) ((int32_t)((r) & 0xffff))

Get the result code for the facility

◆ SLANG_GET_RESULT_FACILITY

#define SLANG_GET_RESULT_FACILITY ( r ) ((int32_t)(((r) >> 16) & 0x7fff))

Get the facility the result is associated with

◆ SLANG_GHS

#define SLANG_GHS 0

◆ SLANG_HAS_BACKTRACE

#define SLANG_HAS_BACKTRACE 0

◆ SLANG_HAS_EXCEPTIONS

#define SLANG_HAS_EXCEPTIONS 1

◆ SLANG_IID_PPV_ARGS

#define SLANG_IID_PPV_ARGS ( ppType )

值:

    std::decay_t<decltype(**(ppType))>::getTypeGuid(),                                     \
        (                                                                                  \
            (void)[] {                                                                     \
                static_assert(                                                             \
                    std::is_base_of_v<ISlangUnknown, std::decay_t<decltype(**(ppType))>>); \
            },                                                                             \
            reinterpret_cast<void**>(ppType))

◆ SLANG_INLINE

#define SLANG_INLINE inline

SLANG_INLINE exists to have a way to inline consistent with SLANG_ALWAYS_INLINE

◆ SLANG_INT64

#define SLANG_INT64 ( x ) (x##ll)

◆ SLANG_IOS

#define SLANG_IOS 0

◆ SLANG_LINUX

#define SLANG_LINUX 0

◆ SLANG_LINUX_FAMILY

#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)

◆ SLANG_LITTLE_ENDIAN

#define SLANG_LITTLE_ENDIAN 0

◆ SLANG_MAKE_CORE_ERROR

#define SLANG_MAKE_CORE_ERROR ( code ) SLANG_MAKE_ERROR(SLANG_FACILITY_CORE, code)

◆ SLANG_MAKE_ERROR

#define SLANG_MAKE_ERROR	(		fac,
			code ) ((((int32_t)(fac)) << 16) \| ((int32_t)(code)) \| int32_t(0x80000000))

◆ SLANG_MAKE_SUCCESS

#define SLANG_MAKE_SUCCESS	(		fac,
			code ) ((((int32_t)(fac)) << 16) \| ((int32_t)(code)))

◆ SLANG_MAKE_WIN_GENERAL_ERROR

#define SLANG_MAKE_WIN_GENERAL_ERROR ( code ) SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, code)

◆ SLANG_MAYBE_UNUSED

#define SLANG_MAYBE_UNUSED

◆ SLANG_MCALL

#define SLANG_MCALL SLANG_STDCALL

◆ SLANG_MICROSOFT_FAMILY

#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)

◆ SLANG_NO_INLINE

#define SLANG_NO_INLINE

◆ SLANG_NO_THROW

#define SLANG_NO_THROW

◆ SLANG_OFFSET_OF

#define SLANG_OFFSET_OF	(		T,
			ELEMENT ) (size_t(&((T*)1)->ELEMENT) - 1)

◆ SLANG_OK

#define SLANG_OK 0

SLANG_OK indicates success, and is equivalent to SLANG_MAKE_SUCCESS(SLANG_FACILITY_WIN_GENERAL, 0)

◆ SLANG_OSX

#define SLANG_OSX 0

◆ SLANG_PLATFORM

#define SLANG_PLATFORM

◆ SLANG_PROCESSOR_ARM

#define SLANG_PROCESSOR_ARM 0

◆ SLANG_PROCESSOR_ARM_64

#define SLANG_PROCESSOR_ARM_64 0

◆ SLANG_PROCESSOR_FAMILY_ARM

#define SLANG_PROCESSOR_FAMILY_ARM (SLANG_PROCESSOR_ARM | SLANG_PROCESSOR_ARM_64)

◆ SLANG_PROCESSOR_FAMILY_POWER_PC

#define SLANG_PROCESSOR_FAMILY_POWER_PC (SLANG_PROCESSOR_POWER_PC_64 | SLANG_PROCESSOR_POWER_PC)

◆ SLANG_PROCESSOR_FAMILY_X86

#define SLANG_PROCESSOR_FAMILY_X86 (SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_X86)

◆ SLANG_PROCESSOR_POWER_PC

#define SLANG_PROCESSOR_POWER_PC 0

◆ SLANG_PROCESSOR_POWER_PC_64

#define SLANG_PROCESSOR_POWER_PC_64 0

◆ SLANG_PROCESSOR_WASM

#define SLANG_PROCESSOR_WASM 0

◆ SLANG_PROCESSOR_X86

#define SLANG_PROCESSOR_X86 0

◆ SLANG_PROCESSOR_X86_64

#define SLANG_PROCESSOR_X86_64 0

◆ SLANG_PS3

#define SLANG_PS3 0

◆ SLANG_PS4

#define SLANG_PS4 0

◆ SLANG_PSP2

#define SLANG_PSP2 0

◆ SLANG_PTR_IS_32

#define SLANG_PTR_IS_32 (SLANG_PTR_IS_64 ^ 1)

◆ SLANG_PTR_IS_64

#define SLANG_PTR_IS_64 (SLANG_PROCESSOR_ARM_64 | SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_POWER_PC_64)

◆ SLANG_RESOURCE_SHAPE

#define SLANG_RESOURCE_SHAPE

◆ SLANG_SNC

#define SLANG_SNC 0

◆ SLANG_STDCALL

#define SLANG_STDCALL

◆ SLANG_STRINGIZE

#define SLANG_STRINGIZE ( X ) SLANG_STRINGIZE_HELPER(X)

◆ SLANG_STRINGIZE_HELPER

#define SLANG_STRINGIZE_HELPER ( X ) #X

◆ SLANG_SUCCEEDED

#define SLANG_SUCCEEDED ( status ) ((status) >= 0)

Use to test if a result succeeded. Never use result == SLANG_OK to test for success, as will detect other successful codes as a failure.

◆ SLANG_UINT64

#define SLANG_UINT64 ( x ) (x##ull)

◆ SLANG_UNALIGNED_ACCESS

#define SLANG_UNALIGNED_ACCESS 0

◆ SLANG_UNBOUNDED_SIZE

#define SLANG_UNBOUNDED_SIZE (~size_t(0))

◆ SLANG_UNIX_FAMILY

#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */

◆ SLANG_UNKNOWN_SIZE

#define SLANG_UNKNOWN_SIZE (SLANG_UNBOUNDED_SIZE - 1)

◆ SLANG_UNUSED

#define SLANG_UNUSED ( v ) (void)v;

◆ SLANG_UUID_ISlangBlob

#define SLANG_UUID_ISlangBlob ISlangBlob::getTypeGuid()

◆ SLANG_UUID_ISlangFileSystem

#define SLANG_UUID_ISlangFileSystem ISlangFileSystem::getTypeGuid()

◆ SLANG_UUID_ISlangFileSystemExt

#define SLANG_UUID_ISlangFileSystemExt ISlangFileSystemExt::getTypeGuid()

◆ SLANG_UUID_ISlangMutableFileSystem

#define SLANG_UUID_ISlangMutableFileSystem ISlangMutableFileSystem::getTypeGuid()

◆ SLANG_UUID_ISlangProfiler

#define SLANG_UUID_ISlangProfiler ISlangProfiler::getTypeGuid()

◆ SLANG_UUID_ISlangSharedLibrary

#define SLANG_UUID_ISlangSharedLibrary ISlangSharedLibrary::getTypeGuid()

◆ SLANG_UUID_ISlangSharedLibrary_Dep1

#define SLANG_UUID_ISlangSharedLibrary_Dep1 ISlangSharedLibrary_Dep1::getTypeGuid()

◆ SLANG_UUID_ISlangSharedLibraryLoader

#define SLANG_UUID_ISlangSharedLibraryLoader ISlangSharedLibraryLoader::getTypeGuid()

◆ SLANG_UUID_ISlangUnknown

#define SLANG_UUID_ISlangUnknown ISlangUnknown::getTypeGuid()

◆ SLANG_UUID_ISlangWriter

#define SLANG_UUID_ISlangWriter ISlangWriter::getTypeGuid()

◆ SLANG_VC

#define SLANG_VC 0

◆ SLANG_WASM

#define SLANG_WASM 0

◆ SLANG_WIIU

#define SLANG_WIIU 0

◆ SLANG_WIN32

#define SLANG_WIN32 0

◆ SLANG_WIN64

#define SLANG_WIN64 0

◆ SLANG_WINDOWS_FAMILY

#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)

◆ SLANG_WINRT

#define SLANG_WINRT 0

Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/

◆ SLANG_X360

#define SLANG_X360 0

◆ SLANG_XBOXONE

#define SLANG_XBOXONE 0

类型定义说明

◆ FileSystemContentsCallBack

typedef void( * FileSystemContentsCallBack) (SlangPathType pathType, const char *name, void *userData)

◆ SlangArchiveTypeIntegral

typedef int SlangArchiveTypeIntegral

◆ SlangBindableResourceIntegral

typedef int SlangBindableResourceIntegral

◆ SlangBindingTypeIntegral

typedef SlangUInt32 SlangBindingTypeIntegral

Types of API-managed bindings that a parameter might use.

SlangBindingType represents the distinct types of binding ranges that might be understood by an underlying graphics API or cross-API abstraction layer. Several of the enumeration cases here correspond to cases of VkDescriptorType defined by the Vulkan API. Note however that the values of this enumeration are not the same as those of any particular API.

The SlangBindingType enumeration is distinct from SlangParameterCategory because SlangParameterCategory differentiates the types of parameters for the purposes of layout, where the layout rules of some targets will treat parameters of different types as occupying the same binding space for layout (e.g., in SPIR-V both a Texture2D and SamplerState use the same space of binding indices, and are not allowed to overlap), while those same types map to different types of bindings in the API (e.g., both textures and samplers use different VkDescriptorType values).

When you want to answer "what register/binding did this parameter use?" you should use SlangParameterCategory.

When you want to answer "what type of descriptor range should this parameter use?" you should use SlangBindingType.

◆ SlangBool

typedef bool SlangBool

◆ SlangCapabilityIDIntegral

typedef SlangInt32 SlangCapabilityIDIntegral

◆ SlangCompileFlags

typedef unsigned int SlangCompileFlags

Flags to control compilation behavior.

◆ SlangCompileRequest

typedef struct slang::ICompileRequest SlangCompileRequest

A request for one or more compilation actions to be performed.

◆ SlangCompileTargetIntegral

typedef int SlangCompileTargetIntegral

◆ SlangContainerFormatIntegral

typedef int SlangContainerFormatIntegral

◆ SlangCooperativeMatrixUseIntegral

typedef SlangUInt32 SlangCooperativeMatrixUseIntegral

◆ SlangCooperativeVectorMatrixLayoutIntegral

typedef SlangUInt32 SlangCooperativeVectorMatrixLayoutIntegral

◆ SlangDebugInfoFormatIntegral

typedef SlangUInt32 SlangDebugInfoFormatIntegral

◆ SlangDebugInfoLevelIntegral

typedef SlangUInt32 SlangDebugInfoLevelIntegral

◆ SlangDeclKindIntegral

typedef unsigned int SlangDeclKindIntegral

◆ SlangDiagnosticCallback

typedef void(* SlangDiagnosticCallback) (char const *message, void *userData)

Callback type used for diagnostic output.

◆ SlangDiagnosticFlags

typedef int SlangDiagnosticFlags

◆ SlangEntryPoint

typedef struct SlangEntryPoint SlangEntryPoint

◆ SlangEntryPointLayout

typedef struct SlangEntryPointLayout SlangEntryPointLayout

◆ SlangFloatingPointModeIntegral

typedef unsigned int SlangFloatingPointModeIntegral

Options to control floating-point precision guarantees for a target.

◆ SlangFpDenormalModeIntegral

typedef unsigned int SlangFpDenormalModeIntegral

Options to control floating-point denormal handling mode for a target.

◆ SlangFuncPtr

typedef void(* SlangFuncPtr) (void)

◆ SlangImageFormatIntegral

typedef SlangUInt32 SlangImageFormatIntegral

◆ SlangInt

typedef int32_t SlangInt

◆ SlangInt32

typedef int32_t SlangInt32

◆ SlangLayoutRulesIntegral

typedef SlangUInt32 SlangLayoutRulesIntegral

◆ SlangLineDirectiveModeIntegral

typedef unsigned int SlangLineDirectiveModeIntegral

Options to control emission of #line directives

◆ SlangMatrixLayoutModeIntegral

typedef unsigned int SlangMatrixLayoutModeIntegral

◆ SlangModifierIDIntegral

typedef SlangUInt32 SlangModifierIDIntegral

◆ SlangOptimizationLevelIntegral

typedef SlangUInt32 SlangOptimizationLevelIntegral

◆ SlangParameterCategoryIntegral

typedef unsigned int SlangParameterCategoryIntegral

◆ SlangPassThroughIntegral

typedef int SlangPassThroughIntegral

◆ SlangPathTypeIntegral

typedef unsigned int SlangPathTypeIntegral

◆ SlangProfileIDIntegral

typedef unsigned int SlangProfileIDIntegral

◆ SlangProgramLayout

typedef struct SlangProgramLayout SlangProgramLayout

◆ SlangReflection

typedef SlangProgramLayout SlangReflection

◆ SlangReflectionAttribute

typedef SlangReflectionUserAttribute SlangReflectionAttribute

◆ SlangReflectionDecl

typedef struct SlangReflectionDecl SlangReflectionDecl

◆ SlangReflectionEntryPoint

typedef SlangEntryPointLayout SlangReflectionEntryPoint

◆ SlangReflectionFunction

typedef struct SlangReflectionFunction SlangReflectionFunction

◆ SlangReflectionGeneric

typedef struct SlangReflectionGeneric SlangReflectionGeneric

◆ SlangReflectionModifier

typedef struct SlangReflectionModifier SlangReflectionModifier

◆ SlangReflectionParameter

typedef SlangReflectionVariableLayout SlangReflectionParameter

◆ SlangReflectionType

typedef struct SlangReflectionType SlangReflectionType

◆ SlangReflectionTypeLayout

typedef struct SlangReflectionTypeLayout SlangReflectionTypeLayout

◆ SlangReflectionTypeParameter

typedef struct SlangReflectionTypeParameter SlangReflectionTypeParameter

◆ SlangReflectionUserAttribute

typedef struct SlangReflectionUserAttribute SlangReflectionUserAttribute

◆ SlangReflectionVariable

typedef struct SlangReflectionVariable SlangReflectionVariable

◆ SlangReflectionVariableLayout

typedef struct SlangReflectionVariableLayout SlangReflectionVariableLayout

◆ SlangResourceAccessIntegral

typedef unsigned int SlangResourceAccessIntegral

◆ SlangResourceShapeIntegral

typedef unsigned int SlangResourceShapeIntegral

◆ SlangResult

typedef int32_t SlangResult

A result code for a Slang API operation.

This type is generally compatible with the Windows API HRESULT type. In particular, negative values indicate failure results, while zero or positive results indicate success.

In general, Slang APIs always return a zero result on success, unless documented otherwise. Strictly speaking a negative value indicates an error, a positive (or 0) value indicates success. This can be tested for with the macros SLANG_SUCCEEDED(x) or SLANG_FAILED(x).

It can represent if the call was successful or not. It can also specify in an extensible manner what facility produced the result (as the integral 'facility') as well as what caused it (as an integral 'code'). Under the covers SlangResult is represented as a int32_t.

SlangResult is designed to be compatible with COM HRESULT.

It's layout in bits is as follows

Severity	Facility	Code
31	30-16	15-0

Severity - 1 fail, 0 is success - as SlangResult is signed 32 bits, means negative number indicates failure. Facility is where the error originated from. Code is the code specific to the facility.

Result codes have the following styles, 1) SLANG_name 2) SLANG_s_f_name 3) SLANG_s_name

where s is S for success, E for error f is the short version of the facility name

Style 1 is reserved for SLANG_OK and SLANG_FAIL as they are so commonly used.

It is acceptable to expand 'f' to a longer name to differentiate a name or drop if unique without it. ie for a facility 'DRIVER' it might make sense to have an error of the form SLANG_E_DRIVER_OUT_OF_MEMORY

◆ SlangScalarTypeIntegral

typedef unsigned int SlangScalarTypeIntegral

◆ SlangScopeIntegral

typedef SlangUInt32 SlangScopeIntegral

◆ SlangSession

typedef slang::IGlobalSession SlangSession

An instance of the Slang library.

◆ SlangSeverityIntegral

typedef int SlangSeverityIntegral

Severity of a diagnostic generated by the compiler. Values come from the enum below, with higher values representing more severe conditions, and all values >= SLANG_SEVERITY_ERROR indicating compilation failure.

◆ SlangSizeT

typedef uint32_t SlangSizeT

◆ SlangSourceLanguageIntegral

typedef int SlangSourceLanguageIntegral

◆ SlangSSizeT

typedef int32_t SlangSSizeT

◆ SlangStageIntegral

typedef SlangUInt32 SlangStageIntegral

◆ SlangTargetFlags

typedef unsigned int SlangTargetFlags

Flags to control code generation behavior of a compilation target

◆ SlangTypeKindIntegral

typedef unsigned int SlangTypeKindIntegral

◆ SlangUInt

typedef uint32_t SlangUInt

◆ SlangUInt32

typedef uint32_t SlangUInt32

◆ SlangWriterChannelIntegral

typedef unsigned int SlangWriterChannelIntegral

◆ SlangWriterModeIntegral

typedef unsigned int SlangWriterModeIntegral

枚举类型说明

◆ anonymous enum

anonymous enum

枚举值
SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS
SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS

◆ anonymous enum

anonymous enum

枚举值
SLANG_COMPILE_FLAG_NO_MANGLING
SLANG_COMPILE_FLAG_NO_CODEGEN
SLANG_COMPILE_FLAG_OBFUSCATE
SLANG_COMPILE_FLAG_NO_CHECKING
SLANG_COMPILE_FLAG_SPLIT_MIXED_TYPES

◆ anonymous enum

anonymous enum

枚举值
SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES
SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM
SLANG_TARGET_FLAG_DUMP_IR
SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY

◆ OSPathKind

enum class OSPathKind : uint8_t

strong

枚举值
None	Paths do not map to the file system
Direct	Paths map directly to the file system
OperatingSystem	Only paths gained via PathKind::OperatingSystem map to the operating system file system

◆ PathKind

enum class PathKind

strong

枚举值
Simplified	Given a path, returns a simplified version of that path. This typically means removing '..' and/or '.' from the path. A simplified path must point to the same object as the original.
Canonical	Given a path, returns a 'canonical path' to the item. This may be the operating system 'canonical path' that is the unique path to the item. If the item exists the returned canonical path should always be usable to access the item. If the item the path specifies doesn't exist, the canonical path may not be returnable or be a path simplification. Not all file systems support canonical paths.
Display	Given a path returns a path such that it is suitable to be displayed to the user. For example if the file system is a zip file - it might include the path to the zip container as well as the path to the specific file. NOTE! The display path won't necessarily work on the file system to access the item
OperatingSystem	Get the path to the item on the operating system file system, if available.
CountOf

◆ SlangArchiveType

enum SlangArchiveType : SlangArchiveTypeIntegral

枚举值
SLANG_ARCHIVE_TYPE_UNDEFINED
SLANG_ARCHIVE_TYPE_ZIP
SLANG_ARCHIVE_TYPE_RIFF	Riff container with no compression
SLANG_ARCHIVE_TYPE_RIFF_DEFLATE
SLANG_ARCHIVE_TYPE_RIFF_LZ4
SLANG_ARCHIVE_TYPE_COUNT_OF

◆ SlangBindableResourceType

enum SlangBindableResourceType : SlangBindableResourceIntegral

枚举值
SLANG_NON_BINDABLE
SLANG_TEXTURE
SLANG_SAMPLER
SLANG_UNIFORM_BUFFER
SLANG_STORAGE_BUFFER

◆ SlangBindingType

enum SlangBindingType : SlangBindingTypeIntegral

枚举值
SLANG_BINDING_TYPE_UNKNOWN
SLANG_BINDING_TYPE_SAMPLER
SLANG_BINDING_TYPE_TEXTURE
SLANG_BINDING_TYPE_CONSTANT_BUFFER
SLANG_BINDING_TYPE_PARAMETER_BLOCK
SLANG_BINDING_TYPE_TYPED_BUFFER
SLANG_BINDING_TYPE_RAW_BUFFER
SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER
SLANG_BINDING_TYPE_INPUT_RENDER_TARGET
SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA
SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE
SLANG_BINDING_TYPE_VARYING_INPUT
SLANG_BINDING_TYPE_VARYING_OUTPUT
SLANG_BINDING_TYPE_EXISTENTIAL_VALUE
SLANG_BINDING_TYPE_PUSH_CONSTANT
SLANG_BINDING_TYPE_MUTABLE_FLAG
SLANG_BINDING_TYPE_MUTABLE_TETURE
SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER
SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER
SLANG_BINDING_TYPE_BASE_MASK
SLANG_BINDING_TYPE_EXT_MASK

◆ SlangCapabilityID

enum SlangCapabilityID : SlangCapabilityIDIntegral

枚举值
SLANG_CAPABILITY_UNKNOWN

◆ SlangCompileTarget

enum SlangCompileTarget : SlangCompileTargetIntegral

枚举值
SLANG_TARGET_UNKNOWN
SLANG_TARGET_NONE
SLANG_GLSL
SLANG_GLSL_VULKAN_DEPRECATED
SLANG_GLSL_VULKAN_ONE_DESC_DEPRECATED
SLANG_HLSL
SLANG_SPIRV
SLANG_SPIRV_ASM
SLANG_DXBC
SLANG_DXBC_ASM
SLANG_DXIL
SLANG_DXIL_ASM
SLANG_C_SOURCE	The C language
SLANG_CPP_SOURCE	C++ code for shader kernels.
SLANG_HOST_EXECUTABLE	Standalone binary executable (for hosting CPU/OS)
SLANG_SHADER_SHARED_LIBRARY	A shared library/Dll for shader kernels (for hosting CPU/OS)
SLANG_SHADER_HOST_CALLABLE	A CPU target that makes the compiled shader code available to be run immediately
SLANG_CUDA_SOURCE	Cuda source
SLANG_PTX	PTX
SLANG_CUDA_OBJECT_CODE	Object code that contains CUDA functions.
SLANG_OBJECT_CODE	Object code that can be used for later linking (kernel/shader)
SLANG_HOST_CPP_SOURCE	C++ code for host library or executable.
SLANG_HOST_HOST_CALLABLE	Host callable host code (ie non kernel/shader)
SLANG_CPP_PYTORCH_BINDING	C++ PyTorch binding code.
SLANG_METAL	Metal shading language
SLANG_METAL_LIB	Metal library
SLANG_METAL_LIB_ASM	Metal library assembly
SLANG_HOST_SHARED_LIBRARY	A shared library/Dll for host code (for hosting CPU/OS)
SLANG_WGSL	WebGPU shading language
SLANG_WGSL_SPIRV_ASM	SPIR-V assembly via WebGPU shading language
SLANG_WGSL_SPIRV	SPIR-V via WebGPU shading language
SLANG_HOST_VM	Bytecode that can be interpreted by the Slang VM
SLANG_CPP_HEADER	C++ header for shader kernels.
SLANG_CUDA_HEADER	Cuda header
SLANG_HOST_OBJECT_CODE	Host object code
SLANG_HOST_LLVM_IR	Host LLVM IR assembly
SLANG_SHADER_LLVM_IR	Host LLVM IR assembly (kernel/shader)
SLANG_TARGET_COUNT_OF

◆ SlangContainerFormat

enum SlangContainerFormat : SlangContainerFormatIntegral

枚举值
SLANG_CONTAINER_FORMAT_NONE
SLANG_CONTAINER_FORMAT_SLANG_MODULE

◆ SlangCooperativeMatrixUse

enum SlangCooperativeMatrixUse : SlangCooperativeMatrixUseIntegral

枚举值
SLANG_COOPERATIVE_MATRIX_USE_A
SLANG_COOPERATIVE_MATRIX_USE_B
SLANG_COOPERATIVE_MATRIX_USE_ACCUMULATOR

◆ SlangCooperativeVectorMatrixLayout

enum SlangCooperativeVectorMatrixLayout : SlangCooperativeVectorMatrixLayoutIntegral

枚举值
SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR
SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR
SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL
SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL

◆ SlangDebugInfoFormat

enum SlangDebugInfoFormat : SlangDebugInfoFormatIntegral

枚举值
SLANG_DEBUG_INFO_FORMAT_DEFAULT	Use the default debugging format for the target
SLANG_DEBUG_INFO_FORMAT_C7	CodeView C7 format (typically means debugging information is embedded in the binary)
SLANG_DEBUG_INFO_FORMAT_PDB	Program database
SLANG_DEBUG_INFO_FORMAT_STABS	Stabs
SLANG_DEBUG_INFO_FORMAT_COFF	COFF debug info
SLANG_DEBUG_INFO_FORMAT_DWARF	DWARF debug info (we may want to support specifying the version)
SLANG_DEBUG_INFO_FORMAT_COUNT_OF

◆ SlangDebugInfoLevel

enum SlangDebugInfoLevel : SlangDebugInfoLevelIntegral

枚举值
SLANG_DEBUG_INFO_LEVEL_NONE	Don't emit debug information at all.
SLANG_DEBUG_INFO_LEVEL_MINIMAL	Emit as little debug information as possible, while still supporting stack trackers.
SLANG_DEBUG_INFO_LEVEL_STANDARD	Emit whatever is the standard level of debug information for each target.
SLANG_DEBUG_INFO_LEVEL_MAXIMAL	Emit as much debug information as possible for each target.

◆ SlangDeclKind

enum SlangDeclKind : SlangDeclKindIntegral

枚举值
SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION
SLANG_DECL_KIND_STRUCT
SLANG_DECL_KIND_FUNC
SLANG_DECL_KIND_MODULE
SLANG_DECL_KIND_GENERIC
SLANG_DECL_KIND_VARIABLE
SLANG_DECL_KIND_NAMESPACE
SLANG_DECL_KIND_ENUM

◆ SlangDiagnosticColor

enum SlangDiagnosticColor

枚举值
SLANG_DIAGNOSTIC_COLOR_AUTO
SLANG_DIAGNOSTIC_COLOR_ALWAYS
SLANG_DIAGNOSTIC_COLOR_NEVER

◆ SlangEmitCPUMethod

enum SlangEmitCPUMethod

枚举值
SLANG_EMIT_CPU_DEFAULT
SLANG_EMIT_CPU_VIA_CPP
SLANG_EMIT_CPU_VIA_LLVM

◆ SlangEmitSpirvMethod

enum SlangEmitSpirvMethod

枚举值
SLANG_EMIT_SPIRV_DEFAULT
SLANG_EMIT_SPIRV_VIA_GLSL
SLANG_EMIT_SPIRV_DIRECTLY

◆ SlangFloatingPointMode

enum SlangFloatingPointMode : SlangFloatingPointModeIntegral

枚举值
SLANG_FLOATING_POINT_MODE_DEFAULT
SLANG_FLOATING_POINT_MODE_FAST
SLANG_FLOATING_POINT_MODE_PRECISE

◆ SlangFpDenormalMode

enum SlangFpDenormalMode : SlangFpDenormalModeIntegral

枚举值
SLANG_FP_DENORM_MODE_ANY
SLANG_FP_DENORM_MODE_PRESERVE
SLANG_FP_DENORM_MODE_FTZ

◆ SlangImageFormat

enum SlangImageFormat : SlangImageFormatIntegral

◆ SlangLayoutRules

enum SlangLayoutRules : SlangLayoutRulesIntegral

枚举值
SLANG_LAYOUT_RULES_DEFAULT
SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2
SLANG_LAYOUT_RULES_DEFAULT_STRUCTURED_BUFFER
SLANG_LAYOUT_RULES_DEFAULT_CONSTANT_BUFFER

◆ SlangLineDirectiveMode

enum SlangLineDirectiveMode : SlangLineDirectiveModeIntegral

枚举值
SLANG_LINE_DIRECTIVE_MODE_DEFAULT	Default behavior: pick behavior base on target.
SLANG_LINE_DIRECTIVE_MODE_NONE	Don't emit line directives at all.
SLANG_LINE_DIRECTIVE_MODE_STANDARD	Emit standard C-style `#line` directives.
SLANG_LINE_DIRECTIVE_MODE_GLSL	Emit GLSL-style directives with file number instead of name
SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP	Use a source map to track line mappings (ie no #line will appear in emitting source)

◆ SlangMatrixLayoutMode

enum SlangMatrixLayoutMode : SlangMatrixLayoutModeIntegral

枚举值
SLANG_MATRIX_LAYOUT_MODE_UNKNOWN
SLANG_MATRIX_LAYOUT_ROW_MAJOR
SLANG_MATRIX_LAYOUT_COLUMN_MAJOR

◆ SlangModifierID

enum SlangModifierID : SlangModifierIDIntegral

枚举值
SLANG_MODIFIER_SHARED
SLANG_MODIFIER_NO_DIFF
SLANG_MODIFIER_STATIC
SLANG_MODIFIER_CONST
SLANG_MODIFIER_EXPORT
SLANG_MODIFIER_EXTERN
SLANG_MODIFIER_DIFFERENTIABLE
SLANG_MODIFIER_MUTATING
SLANG_MODIFIER_IN
SLANG_MODIFIER_OUT
SLANG_MODIFIER_INOUT

◆ SlangOptimizationLevel

enum SlangOptimizationLevel : SlangOptimizationLevelIntegral

枚举值
SLANG_OPTIMIZATION_LEVEL_NONE	Don't optimize at all.
SLANG_OPTIMIZATION_LEVEL_DEFAULT	Default optimization level: balance code quality and compilation time.
SLANG_OPTIMIZATION_LEVEL_HIGH	Optimize aggressively.
SLANG_OPTIMIZATION_LEVEL_MAXIMAL	Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs

◆ SlangParameterCategory

enum SlangParameterCategory : SlangParameterCategoryIntegral

枚举值
SLANG_PARAMETER_CATEGORY_NONE
SLANG_PARAMETER_CATEGORY_MIXED
SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER
SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE
SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS
SLANG_PARAMETER_CATEGORY_VARYING_INPUT
SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT
SLANG_PARAMETER_CATEGORY_SAMPLER_STATE
SLANG_PARAMETER_CATEGORY_UNIFORM
SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT
SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT
SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER
SLANG_PARAMETER_CATEGORY_REGISTER_SPACE
SLANG_PARAMETER_CATEGORY_GENERIC
SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD
SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES
SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD
SLANG_PARAMETER_CATEGORY_SHADER_RECORD
SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM
SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM
SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE
SLANG_PARAMETER_CATEGORY_SUBPASS
SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT
SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE
SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD
SLANG_PARAMETER_CATEGORY_COUNT
SLANG_PARAMETER_CATEGORY_METAL_BUFFER
SLANG_PARAMETER_CATEGORY_METAL_TEXTURE
SLANG_PARAMETER_CATEGORY_METAL_SAMPLER
SLANG_PARAMETER_CATEGORY_VERTEX_INPUT
SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT
SLANG_PARAMETER_CATEGORY_COUNT_V1

◆ SlangPassThrough

enum SlangPassThrough : SlangPassThroughIntegral

枚举值
SLANG_PASS_THROUGH_NONE
SLANG_PASS_THROUGH_FXC
SLANG_PASS_THROUGH_DXC
SLANG_PASS_THROUGH_GLSLANG
SLANG_PASS_THROUGH_SPIRV_DIS
SLANG_PASS_THROUGH_CLANG	Clang C/C++ compiler
SLANG_PASS_THROUGH_VISUAL_STUDIO	Visual studio C/C++ compiler
SLANG_PASS_THROUGH_GCC	GCC C/C++ compiler
SLANG_PASS_THROUGH_GENERIC_C_CPP	Generic C or C++ compiler, which is decided by the source type
SLANG_PASS_THROUGH_NVRTC	NVRTC Cuda compiler
SLANG_PASS_THROUGH_LLVM	LLVM 'compiler' - includes LLVM and Clang
SLANG_PASS_THROUGH_SPIRV_OPT	SPIRV-opt
SLANG_PASS_THROUGH_METAL	Metal compiler
SLANG_PASS_THROUGH_TINT	Tint WGSL compiler
SLANG_PASS_THROUGH_SPIRV_LINK	SPIRV-link
SLANG_PASS_THROUGH_COUNT_OF

◆ SlangPathType

enum SlangPathType : SlangPathTypeIntegral

枚举值
SLANG_PATH_TYPE_DIRECTORY	Path specified specifies a directory.
SLANG_PATH_TYPE_FILE	Path specified is to a file.

◆ SlangProfileID

enum SlangProfileID : SlangProfileIDIntegral

枚举值
SLANG_PROFILE_UNKNOWN

◆ SlangReflectionGenericArgType

enum SlangReflectionGenericArgType

枚举值
SLANG_GENERIC_ARG_TYPE
SLANG_GENERIC_ARG_INT
SLANG_GENERIC_ARG_BOOL

◆ SlangResourceAccess

enum SlangResourceAccess : SlangResourceAccessIntegral

枚举值
SLANG_RESOURCE_ACCESS_NONE
SLANG_RESOURCE_ACCESS_READ
SLANG_RESOURCE_ACCESS_READ_WRITE
SLANG_RESOURCE_ACCESS_RASTER_ORDERED
SLANG_RESOURCE_ACCESS_APPEND
SLANG_RESOURCE_ACCESS_CONSUME
SLANG_RESOURCE_ACCESS_WRITE
SLANG_RESOURCE_ACCESS_FEEDBACK
SLANG_RESOURCE_ACCESS_UNKNOWN

◆ SlangResourceShape

enum SlangResourceShape : SlangResourceShapeIntegral

枚举值
SLANG_RESOURCE_BASE_SHAPE_MASK
SLANG_RESOURCE_NONE
SLANG_TEXTURE_1D
SLANG_TEXTURE_2D
SLANG_TEXTURE_3D
SLANG_TEXTURE_CUBE
SLANG_TEXTURE_BUFFER
SLANG_STRUCTURED_BUFFER
SLANG_BYTE_ADDRESS_BUFFER
SLANG_RESOURCE_UNKNOWN
SLANG_ACCELERATION_STRUCTURE
SLANG_TEXTURE_SUBPASS
SLANG_RESOURCE_EXT_SHAPE_MASK
SLANG_TEXTURE_FEEDBACK_FLAG
SLANG_TEXTURE_SHADOW_FLAG
SLANG_TEXTURE_ARRAY_FLAG
SLANG_TEXTURE_MULTISAMPLE_FLAG
SLANG_TEXTURE_COMBINED_FLAG
SLANG_TEXTURE_1D_ARRAY
SLANG_TEXTURE_2D_ARRAY
SLANG_TEXTURE_CUBE_ARRAY
SLANG_TEXTURE_2D_MULTISAMPLE
SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY
SLANG_TEXTURE_SUBPASS_MULTISAMPLE

◆ SlangScalarType

enum SlangScalarType : SlangScalarTypeIntegral

枚举值
SLANG_SCALAR_TYPE_NONE
SLANG_SCALAR_TYPE_VOID
SLANG_SCALAR_TYPE_BOOL
SLANG_SCALAR_TYPE_INT32
SLANG_SCALAR_TYPE_UINT32
SLANG_SCALAR_TYPE_INT64
SLANG_SCALAR_TYPE_UINT64
SLANG_SCALAR_TYPE_FLOAT16
SLANG_SCALAR_TYPE_FLOAT32
SLANG_SCALAR_TYPE_FLOAT64
SLANG_SCALAR_TYPE_INT8
SLANG_SCALAR_TYPE_UINT8
SLANG_SCALAR_TYPE_INT16
SLANG_SCALAR_TYPE_UINT16
SLANG_SCALAR_TYPE_INTPTR
SLANG_SCALAR_TYPE_UINTPTR
SLANG_SCALAR_TYPE_BFLOAT16
SLANG_SCALAR_TYPE_FLOAT_E4M3
SLANG_SCALAR_TYPE_FLOAT_E5M2

◆ SlangScope

enum SlangScope : SlangScopeIntegral

枚举值
SLANG_SCOPE_NONE
SLANG_SCOPE_THREAD
SLANG_SCOPE_WAVE
SLANG_SCOPE_THREAD_GROUP

◆ SlangSeverity

enum SlangSeverity : SlangSeverityIntegral

枚举值
SLANG_SEVERITY_DISABLED	A message that is disabled, filtered out.
SLANG_SEVERITY_NOTE	An informative message.
SLANG_SEVERITY_WARNING	A warning, which indicates a possible problem.
SLANG_SEVERITY_ERROR	An error, indicating that compilation failed.
SLANG_SEVERITY_FATAL	An unrecoverable error, which forced compilation to abort.
SLANG_SEVERITY_INTERNAL	An internal error, indicating a logic error in the compiler.

◆ SlangSourceLanguage

enum SlangSourceLanguage : SlangSourceLanguageIntegral

枚举值
SLANG_SOURCE_LANGUAGE_UNKNOWN
SLANG_SOURCE_LANGUAGE_SLANG
SLANG_SOURCE_LANGUAGE_HLSL
SLANG_SOURCE_LANGUAGE_GLSL
SLANG_SOURCE_LANGUAGE_C
SLANG_SOURCE_LANGUAGE_CPP
SLANG_SOURCE_LANGUAGE_CUDA
SLANG_SOURCE_LANGUAGE_SPIRV
SLANG_SOURCE_LANGUAGE_METAL
SLANG_SOURCE_LANGUAGE_WGSL
SLANG_SOURCE_LANGUAGE_LLVM
SLANG_SOURCE_LANGUAGE_COUNT_OF

◆ SlangStage

enum SlangStage : SlangStageIntegral

枚举值
SLANG_STAGE_NONE
SLANG_STAGE_VERTEX
SLANG_STAGE_HULL
SLANG_STAGE_DOMAIN
SLANG_STAGE_GEOMETRY
SLANG_STAGE_FRAGMENT
SLANG_STAGE_COMPUTE
SLANG_STAGE_RAY_GENERATION
SLANG_STAGE_INTERSECTION
SLANG_STAGE_ANY_HIT
SLANG_STAGE_CLOSEST_HIT
SLANG_STAGE_MISS
SLANG_STAGE_CALLABLE
SLANG_STAGE_MESH
SLANG_STAGE_AMPLIFICATION
SLANG_STAGE_DISPATCH
SLANG_STAGE_COUNT
SLANG_STAGE_PIXEL

◆ SlangTypeKind

enum SlangTypeKind : SlangTypeKindIntegral

枚举值
SLANG_TYPE_KIND_NONE
SLANG_TYPE_KIND_STRUCT
SLANG_TYPE_KIND_ARRAY
SLANG_TYPE_KIND_MATRIX
SLANG_TYPE_KIND_VECTOR
SLANG_TYPE_KIND_SCALAR
SLANG_TYPE_KIND_CONSTANT_BUFFER
SLANG_TYPE_KIND_RESOURCE
SLANG_TYPE_KIND_SAMPLER_STATE
SLANG_TYPE_KIND_TEXTURE_BUFFER
SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER
SLANG_TYPE_KIND_PARAMETER_BLOCK
SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER
SLANG_TYPE_KIND_INTERFACE
SLANG_TYPE_KIND_OUTPUT_STREAM
SLANG_TYPE_KIND_MESH_OUTPUT
SLANG_TYPE_KIND_SPECIALIZED
SLANG_TYPE_KIND_FEEDBACK
SLANG_TYPE_KIND_POINTER
SLANG_TYPE_KIND_DYNAMIC_RESOURCE
SLANG_TYPE_KIND_ENUM
SLANG_TYPE_KIND_COUNT

◆ SlangWriterChannel

enum SlangWriterChannel : SlangWriterChannelIntegral

枚举值
SLANG_WRITER_CHANNEL_DIAGNOSTIC
SLANG_WRITER_CHANNEL_STD_OUTPUT
SLANG_WRITER_CHANNEL_STD_ERROR
SLANG_WRITER_CHANNEL_COUNT_OF

◆ SlangWriterMode

enum SlangWriterMode : SlangWriterModeIntegral

枚举值
SLANG_WRITER_MODE_TEXT
SLANG_WRITER_MODE_BINARY

函数说明

◆ spGetBuildTagString()

SLANG_API const char * spGetBuildTagString ( )

Get the build version 'tag' string. The string is the same as produced via git describe --tags --match v* for the project. If such a version could not be determined at build time then the contents will be 0.0.0-unknown. Any string can be set by passing -DSLANG_VERSION_FULL=whatever during the cmake invocation.

This function will return exactly the same result as the method getBuildTagString on IGlobalSession.

An advantage of using this function over the method is that doing so does not require the creation of a session, which can be a fairly costly operation.

返回: The build tag string

变量说明

◆ kDefaultTargetFlags

constexpr SlangTargetFlags kDefaultTargetFlags

inlineconstexpr

初始值:

=

SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY

@ SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY

Definition slang.h:754

类

命名空间

宏定义

类型定义

枚举

函数

变量

详细描述

宏定义说明

◆ SLANG_ANDROID

◆ SLANG_API

◆ SLANG_APPLE_FAMILY

◆ SLANG_BIG_ENDIAN

◆ SLANG_BREAKPOINT

◆ SLANG_CLANG

◆ SLANG_CLASS_GUID

◆ SLANG_COM_INTERFACE

◆ SLANG_COMPILE_TIME_ASSERT

◆ SLANG_COMPILER

◆ SLANG_CONCAT

◆ SLANG_CONCAT_HELPER

◆ SLANG_COUNT_OF

◆ SLANG_DEPRECATED

◆ SLANG_DLL_EXPORT

◆ SLANG_DYNAMIC

◆ SLANG_E_ABORT

◆ SLANG_E_BUFFER_TOO_SMALL

◆ SLANG_E_CANNOT_OPEN

◆ SLANG_E_INTERNAL_FAIL

◆ SLANG_E_INVALID_ARG

◆ SLANG_E_INVALID_HANDLE

◆ SLANG_E_NO_INTERFACE

◆ SLANG_E_NOT_AVAILABLE

◆ SLANG_E_NOT_FOUND

◆ SLANG_E_NOT_IMPLEMENTED

◆ SLANG_E_OUT_OF_MEMORY

◆ SLANG_E_PENDING

◆ SLANG_E_TIME_OUT

◆ SLANG_E_UNINITIALIZED

◆ SLANG_ENABLE_DIRECTX

◆ SLANG_ENABLE_DXBC_SUPPORT

◆ SLANG_ENABLE_DXGI_DEBUG

◆ SLANG_ENABLE_DXVK

◆ SLANG_ENABLE_PIX

◆ SLANG_ENABLE_VKD3D

◆ SLANG_ERROR_INSUFFICIENT_BUFFER

◆ SLANG_ERROR_INVALID_PARAMETER

◆ SLANG_EXTERN_C

◆ SLANG_FACILITY_BASE

◆ SLANG_FACILITY_CORE

◆ SLANG_FACILITY_EXTERNAL_BASE

◆ SLANG_FACILITY_INTERNAL

◆ SLANG_FACILITY_WIN_API

◆ SLANG_FACILITY_WIN_GENERAL

◆ SLANG_FACILITY_WIN_INTERFACE

◆ SLANG_FAIL

◆ SLANG_FAILED

◆ SLANG_FORCE_INLINE

◆ SLANG_FORMAT

◆ SLANG_GCC

◆ SLANG_GCC_FAMILY

◆ SLANG_GET_RESULT_CODE

◆ SLANG_GET_RESULT_FACILITY

◆ SLANG_GHS

◆ SLANG_HAS_BACKTRACE

◆ SLANG_HAS_EXCEPTIONS

◆ SLANG_IID_PPV_ARGS

◆ SLANG_INLINE

◆ SLANG_INT64

◆ SLANG_IOS

◆ SLANG_LINUX

◆ SLANG_LINUX_FAMILY

◆ SLANG_LITTLE_ENDIAN

◆ SLANG_MAKE_CORE_ERROR

◆ SLANG_MAKE_ERROR

◆ SLANG_MAKE_SUCCESS

◆ SLANG_MAKE_WIN_GENERAL_ERROR

◆ SLANG_MAYBE_UNUSED

◆ SLANG_MCALL

◆ SLANG_MICROSOFT_FAMILY