|
import com.jme.scene.*;
|
import com.jme.math.*;
|
import com.jme.scene.state.MaterialState;
|
import com.jme.scene.state.TextureState;
|
import com.jme.renderer.ColorRGBA;
|
|
import javax.vecmath.*;
|
//import java.awt.Color;
|
//import java.awt.color.ColorSpace;
|
|
class cJME
|
{
|
static boolean gennormals = false; // can be done through UI
|
static boolean trim = true;
|
static boolean stripify = false; // true;
|
static boolean reduction34 = false;
|
static boolean genUV = false;
|
static boolean mergeAttributes = true;
|
|
Matrix4d tempmat = new Matrix4d();
|
Matrix4d tempmatR = new Matrix4d();
|
Matrix4d tempmatS = new Matrix4d();
|
Matrix4d tempmatT = new Matrix4d();
|
Quat4d quat = new Quat4d();
|
javax.vecmath.Vector3d trans = new javax.vecmath.Vector3d();
|
|
Object3D Read(Spatial s)
|
{
|
// System.out.println("Parsing: " + s);
|
|
if (s == null)
|
return new Object3D("NULL");
|
|
if (s instanceof Node)
|
return Read((Node)s);
|
if (s instanceof com.jme.scene.TriMesh)
|
return Read((com.jme.scene.TriMesh)s);
|
//if (s instanceof SharedNode)
|
//return Read(((SharedNode)s).getChild());
|
|
System.out.println("Unknown node class : " + s.getClass().getSimpleName());
|
|
return new Object3D(s.getClass().getName());
|
}
|
|
public int count = 0;
|
|
void ReadTransform(Object3D c, Spatial g)
|
{
|
tempmat.setIdentity();
|
tempmatR.setIdentity();
|
tempmatS.setIdentity();
|
tempmatT.setIdentity();
|
|
Quaternion q = g.getLocalRotation();
|
quat.set(q.x, q.y, q.z, q.w);
|
com.jme.math.Vector3f s = g.getLocalScale();
|
com.jme.math.Vector3f t = g.getLocalTranslation();
|
trans.set(t.x, t.y, t.z);
|
|
tempmatR.setRotation(quat);
|
//tempmat.setScale(s.x);
|
tempmatS.setElement(0,0, s.x);
|
tempmatS.setElement(1,1, s.y);
|
tempmatS.setElement(2,2, s.z);
|
tempmatT.setTranslation(trans);
|
|
// System.out.println("R = " + quat);
|
// System.out.println("S = " + s);
|
// System.out.println("T = " + trans);
|
|
switch(count%6)
|
{
|
case 0:
|
tempmat.mul(tempmatT);
|
tempmat.mul(tempmatR);
|
tempmat.mul(tempmatS);
|
// System.out.println("TRS");
|
break;
|
|
case 1:
|
tempmat.mul(tempmatT);
|
tempmat.mul(tempmatS);
|
tempmat.mul(tempmatR);
|
// System.out.println("TSR");
|
break;
|
|
case 2:
|
tempmat.mul(tempmatR);
|
tempmat.mul(tempmatS);
|
tempmat.mul(tempmatT);
|
// System.out.println("RST");
|
break;
|
|
case 3:
|
tempmat.mul(tempmatR);
|
tempmat.mul(tempmatT);
|
tempmat.mul(tempmatS);
|
// System.out.println("RTS");
|
break;
|
|
case 4:
|
tempmat.mul(tempmatS);
|
tempmat.mul(tempmatT);
|
tempmat.mul(tempmatR);
|
// System.out.println("STR");
|
break;
|
|
case 5:
|
tempmat.mul(tempmatS);
|
tempmat.mul(tempmatR);
|
tempmat.mul(tempmatT);
|
// System.out.println("SRT");
|
break;
|
}
|
|
if (c.toParent == null)
|
{
|
c.toParent = LA.newMatrix();
|
c.fromParent = LA.newMatrix();
|
}
|
|
if (count < 6)
|
{
|
FillMatrix(tempmat, c.toParent);
|
LA.matInvert(c.toParent, c.fromParent);
|
}
|
else
|
{
|
FillMatrix(tempmat, c.fromParent);
|
LA.matInvert(c.toParent, c.toParent);
|
}
|
}
|
|
void ReadMaterial(Object3D o, Spatial s)
|
{
|
//Object texture = s.getRenderState(com.jme.scene.state.RenderState.RS_TEXTURE);
|
o.material = Read((MaterialState)s.getRenderState(com.jme.scene.state.RenderState.RS_MATERIAL));
|
}
|
|
void ReadTexture(Object3D o, Spatial s)
|
{
|
o.GetTextures().name = ":"; //
|
Read((TextureState)s.getRenderState(com.jme.scene.state.RenderState.RS_TEXTURE));
|
}
|
|
void ReadNode(Object3D c, Spatial g)
|
{
|
ReadTransform(c, g);
|
ReadMaterial(c, g);
|
ReadTexture(c, g);
|
}
|
|
Object3D Read(Node g)
|
{
|
Composite c = new Composite(g.getClass().getName());
|
|
ReadNode(c, g);
|
|
for (int i=0; i<g.getQuantity(); i++)
|
{
|
c.addChild(Read(g.getChild(i)));
|
}
|
|
return c;
|
}
|
|
float[] buffer = new float[4];
|
|
cMaterial Read(MaterialState mat)
|
{
|
if (mat == null)
|
return null;
|
|
cMaterial cmat = new cMaterial();
|
|
ColorRGBA col = mat.getDiffuse();
|
buffer[0] = col.r; buffer[1] = col.g; buffer[2] = col.b; buffer[3] = col.a;
|
//Color col = new Color(buffer[0], buffer[1], buffer[2]);
|
//col.getColorComponents(ColorSpace.getInstance(ColorSpace.TYPE_HSV), buffer);
|
cColor.RGBtoHSB(buffer[0], buffer[1], buffer[2], buffer);
|
|
cmat.color = buffer[0]+0.001f;
|
cmat.modulation = buffer[1]+0.001f;
|
cmat.diffuse = buffer[2]+0.001f;
|
|
col = mat.getSpecular();
|
buffer[0] = col.r; buffer[1] = col.g; buffer[2] = col.b; buffer[3] = col.a;
|
|
cmat.specular = buffer[0]+0.001f;
|
// No way to get the metalness
|
|
col = mat.getAmbient();
|
buffer[0] = col.r; buffer[1] = col.g; buffer[2] = col.b; buffer[3] = col.a;
|
|
cmat.ambient = buffer[0]+0.001f;
|
|
cmat.shininess = /*1/*/(Math.max(mat.getShininess(),0)+0.001f);
|
|
return cmat;
|
}
|
|
cTexture Read(TextureState tex)
|
{
|
if (tex == null)
|
return null;
|
|
if( tex.getTexture() != null)
|
{
|
System.out.println(tex.getTexture().getImageLocation());
|
System.out.println(tex.getTexture().getImage());
|
System.out.println(tex.getTexture().getTextureKey());
|
}
|
else
|
System.out.println("NO TEXTURE");
|
|
cTexture ctex = null; // new cTexture();
|
|
return ctex;
|
}
|
|
Vertex v = new Vertex(true);
|
|
Object3D Read(com.jme.scene.TriMesh g)
|
{
|
Object3D result = new Object3D(g.getClass().getSimpleName());
|
|
ReadNode(result, g);
|
|
Vertex.normalmode = true;
|
//Vertex.normalmode = cJME.gennormals;
|
|
int tris = g.getTriangleCount();
|
|
System.out.println("#triangles = " + tris);
|
//int faces = g.getVertexCount()/3;
|
//int verts = g.getVertexCount();
|
int faces = tris;
|
int verts = tris*3;
|
|
BoundaryRep bRep = new BoundaryRep(verts, faces);
|
|
boolean cache = true;
|
|
if (!cache)
|
bRep.Trim();
|
|
//float[] coords = bRep.getRawVertices();
|
//float[] normals = bRep.getRawNormals();
|
//float[] uvmap = bRep.getRawUVMap();
|
|
//assert (coords != null);
|
//assert (normals != null);
|
|
/*
|
com.jme.math.Vector3f[] vertices = new com.jme.math.Vector3f[verts];
|
|
for (int i=0; i<verts; i++)
|
{
|
vertices[i] = new com.jme.math.Vector3f();
|
}
|
|
g.getMeshAsTrianglesVertices(0, vertices);
|
*/
|
|
com.jme.math.Triangle[] triangles = new com.jme.math.Triangle[tris];
|
|
for (int i=0; i<tris; i++)
|
{
|
triangles[i] = new com.jme.math.Triangle(
|
new com.jme.math.Vector3f(),
|
new com.jme.math.Vector3f(),
|
new com.jme.math.Vector3f());
|
}
|
|
g.getMeshAsTriangles(0, triangles); // jME1
|
//g.getMeshAsTriangles(/*0,*/ triangles); // jME2
|
|
//tsa.getNormals(normals);
|
|
//float[][] textures = new float[1][];
|
//textures[0] = uvmap;
|
|
//tsa.getTextureCoordinates(textures);
|
|
// jME1
|
java.nio.FloatBuffer texcoords = g.getTextureBuffer(0,0);
|
//TexCoords texcoords = g.getTextureBuffer(0,0); //g.getTextureCoords(0); //.coords;
|
java.nio.FloatBuffer normals = g.getNormalBuffer(0);
|
|
// jME2
|
// java.nio.FloatBuffer texcoords = // g.getTextureBuffer(0,0);
|
// /*TexCoords texcoords =*/ g.getTextureCoords(0).coords;
|
// java.nio.FloatBuffer normals = g.getNormalBuffer(); // 0);
|
|
//System.out.println("#texcoords = " + texcoords.capacity());
|
//System.out.println("#normals = " + normals.capacity());
|
|
if(texcoords != null && texcoords.capacity() != tris*6)
|
texcoords = null;
|
if(normals != null && normals.capacity() != verts*3)
|
normals = null;
|
|
if (cache)
|
{
|
// bbox
|
float minx=Float.MAX_VALUE,miny=Float.MAX_VALUE,minz=Float.MAX_VALUE;
|
float maxx=Float.MIN_VALUE,maxy=Float.MIN_VALUE,maxz=Float.MIN_VALUE;
|
for (int i=0; i<verts; i++)
|
{
|
com.jme.math.Vector3f jv = triangles[i/3].get(i%3);
|
if (minx > jv.x)
|
minx = jv.x;
|
if (miny > jv.y)
|
miny = jv.y;
|
if (minz > jv.z)
|
minz = jv.z;
|
if (maxx < jv.x)
|
maxx = jv.x;
|
if (maxy < jv.y)
|
maxy = jv.y;
|
if (maxz < jv.z)
|
maxz = jv.z;
|
}
|
|
float orgx = (minx+maxx)/2;
|
float orgy = miny;
|
float orgz = (minz+maxz)/2;
|
|
// Vertices
|
int i3 = 0;
|
int i2 = 0;
|
for (int i=0; i<verts; i++, i3+=3, i2+=2)
|
{
|
com.jme.math.Vector3f jv = triangles[i/3].get(i%3);
|
v.set(jv.x-orgx, jv.y-orgy, jv.z-orgz);
|
//v.set(jv.x - 94, jv.y - 90, jv.z + 540);
|
if (normals != null)
|
v.norm.set(normals.get(i3), normals.get(i3+1), normals.get(i3+2));
|
if (texcoords != null)
|
{
|
v.s = texcoords.get(i2);
|
v.t = texcoords.get(i2+1);
|
}
|
Vertex in = bRep.GetCache(v);
|
if (in == null)
|
{
|
v.index = -1;
|
bRep.Remember(new Vertex(v));
|
}
|
else
|
{
|
bRep.AddVertex(in);
|
}
|
}
|
|
LA.matTranslate(result.fromParent, -orgx,-orgy,-orgz);
|
LA.matTranslate(result.toParent, orgx,orgy,orgz);
|
}
|
|
// Faces
|
int indexF = 0;
|
int indexV = 0;
|
|
for (int i=0; i<faces; i++)
|
{
|
//bRep.faces.addElement(null);
|
bRep.AddFace(indexV, indexV+1, indexV+2);
|
indexF++;
|
|
indexV += 3;
|
}
|
|
assert indexF == faces;
|
assert indexV == verts;
|
|
if (cache)
|
bRep.Trim(trim, //true, true, true); //
|
normals==null || gennormals,false,stripify,genUV);
|
|
result.bRep = bRep;
|
|
Vertex.normalmode = false;
|
|
return result;
|
}
|
|
/*
|
static BoundaryRep Read(TriangleStripArray tsa)
|
{
|
//System.out.println("TriangleStripArray");
|
BoundaryRep bRep = new BoundaryRep(tsa.getValidVertexCount(),
|
tsa.getValidVertexCount() -
|
tsa.getValidStripCount()*2);
|
|
boolean cache = true;
|
|
if (!cache)
|
bRep.Trim();
|
|
float[] vertices = bRep.getRawVertices(); // new float[tsa.getValidVertexCount()*3];
|
tsa.getVertices(vertices);
|
float[] normals = bRep.getRawNormals(); // new float[tsa.getValidVertexCount()*3];
|
tsa.getNormals(normals);
|
float[] uvmap = bRep.getRawUVMap(); // new float[tsa.getValidVertexCount()*2];
|
|
float[][] textures = new float[1][];
|
textures[0] = uvmap;
|
|
try
|
{
|
tsa.getTextureCoordinates(textures);
|
}
|
catch (Exception e)
|
{
|
System.out.println("MULTI-TEXTURE ???");
|
}
|
|
if (cache)
|
{
|
// Vertices
|
int i3 = 0, i2 = 0;
|
for (int i=0; i<tsa.getValidVertexCount(); i++, i3+=3, i2+=2)
|
{
|
//Vertex v = new Vertex(true);
|
v.set(vertices[i3], vertices[i3+1], vertices[i3+2]);
|
v.norm.set(normals[i3], normals[i3+1], normals[i3+2]);
|
//v.s = textures[0][i2];
|
//v.t = textures[0][i2+1];
|
v.s = uvmap[i2];
|
v.t = uvmap[i2+1];
|
Vertex in = bRep.GetCache(v);
|
if (true) // in == null)
|
{
|
v.index = -1;
|
Vertex out = new Vertex(v);
|
//bRep.AddVertex(out);
|
bRep.Remember(out);
|
}
|
else
|
{
|
bRep.AddVertex(in);
|
}
|
}
|
}
|
|
// Faces
|
int[] counts = new int[tsa.getValidStripCount()];
|
tsa.getStripCount(counts);
|
|
int indexF = 0;
|
int indexV = 0;
|
|
for (int i=0; i<tsa.getValidStripCount(); i++)
|
{
|
int count = counts[i];
|
|
assert count >= 3;
|
|
bRep.AddFace(indexV, indexV+1, indexV+2);
|
indexF++;
|
//bRep.faces.addElement(null);
|
//bRep.setFace(indexF++, indexV, indexV+1, indexV+2);
|
indexV += 3;
|
|
for (int j=3; j<count; j++, indexV++)
|
{
|
//bRep.faces.addElement(null);
|
if ((indexF % 2) == 0)
|
bRep.AddFace(indexV-2, indexV-1, indexV);
|
else
|
bRep.AddFace(indexV-2, indexV, indexV-1);
|
|
indexF++;
|
}
|
}
|
|
assert indexF == tsa.getValidVertexCount() - tsa.getValidStripCount()*2;
|
assert indexV == tsa.getValidVertexCount();
|
|
if (cache)
|
bRep.Trim();
|
|
return bRep;
|
}
|
|
static BoundaryRep Read(TriangleFanArray tsa)
|
{
|
BoundaryRep bRep = new BoundaryRep();
|
|
return bRep;
|
}
|
|
static BoundaryRep Read(TriangleArray tsa)
|
{
|
//System.out.println("TriangleArray");
|
int faces = tsa.getValidVertexCount()/3;
|
|
BoundaryRep bRep = new BoundaryRep(tsa.getValidVertexCount(),
|
faces);
|
|
boolean cache = true;
|
|
if (!cache)
|
bRep.Trim();
|
|
float[] vertices = bRep.getRawVertices(); // new float[tsa.getValidVertexCount()*3];
|
float[] normals = bRep.getRawNormals(); // new float[tsa.getValidVertexCount()*3];
|
float[] uvmap = bRep.getRawUVMap(); // new float[tsa.getValidVertexCount()*2];
|
|
assert (vertices != null);
|
assert (normals != null);
|
try
|
{
|
tsa.getVertices(vertices);
|
tsa.getNormals(normals);
|
|
float[][] textures = new float[1][];
|
textures[0] = uvmap;
|
|
tsa.getTextureCoordinates(textures);
|
}
|
catch (Exception e)
|
{
|
System.out.println("NO VERTEX!");
|
}
|
|
if (cache)
|
{
|
// Vertices
|
int i3 = 0;
|
int i2 = 0;
|
for (int i=0; i<tsa.getValidVertexCount(); i++, i3+=3, i2+=2)
|
{
|
//Vertex v = new Vertex();
|
v.set(vertices[i3], vertices[i3+1], vertices[i3+2]);
|
v.norm.set(normals[i3], normals[i3+1], normals[i3+2]);
|
v.s = uvmap[i2];
|
v.t = uvmap[i2+1];
|
Vertex in = bRep.GetCache(v);
|
if (in == null)
|
{
|
v.index = -1;
|
bRep.Remember(new Vertex(v));
|
}
|
else
|
{
|
bRep.AddVertex(in);
|
}
|
}
|
}
|
|
// Faces
|
int indexF = 0;
|
int indexV = 0;
|
|
for (int i=0; i<faces; i++)
|
{
|
//bRep.faces.addElement(null);
|
bRep.AddFace(indexV, indexV+1, indexV+2);
|
indexF++;
|
|
indexV += 3;
|
}
|
|
assert indexF == faces;
|
assert indexV == tsa.getValidVertexCount();
|
|
if (cache)
|
bRep.Trim();
|
|
return bRep;
|
}
|
|
static Object3D Read(Shape3D s)
|
{
|
Object3D o = new Object3D(s.getClass().getName());
|
|
Material mat = s.getAppearance().getMaterial();
|
|
if (mat != null)
|
o.material = Read(mat);
|
|
//System.out.println("Geometry = " + s.getGeometry());
|
|
o.bRep = Read(s.getGeometry());
|
|
return o;
|
}
|
*/
|
|
void FillMatrix(Matrix4d in, double[][] out)
|
{
|
for (int j=0; j<4; j++)
|
for (int i=0; i<4; i++)
|
out[i][j] = in.getElement(j,i);
|
}
|
}
|
