|
import javax.media.j3d.*;
|
import com.sun.j3d.loaders.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 cJ3D
|
{
|
static boolean gennormals = false; // can be done through UI
|
static boolean trim = true;
|
static boolean stripify = true;
|
static boolean genUV = false;
|
|
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();
|
|
void ResetTransform(Object3D obj, Node s)
|
{
|
if (s instanceof TransformGroup)
|
{
|
ResetTransform(obj, (TransformGroup)s);
|
return;
|
}
|
|
if (s instanceof Group)
|
{
|
Group g = (Group) s;
|
assert(obj.size() == g.numChildren());
|
for (int i=0; i<g.numChildren(); i++)
|
{
|
ResetTransform(obj.get(i), g.getChild(i));
|
}
|
}
|
}
|
|
Object3D Read(Node s)
|
{
|
// System.out.println("Parsing: " + s);
|
|
if (s == null)
|
return new Object3D("NULL");
|
|
if (s instanceof Shape3D)
|
return Read((Shape3D)s);
|
if (s instanceof TransformGroup)
|
return Read((TransformGroup)s);
|
if (s instanceof Group)
|
return Read((Group)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 (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, Shape3D s)
|
{
|
cMaterial cmat = o.material; // Read((MaterialState)s.getRenderState(com.jme.scene.state.RenderState.RS_MATERIAL));
|
Material mat = s.getAppearance().getMaterial();
|
javax.vecmath.Color3f col = new javax.vecmath.Color3f();
|
mat.getDiffuseColor(col);
|
buffer[0] = col.x; buffer[1] = col.y; buffer[2] = col.z; buffer[3] = 1;
|
//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;
|
|
mat.getSpecularColor(col);
|
buffer[0] = col.x; buffer[1] = col.y; buffer[2] = col.z; buffer[3] = 1;
|
|
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] = ol.a;
|
|
//cmat.ambient = buffer[0]+0.001f;
|
|
cmat.shininess = 1 / (Math.max(mat.getShininess(),0)+0.001f); // 1/x
|
}
|
|
void ReadTexture(Object3D o, Shape3D s)
|
{
|
o.GetTextures().name = ":"; // Read((TextureState)s.getRenderState(com.jme.scene.state.RenderState.RS_TEXTURE));
|
}
|
|
void ReadNode(Object3D c, Shape3D g)
|
{
|
// ReadTransform(c, g);
|
ReadMaterial(c, g);
|
ReadTexture(c, g);
|
}
|
|
String GetName(SceneGraphObject sgo)
|
{
|
String thename = "no name";
|
|
if (names == null)
|
{
|
if (sgo.getUserData() == null)
|
return null; // sgo.toString();
|
else
|
return sgo.getUserData().toString();
|
}
|
|
/*
|
if (names.get(s) != null) // ?????
|
name = (String)names.get(s);
|
*/
|
for (java.util.Enumeration<String> e = names.keys(); e.hasMoreElements();)
|
{
|
String name = e.nextElement();
|
|
if (names.get(name) == sgo)
|
{
|
thename = name;
|
break;
|
}
|
}
|
|
return thename;
|
}
|
|
Object3D Read(Shape3D s)
|
{
|
Object3D obj = new Object3D(GetName(s));
|
|
obj.bRep = Read(s.getGeometry());
|
|
if (s.getAppearance() != null)
|
{
|
if (s.getAppearance().getUserData() != null)
|
obj.SetBumpTexture(/*"/" +*/ filename + "/" + s.getAppearance().getUserData().toString());
|
if (s.getAppearance().getMaterial() != null)
|
{
|
obj.CreateMaterial();
|
if (s.getAppearance().getMaterial().getUserData() != null)
|
obj.SetPigmentTexture(/*"/" +*/ filename + "/" + s.getAppearance().getMaterial().getUserData().toString());
|
ReadMaterial(obj, s);
|
}
|
}
|
|
return obj;
|
}
|
|
Object3D Read(Group g)
|
{
|
Composite c = new Composite(GetName(g)); // g.getClass().getName());
|
|
// ReadNode(c, g);
|
|
for (int i=0; i<g.numChildren(); i++)
|
{
|
c.addChild(Read(g.getChild(i)));
|
}
|
|
return c;
|
}
|
|
void ResetTransform(Object3D c, TransformGroup g)
|
{
|
Transform3D t = new Transform3D();
|
Matrix4d m = new Matrix4d();
|
|
ResetTransform(c, t, false);
|
|
// g.getTransform(t);
|
// t.get(m);
|
//
|
// c.toParent[0][0] = m.m00;
|
// c.toParent[0][1] = m.m10;
|
// c.toParent[0][2] = m.m20;
|
// c.toParent[0][3] = m.m30;
|
// c.toParent[1][0] = m.m01;
|
// c.toParent[1][1] = m.m11;
|
// c.toParent[1][2] = m.m21;
|
// c.toParent[1][3] = m.m31;
|
// c.toParent[2][0] = m.m02;
|
// c.toParent[2][1] = m.m12;
|
// c.toParent[2][2] = m.m22;
|
// c.toParent[2][3] = m.m32;
|
// c.toParent[3][0] = m.m03;
|
// c.toParent[3][1] = m.m13;
|
// c.toParent[3][2] = m.m23;
|
// c.toParent[3][3] = m.m33;
|
//
|
// // ReadNode(c, g);
|
// LA.matInvert(c.toParent, c.fromParent);
|
|
// c.Touch();
|
|
assert(c.size() == g.numChildren());
|
for (int i=0; i<g.numChildren(); i++)
|
{
|
ResetTransform(c.get(i), g.getChild(i));
|
}
|
}
|
|
static void GetTranslation(Object3D c, Vector3d t)
|
{
|
t.x = c.toParent[3][0];
|
t.y = c.toParent[3][1];
|
t.z = c.toParent[3][2];
|
}
|
|
static void ResetTransform(Object3D c, Transform3D t, boolean translate)
|
{
|
Matrix4d m = new Matrix4d();
|
t.get(m);
|
|
if (c.toParent == null)
|
{
|
c.toParent = LA.newMatrix();
|
c.fromParent = LA.newMatrix();
|
}
|
|
if (!translate)
|
{
|
c.toParent[0][0] = m.m00;
|
c.toParent[0][1] = m.m10;
|
c.toParent[0][2] = m.m20;
|
c.toParent[0][3] = m.m30;
|
c.toParent[1][0] = m.m01;
|
c.toParent[1][1] = m.m11;
|
c.toParent[1][2] = m.m21;
|
c.toParent[1][3] = m.m31;
|
c.toParent[2][0] = m.m02;
|
c.toParent[2][1] = m.m12;
|
c.toParent[2][2] = m.m22;
|
c.toParent[2][3] = m.m32;
|
}
|
|
c.toParent[3][0] = m.m03;
|
c.toParent[3][1] = m.m13;
|
c.toParent[3][2] = m.m23;
|
c.toParent[3][3] = m.m33;
|
|
// ReadNode(c, g);
|
LA.matInvert(c.toParent, c.fromParent);
|
}
|
|
static void SetTransform(double[][] toParent, Matrix4d m)
|
{
|
toParent[0][0] = m.m00;
|
toParent[0][1] = m.m10;
|
toParent[0][2] = m.m20;
|
toParent[0][3] = m.m30;
|
toParent[1][0] = m.m01;
|
toParent[1][1] = m.m11;
|
toParent[1][2] = m.m21;
|
toParent[1][3] = m.m31;
|
toParent[2][0] = m.m02;
|
toParent[2][1] = m.m12;
|
toParent[2][2] = m.m22;
|
toParent[2][3] = m.m32;
|
toParent[3][0] = m.m03;
|
toParent[3][1] = m.m13;
|
toParent[3][2] = m.m23;
|
toParent[3][3] = m.m33;
|
}
|
|
Matrix4d m = new Matrix4d();
|
|
Object3D Read(TransformGroup g)
|
{
|
Object3D c = new Object3D(GetName(g)); // g.getClass().getName());
|
|
Transform3D t = new Transform3D();
|
|
g.getTransform(t);
|
|
t.get(m);
|
|
c.toParent = LA.newMatrix();
|
c.fromParent = LA.newMatrix();
|
|
if (m.m00 != 0 || m.m10 != 0 || m.m20 != 0 || m.m30 != 0 ||
|
m.m01 != 0 || m.m11 != 0 || m.m21 != 0 || m.m31 != 0 ||
|
m.m02 != 0 || m.m12 != 0 || m.m22 != 0 || m.m32 != 0 ||
|
m.m03 != 0 || m.m13 != 0 || m.m23 != 0 /*|| m.m33 != 0 */)
|
{
|
SetMatrix(c, m);
|
}
|
else
|
{
|
System.err.println("Found zero scale matrix. Hide the object instead.");
|
c.count = 1;
|
}
|
|
// ReadNode(c, g);
|
LA.matInvert(c.toParent, c.fromParent);
|
|
for (int i=0; i<g.numChildren(); i++)
|
{
|
c.addChild(Read(g.getChild(i)));
|
}
|
|
return c;
|
}
|
|
private void SetMatrix(Object3D c, Matrix4d m)
|
{
|
c.toParent[0][0] = m.m00;
|
c.toParent[0][1] = m.m10;
|
c.toParent[0][2] = m.m20;
|
c.toParent[0][3] = m.m30;
|
c.toParent[1][0] = m.m01;
|
c.toParent[1][1] = m.m11;
|
c.toParent[1][2] = m.m21;
|
c.toParent[1][3] = m.m31;
|
c.toParent[2][0] = m.m02;
|
c.toParent[2][1] = m.m12;
|
c.toParent[2][2] = m.m22;
|
c.toParent[2][3] = m.m32;
|
c.toParent[3][0] = m.m03;
|
c.toParent[3][1] = m.m13;
|
c.toParent[3][2] = m.m23;
|
c.toParent[3][3] = m.m33;
|
}
|
|
Object3D Read(Scene s, String fn)
|
{
|
javax.media.j3d.Group g = s.getSceneGroup();
|
names = s.getNamedObjects();
|
filename = fn;
|
// enumnames = names.keys();
|
Object3D obj = Read(g);
|
obj.name = fn;
|
return obj;
|
}
|
|
java.util.Hashtable names;
|
String filename;
|
//java.util.Enumeration<String> enumnames;
|
|
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 = (Math.max(mat.getShininess(),0)+0.001f); // 1/x
|
|
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);
|
|
static Vector3f v3f = new Vector3f();
|
static Point3f p3f = new Point3f();
|
static TexCoord2f t2f = new TexCoord2f();
|
|
BoundaryRep Read(javax.media.j3d.Geometry g)
|
{
|
BoundaryRep brep = null;
|
|
if (g instanceof javax.media.j3d.TriangleArray)
|
{
|
javax.media.j3d.TriangleArray ta = (javax.media.j3d.TriangleArray) g;
|
|
int nbvertices = ta.getVertexCount();
|
|
assert (nbvertices % 3 == 0);
|
|
brep = new BoundaryRep();
|
brep.redimension(nbvertices, nbvertices/3);
|
|
for (int i=0; i<nbvertices; i++)
|
{
|
Vertex v = new Vertex(true);
|
|
ta.getCoordinate(i, p3f);
|
|
v.x = p3f.x;
|
v.y = p3f.y;
|
v.z = p3f.z;
|
|
try
|
{
|
ta.getTextureCoordinate(0, i, t2f);
|
|
v.s = t2f.x;
|
v.t = t2f.y;
|
}
|
catch (Exception e)
|
{
|
v.s = 0;
|
v.t = 0;
|
}
|
|
ta.getNormal(i, v3f);
|
|
v.norm.x = v3f.x;
|
v.norm.y = v3f.y;
|
v.norm.z = v3f.z;
|
|
brep.SetVertex(v, i);
|
}
|
|
for (int i=0; i<nbvertices; i+=3)
|
{
|
brep.setFace(i/3,i,i+1,i+2);
|
}
|
|
//brep.Trim(true, false, false, true, false);
|
// NOT REALLY IMPORTANT
|
brep.Trim();
|
brep.Untrim();
|
if (cJME.stripify)
|
brep.Stripify();
|
if (cJME.reduction34)
|
brep.SplitInTwo(true, false);
|
}
|
if (g instanceof javax.media.j3d.TriangleStripArray)
|
{
|
javax.media.j3d.TriangleStripArray tsa = (javax.media.j3d.TriangleStripArray) g;
|
brep = new BoundaryRep();
|
BoundaryRep bRep = brep;
|
|
bRep.redimension(tsa.getVertexCount(), 0); // tsa.getVertexCount() - tsa.getNumStrips()*2);
|
|
boolean cache = true;
|
|
if (!cache)
|
bRep.Trim();
|
|
float[] vertices = bRep.getRawVertices(); // new float[tsa.getValidVertexCount()*3];
|
tsa.getCoordinates(0, vertices);
|
float[] normals = bRep.getRawNormals(); // new float[tsa.getValidVertexCount()*3];
|
tsa.getNormals(0, normals);
|
float[] uvmap = bRep.getRawUVMap(); // new float[tsa.getValidVertexCount()*2];
|
|
try
|
{
|
tsa.getTextureCoordinate(0, 0, uvmap);
|
}
|
catch (Exception e)
|
{
|
// System.err.println("MULTI-TEXTURE ???");
|
//e.printStackTrace();
|
}
|
|
if (cache)
|
{
|
//Vertex v = new Vertex(true);
|
|
// Vertices
|
int i3 = 0, i2 = 0;
|
for (int i=0; i<tsa.getVertexCount(); i++, i3+=3, i2+=2)
|
{
|
//Vertex v = new Vertex(true);
|
Vertex v = bRep.GetVertex(i);
|
v./*pos.*/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.getNumStrips()];
|
tsa.getStripVertexCounts(counts);
|
|
int indexF = 0;
|
int indexV = 0;
|
|
for (int i=0; i<tsa.getNumStrips(); 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.getVertexCount() - tsa.getNumStrips()*2;
|
assert indexV == tsa.getVertexCount();
|
}
|
/*
|
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.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
|
|
//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);
|
|
//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;
|
*/
|
return brep;
|
}
|
|
/*
|
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);
|
}
|
}
|
