static INLINE CGparameter find_param_from_semantic( CGparameter param, const char *sem) { while (param) { if (cgGetParameterType(param) == CG_STRUCT) { CGparameter ret = find_param_from_semantic( cgGetFirstStructParameter(param), sem); if (ret) return ret; } else { if (cgGetParameterSemantic(param) && !strcmp(sem, cgGetParameterSemantic(param)) && cgGetParameterDirection(param) == CG_IN && cgGetParameterVariability(param) == CG_VARYING && validate_param_name(cgGetParameterName(param))) return param; } param = cgGetNextParameter(param); } return NULL; }
static INLINE CGparameter d3d9_cg_find_param_from_semantic( CGparameter param, const char *sem) { for (; param; param = cgGetNextParameter(param)) { const char *semantic = NULL; if (cgGetParameterType(param) == CG_STRUCT) { CGparameter ret = d3d9_cg_find_param_from_semantic( cgGetFirstStructParameter(param), sem); if (ret) return ret; } if ( cgGetParameterDirection(param) != CG_IN || cgGetParameterVariability(param) != CG_VARYING) continue; semantic = cgGetParameterSemantic(param); if (!semantic) continue; if (string_is_equal(sem, semantic) && d3d9_cg_validate_param_name(cgGetParameterName(param))) return param; } return NULL; }
static void set_program_base_attrib(unsigned i) { CGparameter param = cgGetFirstParameter(prg[i].vprg, CG_PROGRAM); for (; param; param = cgGetNextParameter(param)) { if (cgGetParameterDirection(param) != CG_IN || cgGetParameterVariability(param) != CG_VARYING) continue; const char *semantic = cgGetParameterSemantic(param); if (!semantic) continue; RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i); if (strcmp(semantic, "TEXCOORD") == 0 || strcmp(semantic, "TEXCOORD0") == 0) prg[i].tex = param; else if (strcmp(semantic, "COLOR") == 0 || strcmp(semantic, "COLOR0") == 0) prg[i].color = param; else if (strcmp(semantic, "POSITION") == 0) prg[i].vertex = param; else if (strcmp(semantic, "TEXCOORD1") == 0) prg[i].lut_tex = param; } if (!prg[i].tex) prg[i].tex = cgGetNamedParameter(prg[i].vprg, "IN.tex_coord"); if (!prg[i].color) prg[i].color = cgGetNamedParameter(prg[i].vprg, "IN.color"); if (!prg[i].vertex) prg[i].vertex = cgGetNamedParameter(prg[i].vprg, "IN.vertex_coord"); if (!prg[i].lut_tex) prg[i].lut_tex = cgGetNamedParameter(prg[i].vprg, "IN.lut_tex_coord"); }
void csShaderGLCGCommon::DebugDumpParam (csString& output, CGparameter param) { output << "Parameter: " << cgGetParameterName (param) << "\n"; output << " Type: " << cgGetTypeString (cgGetParameterNamedType (param)) << "\n"; output << " Direction: " << cgGetEnumString (cgGetParameterDirection (param)) << "\n"; output << " Semantic: " << cgGetParameterSemantic (param) << "\n"; const CGenum var = cgGetParameterVariability (param); output << " Variability: " << cgGetEnumString (var) << "\n"; output << " Resource: " << cgGetResourceString (cgGetParameterResource (param)) << "\n"; output << " Resource index: " << cgGetParameterResourceIndex (param) << "\n"; // Cg 2.0 seems to not like CG_DEFAULT for uniforms if (/*(var == CG_UNIFORM) || */(var == CG_CONSTANT)) { int nValues; const double* values = cgGetParameterValues (param, (var == CG_UNIFORM) ? CG_DEFAULT : CG_CONSTANT, &nValues); if (nValues != 0) { output << " Values:"; for (int v = 0; v < nValues; v++) { output << ' ' << values[v]; } output << "\n"; } } if (!cgIsParameterUsed (param, program)) output << " not used\n"; if (!cgIsParameterReferenced (param)) output << " not referenced\n"; }
static void gl_cg_set_program_base_attrib(void *data, unsigned i) { cg_shader_data_t *cg = (cg_shader_data_t*)data; CGparameter param = cgGetFirstParameter( cg->prg[i].vprg, CG_PROGRAM); for (; param; param = cgGetNextParameter(param)) { uint32_t semantic_hash; const char *semantic = NULL; if (cgGetParameterDirection(param) != CG_IN || cgGetParameterVariability(param) != CG_VARYING) continue; semantic = cgGetParameterSemantic(param); if (!semantic) continue; RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i); semantic_hash = djb2_calculate(semantic); switch (semantic_hash) { case SEMANTIC_TEXCOORD: case SEMANTIC_TEXCOORD0: cg->prg[i].tex = param; break; case SEMANTIC_COLOR: case SEMANTIC_COLOR0: cg->prg[i].color = param; break; case SEMANTIC_POSITION: cg->prg[i].vertex = param; break; case SEMANTIC_TEXCOORD1: cg->prg[i].lut_tex = param; break; } } if (!cg->prg[i].tex) cg->prg[i].tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord"); if (!cg->prg[i].color) cg->prg[i].color = cgGetNamedParameter(cg->prg[i].vprg, "IN.color"); if (!cg->prg[i].vertex) cg->prg[i].vertex = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord"); if (!cg->prg[i].lut_tex) cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord"); }
/* iterate all parameters and record input variyings with their semantic and resource index */ void CD3DCG::fillParameterMap(std::vector<parameterEntry> &map, CGparameter param) { parameterEntry mapEntry; while (param) { if(cgGetParameterType(param)==CG_STRUCT) fillParameterMap(map,cgGetFirstStructParameter(param)); else if (cgGetParameterDirection(param) == CG_IN && cgGetParameterVariability(param) == CG_VARYING) { mapEntry.rIndex = cgGetParameterResourceIndex(param); mapEntry.semantic = cgGetParameterSemantic(param); mapEntry.isKnownParam = isKnownParameter(cgGetParameterName(param)); if(map.size()<mapEntry.rIndex+1) map.resize(mapEntry.rIndex+1); map[mapEntry.rIndex] = mapEntry; } param = cgGetNextParameter(param); } }
static void gl_cg_set_program_base_attrib(void *data, unsigned i) { cg_shader_data_t *cg = (cg_shader_data_t*)data; CGparameter param = cgGetFirstParameter( cg->prg[i].vprg, CG_PROGRAM); for (; param; param = cgGetNextParameter(param)) { const char *semantic = NULL; if ( (cgGetParameterDirection(param) != CG_IN) || (cgGetParameterVariability(param) != CG_VARYING)) continue; semantic = cgGetParameterSemantic(param); if (!semantic) continue; RARCH_LOG("[CG]: Found semantic \"%s\" in prog #%u.\n", semantic, i); if ( string_is_equal(semantic, "TEXCOORD") || string_is_equal(semantic, "TEXCOORD0") ) cg->prg[i].tex = param; else if ( string_is_equal(semantic, "COLOR") || string_is_equal(semantic, "COLOR0") ) cg->prg[i].color = param; else if (string_is_equal(semantic, "POSITION")) cg->prg[i].vertex = param; else if (string_is_equal(semantic, "TEXCOORD1")) cg->prg[i].lut_tex = param; } if (!cg->prg[i].tex) cg->prg[i].tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord"); if (!cg->prg[i].color) cg->prg[i].color = cgGetNamedParameter(cg->prg[i].vprg, "IN.color"); if (!cg->prg[i].vertex) cg->prg[i].vertex = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord"); if (!cg->prg[i].lut_tex) cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord"); }
static bool AddPass(CGtechnique technique, JSON &json, CGpass pass, UniformsMap &uniformRemapping) { bool success = true; json.AddObject(NULL); const char * const passName = cgGetPassName(pass); if (NULL != passName) { json.AddString("name", passName); } bool firstParameter = true; #if CG_VERSION_NUM >= 3000 const int CG_NUMBER_OF_DOMAINS = (CG_TESSELLATION_EVALUATION_DOMAIN + 1); #endif for (int domain = CG_FIRST_DOMAIN; domain < CG_NUMBER_OF_DOMAINS; domain++) { const CGprogram program = cgGetPassProgram(pass, (CGdomain)domain); if (NULL != program) { const char * const programString = cgGetProgramString(program, CG_COMPILED_PROGRAM); CGparameter param = cgGetFirstParameter(program, CG_GLOBAL); while (NULL != param) { if (cgIsParameterUsed(param, program) && CG_UNIFORM == cgGetParameterVariability(param)) { if (firstParameter) { firstParameter = false; json.AddArray("parameters", true); json.BeginData(true); } const char * const paramName = cgGetParameterName(param); AddMappedParameter(json, paramName, programString, uniformRemapping); } param = cgGetNextParameter(param); } param = cgGetFirstParameter(program, CG_PROGRAM); while (NULL != param) { if (cgIsParameterUsed(param, program) && CG_UNIFORM == cgGetParameterVariability(param)) { if (firstParameter) { firstParameter = false; json.AddArray("parameters", true); json.BeginData(true); } const char * const paramName = cgGetParameterName(param); AddMappedParameter(json, paramName, programString, uniformRemapping); } param = cgGetNextParameter(param); } } } if (!firstParameter) { json.EndData(); json.CloseArray(true); // parameters } json.AddArray("semantics", true); json.BeginData(true); CGprogram vertexProgram = cgGetPassProgram(pass, CG_VERTEX_DOMAIN); CGparameter vertexInputParameter = cgGetFirstLeafParameter(vertexProgram, CG_PROGRAM); while (NULL != vertexInputParameter) { const CGenum variability = cgGetParameterVariability(vertexInputParameter); if (CG_VARYING == variability) { const CGenum direction = cgGetParameterDirection(vertexInputParameter); if (CG_IN == direction || CG_INOUT == direction) { const char * const semantic = cgGetParameterSemantic(vertexInputParameter); json.AddData(semantic, strlen(semantic)); } } vertexInputParameter = cgGetNextLeafParameter(vertexInputParameter); } json.EndData(); json.CloseArray(true); // semantics json.AddObject("states"); CGstateassignment state = cgGetFirstStateAssignment(pass); if (NULL != state) { do { success &= AddState(json, state); state = cgGetNextStateAssignment(state); } while (NULL != state); } json.CloseObject(); // states json.AddArray("programs", true); json.BeginData(true); for (int domain = CG_FIRST_DOMAIN; domain < CG_NUMBER_OF_DOMAINS; domain++) { const CGprogram program = cgGetPassProgram(pass, (CGdomain)domain); if (NULL != program) { const char * const entryPoint = cgGetProgramString(program, CG_PROGRAM_ENTRY); json.AddData(entryPoint, strlen(entryPoint)); } else if (domain == CG_VERTEX_DOMAIN) { ErrorMessage("%s : No vertex program.", cgGetTechniqueName(technique)); success = false; } else if(domain == CG_FRAGMENT_DOMAIN) { ErrorMessage("%s : No fragment program.", cgGetTechniqueName(technique)); success = false; } } json.EndData(); json.CloseArray(true); // programs json.CloseObject(); // pass return success; }
void cgfxVaryingParameter::setupAttributes( cgfxRCPtr<cgfxVertexAttribute>& vertexAttributes, CGprogram program) { // Make sure our parameter name is acceptable is a Maya attribute name MString attrName = fName; int lastDot = attrName.rindex( '.'); if( lastDot >= 0) attrName = attrName.substring( lastDot + 1, attrName.length() - 1); MString semanticName = cgGetParameterSemantic( fParameter); MString semantic(semanticName); cgGetParameterSemantic( fParameter); semantic.toUpperCase(); // Is this varying parameter packed or atomic? CGtype type = cgGetNamedUserType( program, attrName.asChar()); if( type != CG_UNKNOWN_TYPE) { // It's packed: explode the inputs into the structure elements CGcontext context = cgGetProgramContext( program); CGparameter packing = cgCreateParameter( context, type); fVertexStructure = new cgfxVaryingParameterStructure(); fVertexStructure->fLength = 0; fVertexStructure->fSize = 0; CGparameter element = cgGetFirstStructParameter( packing); while( element) { MString elementName = cgGetParameterName( element); int lastDot = elementName.rindex( '.'); if( lastDot >= 0) elementName = elementName.substring( lastDot + 1, elementName.length() - 1); cgfxRCPtr<cgfxVertexAttribute> attr = setupAttribute( elementName, semantic, element, vertexAttributes); fVertexStructure->fElements[ fVertexStructure->fLength].fVertexAttribute = attr; int size = cgGetParameterRows( element) * cgGetParameterColumns( element); CGtype type = cgGetParameterBaseType( element); if( type == CG_FLOAT) size *= sizeof( GLfloat); else if( type == CG_INT) size *= sizeof( GLint); fVertexStructure->fElements[ fVertexStructure->fLength].fSize = size; fVertexStructure->fLength++; fVertexStructure->fSize += size; element = cgGetNextParameter( element); } cgDestroyParameter( packing); } else { // It's atomic - create a single, simple input fVertexAttribute = setupAttribute( attrName, semantic, fParameter, vertexAttributes); } // Now pull apart the semantic string to work out where to bind // this value in open GL (as the automagic binding through cgGL // didn't work so well when this was written) int radix = 1; fGLIndex = 0; unsigned int length = semantic.length(); const char* str = semantic.asChar(); // If sematic is NULL then stop here, bug 327649 if (length == 0) { fGLType = glRegister::kUnknown; return; } for(;;) { char c = str[ length - 1]; if( c < '0' || c > '9') break; fGLIndex += radix * (c - '0'); radix *= 10; --length; } if( semantic.length() != length) semantic = semantic.substring( 0, length - 1); // Determine the semantic and setup the gl binding type we should use // to set this parameter. If there's a sensible default value, set that // while we're here. // Note there is no need to set the source type, this gets determined // when the vertex attribute sources are analysed if( semantic == "POSITION") { fGLType = glRegister::kPosition; fVertexAttribute->fSourceName = "position"; } else if( semantic == "NORMAL") { fGLType = glRegister::kNormal; if( fVertexAttribute.isNull() == false ) fVertexAttribute->fSourceName = "normal"; } else if( semantic == "TEXCOORD") { fGLType = glRegister::kTexCoord; if( fVertexAttribute.isNull() == false ) { if( attrName.toLowerCase() == "tangent") fVertexAttribute->fSourceName = "tangent:map1"; else if( attrName.toLowerCase() == "binormal") fVertexAttribute->fSourceName = "binormal:map1"; else fVertexAttribute->fSourceName = "uv:map1"; } } else if( semantic == "TANGENT") { fGLType = glRegister::kTexCoord; fGLIndex += 6; // TANGENT is TEXCOORD6 if( fVertexAttribute.isNull() == false ) fVertexAttribute->fSourceName = "tangent:map1"; } else if( semantic == "BINORMAL") { fGLType = glRegister::kTexCoord; fGLIndex += 7; // BINORMAL is TEXCOORD7 if( fVertexAttribute.isNull() == false ) fVertexAttribute->fSourceName = "binormal:map1"; } else if( semantic == "COLOR") { fGLType = fGLIndex == 1 ? glRegister::kSecondaryColor : glRegister::kColor; } else if( semantic == "ATTR") { fGLType = glRegister::kVertexAttrib; if( fVertexAttribute.isNull() == false ) { fVertexAttribute->fSourceName = semanticName; } } else if( semantic == "PSIZE") { fGLType = glRegister::kVertexAttrib; fGLIndex = 6; } else { fGLType = glRegister::kUnknown; } }