From b2805409566af00bc15639494f5a186fbd2f16e6 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Fri, 9 Dec 2011 20:15:42 +0000 Subject: More indenting changes --- nGenEx/Solid.cpp | 3390 +++++++++++++++++++++++++++--------------------------- 1 file changed, 1695 insertions(+), 1695 deletions(-) (limited to 'nGenEx/Solid.cpp') diff --git a/nGenEx/Solid.cpp b/nGenEx/Solid.cpp index b7fa6f0..abc4afd 100644 --- a/nGenEx/Solid.cpp +++ b/nGenEx/Solid.cpp @@ -1,15 +1,15 @@ /* Project nGenEx - Destroyer Studios LLC - Copyright © 1997-2004. All Rights Reserved. + Destroyer Studios LLC + Copyright © 1997-2004. All Rights Reserved. - SUBSYSTEM: nGenEx.lib - FILE: Solid.cpp - AUTHOR: John DiCamillo + SUBSYSTEM: nGenEx.lib + FILE: Solid.cpp + AUTHOR: John DiCamillo - OVERVIEW - ======== - Classes for rendering solid meshes of polygons + OVERVIEW + ======== + Classes for rendering solid meshes of polygons */ #include "MemDebug.h" @@ -42,84 +42,84 @@ Opcode::AABBTreeCollider opcode_collider; class OPCODE_data { public: - OPCODE_data(Surface* s) { - bool status = false; - - if (s) { - using namespace Opcode; - opcode_collider.SetFirstContact(true); - - npolys = s->NumPolys(); - nverts = s->NumVerts(); - ntris = s->NumIndices() / 3; - - locs = new(__FILE__,__LINE__) IcePoint[nverts]; - tris = new(__FILE__,__LINE__) IndexedTriangle[ntris]; - - if (locs && tris) { - int i, n = 0; - - for (i = 0; i < nverts; i++) { - IcePoint* p = locs + i; - Vec3* v = s->GetVertexSet()->loc + i; - - p->Set(v->x, v->y, v->z); - } - - for (i = 0; i < npolys; i++) { - Poly* p = s->GetPolys() + i; - - if (p->nverts == 3) { - IndexedTriangle& t = tris[n++]; - - t.mVRef[0] = p->verts[0]; - t.mVRef[1] = p->verts[2]; - t.mVRef[2] = p->verts[1]; - } - else { - IndexedTriangle& t1 = tris[n++]; - IndexedTriangle& t2 = tris[n++]; - - t1.mVRef[0] = p->verts[0]; - t1.mVRef[1] = p->verts[2]; - t1.mVRef[2] = p->verts[1]; - - t2.mVRef[0] = p->verts[0]; - t2.mVRef[1] = p->verts[3]; - t2.mVRef[2] = p->verts[2]; - } - } - - mesh.SetNbVertices(nverts); - mesh.SetNbTriangles(ntris); - mesh.SetPointers(tris, locs); - - OPCODECREATE creator; - creator.mIMesh = &mesh; - status = model.Build(creator); - } - } - else { - tris = 0; - locs = 0; - npolys = 0; - nverts = 0; - ntris = 0; - } - } - - ~OPCODE_data() { - delete [] tris; - delete [] locs; - } - - Opcode::Model model; - Opcode::MeshInterface mesh; - IndexedTriangle* tris; - IcePoint* locs; - int npolys; - int nverts; - int ntris; + OPCODE_data(Surface* s) { + bool status = false; + + if (s) { + using namespace Opcode; + opcode_collider.SetFirstContact(true); + + npolys = s->NumPolys(); + nverts = s->NumVerts(); + ntris = s->NumIndices() / 3; + + locs = new(__FILE__,__LINE__) IcePoint[nverts]; + tris = new(__FILE__,__LINE__) IndexedTriangle[ntris]; + + if (locs && tris) { + int i, n = 0; + + for (i = 0; i < nverts; i++) { + IcePoint* p = locs + i; + Vec3* v = s->GetVertexSet()->loc + i; + + p->Set(v->x, v->y, v->z); + } + + for (i = 0; i < npolys; i++) { + Poly* p = s->GetPolys() + i; + + if (p->nverts == 3) { + IndexedTriangle& t = tris[n++]; + + t.mVRef[0] = p->verts[0]; + t.mVRef[1] = p->verts[2]; + t.mVRef[2] = p->verts[1]; + } + else { + IndexedTriangle& t1 = tris[n++]; + IndexedTriangle& t2 = tris[n++]; + + t1.mVRef[0] = p->verts[0]; + t1.mVRef[1] = p->verts[2]; + t1.mVRef[2] = p->verts[1]; + + t2.mVRef[0] = p->verts[0]; + t2.mVRef[1] = p->verts[3]; + t2.mVRef[2] = p->verts[2]; + } + } + + mesh.SetNbVertices(nverts); + mesh.SetNbTriangles(ntris); + mesh.SetPointers(tris, locs); + + OPCODECREATE creator; + creator.mIMesh = &mesh; + status = model.Build(creator); + } + } + else { + tris = 0; + locs = 0; + npolys = 0; + nverts = 0; + ntris = 0; + } + } + + ~OPCODE_data() { + delete [] tris; + delete [] locs; + } + + Opcode::Model model; + Opcode::MeshInterface mesh; + IndexedTriangle* tris; + IcePoint* locs; + int npolys; + int nverts; + int ntris; }; // +--------------------------------------------------------------------+ @@ -127,21 +127,21 @@ public: // +--------------------------------------------------------------------+ Solid::Solid() - : model(0), own_model(1), - roll(0.0f), pitch(0.0f), yaw(0.0f), intersection_poly(0) +: model(0), own_model(1), +roll(0.0f), pitch(0.0f), yaw(0.0f), intersection_poly(0) { - shadow = true; - sprintf_s(name, "Solid %d", id); + shadow = true; + sprintf_s(name, "Solid %d", id); } // +--------------------------------------------------------------------+ Solid::~Solid() { - if (own_model) - delete model; + if (own_model) + delete model; - shadows.destroy(); + shadows.destroy(); } // +--------------------------------------------------------------------+ @@ -156,42 +156,42 @@ Solid::Update() void Solid::SetOrientation(const Matrix& o) { - orientation = o; + orientation = o; } void Solid::SetLuminous(bool l) { - luminous = l; + luminous = l; - if (model && luminous) { - model->luminous = luminous; + if (model && luminous) { + model->luminous = luminous; - ListIter iter = model->GetMaterials(); + ListIter iter = model->GetMaterials(); - while (++iter) { - Material* mtl = iter.value(); + while (++iter) { + Material* mtl = iter.value(); - mtl->Ka = Color::Black; - mtl->Kd = Color::Black; - mtl->Ks = Color::Black; - mtl->Ke = Color::White; + mtl->Ka = Color::Black; + mtl->Kd = Color::Black; + mtl->Ks = Color::Black; + mtl->Ke = Color::White; - if (mtl->tex_diffuse && !mtl->tex_emissive) - mtl->tex_emissive = mtl->tex_diffuse; - } + if (mtl->tex_diffuse && !mtl->tex_emissive) + mtl->tex_emissive = mtl->tex_diffuse; + } - ListIter s_iter = model->GetSurfaces(); - while (++s_iter) { - Surface* surface = s_iter.value(); - VertexSet* vset = surface->GetVertexSet(); + ListIter s_iter = model->GetSurfaces(); + while (++s_iter) { + Surface* surface = s_iter.value(); + VertexSet* vset = surface->GetVertexSet(); - for (int i = 0; i < vset->nverts; i++) { - vset->diffuse[i] = Color::White.Value(); - vset->specular[i] = Color::Black.Value(); - } - } - } + for (int i = 0; i < vset->nverts; i++) { + vset->diffuse[i] = Color::White.Value(); + vset->specular[i] = Color::Black.Value(); + } + } + } } // +--------------------------------------------------------------------+ @@ -199,11 +199,11 @@ Solid::SetLuminous(bool l) void Solid::SetOrientation(const Solid& match) { - if (!model || infinite) - return; + if (!model || infinite) + return; - // copy the orientation matrix from the solid we are matching: - orientation = match.Orientation(); + // copy the orientation matrix from the solid we are matching: + orientation = match.Orientation(); } // +--------------------------------------------------------------------+ @@ -211,17 +211,17 @@ Solid::SetOrientation(const Solid& match) void Solid::Render(Video* video, DWORD flags) { - if (flags & RENDER_ADDITIVE) - return; + if (flags & RENDER_ADDITIVE) + return; - if (video && model && model->NumPolys()) { - DWORD blend_modes = Video::BLEND_SOLID; + if (video && model && model->NumPolys()) { + DWORD blend_modes = Video::BLEND_SOLID; - if (flags == RENDER_ALPHA) - blend_modes = Video::BLEND_ALPHA | Video::BLEND_ADDITIVE; + if (flags == RENDER_ALPHA) + blend_modes = Video::BLEND_ALPHA | Video::BLEND_ADDITIVE; - video->DrawSolid(this, blend_modes); - } + video->DrawSolid(this, blend_modes); + } } // +--------------------------------------------------------------------+ @@ -236,51 +236,51 @@ Solid::SelectDetail(Projector* p) void Solid::ProjectScreenRect(Projector* p) { - if (model && p) { - Point tmp = loc; - p->Transform(tmp); + if (model && p) { + Point tmp = loc; + p->Transform(tmp); - if (tmp.z > 1) { - int l = 2000; - int r = -2000; - int t = 2000; - int b = -2000; + if (tmp.z > 1) { + int l = 2000; + int r = -2000; + int t = 2000; + int b = -2000; - for (int i = 0; i < 6; i++) { - Point extent; + for (int i = 0; i < 6; i++) { + Point extent; - if (i < 2) - extent.x = model->extents[i]; + if (i < 2) + extent.x = model->extents[i]; - else if (i < 4) - extent.y = model->extents[i]; + else if (i < 4) + extent.y = model->extents[i]; - else - extent.z = model->extents[i]; + else + extent.z = model->extents[i]; - extent = extent * orientation + loc; + extent = extent * orientation + loc; - p->Transform(extent); - p->Project(extent); + p->Transform(extent); + p->Project(extent); - if (extent.x < l) l = (int) extent.x; - if (extent.x > r) r = (int) extent.x; - if (extent.y < t) t = (int) extent.y; - if (extent.y > b) b = (int) extent.y; - } + if (extent.x < l) l = (int) extent.x; + if (extent.x > r) r = (int) extent.x; + if (extent.y < t) t = (int) extent.y; + if (extent.y > b) b = (int) extent.y; + } - screen_rect.x = l; - screen_rect.y = t; - screen_rect.w = r-l; - screen_rect.h = b-t; - return; - } - } + screen_rect.x = l; + screen_rect.y = t; + screen_rect.w = r-l; + screen_rect.h = b-t; + return; + } + } - screen_rect.x = 2000; - screen_rect.y = 2000; - screen_rect.w = 0; - screen_rect.h = 0; + screen_rect.x = 2000; + screen_rect.y = 2000; + screen_rect.w = 0; + screen_rect.h = 0; } // +--------------------------------------------------------------------+ @@ -289,96 +289,96 @@ Solid::ProjectScreenRect(Projector* p) int Solid::CollidesWith(Graphic& o) { - Vec3 delta_loc = Location() - o.Location(); + Vec3 delta_loc = Location() - o.Location(); - // bounding spheres test: - if (delta_loc.length() > Radius() + o.Radius()) - return 0; + // bounding spheres test: + if (delta_loc.length() > Radius() + o.Radius()) + return 0; - // possible collision, but no further refinement can be done: - if (!o.IsSolid()) - return 1; + // possible collision, but no further refinement can be done: + if (!o.IsSolid()) + return 1; - Solid& s = (Solid&) o; + Solid& s = (Solid&) o; - // use the OPCODE library to check for polygon interference: - if (model && s.model) { - using namespace Opcode; + // use the OPCODE library to check for polygon interference: + if (model && s.model) { + using namespace Opcode; - bool contact = false; + bool contact = false; - // first, reverse the orientation matrices for OPCODE: - Matrix m1 = orientation; - Matrix m2 = s.orientation; + // first, reverse the orientation matrices for OPCODE: + Matrix m1 = orientation; + Matrix m2 = s.orientation; - Matrix4x4 world0; - Matrix4x4 world1; + Matrix4x4 world0; + Matrix4x4 world1; - world0.m[0][0] = (float) m1.elem[0][0]; - world0.m[0][1] = (float) m1.elem[0][1]; - world0.m[0][2] = (float) m1.elem[0][2]; - world0.m[0][3] = 0.0f; + world0.m[0][0] = (float) m1.elem[0][0]; + world0.m[0][1] = (float) m1.elem[0][1]; + world0.m[0][2] = (float) m1.elem[0][2]; + world0.m[0][3] = 0.0f; - world0.m[1][0] = (float) m1.elem[1][0]; - world0.m[1][1] = (float) m1.elem[1][1]; - world0.m[1][2] = (float) m1.elem[1][2]; - world0.m[1][3] = 0.0f; + world0.m[1][0] = (float) m1.elem[1][0]; + world0.m[1][1] = (float) m1.elem[1][1]; + world0.m[1][2] = (float) m1.elem[1][2]; + world0.m[1][3] = 0.0f; - world0.m[2][0] = (float) m1.elem[2][0]; - world0.m[2][1] = (float) m1.elem[2][1]; - world0.m[2][2] = (float) m1.elem[2][2]; - world0.m[2][3] = 0.0f; + world0.m[2][0] = (float) m1.elem[2][0]; + world0.m[2][1] = (float) m1.elem[2][1]; + world0.m[2][2] = (float) m1.elem[2][2]; + world0.m[2][3] = 0.0f; - world0.m[3][0] = (float) Location().x; - world0.m[3][1] = (float) Location().y; - world0.m[3][2] = (float) Location().z; - world0.m[3][3] = 1.0f; + world0.m[3][0] = (float) Location().x; + world0.m[3][1] = (float) Location().y; + world0.m[3][2] = (float) Location().z; + world0.m[3][3] = 1.0f; - world1.m[0][0] = (float) m2.elem[0][0]; - world1.m[0][1] = (float) m2.elem[1][0]; - world1.m[0][2] = (float) m2.elem[2][0]; - world1.m[0][3] = 0.0f; + world1.m[0][0] = (float) m2.elem[0][0]; + world1.m[0][1] = (float) m2.elem[1][0]; + world1.m[0][2] = (float) m2.elem[2][0]; + world1.m[0][3] = 0.0f; - world1.m[1][0] = (float) m2.elem[0][1]; - world1.m[1][1] = (float) m2.elem[1][1]; - world1.m[1][2] = (float) m2.elem[2][1]; - world1.m[1][3] = 0.0f; + world1.m[1][0] = (float) m2.elem[0][1]; + world1.m[1][1] = (float) m2.elem[1][1]; + world1.m[1][2] = (float) m2.elem[2][1]; + world1.m[1][3] = 0.0f; - world1.m[2][0] = (float) m2.elem[0][2]; - world1.m[2][1] = (float) m2.elem[1][2]; - world1.m[2][2] = (float) m2.elem[2][2]; - world1.m[2][3] = 0.0f; + world1.m[2][0] = (float) m2.elem[0][2]; + world1.m[2][1] = (float) m2.elem[1][2]; + world1.m[2][2] = (float) m2.elem[2][2]; + world1.m[2][3] = 0.0f; - world1.m[3][0] = (float) s.Location().x; - world1.m[3][1] = (float) s.Location().y; - world1.m[3][2] = (float) s.Location().z; - world1.m[3][3] = 1.0f; + world1.m[3][0] = (float) s.Location().x; + world1.m[3][1] = (float) s.Location().y; + world1.m[3][2] = (float) s.Location().z; + world1.m[3][3] = 1.0f; - ListIter s1_iter = model->surfaces; - while (++s1_iter && !contact) { - Surface* s1 = s1_iter.value(); + ListIter s1_iter = model->surfaces; + while (++s1_iter && !contact) { + Surface* s1 = s1_iter.value(); - ListIter s2_iter = s.model->surfaces; - while (++s2_iter && !contact) { - Surface* s2 = s2_iter.value(); + ListIter s2_iter = s.model->surfaces; + while (++s2_iter && !contact) { + Surface* s2 = s2_iter.value(); - if (s1->opcode && s2->opcode) { - BVTCache bvt; - bvt.Model0 = &s1->opcode->model; - bvt.Model1 = &s2->opcode->model; + if (s1->opcode && s2->opcode) { + BVTCache bvt; + bvt.Model0 = &s1->opcode->model; + bvt.Model1 = &s2->opcode->model; - if (opcode_collider.Collide(bvt, &world0, &world1)) - if (opcode_collider.GetContactStatus() != 0) - contact = true; - } - } - } + if (opcode_collider.Collide(bvt, &world0, &world1)) + if (opcode_collider.GetContactStatus() != 0) + contact = true; + } + } + } - return contact; - } + return contact; + } - return 1; + return 1; } // +--------------------------------------------------------------------+ @@ -388,131 +388,131 @@ Solid::CollidesWith(Graphic& o) int Solid::CheckRayIntersection(Point Q, Point w, double len, Point& ipt, - bool treat_translucent_polys_as_solid) +bool treat_translucent_polys_as_solid) { - int impact = 0; - - if (!model || model->npolys < 1) - return impact; + int impact = 0; - // check right angle spherical distance: - Point d0 = loc - Q; - Point d1 = d0.cross(w); - double dlen = d1.length(); // distance of point from line - - if (dlen > radius) // clean miss - return 0; // (no impact) - - // possible collision course... - - /********************************** - - - /--- + leading_edge = Q + w * len - / / \ - delta2 / delta 0 - / / \ - / *........x <- solid location - / / - / / delta1 - /--- Q * = closest point + if (!model || model->npolys < 1) + return impact; + // check right angle spherical distance: + Point d0 = loc - Q; + Point d1 = d0.cross(w); + double dlen = d1.length(); // distance of point from line - ************************************/ + if (dlen > radius) // clean miss + return 0; // (no impact) - // find the point on the ray that is closest - // to the solid's location: - Point closest = Q + w * (d0 * w); + // possible collision course... - // find the leading edge, and it's distance from the location: - Point leading_edge = Q + w*len; - Point leading_delta = leading_edge - loc; - double leading_dist = leading_delta.length(); + /********************************** - // if the leading edge is not within the bounding sphere, - if (leading_dist > radius) { - // check to see if the closest point is between the - // ray's endpoints: - Point delta1 = closest - Q; - Point delta2 = leading_edge - Q; // this is w*len - // if the closest point is not between the leading edge - // and the origin, this ray does not intersect: - if (delta1 * delta2 < 0 || delta1.length() > len) { - return 0; - } - } + /--- + leading_edge = Q + w * len + / / \ + delta2 / delta 0 + / / \ + / *........x <- solid location + / / + / / delta1 +/--- Q * = closest point - // probable hit at this point... - // if not active, that's good enough: - if (GetScene() == 0) { - ipt = closest; - return 1; - } +************************************/ - // transform ray into object space: - Matrix xform(Orientation()); + // find the point on the ray that is closest + // to the solid's location: + Point closest = Q + w * (d0 * w); - Vec3 tmp = w; + // find the leading edge, and it's distance from the location: + Point leading_edge = Q + w*len; + Point leading_delta = leading_edge - loc; + double leading_dist = leading_delta.length(); - w.x = tmp * Vec3(xform(0,0), xform(0,1), xform(0,2)); - w.y = tmp * Vec3(xform(1,0), xform(1,1), xform(1,2)); - w.z = tmp * Vec3(xform(2,0), xform(2,1), xform(2,2)); + // if the leading edge is not within the bounding sphere, + if (leading_dist > radius) { + // check to see if the closest point is between the + // ray's endpoints: + Point delta1 = closest - Q; + Point delta2 = leading_edge - Q; // this is w*len - tmp = Q-loc; + // if the closest point is not between the leading edge + // and the origin, this ray does not intersect: + if (delta1 * delta2 < 0 || delta1.length() > len) { + return 0; + } + } - Q.x = tmp * Vec3(xform(0,0), xform(0,1), xform(0,2)); - Q.y = tmp * Vec3(xform(1,0), xform(1,1), xform(1,2)); - Q.z = tmp * Vec3(xform(2,0), xform(2,1), xform(2,2)); - - double min = len; - intersection_poly = 0; + // probable hit at this point... - // check each polygon: - ListIter iter = model->surfaces; - while (++iter) { - Surface* s = iter.value(); - Poly* p = s->GetPolys(); + // if not active, that's good enough: + if (GetScene() == 0) { + ipt = closest; + return 1; + } - for (int i = 0; i < s->NumPolys(); i++) { - if (!treat_translucent_polys_as_solid && p->material && !p->material->IsSolid()) { - p++; - continue; - } + // transform ray into object space: + Matrix xform(Orientation()); - Point v = p->plane.normal; - double d = p->plane.distance; + Vec3 tmp = w; - double denom = w*v; + w.x = tmp * Vec3(xform(0,0), xform(0,1), xform(0,2)); + w.y = tmp * Vec3(xform(1,0), xform(1,1), xform(1,2)); + w.z = tmp * Vec3(xform(2,0), xform(2,1), xform(2,2)); - if (denom < -1.0e-5) { - Point P = v * d; - double ilen = ((P-Q)*v)/denom; + tmp = Q-loc; - if (ilen > 0 && ilen < min) { - Point intersect = Q + w * ilen; + Q.x = tmp * Vec3(xform(0,0), xform(0,1), xform(0,2)); + Q.y = tmp * Vec3(xform(1,0), xform(1,1), xform(1,2)); + Q.z = tmp * Vec3(xform(2,0), xform(2,1), xform(2,2)); - if (p->Contains(intersect)) { - intersection_poly = p; - ipt = intersect; - min = ilen; - impact = 1; - } - } - } + double min = len; + intersection_poly = 0; - p++; - } - } + // check each polygon: + ListIter iter = model->surfaces; + while (++iter) { + Surface* s = iter.value(); + Poly* p = s->GetPolys(); - // xform impact point back into world coordinates: + for (int i = 0; i < s->NumPolys(); i++) { + if (!treat_translucent_polys_as_solid && p->material && !p->material->IsSolid()) { + p++; + continue; + } - if (impact) { - ipt = (ipt * Orientation()) + loc; - } + Point v = p->plane.normal; + double d = p->plane.distance; - return impact; + double denom = w*v; + + if (denom < -1.0e-5) { + Point P = v * d; + double ilen = ((P-Q)*v)/denom; + + if (ilen > 0 && ilen < min) { + Point intersect = Q + w * ilen; + + if (p->Contains(intersect)) { + intersection_poly = p; + ipt = intersect; + min = ilen; + impact = 1; + } + } + } + + p++; + } + } + + // xform impact point back into world coordinates: + + if (impact) { + ipt = (ipt * Orientation()) + loc; + } + + return impact; } // +--------------------------------------------------------------------+ @@ -520,12 +520,12 @@ Solid::CheckRayIntersection(Point Q, Point w, double len, Point& ipt, void Solid::ClearModel() { - if (own_model && model) { - delete model; - model = 0; - } + if (own_model && model) { + delete model; + model = 0; + } - radius = 0.0f; + radius = 0.0f; } // +--------------------------------------------------------------------+ @@ -533,13 +533,13 @@ Solid::ClearModel() void Solid::UseModel(Model* m) { - // get rid of the existing model: - ClearModel(); - - // point to the new model: - own_model = 0; - model = m; - radius = m->radius; + // get rid of the existing model: + ClearModel(); + + // point to the new model: + own_model = 0; + model = m; + radius = m->radius; } // +--------------------------------------------------------------------+ @@ -547,118 +547,118 @@ Solid::UseModel(Model* m) bool Solid::Load(const char* mag_file, double scale) { - // get ready to load, delete existing model: - ClearModel(); - - // loading our own copy, so we own the model: - model = new(__FILE__,__LINE__) Model; - own_model = 1; + // get ready to load, delete existing model: + ClearModel(); + + // loading our own copy, so we own the model: + model = new(__FILE__,__LINE__) Model; + own_model = 1; - // now load the model: - if (model->Load(mag_file, scale)) { - radius = model->radius; - strncpy_s(name, model->name, sizeof(name)); - return true; - } + // now load the model: + if (model->Load(mag_file, scale)) { + radius = model->radius; + strncpy_s(name, model->name, sizeof(name)); + return true; + } - // load failed: - ClearModel(); - return false; + // load failed: + ClearModel(); + return false; } bool Solid::Load(ModelFile* mod_file, double scale) { - // get ready to load, delete existing model: - ClearModel(); - - // loading our own copy, so we own the model: - model = new(__FILE__,__LINE__) Model; - own_model = 1; + // get ready to load, delete existing model: + ClearModel(); - // now load the model: - if (model->Load(mod_file, scale)) { - radius = model->radius; - return true; - } + // loading our own copy, so we own the model: + model = new(__FILE__,__LINE__) Model; + own_model = 1; - // load failed: - ClearModel(); - return false; + // now load the model: + if (model->Load(mod_file, scale)) { + radius = model->radius; + return true; + } + + // load failed: + ClearModel(); + return false; } bool Solid::Rescale(double scale) { - if (!own_model || !model) - return false; + if (!own_model || !model) + return false; - radius = 0; + radius = 0; - ListIter iter = model->GetSurfaces(); - while (++iter) { - Surface* s = iter.value(); + ListIter iter = model->GetSurfaces(); + while (++iter) { + Surface* s = iter.value(); - for (int v = 0; v < s->NumVerts(); v++) { - s->vertex_set->loc[v] *= (float) scale; - s->vloc[v] *= (float) scale; + for (int v = 0; v < s->NumVerts(); v++) { + s->vertex_set->loc[v] *= (float) scale; + s->vloc[v] *= (float) scale; - float lvi = s->vloc[v].length(); - if (lvi > radius) - radius = lvi; - } - } + float lvi = s->vloc[v].length(); + if (lvi > radius) + radius = lvi; + } + } - model->radius = radius; + model->radius = radius; - InvalidateSurfaceData(); + InvalidateSurfaceData(); - return true; + return true; } void Solid::CreateShadows(int nlights) { - while (shadows.size() < nlights) { - shadows.append(new(__FILE__,__LINE__) Shadow(this)); - } + while (shadows.size() < nlights) { + shadows.append(new(__FILE__,__LINE__) Shadow(this)); + } } void Solid::UpdateShadows(List& lights) { - List active_lights; - ListIter iter = lights; + List active_lights; + ListIter iter = lights; - while (++iter) { - Light* light = iter.value(); + while (++iter) { + Light* light = iter.value(); - if (light->IsActive() && light->CastsShadow()) { - double distance = Point(Location() - light->Location()).length(); - double intensity = light->Intensity(); + if (light->IsActive() && light->CastsShadow()) { + double distance = Point(Location() - light->Location()).length(); + double intensity = light->Intensity(); - if (light->Type() == Light::LIGHT_POINT) { - if (intensity / distance > 1) - active_lights.append(light); - } + if (light->Type() == Light::LIGHT_POINT) { + if (intensity / distance > 1) + active_lights.append(light); + } - else if (light->Type() == Light::LIGHT_DIRECTIONAL) { - if (intensity > 0.65) - active_lights.insert(light); - } - } - } + else if (light->Type() == Light::LIGHT_DIRECTIONAL) { + if (intensity > 0.65) + active_lights.insert(light); + } + } + } - iter.attach(active_lights); + iter.attach(active_lights); - while (++iter) { - Light* light = iter.value(); - int index = iter.index(); + while (++iter) { + Light* light = iter.value(); + int index = iter.index(); - if (index < shadows.size()) { - shadows[index]->Update(light); - } - } + if (index < shadows.size()) { + shadows[index]->Update(light); + } + } } // +--------------------------------------------------------------------+ @@ -666,8 +666,8 @@ Solid::UpdateShadows(List& lights) void Solid::DeletePrivateData() { - if (model) - model->DeletePrivateData(); + if (model) + model->DeletePrivateData(); } // +--------------------------------------------------------------------+ @@ -675,56 +675,56 @@ Solid::DeletePrivateData() void Solid::InvalidateSurfaceData() { - if (!model) - return; - - bool invalidate = model->IsDynamic(); + if (!model) + return; + + bool invalidate = model->IsDynamic(); - ListIter iter = model->GetSurfaces(); - while (++iter) { - Surface* s = iter.value(); - VideoPrivateData* vpd = s->GetVideoPrivateData(); + ListIter iter = model->GetSurfaces(); + while (++iter) { + Surface* s = iter.value(); + VideoPrivateData* vpd = s->GetVideoPrivateData(); - if (vpd) { - if (invalidate) { - vpd->Invalidate(); - } - else { - delete vpd; - s->SetVideoPrivateData(0); - } - } - } + if (vpd) { + if (invalidate) { + vpd->Invalidate(); + } + else { + delete vpd; + s->SetVideoPrivateData(0); + } + } + } } void Solid::InvalidateSegmentData() { - if (!model) - return; - - bool invalidate = model->IsDynamic(); - - ListIter iter = model->GetSurfaces(); - while (++iter) { - Surface* s = iter.value(); - - ListIter seg_iter = s->GetSegments(); - while (++seg_iter) { - Segment* segment = seg_iter.value(); - VideoPrivateData* vpd = segment->GetVideoPrivateData(); - - if (vpd) { - if (invalidate) { - vpd->Invalidate(); - } - else { - delete vpd; - segment->SetVideoPrivateData(0); - } - } - } - } + if (!model) + return; + + bool invalidate = model->IsDynamic(); + + ListIter iter = model->GetSurfaces(); + while (++iter) { + Surface* s = iter.value(); + + ListIter seg_iter = s->GetSegments(); + while (++seg_iter) { + Segment* segment = seg_iter.value(); + VideoPrivateData* vpd = segment->GetVideoPrivateData(); + + if (vpd) { + if (invalidate) { + vpd->Invalidate(); + } + else { + delete vpd; + segment->SetVideoPrivateData(0); + } + } + } + } } // +--------------------------------------------------------------------+ @@ -732,17 +732,17 @@ Solid::InvalidateSegmentData() bool Solid::IsDynamic() const { - if (model) - return model->IsDynamic(); + if (model) + return model->IsDynamic(); - return false; + return false; } void Solid::SetDynamic(bool d) { - if (model && own_model) - model->SetDynamic(d); + if (model && own_model) + model->SetDynamic(d); } // +--------------------------------------------------------------------+ @@ -750,32 +750,32 @@ Solid::SetDynamic(bool d) void Solid::GetAllTextures(List& textures) { - if (model) - model->GetAllTextures(textures); + if (model) + model->GetAllTextures(textures); } void Model::GetAllTextures(List& textures) { - ListIter m_iter = materials; - while (++m_iter) { - Material* m = m_iter.value(); + ListIter m_iter = materials; + while (++m_iter) { + Material* m = m_iter.value(); - if (m->tex_diffuse && !textures.contains(m->tex_diffuse)) - textures.append(m->tex_diffuse); + if (m->tex_diffuse && !textures.contains(m->tex_diffuse)) + textures.append(m->tex_diffuse); - if (m->tex_specular && !textures.contains(m->tex_specular)) - textures.append(m->tex_specular); + if (m->tex_specular && !textures.contains(m->tex_specular)) + textures.append(m->tex_specular); - if (m->tex_emissive && !textures.contains(m->tex_emissive)) - textures.append(m->tex_emissive); + if (m->tex_emissive && !textures.contains(m->tex_emissive)) + textures.append(m->tex_emissive); - if (m->tex_bumpmap && !textures.contains(m->tex_bumpmap)) - textures.append(m->tex_bumpmap); + if (m->tex_bumpmap && !textures.contains(m->tex_bumpmap)) + textures.append(m->tex_bumpmap); - if (m->tex_detail && !textures.contains(m->tex_detail)) - textures.append(m->tex_detail); - } + if (m->tex_detail && !textures.contains(m->tex_detail)) + textures.append(m->tex_detail); + } } // +--------------------------------------------------------------------+ @@ -783,64 +783,64 @@ Model::GetAllTextures(List& textures) // +--------------------------------------------------------------------+ Model::Model() - : nverts(0), npolys(0), radius(0), luminous(false), dynamic(false) +: nverts(0), npolys(0), radius(0), luminous(false), dynamic(false) { - ZeroMemory(name, sizeof(name)); + ZeroMemory(name, sizeof(name)); } Model::Model(const Model& m) - : nverts(0), npolys(0), radius(0), luminous(false), dynamic(false) +: nverts(0), npolys(0), radius(0), luminous(false), dynamic(false) { - operator=(m); + operator=(m); } // +--------------------------------------------------------------------+ Model::~Model() { - surfaces.destroy(); - materials.destroy(); + surfaces.destroy(); + materials.destroy(); } Model& Model::operator = (const Model& m) { - if (this != &m) { - surfaces.destroy(); - materials.destroy(); + if (this != &m) { + surfaces.destroy(); + materials.destroy(); - CopyMemory(name, m.name, Solid::NAMELEN); + CopyMemory(name, m.name, Solid::NAMELEN); - nverts = m.nverts; - npolys = m.npolys; - radius = m.radius; - luminous = m.luminous; - dynamic = m.dynamic; + nverts = m.nverts; + npolys = m.npolys; + radius = m.radius; + luminous = m.luminous; + dynamic = m.dynamic; - Model* pmod = (Model*) &m; + Model* pmod = (Model*) &m; - ListIter m_iter = pmod->materials; - while (++m_iter) { - Material* matl1 = m_iter.value(); - Material* matl2 = new(__FILE__,__LINE__) Material; + ListIter m_iter = pmod->materials; + while (++m_iter) { + Material* matl1 = m_iter.value(); + Material* matl2 = new(__FILE__,__LINE__) Material; - CopyMemory(matl2, matl1, sizeof(Material)); - matl2->thumbnail = 0; + CopyMemory(matl2, matl1, sizeof(Material)); + matl2->thumbnail = 0; - materials.append(matl2); - } + materials.append(matl2); + } - ListIter s_iter = pmod->surfaces; - while (++s_iter) { - Surface* surf1 = s_iter.value(); - Surface* surf2 = new(__FILE__,__LINE__) Surface; + ListIter s_iter = pmod->surfaces; + while (++s_iter) { + Surface* surf1 = s_iter.value(); + Surface* surf2 = new(__FILE__,__LINE__) Surface; - surf2->Copy(*surf1, this); - surfaces.append(surf2); - } - } + surf2->Copy(*surf1, this); + surfaces.append(surf2); + } + } - return *this; + return *this; } // +--------------------------------------------------------------------+ @@ -848,60 +848,60 @@ Model::operator = (const Model& m) int Model::NumSegments() const { - int nsegments = 0; + int nsegments = 0; - for (int i = 0; i < surfaces.size(); i++) { - const Surface* s = surfaces[i]; - nsegments += s->NumSegments(); - } + for (int i = 0; i < surfaces.size(); i++) { + const Surface* s = surfaces[i]; + nsegments += s->NumSegments(); + } - return nsegments; + return nsegments; } // +--------------------------------------------------------------------+ inline bool Collinear(const double* a, const double* b, const double* c) { - Point ab(b[0]-a[0], b[1]-a[1], b[2]-a[2]); - Point ac(c[0]-a[0], c[1]-a[1], c[2]-a[2]); - Point cross = ab.cross(ac); - return (cross.length() == 0); + Point ab(b[0]-a[0], b[1]-a[1], b[2]-a[2]); + Point ac(c[0]-a[0], c[1]-a[1], c[2]-a[2]); + Point cross = ab.cross(ac); + return (cross.length() == 0); } struct HomogenousPlane { - double distance; - double normal_x; - double normal_y; - double normal_z; - double normal_w; + double distance; + double normal_x; + double normal_y; + double normal_z; + double normal_w; }; static void LoadPlane(Plane& p, DataLoader* l, BYTE*& fp) { - HomogenousPlane tmp; - l->fread(&tmp, sizeof(HomogenousPlane), 1, fp); + HomogenousPlane tmp; + l->fread(&tmp, sizeof(HomogenousPlane), 1, fp); } static void LoadFlags(LPDWORD flags, DataLoader* l, BYTE*& fp) { - DWORD magic_flags; - l->fread(&magic_flags, sizeof(DWORD), 1, fp); + DWORD magic_flags; + l->fread(&magic_flags, sizeof(DWORD), 1, fp); - /** OLD MAGIC FLAGS - enum { FLAT_SHADED = 1, - LUMINOUS = 2, - TRANSLUCENT = 4, \\ must swap - CHROMAKEY = 8, // these two - FOREGROUND = 16, -- not used - WIREFRAME = 32, -- not used - SPECULAR1 = 64, - SPECULAR2 = 128 }; - ***/ + /** OLD MAGIC FLAGS +enum { FLAT_SHADED = 1, + LUMINOUS = 2, + TRANSLUCENT = 4, \\ must swap + CHROMAKEY = 8, // these two + FOREGROUND = 16, -- not used + WIREFRAME = 32, -- not used + SPECULAR1 = 64, + SPECULAR2 = 128 }; +***/ - const DWORD magic_mask = 0x0fc3; + const DWORD magic_mask = 0x0fc3; - *flags = magic_flags & magic_mask; + *flags = magic_flags & magic_mask; } // +--------------------------------------------------------------------+ @@ -909,78 +909,78 @@ static void LoadFlags(LPDWORD flags, DataLoader* l, BYTE*& fp) bool Model::Load(const char* mag_file, double scale) { - BYTE* block; - DataLoader* loader = DataLoader::GetLoader(); - bool result = false; - - radius = 0.0f; - extents[0] = 0.0f; - extents[1] = 0.0f; - extents[2] = 0.0f; - extents[3] = 0.0f; - extents[4] = 0.0f; - extents[5] = 0.0f; - - if (!loader) { - Print("MAG Open Failed: no data loader for file '%s'\n", mag_file); - return result; - } - - int size = loader->LoadBuffer(mag_file, block); - BYTE* fp = block; - - // check MAG file: - if (!size) { - Print("MAG Open Failed: could not open file '%s'\n", mag_file); - return result; - } - - strncpy_s(name, mag_file, 31); - name[31] = 0; - - char file_id[5]; - CopyMemory(file_id, block, 4); - file_id[4] = '\0'; - int version = 1; - - if (!strcmp(file_id, "MAG6")) { - version = 6; - } - else if (!strcmp(file_id, "MAG5")) { - version = 5; - } - else if (!strcmp(file_id, "MAG4")) { - version = 4; - } - else { - Print("MAG Open Failed: File '%s' Invalid file type '%s'\n", mag_file, file_id); - loader->ReleaseBuffer(block); - return result; - } - - // get ready to load, delete existing model: - surfaces.destroy(); - materials.destroy(); - nverts = 0; - npolys = 0; - - // now load the model: - switch (version) { - case 4: - case 5: - result = LoadMag5(block, size, scale); - break; - - case 6: - result = LoadMag6(block, size, scale); - break; - - default: - break; - } - - loader->ReleaseBuffer(block); - return result; + BYTE* block; + DataLoader* loader = DataLoader::GetLoader(); + bool result = false; + + radius = 0.0f; + extents[0] = 0.0f; + extents[1] = 0.0f; + extents[2] = 0.0f; + extents[3] = 0.0f; + extents[4] = 0.0f; + extents[5] = 0.0f; + + if (!loader) { + Print("MAG Open Failed: no data loader for file '%s'\n", mag_file); + return result; + } + + int size = loader->LoadBuffer(mag_file, block); + BYTE* fp = block; + + // check MAG file: + if (!size) { + Print("MAG Open Failed: could not open file '%s'\n", mag_file); + return result; + } + + strncpy_s(name, mag_file, 31); + name[31] = 0; + + char file_id[5]; + CopyMemory(file_id, block, 4); + file_id[4] = '\0'; + int version = 1; + + if (!strcmp(file_id, "MAG6")) { + version = 6; + } + else if (!strcmp(file_id, "MAG5")) { + version = 5; + } + else if (!strcmp(file_id, "MAG4")) { + version = 4; + } + else { + Print("MAG Open Failed: File '%s' Invalid file type '%s'\n", mag_file, file_id); + loader->ReleaseBuffer(block); + return result; + } + + // get ready to load, delete existing model: + surfaces.destroy(); + materials.destroy(); + nverts = 0; + npolys = 0; + + // now load the model: + switch (version) { + case 4: + case 5: + result = LoadMag5(block, size, scale); + break; + + case 6: + result = LoadMag6(block, size, scale); + break; + + default: + break; + } + + loader->ReleaseBuffer(block); + return result; } // +--------------------------------------------------------------------+ @@ -988,340 +988,340 @@ Model::Load(const char* mag_file, double scale) bool Model::Load(ModelFile* mod_file, double scale) { - if (mod_file) { - return mod_file->Load(this, scale); - } + if (mod_file) { + return mod_file->Load(this, scale); + } - return false; + return false; } // +--------------------------------------------------------------------+ static int mcomp(const void* a, const void* b) { - Poly* pa = (Poly*) a; - Poly* pb = (Poly*) b; + Poly* pa = (Poly*) a; + Poly* pb = (Poly*) b; - if (pa->sortval == pb->sortval) - return 0; + if (pa->sortval == pb->sortval) + return 0; - if (pa->sortval < pb->sortval) - return 1; + if (pa->sortval < pb->sortval) + return 1; - return -1; + return -1; } bool Model::LoadMag5(BYTE* block, int len, double scale) { - bool result = false; + bool result = false; - DataLoader* loader = DataLoader::GetLoader(); - BYTE* fp = block + 4; - int ntex = 0; - int nsurfs = 0; + DataLoader* loader = DataLoader::GetLoader(); + BYTE* fp = block + 4; + int ntex = 0; + int nsurfs = 0; - loader->fread(&ntex, sizeof(ntex), 1, fp); - loader->fread(&nsurfs, sizeof(nsurfs), 1, fp); + loader->fread(&ntex, sizeof(ntex), 1, fp); + loader->fread(&nsurfs, sizeof(nsurfs), 1, fp); - // create a default gray material: - Material* mtl = new Material; + // create a default gray material: + Material* mtl = new Material; - if (mtl) { - mtl->Ka = Color::LightGray; - mtl->Kd = Color::LightGray; - mtl->Ks = ColorValue(0.2f,0.2f,0.2f); - mtl->power = 20.0f; + if (mtl) { + mtl->Ka = Color::LightGray; + mtl->Kd = Color::LightGray; + mtl->Ks = ColorValue(0.2f,0.2f,0.2f); + mtl->power = 20.0f; - mtl->ambient_value = 1.0f; - mtl->ambient_color = Color::LightGray; - mtl->diffuse_value = 1.0f; - mtl->diffuse_color = Color::LightGray; - mtl->specular_value = 0.2f; - mtl->specular_color = Color::White; - strcpy_s(mtl->name, "(default)"); - - materials.append(mtl); - } - - // read texture list: - for (int i = 0; i < ntex; i++) { - mtl = new(__FILE__,__LINE__) Material; - char tname[32]; - - if (mtl) { - mtl->Ka = ColorValue(0.5f,0.5f,0.5f); - mtl->Kd = ColorValue(1.0f,1.0f,1.0f); - mtl->Ks = ColorValue(0.2f,0.2f,0.2f); - mtl->power = 20.0f; - - mtl->ambient_value = 1.0f; - mtl->ambient_color = Color::Gray; - mtl->diffuse_value = 1.0f; - mtl->diffuse_color = Color::White; - mtl->specular_value = 0.2f; - mtl->specular_color = Color::White; - - loader->fread(tname, 32, 1, fp); - loader->LoadTexture(tname, mtl->tex_diffuse, Bitmap::BMP_SOLID, true); - strcpy_s(mtl->name, tname); - - char* dot = strrchr(mtl->name, '.'); - if (dot) - *dot = 0; - - char* plus = strrchr(mtl->name, '+'); - if (plus) - *plus = 0; - - materials.append(mtl); - } - } + mtl->ambient_value = 1.0f; + mtl->ambient_color = Color::LightGray; + mtl->diffuse_value = 1.0f; + mtl->diffuse_color = Color::LightGray; + mtl->specular_value = 0.2f; + mtl->specular_color = Color::White; + strcpy_s(mtl->name, "(default)"); + + materials.append(mtl); + } + + // read texture list: + for (int i = 0; i < ntex; i++) { + mtl = new(__FILE__,__LINE__) Material; + char tname[32]; + + if (mtl) { + mtl->Ka = ColorValue(0.5f,0.5f,0.5f); + mtl->Kd = ColorValue(1.0f,1.0f,1.0f); + mtl->Ks = ColorValue(0.2f,0.2f,0.2f); + mtl->power = 20.0f; + + mtl->ambient_value = 1.0f; + mtl->ambient_color = Color::Gray; + mtl->diffuse_value = 1.0f; + mtl->diffuse_color = Color::White; + mtl->specular_value = 0.2f; + mtl->specular_color = Color::White; + + loader->fread(tname, 32, 1, fp); + loader->LoadTexture(tname, mtl->tex_diffuse, Bitmap::BMP_SOLID, true); + strcpy_s(mtl->name, tname); + + char* dot = strrchr(mtl->name, '.'); + if (dot) + *dot = 0; + + char* plus = strrchr(mtl->name, '+'); + if (plus) + *plus = 0; + + materials.append(mtl); + } + } - loader->fread(&nverts, 4, 1, fp); - loader->fread(&npolys, 4, 1, fp); - - // plan on creating four verts per poly: - int mag_nverts = nverts; - int next_vert = nverts; - - nverts = npolys * 4; + loader->fread(&nverts, 4, 1, fp); + loader->fread(&npolys, 4, 1, fp); + + // plan on creating four verts per poly: + int mag_nverts = nverts; + int next_vert = nverts; + + nverts = npolys * 4; - Surface* s = new(__FILE__,__LINE__) Surface; - VertexSet* vset = 0; + Surface* s = new(__FILE__,__LINE__) Surface; + VertexSet* vset = 0; - if (s) { - strcpy_s(s->name, "default"); - - s->model = this; - s->vertex_set = new(__FILE__,__LINE__) VertexSet(nverts); - s->vloc = new(__FILE__,__LINE__) Vec3[nverts]; - - ZeroMemory(s->vertex_set->loc, nverts * sizeof(Vec3)); - ZeroMemory(s->vertex_set->diffuse, nverts * sizeof(DWORD)); - ZeroMemory(s->vertex_set->specular, nverts * sizeof(DWORD)); - ZeroMemory(s->vertex_set->tu, nverts * sizeof(float)); - ZeroMemory(s->vertex_set->tv, nverts * sizeof(float)); - ZeroMemory(s->vertex_set->rw, nverts * sizeof(float)); - ZeroMemory(s->vloc, nverts * sizeof(Vec3)); - - s->npolys = npolys; - s->polys = new(__FILE__,__LINE__) Poly[npolys]; - - ZeroMemory(s->polys, sizeof(Poly) * npolys); - surfaces.append(s); - - vset = s->vertex_set; - - int v; - // read vertex set: - for (v = 0; v < mag_nverts; v++) { - Vec3 vert, norm; - DWORD vstate; - - loader->fread(&vert, sizeof(Vec3), 1, fp); - loader->fread(&norm, sizeof(Vec3), 1, fp); - loader->fread(&vstate, sizeof(DWORD), 1, fp); - - vert.SwapYZ(); - vert *= (float) scale; - - vset->loc[v] = vert; - vset->nrm[v] = norm; - - double d = vert.length(); - if (d > radius) - radius = (float) d; - - if (vert.x > extents[0]) extents[0] = vert.x; - if (vert.x < extents[1]) extents[1] = vert.x; - if (vert.y > extents[2]) extents[2] = vert.y; - if (vert.y < extents[3]) extents[3] = vert.y; - if (vert.z > extents[4]) extents[4] = vert.z; - if (vert.z < extents[5]) extents[5] = vert.z; - } - - while (v < nverts) - vset->nrm[v++] = Vec3(1,0,0); - - // read polys: - Vec3 dummy_center; - DWORD dummy_flags; - DWORD dummy_color; - Plane dummy_plane; - int texture_num; - int poly_nverts; - int vert_index_buffer[32]; - float texture_index_buffer[32]; - - for (int n = 0; n < npolys; n++) { - Poly& poly = s->polys[n]; - poly.vertex_set = vset; - - loader->fread(&dummy_flags, sizeof(DWORD), 1, fp); - loader->fread(&dummy_center, sizeof(Vec3), 1, fp); - - LoadPlane(dummy_plane, loader, fp); - - loader->fread(&dummy_color, sizeof(DWORD), 1, fp); - loader->fread(&texture_num, sizeof(int), 1, fp); - - if (texture_num >= 0 && texture_num < ntex) { - int mtl_num = texture_num + 1; - poly.material = materials[mtl_num]; - poly.sortval = texture_num; - - bool flag_translucent = (dummy_flags & 0x04) ? true : false; - bool flag_transparent = (dummy_flags & 0x08) ? true : false; - - // luminous - if (dummy_flags & 2) { - mtl = materials[mtl_num]; - - mtl->Ka = ColorValue(0,0,0,0); - mtl->Kd = ColorValue(0,0,0,0); - mtl->Ks = ColorValue(0,0,0,0); - mtl->Ke = ColorValue(1,1,1,1); - - mtl->tex_emissive = mtl->tex_diffuse; - } - - // glowing (additive) - if (flag_translucent && flag_transparent) - materials[mtl_num]->blend = Material::MTL_ADDITIVE; - - // translucent (alpha) - else if (flag_translucent) - materials[mtl_num]->blend = Material::MTL_TRANSLUCENT; - - // transparent (just use alpha for this) - else if (flag_transparent) - materials[mtl_num]->blend = Material::MTL_TRANSLUCENT; - } - else { - poly.material = materials.first(); - poly.sortval = 1000; - } - - // hack: store flat shaded flag in unused visible byte - poly.visible = (BYTE) (dummy_flags & 1); - - loader->fread(&poly_nverts, sizeof(int), 1, fp); - loader->fread(vert_index_buffer, sizeof(int), poly_nverts, fp); - - if (poly_nverts == 3) - s->nindices += 3; - - else if (poly_nverts == 4) - s->nindices += 6; - - poly.nverts = poly_nverts; - for (int vi = 0; vi < poly_nverts; vi++) { - v = vert_index_buffer[vi]; - - if (vset->rw[v] > 0) { - vset->CopyVertex(next_vert, v); - v = next_vert++; - } - - vset->rw[v] = 1; - poly.verts[vi] = v; - } - - loader->fread(texture_index_buffer, sizeof(float), poly_nverts, fp); // tu's - for (int vi = 0; vi < poly_nverts; vi++) { - v = poly.verts[vi]; - vset->tu[v] = texture_index_buffer[vi]; - } - - loader->fread(texture_index_buffer, sizeof(float), poly_nverts, fp); // tv's - for (int vi = 0; vi < poly_nverts; vi++) { - v = poly.verts[vi]; - vset->tv[v] = texture_index_buffer[vi]; - } - - fp += 16; - } - - // pass 2 (adjust vertex normals for flat polys): - for (int n = 0; n < npolys; n++) { - Poly& poly = s->polys[n]; - poly.plane = Plane(vset->loc[poly.verts[0]], - vset->loc[poly.verts[2]], - vset->loc[poly.verts[1]]); - - // hack: retrieve flat shaded flag from unused visible byte - if (poly.visible) { - poly_nverts = poly.nverts; + if (s) { + strcpy_s(s->name, "default"); + + s->model = this; + s->vertex_set = new(__FILE__,__LINE__) VertexSet(nverts); + s->vloc = new(__FILE__,__LINE__) Vec3[nverts]; + + ZeroMemory(s->vertex_set->loc, nverts * sizeof(Vec3)); + ZeroMemory(s->vertex_set->diffuse, nverts * sizeof(DWORD)); + ZeroMemory(s->vertex_set->specular, nverts * sizeof(DWORD)); + ZeroMemory(s->vertex_set->tu, nverts * sizeof(float)); + ZeroMemory(s->vertex_set->tv, nverts * sizeof(float)); + ZeroMemory(s->vertex_set->rw, nverts * sizeof(float)); + ZeroMemory(s->vloc, nverts * sizeof(Vec3)); + + s->npolys = npolys; + s->polys = new(__FILE__,__LINE__) Poly[npolys]; + + ZeroMemory(s->polys, sizeof(Poly) * npolys); + surfaces.append(s); + + vset = s->vertex_set; + + int v; + // read vertex set: + for (v = 0; v < mag_nverts; v++) { + Vec3 vert, norm; + DWORD vstate; + + loader->fread(&vert, sizeof(Vec3), 1, fp); + loader->fread(&norm, sizeof(Vec3), 1, fp); + loader->fread(&vstate, sizeof(DWORD), 1, fp); + + vert.SwapYZ(); + vert *= (float) scale; + + vset->loc[v] = vert; + vset->nrm[v] = norm; + + double d = vert.length(); + if (d > radius) + radius = (float) d; + + if (vert.x > extents[0]) extents[0] = vert.x; + if (vert.x < extents[1]) extents[1] = vert.x; + if (vert.y > extents[2]) extents[2] = vert.y; + if (vert.y < extents[3]) extents[3] = vert.y; + if (vert.z > extents[4]) extents[4] = vert.z; + if (vert.z < extents[5]) extents[5] = vert.z; + } + + while (v < nverts) + vset->nrm[v++] = Vec3(1,0,0); + + // read polys: + Vec3 dummy_center; + DWORD dummy_flags; + DWORD dummy_color; + Plane dummy_plane; + int texture_num; + int poly_nverts; + int vert_index_buffer[32]; + float texture_index_buffer[32]; + + for (int n = 0; n < npolys; n++) { + Poly& poly = s->polys[n]; + poly.vertex_set = vset; + + loader->fread(&dummy_flags, sizeof(DWORD), 1, fp); + loader->fread(&dummy_center, sizeof(Vec3), 1, fp); + + LoadPlane(dummy_plane, loader, fp); + + loader->fread(&dummy_color, sizeof(DWORD), 1, fp); + loader->fread(&texture_num, sizeof(int), 1, fp); + + if (texture_num >= 0 && texture_num < ntex) { + int mtl_num = texture_num + 1; + poly.material = materials[mtl_num]; + poly.sortval = texture_num; + + bool flag_translucent = (dummy_flags & 0x04) ? true : false; + bool flag_transparent = (dummy_flags & 0x08) ? true : false; + + // luminous + if (dummy_flags & 2) { + mtl = materials[mtl_num]; + + mtl->Ka = ColorValue(0,0,0,0); + mtl->Kd = ColorValue(0,0,0,0); + mtl->Ks = ColorValue(0,0,0,0); + mtl->Ke = ColorValue(1,1,1,1); + + mtl->tex_emissive = mtl->tex_diffuse; + } + + // glowing (additive) + if (flag_translucent && flag_transparent) + materials[mtl_num]->blend = Material::MTL_ADDITIVE; + + // translucent (alpha) + else if (flag_translucent) + materials[mtl_num]->blend = Material::MTL_TRANSLUCENT; + + // transparent (just use alpha for this) + else if (flag_transparent) + materials[mtl_num]->blend = Material::MTL_TRANSLUCENT; + } + else { + poly.material = materials.first(); + poly.sortval = 1000; + } + + // hack: store flat shaded flag in unused visible byte + poly.visible = (BYTE) (dummy_flags & 1); + + loader->fread(&poly_nverts, sizeof(int), 1, fp); + loader->fread(vert_index_buffer, sizeof(int), poly_nverts, fp); + + if (poly_nverts == 3) + s->nindices += 3; + + else if (poly_nverts == 4) + s->nindices += 6; + + poly.nverts = poly_nverts; + for (int vi = 0; vi < poly_nverts; vi++) { + v = vert_index_buffer[vi]; + + if (vset->rw[v] > 0) { + vset->CopyVertex(next_vert, v); + v = next_vert++; + } + + vset->rw[v] = 1; + poly.verts[vi] = v; + } + + loader->fread(texture_index_buffer, sizeof(float), poly_nverts, fp); // tu's + for (int vi = 0; vi < poly_nverts; vi++) { + v = poly.verts[vi]; + vset->tu[v] = texture_index_buffer[vi]; + } + + loader->fread(texture_index_buffer, sizeof(float), poly_nverts, fp); // tv's + for (int vi = 0; vi < poly_nverts; vi++) { + v = poly.verts[vi]; + vset->tv[v] = texture_index_buffer[vi]; + } + + fp += 16; + } + + // pass 2 (adjust vertex normals for flat polys): + for (int n = 0; n < npolys; n++) { + Poly& poly = s->polys[n]; + poly.plane = Plane(vset->loc[poly.verts[0]], + vset->loc[poly.verts[2]], + vset->loc[poly.verts[1]]); + + // hack: retrieve flat shaded flag from unused visible byte + if (poly.visible) { + poly_nverts = poly.nverts; - for (int vi = 0; vi < poly_nverts; vi++) { - v = poly.verts[vi]; - vset->nrm[v] = poly.plane.normal; - } - } - } + for (int vi = 0; vi < poly_nverts; vi++) { + v = poly.verts[vi]; + vset->nrm[v] = poly.plane.normal; + } + } + } - // sort the polys by material index: - qsort((void*) s->polys, s->npolys, sizeof(Poly), mcomp); - - // then assign them to cohesive segments: - Segment* segment = 0; - - for (int n = 0; n < npolys; n++) { - if (segment && segment->material == s->polys[n].material) { - segment->npolys++; - } - else { - segment = 0; - } - - if (!segment) { - segment = new(__FILE__,__LINE__) Segment; - - segment->npolys = 1; - segment->polys = &s->polys[n]; - segment->material = segment->polys->material; - segment->model = this; - - s->segments.append(segment); - } - } - - s->BuildHull(); - - result = nverts && npolys; - } - - return result; + // sort the polys by material index: + qsort((void*) s->polys, s->npolys, sizeof(Poly), mcomp); + + // then assign them to cohesive segments: + Segment* segment = 0; + + for (int n = 0; n < npolys; n++) { + if (segment && segment->material == s->polys[n].material) { + segment->npolys++; + } + else { + segment = 0; + } + + if (!segment) { + segment = new(__FILE__,__LINE__) Segment; + + segment->npolys = 1; + segment->polys = &s->polys[n]; + segment->material = segment->polys->material; + segment->model = this; + + s->segments.append(segment); + } + } + + s->BuildHull(); + + result = nverts && npolys; + } + + return result; } // +--------------------------------------------------------------------+ struct MaterialMag6 { - char name[Material::NAMELEN]; - char shader[Material::NAMELEN]; - float power; // highlight sharpness (big=shiny) - float brilliance; // diffuse power function - float bump; // bump level (0=none) - DWORD blend; // alpha blend type - bool shadow; // material casts shadow - bool luminous; // verts have their own lighting - - Color ambient_color; - Color diffuse_color; - Color specular_color; - Color emissive_color; - - float ambient_value; - float diffuse_value; - float specular_value; - float emissive_value; - - BYTE tex_diffuse; - BYTE tex_specular; - BYTE tex_bumpmap; - BYTE tex_emissive; + char name[Material::NAMELEN]; + char shader[Material::NAMELEN]; + float power; // highlight sharpness (big=shiny) + float brilliance; // diffuse power function + float bump; // bump level (0=none) + DWORD blend; // alpha blend type + bool shadow; // material casts shadow + bool luminous; // verts have their own lighting + + Color ambient_color; + Color diffuse_color; + Color specular_color; + Color emissive_color; + + float ambient_value; + float diffuse_value; + float specular_value; + float emissive_value; + + BYTE tex_diffuse; + BYTE tex_specular; + BYTE tex_bumpmap; + BYTE tex_emissive; }; // +--------------------------------------------------------------------+ @@ -1329,231 +1329,231 @@ struct MaterialMag6 { bool Model::LoadMag6(BYTE* block, int len, double scale) { - bool result = false; + bool result = false; - DataLoader* loader = DataLoader::GetLoader(); - BYTE* fp = block + 4; - int ntex = 0; - int nmtls = 0; - int nsurfs = 0; - List textures; + DataLoader* loader = DataLoader::GetLoader(); + BYTE* fp = block + 4; + int ntex = 0; + int nmtls = 0; + int nsurfs = 0; + List textures; - loader->fread(&ntex, sizeof(ntex), 1, fp); // size of texture block - loader->fread(&nmtls, sizeof(nmtls), 1, fp); // number of materials - loader->fread(&nsurfs, sizeof(nsurfs), 1, fp); // number of surfaces + loader->fread(&ntex, sizeof(ntex), 1, fp); // size of texture block + loader->fread(&nmtls, sizeof(nmtls), 1, fp); // number of materials + loader->fread(&nsurfs, sizeof(nsurfs), 1, fp); // number of surfaces - // read texture list: - if (ntex) { - char* buffer = new(__FILE__,__LINE__) char[ntex]; - char* p = buffer; - Bitmap* bmp = 0; - - loader->fread(buffer, ntex, 1, fp); - - while (p < buffer + ntex) { - loader->LoadTexture(p, bmp, Bitmap::BMP_SOLID, true); - textures.append(bmp); - - p += strlen(p) + 1; - } - - delete [] buffer; - } - - for (int i = 0; i < nmtls; i++) { - MaterialMag6 m6; - Material* mtl = new(__FILE__,__LINE__) Material; - - loader->fread(&m6, sizeof(m6), 1, fp); - - if (mtl) { - CopyMemory(mtl->name, m6.name, Material::NAMELEN); - CopyMemory(mtl->shader, m6.shader, Material::NAMELEN); - - mtl->ambient_value = m6.ambient_value; - mtl->ambient_color = m6.ambient_color; - mtl->diffuse_value = m6.diffuse_value; - mtl->diffuse_color = m6.diffuse_color; - mtl->specular_value = m6.specular_value; - mtl->specular_color = m6.specular_color; - mtl->emissive_value = m6.emissive_value; - mtl->emissive_color = m6.emissive_color; - - mtl->Ka = ColorValue(mtl->ambient_color) * mtl->ambient_value; - mtl->Kd = ColorValue(mtl->diffuse_color) * mtl->diffuse_value; - mtl->Ks = ColorValue(mtl->specular_color) * mtl->specular_value; - mtl->Ke = ColorValue(mtl->emissive_color) * mtl->emissive_value; - - mtl->power = m6.power; - mtl->brilliance = m6.brilliance; - mtl->bump = m6.bump; - mtl->blend = m6.blend; - mtl->shadow = m6.shadow; - mtl->luminous = m6.luminous; - - if (m6.tex_diffuse && m6.tex_diffuse <= textures.size()) - mtl->tex_diffuse = textures[m6.tex_diffuse - 1]; - - if (m6.tex_specular && m6.tex_specular <= textures.size()) - mtl->tex_specular = textures[m6.tex_specular - 1]; - - if (m6.tex_emissive && m6.tex_emissive <= textures.size()) - mtl->tex_emissive = textures[m6.tex_emissive - 1]; - - if (m6.tex_bumpmap && m6.tex_bumpmap <= textures.size()) - mtl->tex_bumpmap = textures[m6.tex_bumpmap - 1]; - - materials.append(mtl); - } - } - - for (int i = 0; i < nsurfs; i++) { - int nverts = 0; - int npolys = 0; - BYTE namelen = 0; - char name[128]; - - loader->fread(&nverts, 4, 1, fp); - loader->fread(&npolys, 4, 1, fp); - loader->fread(&namelen, 1, 1, fp); - loader->fread(name, 1, namelen, fp); - - Surface* surface = new(__FILE__,__LINE__) Surface; - surface->model = this; - surface->SetName(name); - surface->CreateVerts(nverts); - surface->CreatePolys(npolys); - - VertexSet* vset = surface->GetVertexSet(); - Poly* polys = surface->GetPolys(); - - ZeroMemory(polys, sizeof(Poly) * npolys); - - // read vertex set: - for (int v = 0; v < nverts; v++) { - loader->fread(&vset->loc[v], sizeof(float), 3, fp); - loader->fread(&vset->nrm[v], sizeof(float), 3, fp); - loader->fread(&vset->tu[v], sizeof(float), 1, fp); - loader->fread(&vset->tv[v], sizeof(float), 1, fp); - - vset->loc[v] *= (float) scale; - - Vec3 vert = vset->loc[v]; - - double d = vert.length(); - if (d > radius) - radius = (float) d; - - if (vert.x > extents[0]) extents[0] = vert.x; - if (vert.x < extents[1]) extents[1] = vert.x; - if (vert.y > extents[2]) extents[2] = vert.y; - if (vert.y < extents[3]) extents[3] = vert.y; - if (vert.z > extents[4]) extents[4] = vert.z; - if (vert.z < extents[5]) extents[5] = vert.z; - } - - // read polys: - for (int n = 0; n < npolys; n++) { - Poly& poly = polys[n]; - BYTE poly_nverts = 0; - BYTE material_index = 0; - WORD poly_verts[8]; - - loader->fread(&poly_nverts, sizeof(BYTE), 1, fp); - loader->fread(&material_index, sizeof(BYTE), 1, fp); - loader->fread(&poly_verts[0], sizeof(WORD), poly_nverts, fp); - - if (poly_nverts >= 3) { - poly.nverts = poly_nverts; - - for (int i = 0; i < poly_nverts; i++) { - poly.verts[i] = poly_verts[i]; - } - } - else { - poly.sortval = 666; - } - - if (material_index > 0) { - poly.material = materials[material_index-1]; - poly.sortval = material_index; - } - else if (materials.size()) { - poly.material = materials.first(); - poly.sortval = 1; - } - else { - poly.sortval = 1000; - } - - if (poly.nverts == 3) - surface->AddIndices(3); - - else if (poly.nverts == 4) - surface->AddIndices(6); - - poly.vertex_set = vset; - poly.plane = Plane(vset->loc[poly.verts[0]], - vset->loc[poly.verts[2]], - vset->loc[poly.verts[1]]); - } - - // sort the polys by material index: - qsort((void*) polys, npolys, sizeof(Poly), mcomp); - - // then assign them to cohesive segments: - Segment* segment = 0; - - for (int n = 0; n < npolys; n++) { - if (segment && segment->material == polys[n].material) { - segment->npolys++; - } - else { - segment = 0; - } - - if (!segment) { - segment = new(__FILE__,__LINE__) Segment; - - segment->npolys = 1; - segment->polys = &polys[n]; - segment->material = segment->polys->material; - segment->model = this; - - surface->GetSegments().append(segment); - } - } - - surface->BuildHull(); - surfaces.append(surface); - - this->nverts += nverts; - this->npolys += npolys; - } - - - result = nverts && npolys; - return result; + // read texture list: + if (ntex) { + char* buffer = new(__FILE__,__LINE__) char[ntex]; + char* p = buffer; + Bitmap* bmp = 0; + + loader->fread(buffer, ntex, 1, fp); + + while (p < buffer + ntex) { + loader->LoadTexture(p, bmp, Bitmap::BMP_SOLID, true); + textures.append(bmp); + + p += strlen(p) + 1; + } + + delete [] buffer; + } + + for (int i = 0; i < nmtls; i++) { + MaterialMag6 m6; + Material* mtl = new(__FILE__,__LINE__) Material; + + loader->fread(&m6, sizeof(m6), 1, fp); + + if (mtl) { + CopyMemory(mtl->name, m6.name, Material::NAMELEN); + CopyMemory(mtl->shader, m6.shader, Material::NAMELEN); + + mtl->ambient_value = m6.ambient_value; + mtl->ambient_color = m6.ambient_color; + mtl->diffuse_value = m6.diffuse_value; + mtl->diffuse_color = m6.diffuse_color; + mtl->specular_value = m6.specular_value; + mtl->specular_color = m6.specular_color; + mtl->emissive_value = m6.emissive_value; + mtl->emissive_color = m6.emissive_color; + + mtl->Ka = ColorValue(mtl->ambient_color) * mtl->ambient_value; + mtl->Kd = ColorValue(mtl->diffuse_color) * mtl->diffuse_value; + mtl->Ks = ColorValue(mtl->specular_color) * mtl->specular_value; + mtl->Ke = ColorValue(mtl->emissive_color) * mtl->emissive_value; + + mtl->power = m6.power; + mtl->brilliance = m6.brilliance; + mtl->bump = m6.bump; + mtl->blend = m6.blend; + mtl->shadow = m6.shadow; + mtl->luminous = m6.luminous; + + if (m6.tex_diffuse && m6.tex_diffuse <= textures.size()) + mtl->tex_diffuse = textures[m6.tex_diffuse - 1]; + + if (m6.tex_specular && m6.tex_specular <= textures.size()) + mtl->tex_specular = textures[m6.tex_specular - 1]; + + if (m6.tex_emissive && m6.tex_emissive <= textures.size()) + mtl->tex_emissive = textures[m6.tex_emissive - 1]; + + if (m6.tex_bumpmap && m6.tex_bumpmap <= textures.size()) + mtl->tex_bumpmap = textures[m6.tex_bumpmap - 1]; + + materials.append(mtl); + } + } + + for (int i = 0; i < nsurfs; i++) { + int nverts = 0; + int npolys = 0; + BYTE namelen = 0; + char name[128]; + + loader->fread(&nverts, 4, 1, fp); + loader->fread(&npolys, 4, 1, fp); + loader->fread(&namelen, 1, 1, fp); + loader->fread(name, 1, namelen, fp); + + Surface* surface = new(__FILE__,__LINE__) Surface; + surface->model = this; + surface->SetName(name); + surface->CreateVerts(nverts); + surface->CreatePolys(npolys); + + VertexSet* vset = surface->GetVertexSet(); + Poly* polys = surface->GetPolys(); + + ZeroMemory(polys, sizeof(Poly) * npolys); + + // read vertex set: + for (int v = 0; v < nverts; v++) { + loader->fread(&vset->loc[v], sizeof(float), 3, fp); + loader->fread(&vset->nrm[v], sizeof(float), 3, fp); + loader->fread(&vset->tu[v], sizeof(float), 1, fp); + loader->fread(&vset->tv[v], sizeof(float), 1, fp); + + vset->loc[v] *= (float) scale; + + Vec3 vert = vset->loc[v]; + + double d = vert.length(); + if (d > radius) + radius = (float) d; + + if (vert.x > extents[0]) extents[0] = vert.x; + if (vert.x < extents[1]) extents[1] = vert.x; + if (vert.y > extents[2]) extents[2] = vert.y; + if (vert.y < extents[3]) extents[3] = vert.y; + if (vert.z > extents[4]) extents[4] = vert.z; + if (vert.z < extents[5]) extents[5] = vert.z; + } + + // read polys: + for (int n = 0; n < npolys; n++) { + Poly& poly = polys[n]; + BYTE poly_nverts = 0; + BYTE material_index = 0; + WORD poly_verts[8]; + + loader->fread(&poly_nverts, sizeof(BYTE), 1, fp); + loader->fread(&material_index, sizeof(BYTE), 1, fp); + loader->fread(&poly_verts[0], sizeof(WORD), poly_nverts, fp); + + if (poly_nverts >= 3) { + poly.nverts = poly_nverts; + + for (int i = 0; i < poly_nverts; i++) { + poly.verts[i] = poly_verts[i]; + } + } + else { + poly.sortval = 666; + } + + if (material_index > 0) { + poly.material = materials[material_index-1]; + poly.sortval = material_index; + } + else if (materials.size()) { + poly.material = materials.first(); + poly.sortval = 1; + } + else { + poly.sortval = 1000; + } + + if (poly.nverts == 3) + surface->AddIndices(3); + + else if (poly.nverts == 4) + surface->AddIndices(6); + + poly.vertex_set = vset; + poly.plane = Plane(vset->loc[poly.verts[0]], + vset->loc[poly.verts[2]], + vset->loc[poly.verts[1]]); + } + + // sort the polys by material index: + qsort((void*) polys, npolys, sizeof(Poly), mcomp); + + // then assign them to cohesive segments: + Segment* segment = 0; + + for (int n = 0; n < npolys; n++) { + if (segment && segment->material == polys[n].material) { + segment->npolys++; + } + else { + segment = 0; + } + + if (!segment) { + segment = new(__FILE__,__LINE__) Segment; + + segment->npolys = 1; + segment->polys = &polys[n]; + segment->material = segment->polys->material; + segment->model = this; + + surface->GetSegments().append(segment); + } + } + + surface->BuildHull(); + surfaces.append(surface); + + this->nverts += nverts; + this->npolys += npolys; + } + + + result = nverts && npolys; + return result; } void Model::AddSurface(Surface* surface) { - if (surface) { - surface->model = this; + if (surface) { + surface->model = this; - ListIter iter = surface->segments; - while (++iter) { - Segment* segment = iter.value(); - segment->model = this; - } + ListIter iter = surface->segments; + while (++iter) { + Segment* segment = iter.value(); + segment->model = this; + } - surface->BuildHull(); - surfaces.append(surface); + surface->BuildHull(); + surfaces.append(surface); - nverts += surface->NumVerts(); - npolys += surface->NumPolys(); - } + nverts += surface->NumVerts(); + npolys += surface->NumPolys(); + } } @@ -1562,49 +1562,49 @@ Model::AddSurface(Surface* surface) const Material* Model::FindMaterial(const char* mtl_name) const { - if (mtl_name && *mtl_name) { - Model* pThis = (Model*) this; + if (mtl_name && *mtl_name) { + Model* pThis = (Model*) this; - ListIter iter = pThis->materials; - while (++iter) { - Material* mtl = iter.value(); + ListIter iter = pThis->materials; + while (++iter) { + Material* mtl = iter.value(); - if (!strcmp(mtl->name, mtl_name)) - return mtl; - } - } + if (!strcmp(mtl->name, mtl_name)) + return mtl; + } + } - return 0; + return 0; } const Material* Model::ReplaceMaterial(const Material* mtl) { - const Material* mtl_orig = 0; + const Material* mtl_orig = 0; - if (mtl) { - mtl_orig = FindMaterial(mtl->name); + if (mtl) { + mtl_orig = FindMaterial(mtl->name); - if (mtl_orig) { - int n = materials.index(mtl_orig); - materials[n] = (Material*) mtl; + if (mtl_orig) { + int n = materials.index(mtl_orig); + materials[n] = (Material*) mtl; - ListIter surf_iter = surfaces; - while (++surf_iter) { - Surface* surf = surf_iter.value(); + ListIter surf_iter = surfaces; + while (++surf_iter) { + Surface* surf = surf_iter.value(); - ListIter seg_iter = surf->GetSegments(); - while (++seg_iter) { - Segment* segment = seg_iter.value(); + ListIter seg_iter = surf->GetSegments(); + while (++seg_iter) { + Segment* segment = seg_iter.value(); - if (segment->material == mtl_orig) - segment->material = (Material*) mtl; - } - } - } - } + if (segment->material == mtl_orig) + segment->material = (Material*) mtl; + } + } + } + } - return mtl_orig; + return mtl_orig; } // +--------------------------------------------------------------------+ @@ -1612,11 +1612,11 @@ Model::ReplaceMaterial(const Material* mtl) Poly* Model::AddPolys(int nsurf, int np, int nv) { - if (nsurf >= 0 && nsurf < surfaces.size()) - return surfaces[nsurf]->AddPolys(np, nv); + if (nsurf >= 0 && nsurf < surfaces.size()) + return surfaces[nsurf]->AddPolys(np, nv); - ::Print("WARNING: AddPolys(%d,%d,%d) invalid surface\n", nsurf, np, nv); - return 0; + ::Print("WARNING: AddPolys(%d,%d,%d) invalid surface\n", nsurf, np, nv); + return 0; } // +--------------------------------------------------------------------+ @@ -1624,21 +1624,21 @@ Model::AddPolys(int nsurf, int np, int nv) void Model::ExplodeMesh() { - ListIter iter = surfaces; + ListIter iter = surfaces; - int nv = 0; - int np = 0; + int nv = 0; + int np = 0; - while (++iter) { - Surface* s = iter.value(); - s->ExplodeMesh(); + while (++iter) { + Surface* s = iter.value(); + s->ExplodeMesh(); - nv += s->NumVerts(); - np += s->NumPolys(); - } + nv += s->NumVerts(); + np += s->NumPolys(); + } - nverts = nv; - npolys = np; + nverts = nv; + npolys = np; } // +--------------------------------------------------------------------+ @@ -1646,21 +1646,21 @@ Model::ExplodeMesh() void Model::OptimizeMesh() { - ListIter iter = surfaces; + ListIter iter = surfaces; - int nv = 0; - int np = 0; + int nv = 0; + int np = 0; - while (++iter) { - Surface* s = iter.value(); - s->OptimizeMesh(); + while (++iter) { + Surface* s = iter.value(); + s->OptimizeMesh(); - nv += s->NumVerts(); - np += s->NumPolys(); - } + nv += s->NumVerts(); + np += s->NumPolys(); + } - nverts = nv; - npolys = np; + nverts = nv; + npolys = np; } // +--------------------------------------------------------------------+ @@ -1668,40 +1668,40 @@ Model::OptimizeMesh() void Model::OptimizeMaterials() { - for (int i = 0; i < materials.size(); i++) { - Material* m1 = materials[i]; + for (int i = 0; i < materials.size(); i++) { + Material* m1 = materials[i]; - for (int n = i; n < materials.size(); n++) { - Material* m2 = materials[n]; + for (int n = i; n < materials.size(); n++) { + Material* m2 = materials[n]; - // if they match, merge them: - if (*m1 == *m2) { - List polys; - SelectPolys(polys, m2); + // if they match, merge them: + if (*m1 == *m2) { + List polys; + SelectPolys(polys, m2); - ListIter iter = polys; - while (++iter) { - Poly* p = iter.value(); - p->material = m1; - } + ListIter iter = polys; + while (++iter) { + Poly* p = iter.value(); + p->material = m1; + } - // and discard the duplicate: - materials.remove(m2); - delete m2; - } - } - } + // and discard the duplicate: + materials.remove(m2); + delete m2; + } + } + } } void Model::ScaleBy(double factor) { - ListIter iter = surfaces; + ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - s->ScaleBy(factor); - } + while (++iter) { + Surface* s = iter.value(); + s->ScaleBy(factor); + } } // +--------------------------------------------------------------------+ @@ -1709,45 +1709,45 @@ Model::ScaleBy(double factor) void Model::Normalize() { - ListIter iter = surfaces; + ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - s->Normalize(); - } + while (++iter) { + Surface* s = iter.value(); + s->Normalize(); + } } void Model::SelectPolys(List& polys, Vec3 loc) { - ListIter iter = surfaces; + ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - s->SelectPolys(polys, loc); - } + while (++iter) { + Surface* s = iter.value(); + s->SelectPolys(polys, loc); + } } void Model::SelectPolys(List& polys, Material* m) { - ListIter iter = surfaces; + ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - s->SelectPolys(polys, m); - } + while (++iter) { + Surface* s = iter.value(); + s->SelectPolys(polys, m); + } } void Model::ComputeTangents() { - ListIter iter = surfaces; + ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - s->ComputeTangents(); - } + while (++iter) { + Surface* s = iter.value(); + s->ComputeTangents(); + } } // +--------------------------------------------------------------------+ @@ -1755,27 +1755,27 @@ Model::ComputeTangents() void Model::DeletePrivateData() { - ListIter iter = surfaces; - while (++iter) { - Surface* s = iter.value(); - VideoPrivateData* vpd = s->GetVideoPrivateData(); + ListIter iter = surfaces; + while (++iter) { + Surface* s = iter.value(); + VideoPrivateData* vpd = s->GetVideoPrivateData(); - if (vpd) { - delete vpd; - s->SetVideoPrivateData(0); - } + if (vpd) { + delete vpd; + s->SetVideoPrivateData(0); + } - ListIter seg_iter = s->GetSegments(); - while (++seg_iter) { - Segment* segment = seg_iter.value(); - VideoPrivateData* vpdp = segment->video_data; + ListIter seg_iter = s->GetSegments(); + while (++seg_iter) { + Segment* segment = seg_iter.value(); + VideoPrivateData* vpdp = segment->video_data; - if (vpdp) { - delete vpdp; - segment->video_data = 0; - } - } - } + if (vpdp) { + delete vpdp; + segment->video_data = 0; + } + } + } } // +--------------------------------------------------------------------+ @@ -1783,23 +1783,23 @@ Model::DeletePrivateData() // +--------------------------------------------------------------------+ Surface::Surface() - : model(0), vertex_set(0), vloc(0), nhull(0), npolys(0), nindices(0), - polys(0), state(0), video_data(0), opcode(0) +: model(0), vertex_set(0), vloc(0), nhull(0), npolys(0), nindices(0), +polys(0), state(0), video_data(0), opcode(0) { - ZeroMemory(name, sizeof(name)); + ZeroMemory(name, sizeof(name)); } Surface::~Surface() { - segments.destroy(); + segments.destroy(); - delete opcode; - delete vertex_set; - delete [] vloc; - delete [] polys; - delete video_data; + delete opcode; + delete vertex_set; + delete [] vloc; + delete [] polys; + delete video_data; - model = 0; + model = 0; } // +--------------------------------------------------------------------+ @@ -1807,63 +1807,63 @@ Surface::~Surface() void Surface::Copy(Surface& s, Model* m) { - segments.destroy(); - - delete opcode; - delete vertex_set; - delete [] vloc; - delete [] polys; - delete video_data; - - CopyMemory(name, s.name, Solid::NAMELEN); - - model = m; - radius = s.radius; - nhull = s.nhull; - npolys = s.npolys; - nindices = s.nindices; - state = s.state; - offset = s.offset; - orientation = s.orientation; - opcode = 0; - video_data = 0; - - vertex_set = s.vertex_set->Clone(); - - if (nhull > 0) { - vloc = new(__FILE__,__LINE__) Vec3[nhull]; - CopyMemory(vloc, s.vloc, nhull * sizeof(Vec3)); - } - else { - vloc = 0; - } - - polys = new(__FILE__,__LINE__) Poly[npolys]; - CopyMemory(polys, s.polys, npolys * sizeof(Poly)); - - for (int i = 0; i < npolys; i++) { - polys[i].vertex_set = vertex_set; - - if (s.polys[i].material) - polys[i].material = (Material*) model->FindMaterial(s.polys[i].material->name); - } - - ListIter iter = s.segments; - while (++iter) { - Segment* seg1 = iter.value(); - Segment* seg2 = new(__FILE__,__LINE__) Segment; - - seg2->npolys = seg1->npolys; - seg2->polys = polys + (seg1->polys - s.polys); - - if (seg2->polys[0].material) - seg2->material = seg2->polys[0].material; - - seg2->model = model; - seg2->video_data = 0; - - segments.append(seg2); - } + segments.destroy(); + + delete opcode; + delete vertex_set; + delete [] vloc; + delete [] polys; + delete video_data; + + CopyMemory(name, s.name, Solid::NAMELEN); + + model = m; + radius = s.radius; + nhull = s.nhull; + npolys = s.npolys; + nindices = s.nindices; + state = s.state; + offset = s.offset; + orientation = s.orientation; + opcode = 0; + video_data = 0; + + vertex_set = s.vertex_set->Clone(); + + if (nhull > 0) { + vloc = new(__FILE__,__LINE__) Vec3[nhull]; + CopyMemory(vloc, s.vloc, nhull * sizeof(Vec3)); + } + else { + vloc = 0; + } + + polys = new(__FILE__,__LINE__) Poly[npolys]; + CopyMemory(polys, s.polys, npolys * sizeof(Poly)); + + for (int i = 0; i < npolys; i++) { + polys[i].vertex_set = vertex_set; + + if (s.polys[i].material) + polys[i].material = (Material*) model->FindMaterial(s.polys[i].material->name); + } + + ListIter iter = s.segments; + while (++iter) { + Segment* seg1 = iter.value(); + Segment* seg2 = new(__FILE__,__LINE__) Segment; + + seg2->npolys = seg1->npolys; + seg2->polys = polys + (seg1->polys - s.polys); + + if (seg2->polys[0].material) + seg2->material = seg2->polys[0].material; + + seg2->model = model; + seg2->video_data = 0; + + segments.append(seg2); + } } // +--------------------------------------------------------------------+ @@ -1871,60 +1871,60 @@ Surface::Copy(Surface& s, Model* m) void Surface::SetName(const char* n) { - int len = sizeof(name); + int len = sizeof(name); - ZeroMemory(name, len); - strncpy_s(name, n, len-1); + ZeroMemory(name, len); + strncpy_s(name, n, len-1); } void Surface::SetHidden(bool b) { - if (b) - state = state | HIDDEN; + if (b) + state = state | HIDDEN; - else - state = state & ~HIDDEN; + else + state = state & ~HIDDEN; } void Surface::SetLocked(bool b) { - if (b) - state = state | LOCKED; + if (b) + state = state | LOCKED; - else - state = state & ~LOCKED; + else + state = state & ~LOCKED; } void Surface::SetSimplified(bool b) { - if (b) - state = state | SIMPLE; + if (b) + state = state | SIMPLE; - else - state = state & ~SIMPLE; + else + state = state & ~SIMPLE; } void Surface::CreateVerts(int nverts) { - if (!vertex_set && !vloc) { - vertex_set = new(__FILE__,__LINE__) VertexSet(nverts); - vloc = new(__FILE__,__LINE__) Vec3[nverts]; - } + if (!vertex_set && !vloc) { + vertex_set = new(__FILE__,__LINE__) VertexSet(nverts); + vloc = new(__FILE__,__LINE__) Vec3[nverts]; + } } void Surface::CreatePolys(int np) { - if (!polys && !npolys) { - npolys = np; - polys = new(__FILE__,__LINE__) Poly[npolys]; + if (!polys && !npolys) { + npolys = np; + polys = new(__FILE__,__LINE__) Poly[npolys]; - ZeroMemory(polys, npolys * sizeof(Poly)); - } + ZeroMemory(polys, npolys * sizeof(Poly)); + } } // +--------------------------------------------------------------------+ @@ -1932,35 +1932,35 @@ Surface::CreatePolys(int np) Poly* Surface::AddPolys(int np, int nv) { - if ( polys && vertex_set && - np > 0 && np + npolys < MAX_POLYS && - nv > 0 && nv + vertex_set->nverts < MAX_VERTS) - { - int newverts = nv + vertex_set->nverts; - int newpolys = np + npolys; + if ( polys && vertex_set && + np > 0 && np + npolys < MAX_POLYS && + nv > 0 && nv + vertex_set->nverts < MAX_VERTS) + { + int newverts = nv + vertex_set->nverts; + int newpolys = np + npolys; - vertex_set->Resize(newverts, true); + vertex_set->Resize(newverts, true); - Poly* pset = new(__FILE__,__LINE__) Poly[newpolys]; - Poly* pnew = pset + npolys; + Poly* pset = new(__FILE__,__LINE__) Poly[newpolys]; + Poly* pnew = pset + npolys; - CopyMemory(pset, polys, npolys * sizeof(Poly)); - ZeroMemory(pnew, np * sizeof(Poly)); + CopyMemory(pset, polys, npolys * sizeof(Poly)); + ZeroMemory(pnew, np * sizeof(Poly)); - if (segments.size() > 0) { - Segment* seg = segments.last(); - Material* mtl = seg->material; - - for (int i = 0; i < np; i++) { - Poly* p = pnew + i; - p->material = mtl; - } + if (segments.size() > 0) { + Segment* seg = segments.last(); + Material* mtl = seg->material; + + for (int i = 0; i < np; i++) { + Poly* p = pnew + i; + p->material = mtl; + } - seg->npolys += np; - } - } + seg->npolys += np; + } + } - return 0; + return 0; } // +--------------------------------------------------------------------+ @@ -1968,55 +1968,55 @@ Surface::AddPolys(int np, int nv) void Surface::ExplodeMesh() { - if (!vertex_set || vertex_set->nverts < 3) - return; + if (!vertex_set || vertex_set->nverts < 3) + return; - int i, j, v; - int nverts = 0; + int i, j, v; + int nverts = 0; - // count max verts: - for (i = 0; i < npolys; i++) { - Poly* p = polys + i; - nverts += p->nverts; - } + // count max verts: + for (i = 0; i < npolys; i++) { + Poly* p = polys + i; + nverts += p->nverts; + } - // create target vertex set: - VertexSet* vset = new(__FILE__,__LINE__) VertexSet(nverts); - v = 0; + // create target vertex set: + VertexSet* vset = new(__FILE__,__LINE__) VertexSet(nverts); + v = 0; - // explode verts: - for (i = 0; i < npolys; i++) { - Poly* p = polys + i; - p->vertex_set = vset; + // explode verts: + for (i = 0; i < npolys; i++) { + Poly* p = polys + i; + p->vertex_set = vset; - for (j = 0; j < p->nverts; j++) { - int vsrc = p->verts[j]; + for (j = 0; j < p->nverts; j++) { + int vsrc = p->verts[j]; - vset->loc[v] = vertex_set->loc[vsrc]; - vset->nrm[v] = vertex_set->nrm[vsrc]; - vset->tu[v] = vertex_set->tu[vsrc]; - vset->tv[v] = vertex_set->tv[vsrc]; - vset->rw[v] = vertex_set->rw[vsrc]; - vset->diffuse[v] = vertex_set->diffuse[vsrc]; - vset->specular[v] = vertex_set->specular[vsrc]; + vset->loc[v] = vertex_set->loc[vsrc]; + vset->nrm[v] = vertex_set->nrm[vsrc]; + vset->tu[v] = vertex_set->tu[vsrc]; + vset->tv[v] = vertex_set->tv[vsrc]; + vset->rw[v] = vertex_set->rw[vsrc]; + vset->diffuse[v] = vertex_set->diffuse[vsrc]; + vset->specular[v] = vertex_set->specular[vsrc]; - p->verts[j] = v++; - } - } + p->verts[j] = v++; + } + } - // finalize: - if (vset) { - delete vertex_set; - vertex_set = vset; - } + // finalize: + if (vset) { + delete vertex_set; + vertex_set = vset; + } - if (vloc) - delete [] vloc; + if (vloc) + delete [] vloc; - vloc = new(__FILE__,__LINE__) Vec3[nverts]; + vloc = new(__FILE__,__LINE__) Vec3[nverts]; - ComputeTangents(); - BuildHull(); + ComputeTangents(); + BuildHull(); } // +--------------------------------------------------------------------+ @@ -2026,141 +2026,141 @@ const double SELECT_TEXTURE = 0.0001; static bool MatchVerts(VertexSet* vset, int i, int j) { - double d = 0; - const Vec3& vl1 = vset->loc[i]; - const Vec3& vn1 = vset->nrm[i]; - float tu1 = vset->tu[i]; - float tv1 = vset->tv[i]; - const Vec3& vl2 = vset->loc[j]; - const Vec3& vn2 = vset->nrm[j]; - float tu2 = vset->tu[j]; - float tv2 = vset->tv[j]; + double d = 0; + const Vec3& vl1 = vset->loc[i]; + const Vec3& vn1 = vset->nrm[i]; + float tu1 = vset->tu[i]; + float tv1 = vset->tv[i]; + const Vec3& vl2 = vset->loc[j]; + const Vec3& vn2 = vset->nrm[j]; + float tu2 = vset->tu[j]; + float tv2 = vset->tv[j]; - d = fabs(vl1.x - vl2.x); - if (d > SELECT_EPSILON) - return false; + d = fabs(vl1.x - vl2.x); + if (d > SELECT_EPSILON) + return false; - d = fabs(vl1.y - vl2.y); - if (d > SELECT_EPSILON) - return false; + d = fabs(vl1.y - vl2.y); + if (d > SELECT_EPSILON) + return false; - d = fabs(vl1.z - vl2.z); - if (d > SELECT_EPSILON) - return false; + d = fabs(vl1.z - vl2.z); + if (d > SELECT_EPSILON) + return false; - d = fabs(vn1.x - vn2.x); - if (d > SELECT_EPSILON) - return false; + d = fabs(vn1.x - vn2.x); + if (d > SELECT_EPSILON) + return false; - d = fabs(vn1.y - vn2.y); - if (d > SELECT_EPSILON) - return false; + d = fabs(vn1.y - vn2.y); + if (d > SELECT_EPSILON) + return false; - d = fabs(vn1.z - vn2.z); - if (d > SELECT_EPSILON) - return false; + d = fabs(vn1.z - vn2.z); + if (d > SELECT_EPSILON) + return false; - d = fabs(tu1 - tu2); - if (d > SELECT_TEXTURE) - return false; + d = fabs(tu1 - tu2); + if (d > SELECT_TEXTURE) + return false; - d = fabs(tv1 - tv2); - if (d > SELECT_TEXTURE) - return false; + d = fabs(tv1 - tv2); + if (d > SELECT_TEXTURE) + return false; - return true; + return true; } void Surface::OptimizeMesh() { - if (!vertex_set || vertex_set->nverts < 3) - return; - - int nverts = vertex_set->nverts; - int used = 0; - int final = 0; - int nmatch = 0; - - // create vertex maps: - BYTE* vert_map = new BYTE[nverts]; - WORD* vert_dst = new WORD[nverts]; - ZeroMemory(vert_map, nverts * sizeof(BYTE)); - ZeroMemory(vert_dst, nverts * sizeof(WORD)); - - // count used verts: - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; - - for (int j = 0; j < p->nverts; j++) { - WORD vert = p->verts[j]; - - if (vert < nverts) { - vert_map[vert]++; - used++; - } - } - } - - // create target vertex set: - VertexSet* vset = new(__FILE__,__LINE__) VertexSet(used); - int v = 0; - - // compress verts: - for (int i = 0; i < nverts; i++) { - if (vert_map[i] == 0) continue; - - vert_dst[i] = v; - vset->loc[v] = vertex_set->loc[i]; - vset->nrm[v] = vertex_set->nrm[i]; - vset->tu[v] = vertex_set->tu[i]; - vset->tv[v] = vertex_set->tv[i]; - vset->rw[v] = vertex_set->rw[i]; - vset->diffuse[v] = vertex_set->diffuse[i]; - vset->specular[v] = vertex_set->specular[i]; - - for (int j = i+1; j < nverts; j++) { - if (vert_map[j] == 0) continue; - - if (MatchVerts(vertex_set, i, j)) { - vert_map[j] = 0; - vert_dst[j] = v; - nmatch++; - } - } - - v++; - } - - final = v; - - // remap polys: - for (int n = 0; n < npolys; n++) { - Poly* p = polys + n; - p->vertex_set = vset; - for (int v = 0; v < p->nverts; v++) { - p->verts[v] = vert_dst[ p->verts[v] ]; - } - } - - // finalize: - if (vset && final < nverts) { - delete vertex_set; - vertex_set = vset; - vset->Resize(final, true); - nverts = final; - } - - // clean up and rebuild hull: - delete [] vert_map; - - if (vloc) - delete [] vloc; - - vloc = new(__FILE__,__LINE__) Vec3[nverts]; - - ComputeTangents(); - BuildHull(); + if (!vertex_set || vertex_set->nverts < 3) + return; + + int nverts = vertex_set->nverts; + int used = 0; + int final = 0; + int nmatch = 0; + + // create vertex maps: + BYTE* vert_map = new BYTE[nverts]; + WORD* vert_dst = new WORD[nverts]; + ZeroMemory(vert_map, nverts * sizeof(BYTE)); + ZeroMemory(vert_dst, nverts * sizeof(WORD)); + + // count used verts: + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; + + for (int j = 0; j < p->nverts; j++) { + WORD vert = p->verts[j]; + + if (vert < nverts) { + vert_map[vert]++; + used++; + } + } + } + + // create target vertex set: + VertexSet* vset = new(__FILE__,__LINE__) VertexSet(used); + int v = 0; + + // compress verts: + for (int i = 0; i < nverts; i++) { + if (vert_map[i] == 0) continue; + + vert_dst[i] = v; + vset->loc[v] = vertex_set->loc[i]; + vset->nrm[v] = vertex_set->nrm[i]; + vset->tu[v] = vertex_set->tu[i]; + vset->tv[v] = vertex_set->tv[i]; + vset->rw[v] = vertex_set->rw[i]; + vset->diffuse[v] = vertex_set->diffuse[i]; + vset->specular[v] = vertex_set->specular[i]; + + for (int j = i+1; j < nverts; j++) { + if (vert_map[j] == 0) continue; + + if (MatchVerts(vertex_set, i, j)) { + vert_map[j] = 0; + vert_dst[j] = v; + nmatch++; + } + } + + v++; + } + + final = v; + + // remap polys: + for (int n = 0; n < npolys; n++) { + Poly* p = polys + n; + p->vertex_set = vset; + for (int v = 0; v < p->nverts; v++) { + p->verts[v] = vert_dst[ p->verts[v] ]; + } + } + + // finalize: + if (vset && final < nverts) { + delete vertex_set; + vertex_set = vset; + vset->Resize(final, true); + nverts = final; + } + + // clean up and rebuild hull: + delete [] vert_map; + + if (vloc) + delete [] vloc; + + vloc = new(__FILE__,__LINE__) Vec3[nverts]; + + ComputeTangents(); + BuildHull(); } // +--------------------------------------------------------------------+ @@ -2168,13 +2168,13 @@ Surface::OptimizeMesh() void Surface::ScaleBy(double factor) { - offset *= factor; + offset *= factor; - if (vertex_set && vertex_set->nverts) { - for (int i = 0; i < vertex_set->nverts; i++) { - vertex_set->loc[i] *= (float) factor; - } - } + if (vertex_set && vertex_set->nverts) { + for (int i = 0; i < vertex_set->nverts; i++) { + vertex_set->loc[i] *= (float) factor; + } + } } // +--------------------------------------------------------------------+ @@ -2182,53 +2182,53 @@ Surface::ScaleBy(double factor) void Surface::BuildHull() { - if (npolys < 1 || !vertex_set || vertex_set->nverts < 1) - return; + if (npolys < 1 || !vertex_set || vertex_set->nverts < 1) + return; - nhull = 0; + nhull = 0; - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - for (int n = 0; n < p->nverts; n++) { - WORD v = p->verts[n]; - WORD h; + for (int n = 0; n < p->nverts; n++) { + WORD v = p->verts[n]; + WORD h; - for (h = 0; h < nhull; h++) { - Vec3& vl = vertex_set->loc[v]; - Vec3& loc = vloc[h]; + for (h = 0; h < nhull; h++) { + Vec3& vl = vertex_set->loc[v]; + Vec3& loc = vloc[h]; - double d = vl.x - loc.x; + double d = vl.x - loc.x; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - d = vl.y - loc.y; + d = vl.y - loc.y; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - d = vl.z - loc.z; + d = vl.z - loc.z; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - // found a match: - break; - } + // found a match: + break; + } - // didn't find a match: - if (h >= nhull) { - vloc[h] = vertex_set->loc[v]; - nhull = h+1; - } + // didn't find a match: + if (h >= nhull) { + vloc[h] = vertex_set->loc[v]; + nhull = h+1; + } - p->vlocs[n] = h; - } - } + p->vlocs[n] = h; + } + } - if (use_collision_detection) - InitializeCollisionHull(); + if (use_collision_detection) + InitializeCollisionHull(); } // +--------------------------------------------------------------------+ @@ -2236,101 +2236,101 @@ Surface::BuildHull() void Surface::Normalize() { - if (npolys < 1 || !vertex_set || vertex_set->nverts < 1) - return; + if (npolys < 1 || !vertex_set || vertex_set->nverts < 1) + return; - // STEP ONE: initialize poly planes + // STEP ONE: initialize poly planes - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - p->plane = Plane( vertex_set->loc[ p->verts[0] ], - vertex_set->loc[ p->verts[2] ], - vertex_set->loc[ p->verts[1] ] ); - } + p->plane = Plane( vertex_set->loc[ p->verts[0] ], + vertex_set->loc[ p->verts[2] ], + vertex_set->loc[ p->verts[1] ] ); + } - // STEP TWO: compute vertex normals by averaging adjecent poly planes + // STEP TWO: compute vertex normals by averaging adjecent poly planes - List faces; - for (int v = 0; v < vertex_set->nverts; v++) { - faces.clear(); - SelectPolys(faces, vertex_set->loc[v]); + List faces; + for (int v = 0; v < vertex_set->nverts; v++) { + faces.clear(); + SelectPolys(faces, vertex_set->loc[v]); - if (faces.size()) { - vertex_set->nrm[v] = Vec3(0.0f, 0.0f, 0.0f); + if (faces.size()) { + vertex_set->nrm[v] = Vec3(0.0f, 0.0f, 0.0f); - for (int i = 0; i < faces.size(); i++) { - vertex_set->nrm[v] += faces[i]->plane.normal; - } + for (int i = 0; i < faces.size(); i++) { + vertex_set->nrm[v] += faces[i]->plane.normal; + } - vertex_set->nrm[v].Normalize(); - } + vertex_set->nrm[v].Normalize(); + } - else if (vertex_set->loc[v].length() > 0) { - vertex_set->nrm[v] = vertex_set->loc[v]; - vertex_set->nrm[v].Normalize(); - } + else if (vertex_set->loc[v].length() > 0) { + vertex_set->nrm[v] = vertex_set->loc[v]; + vertex_set->nrm[v].Normalize(); + } - else { - vertex_set->nrm[v] = Vec3(0.0f, 1.0f, 0.0f); - } - } + else { + vertex_set->nrm[v] = Vec3(0.0f, 1.0f, 0.0f); + } + } - // STEP THREE: adjust vertex normals for poly flatness + // STEP THREE: adjust vertex normals for poly flatness - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - for (int n = 0; n < p->nverts; n++) { - int v = p->verts[n]; + for (int n = 0; n < p->nverts; n++) { + int v = p->verts[n]; - vertex_set->nrm[v] = vertex_set->nrm[v] * (1.0f - p->flatness) + - p->plane.normal * ( p->flatness); - } - } + vertex_set->nrm[v] = vertex_set->nrm[v] * (1.0f - p->flatness) + + p->plane.normal * ( p->flatness); + } + } } void Surface::SelectPolys(List& selection, Vec3 loc) { - const double SELECT_EPSILON = 0.05; + const double SELECT_EPSILON = 0.05; - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - for (int n = 0; n < p->nverts; n++) { - int v = p->verts[n]; - Vec3& vl = vertex_set->loc[v]; - double d = vl.x - loc.x; + for (int n = 0; n < p->nverts; n++) { + int v = p->verts[n]; + Vec3& vl = vertex_set->loc[v]; + double d = vl.x - loc.x; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - d = vl.y - loc.y; + d = vl.y - loc.y; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - d = vl.z - loc.z; + d = vl.z - loc.z; - if (d < -SELECT_EPSILON || d > SELECT_EPSILON) - continue; + if (d < -SELECT_EPSILON || d > SELECT_EPSILON) + continue; - selection.append(p); - break; - } - } + selection.append(p); + break; + } + } } void Surface::SelectPolys(List& selection, Material* m) { - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - if (p->material == m) - selection.append(p); - } + if (p->material == m) + selection.append(p); + } } // +--------------------------------------------------------------------+ @@ -2338,72 +2338,72 @@ Surface::SelectPolys(List& selection, Material* m) void Surface::ComputeTangents() { - Vec3 tangent; - Vec3 binormal; + Vec3 tangent; + Vec3 binormal; - if (!vertex_set || !vertex_set->nverts) - return; + if (!vertex_set || !vertex_set->nverts) + return; - if (vertex_set->tangent) - return; + if (vertex_set->tangent) + return; - vertex_set->CreateTangents(); + vertex_set->CreateTangents(); - for (int i = 0; i < npolys; i++) { - Poly* p = polys + i; + for (int i = 0; i < npolys; i++) { + Poly* p = polys + i; - CalcGradients(*p, tangent, binormal); + CalcGradients(*p, tangent, binormal); - for (int n = 0; n < p->nverts; n++) { - vertex_set->tangent[p->verts[n]] = tangent; - vertex_set->binormal[p->verts[n]] = binormal; - } - } + for (int n = 0; n < p->nverts; n++) { + vertex_set->tangent[p->verts[n]] = tangent; + vertex_set->binormal[p->verts[n]] = binormal; + } + } } void Surface::CalcGradients(Poly& p, Vec3& tangent, Vec3& binormal) { - // using Eric Lengyel's approach with a few modifications - // from Mathematics for 3D Game Programmming and Computer Graphics - // want to be able to trasform a vector in Object Space to Tangent Space - // such that the x-axis cooresponds to the 's' direction and the - // y-axis corresponds to the 't' direction, and the z-axis corresponds - // to <0,0,1>, straight up out of the texture map + // using Eric Lengyel's approach with a few modifications + // from Mathematics for 3D Game Programmming and Computer Graphics + // want to be able to trasform a vector in Object Space to Tangent Space + // such that the x-axis cooresponds to the 's' direction and the + // y-axis corresponds to the 't' direction, and the z-axis corresponds + // to <0,0,1>, straight up out of the texture map - VertexSet* vset = p.vertex_set; + VertexSet* vset = p.vertex_set; - Vec3 P = vset->loc[p.verts[1]] - vset->loc[p.verts[0]]; - Vec3 Q = vset->loc[p.verts[2]] - vset->loc[p.verts[0]]; + Vec3 P = vset->loc[p.verts[1]] - vset->loc[p.verts[0]]; + Vec3 Q = vset->loc[p.verts[2]] - vset->loc[p.verts[0]]; - float s1 = vset->tu[p.verts[1]] - vset->tu[p.verts[0]]; - float t1 = vset->tv[p.verts[1]] - vset->tv[p.verts[0]]; - float s2 = vset->tu[p.verts[2]] - vset->tu[p.verts[0]]; - float t2 = vset->tv[p.verts[2]] - vset->tv[p.verts[0]]; + float s1 = vset->tu[p.verts[1]] - vset->tu[p.verts[0]]; + float t1 = vset->tv[p.verts[1]] - vset->tv[p.verts[0]]; + float s2 = vset->tu[p.verts[2]] - vset->tu[p.verts[0]]; + float t2 = vset->tv[p.verts[2]] - vset->tv[p.verts[0]]; - float tmp = 1.0f; - float denom = s1*t2 - s2*t1; + float tmp = 1.0f; + float denom = s1*t2 - s2*t1; - if (fabsf(denom) > 0.0001f) - tmp = 1.0f/(denom); + if (fabsf(denom) > 0.0001f) + tmp = 1.0f/(denom); - tangent.x = (t2*P.x - t1*Q.x) * tmp; - tangent.y = (t2*P.y - t1*Q.y) * tmp; - tangent.z = (t2*P.z - t1*Q.z) * tmp; + tangent.x = (t2*P.x - t1*Q.x) * tmp; + tangent.y = (t2*P.y - t1*Q.y) * tmp; + tangent.z = (t2*P.z - t1*Q.z) * tmp; - tangent.Normalize(); + tangent.Normalize(); - binormal.x = (s1*Q.x - s2*P.x) * tmp; - binormal.y = (s1*Q.y - s2*P.y) * tmp; - binormal.z = (s1*Q.z - s2*P.z) * tmp; + binormal.x = (s1*Q.x - s2*P.x) * tmp; + binormal.y = (s1*Q.y - s2*P.y) * tmp; + binormal.z = (s1*Q.z - s2*P.z) * tmp; - binormal.Normalize(); + binormal.Normalize(); } void Surface::InitializeCollisionHull() { - opcode = new(__FILE__,__LINE__) OPCODE_data(this); + opcode = new(__FILE__,__LINE__) OPCODE_data(this); } // +--------------------------------------------------------------------+ @@ -2412,19 +2412,19 @@ Surface::InitializeCollisionHull() Segment::Segment() { - ZeroMemory(this, sizeof(Segment)); + ZeroMemory(this, sizeof(Segment)); } Segment::Segment(int n, Poly* p, Material* mtl, Model* mod) - : npolys(n), polys(p), material(mtl), model(mod), video_data(0) +: npolys(n), polys(p), material(mtl), model(mod), video_data(0) { } Segment::~Segment() { - delete video_data; + delete video_data; - ZeroMemory(this, sizeof(Segment)); + ZeroMemory(this, sizeof(Segment)); } // +--------------------------------------------------------------------+ @@ -2432,12 +2432,12 @@ Segment::~Segment() // +--------------------------------------------------------------------+ ModelFile::ModelFile(const char* fname) - : model(0), pname(0), pnverts(0), pnpolys(0), pradius(0) +: model(0), pname(0), pnverts(0), pnpolys(0), pradius(0) { - int len = sizeof(filename); - ZeroMemory(filename, len); - strncpy_s(filename, fname, len); - filename[len-1] = 0; + int len = sizeof(filename); + ZeroMemory(filename, len); + strncpy_s(filename, fname, len); + filename[len-1] = 0; } ModelFile::~ModelFile() @@ -2447,34 +2447,34 @@ ModelFile::~ModelFile() bool ModelFile::Load(Model* m, double scale) { - model = m; + model = m; - // expose model innards for child classes: + // expose model innards for child classes: - if (model) { - pname = model->name; - pnverts = &model->nverts; - pnpolys = &model->npolys; - pradius = &model->radius; - } + if (model) { + pname = model->name; + pnverts = &model->nverts; + pnpolys = &model->npolys; + pradius = &model->radius; + } - return false; + return false; } bool ModelFile::Save(Model* m) { - model = m; + model = m; - // expose model innards for child classes: + // expose model innards for child classes: - if (model) { - pname = model->name; - pnverts = &model->nverts; - pnpolys = &model->npolys; - pradius = &model->radius; - } + if (model) { + pname = model->name; + pnverts = &model->nverts; + pnpolys = &model->npolys; + pradius = &model->radius; + } - return false; + return false; } -- cgit v1.1