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

Support for texture's tube projection.

Browse Source 
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8059 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
3.0
Kae..pl 14 years ago
parent cdf464123d
commit 11b250ffe1
2 changed files with 86 additions and 25 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. 12
      engine/src/blender/com/jme3/scene/plugins/blender/textures/UVCoordinatesGenerator.java
  2. 99
      engine/src/blender/com/jme3/scene/plugins/blender/textures/UVProjectionGenerator.java

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

@ -114,8 +114,8 @@ public class UVCoordinatesGenerator {
uvCoordinates = UVProjectionGenerator.cubeProjection(mesh, bb);
break;
case PROJECTION_TUBE:
// TODO: implement
// uvCoordinates = UVProjectionGenerator.tubeProjection(mesh, bb);
BoundingTube bt = UVCoordinatesGenerator.getBoundingTube(mesh);
uvCoordinates = UVProjectionGenerator.tubeProjection(mesh, bt);
break;
case PROJECTION_SPHERE:
uvCoordinates = UVProjectionGenerator.sphereProjection(mesh, bb);
@ -289,11 +289,11 @@ public class UVCoordinatesGenerator {
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;
miny = y < miny ? y : miny;
maxz = z > maxz ? z : maxz;
minz = z < minz ? z : minz;
}
center.divideLocal(limit);
center.divideLocal(limit/3);
float radius = Math.max(maxx - minx, maxy - miny) * 0.5f;
return new BoundingTube(radius, maxz - minz, center);

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

@ -3,22 +3,26 @@ package com.jme3.scene.plugins.blender.textures;
import java.nio.FloatBuffer;
import com.jme3.bounding.BoundingBox;
import com.jme3.math.FastMath;
import com.jme3.math.Triangle;
import com.jme3.math.Vector3f;
import com.jme3.scene.Mesh;
import com.jme3.scene.VertexBuffer;
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
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] flatProjection(Mesh mesh, BoundingBox bb) {
@ -27,7 +31,7 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
}
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);
FloatBuffer positions = mesh.getFloatBuffer(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];
@ -39,10 +43,11 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
/**
* Cube projection for 2D textures.
*
* @param mesh
* mesh that is to be projected
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] cubeProjection(Mesh mesh, BoundingBox bb) {
@ -101,23 +106,72 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
/**
* Tube projection for 2D textures.
*
* @param mesh
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* mesh that is to be projected
* @param bt
* the bounding tube for projecting
* @return UV coordinates after the projection
*/
public static float[] tubeProjection(Mesh mesh, BoundingTube bt) {
FloatBuffer positions = mesh.getFloatBuffer(VertexBuffer.Type.Position);
float[] uvCoordinates = new float[positions.limit() / 3 * 2];
Vector3f v = new Vector3f();
float cx = bt.getCenter().x, cy = bt.getCenter().y;
Vector3f uBase = new Vector3f(0, -1, 0);
//the key is the Z-ccordinate of the vertex and the value a map between the vertex's angle nad indexes of its UV-coordinates
// Map<Float, Map<Float, Integer[]>> lowestAnglesUVCoordinatesMap = new HashMap<Float, Map<Float,Integer[]>>();
float vBase = bt.getCenter().z - bt.getHeight() * 0.5f;
for (int i = 0, j = 0; i < positions.limit(); i += 3, j += 2) {
// calculating U
v.set(positions.get(i)-cx, positions.get(i + 1)-cy, 0);
v.normalizeLocal();
float angle = v.angleBetween(uBase);// result between [0; PI]
if (v.x < 0) {// the angle should be greater than PI, we're on the other part of the image then
angle = FastMath.TWO_PI - angle;
}
uvCoordinates[j] = angle / FastMath.TWO_PI;
public static float[] tubeProjection(Mesh mesh, BoundingTube bb) {
return null;// TODO: implement
// calculating V
float z = positions.get(i + 2);
uvCoordinates[j + 1] = (vBase - z) / bt.getHeight();
}
//looking for splitted triangles
Triangle triangle = new Triangle();
for(int i=0;i<mesh.getTriangleCount();++i) {
mesh.getTriangle(i, triangle);
float sgn1 = Math.signum(triangle.get1().x-cx);
float sgn2 = Math.signum(triangle.get2().x-cx);
float sgn3 = Math.signum(triangle.get3().x-cx);
float xSideFactor = sgn1 + sgn2 + sgn3;
float ySideFactor = Math.signum(triangle.get1().y-cy)+
Math.signum(triangle.get2().y-cy)+
Math.signum(triangle.get3().y-cy);
if((xSideFactor>-3 || xSideFactor<3) && ySideFactor<0) {//the triangle is on the splitting plane
//indexOfUcoord = (indexOfTriangle*3 + indexOfTrianglesVertex)*2
if(sgn1==1.0f) {
uvCoordinates[i*3*2] += 1.0f;
}
if(sgn2==1.0f) {
uvCoordinates[(i*3+1)*2] += 1.0f;
}
if(sgn3==1.0f) {
uvCoordinates[(i*3+2)*2] += 1.0f;
}
}
}
return uvCoordinates;
}
/**
* Sphere projection for 2D textures.
*
* @param mesh
* mesh that is to be projected
* mesh that is to be projected
* @param bb
* the bounding box for projecting
* the bounding box for projecting
* @return UV coordinates after the projection
*/
public static float[] sphereProjection(Mesh mesh, BoundingBox bb) {
@ -128,7 +182,8 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
// Vector3f yVec = new Vector3f();
// Vector3f zVec = new Vector3f();
// for(Geometry geom : geometries) {
// if(materialHelper.hasTexture(geom.getMaterial())) {//generate only when material has a texture
// 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();
@ -136,7 +191,8 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
// 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
// //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);
//
@ -148,17 +204,22 @@ import com.jme3.scene.plugins.blender.textures.UVCoordinatesGenerator.BoundingTu
// 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
// //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
// //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;
// //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
// //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;
// float v = FastMath.acos(p.dot(zVec)/(bs.getRadius()*p.length())) /
// FastMath.PI;
// uvTable[index] = new Vector2f(u, v);
// }
// }

Write Preview
Loading…
Cancel
Save