added everything
This commit is contained in:
Metario
742
engine/constructor/constructorSimpleMesh.cc
Executable file
742
engine/constructor/constructorSimpleMesh.cc
Executable file
@ -0,0 +1,742 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
// Torque Game Engine
|
||||
// Copyright (C) GarageGames.com, Inc.
|
||||
//-----------------------------------------------------------------------------
|
||||
#include "constructor/constructorSimpleMesh.h"
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
#include "constructor/lightingSystem/lightingSystem.h"
|
||||
#else
|
||||
#include "interior/interiorLMManager.h"
|
||||
#endif
|
||||
|
||||
#include "console/console.h"
|
||||
#include "sim/sceneObject.h"
|
||||
#include "util/triRayCheck.h"
|
||||
#include "math/mathIO.h"
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
ConstructorSimpleMesh *ConstructorSimpleMeshLoader::currentMesh = NULL;
|
||||
#endif
|
||||
|
||||
// *** DAW: Checks for polygon level collision with given planes
|
||||
U32 _whichSide(PlaneF pln, Point3F* verts)
|
||||
{
|
||||
Point3F currv, nextv;
|
||||
S32 csd, nsd;
|
||||
|
||||
// Find out which side the first vert is on
|
||||
U32 side = PlaneF::On;
|
||||
currv = verts[0];
|
||||
csd = pln.whichSide(currv);
|
||||
if(csd != PlaneF::On)
|
||||
side = csd;
|
||||
|
||||
for(U32 k = 1; k < 3; k++)
|
||||
{
|
||||
nextv = verts[k];
|
||||
nsd = pln.whichSide(nextv);
|
||||
if((csd == PlaneF::Back && nsd == PlaneF::Front) ||
|
||||
(csd == PlaneF::Front && nsd == PlaneF::Back))
|
||||
return 2;
|
||||
else if (nsd != PlaneF::On)
|
||||
side = nsd;
|
||||
currv = nextv;
|
||||
csd = nsd;
|
||||
}
|
||||
|
||||
// Loop back to the first vert
|
||||
nextv = verts[0];
|
||||
nsd = pln.whichSide(nextv);
|
||||
if((csd == PlaneF::Back && nsd == PlaneF::Front) ||
|
||||
(csd == PlaneF::Front && nsd == PlaneF::Back))
|
||||
return 2;
|
||||
else if(nsd != PlaneF::On)
|
||||
side = nsd;
|
||||
return side;
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool ConstructorSimpleMesh::castRay(const Point3F &start, const Point3F &end, RayInfo* info)
|
||||
{
|
||||
bool found = false;
|
||||
F32 best_t = F32_MAX;
|
||||
Point3F best_normal = Point3F(0, 0, 1);
|
||||
Point3F dir = end - start;
|
||||
|
||||
for(U32 p=0; p<primitives.size(); p++)
|
||||
{
|
||||
primitive &prim = primitives[p];
|
||||
for(U32 t=2; t<prim.count; t++)
|
||||
{
|
||||
Point3F &v1 = verts[prim.start+t-2];
|
||||
Point3F &v2 = verts[prim.start+t-1];
|
||||
Point3F &v3 = verts[prim.start+t];
|
||||
|
||||
F32 cur_t = 0;
|
||||
Point2F b;
|
||||
|
||||
if(castRayTriangle(start, dir, v1, v2, v3, cur_t, b))
|
||||
{
|
||||
if(cur_t < best_t)
|
||||
{
|
||||
best_t = cur_t;
|
||||
best_normal = norms[prim.start+t];
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(found && info)
|
||||
{
|
||||
info->t = best_t;
|
||||
info->normal = best_normal;
|
||||
info->material = 0;
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
bool ConstructorSimpleMesh::castPlanes(PlaneF left, PlaneF right, PlaneF top, PlaneF bottom)
|
||||
{
|
||||
for(U32 p=0; p<primitives.size(); p++)
|
||||
{
|
||||
primitive &prim = primitives[p];
|
||||
for(U32 t=2; t<prim.count; t++)
|
||||
{
|
||||
Point3F v[3];
|
||||
v[0] = verts[prim.start+t-2];
|
||||
v[1] = verts[prim.start+t-1];
|
||||
v[2] = verts[prim.start+t];
|
||||
|
||||
if(_whichSide(left, v) == PlaneF::Front)
|
||||
continue;
|
||||
if(_whichSide(right, v) == PlaneF::Front)
|
||||
continue;
|
||||
if(_whichSide(top, v) == PlaneF::Front)
|
||||
continue;
|
||||
if(_whichSide(bottom, v) == PlaneF::Front)
|
||||
continue;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
void ConstructorSimpleMesh::render(bool transparent, bool texture, bool lightmap)
|
||||
{
|
||||
#else
|
||||
void ConstructorSimpleMesh::render(bool transparent, bool texture, bool lightmap,
|
||||
U32 interiorlmhandle, U32 instancelmhandle)
|
||||
{
|
||||
if(!materialList)
|
||||
return;
|
||||
#endif
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(3, GL_FLOAT, 0, verts.address());
|
||||
glEnableClientState(GL_NORMAL_ARRAY);
|
||||
glNormalPointer(GL_FLOAT, 0, norms.address());
|
||||
|
||||
glClientActiveTextureARB(GL_TEXTURE0_ARB);
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, diffuseUVs.address());
|
||||
|
||||
//if (lightmap)
|
||||
//{
|
||||
glClientActiveTextureARB(GL_TEXTURE1_ARB);
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, lightmapUVs.address());
|
||||
glClientActiveTextureARB(GL_TEXTURE0_ARB);
|
||||
//}
|
||||
|
||||
for(S32 i=0; i<primitives.size(); i++)
|
||||
{
|
||||
primitive &draw = primitives[i];
|
||||
|
||||
if(draw.alpha != transparent)
|
||||
continue;
|
||||
|
||||
if(texture)
|
||||
{
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
glBindTexture(GL_TEXTURE_2D, draw.diffuseId);
|
||||
#else
|
||||
glBindTexture(GL_TEXTURE_2D, materialList->getMaterial(draw.diffuseIndex).getGLName());
|
||||
#endif
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, draw.texS);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, draw.texT);
|
||||
}
|
||||
|
||||
if(lightmap)
|
||||
{
|
||||
glActiveTextureARB(GL_TEXTURE1_ARB);
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
glBindTexture(GL_TEXTURE_2D, draw.lightMapId);
|
||||
#else
|
||||
glBindTexture(GL_TEXTURE_2D, gInteriorLMManager.getHandle(interiorlmhandle, instancelmhandle, draw.lightMapIndex)->getGLName());
|
||||
#endif
|
||||
glActiveTextureARB(GL_TEXTURE0_ARB);
|
||||
}
|
||||
|
||||
glDrawElements(GL_TRIANGLE_STRIP, draw.count, GL_UNSIGNED_SHORT,
|
||||
&indices[draw.start]);
|
||||
}
|
||||
|
||||
glClientActiveTextureARB(GL_TEXTURE1_ARB);
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
|
||||
glClientActiveTextureARB(GL_TEXTURE0_ARB);
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
|
||||
glDisableClientState(GL_NORMAL_ARRAY);
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
}
|
||||
|
||||
bool ConstructorSimpleMesh::read(Stream& stream)
|
||||
{
|
||||
// Simple serialization
|
||||
S32 vectorSize = 0;
|
||||
|
||||
// Primitives
|
||||
stream.read(&vectorSize);
|
||||
primitives.setSize(vectorSize);
|
||||
for (U32 i = 0; i < primitives.size(); i++)
|
||||
{
|
||||
stream.read(&primitives[i].alpha);
|
||||
stream.read(&primitives[i].texS);
|
||||
stream.read(&primitives[i].texT);
|
||||
stream.read(&primitives[i].diffuseIndex);
|
||||
stream.read(&primitives[i].lightMapIndex);
|
||||
stream.read(&primitives[i].start);
|
||||
stream.read(&primitives[i].count);
|
||||
|
||||
mathRead(stream, &primitives[i].lightMapEquationX);
|
||||
mathRead(stream, &primitives[i].lightMapEquationY);
|
||||
mathRead(stream, &primitives[i].lightMapOffset);
|
||||
mathRead(stream, &primitives[i].lightMapSize);
|
||||
}
|
||||
|
||||
// Indices
|
||||
stream.read(&vectorSize);
|
||||
indices.setSize(vectorSize);
|
||||
for (U32 i = 0; i < indices.size(); i++)
|
||||
stream.read(&indices[i]);
|
||||
|
||||
// Vertices
|
||||
stream.read(&vectorSize);
|
||||
verts.setSize(vectorSize);
|
||||
for (U32 i = 0; i < verts.size(); i++)
|
||||
mathRead(stream, &verts[i]);
|
||||
|
||||
// Normals
|
||||
stream.read(&vectorSize);
|
||||
norms.setSize(vectorSize);
|
||||
for (U32 i = 0; i < norms.size(); i++)
|
||||
mathRead(stream, &norms[i]);
|
||||
|
||||
// Diffuse UVs
|
||||
stream.read(&vectorSize);
|
||||
diffuseUVs.setSize(vectorSize);
|
||||
for (U32 i = 0; i < diffuseUVs.size(); i++)
|
||||
mathRead(stream, &diffuseUVs[i]);
|
||||
|
||||
// Lightmap UVs
|
||||
stream.read(&vectorSize);
|
||||
lightmapUVs.setSize(vectorSize);
|
||||
for (U32 i = 0; i < lightmapUVs.size(); i++)
|
||||
mathRead(stream, &lightmapUVs[i]);
|
||||
|
||||
// Material list
|
||||
bool hasMaterialList = false;
|
||||
stream.read(&hasMaterialList);
|
||||
if (hasMaterialList)
|
||||
{
|
||||
// Since we are doing this externally to a TSShape read we need to
|
||||
// make sure that our read version is the same as our write version.
|
||||
// It is possible that it was changed along the way by a loaded TSShape.
|
||||
TSShape::smReadVersion = TSShape::smVersion;
|
||||
|
||||
if (materialList)
|
||||
delete materialList;
|
||||
|
||||
materialList = new TSMaterialList;
|
||||
materialList->read(stream);
|
||||
}
|
||||
else
|
||||
materialList = NULL;
|
||||
|
||||
// Diffuse bitmaps
|
||||
stream.read(&vectorSize);
|
||||
for (U32 i = 0; i < vectorSize; i++)
|
||||
{
|
||||
TextureHandle& handle = materialList->getMaterial(i);
|
||||
|
||||
bool hasBitmap = false;
|
||||
|
||||
stream.read(&hasBitmap);
|
||||
|
||||
if (hasBitmap)
|
||||
{
|
||||
GBitmap* bitMap = new GBitmap;
|
||||
bitMap->readPNG(stream);
|
||||
|
||||
handle.set(materialList->getMaterialName(i), bitMap, BitmapKeepTexture);
|
||||
}
|
||||
}
|
||||
|
||||
// Misc data
|
||||
stream.read(&hasSolid);
|
||||
stream.read(&hasTranslucency);
|
||||
mathRead(stream, &bounds);
|
||||
mathRead(stream, &transform);
|
||||
mathRead(stream, &scale);
|
||||
|
||||
calculateBounds();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ConstructorSimpleMesh::write(Stream& stream) const
|
||||
{
|
||||
// Simple serialization
|
||||
// Primitives
|
||||
stream.write(primitives.size());
|
||||
for (U32 i = 0; i < primitives.size(); i++)
|
||||
{
|
||||
stream.write(primitives[i].alpha);
|
||||
stream.write(primitives[i].texS);
|
||||
stream.write(primitives[i].texT);
|
||||
stream.write(primitives[i].diffuseIndex);
|
||||
stream.write(primitives[i].lightMapIndex);
|
||||
stream.write(primitives[i].start);
|
||||
stream.write(primitives[i].count);
|
||||
|
||||
mathWrite(stream, primitives[i].lightMapEquationX);
|
||||
mathWrite(stream, primitives[i].lightMapEquationY);
|
||||
mathWrite(stream, primitives[i].lightMapOffset);
|
||||
mathWrite(stream, primitives[i].lightMapSize);
|
||||
}
|
||||
|
||||
// Indices
|
||||
stream.write(indices.size());
|
||||
for (U32 i = 0; i < indices.size(); i++)
|
||||
stream.write(indices[i]);
|
||||
|
||||
// Vertices
|
||||
stream.write(verts.size());
|
||||
for (U32 i = 0; i < verts.size(); i++)
|
||||
mathWrite(stream, verts[i]);
|
||||
|
||||
// Normals
|
||||
stream.write(norms.size());
|
||||
for (U32 i = 0; i < norms.size(); i++)
|
||||
mathWrite(stream, norms[i]);
|
||||
|
||||
// Diffuse UVs
|
||||
stream.write(diffuseUVs.size());
|
||||
for (U32 i = 0; i < diffuseUVs.size(); i++)
|
||||
mathWrite(stream, diffuseUVs[i]);
|
||||
|
||||
// Lightmap UVs
|
||||
stream.write(lightmapUVs.size());
|
||||
for (U32 i = 0; i < lightmapUVs.size(); i++)
|
||||
mathWrite(stream, lightmapUVs[i]);
|
||||
|
||||
// Material list
|
||||
if (materialList)
|
||||
{
|
||||
stream.write(true);
|
||||
materialList->write(stream);
|
||||
}
|
||||
else
|
||||
stream.write(false);
|
||||
|
||||
// Diffuse bitmaps
|
||||
if (!materialList)
|
||||
stream.write(0);
|
||||
else
|
||||
{
|
||||
stream.write(materialList->getMaterialCount());
|
||||
|
||||
for (U32 i = 0; i < materialList->getMaterialCount(); i++)
|
||||
{
|
||||
TextureHandle& handle = materialList->getMaterial(i);
|
||||
|
||||
if (handle.isValid())
|
||||
{
|
||||
GBitmap* bitMap = handle.getBitmap();
|
||||
|
||||
if (bitMap)
|
||||
{
|
||||
stream.write(true);
|
||||
bitMap->writePNG(stream);
|
||||
}
|
||||
else
|
||||
stream.write(false);
|
||||
}
|
||||
else
|
||||
stream.write(false);
|
||||
}
|
||||
}
|
||||
|
||||
// Misc data
|
||||
stream.write(hasSolid);
|
||||
stream.write(hasTranslucency);
|
||||
mathWrite(stream, bounds);
|
||||
mathWrite(stream, transform);
|
||||
mathWrite(stream, scale);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
bool ConstructorSimpleMeshLoader::loadSimpleMesh(const char *filename, ConstructorSimpleMesh &mesh)
|
||||
{
|
||||
if(!filename)
|
||||
return false;
|
||||
|
||||
const char *ext = dStrrchr(filename, '.');
|
||||
if(!ext || (ext[0] == 0))
|
||||
return false;
|
||||
|
||||
FileStream file;
|
||||
if(!file.open(filename, FileStream::Read))
|
||||
{
|
||||
Con::errorf("Unable to open file '%s'.", filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
currentMesh = &mesh;
|
||||
currentMesh->clear();
|
||||
|
||||
bool res = false;
|
||||
if(dStricmp(ext, ".dts") == 0)
|
||||
res = loadDTSFile(filename);
|
||||
//else if(dStricmp(ext, ".x") == 0)
|
||||
// res = loadDirectXFile(&file);
|
||||
else
|
||||
{
|
||||
ext = &ext[1];
|
||||
if(ext[0] != 0)
|
||||
{
|
||||
char func[256];
|
||||
func[0] = 0;
|
||||
dStrcat(func, "SimpleMeshLoader_load");
|
||||
dStrcat(func, ext);
|
||||
dStrcat(func, "File");
|
||||
const char *ret = Con::executef(1, func);
|
||||
if(!ret || (dStricmp(ret, "1") != 0))
|
||||
res = false;
|
||||
else
|
||||
res = true;
|
||||
}
|
||||
}
|
||||
|
||||
currentMesh->calculateBounds();
|
||||
currentMesh = NULL;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
bool ConstructorSimpleMeshLoader::loadDTSFile(const char *filename)
|
||||
{
|
||||
Resource<TSShape> shape;
|
||||
shape = ResourceManager->load(filename);
|
||||
if(shape.isNull())
|
||||
return false;
|
||||
|
||||
TSShapeInstance *shapeinst = new TSShapeInstance(shape, true);
|
||||
if(!shapeinst)
|
||||
return false;
|
||||
|
||||
// load up...
|
||||
currentMesh->materialList = new TSMaterialList(shapeinst->getMaterialList());
|
||||
|
||||
// only interested in the top detail...
|
||||
const TSDetail *detail = &shapeinst->getShape()->details[0];
|
||||
S32 ss = detail->subShapeNum;
|
||||
S32 od = detail->objectDetailNum;
|
||||
S32 start = shapeinst->getShape()->subShapeFirstObject[ss];
|
||||
S32 end = start + shapeinst->getShape()->subShapeNumObjects[ss];
|
||||
|
||||
shapeinst->animate(0);
|
||||
shapeinst->setCurrentDetail(0);
|
||||
shapeinst->setStatics(0);
|
||||
|
||||
currentMesh->hasSolid = true;
|
||||
|
||||
for(U32 i=start; i<end; i++)
|
||||
{
|
||||
TSMesh *mesh = shapeinst->mMeshObjects[i].getMesh(od);
|
||||
MatrixF *mat = shapeinst->mMeshObjects[i].getTransform();
|
||||
|
||||
if(!mesh)
|
||||
continue;
|
||||
|
||||
MatrixF m;
|
||||
if(mat)
|
||||
m = *mat;
|
||||
else
|
||||
m.identity();
|
||||
|
||||
ToolVector<Point3F> *vertsp;
|
||||
ToolVector<Point3F> *normsp;
|
||||
TSSkinMesh *smesh = dynamic_cast<TSSkinMesh *>(mesh);
|
||||
if(smesh)
|
||||
{
|
||||
vertsp = &smesh->initialVerts;
|
||||
normsp = &smesh->initialNorms;
|
||||
}
|
||||
else
|
||||
{
|
||||
vertsp = &mesh->verts;
|
||||
normsp = &mesh->norms;
|
||||
}
|
||||
ToolVector<Point3F> &verts = *vertsp;
|
||||
ToolVector<Point3F> &norms = *normsp;
|
||||
|
||||
for(U32 p=0; p<mesh->primitives.size(); p++)
|
||||
{
|
||||
TSDrawPrimitive &oldprim = mesh->primitives[p];
|
||||
|
||||
currentMesh->primitives.increment();
|
||||
ConstructorSimpleMesh::primitive &newprim = currentMesh->primitives.last();
|
||||
|
||||
U32 flags = currentMesh->materialList->getFlags(oldprim.matIndex & TSDrawPrimitive::MaterialMask);
|
||||
newprim.alpha = (flags & TSMaterialList::Translucent);
|
||||
newprim.texS = (flags & TSMaterialList::S_Wrap) ? GL_REPEAT : GL_CLAMP;
|
||||
newprim.texT = (flags & TSMaterialList::T_Wrap) ? GL_REPEAT : GL_CLAMP;
|
||||
newprim.start = currentMesh->indices.size();
|
||||
newprim.count = 0;
|
||||
newprim.lightMapId = 0;
|
||||
newprim.lightMapIndex = 0;
|
||||
|
||||
if(newprim.alpha)
|
||||
currentMesh->hasTranslucency = true;
|
||||
|
||||
newprim.diffuseIndex = oldprim.matIndex & TSDrawPrimitive::MaterialMask;
|
||||
TextureHandle &tex = currentMesh->materialList->getMaterial(newprim.diffuseIndex);
|
||||
newprim.diffuseId = tex.getGLName();
|
||||
|
||||
for(U32 v=0; v<oldprim.numElements; v++)
|
||||
{
|
||||
AssertFatal(((S32(oldprim.start + v) > -1) &&
|
||||
(S32(oldprim.start + v) < mesh->indices.size())), "!");
|
||||
S32 srcindex = mesh->indices[oldprim.start + v];
|
||||
S32 dstindex = currentMesh->verts.size();
|
||||
|
||||
currentMesh->indices.increment();
|
||||
currentMesh->norms.increment();
|
||||
currentMesh->verts.increment();
|
||||
currentMesh->diffuseUVs.increment();
|
||||
currentMesh->lightmapUVs.increment();
|
||||
|
||||
currentMesh->indices.last() = dstindex;
|
||||
currentMesh->verts[dstindex] = verts[srcindex];
|
||||
currentMesh->norms[dstindex] = norms[srcindex];
|
||||
|
||||
m.mulP(currentMesh->verts[dstindex]);
|
||||
m.mulV(currentMesh->norms[dstindex]);
|
||||
|
||||
ToolVector<Point2F> uvs;
|
||||
mesh->getUVs(TSMesh::tDiffuse, uvs);
|
||||
|
||||
if(uvs.size() > 0)
|
||||
currentMesh->diffuseUVs[dstindex] = uvs[srcindex];
|
||||
|
||||
newprim.count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Now grab the collision meshes and shove them into ConvexBrushes
|
||||
for (U32 i = 0; i < shapeinst->getShape()->details.size(); i++)
|
||||
{
|
||||
const TSDetail * detail = &shapeinst->getShape()->details[i];
|
||||
|
||||
char* name = (char*)shapeinst->getShape()->names[detail->nameIndex];
|
||||
|
||||
if (dStrstr(dStrlwr(name), "collision-"))
|
||||
{
|
||||
shapeinst->animate(i);
|
||||
shapeinst->setCurrentDetail(i);
|
||||
shapeinst->setStatics(i);
|
||||
|
||||
S32 ss = detail->subShapeNum;
|
||||
S32 od = detail->objectDetailNum;
|
||||
|
||||
S32 start = shapeinst->getShape()->subShapeFirstObject[ss];
|
||||
S32 end = shapeinst->getShape()->subShapeNumObjects[ss] + start;
|
||||
if (start < end)
|
||||
{
|
||||
// Run through objects and collide
|
||||
for (S32 j = start; j < end; j++)
|
||||
{
|
||||
TSShapeInstance::MeshObjectInstance * mesh = &shapeinst->mMeshObjects[j];
|
||||
|
||||
if (od >= mesh->object->numMeshes)
|
||||
continue;
|
||||
|
||||
ConcretePolyList polys;
|
||||
|
||||
// Get a valid transform for the polylist
|
||||
MatrixF* mat = mesh->getTransform();
|
||||
|
||||
MatrixF m;
|
||||
if(mat)
|
||||
m = *mat;
|
||||
else
|
||||
m.identity();
|
||||
|
||||
polys.setTransform(&m, Point3F(1.0f, 1.0f, 1.0f));
|
||||
|
||||
// collide...
|
||||
U32 surfaceKey = 0;
|
||||
mesh->buildPolyList(od, &polys, surfaceKey);
|
||||
|
||||
if (polys.mPolyList.size() == 0)
|
||||
continue;
|
||||
|
||||
// Now build our actual ConvexBrush
|
||||
ConvexBrush* hull = new ConvexBrush;
|
||||
|
||||
for (U32 k = 0; k < polys.mPolyList.size(); k++)
|
||||
{
|
||||
ConcretePolyList::Poly& srcPoly = polys.mPolyList[k];
|
||||
OptimizedPolyList::Poly dstPoly;
|
||||
|
||||
dstPoly.plane = hull->mFaces.addPlane(srcPoly.plane);
|
||||
dstPoly.vertexStart = hull->mFaces.mIndexList.size();
|
||||
dstPoly.vertexCount = srcPoly.vertexCount;
|
||||
|
||||
for (U32 m = 0; m < srcPoly.vertexCount; m++)
|
||||
{
|
||||
U32 srcIndex = polys.mIndexList[srcPoly.vertexStart + m];
|
||||
Point3F& pt = polys.mVertexList[srcIndex];
|
||||
|
||||
U32 dstIndex = hull->mFaces.addPoint(pt);
|
||||
hull->mFaces.mIndexList.push_back(dstIndex);
|
||||
}
|
||||
|
||||
dstPoly.textureData.texture = StringTable->insert("null");
|
||||
dstPoly.isNull = true;
|
||||
|
||||
hull->mFaces.setUpTextureMatrix(dstPoly);
|
||||
|
||||
hull->mFaces.mPolyList.push_back(dstPoly);
|
||||
}
|
||||
|
||||
// We need to do a merging pass on the polylist since TSMesh's
|
||||
// buildPolyList returns a list of individual triangles
|
||||
// Setup the surface id's
|
||||
for (U32 k = 0; k < hull->mFaces.mPlaneList.size(); k++)
|
||||
{
|
||||
for (U32 m = 0; m < hull->mFaces.size(); m++)
|
||||
{
|
||||
OptimizedPolyList::Poly& poly = hull->mFaces[m];
|
||||
|
||||
if (poly.plane == k)
|
||||
poly.surfaceID = k;
|
||||
}
|
||||
}
|
||||
|
||||
// And do the actual merge
|
||||
hull->mFaces.mergeSurfaces();
|
||||
|
||||
// Need to do a couple operations on our ConvexBrush
|
||||
hull->mFaces.generateEdgelist();
|
||||
hull->calcBounds();
|
||||
hull->calcCentroid();
|
||||
hull->mStatus = ConvexBrush::Good;
|
||||
hull->mType = InteriorMapResource::Detail;
|
||||
hull->mBrushScale = 32.0f;
|
||||
|
||||
// And now push it back into our collisionHulls list
|
||||
currentMesh->collisionHulls.push_back(hull);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
shapeinst->clearStatics();
|
||||
|
||||
delete shapeinst;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*bool ConstructorSimpleMeshLoader::loadDirectXFile(Stream *stream)
|
||||
{
|
||||
return false;
|
||||
}*/
|
||||
|
||||
|
||||
ConsoleFunction(SimpleMeshLoader_createTriStrip, bool, 3, 3, "bool SimpleMeshLoader_createTriStrip(textureFileName, transparent)")
|
||||
{
|
||||
ConstructorSimpleMesh *mesh = ConstructorSimpleMeshLoader::currentMesh;
|
||||
if(!mesh)
|
||||
return false;
|
||||
|
||||
if(!mesh->materialList)
|
||||
mesh->materialList = new TSMaterialList();
|
||||
mesh->materialList->push_back(argv[2], 0);
|
||||
|
||||
mesh->primitives.increment();
|
||||
ConstructorSimpleMesh::primitive &prim = mesh->primitives.last();
|
||||
prim.start = mesh->indices.size();
|
||||
prim.count = 0;
|
||||
|
||||
prim.diffuseIndex = mesh->materialList->size() - 1;
|
||||
TextureHandle &tex = mesh->materialList->getMaterial(prim.diffuseIndex);
|
||||
prim.diffuseId = tex.getGLName();
|
||||
|
||||
prim.lightMapId = 0;
|
||||
prim.lightMapIndex = 0;
|
||||
|
||||
prim.alpha = ((dAtoi(argv[2]) == 1) || (dStrcmp(argv[2], "true") == 0));
|
||||
prim.texS = GL_REPEAT;
|
||||
prim.texT = GL_REPEAT;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
ConsoleFunction(SimpleMeshLoader_createVert, bool, 4, 4, "bool SimpleMeshLoader_createVert(pos, norm, uv)")
|
||||
{
|
||||
ConstructorSimpleMesh *mesh = ConstructorSimpleMeshLoader::currentMesh;
|
||||
if(!mesh || (mesh->primitives.size() < 1))
|
||||
return false;
|
||||
|
||||
Point3F pos, norm;
|
||||
Point2F uv;
|
||||
|
||||
dSscanf(argv[1], "%f %f %f", &pos.x, &pos.y, &pos.z);
|
||||
dSscanf(argv[2], "%f %f %f", &norm.x, &norm.y, &norm.z);
|
||||
dSscanf(argv[3], "%f %f", &uv.x, &uv.y);
|
||||
|
||||
ConstructorSimpleMesh::primitive &prim = mesh->primitives.last();
|
||||
prim.count++;
|
||||
|
||||
mesh->indices.increment();
|
||||
mesh->indices.last() = mesh->verts.size();
|
||||
|
||||
mesh->verts.increment();
|
||||
mesh->verts.last() = pos;
|
||||
|
||||
mesh->norms.increment();
|
||||
mesh->norms.last() = norm;
|
||||
|
||||
mesh->diffuseUVs.increment();
|
||||
mesh->diffuseUVs.last() = uv;
|
||||
|
||||
mesh->lightmapUVs.increment();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
166
engine/constructor/constructorSimpleMesh.h
Executable file
166
engine/constructor/constructorSimpleMesh.h
Executable file
@ -0,0 +1,166 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
// Torque Game Engine
|
||||
// Copyright (C) GarageGames.com, Inc.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef _CONSTRUCTORSIMPLEMESH_H_
|
||||
#define _CONSTRUCTORSIMPLEMESH_H_
|
||||
|
||||
#include "core/tVector.h"
|
||||
#include "dgl/dgl.h"
|
||||
#include "math/mBox.h"
|
||||
#include "core/fileStream.h"
|
||||
#include "ts/tsShapeInstance.h"
|
||||
|
||||
//#define IS_CONSTRUCTOR
|
||||
|
||||
|
||||
class ConstructorSimpleMesh
|
||||
{
|
||||
public:
|
||||
class primitive
|
||||
{
|
||||
public:
|
||||
bool alpha;
|
||||
U32 texS;
|
||||
U32 texT;
|
||||
S32 diffuseIndex;
|
||||
S32 lightMapIndex;
|
||||
U32 start;
|
||||
U32 count;
|
||||
|
||||
// used to relight the surface in-engine...
|
||||
PlaneF lightMapEquationX;
|
||||
PlaneF lightMapEquationY;
|
||||
Point2I lightMapOffset;
|
||||
Point2I lightMapSize;
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
S32 diffuseId;
|
||||
S32 lightMapId;
|
||||
#endif
|
||||
|
||||
primitive()
|
||||
{
|
||||
alpha = false;
|
||||
texS = GL_REPEAT;
|
||||
texT = GL_REPEAT;
|
||||
diffuseIndex = 0;
|
||||
lightMapIndex = 0;
|
||||
start = 0;
|
||||
count = 0;
|
||||
|
||||
lightMapEquationX = PlaneF(0, 0, 0, 0);
|
||||
lightMapEquationY = PlaneF(0, 0, 0, 0);
|
||||
lightMapOffset = Point2I(0, 0);
|
||||
lightMapSize = Point2I(0, 0);
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
diffuseId = 0;
|
||||
lightMapId = 0;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
ConstructorSimpleMesh()
|
||||
{
|
||||
materialList = NULL;
|
||||
clear();
|
||||
}
|
||||
~ConstructorSimpleMesh(){clear();}
|
||||
void clear(bool wipeMaterials = true)
|
||||
{
|
||||
hasSolid = false;
|
||||
hasTranslucency = false;
|
||||
bounds = Box3F(-1, -1, -1, 1, 1, 1);
|
||||
transform.identity();
|
||||
scale.set(1.0f, 1.0f, 1.0f);
|
||||
|
||||
primitives.clear();
|
||||
indices.clear();
|
||||
verts.clear();
|
||||
norms.clear();
|
||||
diffuseUVs.clear();
|
||||
lightmapUVs.clear();
|
||||
|
||||
if(wipeMaterials && materialList)
|
||||
delete materialList;
|
||||
|
||||
if (wipeMaterials)
|
||||
materialList = NULL;
|
||||
}
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
void render(bool transparent, bool texture, bool lightmap);
|
||||
#else
|
||||
void render(bool transparent, bool texture, bool lightmap,
|
||||
U32 interiorlmhandle, U32 instancelmhandle);
|
||||
#endif
|
||||
|
||||
void calculateBounds()
|
||||
{
|
||||
bounds = Box3F(F32_MAX, F32_MAX, F32_MAX, -F32_MAX, -F32_MAX, -F32_MAX);
|
||||
for(U32 i=0; i<verts.size(); i++)
|
||||
{
|
||||
bounds.max.setMax(verts[i]);
|
||||
bounds.min.setMin(verts[i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool hasSolid;
|
||||
bool hasTranslucency;
|
||||
Box3F bounds;
|
||||
MatrixF transform;
|
||||
Point3F scale;
|
||||
|
||||
Vector<primitive> primitives;
|
||||
|
||||
// same index relationship...
|
||||
Vector<U16> indices;
|
||||
Vector<Point3F> verts;
|
||||
Vector<Point3F> norms;
|
||||
Vector<Point2F> diffuseUVs;
|
||||
Vector<Point2F> lightmapUVs;
|
||||
|
||||
TSMaterialList *materialList;
|
||||
|
||||
void copyTo(ConstructorSimpleMesh &dest)
|
||||
{
|
||||
dest.clear();
|
||||
dest.hasSolid = hasSolid;
|
||||
dest.hasTranslucency = hasTranslucency;
|
||||
dest.bounds = bounds;
|
||||
dest.transform = transform;
|
||||
dest.scale = scale;
|
||||
dest.primitives = primitives;
|
||||
dest.indices = indices;
|
||||
dest.verts = verts;
|
||||
dest.norms = norms;
|
||||
dest.diffuseUVs = diffuseUVs;
|
||||
dest.lightmapUVs = lightmapUVs;
|
||||
|
||||
if(materialList)
|
||||
dest.materialList = new TSMaterialList(materialList);
|
||||
}
|
||||
bool castRay(const Point3F &start, const Point3F &end, RayInfo* info);
|
||||
bool castPlanes(PlaneF left, PlaneF right, PlaneF top, PlaneF bottom);
|
||||
|
||||
bool read(Stream& stream);
|
||||
bool write(Stream& stream) const;
|
||||
};
|
||||
|
||||
#ifdef IS_CONSTRUCTOR
|
||||
class ConstructorSimpleMeshLoader
|
||||
{
|
||||
public:
|
||||
static ConstructorSimpleMesh *currentMesh;
|
||||
static bool loadSimpleMesh(const char *filename, ConstructorSimpleMesh &mesh);
|
||||
|
||||
private:
|
||||
static bool loadDTSFile(const char *filename);
|
||||
//static bool loadDirectXFile(Stream *stream);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif //_CONSTRUCTORSIMPLEMESH_H_
|
||||
|
||||
Reference in New Issue
Block a user