bstring DataRGetPeersStr(Message *message)
{
if (message->data.rgetpeers.nodes != NULL)
{
return DataRFindNodeStr(message);
}
bstring ftoken = Dht_FTokenStr(message->data.rgetpeers.token);
bstring str = bformat("Token: %s", ftoken->data);
bdestroy(ftoken);
size_t i = 0;
if (message->data.rgetpeers.values == NULL)
{
bformata(str, "\n(NULL rgetpeers.values)");
return str;
}
for (i = 0; i < message->data.rgetpeers.count; i++)
{
bstring peer = Dht_PeerStr(message->data.rgetpeers.values + i);
bformata(str, "\nPeer %03zd: %s", i, peer->data);
bdestroy(peer);
}
return str;
}
void TextureName(HLSLCrossCompilerContext* psContext, const uint32_t ui32RegisterNumber, const int bZCompare)
{
bstring glsl = *psContext->currentGLSLString;
ResourceBinding* psBinding = 0;
int found;
found = GetResourceFromBindingPoint(RGROUP_TEXTURE, ui32RegisterNumber, &psContext->psShader->sInfo, &psBinding);
if(bZCompare)
{
bcatcstr(glsl, "hlslcc_zcmp_");
}
if(found)
{
int i = 0;
char name[MAX_REFLECT_STRING_LENGTH];
uint32_t ui32ArrayOffset = ui32RegisterNumber - psBinding->ui32BindPoint;
while(psBinding->Name[i] != '\0' && i < (MAX_REFLECT_STRING_LENGTH-1))
{
name[i] = psBinding->Name[i];
//array syntax [X] becomes _0_
//Otherwise declarations could end up as:
//uniform sampler2D SomeTextures[0];
//uniform sampler2D SomeTextures[1];
if(name[i] == '[' || name[i] == ']')
name[i] = '_';
++i;
}
name[i] = '\0';
if(ui32ArrayOffset)
{
bformata(glsl, "%s%d", name, ui32ArrayOffset);
}
else
{
bformata(glsl, "%s", name);
}
}
else
{
bformata(glsl, "UnknownResource%d", ui32RegisterNumber);
}
}
bstring DataRFindNodeStr(Message *message)
{
if (message->data.rfindnode.nodes == NULL)
return bfromcstr("(NULL rfindnode.nodes)");
if (message->data.rfindnode.count == 0)
return bfromcstr("(Zero nodes)");
size_t i = 0;
Node **nodes = message->data.rfindnode.nodes;
bstring str = bfromcstr("");
for (i = 0; i < message->data.rfindnode.count; i++)
{
bstring node = Dht_NodeStr(nodes[i]);
bformata(str, "%sNode %02zd: %s",
i > 0 ? "\n" : "",
i,
node->data);
bdestroy(node);
}
return str;
}
void
alder_wordtable_bigbitarray_print(alder_wordtable_bigbitarray_t *o)
{
bool isExit = false;
bstring bs = bfromcstralloc((int)o->maxsize * 10, " ");
alder_dwordtable_t x1 = 1;
for (size_t i = 0; i < o->blockarraysize; i++) {
for (size_t j = 0; j < o->subarraybits; j++) {
size_t pos = j + i * o->subarraybits;
if (j + i * o->subarraybits == o->maxsize) {
isExit = true;
break;
}
size_t k = j / o->blocksize;
size_t kbit = j % o->blocksize;
alder_dwordtable_t x = o->blockarray[i][k];
bformata(bs, "[%zu] ", pos);
if (x & (x1 << kbit)) {
bconchar(bs, '1');
} else {
bconchar(bs, '0');
}
bconchar(bs, ' ');
}
if (isExit == true) {
break;
}
}
alder_log5("bit: %s", bdata(bs));
bdestroy(bs);
}
void Connection_fingerprint_from_cert(Connection *conn)
{
x509_cert* _x509P = conn->iob->ssl.peer_cert;
int i = 0;
debug("Connection_send_to_handler: peer_cert: %016lX: tag=%d length=%ld",
(unsigned long) _x509P,
_x509P ? _x509P->raw.tag : -1,
_x509P ? _x509P->raw.len : -1);
if (_x509P != NULL && _x509P->raw.len > 0) {
sha1_context ctx;
unsigned char sha1sum[CERT_FINGERPRINT_SIZE + 1] = {0};
sha1_starts(&ctx);
sha1_update(&ctx, _x509P->raw.p, _x509P->raw.len);
sha1_finish(&ctx, sha1sum);
bstring hex = bfromcstr("");
for (i = 0; i < (int)sizeof(sha1sum); i++) {
bformata(hex, "%02X", sha1sum[i]);
}
Request_set(conn->req, &PEER_CERT_SHA1_KEY, hex, 1);
}
}
void Node_catbstr(bstring str, Node *d, char sep, int follow_sibs)
{
int rc = 0;
assert_not(str, NULL);
if(d == NULL) return;
if(d->sibling != NULL && follow_sibs) {
Node_catbstr(str, d->sibling, sep, follow_sibs);
}
if(d->type == TYPE_GROUP) {
rc = bformata(str, "[%c", sep);
assert(rc == BSTR_OK);
}
if(d->child != NULL) {
// we always follow siblings on the children
Node_catbstr(str, d->child, sep, 1);
}
switch(d->type) {
case TYPE_BLOB:
bformata(str, "'%zu:" , blength(d->value.string));
bconcat(str, d->value.string);
bformata(str, "\'%c", sep);
break;
case TYPE_STRING:
bformata(str, "\"%s\"%c" , bdata(d->value.string), sep);
break;
case TYPE_NUMBER:
bformata(str, "%llu%c", d->value.number, sep);
break;
case TYPE_FLOAT:
bformata(str, "%f%c", d->value.floating, sep);
break;
case TYPE_GROUP:
if(!d->name || bchar(d->name, 0) == '@') {
rc = bformata(str, "]%c", sep);
assert(rc == BSTR_OK);
}
break;
case TYPE_INVALID: // fallthrough
default:
assert(!"invalid type for node");
break;
}
if(d->name != NULL) {
rc = bformata(str, "%s%c", bdata(d->name), sep);
assert(rc == BSTR_OK);
}
}
bstring to_json(hgt_pop ** ps, hgt_params * params) {
unsigned i;
char *c;
bstring b;
b = bfromcstr("");
for (i = 0; i < params->replicates; i ++) {
hgt_pop * pop = ps[i];
c = hgt_pop_to_json(pop, params);
bformata(b, "%s", c);
free(c);
if (i < params->replicates-1)
{
bformata(b, "\n");
}
}
return b;
}
void TranslateOperandIndexMAD(HLSLCrossCompilerContext* psContext, const Operand* psOperand, int index, uint32_t multiply, uint32_t add)
{
int i = index;
int isGeoShader = psContext->psShader->eShaderType == GEOMETRY_SHADER ? 1 : 0;
bstring glsl = *psContext->currentGLSLString;
ASSERT(index < psOperand->iIndexDims);
switch(psOperand->eIndexRep[i])
{
case OPERAND_INDEX_IMMEDIATE32:
{
if(i > 0 || isGeoShader)
{
bformata(glsl, "[%d*%d+%d]", psOperand->aui32ArraySizes[i], multiply, add);
}
else
{
bformata(glsl, "%d*%d+%d", psOperand->aui32ArraySizes[i], multiply, add);
}
break;
}
case OPERAND_INDEX_RELATIVE:
{
bcatcstr(glsl, "[int("); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[i], TO_FLAG_NONE);
bformata(glsl, ")*%d+%d]", multiply, add);
break;
}
case OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE:
{
bcatcstr(glsl, "[(int("); //Indexes must be integral.
TranslateOperand(psContext, psOperand->psSubOperand[i], TO_FLAG_NONE);
bformata(glsl, ") + %d)*%d+%d]", psOperand->aui32ArraySizes[i], multiply, add);
break;
}
default:
{
break;
}
}
}
int
scm_out_vprintf(output_t *output, const char *format, va_list args)
{
int rslt;
if (output->stream)
rslt = vfprintf(output->stream, format, args);
else
rslt = bformata(output->str_buf, format, args);
return rslt;
}
void Handler_notify_credits(Handler *handler, int id, int credits)
{
void *socket = handler->send_socket;
assert(socket && "Socket can't be NULL");
tns_outbuf outbuf = {.buffer = NULL};
bstring payload = NULL;
if(handler->protocol == HANDLER_PROTO_TNET) {
int header_start = tns_render_request_start(&outbuf);
bstring creditsstr = bformat("%d", credits);
tns_render_hash_pair(&outbuf, &HTTP_METHOD, &JSON_METHOD);
tns_render_hash_pair(&outbuf, &DOWNLOAD_CREDITS, creditsstr);
bdestroy(creditsstr);
tns_outbuf_clamp(&outbuf, header_start);
payload = bformat("%s %d @* %s%d:%s,",
bdata(handler->send_ident), id,
bdata(tns_outbuf_to_bstring(&outbuf)),
blength(&CREDITS_MSG), bdata(&CREDITS_MSG));
} else {
bstring headers = bfromcstralloc(PAYLOAD_GUESS, "{");
bcatcstr(headers, "\"METHOD\":\"JSON\",\"");
bconcat(headers, &DOWNLOAD_CREDITS);
bcatcstr(headers, "\":\"");
bformata(headers, "%d", credits);
bcatcstr(headers, "\"}");
payload = bformat("%s %d @* %d:%s,%d:%s,",
bdata(handler->send_ident), id,
blength(headers), bdata(headers),
blength(&CREDITS_MSG), bdata(&CREDITS_MSG));
bdestroy(headers);
}
check(payload != NULL, "Failed to make the payload for credits.");
if(Handler_deliver(socket, bdata(payload), blength(payload)) == -1) {
log_err("Can't tell handler %d giving credits.", id);
}
error: //fallthrough
if(payload) free(payload);
if(outbuf.buffer) free(outbuf.buffer);
}
bstring HexStr(char *data, size_t len)
{
assert(data != NULL && "NULL data pointer");
bstring str = bfromcstralloc(len * 2, "");
check_mem(str);
char *end = data + len;
while (data < end)
{
int rc = bformata(str, "%02hhX", *data++);
check(rc == BSTR_OK, "bformata failed");
}
return str;
error:
bdestroy(str);
return NULL;
}
void AddVersionDependentCode(HLSLCrossCompilerContext* psContext)
{
bstring glsl = *psContext->currentGLSLString;
if(psContext->psShader->ui32MajorVersion <= 3)
{
bcatcstr(glsl, "int RepCounter;\n");
if(psContext->psShader->eShaderType == VERTEX_SHADER)
{
uint32_t texCoord;
bcatcstr(glsl, "ivec4 Address;\n");
if(InOutSupported(psContext->psShader->eTargetLanguage))
{
bcatcstr(glsl, "out vec4 OffsetColour;\n");
bcatcstr(glsl, "out vec4 BaseColour;\n");
bcatcstr(glsl, "out vec4 Fog;\n");
for(texCoord=0; texCoord<8; ++texCoord)
{
bformata(glsl, "out vec4 TexCoord%d;\n", texCoord);
}
}
else
{
bcatcstr(glsl, "varying vec4 OffsetColour;\n");
bcatcstr(glsl, "varying vec4 BaseColour;\n");
bcatcstr(glsl, "varying vec4 Fog;\n");
for(texCoord=0; texCoord<8; ++texCoord)
{
bformata(glsl, "varying vec4 TexCoord%d;\n", texCoord);
}
}
}
else
{
uint32_t renderTargets, texCoord;
bcatcstr(glsl, "varying vec4 OffsetColour;\n");
bcatcstr(glsl, "varying vec4 BaseColour;\n");
bcatcstr(glsl, "varying vec4 Fog;\n");
for(texCoord=0; texCoord<8; ++texCoord)
{
bformata(glsl, "varying vec4 TexCoord%d;\n", texCoord);
}
for(renderTargets=0; renderTargets<8; ++renderTargets)
{
bformata(glsl, "#define Output%d gl_FragData[%d]\n", renderTargets, renderTargets);
}
}
}
if(!HaveCompute(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->eShaderType == COMPUTE_SHADER)
{
bcatcstr(glsl,"#extension GL_ARB_compute_shader : enable\n");
bcatcstr(glsl,"#extension GL_ARB_shader_storage_buffer_object : enable\n");
}
}
if (!HaveAtomicMem(psContext->psShader->eTargetLanguage) ||
!HaveAtomicCounter(psContext->psShader->eTargetLanguage))
{
if( psContext->psShader->aiOpcodeUsed[OPCODE_IMM_ATOMIC_ALLOC] ||
psContext->psShader->aiOpcodeUsed[OPCODE_IMM_ATOMIC_CONSUME] ||
psContext->psShader->aiOpcodeUsed[OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED])
{
bcatcstr(glsl,"#extension GL_ARB_shader_atomic_counters : enable\n");
bcatcstr(glsl,"#extension GL_ARB_shader_storage_buffer_object : enable\n");
}
}
if(!HaveGather(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4] ||
psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4_PO_C] ||
psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4_PO] ||
psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4_C])
{
bcatcstr(glsl,"#extension GL_ARB_texture_gather : enable\n");
}
}
if(!HaveGatherNonConstOffset(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4_PO_C] ||
psContext->psShader->aiOpcodeUsed[OPCODE_GATHER4_PO])
{
bcatcstr(glsl,"#extension GL_ARB_gpu_shader5 : enable\n");
}
}
if(!HaveQueryLod(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->aiOpcodeUsed[OPCODE_LOD])
{
bcatcstr(glsl,"#extension GL_ARB_texture_query_lod : enable\n");
}
}
if(!HaveQueryLevels(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->aiOpcodeUsed[OPCODE_RESINFO])
{
bcatcstr(glsl,"#extension GL_ARB_texture_query_levels : enable\n");
}
}
if(!HaveImageLoadStore(psContext->psShader->eTargetLanguage))
{
if(psContext->psShader->aiOpcodeUsed[OPCODE_STORE_UAV_TYPED] ||
psContext->psShader->aiOpcodeUsed[OPCODE_STORE_RAW] ||
psContext->psShader->aiOpcodeUsed[OPCODE_STORE_STRUCTURED])
{
bcatcstr(glsl,"#extension GL_ARB_shader_image_load_store : enable\n");
bcatcstr(glsl,"#extension GL_ARB_shader_bit_encoding : enable\n");
}
else
if(psContext->psShader->aiOpcodeUsed[OPCODE_LD_UAV_TYPED] ||
psContext->psShader->aiOpcodeUsed[OPCODE_LD_RAW] ||
psContext->psShader->aiOpcodeUsed[OPCODE_LD_STRUCTURED])
{
bcatcstr(glsl,"#extension GL_ARB_shader_image_load_store : enable\n");
}
}
if((psContext->flags & HLSLCC_FLAG_ORIGIN_UPPER_LEFT)
&& (psContext->psShader->eTargetLanguage >= LANG_150))
{
bcatcstr(glsl,"layout(origin_upper_left) in vec4 gl_FragCoord;\n");
}
if((psContext->flags & HLSLCC_FLAG_PIXEL_CENTER_INTEGER)
&& (psContext->psShader->eTargetLanguage >= LANG_150))
{
bcatcstr(glsl,"layout(pixel_center_integer) in vec4 gl_FragCoord;\n");
}
/* For versions which do not support a vec1 (currently all versions) */
bcatcstr(glsl,"struct vec1 {\n");
bcatcstr(glsl,"\tfloat x;\n");
bcatcstr(glsl,"};\n");
if(HaveUVec(psContext->psShader->eTargetLanguage))
{
bcatcstr(glsl,"struct uvec1 {\n");
bcatcstr(glsl,"\tuint x;\n");
bcatcstr(glsl,"};\n");
}
bcatcstr(glsl,"struct ivec1 {\n");
bcatcstr(glsl,"\tint x;\n");
bcatcstr(glsl,"};\n");
/*
OpenGL 4.1 API spec:
To use any built-in input or output in the gl_PerVertex block in separable
program objects, shader code must redeclare that block prior to use.
*/
if(psContext->psShader->eShaderType == VERTEX_SHADER && psContext->psShader->eTargetLanguage >= LANG_410)
{
bcatcstr(glsl, "out gl_PerVertex {\n");
bcatcstr(glsl, "vec4 gl_Position;\n");
bcatcstr(glsl, "float gl_PointSize;\n");
bcatcstr(glsl, "float gl_ClipDistance[];");
bcatcstr(glsl, "};\n");
}
//The fragment language has no default precision qualifier for floating point types.
if(psContext->psShader->eShaderType == PIXEL_SHADER &&
psContext->psShader->eTargetLanguage == LANG_ES_100 || psContext->psShader->eTargetLanguage == LANG_ES_300 )
{
bcatcstr(glsl,"precision highp float;\n");
}
/* There is no default precision qualifier for the following sampler types in either the vertex or fragment language: */
if(psContext->psShader->eTargetLanguage == LANG_ES_300 )
{
bcatcstr(glsl,"precision lowp sampler3D;\n");
bcatcstr(glsl,"precision lowp samplerCubeShadow;\n");
bcatcstr(glsl,"precision lowp sampler2DShadow;\n");
bcatcstr(glsl,"precision lowp sampler2DArray;\n");
bcatcstr(glsl,"precision lowp sampler2DArrayShadow;\n");
bcatcstr(glsl,"precision lowp isampler2D;\n");
bcatcstr(glsl,"precision lowp isampler3D;\n");
bcatcstr(glsl,"precision lowp isamplerCube;\n");
bcatcstr(glsl,"precision lowp isampler2DArray;\n");
bcatcstr(glsl,"precision lowp usampler2D;\n");
bcatcstr(glsl,"precision lowp usampler3D;\n");
bcatcstr(glsl,"precision lowp usamplerCube;\n");
bcatcstr(glsl,"precision lowp usampler2DArray;\n");
}
if(SubroutinesSupported(psContext->psShader->eTargetLanguage))
{
bcatcstr(glsl, "subroutine void SubroutineType();\n");
}
}
void TranslateToGLSL(HLSLCrossCompilerContext* psContext, GLLang* planguage,const GlExtensions *extensions)
{
bstring glsl;
uint32_t i;
Shader* psShader = psContext->psShader;
GLLang language = *planguage;
const uint32_t ui32InstCount = psShader->ui32InstCount;
const uint32_t ui32DeclCount = psShader->ui32DeclCount;
psContext->indent = 0;
if(language == LANG_DEFAULT)
{
language = ChooseLanguage(psShader);
*planguage = language;
}
glsl = bfromcstralloc (1024, GetVersionString(language));
psContext->glsl = glsl;
psContext->earlyMain = bfromcstralloc (1024, "");
for(i=0; i<NUM_PHASES;++i)
{
psContext->postShaderCode[i] = bfromcstralloc (1024, "");
}
psContext->currentGLSLString = &glsl;
psShader->eTargetLanguage = language;
psShader->extensions = (const struct GlExtensions*)extensions;
psContext->currentPhase = MAIN_PHASE;
if(extensions)
{
if(extensions->ARB_explicit_attrib_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_attrib_location : require\n");
if(extensions->ARB_explicit_uniform_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_uniform_location : require\n");
if(extensions->ARB_shading_language_420pack)
bcatcstr(glsl,"#extension GL_ARB_shading_language_420pack : require\n");
}
ClearDependencyData(psShader->eShaderType, psContext->psDependencies);
AddVersionDependentCode(psContext);
if(psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
bcatcstr(glsl, "layout(std140) uniform;\n");
}
//Special case. Can have multiple phases.
if(psShader->eShaderType == HULL_SHADER)
{
int haveInstancedForkPhase = 0;
uint32_t forkIndex = 0;
ConsolidateHullTempVars(psShader);
for(i=0; i < psShader->ui32HSDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSDecl+i);
}
//control
psContext->currentPhase = HS_CTRL_POINT_PHASE;
if(psShader->ui32HSControlPointDeclCount)
{
bcatcstr(glsl, "//Control point phase declarations\n");
for(i=0; i < psShader->ui32HSControlPointDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSControlPointPhaseDecl+i);
}
}
if(psShader->ui32HSControlPointInstrCount)
{
SetDataTypes(psContext, psShader->psHSControlPointPhaseInstr, psShader->ui32HSControlPointInstrCount);
bcatcstr(glsl, "void control_point_phase()\n{\n");
psContext->indent++;
for(i=0; i < psShader->ui32HSControlPointInstrCount; ++i)
{
TranslateInstruction(psContext, psShader->psHSControlPointPhaseInstr+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
//fork
psContext->currentPhase = HS_FORK_PHASE;
for(forkIndex = 0; forkIndex < psShader->ui32ForkPhaseCount; ++forkIndex)
{
bcatcstr(glsl, "//Fork phase declarations\n");
for(i=0; i < psShader->aui32HSForkDeclCount[forkIndex]; ++i)
{
TranslateDeclaration(psContext, psShader->apsHSForkPhaseDecl[forkIndex]+i);
if(psShader->apsHSForkPhaseDecl[forkIndex][i].eOpcode == OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT)
{
haveInstancedForkPhase = 1;
}
}
bformata(glsl, "void fork_phase%d()\n{\n", forkIndex);
psContext->indent++;
SetDataTypes(psContext, psShader->apsHSForkPhaseInstr[forkIndex], psShader->aui32HSForkInstrCount[forkIndex]-1);
if(haveInstancedForkPhase)
{
AddIndentation(psContext);
bformata(glsl, "for(int forkInstanceID = 0; forkInstanceID < HullPhase%dInstanceCount; ++forkInstanceID) {\n", forkIndex);
psContext->indent++;
}
//The minus one here is remove the return statement at end of phases.
//This is needed otherwise the for loop will only run once.
ASSERT(psShader->apsHSForkPhaseInstr[forkIndex][psShader->aui32HSForkInstrCount[forkIndex]-1].eOpcode == OPCODE_RET);
for(i=0; i < psShader->aui32HSForkInstrCount[forkIndex]-1; ++i)
{
TranslateInstruction(psContext, psShader->apsHSForkPhaseInstr[forkIndex]+i);
}
if(haveInstancedForkPhase)
{
psContext->indent--;
AddIndentation(psContext);
bcatcstr(glsl, "}\n");
if(psContext->havePostShaderCode[psContext->currentPhase])
{
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Post shader code ---\n");
#endif
bconcat(glsl, psContext->postShaderCode[psContext->currentPhase]);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End post shader code ---\n");
#endif
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
//join
psContext->currentPhase = HS_JOIN_PHASE;
if(psShader->ui32HSJoinDeclCount)
{
bcatcstr(glsl, "//Join phase declarations\n");
for(i=0; i < psShader->ui32HSJoinDeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psHSJoinPhaseDecl+i);
}
}
if(psShader->ui32HSJoinInstrCount)
{
SetDataTypes(psContext, psShader->psHSJoinPhaseInstr, psShader->ui32HSJoinInstrCount);
bcatcstr(glsl, "void join_phase()\n{\n");
psContext->indent++;
for(i=0; i < psShader->ui32HSJoinInstrCount; ++i)
{
TranslateInstruction(psContext, psShader->psHSJoinPhaseInstr+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
if(psShader->ui32HSControlPointInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "control_point_phase();\n");
if(psShader->ui32ForkPhaseCount || psShader->ui32HSJoinInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
for(forkIndex = 0; forkIndex < psShader->ui32ForkPhaseCount; ++forkIndex)
{
AddIndentation(psContext);
bformata(glsl, "fork_phase%d();\n", forkIndex);
if(psShader->ui32HSJoinInstrCount || (forkIndex+1 < psShader->ui32ForkPhaseCount))
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
if(psShader->ui32HSJoinInstrCount)
{
AddIndentation(psContext);
bcatcstr(glsl, "join_phase();\n");
}
psContext->indent--;
bcatcstr(glsl, "}\n");
if(psContext->psDependencies)
{
//Save partitioning and primitive type for use by domain shader.
psContext->psDependencies->eTessOutPrim = psShader->sInfo.eTessOutPrim;
psContext->psDependencies->eTessPartitioning = psShader->sInfo.eTessPartitioning;
}
return;
}
if(psShader->eShaderType == DOMAIN_SHADER && psContext->psDependencies)
{
//Load partitioning and primitive type from hull shader.
switch(psContext->psDependencies->eTessOutPrim)
{
case TESSELLATOR_OUTPUT_TRIANGLE_CW:
{
bcatcstr(glsl, "layout(cw) in;\n");
break;
}
case TESSELLATOR_OUTPUT_POINT:
{
bcatcstr(glsl, "layout(point_mode) in;\n");
break;
}
default:
{
break;
}
}
switch(psContext->psDependencies->eTessPartitioning)
{
case TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
{
bcatcstr(glsl, "layout(fractional_odd_spacing) in;\n");
break;
}
case TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
{
bcatcstr(glsl, "layout(fractional_even_spacing) in;\n");
break;
}
default:
{
break;
}
}
}
for(i=0; i < ui32DeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->psDecl+i);
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
MarkIntegerImmediates(psContext);
SetDataTypes(psContext, psShader->psInst, ui32InstCount);
for(i=0; i < ui32InstCount; ++i)
{
TranslateInstruction(psContext, psShader->psInst+i);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
void TranslateToGLSL(HLSLCrossCompilerContext* psContext, GLLang* planguage,const GlExtensions *extensions)
{
bstring glsl;
uint32_t i;
Shader* psShader = psContext->psShader;
GLLang language = *planguage;
uint32_t ui32InstCount = 0;
uint32_t ui32DeclCount = 0;
psContext->indent = 0;
/*psShader->sPhase[MAIN_PHASE].ui32InstanceCount = 1;
psShader->sPhase[MAIN_PHASE].ppsDecl = hlslcc_malloc(sizeof(Declaration*));
psShader->sPhase[MAIN_PHASE].ppsInst = hlslcc_malloc(sizeof(Instruction*));
psShader->sPhase[MAIN_PHASE].pui32DeclCount = hlslcc_malloc(sizeof(uint32_t));
psShader->sPhase[MAIN_PHASE].pui32InstCount = hlslcc_malloc(sizeof(uint32_t));*/
if(language == LANG_DEFAULT)
{
language = ChooseLanguage(psShader);
*planguage = language;
}
glsl = bfromcstralloc (1024, GetVersionString(language));
psContext->glsl = glsl;
psContext->earlyMain = bfromcstralloc (1024, "");
for(i=0; i<NUM_PHASES;++i)
{
psContext->postShaderCode[i] = bfromcstralloc (1024, "");
}
psContext->currentGLSLString = &glsl;
psShader->eTargetLanguage = language;
psShader->extensions = (const struct GlExtensions*)extensions;
psContext->currentPhase = MAIN_PHASE;
if(extensions)
{
if(extensions->ARB_explicit_attrib_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_attrib_location : require\n");
if(extensions->ARB_explicit_uniform_location)
bcatcstr(glsl,"#extension GL_ARB_explicit_uniform_location : require\n");
if(extensions->ARB_shading_language_420pack)
bcatcstr(glsl,"#extension GL_ARB_shading_language_420pack : require\n");
}
ClearDependencyData(psShader->eShaderType, psContext->psDependencies);
AddVersionDependentCode(psContext);
if(psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
bcatcstr(glsl, "layout(std140) uniform;\n");
}
//Special case. Can have multiple phases.
if(psShader->eShaderType == HULL_SHADER)
{
int haveInstancedForkPhase = 0; // Do we have an instanced fork phase?
int isCurrentForkPhasedInstanced = 0; // Is the current fork phase instanced?
const char* asPhaseFuncNames[NUM_PHASES];
uint32_t ui32PhaseFuncCallOrder[3];
uint32_t ui32PhaseCallIndex;
uint32_t ui32Phase;
uint32_t ui32Instance;
asPhaseFuncNames[MAIN_PHASE] = "";
asPhaseFuncNames[HS_GLOBAL_DECL] = "";
asPhaseFuncNames[HS_FORK_PHASE] = "fork_phase";
asPhaseFuncNames[HS_CTRL_POINT_PHASE] = "control_point_phase";
asPhaseFuncNames[HS_JOIN_PHASE] = "join_phase";
ConsolidateHullTempVars(psShader);
for(i=0; i < psShader->asPhase[HS_GLOBAL_DECL].pui32DeclCount[0]; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[HS_GLOBAL_DECL].ppsDecl[0]+i);
}
for(ui32Phase=HS_CTRL_POINT_PHASE; ui32Phase<NUM_PHASES; ui32Phase++)
{
psContext->currentPhase = ui32Phase;
for(ui32Instance = 0; ui32Instance < psShader->asPhase[ui32Phase].ui32InstanceCount; ++ui32Instance)
{
isCurrentForkPhasedInstanced = 0; //reset for each fork phase for cases we don't have a fork phase instance count opcode.
bformata(glsl, "//%s declarations\n", asPhaseFuncNames[ui32Phase]);
for(i=0; i < psShader->asPhase[ui32Phase].pui32DeclCount[ui32Instance]; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[ui32Phase].ppsDecl[ui32Instance]+i);
if(psShader->asPhase[ui32Phase].ppsDecl[ui32Instance][i].eOpcode == OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT)
{
haveInstancedForkPhase = 1;
isCurrentForkPhasedInstanced = 1;
}
}
bformata(glsl, "void %s%d()\n{\n", asPhaseFuncNames[ui32Phase], ui32Instance);
psContext->indent++;
SetDataTypes(psContext, psShader->asPhase[ui32Phase].ppsInst[ui32Instance], psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1);
if(isCurrentForkPhasedInstanced)
{
AddIndentation(psContext);
bformata(glsl, "for(int forkInstanceID = 0; forkInstanceID < HullPhase%dInstanceCount; ++forkInstanceID) {\n", ui32Instance);
psContext->indent++;
}
//The minus one here is remove the return statement at end of phases.
//This is needed otherwise the for loop will only run once.
ASSERT(psShader->asPhase[ui32Phase].ppsInst[ui32Instance] [psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1].eOpcode == OPCODE_RET);
for(i=0; i < psShader->asPhase[ui32Phase].pui32InstCount[ui32Instance]-1; ++i)
{
TranslateInstruction(psContext, psShader->asPhase[ui32Phase].ppsInst[ui32Instance]+i, NULL);
}
if(haveInstancedForkPhase)
{
psContext->indent--;
AddIndentation(psContext);
if(isCurrentForkPhasedInstanced)
{
bcatcstr(glsl, "}\n");
}
if(psContext->havePostShaderCode[psContext->currentPhase])
{
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Post shader code ---\n");
#endif
bconcat(glsl, psContext->postShaderCode[psContext->currentPhase]);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End post shader code ---\n");
#endif
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
ui32PhaseFuncCallOrder[0] = HS_CTRL_POINT_PHASE;
ui32PhaseFuncCallOrder[1] = HS_FORK_PHASE;
ui32PhaseFuncCallOrder[2] = HS_JOIN_PHASE;
for(ui32PhaseCallIndex=0; ui32PhaseCallIndex<3; ui32PhaseCallIndex++)
{
ui32Phase = ui32PhaseFuncCallOrder[ui32PhaseCallIndex];
for(ui32Instance = 0; ui32Instance < psShader->asPhase[ui32Phase].ui32InstanceCount; ++ui32Instance)
{
AddIndentation(psContext);
bformata(glsl, "%s%d();\n", asPhaseFuncNames[ui32Phase], ui32Instance);
if(ui32Phase == HS_FORK_PHASE)
{
if(psShader->asPhase[HS_JOIN_PHASE].ui32InstanceCount ||
(ui32Instance+1 < psShader->asPhase[HS_FORK_PHASE].ui32InstanceCount))
{
AddIndentation(psContext);
bcatcstr(glsl, "barrier();\n");
}
}
}
}
psContext->indent--;
bcatcstr(glsl, "}\n");
if(psContext->psDependencies)
{
//Save partitioning and primitive type for use by domain shader.
psContext->psDependencies->eTessOutPrim = psShader->sInfo.eTessOutPrim;
psContext->psDependencies->eTessPartitioning = psShader->sInfo.eTessPartitioning;
}
return;
}
if(psShader->eShaderType == DOMAIN_SHADER && psContext->psDependencies)
{
//Load partitioning and primitive type from hull shader.
switch(psContext->psDependencies->eTessOutPrim)
{
case TESSELLATOR_OUTPUT_TRIANGLE_CW:
{
bcatcstr(glsl, "layout(cw) in;\n");
break;
}
case TESSELLATOR_OUTPUT_POINT:
{
bcatcstr(glsl, "layout(point_mode) in;\n");
break;
}
default:
{
break;
}
}
switch(psContext->psDependencies->eTessPartitioning)
{
case TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
{
bcatcstr(glsl, "layout(fractional_odd_spacing) in;\n");
break;
}
case TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
{
bcatcstr(glsl, "layout(fractional_even_spacing) in;\n");
break;
}
default:
{
break;
}
}
}
ui32InstCount = psShader->asPhase[MAIN_PHASE].pui32InstCount[0];
ui32DeclCount = psShader->asPhase[MAIN_PHASE].pui32DeclCount[0];
for(i=0; i < ui32DeclCount; ++i)
{
TranslateDeclaration(psContext, psShader->asPhase[MAIN_PHASE].ppsDecl[0]+i);
}
if(psContext->psShader->ui32NumDx9ImmConst)
{
bformata(psContext->glsl, "vec4 ImmConstArray [%d];\n", psContext->psShader->ui32NumDx9ImmConst);
}
bcatcstr(glsl, "void main()\n{\n");
psContext->indent++;
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- Start Early Main ---\n");
#endif
bconcat(glsl, psContext->earlyMain);
#ifdef _DEBUG
AddIndentation(psContext);
bcatcstr(glsl, "//--- End Early Main ---\n");
#endif
MarkIntegerImmediates(psContext);
SetDataTypes(psContext, psShader->asPhase[MAIN_PHASE].ppsInst[0], ui32InstCount);
for(i=0; i < ui32InstCount; ++i)
{
TranslateInstruction(psContext, psShader->asPhase[MAIN_PHASE].ppsInst[0]+i, i+1 < ui32InstCount ? psShader->asPhase[MAIN_PHASE].ppsInst[0]+i+1 : 0);
}
psContext->indent--;
bcatcstr(glsl, "}\n");
}
void pp_lua_handle(struct pp_state* state, void* scanner, bstring name, list_t* parameters)
{
struct lua_preproc* pp;
struct customarg_entry* carg;
char* cstr;
bstring dot;
unsigned int i;
int paramtbl;
// Convert the name to lowercase.
btolower(name);
cstr = bstr2cstr(name, '0');
// Loop through all of the modules.
list_iterator_start(&modules);
while (list_iterator_hasnext(&modules))
{
pp = list_iterator_next(&modules);
// Set stack top (I don't know why the top of the
// stack is negative!)
lua_settop(pp->state, 0);
// Search handler table for entries.
lua_getglobal(pp->state, HANDLER_TABLE_NAME);
lua_getfield(pp->state, -1, cstr);
if (!lua_istable(pp->state, -1))
{
// No such entry.
lua_pop(pp->state, 2);
continue;
}
// Call the handler function.
lua_getfield(pp->state, -1, HANDLER_FIELD_FUNCTION_NAME);
pp_lua_push_state(pp, state, scanner);
lua_newtable(pp->state);
paramtbl = lua_gettop(pp->state);
for (i = 0; i < list_size(parameters); i++)
{
carg = list_get_at(parameters, i);
lua_newtable(pp->state);
if (carg->expr != NULL)
lua_pushstring(pp->state, "EXPRESSION");
else if (carg->string != NULL)
lua_pushstring(pp->state, "STRING");
else if (carg->word != NULL)
lua_pushstring(pp->state, "WORD");
else
lua_pushstring(pp->state, "NUMBER");
lua_setfield(pp->state, -2, "type");
if (carg->expr != NULL)
luaX_pushexpression(pp->state, carg->expr);
else if (carg->string != NULL)
lua_pushstring(pp->state, carg->string->data);
else if (carg->word != NULL)
lua_pushstring(pp->state, carg->word->data);
else
lua_pushnumber(pp->state, carg->number);
lua_setfield(pp->state, -2, "value");
lua_rawseti(pp->state, paramtbl, i + 1);
}
if (lua_pcall(pp->state, 2, 0, 0) != 0)
{
printd(LEVEL_ERROR, "error: unable to call preprocessor handler for '%s'.\n", name->data);
printd(LEVEL_ERROR, "%s\n", lua_tostring(pp->state, -1));
bdestroy(name);
bcstrfree(cstr);
lua_pop(pp->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
return;
}
bdestroy(name);
bcstrfree(cstr);
lua_pop(pp->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
return;
}
list_iterator_stop(&modules);
// There is no custom preprocessor module that handles this directive, however
// it could be a directive that is recognised by the underlying assembler / compiler,
// so pass it through as output.
dot = bfromcstr(".");
bconcat(dot, name);
btoupper(dot);
bconchar(dot, ' ');
list_iterator_start(parameters);
while (list_iterator_hasnext(parameters))
{
carg = list_iterator_next(parameters);
// Output the parameter based on the type.
if (carg->word != NULL)
bconcat(dot, carg->word);
else if (carg->string != NULL)
{
bconchar(dot, '"');
bescape(carg->string);
bconcat(dot, carg->string);
bconchar(dot, '"');
}
else
bformata(dot, "%i", carg->number);
}
list_iterator_stop(parameters);
handle_pp_lua_print_line(dot->data, scanner);
// Clean up.
list_destroy(parameters);
bdestroy(name);
bcstrfree(cstr);
}
// Generates the LuaJIT header given a Lua script and a property file. The
// header file is generated based on the property usage of the 'event'
// variable in the script.
//
// source - The source code of the Lua script.
// property_file - The property file used to lookup properties.
// event_decl - A pointer to where the struct def should be returned.
// init_descriptor_func - A pointer to where the descriptor init function should be returned.
//
// Returns 0 if successful, otherwise returns -1.
int sky_lua_generate_event_info(bstring source,
sky_property_file *property_file,
bstring *event_decl,
bstring *init_descriptor_func)
{
int rc;
bstring identifier = NULL;
assert(source != NULL);
assert(property_file != NULL);
assert(event_decl != NULL);
assert(init_descriptor_func != NULL);
// Initialize returned value.
*event_decl = bfromcstr(
" int64_t timestamp;\n"
" uint16_t action_id;\n"
);
check_mem(*event_decl);
*init_descriptor_func = bfromcstr(
" ffi.C.sky_data_descriptor_set_timestamp_offset(descriptor, ffi.offsetof(\"sky_lua_event_t\", \"timestamp\"));\n"
" ffi.C.sky_data_descriptor_set_action_id_offset(descriptor, ffi.offsetof(\"sky_lua_event_t\", \"action_id\"));\n"
);
check_mem(*init_descriptor_func);
// Setup a lookup of properties.
bool lookup[SKY_PROPERTY_ID_COUNT+1];
memset(lookup, 0, sizeof(lookup));
// Loop over every mention of an "event." property.
int pos = 0;
struct tagbstring EVENT_DOT_STR = bsStatic("event.");
while((pos = binstr(source, pos, &EVENT_DOT_STR)) != BSTR_ERR) {
// Make sure that this is not part of another identifier.
bool skip = false;
if(pos > 0 && (isalnum(bchar(source, pos-1)) || bchar(source, pos-1) == '_')) {
skip = true;
}
// Move past the "event." string.
pos += blength(&EVENT_DOT_STR);
if(!skip) {
// Read in identifier.
int i;
for(i=pos+1; i<blength(source); i++) {
char ch = bchar(source, i);
if(!(isalnum(ch) || ch == '_')) {
break;
}
}
identifier = bmidstr(source, pos, i-pos); check_mem(identifier);
if(blength(identifier)) {
sky_property *property = NULL;
rc = sky_property_file_find_by_name(property_file, identifier, &property);
check(rc == 0, "Unable to find property by name: %s", bdata(identifier));
check(property != NULL, "Property not found: %s", bdata(identifier));
if(!lookup[property->id-SKY_PROPERTY_ID_MIN]) {
// Append property definition to event decl and function.
switch(property->data_type) {
case SKY_DATA_TYPE_STRING: {
bformata(*event_decl, " char %s[];\n", bdata(property->name));
break;
}
case SKY_DATA_TYPE_INT: {
bformata(*event_decl, " int64_t %s;\n", bdata(property->name));
break;
}
case SKY_DATA_TYPE_DOUBLE: {
bformata(*event_decl, " double %s;\n", bdata(property->name));
break;
}
case SKY_DATA_TYPE_BOOLEAN: {
bformata(*event_decl, " bool %s;\n", bdata(property->name));
break;
}
default:{
sentinel("Invalid sky lua type: %d", property->data_type);
}
}
check_mem(*event_decl);
bformata(*init_descriptor_func, " ffi.C.sky_data_descriptor_set_property(descriptor, %d, ffi.offsetof(\"sky_lua_event_t\", \"%s\"), %d);\n", property->id, bdata(property->name), property->data_type);
check_mem(*init_descriptor_func);
// Flag the property as already processed.
lookup[property->id - SKY_PROPERTY_ID_MIN] = true;
}
}
bdestroy(identifier);
identifier = NULL;
}
}
// Wrap properties in a struct.
bassignformat(*event_decl, "typedef struct {\n%s} sky_lua_event_t;", bdata(*event_decl));
check_mem(*event_decl);
// Wrap info function.
bassignformat(*init_descriptor_func,
"function sky_init_descriptor(_descriptor)\n"
" descriptor = ffi.cast(\"sky_data_descriptor_t*\", _descriptor)\n"
"%s"
"end\n",
bdata(*init_descriptor_func)
);
check_mem(*init_descriptor_func);
return 0;
error:
bdestroy(identifier);
bdestroy(*event_decl);
*event_decl = NULL;
bdestroy(*init_descriptor_func);
*init_descriptor_func = NULL;
return -1;
}
static void TranslateVariableName(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag, uint32_t* pui32IgnoreSwizzle)
{
bstring glsl = *psContext->currentGLSLString;
*pui32IgnoreSwizzle = 0;
switch(psOperand->eType)
{
case OPERAND_TYPE_IMMEDIATE32:
{
if(psOperand->iNumComponents == 1)
{
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(psOperand->iNumComponents == 4)
{
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, "vec4(%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]);
}
}
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 = GetDeclaredName(psContext->psShader->eShaderType, psContext->flags);
}
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
{
const char* name = "Input";
if(ui32TOFlag & TO_FLAG_DECLARATION_NAME)
{
name = GetDeclaredName(psContext->psShader->eShaderType, psContext->flags);
}
bformata(glsl, "%s%d", name, 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:
{
bformata(glsl, "Temp%d", psOperand->ui32RegisterNumber);
break;
}
case OPERAND_TYPE_CONSTANT_BUFFER:
{
const char* StageName = "VS";
ConstantBuffer* psCBuf = NULL;
GetConstantBufferFromBindingPoint(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;
}
default:
{
break;
}
}
#if CBUFFER_USE_STRUCT_AND_NAMES
{
char* pszContBuffName;
pszContBuffName = psCBuf->Name;
if(psCBuf->Name[0] == '$')//$Global or $Param
pszContBuffName++;
ASSERT(psOperand->aui32ArraySizes[1] < psCBuf->ui32NumVars);
bformata(glsl, "%s%s.%s", pszContBuffName, StageName, psCBuf->asVars[psOperand->aui32ArraySizes[1]].Name);
}
#else
if(psContext->flags & HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT)
{
if((psCBuf->Name[0] == '$') && (psContext->flags & HLSLCC_FLAG_GLOBAL_CONSTS_NEVER_IN_UBO))
{
bformata(glsl, "Globals%s[%d]", StageName, psOperand->aui32ArraySizes[1]);
}
else
{
//Each uniform block is given the HLSL consant buffer name.
//Within each uniform block is a constant array named ConstN
bformata(glsl, "Const%d[%d]", psOperand->aui32ArraySizes[0], psOperand->aui32ArraySizes[1]);
}
}
else
{
//$Globals.
if(psCBuf->Name[0] == '$')
{
bformata(glsl, "Globals%s[%d]", StageName, psOperand->aui32ArraySizes[1]);
}
else
{
bformata(glsl, "%s%s[%d]", psCBuf->Name, StageName, psOperand->aui32ArraySizes[1]);
}
}
#endif
break;
}
case OPERAND_TYPE_RESOURCE:
{
TextureName(psContext, psOperand->ui32RegisterNumber, 0);
break;
}
case OPERAND_TYPE_SAMPLER:
{
bformata(glsl, "Sampler%d", psOperand->ui32RegisterNumber);
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;
}
default:
{
ASSERT(0);
break;
}
}
}
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, ")");
}
}
static int
ssh_validate_hostkey(obfsproxyssh_client_session_t *session)
{
obfsproxyssh_t *state = session->client->state;
const char *hkey_method;
bstring trusted_fp;
const char *fp;
bstring fp_s;
int i, len, dlen;
hkey_method = libssh2_session_methods(session->ssh_session,
LIBSSH2_METHOD_HOSTKEY);
if (0 == strcmp(hkey_method, "ssh-rsa"))
trusted_fp = session->hostkey_rsa;
else if (0 == strcmp(hkey_method, "ssh-dss"))
trusted_fp = session->hostkey_dss;
else {
log_f(state, "SSH: Error: Supplied hostkey method is invalid (%s)",
bdata(session->ssh_addr),
hkey_method);
return -1;
}
len = blength(trusted_fp);
switch (len) {
case OBFSPROXYSSH_CLIENT_MD5_FP_LEN:
fp = libssh2_hostkey_hash(session->ssh_session,
LIBSSH2_HOSTKEY_HASH_MD5);
dlen = 16;
break;
case OBFSPROXYSSH_CLIENT_SHA1_FP_LEN:
fp = libssh2_hostkey_hash(session->ssh_session,
LIBSSH2_HOSTKEY_HASH_SHA1);
dlen = 20;
break;
default:
log_f(state, "SSH: Error: Supplied hostkey length is invalid (%s)",
bdata(session->ssh_addr),
bdata(trusted_fp));
return -1;
}
fp_s = bfromcstralloc(len, "");
for (i = 0; i < dlen; i++) {
bformata(fp_s, "%02X", (unsigned char) fp[i]);
if (i != dlen - 1)
bconchar(fp_s, ':');
}
i = bstricmp(trusted_fp, fp_s);
if (0 != i)
log_f(state, "SSH: Error: %s Hostkey mismatch (Got: %s, Expecting: %s)",
bdata(session->ssh_addr),
bdata(trusted_fp),
bdata(fp_s));
else
log_f(state, "SSH: %s Hostkey matched (%s)",
bdata(session->ssh_addr),
bdata(trusted_fp));
return (0 == i) ? 0 : -1;
}
