void R3PointLight::
Draw(int i) const
{
// Draw light
GLenum index = (GLenum) (GL_LIGHT2 + i);
if (index > GL_LIGHT7) return;
GLfloat buffer[4];
buffer[0] = Intensity() * Color().R();
buffer[1] = Intensity() * Color().G();
buffer[2] = Intensity() * Color().B();
buffer[3] = 1.0;
glLightfv(index, GL_DIFFUSE, buffer);
glLightfv(index, GL_SPECULAR, buffer);
buffer[0] = Position().X();
buffer[1] = Position().Y();
buffer[2] = Position().Z();
buffer[3] = 1.0;
glLightfv(index, GL_POSITION, buffer);
buffer[0] = 180.0;
glLightf(index, GL_SPOT_CUTOFF, buffer[0]);
glEnable(index);
buffer[0] = ConstantAttenuation();
buffer[1] = LinearAttenuation();
buffer[2] = QuadraticAttenuation();
glLightf(index, GL_CONSTANT_ATTENUATION, buffer[0]);
glLightf(index, GL_LINEAR_ATTENUATION, buffer[1]);
glLightf(index, GL_QUADRATIC_ATTENUATION, buffer[2]);
}
void Scene::initialize()
{
Source* s1 = new Source(Point(SWIDTH / 2, SHEIGHT / 2, SDEPTH / 2), Intensity(5000), 10.0);
Source* s2 = new Source(Point(SWIDTH * 0.5, -SHEIGHT * 1.1, -SDEPTH * 0.6), Intensity(10000, 20000, 60000), 50);
Source* s3 = new Source(Point(-SWIDTH * 0.5, 0, -SDEPTH * 0.3), Intensity(20000, 4000, 2000), 50);
sources.append(s1);
//sources.append(s2);
//sources.append(s3);
camera = new Camera(Point(SWIDTH * 0.5, SHEIGHT * 0.5, -SDEPTH * 0.3 - CDEPTH));
camera->rotateZ(-0.1);
}
RNScalar R3PointLight::
IntensityAtPoint(const R3Point& point) const
{
// Return intensity at point
RNLength d = R3Distance(point, position);
RNScalar denom = constant_attenuation;
denom += d * linear_attenuation;
denom += d * d * quadratic_attenuation;
if (RNIsZero(denom)) return Intensity();
else return (Intensity() / denom);
}
RNScalar R3PointLight::
RadiusOfInfluence(RNScalar intensity_threshhold) const
{
// Return distance beyond which intensity is below threshold
// kq*d^2 + kl*d + (kc - 1/a) = 0 (use quadratic formula)
if (RNIsZero(Intensity())) return 0.0;
if (RNIsZero(intensity_threshhold)) return RN_INFINITY;
RNScalar A = quadratic_attenuation;
RNScalar B = linear_attenuation;
RNScalar C = constant_attenuation - Intensity() / intensity_threshhold;
RNScalar radius = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A);
return radius;
}
void ColorScreening(IplImage *src, IplImage *dst)
{
for (int i = 0; i < src->height; i++) {
uchar* srcp = (uchar*)(src->imageData + i*src->widthStep);
uchar* dstp = (uchar*)(dst->imageData + i*src->widthStep);
for (int j = 0; j < src->width; j++) {
unsigned int b = srcp[3*j];
unsigned int g = srcp[3*j+1];
unsigned int r = srcp[3*j+2];
unsigned int hue = Hue(r, g, b);
float sat = Saturation(r, g, b);
unsigned int ins = Intensity(r, g, b);
//printf("src: %d %d %d\n", r, g, b);
//printf("cal: %d %f %d\n", hue, sat, ins);
if (((hue >= H_MIN1 && hue <= H_MAX1) || (hue >= H_MIN2 && hue <= H_MAX2)) && sat >= S_THRESHOLD && ins >= I_THRESHOLD){
dstp[3*j] = 0;
dstp[3*j+1] = 0;
dstp[3*j+2] = r;
//printf("sto: %d %d %d\n", dstp[3*j], dstp[3*j+1], dstp[3*j+2]);
} else {
dstp[3*j] = 0;
dstp[3*j+1] = 0;
dstp[3*j+2] = 0;
//printf("sto: %d %d %d\n", dstp[3*j], dstp[3*j+1], dstp[3*j+2]);
}
}
}
}
RNScalar R3DirectionalLight::
IntensityAtPoint(const R3Point& point) const
{
// Return intensity at point
if (!IsActive()) return 0.0;
return Intensity();
}
RNRgb R3DirectionalLight::
Reflection(const R3Brdf& brdf, const R3Point& eye,
const R3Point& point, const R3Vector& normal) const
{
// Check if light is active
if (!IsActive()) return RNblack_rgb;
// Get material properties
const RNRgb& Dc = brdf.Diffuse();
const RNRgb& Sc = brdf.Specular();
RNScalar s = brdf.Shininess();
// Get light properties
RNScalar I = Intensity();
R3Vector L = -(Direction());
const RNRgb& Ic = Color();
// Compute geometric stuff
RNScalar NL = normal.Dot(L);
if (RNIsNegativeOrZero(NL)) return RNblack_rgb;
R3Vector R = (2.0 * NL) * normal - L;
R3Vector V = eye - point;
V.Normalize();
RNScalar VR = V.Dot(R);
// Compute diffuse reflection
RNRgb rgb = (I * NL) * Dc * Ic;
// Compute specular reflection
if (RNIsPositive(VR)) rgb += (I * pow(VR,s)) * Sc * Ic;
// Return total reflection
return rgb;
}
R3Sphere R3DirectionalLight::
SphereOfInfluence(RNScalar intensity_threshold) const
{
// Return sphere within which light intensity is above threshhold
if (Intensity() > intensity_threshold) return R3infinite_sphere;
else return R3null_sphere;
}
RNScalar R3DirectionalLight::
RadiusOfInfluence(RNScalar intensity_threshold) const
{
// Return distance beyond which intensity is below threshold
if (!IsActive()) return 0.0;
if (Intensity() > intensity_threshold) return RN_INFINITY;
else return 0.0;
}
const void Experiment::printEx(int aufloesungsSchritte){
double alpha = -minima;
ofstream myfile;
myfile.open("Intensity.txt");
myfile << "# alpha | Intensity\n";
for(int i=0;i<2*aufloesungsSchritte;i++){
alpha += minima/aufloesungsSchritte;
myfile << alpha << "\t" << Intensity(alpha,elec.Lambda()) << "\n";
} // end for
myfile.close();
}
Material::Material (const Scene* const scene) : m_name("default")
{
float coeff[3] = { 1.0, 1.0, 1.0 };
m_scene = scene;
m_Kss = 0;
m_Ka = Intensity (coeff);
m_diffuseTexture = -1;
}
void R3DirectionalLight::
Draw(int i) const
{
// Draw light
GLenum index = (GLenum) (GL_LIGHT0 + i);
if (index > GL_LIGHT7) return;
GLfloat buffer[4];
buffer[0] = Intensity() * Color().R();
buffer[1] = Intensity() * Color().G();
buffer[2] = Intensity() * Color().B();
buffer[3] = 1.0;
glLightfv(index, GL_DIFFUSE, buffer);
glLightfv(index, GL_SPECULAR, buffer);
buffer[0] = -(Direction().X());
buffer[1] = -(Direction().Y());
buffer[2] = -(Direction().Z());
buffer[3] = 0.0;
glLightfv(index, GL_POSITION, buffer);
buffer[0] = 180.0;
glLightf(index, GL_SPOT_CUTOFF, buffer[0]);
glEnable(index);
}
Material::Material ( const Scene* const scene, const string& name,
float *const ambientCoefficients,
float *const diffuseCoefficients,
float *const specularCoefficients,
float specularExponent, int tex) : m_name(name)
{
m_scene = scene;
m_Kss = specularExponent;
if (ambientCoefficients != NULL)
{
m_Ka = Intensity (ambientCoefficients);
}
if (diffuseCoefficients != NULL)
{
m_Kd = Intensity (diffuseCoefficients);
}
if (specularCoefficients != NULL)
{
m_Ks = Intensity (specularCoefficients);
}
m_Kss = specularExponent;
m_diffuseTexture = tex;
}
/* Initialise the Maxim driver(s) */
void HCMAX7219::Init(void)
{
byte DriverIndex;
for (DriverIndex = 0; DriverIndex < NUMBEROFDRIVERS; DriverIndex++)
{
Write(MAX7219DECODE, 0,DriverIndex);
Intensity(0x0F, DriverIndex);
SevenSegDigits(7, DriverIndex);
TestMode(TESTMODEOFF, DriverIndex);
Shutdown(MAX7219ON, DriverIndex);
Clear();
Refresh();
}
}
RNRgb R3DirectionalLight::
DiffuseReflection(const R3Brdf& brdf,
const R3Point& point, const R3Vector& normal) const
{
// Check if light is active
if (!IsActive()) return RNblack_rgb;
// Get material properties
const RNRgb& Dc = brdf.Diffuse();
// Get light properties
const RNRgb& Ic = Color();
RNScalar I = Intensity();
R3Vector L = -(Direction());
// Compute geometric stuff
RNScalar NL = normal.Dot(L);
if (RNIsNegativeOrZero(NL)) return RNblack_rgb;
// Return diffuse component of reflection
return (I * NL) * Dc * Ic;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% N o r m a l i z e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method NormalizeImage normalizes the pixel values to span the full
% range of color values. This is a contrast enhancement technique.
%
% The format of the NormalizeImage method is:
%
% void NormalizeImage(Image *image)
%
% A description of each parameter follows:
%
% o image: The address of a structure of type Image; returned from
% ReadImage.
%
%
*/
Export void NormalizeImage(Image *image)
{
#define NormalizeImageText " Normalizing image... "
int
*histogram,
threshold_intensity,
y;
Quantum
gray_value,
*normalize_map;
register int
i,
intensity,
x;
register PixelPacket
*p,
*q;
unsigned int
high,
low;
/*
Allocate histogram and normalize map.
*/
assert(image != (Image *) NULL);
histogram=(int *) AllocateMemory((MaxRGB+1)*sizeof(int));
normalize_map=(Quantum *) AllocateMemory((MaxRGB+1)*sizeof(Quantum));
if ((histogram == (int *) NULL) || (normalize_map == (Quantum *) NULL))
{
MagickWarning(ResourceLimitWarning,"Unable to normalize image",
"Memory allocation failed");
return;
}
/*
Form histogram.
*/
for (i=0; i <= MaxRGB; i++)
histogram[i]=0;
for (y=0; y < (int) image->rows; y++)
{
p=GetPixelCache(image,0,y,image->columns,1);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
{
gray_value=Intensity(*p);
histogram[gray_value]++;
p++;
}
}
/*
Find the histogram boundaries by locating the 1 percent levels.
*/
threshold_intensity=(image->columns*image->rows)/100;
intensity=0;
for (low=0; low < MaxRGB; low++)
{
intensity+=histogram[low];
if (intensity > threshold_intensity)
break;
}
intensity=0;
for (high=MaxRGB; high != 0; high--)
{
intensity+=histogram[high];
if (intensity > threshold_intensity)
break;
}
if (low == high)
{
/*
Unreasonable contrast; use zero threshold to determine boundaries.
*/
threshold_intensity=0;
intensity=0;
for (low=0; low < MaxRGB; low++)
{
intensity+=histogram[low];
if (intensity > threshold_intensity)
break;
}
intensity=0;
for (high=MaxRGB; high != 0; high--)
{
intensity+=histogram[high];
if (intensity > threshold_intensity)
break;
}
if (low == high)
return; /* zero span bound */
}
/*
Stretch the histogram to create the normalized image mapping.
*/
for (i=0; i <= MaxRGB; i++)
if (i < (int) low)
normalize_map[i]=0;
else
if (i > (int) high)
normalize_map[i]=MaxRGB;
else
normalize_map[i]=(MaxRGB-1)*(i-low)/(high-low);
/*
Normalize the image.
*/
switch (image->class)
{
case DirectClass:
default:
{
/*
Normalize DirectClass image.
*/
for (y=0; y < (int) image->rows; y++)
{
q=GetPixelCache(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
{
q->red=normalize_map[q->red];
q->green=normalize_map[q->green];
q->blue=normalize_map[q->blue];
q++;
}
if (!SyncPixelCache(image))
break;
if (QuantumTick(y,image->rows))
ProgressMonitor(NormalizeImageText,y,image->rows);
}
break;
}
case PseudoClass:
{
/*
Normalize PseudoClass image.
*/
for (i=0; i < (int) image->colors; i++)
{
image->colormap[i].red=normalize_map[image->colormap[i].red];
image->colormap[i].green=normalize_map[image->colormap[i].green];
image->colormap[i].blue=normalize_map[image->colormap[i].blue];
}
SyncImage(image);
break;
}
}
FreeMemory(normalize_map);
FreeMemory(histogram);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% E q u a l i z e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method EqualizeImage performs histogram equalization on the reference
% image.
%
% The format of the EqualizeImage method is:
%
% void EqualizeImage(Image *image)
%
% A description of each parameter follows:
%
% o image: The address of a structure of type Image; returned from
% ReadImage.
%
%
*/
Export void EqualizeImage(Image *image)
{
#define EqualizeImageText " Equalizing image... "
int
j,
y;
Quantum
*equalize_map;
register int
i,
x;
register PixelPacket
*p,
*q;
unsigned int
high,
*histogram,
low,
*map;
/*
Allocate and initialize histogram arrays.
*/
assert(image != (Image *) NULL);
histogram=(unsigned int *) AllocateMemory((MaxRGB+1)*sizeof(unsigned int));
map=(unsigned int *) AllocateMemory((MaxRGB+1)*sizeof(unsigned int));
equalize_map=(Quantum *) AllocateMemory((MaxRGB+1)*sizeof(Quantum));
if ((histogram == (unsigned int *) NULL) || (map == (unsigned int *) NULL) ||
(equalize_map == (Quantum *) NULL))
{
MagickWarning(ResourceLimitWarning,"Unable to equalize image",
"Memory allocation failed");
return;
}
/*
Form histogram.
*/
for (i=0; i <= MaxRGB; i++)
histogram[i]=0;
for (y=0; y < (int) image->rows; y++)
{
p=GetPixelCache(image,0,y,image->columns,1);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
{
histogram[Intensity(*p)]++;
p++;
}
}
/*
Integrate the histogram to get the equalization map.
*/
j=0;
for (i=0; i <= MaxRGB; i++)
{
j+=histogram[i];
map[i]=j;
}
FreeMemory(histogram);
if (map[MaxRGB] == 0)
{
FreeMemory(equalize_map);
FreeMemory(map);
return;
}
/*
Equalize.
*/
low=map[0];
high=map[MaxRGB];
for (i=0; i <= MaxRGB; i++)
equalize_map[i]=(Quantum)
((((double) (map[i]-low))*MaxRGB)/Max(high-low,1));
FreeMemory(map);
/*
Stretch the histogram.
*/
switch (image->class)
{
case DirectClass:
default:
{
/*
Equalize DirectClass packets.
*/
for (y=0; y < (int) image->rows; y++)
{
q=GetPixelCache(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
{
q->red=equalize_map[q->red];
q->green=equalize_map[q->green];
q->blue=equalize_map[q->blue];
q++;
}
if (!SyncPixelCache(image))
break;
if (QuantumTick(y,image->rows))
ProgressMonitor(EqualizeImageText,y,image->rows);
}
break;
}
case PseudoClass:
{
/*
Equalize PseudoClass packets.
*/
for (i=0; i < (int) image->colors; i++)
{
image->colormap[i].red=equalize_map[image->colormap[i].red];
image->colormap[i].green=equalize_map[image->colormap[i].green];
image->colormap[i].blue=equalize_map[image->colormap[i].blue];
}
SyncImage(image);
break;
}
}
FreeMemory(equalize_map);
}
void ON_Light::Dump( ON_TextLog& dump ) const
{
ON_BOOL32 bDumpDir = false;
ON_BOOL32 bDumpLength = false;
ON_BOOL32 bDumpWidth = false;
const char* sStyle = "unknown";
switch(Style())
{
//case ON::view_directional_light:
// sStyle = "view_directional_light";
// bDumpDir = true;
// break;
//case ON::view_point_light:
// sStyle = "view_point_light";
// break;
//case ON::view_spot_light:
// sStyle = "view_spot_light";
// bDumpDir = true;
// break;
case ON::camera_directional_light:
sStyle = "camera_directional_light";
bDumpDir = true;
break;
case ON::camera_point_light:
sStyle = "camera_point_light";
break;
case ON::camera_spot_light:
sStyle = "camera_spot_light";
bDumpDir = true;
break;
case ON::world_directional_light:
sStyle = "world_directional_light";
bDumpDir = true;
break;
case ON::world_point_light:
sStyle = "world_point_light";
break;
case ON::world_spot_light:
sStyle = "world_spot_light";
bDumpDir = true;
break;
case ON::world_linear_light:
sStyle = "linear_light";
bDumpDir = true;
bDumpLength = true;
break;
case ON::world_rectangular_light:
sStyle = "rectangular_light";
bDumpDir = true;
bDumpLength = true;
bDumpWidth = true;
break;
case ON::ambient_light:
sStyle = "ambient_light";
break;
case ON::unknown_light_style:
sStyle = "unknown";
break;
default:
sStyle = "unknown";
break;
}
dump.Print("index = %d style = %s\n",LightIndex(),sStyle);
dump.Print("location = "); dump.Print(Location()); dump.Print("\n");
if ( bDumpDir )
dump.Print("direction = "); dump.Print(Direction()); dump.Print("\n");
if ( bDumpLength )
dump.Print("length = "); dump.Print(Length()); dump.Print("\n");
if ( bDumpWidth )
dump.Print("width = "); dump.Print(Width()); dump.Print("\n");
dump.Print("intensity = %g%%\n",Intensity()*100.0);
dump.Print("ambient rgb = "); dump.PrintRGB(Ambient()); dump.Print("\n");
dump.Print("diffuse rgb = "); dump.PrintRGB(Diffuse()); dump.Print("\n");
dump.Print("specular rgb = "); dump.PrintRGB(Specular()); dump.Print("\n");
dump.Print("spot angle = %g degrees\n",SpotAngleDegrees());
}
int CLightManager::Add (CSegFace* faceP, tRgbaColorf *colorP, fix xBrightness, short nSegment,
short nSide, short nObject, short nTexture, CFixVector *vPos, ubyte bAmbient)
{
CDynLight* pl;
short h, i;
float fBrightness = X2F (xBrightness);
#if USE_OGL_LIGHTS
GLint nMaxLights;
#endif
#if 0
if (xBrightness > I2X (1))
xBrightness = I2X (1);
#endif
if (fBrightness <= 0)
return -1;
#if DBG
if ((nDbgSeg >= 0) && (nSegment == nDbgSeg))
nSegment = nSegment;
if ((nDbgObj >= 0) && (nObject == nDbgObj))
nDbgObj = nDbgObj;
if (colorP && ((colorP->red > 1) || (colorP->green > 1) || (colorP->blue > 1)))
colorP = colorP;
#endif
if (gameStates.render.nLightingMethod && (nSegment >= 0) && (nSide >= 0)) {
#if 1
fBrightness /= Intensity (colorP->red, colorP->green, colorP->blue);
#else
if (fBrightness < 1)
fBrightness = (float) sqrt (fBrightness);
else
fBrightness *= fBrightness;
#endif
}
if (colorP)
colorP->alpha = 1.0f;
if (0 <= (h = Update (colorP, fBrightness, nSegment, nSide, nObject)))
return h;
if (!colorP)
return -1;
if ((colorP->red == 0.0f) && (colorP->green == 0.0f) && (colorP->blue == 0.0f)) {
if (gameStates.app.bD2XLevel && gameStates.render.bColored)
return -1;
colorP->red = colorP->green = colorP->blue = 1.0f;
}
if (m_data.nLights [0] >= MAX_OGL_LIGHTS) {
gameStates.render.bHaveDynLights = 0;
return -1; //too many lights
}
i = m_data.nLights [0]; //LastEnabledDynLight () + 1;
pl = m_data.lights + i;
pl->info.faceP = faceP;
pl->info.nSegment = nSegment;
pl->info.nSide = nSide;
pl->info.nObject = nObject;
pl->info.nPlayer = -1;
pl->info.bState = 1;
pl->info.bSpot = 0;
pl->info.fBoost = 0;
pl->info.bPowerup = 0;
pl->info.bAmbient = bAmbient;
//0: static light
//2: object/lightning
//3: headlight
if (nObject >= 0) {
CObject *objP = OBJECTS + nObject;
//HUDMessage (0, "Adding object light %d, type %d", m_data.nLights [0], objP->info.nType);
pl->info.nType = 2;
if (objP->info.nType == OBJ_POWERUP) {
int id = objP->info.nId;
if ((id == POW_EXTRA_LIFE) || (id == POW_ENERGY) || (id == POW_SHIELD_BOOST) ||
(id == POW_HOARD_ORB) || (id == POW_MONSTERBALL) || (id == POW_INVUL))
pl->info.bPowerup = 1;
else
pl->info.bPowerup = 2;
}
pl->info.vPos = objP->info.position.vPos;
pl->info.fRad = 0; //X2F (OBJECTS [nObject].size) / 2;
if (fBrightness > 1) {
if ((objP->info.nType == OBJ_FIREBALL) || (objP->info.nType == OBJ_EXPLOSION)) {
pl->info.fBoost = 1;
pl->info.fRad = fBrightness;
}
else if ((objP->info.nType == OBJ_WEAPON) && (objP->info.nId == FLARE_ID)) {
pl->info.fBoost = 1;
pl->info.fRad = 2 * fBrightness;
}
}
m_data.owners [nObject] = m_data.nLights [0];
}
else if (nSegment >= 0) {
#if 0
CFixVector vOffs;
CSide *sideP = SEGMENTS [nSegment].m_sides + nSide;
#endif
if (nSide < 0) {
pl->info.nType = 2;
pl->info.bVariable = 0;
pl->info.fRad = 0;
if (vPos)
pl->info.vPos = *vPos;
else
pl->info.vPos = SEGMENTS [nSegment].Center ();
}
else {
#if DBG
if ((nSegment == nDbgSeg) && ((nDbgSide < 0) || (nSide == nDbgSide)))
nDbgSeg = nDbgSeg;
#endif
pl->info.nType = 0;
pl->info.fRad = faceP ? faceP->fRads [1] / 2.0f : 0;
//RegisterLight (NULL, nSegment, nSide);
pl->info.bVariable = IsDestructible (nTexture) || IsFlickering (nSegment, nSide) || IsTriggered (nSegment, nSide) ||
SEGMENTS [nSegment].Side (nSide)->IsVolatile ();
m_data.nVariable += pl->info.bVariable;
CSide* sideP = SEGMENTS [nSegment].m_sides + nSide;
pl->info.vPos = sideP->Center ();
CFixVector vOffs = CFixVector::Avg (sideP->m_normals [0], sideP->m_normals [1]);
pl->info.vDirf.Assign (vOffs);
CFloatVector::Normalize (pl->info.vDirf);
#if 0
if (gameStates.render.bPerPixelLighting) {
vOffs *= I2X (1) / 64;
pl->info.vPos += vOffs;
}
#endif
}
}
else {
pl->info.nType = 3;
pl->info.bVariable = 0;
}
#if 0
PrintLog ("adding light %d,%d\n", m_data.nLights [0], pl - m_data.lights [0]);
#endif
pl->info.bOn = 1;
pl->bTransform = 1;
SetColor (m_data.nLights [0], colorP->red, colorP->green, colorP->blue, fBrightness);
return m_data.nLights [0]++;
}
RNScalar R3DirectionalLight::
IntensityAtPoint(const R3Point& ) const
{
// Return intensity at point
return Intensity();
}
