summaryrefslogtreecommitdiffhomepage
path: root/nGenEx/Polygon.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'nGenEx/Polygon.cpp')
-rw-r--r--nGenEx/Polygon.cpp764
1 files changed, 764 insertions, 0 deletions
diff --git a/nGenEx/Polygon.cpp b/nGenEx/Polygon.cpp
new file mode 100644
index 0000000..3eefe87
--- /dev/null
+++ b/nGenEx/Polygon.cpp
@@ -0,0 +1,764 @@
+/* Starshatter OpenSource Distribution
+ Copyright (c) 1997-2004, Destroyer Studios LLC.
+ All Rights Reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ * Neither the name "Destroyer Studios" nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ SUBSYSTEM: nGenEx.lib
+ FILE: Polygon.cpp
+ AUTHOR: John DiCamillo
+
+
+ OVERVIEW
+ ========
+ Polygon and VertexSet structures for 3D rendering
+*/
+
+#include "MemDebug.h"
+#include "Polygon.h"
+#include "Bitmap.h"
+
+// +--------------------------------------------------------------------+
+
+VertexSet::VertexSet(int m)
+ : nverts(0), space(OBJECT_SPACE), tu1(0), tv1(0), tangent(0), binormal(0)
+{
+ Resize(m);
+}
+
+// +--------------------------------------------------------------------+
+
+VertexSet::~VertexSet()
+{
+ Delete();
+}
+
+// +--------------------------------------------------------------------+
+
+void
+VertexSet::Resize(int m, bool preserve)
+{
+ // easy cases (no data will be preserved):
+ if (!m || !nverts || !preserve) {
+ bool additional_tex_coords = (tu1 != 0);
+
+ Delete();
+
+ nverts = m;
+
+ if (nverts <= 0) {
+ ZeroMemory(this, sizeof(VertexSet));
+ }
+
+ else {
+ loc = new(__FILE__,__LINE__) Vec3[nverts];
+ nrm = new(__FILE__,__LINE__) Vec3[nverts];
+ s_loc = new(__FILE__,__LINE__) Vec3[nverts];
+ tu = new(__FILE__,__LINE__) float[nverts];
+ tv = new(__FILE__,__LINE__) float[nverts];
+ rw = new(__FILE__,__LINE__) float[nverts];
+ diffuse = new(__FILE__,__LINE__) DWORD[nverts];
+ specular = new(__FILE__,__LINE__) DWORD[nverts];
+
+ if (additional_tex_coords)
+ CreateAdditionalTexCoords();
+
+ if (!loc || !nrm || !s_loc || !rw || !tu || !tv || !diffuse || !specular) {
+ nverts = 0;
+
+ delete [] loc;
+ delete [] nrm;
+ delete [] s_loc;
+ delete [] rw;
+ delete [] tu;
+ delete [] tv;
+ delete [] tu1;
+ delete [] tv1;
+ delete [] diffuse;
+ delete [] specular;
+
+ ZeroMemory(this, sizeof(VertexSet));
+ }
+ }
+ }
+
+ // actually need to copy data:
+ else {
+ int np = nverts;
+
+ nverts = m;
+
+ if (nverts < np)
+ np = nverts;
+
+ Vec3* new_loc = new(__FILE__,__LINE__) Vec3[nverts];
+ Vec3* new_nrm = new(__FILE__,__LINE__) Vec3[nverts];
+ Vec3* new_s_loc = new(__FILE__,__LINE__) Vec3[nverts];
+ float* new_rw = new(__FILE__,__LINE__) float[nverts];
+ float* new_tu = new(__FILE__,__LINE__) float[nverts];
+ float* new_tv = new(__FILE__,__LINE__) float[nverts];
+ float* new_tu1 = 0;
+ float* new_tv1 = 0;
+ DWORD* new_diffuse = new(__FILE__,__LINE__) DWORD[nverts];
+ DWORD* new_specular = new(__FILE__,__LINE__) DWORD[nverts];
+
+ if (tu1)
+ new_tu1 = new(__FILE__,__LINE__) float[nverts];
+
+ if (tv1)
+ new_tv1 = new(__FILE__,__LINE__) float[nverts];
+
+ if (new_loc) {
+ CopyMemory(new_loc, loc, np * sizeof(Vec3));
+ delete [] loc;
+ loc = new_loc;
+ }
+
+ if (new_nrm) {
+ CopyMemory(new_nrm, nrm, np * sizeof(Vec3));
+ delete [] nrm;
+ nrm = new_nrm;
+ }
+
+ if (new_s_loc) {
+ CopyMemory(new_s_loc, s_loc, np * sizeof(Vec3));
+ delete [] s_loc;
+ s_loc = new_s_loc;
+ }
+
+ if (new_tu) {
+ CopyMemory(new_tu, tu, np * sizeof(float));
+ delete [] tu;
+ tu = new_tu;
+ }
+
+ if (new_tv) {
+ CopyMemory(new_tv, tv, np * sizeof(float));
+ delete [] tv;
+ tv = new_tv;
+ }
+
+ if (new_tu1) {
+ CopyMemory(new_tu1, tu1, np * sizeof(float));
+ delete [] tu1;
+ tu = new_tu1;
+ }
+
+ if (new_tv1) {
+ CopyMemory(new_tv1, tv1, np * sizeof(float));
+ delete [] tv1;
+ tv = new_tv1;
+ }
+
+ if (new_diffuse) {
+ CopyMemory(new_diffuse, diffuse, np * sizeof(DWORD));
+ delete [] diffuse;
+ diffuse = new_diffuse;
+ }
+
+ if (new_specular) {
+ CopyMemory(new_specular, specular, np * sizeof(DWORD));
+ delete [] specular;
+ specular = new_specular;
+ }
+
+ if (!loc || !nrm || !s_loc || !rw || !tu || !tv || !diffuse || !specular) {
+ Delete();
+ ZeroMemory(this, sizeof(VertexSet));
+ }
+ }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+VertexSet::Delete()
+{
+ if (nverts) {
+ delete [] loc;
+ delete [] nrm;
+ delete [] s_loc;
+ delete [] rw;
+ delete [] tu;
+ delete [] tv;
+ delete [] tu1;
+ delete [] tv1;
+ delete [] diffuse;
+ delete [] specular;
+ delete [] tangent;
+ delete [] binormal;
+
+ tangent = 0;
+ binormal = 0;
+ }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+VertexSet::Clear()
+{
+ if (nverts) {
+ ZeroMemory(loc, sizeof(Vec3) * nverts);
+ ZeroMemory(nrm, sizeof(Vec3) * nverts);
+ ZeroMemory(s_loc, sizeof(Vec3) * nverts);
+ ZeroMemory(tu, sizeof(float) * nverts);
+ ZeroMemory(tv, sizeof(float) * nverts);
+ ZeroMemory(rw, sizeof(float) * nverts);
+ ZeroMemory(diffuse, sizeof(DWORD) * nverts);
+ ZeroMemory(specular, sizeof(DWORD) * nverts);
+
+ if (tu1)
+ ZeroMemory(tu1, sizeof(float) * nverts);
+
+ if (tv1)
+ ZeroMemory(tv1, sizeof(float) * nverts);
+
+ if (tangent)
+ ZeroMemory(tangent, sizeof(Vec3) * nverts);
+
+ if (binormal)
+ ZeroMemory(binormal, sizeof(Vec3) * nverts);
+ }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+VertexSet::CreateTangents()
+{
+ if (tangent) delete [] tangent;
+ if (binormal) delete [] binormal;
+
+ tangent = 0;
+ binormal = 0;
+
+ if (nverts) {
+ tangent = new(__FILE__,__LINE__) Vec3[nverts];
+ binormal = new(__FILE__,__LINE__) Vec3[nverts];
+ }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+VertexSet::CreateAdditionalTexCoords()
+{
+ if (tu1) delete [] tu1;
+ if (tv1) delete [] tv1;
+
+ tu1 = 0;
+ tv1 = 0;
+
+ if (nverts) {
+ tu1 = new(__FILE__,__LINE__) float[nverts];
+ tv1 = new(__FILE__,__LINE__) float[nverts];
+ }
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+VertexSet::CopyVertex(int dst, int src)
+{
+ if (src >= 0 && src < nverts && dst >= 0 && dst < nverts) {
+ loc[dst] = loc[src];
+ nrm[dst] = nrm[src];
+ s_loc[dst] = s_loc[src];
+ tu[dst] = tu[src];
+ tv[dst] = tv[src];
+ diffuse[dst] = diffuse[src];
+ specular[dst] = specular[src];
+
+ if (tu1)
+ tu1[dst] = tu1[src];
+
+ if (tv1)
+ tv1[dst] = tv1[src];
+
+ if (tangent)
+ tangent[dst] = tangent[src];
+
+ if (binormal)
+ binormal[dst] = binormal[src];
+
+ return true;
+ }
+
+ return false;
+}
+
+VertexSet*
+VertexSet::Clone() const
+{
+ VertexSet* result = new(__FILE__,__LINE__) VertexSet(nverts);
+
+ CopyMemory(result->loc, loc, nverts * sizeof(Vec3));
+ CopyMemory(result->nrm, nrm, nverts * sizeof(Vec3));
+ CopyMemory(result->s_loc, s_loc, nverts * sizeof(Vec3));
+ CopyMemory(result->rw, rw, nverts * sizeof(float));
+ CopyMemory(result->tu, tu, nverts * sizeof(float));
+ CopyMemory(result->tv, tv, nverts * sizeof(float));
+ CopyMemory(result->diffuse, diffuse, nverts * sizeof(DWORD));
+ CopyMemory(result->specular, specular, nverts * sizeof(DWORD));
+
+ if (tu1) {
+ if (!result->tu1)
+ result->tu1 = new(__FILE__,__LINE__) float[nverts];
+
+ CopyMemory(result->tu1, tu1, nverts * sizeof(float));
+ }
+
+ if (tv1) {
+ if (!result->tv1)
+ result->tv1 = new(__FILE__,__LINE__) float[nverts];
+
+ CopyMemory(result->tv1, tv1, nverts * sizeof(float));
+ }
+
+ if (tangent) {
+ if (!result->tangent)
+ result->tangent = new(__FILE__,__LINE__) Vec3[nverts];
+
+ CopyMemory(result->tangent, tangent, nverts * sizeof(Vec3));
+ }
+
+ if (binormal) {
+ if (!result->binormal)
+ result->binormal = new(__FILE__,__LINE__) Vec3[nverts];
+
+ CopyMemory(result->binormal, binormal, nverts * sizeof(Vec3));
+ }
+
+ return result;
+}
+
+void
+VertexSet::CalcExtents(Point& plus, Point& minus)
+{
+ plus = Point(-1e6, -1e6, -1e6);
+ minus = Point( 1e6, 1e6, 1e6);
+
+ for (int i = 0; i < nverts; i++) {
+ if (loc[i].x > plus.x) plus.x = loc[i].x;
+ if (loc[i].x < minus.x) minus.x = loc[i].x;
+ if (loc[i].y > plus.y) plus.y = loc[i].y;
+ if (loc[i].y < minus.y) minus.y = loc[i].y;
+ if (loc[i].z > plus.z) plus.z = loc[i].z;
+ if (loc[i].z < minus.z) minus.z = loc[i].z;
+ }
+}
+
+// +--------------------------------------------------------------------+
+// +--------------------------------------------------------------------+
+// +--------------------------------------------------------------------+
+
+Poly::Poly(int init)
+ : nverts(0), visible(1), material(0), vertex_set(0), sortval(0), flatness(0)
+{ }
+
+// +--------------------------------------------------------------------+
+// Check to see if a test point is within the bounds of the poly.
+// The point is assumed to be coplanar with the poly. Return 1 if
+// the point is inside, 0 if the point is outside.
+
+Vec2 projverts[Poly::MAX_VERTS];
+
+static inline double extent3(double a, double b, double c)
+{
+ double d1 = fabs(a-b);
+ double d2 = fabs(a-c);
+ double d3 = fabs(b-c);
+
+ if (d1 > d2) {
+ if (d1 > d3)
+ return d1;
+ else
+ return d3;
+ }
+ else {
+ if (d2 > d3)
+ return d2;
+ else
+ return d3;
+ }
+}
+
+int Poly::Contains(const Vec3& pt) const
+{
+ // find largest 2d projection of this 3d Poly:
+ int projaxis;
+
+ double pnx = fabs(plane.normal.x);
+ double pny = fabs(plane.normal.y);
+ double pnz = fabs(plane.normal.z);
+
+ if (pnx > pny)
+ if (pnx > pnz)
+ if (plane.normal.x > 0)
+ projaxis = 1;
+ else
+ projaxis = -1;
+ else
+ if (plane.normal.z > 0)
+ projaxis = 3;
+ else
+ projaxis = -3;
+ else
+ if (pny > pnz)
+ if (plane.normal.y > 0)
+ projaxis = 2;
+ else
+ projaxis = -2;
+ else
+ if (plane.normal.z > 0)
+ projaxis = 3;
+ else
+ projaxis = -3;
+
+ int i;
+
+ for (i = 0; i < nverts; i++) {
+ Vec3 loc = vertex_set->loc[verts[i]];
+ switch (projaxis) {
+ case 1: projverts[i] = Vec2(loc.y, loc.z); break;
+ case -1: projverts[i] = Vec2(loc.z, loc.y); break;
+ case 2: projverts[i] = Vec2(loc.z, loc.x); break;
+ case -2: projverts[i] = Vec2(loc.x, loc.z); break;
+ case 3: projverts[i] = Vec2(loc.x, loc.y); break;
+ case -3: projverts[i] = Vec2(loc.y, loc.x); break;
+ }
+ }
+
+ // now project the test point into the same plane:
+ Vec2 test;
+ switch (projaxis) {
+ case 1: test.x = pt.y; test.y = pt.z; break;
+ case -1: test.x = pt.z; test.y = pt.y; break;
+ case 2: test.x = pt.z; test.y = pt.x; break;
+ case -2: test.x = pt.x; test.y = pt.z; break;
+ case 3: test.x = pt.x; test.y = pt.y; break;
+ case -3: test.x = pt.y; test.y = pt.x; break;
+ }
+
+ const float INSIDE_EPSILON = -0.01f;
+
+ // if the test point is outside of any segment,
+ // it is outside the entire convex Poly.
+ for (i = 0; i < nverts-1; i++) {
+ if (verts[i] != verts[i+1]) {
+ Vec2 segment = projverts[i+1] - projverts[i];
+ Vec2 segnorm = segment.normal();
+ Vec2 tdelta = projverts[i] - test;
+ float inside = segnorm * tdelta;
+ if (inside < INSIDE_EPSILON)
+ return 0;
+ }
+ }
+
+ // check last segment, too:
+ if (verts[0] != verts[nverts-1]) {
+ Vec2 segment = projverts[0] - projverts[nverts-1];
+ float inside = segment.normal() * (projverts[0] - test);
+ if (inside < INSIDE_EPSILON)
+ return 0;
+ }
+
+ // still here? must be inside:
+ return 1;
+}
+
+// +--------------------------------------------------------------------+
+// +--------------------------------------------------------------------+
+// +--------------------------------------------------------------------+
+
+Material::Material()
+ : power(1.0f), brilliance(1.0f), bump(0.0f), blend(MTL_SOLID),
+ shadow(true), luminous(false),
+ tex_diffuse(0), tex_specular(0), tex_bumpmap(0), tex_emissive(0),
+ tex_alternate(0), tex_detail(0), thumbnail(0)
+{
+ ZeroMemory(name, sizeof(name));
+ ZeroMemory(shader, sizeof(shader));
+
+ ambient_value = 0.2f;
+ diffuse_value = 1.0f;
+ specular_value = 0.0f;
+ emissive_value = 0.0f;
+}
+
+// +--------------------------------------------------------------------+
+
+Material::~Material()
+{
+ // these objects are owned by the shared
+ // bitmap cache, so don't delete them now:
+ tex_diffuse = 0;
+ tex_specular = 0;
+ tex_bumpmap = 0;
+ tex_emissive = 0;
+ tex_alternate = 0;
+ tex_detail = 0;
+
+ // the thumbnail is unique to the material,
+ // so it is never cached:
+ if (thumbnail)
+ delete thumbnail;
+}
+
+// +--------------------------------------------------------------------+
+
+int
+Material::operator == (const Material& m) const
+{
+ if (this == &m) return 1;
+
+ if (Ka != m.Ka) return 0;
+ if (Kd != m.Kd) return 0;
+ if (Ks != m.Ks) return 0;
+ if (Ke != m.Ke) return 0;
+ if (power != m.power) return 0;
+ if (brilliance != m.brilliance) return 0;
+ if (bump != m.bump) return 0;
+ if (blend != m.blend) return 0;
+ if (shadow != m.shadow) return 0;
+ if (tex_diffuse != m.tex_diffuse) return 0;
+ if (tex_specular != m.tex_specular) return 0;
+ if (tex_bumpmap != m.tex_bumpmap) return 0;
+ if (tex_emissive != m.tex_emissive) return 0;
+ if (tex_alternate != m.tex_alternate) return 0;
+ if (tex_detail != m.tex_detail) return 0;
+
+ return !strcmp(name, m.name);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+Material::Clear()
+{
+ Ka = ColorValue();
+ Kd = ColorValue();
+ Ks = ColorValue();
+ Ke = ColorValue();
+
+ power = 1.0f;
+ bump = 0.0f;
+ blend = MTL_SOLID;
+ shadow = true;
+
+ tex_diffuse = 0;
+ tex_specular = 0;
+ tex_bumpmap = 0;
+ tex_emissive = 0;
+ tex_alternate = 0;
+ tex_detail = 0;
+}
+
+// +--------------------------------------------------------------------+
+
+static char shader_name[Material::NAMELEN];
+
+const char*
+Material::GetShader(int pass) const
+{
+ int level = 0;
+ if (pass > 1) pass--;
+
+ for (int i = 0; i < NAMELEN; i++) {
+ if (shader[i] == '/') {
+ level++;
+
+ if (level > pass)
+ return 0;
+ }
+
+ else if (shader[i] != 0) {
+ if (level == pass) {
+ ZeroMemory(shader_name, NAMELEN);
+
+ char* s = shader_name;
+ while (i < NAMELEN && shader[i] != 0 && shader[i] != '/') {
+ *s++ = shader[i++];
+ }
+
+ return shader_name;
+ }
+ }
+
+ else {
+ return 0;
+ }
+ }
+
+ return 0;
+}
+
+// +--------------------------------------------------------------------+
+
+void
+Material::CreateThumbnail(int size)
+{
+ if (!thumbnail) {
+ thumbnail = new(__FILE__,__LINE__) Bitmap(size, size);
+ }
+
+ if (!thumbnail || thumbnail->Width() != thumbnail->Height())
+ return;
+
+ size = thumbnail->Width();
+
+ DWORD* image = new(__FILE__,__LINE__) DWORD[size*size];
+ DWORD* dst = image;
+
+ for (int j = 0; j < size; j++) {
+ for (int i = 0; i < size; i++) {
+ *dst++ = GetThumbColor(i, j, size);
+ }
+ }
+
+ thumbnail->CopyHighColorImage(size, size, image, Bitmap::BMP_SOLID);
+}
+
+DWORD
+Material::GetThumbColor(int i, int j, int size)
+{
+ Color result = Color::LightGray;
+
+ double x = i - size/2;
+ double y = j - size/2;
+ double r = 0.9 * size/2;
+ double d = sqrt(x*x + y*y);
+
+ if (d <= r) {
+ double z = sqrt(r*r - x*x - y*y);
+
+ Point loc(x,y,z);
+ Point nrm = loc; nrm.Normalize();
+ Point light(1,-1,1); light.Normalize();
+ Point eye(0,0,1);
+
+ ColorValue c = Ka * ColorValue(0.25f, 0.25f, 0.25f); // ambient light
+ ColorValue white(1,1,1);
+
+ double diffuse = nrm*light;
+ double v = 1 - (acos(nrm.y)/PI);
+ double u = asin(nrm.x / sin(acos(nrm.y))) / PI + 0.5;
+
+ ColorValue cd = Kd;
+ ColorValue cs = Ks;
+ ColorValue ce = Ke;
+
+ if (tex_diffuse) {
+ int tu = (int) (u * tex_diffuse->Width());
+ int tv = (int) (v * tex_diffuse->Height());
+ cd = Kd * tex_diffuse->GetColor(tu,tv);
+ }
+
+ if (tex_emissive) {
+ int tu = (int) (u * tex_emissive->Width());
+ int tv = (int) (v * tex_emissive->Height());
+ ce = Ke * tex_emissive->GetColor(tu,tv);
+ }
+
+ if (tex_bumpmap && bump != 0 && nrm.z > 0) {
+ // compute derivatives B(u,v)
+ int tu = (int) (u * tex_bumpmap->Width());
+ int tv = (int) (v * tex_bumpmap->Height());
+
+ DWORD tmpred = tex_bumpmap->GetColor(tu,tv).Red();
+ double du1 = tmpred - tex_bumpmap->GetColor(tu-1,tv).Red();
+ double du2 = tex_bumpmap->GetColor(tu+1,tv).Red() - tmpred;
+
+ double dv1 = tmpred - tex_bumpmap->GetColor(tu,tv-1).Red();
+ double dv2 = tex_bumpmap->GetColor(tu,tv+1).Red() - tmpred;
+
+ double du = (du1 + du2) / 512 * 1e-8;
+ double dv = (dv1 + dv2) / 512 * 1e-8;
+
+ if (du || dv) {
+ Point Nu = nrm.cross(Point(0,-1,0)); Nu.Normalize();
+ Point Nv = nrm.cross(Point(1, 0,0)); Nv.Normalize();
+
+ nrm += (Nu*du*bump);
+ nrm += (Nv*dv*bump);
+ nrm.Normalize();
+
+ diffuse = nrm*light;
+ v = 1 - (acos(nrm.y)/PI);
+ u = asin(nrm.x / sin(acos(nrm.y))) / PI + 0.5;
+ }
+ }
+
+ if (tex_specular) {
+ int tu = (int) (u * tex_specular->Width());
+ int tv = (int) (v * tex_specular->Height());
+ cs = Ks * tex_specular->GetColor(tu,tv);
+ }
+
+ // anisotropic diffuse lighting
+ if (brilliance >= 0) {
+ diffuse = pow(diffuse, (double)brilliance);
+ }
+
+ // forward lighting
+ if (diffuse > 0) {
+ // diffuse
+ c += cd * (white * diffuse);
+
+ // specular
+ if (power > 0) {
+ double spec = ((nrm * 2*(nrm*light) - light) * eye);
+ if (spec > 0.01) {
+ spec = pow(spec, (double)power);
+ c += cs * (white * spec);
+ }
+ }
+ }
+
+ // back lighting
+ else {
+ diffuse *= -0.5;
+ c += cd * (white * diffuse);
+
+ // specular
+ if (power > 0) {
+ light *= -1;
+
+ double spec = ((nrm * 2*(nrm*light) - light) * eye);
+ if (spec > 0.01) {
+ spec = pow(spec, (double)power);
+ c += cs * (white * spec) * 0.7;
+ }
+ }
+ }
+
+ c += ce;
+
+ result = c.ToColor();
+ }
+
+ return result.Value();
+}