void
GlfSimpleMaterial::Bind()
{
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, GetAmbient().GetArray());
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, GetDiffuse().GetArray());
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, GetSpecular().GetArray());
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, GetEmission().GetArray());
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, GetShininess());
}
int main(int argc, char *argv[])
{
int i;
double r=1.0, g=0.5, b=.25, sr, sg, sb;
for(i=0;i<145;i+=16)
{
GetSpecular(r,g,b,i,&sr,&sg,&sb);
fprintf(stdout,"rgb %0.3f %0.3f %0.3f spec %0.3f %0.3f %0.3f shi %d\n", r, g, b, sr, sg, sb, i);
}
return(EXIT_SUCCESS);
}
void Light::SetupLight(int lightIndex){
glEnable(GL_LIGHT0+lightIndex);
// Setup and enable light 0
glLightfv(GL_LIGHT0+lightIndex,GL_AMBIENT, glm::value_ptr(GetAmbient()));
glLightfv(GL_LIGHT0+lightIndex,GL_DIFFUSE, glm::value_ptr(GetDiffuse()));
glLightfv(GL_LIGHT0+lightIndex,GL_SPECULAR, glm::value_ptr(GetSpecular()));
glLighti(GL_LIGHT0+lightIndex, GL_SPOT_CUTOFF, spotCutoff);
glLightfv(GL_LIGHT0+lightIndex,GL_SPOT_DIRECTION, glm::value_ptr(spotDirection));
float w = 0;
if (GetLightType()==PointLight){
w = 1;
} else if (GetLightType()==DirectionalLight){
w = 0;
}
SceneObject *sceneObject = GetOwner();
assert(sceneObject != NULL);
glm::vec4 lightPos(sceneObject->GetTransform()->GetPosition(), w);
glLightfv(GL_LIGHT0+lightIndex,GL_POSITION, glm::value_ptr(lightPos));
}
//????????????????????????????????????????????????????????????????????????
// The stdID parameter doesn't really have a meaning in this case.
//
bool Matte::EvalMonoStdChannel
(
ShadeContext& sc, // describes context of evaluation
int stdID, // must be ID_AM, ect
float& outVal // output var
)
{
switch ( stdID )
{
case ID_BU: // Bump (value 8)
case ID_RR: // Refraction (value 10)
case ID_DP: // Displacement (value 11)
case ID_SI: // Self-illumination (value 5)
case ID_FI: // Filter color (value 7)
return false;
break;
case ID_RL: // Reflection (value 9)
if ( sc.doMaps &&
reflmap &&
useReflMap &&
reflmap->IsOutputMeaningful(sc) )
{
if ( reflmap->HandleOwnViewPerturb() )
{
sc.TossCache(reflmap);
outVal = reflmap->EvalMono(sc);
}
else
{
AColor rcol;
rcol = sc.EvalEnvironMap( reflmap, sc.ReflectVector() );
Color rc;
rc = Color(rcol.r,rcol.g,rcol.b)*reflAmt;
outVal = Intens(rc);
}
}
else
return false;
break;
case ID_AM: // Ambient (value 0)
outVal = Intens( GetAmbient() );
break;
case ID_DI: // Diffuse (value 1)
outVal = Intens( GetDiffuse() );
break;
case ID_SP: // Specular (value 2)
outVal = Intens( GetSpecular() );
break;
case ID_SH: // Shininess (value 3). In R3 and later this is called Glossiness.
outVal = GetShininess();
break;
case ID_SS: // Shininess strength (value 4). In R3 and later this is called Specular Level.
outVal = GetShinStr();
break;
case ID_OP: // Opacity (value 6)
outVal = GetXParency();
break;
default:
// Should never happen
//DbgAssert( false );
return false;
break;
}
return true;
}
// Save():
const char * IllumiSurf_Instance::Save( const LWSaveState *saver ) {
char cvalue;
// Version
LWSAVE_BEGIN( saver, &illumisurf_io_isfv[0], 0 );
cvalue = 1;
LWSAVE_I1( saver, &cvalue, 1 );
// Blending Mode
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_BLND ], 1 );
cvalue = GetBlendMode();
LWSAVE_I1( saver, &cvalue, 1 );
LWSAVE_END( saver );
// Base Intensity
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_BINT ], 1 );
vparam_funcs->save( GetBaseIntensity(), saver );
LWSAVE_END( saver );
// Alternate Intensity
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_AINT ], 1 );
vparam_funcs->save( GetAltIntensity(), saver );
LWSAVE_END( saver );
// Color
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_COLR ], 1 );
cvalue = GetUseColor() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetColor(), saver );
LWSAVE_END( saver );
// Luminosity
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_LUMI ], 1 );
cvalue = GetUseLuminosity() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetLuminosity(), saver );
LWSAVE_END( saver );
// Diffusion
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_DIFF ], 1 );
cvalue = GetUseDiffusion() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetDiffusion(), saver );
LWSAVE_END( saver );
// Specular
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_SPEC ], 1 );
cvalue = GetUseSpecular() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetSpecular(), saver );
LWSAVE_END( saver );
// Glossiness
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_GLOS ], 1 );
cvalue = GetUseGlossiness() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetGlossiness(), saver );
LWSAVE_END( saver );
// Reflection
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_REFL ], 1 );
cvalue = GetUseReflection() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetReflection(), saver );
LWSAVE_END( saver );
// Transparency
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_TRNP ], 1 );
cvalue = GetUseTransparency() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetTransparency(), saver );
LWSAVE_END( saver );
// Refraction
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_REFR ], 1 );
cvalue = GetUseRefraction() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetRefraction(), saver );
LWSAVE_END( saver );
// Translucency
LWSAVE_BEGIN( saver, &illumisurf_io_root[ ISIOID_TRNC ], 1 );
cvalue = GetUseTranslucency() ? 1 : 0;
LWSAVE_I1( saver, &cvalue, 1 );
vparam_funcs->save( GetTranslucency(), saver );
LWSAVE_END( saver );
LWSAVE_END( saver );
return NULL;
}
// Load():
const char * IllumiSurf_Instance::Load( const LWLoadState *loader ) {
char cvalue;
if( ISIOPRE_ISFV == LWLOAD_FIND( loader, illumisurf_io_isfv ) ) {
LWLOAD_I1( loader, &cvalue, 1 );
if( cvalue != 1 )
return "IllumiSurf Error: Unsupported version found, aborting load";
while( int id = LWLOAD_FIND( loader, illumisurf_io_root ) ) {
switch( id ) {
case ISIOPRE_BLND:
LWLOAD_I1( loader, &cvalue, 1 );
SetBlendMode( (IllumiSurf_BlendModes)cvalue );
break;
case ISIOPRE_BINT:
vparam_funcs->load( GetBaseIntensity(), loader );
break;
case ISIOPRE_AINT:
vparam_funcs->load( GetAltIntensity(), loader );
break;
case ISIOPRE_COLR:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseColor( cvalue != 0 );
vparam_funcs->load( GetColor(), loader );
break;
case ISIOPRE_LUMI:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseLuminosity( cvalue != 0 );
vparam_funcs->load( GetLuminosity(), loader );
break;
case ISIOPRE_DIFF:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseDiffusion( cvalue != 0 );
vparam_funcs->load( GetDiffusion(), loader );
break;
case ISIOPRE_SPEC:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseSpecular( cvalue != 0 );
vparam_funcs->load( GetSpecular(), loader );
break;
case ISIOPRE_GLOS:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseGlossiness( cvalue != 0 );
vparam_funcs->load( GetGlossiness(), loader );
break;
case ISIOPRE_REFL:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseReflection( cvalue != 0 );
vparam_funcs->load( GetReflection(), loader );
break;
case ISIOPRE_TRNP:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseTransparency( cvalue != 0 );
vparam_funcs->load( GetTransparency(), loader );
break;
case ISIOPRE_REFR:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseRefraction( cvalue != 0 );
vparam_funcs->load( GetRefraction(), loader );
break;
case ISIOPRE_TRNC:
LWLOAD_I1( loader, &cvalue, 1 );
SetUseTranslucency( cvalue != 0 );
vparam_funcs->load( GetTranslucency(), loader );
break;
}
LWLOAD_END( loader ); // End Keyword
}
LWLOAD_END( loader ); // End Keyword
}
return NULL;
}
void MaterialHandler::ProcessData(FbxSurfaceMaterial* pMaterial, unsigned int materialCount, MaterialExport* outputMat, SceneMap* sceneMap)
{
MaterialHeader materialStruct;
//diffuse property
FbxProperty diffProp = pMaterial->FindProperty(FbxSurfaceMaterial::sDiffuse);
unsigned int diffMapCount = diffProp.GetSrcObjectCount<FbxFileTexture>();
memcpy(materialStruct.matName, pMaterial->GetName(), sizeof(char) * 256);
materialStruct.Id = sceneMap->materialHash[pMaterial->GetName()];
//check if there are texturemaps
if (diffMapCount > 0)
{
memcpy(materialStruct.diffMap, GetTextureMap(diffProp), sizeof(char) * 256);
materialStruct.diffuseVal[0] = 0.0f;
materialStruct.diffuseVal[1] = 0.0f;
materialStruct.diffuseVal[2] = 0.0f;
}
else
{
GetDiffuse(pMaterial, materialStruct.diffuseVal);
memcpy(materialStruct.diffMap, "", sizeof(char) * 256);
}
//SpecularProperty
FbxProperty specProp = pMaterial->FindProperty(FbxSurfaceMaterial::sSpecular);
unsigned int specMapCount = specProp.GetSrcObjectCount<FbxFileTexture>();
FbxSurfacePhong* tmpCompare = (FbxSurfacePhong*)pMaterial;
if (specMapCount > 0)
{
memcpy(materialStruct.specMap, GetSpecularMap(specProp), sizeof(char) * 256);
materialStruct.specularVal[0] = 0.0f;
materialStruct.specularVal[1] = 0.0f;
materialStruct.specularVal[2] = 0.0f;
}
else
{
if (pMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
GetSpecular(pMaterial, materialStruct.specularVal);
memcpy(materialStruct.specMap, "", sizeof(char) * 256);
}
else
{
materialStruct.specularVal[0] = 0.0f;
materialStruct.specularVal[1] = 0.0f;
materialStruct.specularVal[2] = 0.0f;
memcpy(materialStruct.specMap, "", sizeof(char) * 256);
}
}
//NormalMap properties
FbxProperty normMapProp = pMaterial->FindProperty(FbxSurfaceMaterial::sNormalMap);
unsigned int normMapCount = normMapProp.GetSrcObjectCount<FbxFileTexture>();
if (normMapCount > 0)
{
memcpy(materialStruct.normalMap, GetNormalMap(normMapProp), sizeof(char) * 256);
}
else
{
memcpy(materialStruct.normalMap, "", sizeof(char) * 256);
}
//GlowMap proporties
FbxProperty glowMapProp = pMaterial->FindProperty(FbxSurfaceMaterial::sEmissive);
unsigned int glowMapCount = glowMapProp.GetSrcObjectCount<FbxFileTexture>();
if (glowMapCount > 0)
{
memcpy(materialStruct.glowMap, GetGlowMap(glowMapProp), sizeof(char) * 256);
}
else
{
memcpy(materialStruct.glowMap, "", sizeof(char) * 256);
}
outputMat->materials->push_back(materialStruct);
std::cout << "";
}
