SHADER_VARIABLE_TYPE GetOperandDataType(HLSLCrossCompilerContext* psContext, const Operand* psOperand)
{
switch(psOperand->eType)
{
case OPERAND_TYPE_TEMP:
{
SHADER_VARIABLE_TYPE eCurrentType;
int i = 0;
if(psOperand->eSelMode == OPERAND_4_COMPONENT_SELECT_1_MODE)
{
return psOperand->aeDataType[psOperand->aui32Swizzle[0]];
}
if(psOperand->eSelMode == OPERAND_4_COMPONENT_SWIZZLE_MODE)
{
if(psOperand->ui32Swizzle == (NO_SWIZZLE))
{
return psOperand->aeDataType[0];
}
return psOperand->aeDataType[psOperand->aui32Swizzle[0]];
}
if(psOperand->eSelMode == OPERAND_4_COMPONENT_MASK_MODE)
{
uint32_t ui32CompMask = psOperand->ui32CompMask;
if(!psOperand->ui32CompMask)
{
ui32CompMask = OPERAND_4_COMPONENT_MASK_ALL;
}
for(;i<4;++i)
{
if(ui32CompMask & (1<<i))
{
eCurrentType = psOperand->aeDataType[i];
break;
}
}
#ifdef _DEBUG
//Check if all elements have the same basic type.
for(;i<4;++i)
{
if(psOperand->ui32CompMask & (1<<i))
{
if(eCurrentType != psOperand->aeDataType[i])
{
ASSERT(0);
}
}
}
#endif
return eCurrentType;
}
ASSERT(0);
break;
}
case OPERAND_TYPE_OUTPUT:
{
const uint32_t ui32Register = psOperand->aui32ArraySizes[psOperand->iIndexDims-1];
InOutSignature* psOut;
if(GetOutputSignatureFromRegister(ui32Register, psOperand->ui32CompMask, 0, &psContext->psShader->sInfo, &psOut))
{
if( psOut->eComponentType == INOUT_COMPONENT_UINT32)
{
return SVT_UINT;
}
else if( psOut->eComponentType == INOUT_COMPONENT_SINT32)
{
return SVT_INT;
}
}
break;
}
case OPERAND_TYPE_INPUT:
{
const uint32_t ui32Register = psOperand->aui32ArraySizes[psOperand->iIndexDims-1];
InOutSignature* psIn;
//UINT in DX, INT in GL.
if(psOperand->eSpecialName == NAME_PRIMITIVE_ID)
{
return SVT_INT;
}
if(GetInputSignatureFromRegister(ui32Register, &psContext->psShader->sInfo, &psIn))
{
if( psIn->eComponentType == INOUT_COMPONENT_UINT32)
{
return SVT_UINT;
}
else if( psIn->eComponentType == INOUT_COMPONENT_SINT32)
{
return SVT_INT;
}
}
break;
}
case OPERAND_TYPE_CONSTANT_BUFFER:
{
ConstantBuffer* psCBuf = NULL;
ShaderVarType* psVarType = NULL;
int32_t index = -1;
int32_t rebase = -1;
int foundVar;
GetConstantBufferFromBindingPoint(RGROUP_CBUFFER, psOperand->aui32ArraySizes[0], &psContext->psShader->sInfo, &psCBuf);
if(psCBuf)
{
foundVar = GetShaderVarFromOffset(psOperand->aui32ArraySizes[1], psOperand->aui32Swizzle, psCBuf, &psVarType, &index, &rebase);
if(foundVar && index == -1 && psOperand->psSubOperand[1] == NULL)
{
return psVarType->Type;
}
}
else
{
// Todo: this isn't correct yet.
return SVT_FLOAT;
}
break;
}
case OPERAND_TYPE_IMMEDIATE32:
{
return psOperand->iIntegerImmediate ? SVT_INT : SVT_FLOAT;
}
case OPERAND_TYPE_INPUT_THREAD_ID:
case OPERAND_TYPE_INPUT_THREAD_GROUP_ID:
case OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP:
case OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED:
{
return SVT_UINT;
}
case OPERAND_TYPE_SPECIAL_ADDRESS:
{
return SVT_INT;
}
default:
{
return SVT_FLOAT;
}
}
return SVT_FLOAT;
}
static void TranslateVariableName(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag, uint32_t* pui32IgnoreSwizzle)
{
int integerConstructor = 0;
bstring glsl = *psContext->currentGLSLString;
*pui32IgnoreSwizzle = 0;
if(psOperand->eType != OPERAND_TYPE_IMMEDIATE32 &&
psOperand->eType != OPERAND_TYPE_IMMEDIATE64 &&
psOperand->eType != OPERAND_TYPE_CONSTANT_BUFFER)
{
const uint32_t swizCount = psOperand->iNumComponents;
SHADER_VARIABLE_TYPE eType = GetOperandDataType(psContext, psOperand);
if( (ui32TOFlag & (TO_FLAG_INTEGER|TO_FLAG_UNSIGNED_INTEGER)) == (TO_FLAG_INTEGER|TO_FLAG_UNSIGNED_INTEGER))
{
//Can be either int or uint
if(eType != SVT_INT && eType != SVT_UINT)
{
if(swizCount == 1)
bformata(glsl, "int(");
else
bformata(glsl, "ivec%d(", swizCount);
integerConstructor = 1;
}
}
else
{
if((ui32TOFlag & (TO_FLAG_INTEGER|TO_FLAG_DESTINATION))==TO_FLAG_INTEGER &&
eType != SVT_INT)
{
//Convert to int
if(swizCount == 1)
bformata(glsl, "int(");
else
bformata(glsl, "ivec%d(", swizCount);
integerConstructor = 1;
}
if((ui32TOFlag & (TO_FLAG_UNSIGNED_INTEGER|TO_FLAG_DESTINATION))==TO_FLAG_UNSIGNED_INTEGER &&
eType != SVT_UINT)
{
//Convert to uint
if(swizCount == 1)
bformata(glsl, "uint(");
else
bformata(glsl, "uvec%d(", swizCount);
integerConstructor = 1;
}
}
}
switch(psOperand->eType)
{
case OPERAND_TYPE_IMMEDIATE32:
{
if(psOperand->iNumComponents == 1)
{
if(ui32TOFlag & TO_FLAG_UNSIGNED_INTEGER)
{
bformata(glsl, "%uu",
*((unsigned int*)(&psOperand->afImmediates[0])));
}
else
if((ui32TOFlag & TO_FLAG_INTEGER) || psOperand->iIntegerImmediate || fpcheck(psOperand->afImmediates[0]))
{
bformata(glsl, "%d",
*((int*)(&psOperand->afImmediates[0])));
}
else
{
bformata(glsl, "%f",
psOperand->afImmediates[0]);
}
}
else
{
if(ui32TOFlag & TO_FLAG_UNSIGNED_INTEGER)
{
bformata(glsl, "uvec4(%uu, %uu, %uu, %uu)",
*(unsigned int*)&psOperand->afImmediates[0],
*(unsigned int*)&psOperand->afImmediates[1],
*(unsigned int*)&psOperand->afImmediates[2],
*(unsigned int*)&psOperand->afImmediates[3]);
}
else
if((ui32TOFlag & TO_FLAG_INTEGER) ||
psOperand->iIntegerImmediate ||
fpcheck(psOperand->afImmediates[0]) ||
fpcheck(psOperand->afImmediates[1]) ||
fpcheck(psOperand->afImmediates[2]) ||
fpcheck(psOperand->afImmediates[3]))
{
bformata(glsl, "ivec4(%d, %d, %d, %d)",
*(int*)&psOperand->afImmediates[0],
*(int*)&psOperand->afImmediates[1],
*(int*)&psOperand->afImmediates[2],
*(int*)&psOperand->afImmediates[3]);
}
else
{
bformata(glsl, "vec4(%f, %f, %f, %f)",
psOperand->afImmediates[0],
psOperand->afImmediates[1],
psOperand->afImmediates[2],
psOperand->afImmediates[3]);
}
if(psOperand->iNumComponents != 4)
{
AddSwizzleUsingElementCount(psContext, psOperand->iNumComponents);
}
}
break;
}
case OPERAND_TYPE_IMMEDIATE64:
{
if(psOperand->iNumComponents == 1)
{
bformata(glsl, "%f",
psOperand->adImmediates[0]);
}
else
{
bformata(glsl, "dvec4(%f, %f, %f, %f)",
psOperand->adImmediates[0],
psOperand->adImmediates[1],
psOperand->adImmediates[2],
psOperand->adImmediates[3]);
if(psOperand->iNumComponents != 4)
{
AddSwizzleUsingElementCount(psContext, psOperand->iNumComponents);
}
}
break;
}
case OPERAND_TYPE_INPUT:
{
switch(psOperand->iIndexDims)
{
case INDEX_2D:
{
if(psOperand->aui32ArraySizes[1] == 0)//Input index zero - position.
{
bcatcstr(glsl, "gl_in");
TranslateOperandIndex(psContext, psOperand, TO_FLAG_NONE);//Vertex index
bcatcstr(glsl, ".gl_Position");
}
else
{
const char* name = "Input";
if(ui32TOFlag & TO_FLAG_DECLARATION_NAME)
{
name = GetDeclaredInputName(psContext, psContext->psShader->eShaderType, psOperand);
}
bformata(glsl, "%s%d", name, psOperand->aui32ArraySizes[1]);
TranslateOperandIndex(psContext, psOperand, TO_FLAG_NONE);//Vertex index
}
break;
}
default:
{
if(psOperand->eIndexRep[0] == OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE)
{
bformata(glsl, "Input%d[int(", psOperand->ui32RegisterNumber);
TranslateOperand(psContext, psOperand->psSubOperand[0], TO_FLAG_NONE);
bcatcstr(glsl, ")]");
}
else
{
if(psContext->psShader->aIndexedInput[psOperand->ui32RegisterNumber] != 0)
{
const uint32_t parentIndex = psContext->psShader->aIndexedInputParents[psOperand->ui32RegisterNumber];
bformata(glsl, "Input%d[%d]", parentIndex,
psOperand->ui32RegisterNumber - parentIndex);
}
else
{
if(ui32TOFlag & TO_FLAG_DECLARATION_NAME)
{
const char* name = GetDeclaredInputName(psContext, psContext->psShader->eShaderType, psOperand);
bcatcstr(glsl, name);
}
else
{
bformata(glsl, "Input%d", psOperand->ui32RegisterNumber);
}
}
}
break;
}
}
break;
}
case OPERAND_TYPE_OUTPUT:
{
bformata(glsl, "Output%d", psOperand->ui32RegisterNumber);
if(psOperand->psSubOperand[0])
{
bcatcstr(glsl, "[int("); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[0], TO_FLAG_NONE);
bcatcstr(glsl, ")]");
}
break;
}
case OPERAND_TYPE_OUTPUT_DEPTH:
case OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL:
case OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL:
{
bcatcstr(glsl, "gl_FragDepth");
break;
}
case OPERAND_TYPE_TEMP:
{
SHADER_VARIABLE_TYPE eType = GetOperandDataType(psContext, psOperand);
bcatcstr(glsl, "Temp");
if(eType == SVT_INT)
{
bcatcstr(glsl, "_int");
}
else if(eType == SVT_UINT)
{
bcatcstr(glsl, "_uint");
}
else if(eType == SVT_DOUBLE)
{
bcatcstr(glsl, "_double");
}
else if(eType == SVT_VOID ||
(ui32TOFlag & TO_FLAG_DESTINATION))
{
if(ui32TOFlag & TO_FLAG_INTEGER)
{
bcatcstr(glsl, "_int");
}
else
if(ui32TOFlag & TO_FLAG_UNSIGNED_INTEGER)
{
bcatcstr(glsl, "_uint");
}
}
bformata(glsl, "[%d]", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_SPECIAL_IMMCONSTINT:
{
bformata(glsl, "IntImmConst%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_SPECIAL_IMMCONST:
{
bformata(glsl, "ImmConst%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_SPECIAL_OUTBASECOLOUR:
{
bcatcstr(glsl, "BaseColour");
break;
}
case OPERAND_TYPE_SPECIAL_OUTOFFSETCOLOUR:
{
bcatcstr(glsl, "OffsetColour");
break;
}
case OPERAND_TYPE_SPECIAL_POSITION:
{
bcatcstr(glsl, "gl_Position");
break;
}
case OPERAND_TYPE_SPECIAL_FOG:
{
bcatcstr(glsl, "Fog");
break;
}
case OPERAND_TYPE_SPECIAL_POINTSIZE:
{
bcatcstr(glsl, "gl_PointSize");
break;
}
case OPERAND_TYPE_SPECIAL_ADDRESS:
{
bcatcstr(glsl, "Address");
break;
}
case OPERAND_TYPE_SPECIAL_TEXCOORD:
{
bformata(glsl, "TexCoord%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_CONSTANT_BUFFER:
{
const char* StageName = "VS";
ConstantBuffer* psCBuf = NULL;
ShaderVarType* psVarType = NULL;
int32_t index = -1;
GetConstantBufferFromBindingPoint(RGROUP_CBUFFER, psOperand->aui32ArraySizes[0], &psContext->psShader->sInfo, &psCBuf);
switch(psContext->psShader->eShaderType)
{
case PIXEL_SHADER:
{
StageName = "PS";
break;
}
case HULL_SHADER:
{
StageName = "HS";
break;
}
case DOMAIN_SHADER:
{
StageName = "DS";
break;
}
case GEOMETRY_SHADER:
{
StageName = "GS";
break;
}
case COMPUTE_SHADER:
{
StageName = "CS";
break;
}
default:
{
break;
}
}
if(ui32TOFlag & TO_FLAG_DECLARATION_NAME)
{
pui32IgnoreSwizzle[0] = 1;
}
if((psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)!=HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
if(psCBuf)
{
//$Globals.
if(psCBuf->Name[0] == '$')
{
bformata(glsl, "Globals%s", StageName);
}
else
{
bformata(glsl, "%s%s", psCBuf->Name, StageName);
}
if((ui32TOFlag & TO_FLAG_DECLARATION_NAME) != TO_FLAG_DECLARATION_NAME)
{
bcatcstr(glsl, ".");
}
}
else
{
//bformata(glsl, "cb%d", psOperand->aui32ArraySizes[0]);
}
}
if((ui32TOFlag & TO_FLAG_DECLARATION_NAME) != TO_FLAG_DECLARATION_NAME)
{
//Work out the variable name. Don't apply swizzle to that variable yet.
int32_t rebase = 0;
if(psCBuf)
{
GetShaderVarFromOffset(psOperand->aui32ArraySizes[1], psOperand->aui32Swizzle, psCBuf, &psVarType, &index, &rebase);
bformata(glsl, "%s", psVarType->FullName);
}
else // We don't have a semantic for this variable, so try the raw dump appoach.
{
bformata(glsl, "cb%d.data", psOperand->aui32ArraySizes[0]);//
index = psOperand->aui32ArraySizes[1];
}
//Dx9 only?
if(psOperand->psSubOperand[0] != NULL)
{
SHADER_VARIABLE_TYPE eType = GetOperandDataType(psContext, psOperand->psSubOperand[0]);
if(eType != SVT_INT && eType != SVT_UINT)
{
bcatcstr(glsl, "[int("); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[0], TO_FLAG_NONE);
bcatcstr(glsl, ")]");
}
else
{
bcatcstr(glsl, "["); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[0], TO_FLAG_NONE);
bcatcstr(glsl, "]");
}
ASSERT(index == 0 || index == -1);
}
else
if(index != -1 && psOperand->psSubOperand[1] != NULL)
{
//Array of matrices is treated as array of vec4s
if(index != -1)
{
SHADER_VARIABLE_TYPE eType = GetOperandDataType(psContext, psOperand->psSubOperand[1]);
if(eType != SVT_INT && eType != SVT_UINT)
{
bcatcstr(glsl, "[int(");
TranslateOperand(psContext, psOperand->psSubOperand[1], TO_FLAG_NONE);
bformata(glsl, ") + %d]", index);
}
else
{
bcatcstr(glsl, "[");
TranslateOperand(psContext, psOperand->psSubOperand[1], TO_FLAG_NONE);
bformata(glsl, " + %d]", index);
}
}
}
else if(index != -1)
{
bformata(glsl, "[%d]", index);
}
else if(psOperand->psSubOperand[1] != NULL)
{
SHADER_VARIABLE_TYPE eType = GetOperandDataType(psContext, psOperand->psSubOperand[1]);
if(eType != SVT_INT && eType != SVT_UINT)
{
bcatcstr(glsl, "[");
TranslateOperand(psContext, psOperand->psSubOperand[1], TO_FLAG_NONE);
bcatcstr(glsl, "]");
}
else
{
bcatcstr(glsl, "[int(");
TranslateOperand(psContext, psOperand->psSubOperand[1], TO_FLAG_NONE);
bcatcstr(glsl, ")]");
}
}
if(psVarType && psVarType->Class == SVC_VECTOR)
{
switch(rebase)
{
case 4:
{
if(psVarType->Columns == 2)
{
//.x(GLSL) is .y(HLSL). .y(GLSL) is .z(HLSL)
bcatcstr(glsl, ".xxyx");
}
else if(psVarType->Columns == 3)
{
//.x(GLSL) is .y(HLSL). .y(GLSL) is .z(HLSL) .z(GLSL) is .w(HLSL)
bcatcstr(glsl, ".xxyz");
}
break;
}
case 8:
{
if(psVarType->Columns == 2)
{
//.x(GLSL) is .z(HLSL). .y(GLSL) is .w(HLSL)
bcatcstr(glsl, ".xxxy");
}
break;
}
case 0:
default:
{
//No rebase, but extend to vec4.
if(psVarType->Columns == 2)
{
bcatcstr(glsl, ".xyxx");
}
else if(psVarType->Columns == 3)
{
bcatcstr(glsl, ".xyzx");
}
break;
}
}
}
if(psVarType && psVarType->Class == SVC_SCALAR)
{
*pui32IgnoreSwizzle = 1;
}
}
break;
}
case OPERAND_TYPE_RESOURCE:
{
TextureName(psContext, psOperand->ui32RegisterNumber, 0);
*pui32IgnoreSwizzle = 1;
break;
}
case OPERAND_TYPE_SAMPLER:
{
bformata(glsl, "Sampler%d", psOperand->ui32RegisterNumber);
*pui32IgnoreSwizzle = 1;
break;
}
case OPERAND_TYPE_FUNCTION_BODY:
{
const uint32_t ui32FuncBody = psOperand->ui32RegisterNumber;
const uint32_t ui32FuncTable = psContext->psShader->aui32FuncBodyToFuncTable[ui32FuncBody];
//const uint32_t ui32FuncPointer = psContext->psShader->aui32FuncTableToFuncPointer[ui32FuncTable];
const uint32_t ui32ClassType = psContext->psShader->sInfo.aui32TableIDToTypeID[ui32FuncTable];
const char* ClassTypeName = &psContext->psShader->sInfo.psClassTypes[ui32ClassType].Name[0];
const uint32_t ui32UniqueClassFuncIndex = psContext->psShader->ui32NextClassFuncName[ui32ClassType]++;
bformata(glsl, "%s_Func%d", ClassTypeName, ui32UniqueClassFuncIndex);
break;
}
case OPERAND_TYPE_INPUT_FORK_INSTANCE_ID:
{
bcatcstr(glsl, "forkInstanceID");
*pui32IgnoreSwizzle = 1;
return;
}
case OPERAND_TYPE_IMMEDIATE_CONSTANT_BUFFER:
{
bcatcstr(glsl, "immediateConstBufferF");
if(psOperand->psSubOperand[0])
{
bcatcstr(glsl, "(int("); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[0], TO_FLAG_NONE);
bcatcstr(glsl, "))");
}
break;
}
case OPERAND_TYPE_INPUT_DOMAIN_POINT:
{
bcatcstr(glsl, "gl_TessCoord");
break;
}
case OPERAND_TYPE_INPUT_CONTROL_POINT:
{
if(psOperand->aui32ArraySizes[1] == 0)//Input index zero - position.
{
bformata(glsl, "gl_in[%d].gl_Position", psOperand->aui32ArraySizes[0]);
}
else
{
bformata(glsl, "Input%d[%d]", psOperand->aui32ArraySizes[1], psOperand->aui32ArraySizes[0]);
}
break;
}
case OPERAND_TYPE_NULL:
{
// Null register, used to discard results of operations
bcatcstr(glsl, "//null");
break;
}
case OPERAND_TYPE_OUTPUT_CONTROL_POINT_ID:
{
bcatcstr(glsl, "gl_InvocationID");
*pui32IgnoreSwizzle = 1;
break;
}
case OPERAND_TYPE_OUTPUT_COVERAGE_MASK:
{
bcatcstr(glsl, "gl_SampleMask[0]");
*pui32IgnoreSwizzle = 1;
break;
}
case OPERAND_TYPE_INPUT_COVERAGE_MASK:
{
bcatcstr(glsl, "gl_SampleMaskIn[0]");
//Skip swizzle on scalar types.
*pui32IgnoreSwizzle = 1;
break;
}
case OPERAND_TYPE_INPUT_THREAD_ID://SV_DispatchThreadID
{
bcatcstr(glsl, "gl_GlobalInvocationID");
break;
}
case OPERAND_TYPE_INPUT_THREAD_GROUP_ID://SV_GroupThreadID
{
bcatcstr(glsl, "gl_LocalInvocationID");
break;
}
case OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP://SV_GroupID
{
bcatcstr(glsl, "gl_WorkGroupID");
break;
}
case OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED://SV_GroupIndex
{
bcatcstr(glsl, "gl_LocalInvocationIndex");
break;
}
case OPERAND_TYPE_UNORDERED_ACCESS_VIEW:
{
bformata(glsl, "UAV%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY:
{
bformata(glsl, "TGSM%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_INPUT_PRIMITIVEID:
{
bcatcstr(glsl, "gl_PrimitiveID");
break;
}
case OPERAND_TYPE_INDEXABLE_TEMP:
{
bformata(glsl, "TempArray%d", psOperand->aui32ArraySizes[0]);
bformata(glsl, "[%d", psOperand->aui32ArraySizes[1]);
if(psOperand->psSubOperand[1])
{
bcatcstr(glsl, "+");
TranslateOperand(psContext, psOperand->psSubOperand[1], TO_FLAG_NONE);
}
bcatcstr(glsl, "]");
break;
}
case OPERAND_TYPE_STREAM:
{
bformata(glsl, "%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_INPUT_GS_INSTANCE_ID:
{
bcatcstr(glsl, "gl_InvocationID");
break;
}
case OPERAND_TYPE_THIS_POINTER:
{
/*
The "this" register is a register that provides up to 4 pieces of information:
X: Which CB holds the instance data
Y: Base element offset of the instance data within the instance CB
Z: Base sampler index
W: Base Texture index
Can be different for each function call
*/
break;
}
default:
{
ASSERT(0);
break;
}
}
if(integerConstructor)
{
bcatcstr(glsl, ")");
}
}
SHADER_VARIABLE_TYPE GetOperandDataType(HLSLCrossCompilerContext* psContext, const Operand* psOperand)
{
if(psOperand->eType == OPERAND_TYPE_TEMP)
{
SHADER_VARIABLE_TYPE eCurrentType;
int i = 0;
if(psOperand->eSelMode == OPERAND_4_COMPONENT_SELECT_1_MODE)
{
return psOperand->aeDataType[psOperand->aui32Swizzle[0]];
}
if(psOperand->eSelMode == OPERAND_4_COMPONENT_SWIZZLE_MODE)
{
if(psOperand->ui32Swizzle == (NO_SWIZZLE))
{
return psOperand->aeDataType[0];
}
return psOperand->aeDataType[psOperand->aui32Swizzle[0]];
}
if(psOperand->eSelMode == OPERAND_4_COMPONENT_MASK_MODE)
{
uint32_t ui32CompMask = psOperand->ui32CompMask;
if(!psOperand->ui32CompMask)
{
ui32CompMask = OPERAND_4_COMPONENT_MASK_ALL;
}
for(;i<4;++i)
{
if(ui32CompMask & (1<<i))
{
eCurrentType = psOperand->aeDataType[i];
break;
}
}
#ifdef _DEBUG
//Check if all elements have the same basic type.
for(;i<4;++i)
{
if(psOperand->ui32CompMask & (1<<i))
{
if(eCurrentType != psOperand->aeDataType[i])
{
ASSERT(0);
}
}
}
#endif
return eCurrentType;
}
ASSERT(0);
}
else if(psOperand->eType == OPERAND_TYPE_OUTPUT)
{
const uint32_t ui32Register = psOperand->aui32ArraySizes[psOperand->iIndexDims-1];
InOutSignature* psOut;
if(GetOutputSignatureFromRegister(ui32Register, psOperand->ui32CompMask, &psContext->psShader->sInfo, &psOut))
{
if( psOut->eComponentType == INOUT_COMPONENT_UINT32)
{
return SVT_UINT;
}
else if( psOut->eComponentType == INOUT_COMPONENT_SINT32)
{
return SVT_INT;
}
}
}
else if(psOperand->eType == OPERAND_TYPE_INPUT)
{
const uint32_t ui32Register = psOperand->aui32ArraySizes[psOperand->iIndexDims-1];
InOutSignature* psIn;
if(GetInputSignatureFromRegister(ui32Register, &psContext->psShader->sInfo, &psIn))
{
if( psIn->eComponentType == INOUT_COMPONENT_UINT32)
{
return SVT_UINT;
}
else if( psIn->eComponentType == INOUT_COMPONENT_SINT32)
{
return SVT_INT;
}
}
}
else if(psOperand->eType == OPERAND_TYPE_CONSTANT_BUFFER)
{
ConstantBuffer* psCBuf = NULL;
ShaderVar* psVar = NULL;
int32_t index = -1;
int foundVar;
GetConstantBufferFromBindingPoint(psOperand->aui32ArraySizes[0], &psContext->psShader->sInfo, &psCBuf);
foundVar = GetShaderVarFromOffset(psOperand->aui32ArraySizes[1], psOperand->aui32Swizzle, psCBuf, &psVar, &index);
if(foundVar && index == -1 && psOperand->psSubOperand[1] == NULL)
{
return psVar->sType.Type;
}
}
else if(psOperand->eType == OPERAND_TYPE_IMMEDIATE32)
{
return psOperand->iIntegerImmediate ? SVT_INT : SVT_FLOAT;
}
return SVT_FLOAT;
}