Error and warning codes that a shader can return.
| Constant/value | Description |
|---|---|
| A comment continues past the end of file. |
| A hex value was truncated to 32 bits. |
| An octal value was truncated to 32 bits. |
| A decimal value was truncated to 32 bits. |
| A string continues past the end of line. |
| A string continues past the end of file. |
| A character continues past the end of file. |
| An error in the token version. |
| An invalid preprocessor syntax. |
| There were unexpected tokens following the preprocessor directive. |
| The end of file was reached unexpectedly. |
| A division by zero in the preprocessor expression occurred. |
| An invalid preprocessor command. |
| The include interface that is required to support #include from resource or memory doesn't work. |
| There are too many nested #includes. |
| The specified source file failed to open. |
| An unexpected #elif directive occurred. |
| An unexpected #else directive occurred. |
| An unexpected #endif directive occurred. |
| A duplicate parameter was supplied to the specified macro. |
| A resource failed to open. |
| An unexpected #elif directive followed a #else directive. |
| An unexpected #else directive followed a #else directive. |
| An unexpected end of file occurred in a macro expansion. |
| Not enough actual parameters were supplied to the specified macro. |
| Functional defines in preprocessor expressions are not yet implemented. |
| An integer constant expression is invalid or unsupported. |
| The specified macro requires redefining. |
| The #hlsl_full_path directive must be the first content in a source file. |
| The #hlsl_full_path directive was malformed. |
| A syntax error was found while parsing a shader file. |
| The specified function requires redefining. |
| An undeclared identifier was found while parsing a shader file. |
| The invalid use of a type was found while parsing a shader file. |
| The specified variable can't be declared extern. |
| The specified variable can't be declared static. |
| The specified variable can't be declared volatile. |
| The specified variable can't have initializers. |
| The specified variable can't be declared as group shared or the group-shared variable can't perform a specific task. |
| The specified variable must be a literal expression. |
| The specified variable is missing initializers. |
| The function doesn't take the specified number of parameters. |
| An incorrect number of arguments was passed to the numeric-type constructor. |
| An incorrect number of arguments was passed to the intrinsic function. |
| The conversion from one type to another type is unsupported. |
| The subscript is invalid. |
| A numeric value, like a float, was expected. |
| A type mismatch occurred. For example, this error is returned if all template type components must have the same type, but they don't. |
| An array was expected. |
| A scalar, vector, or matrix was expected. |
| A determinant error, such as a faulty observation, occurred. |
| A vector was expected. |
| An l-value, which specifies a const object, was expected. |
| An error in matrix multiplication occurred. |
| An index for an array is out of bounds. |
| A imaginary square root error was found while parsing a shader file. |
| A indefinite log error was found while parsing a shader file. |
| A division-by-zero error was found while parsing a shader file. |
| The specified variable can't be declared const. |
| An error occurred with the redefinition of the specified formal parameter. |
| Constructors only defined for numeric base types. |
| The specified variable must be numeric. |
| Can't be specific to the target. |
| Can't have annotations. |
| The compiler target is unsupported. |
| A not-yet-implemented error was found while parsing a shader file. |
| Can't have semantics. |
| A default value for the specified parameter is missing. |
| Output only and can't be initialized. |
| Output parameters can't be declared const. |
| The specified variable can't be declared uniform. |
| Duplicate usages are specified. |
| Can't be specific to the usage. |
| A matrix was expected. |
| A scalar was expected. |
| The vector dimension must be between 1 and MAX_VECTOR_SIZE. |
| The matrix dimensions must be between 1 and MAX_VECTOR_SIZE. |
| The specified variable can't be declared as shared. |
| The specified variable can't be declared as inline. |
| The specified variable is a literal expression. |
| Array dimensions must be literal scalar expressions. |
| Array dimension must be between 1 and 65536. |
| The vector dimension must be a literal scalar expression. |
| Matrix dimensions must be a literal scalar expressions. |
| The specified variable can't be declared 'uniform out'. |
| The specified variable can't be a sampler. |
| Object literal expressions aren't allowed inside functions. |
| Object assignments aren't allowed inside functions. |
| A sampler was expected. |
| The function call is ambiguous. |
| The return value of a function differs from the return value of the prototype of the function. |
| The function already has a body. |
| A syntax error was found while parsing an indefinite arccosine. |
| A syntax error was found while parsing an indefinite arcsine. |
| Array dimensions for this type must be explicit. |
| Secondary array dimensions must be explicit. |
| The implicit array is missing a value. |
| The implicit array type does not match. |
| A void function can't have a semantic attached to it. |
| Non-matrix types can't be declared as row_major or column_major. |
| The loop control variable that is used outside the for-loop scope conflicts with a previous declaration in the outer scope; the most recent definition was used. |
| Void functions can't return a value. |
| The function must return a value. |
| A comma expression was used where an initializer list may have been intended. |
| An int or unsigned int type is required for bitwise operators. |
| There are conflicting geometry types. |
| Error with the attribute due to errors with its parameters. |
| The unsigned type can't be used with this variable type. |
| The particular syntax (DirectX 9 syntax) or keyword (pixelshader) is deprecated in strict mode. |
| The object doesn't have methods. |
| The object doesn't have the specified method. |
| The shader target or usage is invalid. |
| No writable textures, samplers, or UAVs can be members of compound types with interface inheritance. |
| Packoffset is only allowed in a constant buffer. |
| Unary negate of unsigned value is still unsigned. |
| Ran out of memory will performing the operation. |
| The base type is not a structure, class, or interface. |
| Multiple concrete base types were specified. |
| The specified variable isn't a template type. |
| The specified static method can't refer to instance members. |
| The method isn't found in the class. |
| The specified static method can't be called on objects. |
| The specified static member isn't found in the class or isn't a static variable. |
| The declaration type differs from the definition type. |
| Static members can only be defined in global scopes. |
| The specified variable was declared but not defined. |
| Interfaces can't contain data. |
| Interface methods can't be static. |
| Interface methods can't be declared outside of an interface. |
| Interfaces can't inherit from other types. |
| The class doesn't implement the specified method. |
| The return type doesn't match the overridden method. |
| Interfaces can't be members. |
| Types can't contain members of their own type. |
| Can't use call or forcecase attributes on switch statements in the specified programs. |
| |
| Default parameters can only be provided in the first prototype. |
| The specified register is used more than once. |
| The API call is invalid. |
| The debug info flag can only be set globally. |
| Interfaces can only be inputs. |
| Interface arrays can't be multi-dimensional. |
| Invalid type for index was specified. Index must be a scalar or a vector with the correct number of dimensions. |
| An array, matrix, vector, or indexable object type was expected in the index expression. |
| The vector element type must be a scalar type. |
| The matrix element type must be a scalar type. |
| The object element type can't be an object type. |
| The .mips type can only be used in a two-element indexing expression, such as, .mips[mip][element]. |
| The specified method didn't match any prototype in the class. |
| The specified method can't be re-declared. |
| Stream parameters can only be single-element types. |
| A warning was treated as an error. |
| The specified variable can't be declared 'single'. |
| Static interfaces can't have initializers. |
| Interfaces can't be declared in buffers. |
| Type mismatches aren't recommended. |
| Fragments aren't recommended. |
| The semantic doesn't apply and is ignored. |
| A signed versus unsigned mismatch occurred between destination and value and unsigned is assumed. |
| Unsigned integer literal is too large so is truncated. |
| In the conversion from larger type to smaller, a loss of data might occur. |
| The implicit truncation of a vector type occurred. |
| Initializer was used on a global 'const' variable. This requires setting an external constant. If a literal is wanted, use 'static const' instead. |
| Failed compiling the 10_level_9 (9_x feature levels) vertex shader version of the library function. |
| Failed compiling the 10_level_9 (9_x feature levels) pixel shader version of the library function. |
| The particular expressions are not yet implemented. |
| The entry-point function is not found. |
| The specified input parameter is missing semantics. |
| The specified output parameter or function return value is missing semantics. |
| The index of the array is out of bounds. |
| The version being used is no longer supported; instead use a current version. |
| The compiler target isn't recognized. |
| The type can't return a value. |
| The output parameter or return value was never assigned a value. |
| Texture sample is considered dependent since texcoord wasn't declared as at least a float. |
| The function is missing an implementation. |
| The loop is unable to unroll, the loop doesn't appear to terminate in a timely manner (in the specified number of iterations), or the unrolled loop is too large. Use the [unroll(n)] attribute to force an exact higher number. |
| The index of the sampler array must be a literal expression. |
| An array or a particular array dimension was expected. |
| The specified input semantic is invalid for geometry shader primitives, it must be its own parameter. |
| The target is invalid. For example, user-defined buffers can't be target specific, and the register specification expected a particular binding. |
| Texcube instructions can't have integer offsets. |
| The variable is undefined. |
| A break must be inside a loop. |
| A continue must be inside a loop. |
| Texture projection can't have texcoord instructions. |
| The return type of the texture is too large. It can't exceed four components. |
| Texture objects or streams aren't supported on legacy targets. |
| DirectX 9-style intrinsic functions are disabled when not running in DirectX 9 compatibility mode. |
| Specific attributes can't be used together, like loop and unroll, or a duplicate attribute was supplied. |
| The loop can't be mapped to a shader target because the target doesn't support breaks. |
| Gradient instructions can't be used in loops with breaks. |
| Texture access requires literal offset and multisample index. |
| Flow control (branching) can't be used on this profile. |
| Flattening with flow control in this specific situation can't be done. |
| Invalid binding operation was performed. For example, buffers can only be bound to one slot or one constant offset; invalid register specification because a particular binding was expected but didn't occur; can't mix packoffset elements with nonpackoffset elements in a cbuffer. |
| Loops that are marked with the loop attribute can't be unrolled. |
| A duplicate default or case statement occurred in a switch statement. |
| Non-empty case statements must have a break or return. |
| Partial precision isn't supported for the specified target. Min-precision types might offer similar functionality. |
| An unsupported operation was performed. For example, bitwise operations aren't supported on legacy targets; CheckAccessFullyMapped requires shader model 5 or higher; TextureXxx methods for tiled resources require shader model 5 or higher. |
| SV_ClipDistance semantics can't be used when using the clipplanes attribute, or duplicated input semantics can't change type, size, or layout. |
| Fall-through cases in switch statements aren't supported. case/default statements that fall through to the next case/default without a breakcan't have any code in them. |
| Sampler parameter must come from a literal expression. |
| A particular shader version, such as, ps_1_x, is no longer supported; use /Gec in the fxc.exe HLSL code compiler to automatically upgrade to the next shader version, such as, ps_2_0; alternately, fxc's /LD option allows use of a previous compiler DLL. |
| Global packoffset variables aren't supported. |
| Invalid packoffset location was specified. |
| A packoffset variable can't have a target qualifier. |
| The operation can't reinterpret the supplied datatype. |
| Abstract interfaces aren't supported on the specified target; interface references must resolve to specific instances. |
| No classes implement the specified method. |
| Reading from texture buffers is unsupported on the specified target. |
| Global structs and classes can't be changed. |
| The specified uints can only be used with known-positive values, use int if possible. |
| Interlocked targets must be groupshared or UAV elements. Or, the specified target doesn't support interlocked operations, for example,IncrementCounter/DecrementCounter are only valid on RWStructuredBuffer objects. |
| The index of the sampler array must be a literal expression, so the loop is forced to unroll. |
| An infinite loop was detected so the loop writes no values. |
| The loop can't be mapped to a shader target because the target doesn't support breaks. |
| Can't use gradient instructions in loops with break. |
| The attribute is unknown or invalid for the specified statement. |
| Flags aren't compatible with the operation. |
| Integer divides might be much slower, try using uints if possible. |
| The loop only executes for a limited number of iterations or doesn't seem to do anything so consider removing it or forcing it to unroll. |
| The #endif directive is uninitialized. |
| The loop returns asymmetrically. |
| If statements that contain out of bounds array accesses can't be flattened. |
| A particular shader version, such as, ps_1_x, is no longer supported; use the next shader version, such as, ps_2_0. |
| The loop simulation goes out of bounds. |
| The loop unrolls out of bounds. |
| For better compilation results, consider re-enabling the specified rule. |
| Loop simulation finished early, use /O1 or higher for potentially better codegen. |
| Loop won't exit early, try to make sure the loop condition is as tight as possible. |
| The register semantic is ignored. |
| The unknown pragma directive is ignored. |
| The loop executes for more than the maximum number of iterations for the specified shader target, which forces the loop to unroll. |
| A gradient instruction is used in a loop with varying iteration, which forces the loop to unroll. |
| The pow(f, e) intrinsic function won't work for negative f, use abs(f) or conditionally handle negative values if you expect them. |
| Interface references must resolve to non-varying objects. |
| Tessellation factor scale is clamped to the range [0, 1]. |
| Thread synchronization operations can't be used in varying flow control. |
| Automatic unrolling has been disabled for the loop, consider using the [unroll] attribute or manual unrolling. Or, loop termination conditions in varying flow control so can't depend on data read from a UAV. |
| Patch semantics must live in the enclosed type so the outer semantic is ignored. Or, semantics in type are overridden by variable/function or enclosing type. |
| The value can't be infinity, A call to isfinite might not be necessary. /Gis might force isfinite to be performed. Or, The value can't be NaN, A call toisnan might not be necessary. /Gis might forceisnan to be performed. |
| The output value isn't completely initialized. |
| The specified variable doesn't supportgroupshared so groupshared is ignored. |
| Both sides of the &&, ||, or ?: operator are always evaluated so the side effect on the specified side won't be conditional. |
| The abs operation on unsigned values is not meaningful so it's ignored. |
| Texture access must have literal offset and multisample index. |
| A race condition writing to a shared resource was detected, note that threads are writing the same value, but performance might be diminished due to contention. |
| A race condition writing to shared memory was detected, note that threads are writing the same value, but performance might be diminished due to contention. |
| Source_mark is most useful in /Od builds. Without /Od source_mark, can be moved around in the final shader by optimizations. |
| Abstract interfaces aren't supported on the specified target so interface references must resolve to specific instances. |
| The target emulates A / B with A * reciprocal(B). If the reciprocal of B is not representable in your min-precision type, the result might not be mathematically correct. |
| The clipplanes attribute is ignored in library functions. |
| The '#pragma def' directive is no longer supported on DirectX 10+ and 10_level_9 (9_x feature levels) targets. Use compatibility mode to allow compilation. |
| Global variables can't use the 'half' type in the specified target. To treat this variable as a float, use the backwards compatibility flag. |
| The specified target doesn't support double data type values. |
| The specified target doesn't support 8-bit or 16-bit integers. |
| The specified target doesn't support 64-bit integers. |
| The abs operation on unsigned values isn't supported. |
| The thread group size is invalid. |
| The size of the thread group is missing. |
| Expected the specified parameter to be a certain value but got the specified value. Or, line or triangle output topologies are only available with isoline domains. Or, the maximum tesselation factor must be in the range [1,64]. |
| Only one InputPatch or OutputPatch parameter is allowed. Or, InputPatch inputs can only be used in hull and geometry (5_0+) shaders. Or,OutputPatch inputs can only be used in the domain shaders and a hull shader's patch constant function. |
| The patch constant function must use the same input control point type that is declared in the control point phase. Or, the patch constant function must use the same output control point type that is returned from the control point phase. Or, the patch constant function's output patch input should have a certain number of elements, but has the specified amount. |
| The specified target doesn't support interlocked operations. |
| The specified variable doesn't supportgroupshared. |
| The gradient operation uses a value that might not be defined for all pixels (in the specified target, UAV loads can't participate in gradient operations). |
| Thread synchronization operations can't be used in varying flow control. |
| The specified target doesn't support synchronization operations. |
| The specified target doesn't support Append/Consume buffers. |
| The specified target doesn't support typed UAVs. |
| The specified target doesn't support UAVs. |
| Stores to group shared memory for specified targets must be indexed by an SV_GroupIndexonly. |
| Resources being indexed can't come from conditional expressions, they must come from literal expressions. |
| The stream parameter must come from a literal expression. |
| Loop termination conditions in varying flow control so can't depend on data read from a UAV. |
| The specified target doesn't support pull-model attribute evaluation. |
| The specified target doesn't support pull-model evaluation of position. |
| Attribute evaluation can only be done on values that are taken directly from inputs. |
| Can't unroll loop with an out-of-bounds array reference in the condition. |
| Typed UAV loads are only supported for single-component 32-bit element types. |
| The specified target only allows one depth output. |
| Interface-reachable members containing UAVs or group shared variables aren't implemented yet. |
| The storage class globallycoherent can only be used with Unordered Access View (UAV) buffers and can't be used with append/consume buffers. |
| When you define a pass-through control-point shader, you must declare an InputPatch object, and the number of output control points must be zero or must match the input patch size. |
| The specified target only supports interlocked operations on scalar int or uint data. |
| Expressions with side effects are invalid as attribute parameters |
| Groupshared variables can't contain resources such as textures, samplers or UAVs. Or, resources such as textures, samplers or UAVs can't contain other resources. |
| The specified target doesn't support double-precision floating-point. Or, the operation can't be used directly on resources. Or, the operation can't be used with doubles, cast to float first. Or, the operation isn't supported on the given type. |
| The tessfactor semantic is out of order. Or, conflicting quad/tri/isoline tessfactor semantic. Or, tessfactor semantics must be in the same component. |
| The specified object isn't supported. |
| Double types can't be used as shader inputs or outputs. If you need to pass a double between shader stages, you must pass it as two uints and use asuint and asdouble to convert between forms. |
| Derivatives of indexed variables aren't implemented yet. |
| The left-hand side of an assignment can't be cast to an indexable object so consider using asuint,asfloat, or asdouble on the right-hand side. |
| The resource being indexed is uninitialized. |
| Invalid variable reference in static variable initializer. Locals can't be used to initialize static variables. |
| The specified target doesn't support aborts. |
| The specified target doesn't support messages. |
| A race condition writing to a shared resource was detected so consider making this operation write conditional. |
| A race condition writing to shared memory was detected so consider making this operation write conditional. |
| An infinite loop was detected so the loop never exits. |
| The specified variable matches a variable in the template shader but the type layout doesn't match. |
| The specified resource had binding conflicts with the template shader. |
| Place-holder template resources can only be simple resources so structs and arrays aren't supported. |
| For the specified resource, binding isn't present in the template shader. |
| The specified target doesn't support indexing resources. |
| The fma intrinsic function can only be used with double arguments. |
| The specified target doesn't support minimum-precision data. |
| The specified target doesn't support 16-bit float conversions. |
| If statements that contain side effects can't be flattened. |
| Signed integer division isn't supported on minimum-precision types. Cast to int to use 32-bit division. |
| A minimum 8-bit floating point value is invalid or unsupported. |
| A continue statement can't be used in a switch statement. |
| Debug isn't supported. |
| The specified function parameters are unsupported. |
| Library function parameters and return values can't have duplicate semantic. |
| Library functions are supported only for pixel shaders and vertex shaders. |
| An entry point can't be specified for a library. Mark library entry points with the export keyword. |
| The specified variable is declared as static, which isn't supported for libraries yet. |
| The specified variable is declared as tbuffer, which is not supported for libraries yet. |
| Classes and interfaces aren't supported in libraries. |
| Double data types can't be used as library function inputs or outputs. If you need to pass a double to a library function, you must pass it as two uints and use asuint and asdouble to convert between forms. |
| Library entry points can't be overloaded. |
| The 'resources_may_alias' option is only valid for cs_5_0+ targets. |
| The specified variable is used without having been completely initialized. |
| A division by zero in the mid-level preprocessor expression occurred. |
| An indefinite logarithm occurred. |
| An imaginary square root occurred. |
| The program is too complex because there are more active values than registers. |
| An indefinite arcsine occurred. |
| An indefinite arccosine occurred. |
| The array index is out of bounds. |
| A floating point division by zero occurred. |
| An integer division by zero occurred. |
| An unsigned integer division by zero occurred. |
| The floating-point value out of integer range for a conversion. |
| The floating-point value out of unsigned integer range for a conversion. |
| An indefinite derivative calculation occurred. |
| Gradient operations can't occur inside loops with divergent flow control. |
| The semantic length is too long. |
| The semantic is invalid. For example, theSV_InstanceID semantic can't be used with 10_level_9 (9_x feature levels) targets, or zero-character semantics aren't supported. |
| The same variable can't be bound to multiple constants in the same constant bank. |
| The shader uses texture addressing operations in a dependency chain that is too complex for the specific target shader model to handle. |
| Multiple variables were found with the same user-specified location. |
| Multiple variables were found with the same user-specified location. |
| Derivative is being used before it was defined so consider moving the derivative assignment earlier in the program. |
| Derivative isn't defined in a different branch of flow-control so consider moving the derivative assignment before any flow control statements. |
| A redefinition of a derivative occurred, and derivatives can only be assigned once. |
| Derivatives of known values are unimplemented. |
| Unable to calculate the derivative of the specified value. |
| A thread sync operation must be in non-varying flow control. Because of a potential race condition, this sync is invalid so consider adding a sync after reading any values that control shader execution at this point. |
| The array index is out of bounds. |
| The specified variable has a minimum precision type and can't be marked precise. |
| An infinite loop was detected so the loop never exits. |
| The literal floating-point value is out of integer range for the conversion. |
| The literal floating-point value is out of unsigned integer range for the conversion. |
| A possible integer divide by zero occurred. |
| A possible unsigned integer divide by zero occurred. |
| An imaginary square root operation occurred. |
| An indefinite logarithm operation occurred. |
| Optimizations aren't converging. |
| Gradient-based operations must be moved out of flow control to prevent divergence. Performance might improve by using a non-gradient operation. |
| The sum of two floating point values can't be represented accurately in double precision. |
| Floating-point operations flush denorm float literals to zero so the specified floating point value is losing precision (this warning will only be shown once per compile). |
| A feature like clipping from a swizzled vector is not yet implemented. |
| An inconsistent semantic definition occurred. |
| The specified input semantic is invalid. |
| The specified output semantic is invalid. |
| Overlapping output semantics occurred. |
| The maximum temp register index was exceeded. |
| The maximum number of inputs was exceeded. |
| The maximum constant register index was exceeded. Try to reduce the number of constants that are referenced. |
| The maximum address register index was exceeded. |
| An invalid register semantic was used, or a variable must be bound to multiple register banks. |
| The maximum number of samplers was exceeded. |
| The target doesn't support relative addressing. |
| The texture coordinate w-component can't be accessed. |
| Dependent texture read operations that in any way are based on color inputs can't be performed. |
| The program is too big. |
| The sampler can't be bound to the user specified stage or sampler array. |
| A texcoord that was used as input in a sampler can't be read from. |
| User defined sampler or sampler array bindings are conflicting. If two samplers have the same user binding, they can't both be used in the same shader. |
| Texture lookup can't be performed twice from a user bound or similar array access sampler. |
| Too many texture loads and reads occurred from texcoords. |
| texcoord can be read from and used for texlookup only in ps_1_4 and higher. |
| The program is too complex and is out of temporary registers. |
| Replicate swizzles are only supported in ps_1_4. |
| This dependent texture read can't be mapped to ps_1_x, or the shader can't compile to a ps_1_x shader because this model can't match all the dependent texture reads this shader requires. |
| texm can't be matched because computed texcoord is used in shader. |
| texm* can't be matched because source inputs aren't in the appropriate texture coordinates. For more info, see the ps_1_x assembly reference. |
| texm* can't be matched to because texm* can't have source modifiers on input texcoord. |
| texm* can't be matched to because texm* can only have bx2 modifier on input texload. |
| DEPTH must be a scalar. |
| The semantic (SV_Target or COLOR) value must be a four-component vector. |
| The pixel shader must minimally write all four components of the semantic (SV_Target0 or COLOR0) value. |
| DP4 isn't supported. |
| The expression can't be mapped to the shader instruction set. |
| Swizzle can't be mapped to ps_1_x. |
| Double dependent texture reads can't be performed in ps_1_x. |
| The texreg2ar or texreg2gb instruction can't be matched to because you can't have input modifiers. |
| The expression can only be mapped to texreg2rgb, but this instruction isn't supported on 1_x. |
| Write masks can't be emulated for the ps_1_x shader model. |
| SV_Target outputs must be contiguous from SV_Target0 to SV_TargetN, or COLOR outputs must be contiguous from COLOR0 to COLORn. |
| A sampler mismatch occurred because the sampler was used inconsistently. |
| PSIZE or FOG must be a scalar. |
| The vertex shader must minimally write all four components of SV_Position or POSITION. |
| Texcoord outputs must be contiguous from texcoord0 to texcoordn. |
| Multi-register semantics aren't supported in fragments. |
| The clip must be from a 3 vector in ps_1_x. |
| An unsupported texture type for the specified target was encountered. |
| The maximum sampler register index was exceeded. |
| The debug info exceeds the maximum comment size so no debug info was emitted. |
| The constant table info exceeds the maximum comment size. |
| The maximum predicate register index was exceeded. |
| Try reducing the number of constant branches, take bools out of structs/arrays, or move them to the start of the struct. |
| Try reducing the number of loops, take loop counters out of structs/arrays, or move them to the start of the struct. |
| The general loop can't be mapped to this instruction set. |
| Relative address references are too deep. |
| Vector conditionals can't be emulated in ps_1_x shader model. |
| An invalid type used for the specified semantics. |
| The maximum number of texture slots is exceeded for a library. |
| Offset texture instructions must take an offset, which can resolve to integer literal in the range -8 to 7. |
| The maximum number of constant buffer slots is exceeded for a library. |
| The usage is unsupported on the target. For example, the sample interpolation, nointerpolation, noperspective, or integer inputs usages might be unsupported. |
| An incorrect type was specified for the POSITION value. |
| The target can only emit to a specific amount of streams. |
| The output limit was exceeded. |
| The geometry shader didn't emit anything. |
| The semantic length is too long and is limited to the specified number of characters. |
| A duplicate system value semantic definition was encountered. |
| An uninitialized value was read. |
| An error occurred during signature validation. |
| Not all elements of SV_Position were written. |
| The specified cbuffer register was used more than once. |
| An invalid floating point literal occurred. |
| The specified output contains a system-interpreted value that must be written in every execution path of the shader. Unconditional initialization might help. |
| Using sampler arrays with texture objects on 10_level_9 (9_x feature level) targets isn't implemented yet. |
| Sampling from non-floating point texture formats can't be done. |
| The specified semantic isn't supported on the 10_level_9 (9_x feature level) target. |
| The maximum number of interface pointers was exceeded. |
| The maximum number of UAV slots was exceeded for a library. |
| The total amount, in bytes, of group shared memory exceeded the target's limit. |
| Shaders compiled for the specified target can only have a single group shared data item. |
| Group shared data for the specified target must have a count of elements that is equal to the number of threads in the thread group. |
| The maximum control point count for the target was exceeded |
| Group shared data for the specified target is too large and must have an element size of at most the specified amount of bytes when compiling for the specified number of threads. |
| Group shared data for the specified target must be an array of elements. |
| When multiple geometry shader output streams are used they must be point lists. |
| The target's snap offset must be in the range -8 to 7. |
| Clip planes can't be addressed in the specified target; or, clip planes must be non-literal constants with identity swizzles in the specified target. |
| RWStructuredBuffer objects can increment or decrement their counters, but not both. |
| Typed UAV stores must write all declared components. |
| Texture1D types are unsupported on the specified target. |
| The array element count of GetDimensions onTextureCubeArray objects is unavailable on the specified target. |
| The structured buffer element size is invalid. It must be a multiple of specified bytes in the specified target, or it can't be larger than the specified bytes in in the specified target. |
| The shader's indexable literal values were exceeded. The shader uses too many indexable literal values so consider using less constant arrays. |
| The size of the specified constant buffer is the specified number 16-byte entries, which exceeds maximum allowed size of entries. |
| Debug instructions are unsupported in shader libraries. |
| Interface calls can't be indexed with varying values. |
| A feature isn't implemented yet. |
| A _bias opportunity was missed because the source wasn't clamped 0 to 1. |
| A complement opportunity was missed because the input result was clamped from 0 to 1. |
| Lerp can't be matched because the lerp factor is not _sat'd. |
| Literal values outside range -1 to 1 are clamped on all ps_1_x shading models. |
| The specified input semantic has been deprecated; use the specified semantic instead. |
| The specified output semantic has been deprecated; use the specified semantic instead. |
| The texcoord inputs used directly (that is, other than sampling from textures) in shader body in ps_1_x are always clamped from 0 to 1. |
| The mid-level var was not found. |
| The semantic is no longer in use. |
| A duplicate non-system value semantic definition was encountered. |
| The loop can't be matched because the loop count isn't from an integer type. |
| The sample bias value is limited to the range [-16.00, 15.99] so use the specified value instead of this value. |
| The sum of temp registers and indexable temp registers times the specified number of threads exceeds the recommended total number of threads so performance might be reduced. |
| A system-interpreted value is emitted that can't be written in every execution path of the shader. |
| The specified semantic has no special meaning on 10_level_9 (9_x feature levels) targets. |
| Effects are deprecated for the D3DCompiler_47.dll or later. |
Requirements
| Header |
|
|---|
