void graphics::scale(point p)
{
//glScalef(p.x, p.y, p.z);
v3 vec = {p.x, p.y, p.z};
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
snScaleM4(getModelMatrix(), getModelMatrix(), &vec);
break;
}
case SINNCA_PROJECTION_MATRIX:
{
snScaleM4(getProjectionMatrix(), getProjectionMatrix(), &vec);
break;
}
case SINNCA_TEXTURE_MATRIX:
{
snScaleM4(getTextureMatrix(), getTextureMatrix(), &vec);
break;
}
}
}
void graphics::move(float x, float y, float z)
{
//glTranslatef(x, y, z);
v3 vec = {x, y, z};
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
snTranslateM4(getModelMatrix(), getModelMatrix(), &vec);
break;
}
case SINNCA_PROJECTION_MATRIX:
{
snTranslateM4(getProjectionMatrix(), getProjectionMatrix(), &vec);
break;
}
case SINNCA_TEXTURE_MATRIX:
{
snTranslateM4(getTextureMatrix(), getTextureMatrix(), &vec);
break;
}
}
}
void graphics::ortho(float near, float far)
{
float left = (float)resW * 0.5f;
float right = -(float)resW * 0.5f;
float up = (float)resH * 0.5f;
float down = -(float)resH * 0.5f;
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
snOrthoMatrix(getModelMatrix(), left, right, up, down, near, far);
break;
}
case SINNCA_PROJECTION_MATRIX:
{
snOrthoMatrix(getProjectionMatrix(), left, right, up, down, near, far);
break;
}
case SINNCA_TEXTURE_MATRIX:
{
snOrthoMatrix(getTextureMatrix(), left, right, up, down, near, far);
break;
}
}
}
void graphics::perspective(float end, float start = 0.1f, float fov = 35.0f)
{
m4 base;
float aspectRatio = (float)resW / (float)resH;
float d = end - start,
r = (fov * 0.5) * (M_PI / 180),
s = sin(r),
c = sin(r) / s;
snLoadIdentity(&base);
base.m[0].x = c / aspectRatio;
base.m[1].y = c;
base.m[2].z = -(end + start) / d;
base.m[2].w = -1.0f;
base.m[3].z = -2.0f * start * end / d;
base.m[3].w = 0.0f;
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
multiply(getModelMatrix(), getModelMatrix(), &base);
break;
}
case SINNCA_PROJECTION_MATRIX:
{
multiply(getProjectionMatrix(), getProjectionMatrix(), &base);
break;
}
case SINNCA_TEXTURE_MATRIX:
{
multiply(getTextureMatrix(), getTextureMatrix(), &base);
break;
}
}
}
void graphics::scale(float x, float y, float z)
{
v3 vec = {x, y, z};
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
snScaleM4(getModelMatrix(), getModelMatrix(), &vec);
break;
}
case SINNCA_PROJECTION_MATRIX:
{
snScaleM4(getProjectionMatrix(), getProjectionMatrix(), &vec);
break;
}
case SINNCA_TEXTURE_MATRIX:
{
snScaleM4(getTextureMatrix(), getTextureMatrix(), &vec);
break;
}
}
}
void graphics::loadIdentity()
{
switch (matrixMode)
{
case SINNCA_MODELVIEW_MATRIX:
{
snLoadIdentity(getModelMatrix());
break;
}
case SINNCA_PROJECTION_MATRIX:
{
snLoadIdentity(getProjectionMatrix());
break;
}
case SINNCA_TEXTURE_MATRIX:
{
snLoadIdentity(getTextureMatrix());
break;
}
}
}
bool Exporter::splitMesh(INode *node, Mesh& mesh, FaceGroups &grps, TimeValue t, vector<Color4>& vertColors, bool noSplit)
{
Mtl* nodeMtl = node->GetMtl();
Matrix3 tm = node->GetObjTMAfterWSM(t);
// Order of the vertices. Get 'em counter clockwise if the objects is
// negatively scaled.
int vi[3];
if (TMNegParity(tm)) {
vi[0] = 2; vi[1] = 1; vi[2] = 0;
} else {
vi[0] = 0; vi[1] = 1; vi[2] = 2;
}
Matrix3 flip;
flip.IdentityMatrix();
flip.Scale(Point3(1, -1, 1));
int nv = mesh.getNumVerts();
int nf = mesh.getNumFaces();
if (noSplit)
{
int nv = mesh.getNumVerts();
int nf = mesh.getNumFaces();
// Dont split the mesh at all. For debugging purposes.
FaceGroup& grp = grps[0];
grp.vidx.resize(nv, -1);
grp.verts.resize(nv);
grp.faces.resize(nf);
grp.uvs.resize(nv);
grp.vnorms.resize(nv);
grp.fidx.resize(nf);
Matrix3 texm;
getTextureMatrix(texm, getMaterial(node, 0));
texm *= flip;
for (int face=0; face<nf; ++face) {
grp.fidx[face] = face;
for (int vi=0; vi<3; ++vi) {
int idx = mesh.faces[face].getVert(vi);
grp.faces[face][vi] = idx;
// Calculate normal
Point3 norm;
#if VERSION_3DSMAX <= ((5000<<16)+(15<<8)+0) // Version 5
norm = getVertexNormal(&mesh, face, mesh.getRVertPtr(idx));
#else
MeshNormalSpec *specNorms = mesh.GetSpecifiedNormals ();
if (NULL != specNorms && specNorms->GetNumNormals() != 0)
norm = specNorms->GetNormal(face, vi);
else
norm = getVertexNormal(&mesh, face, mesh.getRVertPtr(idx));
#endif
Point3 uv;
if (mesh.tVerts && mesh.tvFace) {
uv = mesh.tVerts[ mesh.tvFace[ face ].t[ vi ]] * texm;
uv.y += 1.0f;
}
if (grp.vidx[idx] == idx){
ASSERT(grp.verts[idx] == TOVECTOR3(mesh.getVert(idx)));
//ASSERT(vg.norm == norm);
//Point3 uv = mesh.getTVert(idx);
//if (mesh.getNumTVerts() > 0)
//{
// ASSERT(grp.uvs[idx].u == uv.x && grp.uvs[idx].v == uv.y);
//}
} else {
grp.vidx[idx] = idx;
grp.verts[idx] = TOVECTOR3(mesh.getVert(idx));
//grp.uvs[idx].u = uv.x;
//grp.uvs[idx].v = uv.y;
grp.vnorms[idx] = TOVECTOR3(norm);
}
}
}
for (int i=0; i<nv; ++i) {
ASSERT(grp.vidx[i] != -1);
}
}
else
{
int face, numSubMtls = nodeMtl?nodeMtl->NumSubMtls():0;
for (face=0; face<mesh.getNumFaces(); face++)
{
int mtlID = (numSubMtls!=0) ? (mesh.faces[face].getMatID() % numSubMtls) : 0;
Mtl *mtl = getMaterial(node, mtlID);
Matrix3 texm;
getTextureMatrix(texm, mtl);
texm *= flip;
FaceGroup& grp = grps[mtlID];
if (grp.uvMapping.size() == 0) // Only needs to be done once per face group
{
int nmaps = 0;
int nmapsStart = max(1, mesh.getNumMaps() - (mesh.mapSupport(0) ? 1 : 0)); // Omit vertex color map.
for (int ii = 1; ii <= nmapsStart; ii++) // Winnow out the unsupported maps.
{
if (!mesh.mapSupport(ii)) continue;
grp.uvMapping[ii] = nmaps++;
}
grp.uvs.resize(nmaps == 0 ? 1 : nmaps);
}
if (nv > int(grp.verts.capacity()))
{
grp.vgrp.reserve(nv);
grp.verts.reserve(nv);
grp.vnorms.reserve(nv);
for (int i=0; i<grp.uvs.size(); ++i)
grp.uvs[i].reserve(nv);
grp.vcolors.reserve(nv);
grp.vidx.reserve(nv);
}
if (nf > int(grp.faces.capacity()))
{
grp.faces.reserve(nf);
grp.fidx.reserve(nf);
}
Triangle tri;
for (int i=0; i<3; i++)
tri[i] = addVertex(grp, face, vi[i], &mesh, texm, vertColors);
grp.faces.push_back(tri);
if (grp.fidx.size() < nf)
grp.fidx.resize(nf,-1);
grp.fidx[face] = grp.faces.size() - 1;
}
}
return true;
}
