sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Moving projection calculations to a separate class.

Browse Source 
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8055 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
3.0
Kae..pl 13 years ago
parent 843cce9b30
commit 8f1e07a557
2 changed files with 242 additions and 161 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 236
      engine/src/blender/com/jme3/scene/plugins/blender/textures/UVCoordinatesGenerator.java
  2. 167
      engine/src/blender/com/jme3/scene/plugins/blender/textures/UVProjectionGenerator.java

236
engine/src/blender/com/jme3/scene/plugins/blender/textures/UVCoordinatesGenerator.java
Unescape View File

@ -38,7 +38,6 @@ import java.util.logging.Logger;
import com.jme3.bounding.BoundingBox;
import com.jme3.bounding.BoundingSphere;
import com.jme3.bounding.BoundingVolume;
import com.jme3.math.Triangle;
import com.jme3.math.Vector2f;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
@ -109,16 +108,17 @@ public class UVCoordinatesGenerator {
if (textureDimension == 2) {
switch (projection) {
case PROJECTION_FLAT:
uvCoordinates = UVCoordinatesGenerator.flatProjection(mesh, bb);
uvCoordinates = UVProjectionGenerator.flatProjection(mesh, bb);
break;
case PROJECTION_CUBE:
uvCoordinates = UVCoordinatesGenerator.cubeProjection(mesh, bb);
uvCoordinates = UVProjectionGenerator.cubeProjection(mesh, bb);
break;
case PROJECTION_TUBE:
uvCoordinates = UVCoordinatesGenerator.tubeProjection(mesh, bb);
// TODO: implement
// uvCoordinates = UVProjectionGenerator.tubeProjection(mesh, bb);
break;
case PROJECTION_SPHERE:
uvCoordinates = UVCoordinatesGenerator.sphereProjection(mesh, bb);
uvCoordinates = UVProjectionGenerator.sphereProjection(mesh, bb);
break;
default:
throw new IllegalStateException("Unknown projection type: " + projection);
@ -188,165 +188,13 @@ public class UVCoordinatesGenerator {
}
}
/**
* Flat projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
private static float[] flatProjection(Mesh mesh, BoundingBox bb) {
if (bb == null) {
bb = UVCoordinatesGenerator.getBoundingBox(mesh);
}
Vector3f min = bb.getMin(null);
float[] ext = new float[] { bb.getXExtent() * 2.0f, bb.getYExtent() * 2.0f };
FloatBuffer positions = mesh.getFloatBuffer(com.jme3.scene.VertexBuffer.Type.Position);
float[] uvCoordinates = new float[positions.limit() / 3 * 2];
for (int i = 0, j = 0; i < positions.limit(); i += 3, j += 2) {
uvCoordinates[j] = (positions.get(i) - min.x) / ext[0];
uvCoordinates[j + 1] = (positions.get(i + 1) - min.y) / ext[1];
// skip the Z-coordinate
}
return uvCoordinates;
}
/**
* Cube projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
private static float[] cubeProjection(Mesh mesh, BoundingBox bb) {
Triangle triangle = new Triangle();
Vector3f x = new Vector3f(1, 0, 0);
Vector3f y = new Vector3f(0, 1, 0);
Vector3f z = new Vector3f(0, 0, 1);
Vector3f min = bb.getMin(null);
float[] ext = new float[] { bb.getXExtent() * 2.0f, bb.getYExtent() * 2.0f, bb.getZExtent() * 2.0f };
float[] uvCoordinates = new float[mesh.getTriangleCount() * 6];// 6 == 3 * 2
float borderAngle = (float)Math.sqrt(2.0f)/2.0f;
for (int i = 0, pointIndex = 0; i < mesh.getTriangleCount(); ++i) {
mesh.getTriangle(i, triangle);
Vector3f n = triangle.getNormal();
float dotNX = Math.abs(n.dot(x));
float dorNY = Math.abs(n.dot(y));
float dotNZ = Math.abs(n.dot(z));
if (dotNX > borderAngle) {
if (dotNZ < borderAngle) {// discard X-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get1().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().z - min.z) / ext[2];
} else {// discard Z-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
}
} else {
if (dorNY > borderAngle) {// discard Y-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().z - min.z) / ext[2];
} else {// discard Z-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
}
}
triangle.setNormal(null);//clear the previous normal vector
}
return uvCoordinates;
}
/**
* Tube projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
private static float[] tubeProjection(Mesh mesh, BoundingBox bb) {
return null;// TODO: implement
}
/**
* Sphere projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
private static float[] sphereProjection(Mesh mesh, BoundingBox bb) {
return null;// TODO: implement
// Vector2f[] uvTable = new Vector2f[vertexList.size()];
// Ray ray = new Ray();
// CollisionResults cr = new CollisionResults();
// Vector3f yVec = new Vector3f();
// Vector3f zVec = new Vector3f();
// for(Geometry geom : geometries) {
// if(materialHelper.hasTexture(geom.getMaterial())) {//generate only when material has a texture
// geom.getMesh().updateBound();
// BoundingSphere bs = this.getBoundingSphere(geom.getMesh());
// float r2 = bs.getRadius() * bs.getRadius();
// yVec.set(0, -bs.getRadius(), 0);
// zVec.set(0, 0, -bs.getRadius());
// Vector3f center = bs.getCenter();
// ray.setOrigin(center);
// //we cast each vertex of the current mesh on the bounding box to determine the UV-coordinates
// for(int i=0;i<geom.getMesh().getIndexBuffer().size();++i) {
// int index = geom.getMesh().getIndexBuffer().get(i);
//
// ray.setOrigin(vertexList.get(index));
// ray.setDirection(normalList.get(index));
//
// //finding collision point
// cr.clear();
// bs.collideWith(ray, cr);//there is ALWAYS one collision
// Vector3f p = cr.getCollision(0).getContactPoint();
// p.subtractLocal(center);
// //arcLength = FastMath.acos(p.dot(yVec)/(p.length * yVec.length)) * r <- an arc length on the sphere (from top to the point on
// the sphere)
// //but yVec.length == r and p.length == r so: arcLength = FastMath.acos(p.dot(yVec)/r^2)/r
// //U coordinate is as follows: u = arcLength / PI*r
// //so to compute it faster we just write: u = FastMath.acos(p.dot(yVec)/r^2) / PI;
// float u = FastMath.acos(p.dot(yVec)/r2) / FastMath.PI;
// //we use similiar method to compute v
// //the only difference is that we need to cast the p vector on ZX plane
// //and use its length instead of r
// p.y = 0;
// float v = FastMath.acos(p.dot(zVec)/(bs.getRadius()*p.length())) / FastMath.PI;
// uvTable[index] = new Vector2f(u, v);
// }
// }
// }
}
/**
* This method returns the bounding box of the given geometries.
* @param geometries
* the list of geometries
* @return bounding box of the given geometries
*/
private static BoundingBox getBoundingBox(List<Geometry> geometries) {
/* package */static BoundingBox getBoundingBox(List<Geometry> geometries) {
BoundingBox result = null;
for (Geometry geometry : geometries) {
BoundingBox bb = UVCoordinatesGenerator.getBoundingBox(geometry.getMesh());
@ -365,7 +213,7 @@ public class UVCoordinatesGenerator {
* the mesh
* @return bounding box of the given mesh
*/
private static BoundingBox getBoundingBox(Mesh mesh) {
/* package */static BoundingBox getBoundingBox(Mesh mesh) {
mesh.updateBound();
BoundingVolume bv = mesh.getBound();
if (bv instanceof BoundingBox) {
@ -385,7 +233,7 @@ public class UVCoordinatesGenerator {
* the list of geometries
* @return bounding spheres of the given geometries
*/
private static BoundingSphere getBoundingSphere(List<Geometry> geometries) {
/* package */static BoundingSphere getBoundingSphere(List<Geometry> geometries) {
BoundingSphere result = null;
for (Geometry geometry : geometries) {
BoundingSphere bs = UVCoordinatesGenerator.getBoundingSphere(geometry.getMesh());
@ -404,7 +252,7 @@ public class UVCoordinatesGenerator {
* the mesh
* @return bounding sphere of the given mesh
*/
private static BoundingSphere getBoundingSphere(Mesh mesh) {
/* package */static BoundingSphere getBoundingSphere(Mesh mesh) {
mesh.updateBound();
BoundingVolume bv = mesh.getBound();
if (bv instanceof BoundingBox) {
@ -418,4 +266,70 @@ public class UVCoordinatesGenerator {
throw new IllegalStateException("Unknown bounding volume type: " + bv.getClass().getName());
}
}
/**
* This method returns the bounding tube of the given mesh.
* @param mesh
* the mesh
* @return bounding tube of the given mesh
*/
/* package */static BoundingTube getBoundingTube(Mesh mesh) {
Vector3f center = new Vector3f();
float maxx = -Float.MAX_VALUE, minx = Float.MAX_VALUE;
float maxy = -Float.MAX_VALUE, miny = Float.MAX_VALUE;
float maxz = -Float.MAX_VALUE, minz = Float.MAX_VALUE;
FloatBuffer positions = mesh.getFloatBuffer(VertexBuffer.Type.Position);
int limit = positions.limit();
for (int i = 0; i < limit; i += 3) {
float x = positions.get(i);
float y = positions.get(i + 1);
float z = positions.get(i + 2);
center.addLocal(x, y, z);
maxx = x > maxx ? x : maxx;
minx = x < minx ? x : minx;
maxy = y > maxy ? y : maxy;
miny = x < miny ? y : miny;
maxz = x > maxz ? z : maxz;
minz = x < minz ? z : minz;
}
center.divideLocal(limit);
float radius = Math.max(maxx - minx, maxy - miny) * 0.5f;
return new BoundingTube(radius, maxz - minz, center);
}
/**
* A very simple bounding tube. Id holds only the basic data bout the bounding tube
* and does not provide full functionality of a BoundingVolume.
* Should be replaced with a bounding tube that extends the BoundingVolume if it is ever created.
* @author Marcin Roguski (Kaelthas)
*/
/* package */static class BoundingTube {
private float radius;
private float height;
private Vector3f center;
public BoundingTube(float radius, float height, Vector3f center) {
this.radius = radius;
this.height = height;
this.center = center;
}
public void merge(BoundingTube boundingTube) {
// TODO: implement
}
public float getRadius() {
return radius;
}
public float getHeight() {
return height;
}
public Vector3f getCenter() {
return center;
}
}
}

167
engine/src/blender/com/jme3/scene/plugins/blender/textures/UVProjectionGenerator.java
Unescape View File

@ -0,0 +1,167 @@
package com.jme3.scene.plugins.blender.textures;
import java.nio.FloatBuffer;
import com.jme3.bounding.BoundingBox;
import com.jme3.math.Triangle;
import com.jme3.math.Vector3f;
import com.jme3.scene.Mesh;
import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTube;
/**
* This class helps with projection calculations.
* @author Marcin Roguski (Kaelthas)
*/
/* package */class UVProjectionGenerator {
/**
* Flat projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] flatProjection(Mesh mesh, BoundingBox bb) {
if (bb == null) {
bb = UVCoordinatesGenerator.getBoundingBox(mesh);
}
Vector3f min = bb.getMin(null);
float[] ext = new float[] { bb.getXExtent() * 2.0f, bb.getYExtent() * 2.0f };
FloatBuffer positions = mesh.getFloatBuffer(com.jme3.scene.VertexBuffer.Type.Position);
float[] uvCoordinates = new float[positions.limit() / 3 * 2];
for (int i = 0, j = 0; i < positions.limit(); i += 3, j += 2) {
uvCoordinates[j] = (positions.get(i) - min.x) / ext[0];
uvCoordinates[j + 1] = (positions.get(i + 1) - min.y) / ext[1];
// skip the Z-coordinate
}
return uvCoordinates;
}
/**
* Cube projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] cubeProjection(Mesh mesh, BoundingBox bb) {
Triangle triangle = new Triangle();
Vector3f x = new Vector3f(1, 0, 0);
Vector3f y = new Vector3f(0, 1, 0);
Vector3f z = new Vector3f(0, 0, 1);
Vector3f min = bb.getMin(null);
float[] ext = new float[] { bb.getXExtent() * 2.0f, bb.getYExtent() * 2.0f, bb.getZExtent() * 2.0f };
float[] uvCoordinates = new float[mesh.getTriangleCount() * 6];// 6 == 3 * 2
float borderAngle = (float) Math.sqrt(2.0f) / 2.0f;
for (int i = 0, pointIndex = 0; i < mesh.getTriangleCount(); ++i) {
mesh.getTriangle(i, triangle);
Vector3f n = triangle.getNormal();
float dotNX = Math.abs(n.dot(x));
float dorNY = Math.abs(n.dot(y));
float dotNZ = Math.abs(n.dot(z));
if (dotNX > borderAngle) {
if (dotNZ < borderAngle) {// discard X-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get1().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().z - min.z) / ext[2];
} else {// discard Z-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
}
} else {
if (dorNY > borderAngle) {// discard Y-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().z - min.z) / ext[2];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().z - min.z) / ext[2];
} else {// discard Z-coordinate
uvCoordinates[pointIndex++] = (triangle.get1().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get1().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get2().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get2().y - min.y) / ext[1];
uvCoordinates[pointIndex++] = (triangle.get3().x - min.x) / ext[0];
uvCoordinates[pointIndex++] = (triangle.get3().y - min.y) / ext[1];
}
}
triangle.setNormal(null);// clear the previous normal vector
}
return uvCoordinates;
}
/**
* Tube projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] tubeProjection(Mesh mesh, BoundingTube bb) {
return null;// TODO: implement
}
/**
* Sphere projection for 2D textures.
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] sphereProjection(Mesh mesh, BoundingBox bb) {
return null;// TODO: implement
// Vector2f[] uvTable = new Vector2f[vertexList.size()];
// Ray ray = new Ray();
// CollisionResults cr = new CollisionResults();
// Vector3f yVec = new Vector3f();
// Vector3f zVec = new Vector3f();
// for(Geometry geom : geometries) {
// if(materialHelper.hasTexture(geom.getMaterial())) {//generate only when material has a texture
// geom.getMesh().updateBound();
// BoundingSphere bs = this.getBoundingSphere(geom.getMesh());
// float r2 = bs.getRadius() * bs.getRadius();
// yVec.set(0, -bs.getRadius(), 0);
// zVec.set(0, 0, -bs.getRadius());
// Vector3f center = bs.getCenter();
// ray.setOrigin(center);
// //we cast each vertex of the current mesh on the bounding box to determine the UV-coordinates
// for(int i=0;i<geom.getMesh().getIndexBuffer().size();++i) {
// int index = geom.getMesh().getIndexBuffer().get(i);
//
// ray.setOrigin(vertexList.get(index));
// ray.setDirection(normalList.get(index));
//
// //finding collision point
// cr.clear();
// bs.collideWith(ray, cr);//there is ALWAYS one collision
// Vector3f p = cr.getCollision(0).getContactPoint();
// p.subtractLocal(center);
// //arcLength = FastMath.acos(p.dot(yVec)/(p.length * yVec.length)) * r <- an arc length on the sphere (from top to the point on
// the sphere)
// //but yVec.length == r and p.length == r so: arcLength = FastMath.acos(p.dot(yVec)/r^2)/r
// //U coordinate is as follows: u = arcLength / PI*r
// //so to compute it faster we just write: u = FastMath.acos(p.dot(yVec)/r^2) / PI;
// float u = FastMath.acos(p.dot(yVec)/r2) / FastMath.PI;
// //we use similiar method to compute v
// //the only difference is that we need to cast the p vector on ZX plane
// //and use its length instead of r
// p.y = 0;
// float v = FastMath.acos(p.dot(zVec)/(bs.getRadius()*p.length())) / FastMath.PI;
// uvTable[index] = new Vector2f(u, v);
// }
// }
// }
}
}
Write Preview
Loading…
Cancel
Save