void Cg::Init(void)
{
context = NULL;
vertexProgram = NULL;
vertexProfile = CG_PROFILE_ARBVP1;
fragmentProgram = NULL;
fragmentProfile = CG_PROFILE_ARBFP1;
//vertex用
BNUMParam = NULL;
BRParam = NULL;
INIBNParam = NULL;
//fragment用
vdecalParam = NULL;
fdecalParam = NULL;
globalAmbientParam = NULL;
lightColorParam = NULL;
lightPositionParam = NULL;
eyePositionParam = NULL;
KeParam = NULL;
KaParam = NULL;
KdParam = NULL;
KsParam = NULL;
shininessParam = NULL;
matModelViewNormalParam = NULL;
cameraParam = NULL;
stepsizeParam = NULL;
volExtentMinParam = NULL;
volExtentMaxParam = NULL;
rsclParam = NULL;
resoColorParam = NULL;
renderAlphaParam = NULL;
renderBetaParam = NULL;
farSliceParam = NULL;
rayLoopParam = NULL;
srcDivParam = NULL;
BLParam = NULL;
transfer_functionParam = NULL;
//スライス用
vertex_sliceProgram = NULL;
BR2Param = NULL;
BNUM2Param = NULL;
INIBN2Param = NULL;
dPlaneStartParam = NULL;
frontIdxParam = NULL;
vecViewParam = NULL;
nSequenceTemp = NULL;
vecVerticesTemp = NULL;
v1Temp = NULL;
v2Temp = NULL;
//occlusion fragment用
fragment_occlusionProgram = NULL;
fdecal2Param = NULL;
vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
fprintf(stderr, "Video card supports : %d.\n", vertexProfile);
CheckCgError();
fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
fprintf(stderr, "Video card supports : %d.\n", fragmentProfile);
CheckCgError();
context = cgCreateContext();
CheckCgError();
vertexProgram= cgCreateProgramFromFile(context, CG_SOURCE, "shader.cg",vertexProfile, "vertex", NULL);//TODO:
CheckCgError();
if(vertexProgram != NULL) {
cgGLLoadProgram(vertexProgram);CheckCgError();
BNUMParam = cgGetNamedParameter(vertexProgram, "BNUM");CheckCgError();
BRParam = cgGetNamedParameter(vertexProgram, "BR");CheckCgError();
INIBNParam = cgGetNamedParameter(vertexProgram, "INIBN");CheckCgError();
}
fragmentProgram= cgCreateProgramFromFile(context, CG_SOURCE, "shader.cg",fragmentProfile, "fragment", NULL);
CheckCgError();
if(fragmentProgram != NULL)
{
cgGLLoadProgram(fragmentProgram);
CheckCgError();
vdecalParam = cgGetNamedParameter(fragmentProgram,"vdecal");CheckCgError();
fdecalParam = cgGetNamedParameter(fragmentProgram,"fdecal");CheckCgError();
globalAmbientParam = cgGetNamedParameter(fragmentProgram, "globalAmbient");CheckCgError();
lightColorParam = cgGetNamedParameter(fragmentProgram, "lightColor");CheckCgError();
lightPositionParam = cgGetNamedParameter(fragmentProgram, "lightPosition");CheckCgError();
eyePositionParam = cgGetNamedParameter(fragmentProgram, "eyePosition");CheckCgError();
KeParam = cgGetNamedParameter(fragmentProgram, "Ke");CheckCgError();
KaParam = cgGetNamedParameter(fragmentProgram, "Ka");CheckCgError();
KdParam = cgGetNamedParameter(fragmentProgram, "Kd");CheckCgError();
KsParam = cgGetNamedParameter(fragmentProgram, "Ks");CheckCgError();
shininessParam = cgGetNamedParameter(fragmentProgram, "shininess");CheckCgError();
matModelViewNormalParam = cgGetNamedParameter(fragmentProgram, "matModelViewNormal");CheckCgError();
cameraParam = cgGetNamedParameter(fragmentProgram, "camera");CheckCgError();
stepsizeParam = cgGetNamedParameter(fragmentProgram, "stepsize");CheckCgError();
volExtentMinParam = cgGetNamedParameter(fragmentProgram, "volExtentMin");CheckCgError();
volExtentMaxParam = cgGetNamedParameter(fragmentProgram, "volExtentMax");CheckCgError();
rsclParam = cgGetNamedParameter(fragmentProgram, "rscl");CheckCgError();
resoColorParam = cgGetNamedParameter(fragmentProgram, "resoColor");CheckCgError();
renderAlphaParam = cgGetNamedParameter(fragmentProgram, "renderAlpha");CheckCgError();
renderBetaParam = cgGetNamedParameter(fragmentProgram, "renderBeta");CheckCgError();
farSliceParam = cgGetNamedParameter(fragmentProgram, "farSlice");CheckCgError();
rayLoopParam = cgGetNamedParameter(fragmentProgram, "rayLoop");CheckCgError();
srcDivParam = cgGetNamedParameter(fragmentProgram, "srcDiv");CheckCgError();
BLParam = cgGetNamedParameter(fragmentProgram, "BL");CheckCgError();
transfer_functionParam = cgGetNamedParameter(fragmentProgram,"transfer_function");CheckCgError();
//cgGLSetTextureParameter(transfer_functionParam,preintName);CheckCgError();
}
vertex_sliceProgram= cgCreateProgramFromFile(context, CG_SOURCE, "shader.cg",vertexProfile, "vertex_slice", NULL);CheckCgError();
CheckCgError();
if(vertex_sliceProgram != NULL) {
cgGLLoadProgram(vertex_sliceProgram);
CheckCgError();
frontIdxParam = cgGetNamedParameter(vertex_sliceProgram, "frontIdx");
CheckCgError();
dPlaneStartParam = cgGetNamedParameter(vertex_sliceProgram, "dPlaneStart");
CheckCgError();
vecViewParam = cgGetNamedParameter(vertex_sliceProgram, "vecView");
CheckCgError();
nSequenceTemp = cgGetNamedParameter(vertex_sliceProgram, "nSequence");
CheckCgError();
for(int i=0;i< 64;i++)
nSequenceParam[i] = cgGetArrayParameter(nSequenceTemp,i);
CheckCgError();
vecVerticesTemp = cgGetNamedParameter(vertex_sliceProgram, "vecVertices");
CheckCgError();
for(int i=0 ;i< 8;i++)
vecVerticesParam[i] = cgGetArrayParameter(vecVerticesTemp,i);
CheckCgError();
v1Temp = cgGetNamedParameter(vertex_sliceProgram, "v1");
CheckCgError();
for(int i= 0;i<24;i++)
v1Param[i] = cgGetArrayParameter(v1Temp,i);
CheckCgError();
v2Temp = cgGetNamedParameter(vertex_sliceProgram, "v2");
CheckCgError();
for(int i= 0;i<24;i++)
v2Param[i] = cgGetArrayParameter(v2Temp,i);
CheckCgError();
BNUM2Param = cgGetNamedParameter(vertex_sliceProgram, "BNUM");
CheckCgError();
BR2Param = cgGetNamedParameter(vertex_sliceProgram, "BR");
CheckCgError();
INIBN2Param = cgGetNamedParameter(vertex_sliceProgram, "INIBN");
CheckCgError();
}
//オクルージョンfragment用
fragment_occlusionProgram= cgCreateProgramFromFile(context, CG_SOURCE, "shader.cg",fragmentProfile, "fragment_occlusion", NULL);CheckCgError();
if(fragment_occlusionProgram != NULL)
{
cgGLLoadProgram(fragment_occlusionProgram);
CheckCgError();
fdecal2Param = cgGetNamedParameter(fragmentProgram,"fdecal");
CheckCgError();
}
this->SetParameter(this->srcDivParam,SRCDIV);
/*
MAXBL計算
*/
int MAXBL;
MAXBL = max(BLX,BLY);
MAXBL = max(MAXBL,BLZ);
int MAXINI;
MAXINI = max(INIBLX,INIBLY);
MAXINI = max(MAXINI,INIBLZ);
Block::brX = (float)BLX/(float)MAXBL;
Block::brY = (float)BLY/(float)MAXBL;
Block::brZ = (float)BLZ/(float)MAXBL;
Block::iniX = (float)INIBLX/(float)MAXINI;
Block::iniY = (float)INIBLY/(float)MAXINI;
Block::iniZ = (float)INIBLZ/(float)MAXINI;
float bl[3] = {BLX,BLY,BLZ};//bl=(64,64,64) １ブロックあたりのボクセルの数を示すと思われる。
this->SetParameter(BLParam,bl);
float br[3] = {Block::brX,Block::brY,Block::brZ};//br=(1,1,1)
printf("br(%.lf,%.lf,%.lf)",br[0],br[1],br[2]);
this->SetParameter(BRParam,br);
this->SetParameter(BR2Param,br);
float ini[3] = {Block::iniX,Block::iniY,Block::iniZ};//ini=(1,1,1)
//printf("ini(%.lf,%.lf,%.lf)\n",ini[0],ini[1],ini[2]);
this->SetParameter(INIBNParam,ini);
this->SetParameter(INIBN2Param,ini);
float volExtentMin[3] = {0.0f*Block::brX,0.0f*Block::brY,0.0f*Block::brZ};
//printf("br(%.lf,%.lf,%.lf)\n",Block::brX,Block::brY,Block::brZ);
this->SetParameter(volExtentMinParam , volExtentMin);
float volExtentMax[3] = {1.0f*Block::brX,1.0f*Block::brY,1.0f*Block::brZ};
this->SetParameter(volExtentMaxParam , volExtentMax);
for(int i = 0;i<24;i++)
{
this->SetParameter(v1Param[i],(float)v1[i]);
this->SetParameter(v2Param[i],(float)v2[i]);
}
for(int i = 0;i<64;i++)
this->SetParameter(nSequenceParam[i],(float)nSequence[i]);
for(int i= 0;i<8;i++)
this->SetParameter(vecVerticesParam[i],vecVertices[i]);
}
bool CgShaderProgramGL::setConstant(const io::stringc &Name, const f32* Buffer, s32 Count)
{
if (!Buffer)
return false;
/* Get top-level parameter */
CGparameter Param = cgGetNamedParameter(cgProgram_, Name.c_str());
if (!Param)
return false;
/* Get array parameter */
if (cgGetParameterType(Param) != CG_ARRAY)
return false;
s32 ArraySize = cgGetArraySize(Param, 0);
for (s32 i = 0; i < ArraySize; ++i)
{
/* Get array element parameter */
CGparameter ElementParam = cgGetArrayParameter(Param, i);
switch (cgGetParameterType(ElementParam))
{
case CG_FLOAT:
cgGLSetParameterArray1f(Param, 0, Count, Buffer);
return true;
case CG_FLOAT2:
cgGLSetParameterArray2f(Param, 0, Count/2, Buffer);
return true;
case CG_FLOAT3:
cgGLSetParameterArray3f(Param, 0, Count/3, Buffer);
return true;
case CG_FLOAT4:
cgGLSetParameterArray4f(Param, 0, Count/4, Buffer);
return true;
case CG_FLOAT4x4:
cgGLSetMatrixParameterArrayfc(Param, 0, Count/16, Buffer);
return true;
case CG_STRUCT:
{
/* Get structure field parameter */
CGparameter FieldParam = cgGetFirstStructParameter(ElementParam);
while (FieldParam)
{
switch (cgGetParameterType(FieldParam))
{
case CG_FLOAT:
cgGLSetParameter1f(FieldParam, *Buffer);
Buffer += 1;
break;
case CG_FLOAT2:
cgGLSetParameter2fv(FieldParam, Buffer);
Buffer += 2;
break;
case CG_FLOAT3:
cgGLSetParameter3fv(FieldParam, Buffer);
Buffer += 3;
break;
case CG_FLOAT4:
cgGLSetParameter4fv(FieldParam, Buffer);
Buffer += 4;
break;
case CG_FLOAT4x4:
cgGLSetMatrixParameterfc(FieldParam, Buffer);
Buffer += 16;
break;
case CG_INT:
cgSetParameter1i(FieldParam, *((s32*)Buffer));
Buffer += 1;
break;
default:
break;
}
FieldParam = cgGetNextParameter(FieldParam);
}
}
break;
default:
break;
}
}
return true;
}
//---------------------------------------------------------------------
void CgProgram::recurseParams(CGparameter parameter, size_t contextArraySize)
{
while (parameter != 0)
{
// Look for uniform parameters only
// Don't bother enumerating unused parameters, especially since they will
// be optimised out and therefore not in the indexed versions
CGtype paramType = cgGetParameterType(parameter);
if (cgGetParameterVariability(parameter) == CG_UNIFORM &&
paramType != CG_SAMPLER1D &&
paramType != CG_SAMPLER2D &&
paramType != CG_SAMPLER3D &&
paramType != CG_SAMPLERCUBE &&
paramType != CG_SAMPLERRECT &&
cgGetParameterDirection(parameter) != CG_OUT &&
cgIsParameterReferenced(parameter))
{
int arraySize;
switch(paramType)
{
case CG_STRUCT:
recurseParams(cgGetFirstStructParameter(parameter));
break;
case CG_ARRAY:
// Support only 1-dimensional arrays
arraySize = cgGetArraySize(parameter, 0);
recurseParams(cgGetArrayParameter(parameter, 0), (size_t)arraySize);
break;
default:
// Normal path (leaf)
String paramName = cgGetParameterName(parameter);
size_t logicalIndex = cgGetParameterResourceIndex(parameter);
// Get the parameter resource, to calculate the physical index
CGresource res = cgGetParameterResource(parameter);
bool isRegisterCombiner = false;
size_t regCombinerPhysicalIndex = 0;
switch (res)
{
case CG_COMBINER_STAGE_CONST0:
// register combiner, const 0
// the index relates to the texture stage; store this as (stage * 2) + 0
regCombinerPhysicalIndex = logicalIndex * 2;
isRegisterCombiner = true;
break;
case CG_COMBINER_STAGE_CONST1:
// register combiner, const 1
// the index relates to the texture stage; store this as (stage * 2) + 1
regCombinerPhysicalIndex = (logicalIndex * 2) + 1;
isRegisterCombiner = true;
break;
default:
// normal constant
break;
}
// Trim the '[0]' suffix if it exists, we will add our own indexing later
if (StringUtil::endsWith(paramName, "[0]", false))
{
paramName.erase(paramName.size() - 3);
}
GpuConstantDefinition def;
def.arraySize = contextArraySize;
mapTypeAndElementSize(paramType, isRegisterCombiner, def);
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Problem parsing the following Cg Uniform: '"
+ paramName + "' in file " + mName);
// next uniform
parameter = cgGetNextParameter(parameter);
continue;
}
if (isRegisterCombiner)
{
def.physicalIndex = regCombinerPhysicalIndex;
}
else
{
// base position on existing buffer contents
if (def.isFloat())
{
def.physicalIndex = mFloatLogicalToPhysical->bufferSize;
}
else
{
def.physicalIndex = mIntLogicalToPhysical->bufferSize;
}
}
def.logicalIndex = logicalIndex;
if( mParametersMap.find(paramName) == mParametersMap.end())
{
mParametersMap.insert(GpuConstantDefinitionMap::value_type(paramName, def));
mParametersMapSizeAsBuffer += sizeof(size_t);
mParametersMapSizeAsBuffer += paramName.size();
mParametersMapSizeAsBuffer += sizeof(GpuConstantDefinition);
}
// Record logical / physical mapping
if (def.isFloat())
{
OGRE_LOCK_MUTEX(mFloatLogicalToPhysical->mutex);
mFloatLogicalToPhysical->map.insert(
GpuLogicalIndexUseMap::value_type(def.logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));
mFloatLogicalToPhysical->bufferSize += def.arraySize * def.elementSize;
}
else
{
OGRE_LOCK_MUTEX(mIntLogicalToPhysical->mutex);
mIntLogicalToPhysical->map.insert(
GpuLogicalIndexUseMap::value_type(def.logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));
mIntLogicalToPhysical->bufferSize += def.arraySize * def.elementSize;
}
break;
}
}
// now handle uniform samplers. This is needed to fix their register positions
// if delegating to a GLSL shader.
if (mDelegate && cgGetParameterVariability(parameter) == CG_UNIFORM && (
paramType == CG_SAMPLER1D ||
paramType == CG_SAMPLER2D ||
paramType == CG_SAMPLER3D ||
paramType == CG_SAMPLERCUBE ||
paramType == CG_SAMPLERRECT) &&
cgGetParameterDirection(parameter) != CG_OUT &&
cgIsParameterReferenced(parameter))
{
String paramName = cgGetParameterName(parameter);
CGresource res = cgGetParameterResource(parameter);
int pos = -1;
switch (res)
{
case CG_TEXUNIT0: pos = 0; break;
case CG_TEXUNIT1: pos = 1; break;
case CG_TEXUNIT2: pos = 2; break;
case CG_TEXUNIT3: pos = 3; break;
case CG_TEXUNIT4: pos = 4; break;
case CG_TEXUNIT5: pos = 5; break;
case CG_TEXUNIT6: pos = 6; break;
case CG_TEXUNIT7: pos = 7; break;
case CG_TEXUNIT8: pos = 8; break;
case CG_TEXUNIT9: pos = 9; break;
case CG_TEXUNIT10: pos = 10; break;
case CG_TEXUNIT11: pos = 11; break;
case CG_TEXUNIT12: pos = 12; break;
case CG_TEXUNIT13: pos = 13; break;
case CG_TEXUNIT14: pos = 14; break;
case CG_TEXUNIT15: pos = 15; break;
#if(CG_VERSION_NUM >= 3000)
case CG_TEXUNIT16: pos = 16; break;
case CG_TEXUNIT17: pos = 17; break;
case CG_TEXUNIT18: pos = 18; break;
case CG_TEXUNIT19: pos = 19; break;
case CG_TEXUNIT20: pos = 20; break;
case CG_TEXUNIT21: pos = 21; break;
case CG_TEXUNIT22: pos = 22; break;
case CG_TEXUNIT23: pos = 23; break;
case CG_TEXUNIT24: pos = 24; break;
case CG_TEXUNIT25: pos = 25; break;
case CG_TEXUNIT26: pos = 26; break;
case CG_TEXUNIT27: pos = 27; break;
case CG_TEXUNIT28: pos = 28; break;
case CG_TEXUNIT29: pos = 29; break;
case CG_TEXUNIT30: pos = 30; break;
case CG_TEXUNIT31: pos = 31; break;
#endif
default:
break;
}
if (pos != -1)
{
mSamplerRegisterMap.insert(std::make_pair(paramName, pos));
}
}
// Get next
parameter = cgGetNextParameter(parameter);
}
}
//---------------------------------------------------------------------
void CgProgram::recurseParams(CGparameter parameter, size_t contextArraySize) const
{
while (parameter != 0)
{
// Look for uniform (non-sampler) parameters only
// Don't bother enumerating unused parameters, especially since they will
// be optimised out and therefore not in the indexed versions
CGtype paramType = cgGetParameterType(parameter);
if (cgGetParameterVariability(parameter) == CG_UNIFORM &&
paramType != CG_SAMPLER1D &&
paramType != CG_SAMPLER2D &&
paramType != CG_SAMPLER3D &&
paramType != CG_SAMPLERCUBE &&
paramType != CG_SAMPLERRECT &&
cgGetParameterDirection(parameter) != CG_OUT &&
cgIsParameterReferenced(parameter))
{
int arraySize;
switch(paramType)
{
case CG_STRUCT:
recurseParams(cgGetFirstStructParameter(parameter));
break;
case CG_ARRAY:
// Support only 1-dimensional arrays
arraySize = cgGetArraySize(parameter, 0);
recurseParams(cgGetArrayParameter(parameter, 0), (size_t)arraySize);
break;
default:
// Normal path (leaf)
String paramName = cgGetParameterName(parameter);
size_t logicalIndex = cgGetParameterResourceIndex(parameter);
// Get the parameter resource, to calculate the physical index
CGresource res = cgGetParameterResource(parameter);
bool isRegisterCombiner = false;
size_t regCombinerPhysicalIndex = 0;
switch (res)
{
case CG_COMBINER_STAGE_CONST0:
// register combiner, const 0
// the index relates to the texture stage; store this as (stage * 2) + 0
regCombinerPhysicalIndex = logicalIndex * 2;
isRegisterCombiner = true;
break;
case CG_COMBINER_STAGE_CONST1:
// register combiner, const 1
// the index relates to the texture stage; store this as (stage * 2) + 1
regCombinerPhysicalIndex = (logicalIndex * 2) + 1;
isRegisterCombiner = true;
break;
default:
// normal constant
break;
}
// Trim the '[0]' suffix if it exists, we will add our own indexing later
if (StringUtil::endsWith(paramName, "[0]", false))
{
paramName.erase(paramName.size() - 3);
}
GpuConstantDefinition def;
def.arraySize = contextArraySize;
mapTypeAndElementSize(paramType, isRegisterCombiner, def);
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Problem parsing the following Cg Uniform: '"
+ paramName + "' in file " + mName);
// next uniform
continue;
}
if (isRegisterCombiner)
{
def.physicalIndex = regCombinerPhysicalIndex;
}
else
{
// base position on existing buffer contents
if (def.isFloat())
{
def.physicalIndex = mFloatLogicalToPhysical.bufferSize;
}
else
{
def.physicalIndex = mIntLogicalToPhysical.bufferSize;
}
}
mConstantDefs.map.insert(GpuConstantDefinitionMap::value_type(paramName, def));
// Record logical / physical mapping
if (def.isFloat())
{
OGRE_LOCK_MUTEX(mFloatLogicalToPhysical.mutex)
mFloatLogicalToPhysical.map.insert(
GpuLogicalIndexUseMap::value_type(logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize)));
mFloatLogicalToPhysical.bufferSize += def.arraySize * def.elementSize;
mConstantDefs.floatBufferSize = mFloatLogicalToPhysical.bufferSize;
}
else
{
OGRE_LOCK_MUTEX(mIntLogicalToPhysical.mutex)
mIntLogicalToPhysical.map.insert(
GpuLogicalIndexUseMap::value_type(logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize)));
mIntLogicalToPhysical.bufferSize += def.arraySize * def.elementSize;
mConstantDefs.intBufferSize = mIntLogicalToPhysical.bufferSize;
}
// Deal with array indexing
mConstantDefs.generateConstantDefinitionArrayEntries(paramName, def);
break;
}
}
// Get next
parameter = cgGetNextParameter(parameter);
}
}