RGBA Noise::EvalColor(ShadeContext& sc) {
Point3 p,dp;
if (!sc.doMaps) return black;
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
//IPoint2 ps = sc.ScreenCoord();
UpdateCache(sc.CurTime()); // DS 10/3/00
xyzGen->GetXYZ(sc,p,dp);
p /= size;
filter = sc.filterMaps;
float smw;
float limlev = LimitLevel(dp,smw);
float d = NoiseFunction(p,limlev,smw);
RGBA c0 = mapOn[0]&&subTex[0] ? subTex[0]->EvalColor(sc): col[0];
RGBA c1 = mapOn[1]&&subTex[1] ? subTex[1]->EvalColor(sc): col[1];
c = texout->Filter((1.0f-d)*c0 + d*c1);
sc.PutCache(this,c);
return c;
}
AColor BerconNoise::EvalColor(ShadeContext& sc) {
if (!sc.doMaps) return black;
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
// UVW and Distortion
Point3 p, dpdx, dpdy, dp;
if(!berconXYZ.get(sc, p, dpdx, dpdy)) return AColor(0,0,0,0);
if (useDistortion)
applyDistortion(sc,p);
float nSize = (mapOn[4] && subtex[4]) ? subtex[4]->EvalMono(sc)*size : size;
p /= nSize; dpdx /= nSize; dpdy /= nSize;
Noise::alterUVW(p, uvwDist);
NoiseParams np = EvalParameters(&sc);
// Caluclate noise function
float d = sc.filterMaps ? Noise::limitedNoise(p, dpdx, dpdy, np) : Noise::limitedNoise(p, np);
if (useCurve)
d = curve->GetControlCurve(0)->GetValue(sc.CurTime(), d);
// Get colors
RGBA c0 = mapOn[0]&&subtex[0] ? subtex[0]->EvalColor(sc): col[0];
RGBA c1 = mapOn[1]&&subtex[1] ? subtex[1]->EvalColor(sc): col[1];
c = texout->Filter((1.f-d)*c0 + d*c1);
// Cache
sc.PutCache(this,c);
return c;
}
AColor BerconTile::EvalColor(ShadeContext& sc) {
Point3 p;
if (!sc.doMaps) return black;
// If we've already evalutated the color at this point we'll use it and stop here
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
// Evaulate maps and tiling parameters
TileParam t = EvalParameters(sc);
// UVW, Distortion and size
berconXYZ.get(sc,p);
if (useDistortion) p += getDistVector(sc);
p /= tileSize;
// Caluclate tiling
TilePoint tp = Tile::draw(p, t);
// Calculate color
if (tp.d < -.5f) // First check if we are on edge
c = mapOn[1]&&subtex[1]?subtex[1]->EvalColor(sc): col[1];
else {
RGBA c1, c2;
if (tileParam.mapUV || tileParam.tileID || tileParam.center) { // Then if we map UV coordinates
BerconSC bsc = BerconSC(&sc);
if (tileParam.mapUV)
bsc.setUV1(tp.uvw, uvChan);
if (tileParam.center)
bsc.setUV2(tp.center, uvChan2);
if (tileParam.tileID)
bsc.setMultiTexture((float)tp.id);
c1 = getColor(bsc, 0);
if (lockEdge) c2 = getColor(bsc, 1);
else c2 = getColor(bsc, 2);
} else { // Normal eval
c1 = getColor(sc, 0);
if (lockEdge) c2 = getColor(sc, 1);
else c2 = getColor(sc, 2);
}
c = (1.0f-tp.d)*c2 + tp.d*c1;
}
c = texout->Filter(c);
// Cache
sc.PutCache(this,c);
return c;
}
float Gradient::EvalMono(ShadeContext& sc) {
if (!sc.doMaps)
return 0.0f;
float f;
if (sc.GetCache(this,f))
return f;
if (gbufID) sc.SetGBufferID(gbufID);
f = texout->Filter(uvGen->EvalUVMapMono(sc,&mysamp));
sc.PutCache(this,f);
return f;
}
AColor Gradient::EvalColor(ShadeContext& sc) {
if (!sc.doMaps)
return black;
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
c = texout->Filter(uvGen->EvalUVMap(sc,&mysamp));
sc.PutCache(this,c);
return c;
}
AColor plLayerTex::EvalColor(ShadeContext& sc)
{
if (!sc.doMaps)
return AColor(0.0f, 0.0f, 0.0f, 1.0f);
AColor color;
if (sc.GetCache(this, color))
return color;
if (gbufID)
sc.SetGBufferID(gbufID);
//
// Evaluate the Bitmap
//
if (fBitmapPB->GetInt(kBmpUseBitmap) && fBM)
{
plBMSampler mysamp(this, fBM);
color = fUVGen->EvalUVMap(sc, &mysamp, FALSE);
// We'd like to pass TRUE and actually filter the image, but that seems to be
// tripping an odd crash in Max internals. *shrug*
}
else
color.White();
// Invert color if specified
if (fBitmapPB->GetInt(kBmpInvertColor))
{
color.r = 1.0f - color.r;
color.g = 1.0f - color.g;
color.b = 1.0f - color.b;
}
// Discard color if specified
if (fBitmapPB->GetInt(kBmpDiscardColor))
color.r = color.g = color.b = 1.0f;
// Invert alpha if specified
if (fBitmapPB->GetInt(kBmpInvertAlpha))
color.a = 1.0f - color.a;
// Discard alpha if specified
if (fBitmapPB->GetInt(kBmpDiscardAlpha))
color.a = 1.0f;
// If RGB output is set to alpha, show RGB as grayscale of the alpha
if (fBitmapPB->GetInt(kBmpRGBOutput) == 1)
color = AColor(color.a, color.a, color.a, 1.0f);
sc.PutCache(this, color);
return color;
}
AColor BerconWood::EvalColor(ShadeContext& sc) {
Point3 p,dpdx,dpdy;
if (!sc.doMaps) return black;
// If we've already evalutated the color at this point we'll use it and stop here
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
// Evaluate parameters
WoodParam wp = EvalParameters(sc);
float grainA = mapOn[19]&&subtex[19]?subtex[19]->EvalMono(sc)*grainAmount:grainAmount;
float grainF = mapOn[20]&&subtex[20]?subtex[20]->EvalMono(sc)*grainFreq:grainFreq;
// UVW, Distortion and size
berconXYZ.get(sc,p,dpdx,dpdy);
if (useDistortion)
applyDistortion(sc,p);
float wSize = mapOn[5]&&subtex[5]?subtex[5]->EvalMono(sc)*woodSize:woodSize;
p /= wSize; dpdx /= (wSize / 2.f); dpdy /= (wSize / 2.f);
// Caluclate wood function and grain
Point3 gP;
float d = sc.filterMaps? Noise::wood(p, dpdx, dpdy, gP, wp) : Noise::wood(p, gP, wp);
float g = (grainAmount > .001f) ? Fractal::grain(gP, grainA, grainF): 0.f;
// Get colors
RGBA c0 = mapOn[0]&&subtex[0] ? subtex[0]->EvalColor(sc): col[0];
RGBA c1 = mapOn[1]&&subtex[1] ? subtex[1]->EvalColor(sc): col[1];
RGBA c2 = lockGrain ? c1: (mapOn[2]&&subtex[2] ? subtex[2]->EvalColor(sc): col[2]);
// Apply curves
if (useCurve)
d = curve->GetControlCurve(0)->GetValue(sc.CurTime(), d);
// Calculate color
c = (1.0f-d)*c0 + d*c1;
c = (1.0f-g)*c + g*c2;
c = texout->Filter(c);
// Cache
sc.PutCache(this,c);
return c;
}
AColor Composite::EvalColor(ShadeContext& sc) {
AColor c;
if (sc.GetCache(this,c))
return c;
if (gbufID) sc.SetGBufferID(gbufID);
AColor res(0,0,0);
for (int i=0; i<subTex.Count(); i++) {
// int on;
Interval iv;
// pblock->GetValue(comptex_ons,0,on,iv,i);
if (!subTex[i]||!mapOn[i]) continue;
// if (!subTex[i]||!on) continue;
res = CompOver(subTex[i]->EvalColor(sc),res);
}
sc.PutCache(this,res);
return res;
}
// #################### // Color \\ ####################
AColor BerconGradient::EvalColor(ShadeContext& sc) {
// Initialize returned color
AColor res(0.0f,0.0f,0.0f,0.0f);
if (!sc.doMaps) return res;
// Use cache
if (sc.GetCache(this,res))
return res;
if (gbufID) sc.SetGBufferID(gbufID);
// Function type
float d;
if (p_type == 0) {// UVW
Point3 p;
if (!berconXYZ.get(sc, p)) return res;
d = getGradientValueUVW(p);
} else { // Others
d = getGradientValue(sc);
}
// Distortion
if (p_disOn && p_distex) d += (1.f - p_distex->EvalMono(sc) * 2.f) * p_disStr;
// Limit range
if (!limitRange(d)) return res;
// Curve
if (p_curveOn) d = curve->GetControlCurve(0)->GetValue(sc.CurTime(), d);
// Get color from gradient
res = gradient->getColor(p_reverse?1.f-d:d, sc);
// Output
res = texout->Filter(res);
// Shading ready, return results
sc.PutCache(this,res);
return res;
}
float Noise::EvalMono(ShadeContext& sc) {
Point3 p,dp;
if (!sc.doMaps) return 0.0f;
float f;
if (sc.GetCache(this,f))
return f;
if (gbufID) sc.SetGBufferID(gbufID);
UpdateCache(sc.CurTime()); // DS 10/3/00
xyzGen->GetXYZ(sc,p,dp);
p /= size;
filter = sc.filterMaps;
float smw;
float limlev = LimitLevel(dp, smw);
float d = NoiseFunction(p,limlev,smw);
float c0 = mapOn[0]&&subTex[0] ? subTex[0]->EvalMono(sc): Intens(col[0]);
float c1 = mapOn[1]&&subTex[1] ? subTex[1]->EvalMono(sc): Intens(col[1]);
f = texout->Filter((1.0f-d)*c0 + d*c1);
sc.PutCache(this,f);
return f;
}
AColor plStaticEnvLayer::EvalColor(ShadeContext& sc)
{
if (!sc.doMaps)
return AColor(0.0f, 0.0f, 0.0f, 1.0f);
AColor color;
if (sc.GetCache(this, color))
return color;
if (gbufID)
sc.SetGBufferID(gbufID);
// Evaluate the Bitmap
// Point3 v = sc.VectorTo( sc.V(), REF_OBJECT );//WORLD );
Point3 v = sc.VectorTo( sc.Normal(), REF_OBJECT );
float wx,wy,wz;
Color rcol;
Bitmap *refmap = NULL;
Point3 rv;
Point2 uv;
int size;
wx = (float)fabs( v.x );
wy = (float)fabs( v.y );
wz = (float)fabs( v.z );
if( wx >= wy && wx >= wz )
{
if( v.x < 0 )
{
refmap = fBitmaps[ kLeftFace ];
uv = CompUV( -v.y, -v.z, v.x );
}
else
{
refmap = fBitmaps[ kRightFace ];
uv = CompUV( v.y, -v.z, -v.x );
}
}
else if( wy >= wx && wy >= wz )
{
if( v.y > 0 )
{
refmap = fBitmaps[ kBackFace ];
uv = CompUV( -v.x, -v.z, -v.y );
}
else
{
refmap = fBitmaps[ kFrontFace ];
uv = CompUV( v.x, -v.z, v.y );
}
}
else if( wz >= wx && wz >= wy )
{
if( v.z < 0 )
{
refmap = fBitmaps[ kBottomFace ];
uv = CompUV( -v.x, -v.y, v.z );
}
else
{
refmap = fBitmaps[ kTopFace ];
uv = CompUV( -v.x, v.y, -v.z );
}
}
if( refmap == NULL )
color.White();
else
{
if( uv.x < 0.0f )
uv.x = 0.0f;
else if( uv.x > 1.0f )
uv.x = 1.0f;
if( uv.y < 0.0f )
uv.y = 0.0f;
else if( uv.y > 1.0f )
uv.y = 1.0f;
size = refmap->Width();
int x = (int)( uv.x * (float)( size - 1 ) );
int y = (int)( ( 1.0f - uv.y ) * (float)( size - 1 ) );
BMM_Color_64 c;
refmap->GetLinearPixels( x, y, 1, &c );
color = AColor( c.r / 65535.f, c.g / 65535.f, c.b / 65535.f, c.a / 65535.f );
}
// Invert color if specified
if( fBitmapPB->GetInt( kBmpInvertColor ) )
{
color.r = 1.0f - color.r;
color.g = 1.0f - color.g;
color.b = 1.0f - color.b;
}
// Discard color if specified
if( fBitmapPB->GetInt( kBmpDiscardColor ) )
color.r = color.g = color.b = 1.0f;
// Invert alpha if specified
if( fBitmapPB->GetInt( kBmpInvertAlpha ) )
color.a = 1.0f - color.a;
// Discard alpha if specified
if( fBitmapPB->GetInt( kBmpDiscardAlpha ) )
color.a = 1.0f;
// If RGB output is set to alpha, show RGB as grayscale of the alpha
if( fBitmapPB->GetInt( kBmpRGBOutput ) == 1 )
color = AColor( color.a, color.a, color.a, 1.0f );
sc.PutCache(this, color);
return color;
}
Point3 BerconGradient::EvalNormalPerturb(ShadeContext& sc) {
// Returned vector
Point3 res(0.0f,0.0f,0.0f);
if (p_type != 0) return res; // Bump only works for UVW, otherwise we don't really know the derivative of the gradient
// Use cache
if (sc.GetCache(this,res))
return res;
if (gbufID) sc.SetGBufferID(gbufID);
// UVW
Point3 p;
Point3 M[3];
if (!berconXYZ.get(sc, p, M)) return res;
// Distortion
float dist = 0.f;
if (p_disOn && p_distex) dist = (1.f - p_distex->EvalMono(sc) * 2.f) * p_disStr;
// Origin
float d = getGradientValueUVW(p) + dist;
if (!limitRange(d)) return res;
if (p_curveOn) d = curve->GetControlCurve(0)->GetValue(sc.CurTime(), d);
d = Intens(gradient->getColor(d, sc));
// Deltas
Point3 normal;
/*if (berconXYZ.req()) {
Point3 MP[3];
MP[0] = Point3(DELTA,0.f,0.f); MP[1] = Point3(0.f,DELTA,0.f); MP[2] = Point3(0.f,DELTA,0.f);
for (int i=0; i<3; i++) {
normal[i] = getGradientValueUVW(p+DELTA*M[i]) + dist;
if (!limitRange(normal[i])) return res;
if (p_curveOn)
normal[i] = curve->GetControlCurve(0)->GetValue(sc.CurTime(), normal[i]);
normal[i] = (normal[i] - d) / DELTA;
}
normal = M[0]*normal.x + M[1]*normal.y + M[2]*normal.z;
} else {*/
Point3 MP[3];
MP[0] = Point3(DELTA,0.f,0.f); MP[1] = Point3(0.f,DELTA,0.f); MP[2] = Point3(0.f,DELTA,0.f);
for (int i=0; i<3; i++) {
normal[i] = getGradientValueUVW(p+MP[i]) + dist;
if (!limitRange(normal[i])) return res;
if (p_curveOn)
normal[i] = curve->GetControlCurve(0)->GetValue(sc.CurTime(), normal[i]);
normal[i] = Intens(gradient->getColor(normal[i], sc));
normal[i] = (normal[i] - d) / DELTA;
}
normal = M[0]*normal.x + M[1]*normal.y + M[2]*normal.z;
//normal = sc.VectorFromNoScale(normal, REF_OBJECT);
//}
// Compute maps and proper bump vector
res = gradient->getBump(p_reverse?1.f-d:d, p_reverse?normal:-normal, sc);
// Output
res = texout->Filter(res);
// Shading ready, return results
sc.PutCache(this,res);
return res;
}