//-----------------------------------------------------------------------
void CgProgram::buildConstantDefinitions() const
{
// Derive parameter names from Cg
createParameterMappingStructures(true);
if (!mCgProgram)
return;
recurseParams(cgGetFirstParameter(mCgProgram, CG_PROGRAM));
recurseParams(cgGetFirstParameter(mCgProgram, CG_GLOBAL));
}
//-----------------------------------------------------------------------
void CgProgram::buildConstantDefinitions() const
{
// Derive parameter names from Cg
mFloatLogicalToPhysical.bufferSize = 0;
mIntLogicalToPhysical.bufferSize = 0;
mConstantDefs.floatBufferSize = 0;
mConstantDefs.intBufferSize = 0;
if (!mCgProgram)
return;
recurseParams(cgGetFirstParameter(mCgProgram, CG_PROGRAM));
recurseParams(cgGetFirstParameter(mCgProgram, CG_GLOBAL));
}
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 CD3DCG::setupVertexDeclaration(shaderPass &pass)
{
static const D3DVERTEXELEMENT9 end = D3DDECL_END();
CGparameter param = cgGetFirstParameter(pass.cgVertexProgram, CG_PROGRAM);
fillParameterMap(pass.parameterMap,param);
/* set up vertex elements according to parameter map.
all streams use the same vertex buffer layout, with
different offsets.
default (unknown name) parameters with semantics
POSITION0, TEXCOORD0, TEXCOORD1 and COLOR0 get stream
0,1,2 and 3 respectively.
the rest (all texcoords) get stream 4 and up
*/
D3DVERTEXELEMENT9 *vElems = new D3DVERTEXELEMENT9[pass.parameterMap.size()+1];
int streamNum = 4;
for(int i=0;i<pass.parameterMap.size();i++) {
const char* sem = pass.parameterMap[i].semantic;
pass.parameterMap[i].streamNumber = 0;
if(pass.parameterMap[i].isKnownParam==false) {
if(!strcmp(sem,"TEXCOORD0")) {
D3DVERTEXELEMENT9 elem = {1, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0};
vElems[i] = elem;
} else if(!strcmp(sem,"TEXCOORD1")) {
D3DVERTEXELEMENT9 elem = {2, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1};
vElems[i] = elem;
} else if(!strcmp(sem,"COLOR0")) {
D3DVERTEXELEMENT9 elem = {3, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0};
vElems[i] = elem;
} else if(!strcmp(sem,"POSITION0")) {
D3DVERTEXELEMENT9 elem = {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0};
vElems[i] = elem;
}
} else {
int resIndex = atoi(sem + strlen(sem) - 1);
D3DVERTEXELEMENT9 elem = {streamNum, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, resIndex};
vElems[i] = elem;
pass.parameterMap[i].streamNumber = streamNum;
streamNum++;
}
}
vElems[pass.parameterMap.size()] = end;
/* create vertex declaration for vertex elements, then
get rid of the elements
*/
LPDIRECT3DVERTEXDECLARATION9 vertexDeclaration;
HRESULT hr = pDevice->CreateVertexDeclaration(vElems,&vertexDeclaration);
if(FAILED(hr)) {
DXTRACE_ERR_MSGBOX(TEXT("Error creating vertex declaration"), hr);
}
if(pass.vertexDeclaration)
pass.vertexDeclaration->Release();
pass.vertexDeclaration = vertexDeclaration;
delete [] vElems;
}
void GLCgShader::FillParameters(const CGenum domain)
{
CGparameter param = cgGetFirstParameter(m_cgProgam, domain);
while (param)
{
const char* name = cgGetParameterName(param);
m_params[name] = param;
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))
{
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");
}
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");
}
cgfxPass::cgfxPass(
CGpass pass,
const cgfxProfile* profile
)
: fPass( pass),
fProgram( NULL),
fParameters( NULL),
fDefaultProfile("default", pass),
fNext( NULL)
{
if( pass)
{
fName = cgGetPassName( pass);
CGstateassignment stateAssignment = cgGetFirstStateAssignment( pass);
cgfxVaryingParameter** nextParameter = &fParameters;
while( stateAssignment )
{
CGstate state = cgGetStateAssignmentState( stateAssignment);
if( cgGetStateType( state) == CG_PROGRAM_TYPE &&
( stricmp( cgGetStateName( state), "vertexProgram") == 0 ||
stricmp( cgGetStateName( state), "vertexShader") == 0))
{
fProgram = cgGetProgramStateAssignmentValue( stateAssignment);
if( fProgram)
{
CGparameter parameter = cgGetFirstParameter( fProgram, CG_PROGRAM);
while( parameter)
{
cgfxVaryingParameter::addRecursive( parameter, nextParameter);
parameter = cgGetNextParameter( parameter);
}
}
}
setProfile(profile);
stateAssignment = cgGetNextStateAssignment( stateAssignment);
}
}
}
//-----------------------------------------------------------------------
void CgProgram::compileMicrocode(void)
{
// Create Cg Program
/// Program handle
CGprogram cgProgram;
if (mSelectedCgProfile == CG_PROFILE_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Attempted to load Cg program '" + mName + "', but no supported "
"profile was found. ");
return;
}
buildArgs();
// deal with includes
String sourceToUse = resolveCgIncludes(mSource, this, mFilename);
cgProgram = cgCreateProgram(mCgContext, CG_SOURCE, sourceToUse.c_str(),
mSelectedCgProfile, mEntryPoint.c_str(), const_cast<const char**>(mCgArguments));
// Test
//LogManager::getSingleton().logMessage(cgGetProgramString(mCgProgram, CG_COMPILED_PROGRAM));
// Check for errors
checkForCgError("CgProgram::compileMicrocode",
"Unable to compile Cg program " + mName + ": ", mCgContext);
CGerror error = cgGetError();
if (error == CG_NO_ERROR)
{
// get program string (result of cg compile)
mProgramString = cgGetProgramString(cgProgram, CG_COMPILED_PROGRAM);
checkForCgError("CgProgram::compileMicrocode",
"Unable to retrieve program code for Cg program " + mName + ": ", mCgContext);
// get params
mParametersMap.clear();
mParametersMapSizeAsBuffer = 0;
mSamplerRegisterMap.clear();
recurseParams(cgGetFirstParameter(cgProgram, CG_PROGRAM));
recurseParams(cgGetFirstParameter(cgProgram, CG_GLOBAL));
if (mDelegate)
{
// Delegating to HLSL or GLSL, need to clean up Cg's output
fixHighLevelOutput(mProgramString);
if (mSelectedCgProfile == CG_PROFILE_GLSLG)
{
// need to determine input and output operations
mInputOp = cgGetProgramInput(cgProgram);
mOutputOp = cgGetProgramOutput(cgProgram);
}
}
// Unload Cg Program - we don't need it anymore
cgDestroyProgram(cgProgram);
//checkForCgError("CgProgram::unloadImpl",
// "Error while unloading Cg program " + mName + ": ",
// mCgContext);
cgProgram = 0;
if ( GpuProgramManager::getSingleton().getSaveMicrocodesToCache())
{
addMicrocodeToCache();
}
}
}
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;
}
static bool d3d9_cg_renderchain_init_shader_fvf(
d3d9_renderchain_t *chain,
struct shader_pass *pass)
{
CGparameter param;
unsigned index, i, count;
unsigned tex_index = 0;
bool texcoord0_taken = false;
bool texcoord1_taken = false;
bool stream_taken[4] = {false};
static const D3DVERTEXELEMENT9 decl_end = D3DDECL_END();
D3DVERTEXELEMENT9 decl[MAXD3DDECLLENGTH] = {{0}};
bool *indices = NULL;
if (cgD3D9GetVertexDeclaration(pass->vprg, decl) == CG_FALSE)
return false;
for (count = 0; count < MAXD3DDECLLENGTH; count++)
{
if (string_is_equal_fast(&decl_end, &decl[count], sizeof(decl_end)))
break;
}
/* This is completely insane.
* We do not have a good and easy way of setting up our
* attribute streams, so we have to do it ourselves, yay!
*
* Stream 0 => POSITION
* Stream 1 => TEXCOORD0
* Stream 2 => TEXCOORD1
* Stream 3 => COLOR (Not really used for anything.)
* Stream {4..N} => Texture coord streams for varying resources
* which have no semantics.
*/
indices = (bool*)calloc(1, count * sizeof(*indices));
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "POSITION");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "POSITION0");
if (param)
{
static const D3DVERTEXELEMENT9 element =
{
0, 0 * sizeof(float),
D3DDECLTYPE_FLOAT3,
D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION,
0
};
stream_taken[0] = true;
index = cgGetParameterResourceIndex(param);
decl[index] = element;
indices[index] = true;
RARCH_LOG("[D3D9 Cg]: FVF POSITION semantic found.\n");
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "TEXCOORD");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "TEXCOORD0");
if (param)
{
static const D3DVERTEXELEMENT9 tex_coord0 = D3D9_DECL_FVF_TEXCOORD(1, 3, 0);
stream_taken[1] = true;
texcoord0_taken = true;
RARCH_LOG("[D3D9 Cg]: FVF TEXCOORD0 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = tex_coord0;
indices[index] = true;
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "TEXCOORD1");
if (param)
{
static const D3DVERTEXELEMENT9 tex_coord1 = D3D9_DECL_FVF_TEXCOORD(2, 5, 1);
stream_taken[2] = true;
texcoord1_taken = true;
RARCH_LOG("[D3D9 Cg]: FVF TEXCOORD1 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = tex_coord1;
indices[index] = true;
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "COLOR");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vprg, CG_PROGRAM), "COLOR0");
if (param)
{
static const D3DVERTEXELEMENT9 color = DECL_FVF_COLOR(3, 7, 0);
stream_taken[3] = true;
RARCH_LOG("[D3D9 Cg]: FVF COLOR0 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = color;
indices[index] = true;
}
/* Stream {0, 1, 2, 3} might be already taken. Find first vacant stream. */
for (index = 0; index < 4; index++)
{
if (stream_taken[index] == false)
break;
}
/* Find first vacant texcoord declaration. */
if (texcoord0_taken && texcoord1_taken)
tex_index = 2;
else if (texcoord1_taken && !texcoord0_taken)
tex_index = 0;
else if (texcoord0_taken && !texcoord1_taken)
tex_index = 1;
for (i = 0; i < count; i++)
{
if (indices[i])
unsigned_vector_list_append((struct unsigned_vector_list *)
pass->attrib_map, 0);
else
{
D3DVERTEXELEMENT9 elem = D3D9_DECL_FVF_TEXCOORD(index, 3, tex_index);
unsigned_vector_list_append((struct unsigned_vector_list *)
pass->attrib_map, index);
decl[i] = elem;
/* Find next vacant stream. */
while ((++index < 4) && stream_taken[index])
index++;
/* Find next vacant texcoord declaration. */
if ((++tex_index == 1) && texcoord1_taken)
tex_index++;
}
}
free(indices);
return d3d9_vertex_declaration_new(chain->dev,
decl, (void**)&pass->vertex_decl);
}
void CCgMaterialRenderer::getUniformList()
{
for(unsigned int i = 0; i < UniformInfo.size(); ++i)
delete UniformInfo[i];
UniformInfo.clear();
for(unsigned int i = 0; i < 2; ++i)
{
CGenum Space = CG_GLOBAL;
bool IsGlobal = 1;
if(i == 1)
{
Space = CG_PROGRAM;
IsGlobal = 0;
}
for(unsigned int j = 0; j < 3; ++j)
{
CGprogram* Program = 0;
switch(j)
{
case 0:
Program = &VertexProgram;
break;
case 1:
Program = &FragmentProgram;
break;
case 2:
Program = &GeometryProgram;
break;
}
if(*Program)
{
CGparameter Parameter = cgGetFirstParameter(*Program, Space);
while(Parameter)
{
if(cgGetParameterVariability(Parameter) == CG_UNIFORM && cgGetParameterDirection(Parameter) == CG_IN)
{
CCgUniform* Uniform = 0;
CGtype Type = cgGetParameterType(Parameter);
switch(Type)
{
case CG_FLOAT:
case CG_FLOAT1:
Uniform = new CCgUniform1f(Parameter, IsGlobal);
break;
case CG_FLOAT2:
Uniform = new CCgUniform2f(Parameter, IsGlobal);
break;
case CG_FLOAT3:
Uniform = new CCgUniform3f(Parameter, IsGlobal);
break;
case CG_FLOAT4:
Uniform = new CCgUniform4f(Parameter, IsGlobal);
break;
case CG_INT:
case CG_INT1:
Uniform = new CCgUniform1i(Parameter, IsGlobal);
break;
case CG_INT2:
Uniform = new CCgUniform2i(Parameter, IsGlobal);
break;
case CG_INT3:
Uniform = new CCgUniform3i(Parameter, IsGlobal);
break;
case CG_INT4:
Uniform = new CCgUniform4i(Parameter, IsGlobal);
break;
case CG_FLOAT4x4:
Uniform = new CCgUniform4x4f(Parameter, IsGlobal);
break;
case CG_SAMPLER2D:
Uniform = new CCgUniformSampler2D(Parameter, IsGlobal);
break;
}
if(Uniform)
UniformInfo.push_back(Uniform);
}
Parameter = cgGetNextParameter(Parameter);
}
}
}
}
}
static bool cg_d3d9_renderchain_init_shader_fvf(void *data, void *pass_data)
{
CGparameter param;
unsigned index, i, count;
unsigned tex_index = 0;
bool texcoord0_taken = false;
bool texcoord1_taken = false;
bool stream_taken[4] = {false};
cg_renderchain_t *chain = (cg_renderchain_t*)data;
Pass *pass = (Pass*)pass_data;
static const D3DVERTEXELEMENT decl_end = D3DDECL_END();
D3DVERTEXELEMENT decl[MAXD3DDECLLENGTH] = {{0}};
if (cgD3D9GetVertexDeclaration(pass->vPrg, decl) == CG_FALSE)
return false;
for (count = 0; count < MAXD3DDECLLENGTH; count++)
{
if (memcmp(&decl_end, &decl[count], sizeof(decl_end)) == 0)
break;
}
/* This is completely insane.
* We do not have a good and easy way of setting up our
* attribute streams, so we have to do it ourselves, yay!
*
* Stream 0 => POSITION
* Stream 1 => TEXCOORD0
* Stream 2 => TEXCOORD1
* Stream 3 => COLOR (Not really used for anything.)
* Stream {4..N} => Texture coord streams for varying resources
* which have no semantics.
*/
std::vector<bool> indices(count);
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "POSITION");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "POSITION0");
if (param)
{
static const D3DVERTEXELEMENT element =
{
0, 0 * sizeof(float),
D3DDECLTYPE_FLOAT3,
D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION,
0
};
stream_taken[0] = true;
index = cgGetParameterResourceIndex(param);
decl[index] = element;
indices[index] = true;
RARCH_LOG("[FVF]: POSITION semantic found.\n");
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "TEXCOORD");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "TEXCOORD0");
if (param)
{
static const D3DVERTEXELEMENT tex_coord0 = DECL_FVF_TEXCOORD(1, 3, 0);
stream_taken[1] = true;
texcoord0_taken = true;
RARCH_LOG("[FVF]: TEXCOORD0 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = tex_coord0;
indices[index] = true;
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "TEXCOORD1");
if (param)
{
static const D3DVERTEXELEMENT tex_coord1 = DECL_FVF_TEXCOORD(2, 5, 1);
stream_taken[2] = true;
texcoord1_taken = true;
RARCH_LOG("[FVF]: TEXCOORD1 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = tex_coord1;
indices[index] = true;
}
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "COLOR");
if (!param)
param = d3d9_cg_find_param_from_semantic(cgGetFirstParameter(pass->vPrg, CG_PROGRAM), "COLOR0");
if (param)
{
static const D3DVERTEXELEMENT color = DECL_FVF_COLOR(3, 7, 0);
stream_taken[3] = true;
RARCH_LOG("[FVF]: COLOR0 semantic found.\n");
index = cgGetParameterResourceIndex(param);
decl[index] = color;
indices[index] = true;
}
/* Stream {0, 1, 2, 3} might be already taken. Find first vacant stream. */
for (index = 0; index < 4; index++)
{
if (stream_taken[index] == false)
break;
}
/* Find first vacant texcoord declaration. */
if (texcoord0_taken && texcoord1_taken)
tex_index = 2;
else if (texcoord1_taken && !texcoord0_taken)
tex_index = 0;
else if (texcoord0_taken && !texcoord1_taken)
tex_index = 1;
for (i = 0; i < count; i++)
{
if (indices[i])
pass->attrib_map.push_back(0);
else
{
D3DVERTEXELEMENT elem = DECL_FVF_TEXCOORD(index, 3, tex_index);
pass->attrib_map.push_back(index);
decl[i] = elem;
/* Find next vacant stream. */
while ((++index < 4) && stream_taken[index])
index++;
/* Find next vacant texcoord declaration. */
if ((++tex_index == 1) && texcoord1_taken)
tex_index++;
}
}
if (FAILED(chain->dev->CreateVertexDeclaration(
decl, &pass->vertex_decl)))
return false;
return true;
}
static inline CGparameter find_param_from_semantic(CGprogram prog, const std::string &sem)
{
return find_param_from_semantic(cgGetFirstParameter(prog, CG_PROGRAM), sem);
}
static INLINE CGparameter find_param_from_semantic(CGprogram prog,
const char *sem)
{
CGparameter param = cgGetFirstParameter(prog, CG_PROGRAM);
return find_param_from_semantic(param, sem);
}
