corrections to com.jme3.scene.* comments as discussed at http://hub.jmonkeyengine.org/forum/topic/typos-in-com-jme3-scene/
This commit is contained in:
sgold@sonic.net
parent
5372cb505d
commit
4a69eee64f
@ -76,7 +76,7 @@ public class Geometry extends Spatial {
|
||||
*/
|
||||
protected BatchNode batchNode = null;
|
||||
/**
|
||||
* the start index of this geom's mesh in the batchNode mesh
|
||||
* the start index of this geometry's mesh in the batchNode mesh
|
||||
*/
|
||||
protected int startIndex;
|
||||
/**
|
||||
@ -201,9 +201,9 @@ public class Geometry extends Spatial {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the mseh to use for this geometry
|
||||
* Returns the mesh to use for this geometry
|
||||
*
|
||||
* @return the mseh to use for this geometry
|
||||
* @return the mesh to use for this geometry
|
||||
*
|
||||
* @see #setMesh(com.jme3.scene.Mesh)
|
||||
*/
|
||||
@ -472,9 +472,8 @@ public class Geometry extends Spatial {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a deep clone of the geometry,
|
||||
* this creates an identical copy of the mesh
|
||||
* with the vertexbuffer data duplicated.
|
||||
* Create a deep clone of the geometry. This creates an identical copy of
|
||||
* the mesh with the vertex buffer data duplicated.
|
||||
*/
|
||||
@Override
|
||||
public Spatial deepClone() {
|
||||
|
||||
@ -76,9 +76,8 @@ public class Node extends Spatial implements Savable {
|
||||
* Constructor instantiates a new <code>Node</code> with a default empty
|
||||
* list for containing children.
|
||||
*
|
||||
* @param name
|
||||
* the name of the scene element. This is required for
|
||||
* identification and comparision purposes.
|
||||
* @param name the name of the scene element. This is required for
|
||||
* identification and comparison purposes.
|
||||
*/
|
||||
public Node(String name) {
|
||||
super(name);
|
||||
|
||||
@ -84,11 +84,12 @@ public class VertexBuffer extends NativeObject implements Savable, Cloneable {
|
||||
*/
|
||||
Color,
|
||||
|
||||
/**
|
||||
* Tangent vector, normalized (4 floats) (x,y,z,w)
|
||||
* the w component is called the binormal parity, is not normalized and is either 1f or -1f
|
||||
* It's used to compuste the direction on the binormal verctor on the GPU at render time.
|
||||
*/
|
||||
/**
|
||||
* Tangent vector, normalized (4 floats) (x,y,z,w). The w component is
|
||||
* called the binormal parity, is not normalized, and is either 1f or
|
||||
* -1f. It's used to compute the direction on the binormal vector on the
|
||||
* GPU at render time.
|
||||
*/
|
||||
Tangent,
|
||||
|
||||
/**
|
||||
|
||||
@ -46,9 +46,8 @@ import com.jme3.math.FastMath;
|
||||
public class AreaUtils {
|
||||
|
||||
/**
|
||||
* calcScreenArea -- in Pixels
|
||||
* Aproximates the screen area of a bounding volume. If the volume isn't a
|
||||
* BoundingSphere, BoundingBox, or OrientedBoundingBox 0 is returned.
|
||||
* Estimate the screen area of a bounding volume. If the volume isn't a
|
||||
* BoundingSphere, BoundingBox, or OrientedBoundingBox, 0 is returned.
|
||||
*
|
||||
* @param bound The bounds to calculate the volume from.
|
||||
* @param distance The distance from camera to object.
|
||||
|
||||
@ -90,7 +90,7 @@ public class SkeletonPoints extends Mesh {
|
||||
}
|
||||
|
||||
/**
|
||||
* The method updates the geometry according to the poitions of the bones.
|
||||
* The method updates the geometry according to the positions of the bones.
|
||||
*/
|
||||
public void updateGeometry() {
|
||||
VertexBuffer vb = this.getBuffer(Type.Position);
|
||||
|
||||
@ -1,314 +1,316 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2012 jMonkeyEngine
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
package com.jme3.scene.shape;
|
||||
|
||||
import com.jme3.math.CurveAndSurfaceMath;
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Spline.SplineType;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.math.Vector4f;
|
||||
import com.jme3.scene.Mesh;
|
||||
import com.jme3.scene.VertexBuffer;
|
||||
import com.jme3.util.BufferUtils;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* This class represents a surface described by knots, weights and control points.
|
||||
* Currently the following types are supported:
|
||||
* a) NURBS
|
||||
* @author Marcin Roguski (Kealthas)
|
||||
*/
|
||||
public class Surface extends Mesh {
|
||||
|
||||
private SplineType type; //the type of the surface
|
||||
private List<List<Vector4f>> controlPoints; //space control points and their weights
|
||||
private List<Float>[] knots; //knots of the surface
|
||||
private int basisUFunctionDegree; //the degree of basis U function
|
||||
private int basisVFunctionDegree; //the degree of basis V function
|
||||
private int uSegments; //the amount of U segments
|
||||
private int vSegments; //the amount of V segments
|
||||
|
||||
/**
|
||||
* Constructor. Constructs required surface.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
* @param basisUFunctionDegree the degree of basis U function
|
||||
* @param basisVFunctionDegree the degree of basis V function
|
||||
*/
|
||||
private Surface(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments, int basisUFunctionDegree, int basisVFunctionDegree) {
|
||||
this.validateInputData(controlPoints, nurbKnots, uSegments, vSegments);
|
||||
this.type = SplineType.Nurb;
|
||||
this.uSegments = uSegments;
|
||||
this.vSegments = vSegments;
|
||||
this.controlPoints = controlPoints;
|
||||
this.knots = nurbKnots;
|
||||
this.basisUFunctionDegree = basisUFunctionDegree;
|
||||
CurveAndSurfaceMath.prepareNurbsKnots(nurbKnots[0], basisUFunctionDegree);
|
||||
if (nurbKnots[1] != null) {
|
||||
this.basisVFunctionDegree = basisVFunctionDegree;
|
||||
CurveAndSurfaceMath.prepareNurbsKnots(nurbKnots[1], basisVFunctionDegree);
|
||||
}
|
||||
|
||||
this.buildSurface();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method creates a NURBS surface.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
* @param basisUFunctionDegree the degree of basis U function
|
||||
* @param basisVFunctionDegree the degree of basis V function
|
||||
* @return an instance of NURBS surface
|
||||
*/
|
||||
public static final Surface createNurbsSurface(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments, int basisUFunctionDegree, int basisVFunctionDegree) {
|
||||
Surface result = new Surface(controlPoints, nurbKnots, uSegments, vSegments, basisUFunctionDegree, basisVFunctionDegree);
|
||||
result.type = SplineType.Nurb;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method creates the surface.
|
||||
*/
|
||||
private void buildSurface() {
|
||||
boolean smooth = true;//TODO: take smoothing into consideration
|
||||
float minUKnot = this.getMinUNurbKnot();
|
||||
float maxUKnot = this.getMaxUNurbKnot();
|
||||
float deltaU = (maxUKnot - minUKnot) / uSegments;
|
||||
|
||||
float minVKnot = this.getMinVNurbKnot();
|
||||
float maxVKnot = this.getMaxVNurbKnot();
|
||||
float deltaV = (maxVKnot - minVKnot) / vSegments;
|
||||
|
||||
Vector3f[] vertices = new Vector3f[(uSegments + 1) * (vSegments + 1)];
|
||||
|
||||
float u = minUKnot, v = minVKnot;
|
||||
int arrayIndex = 0;
|
||||
|
||||
for (int i = 0; i <= vSegments; ++i) {
|
||||
for (int j = 0; j <= uSegments; ++j) {
|
||||
Vector3f interpolationResult = new Vector3f();
|
||||
CurveAndSurfaceMath.interpolate(u, v, controlPoints, knots, basisUFunctionDegree, basisVFunctionDegree, interpolationResult);
|
||||
vertices[arrayIndex++] = interpolationResult;
|
||||
u += deltaU;
|
||||
}
|
||||
u = minUKnot;
|
||||
v += deltaV;
|
||||
}
|
||||
|
||||
//adding indexes
|
||||
int uVerticesAmount = uSegments + 1;
|
||||
int[] indices = new int[uSegments * vSegments * 6];
|
||||
arrayIndex = 0;
|
||||
for (int i = 0; i < vSegments; ++i) {
|
||||
for (int j = 0; j < uSegments; ++j) {
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
|
||||
}
|
||||
}
|
||||
|
||||
//normalMap merges normals of faces that will be rendered smooth
|
||||
Map<Vector3f, Vector3f> normalMap = new HashMap<Vector3f, Vector3f>(vertices.length);
|
||||
for (int i = 0; i < indices.length; i += 3) {
|
||||
Vector3f n = FastMath.computeNormal(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
|
||||
this.addNormal(n, normalMap, smooth, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
|
||||
}
|
||||
//preparing normal list (the order of normals must match the order of vertices)
|
||||
float[] normals = new float[vertices.length * 3];
|
||||
arrayIndex = 0;
|
||||
for (int i = 0; i < vertices.length; ++i) {
|
||||
Vector3f n = normalMap.get(vertices[i]);
|
||||
normals[arrayIndex++] = n.x;
|
||||
normals[arrayIndex++] = n.y;
|
||||
normals[arrayIndex++] = n.z;
|
||||
}
|
||||
|
||||
this.setBuffer(VertexBuffer.Type.Position, 3, BufferUtils.createFloatBuffer(vertices));
|
||||
this.setBuffer(VertexBuffer.Type.Index, 3, indices);
|
||||
this.setBuffer(VertexBuffer.Type.Normal, 3, normals);
|
||||
this.updateBound();
|
||||
this.updateCounts();
|
||||
}
|
||||
|
||||
public List<List<Vector4f>> getControlPoints() {
|
||||
return controlPoints;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the amount of U control points.
|
||||
* @return the amount of U control points
|
||||
*/
|
||||
public int getUControlPointsAmount() {
|
||||
return controlPoints.size();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the amount of V control points.
|
||||
* @return the amount of V control points
|
||||
*/
|
||||
public int getVControlPointsAmount() {
|
||||
return controlPoints.get(0) == null ? 0 : controlPoints.get(0).size();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the degree of basis U function.
|
||||
* @return the degree of basis U function
|
||||
*/
|
||||
public int getBasisUFunctionDegree() {
|
||||
return basisUFunctionDegree;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the degree of basis V function.
|
||||
* @return the degree of basis V function
|
||||
*/
|
||||
public int getBasisVFunctionDegree() {
|
||||
return basisVFunctionDegree;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the knots for specified dimension (U knots - value: '0',
|
||||
* V knots - value: '1').
|
||||
* @param dim an integer specifying if the U or V knots are required
|
||||
* @return an array of knots
|
||||
*/
|
||||
public List<Float> getKnots(int dim) {
|
||||
return knots[dim];
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the type of the surface.
|
||||
* @return the type of the surface
|
||||
*/
|
||||
public SplineType getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the minimum nurb curve U knot value.
|
||||
* @return the minimum nurb curve knot value
|
||||
*/
|
||||
private float getMinUNurbKnot() {
|
||||
return knots[0].get(basisUFunctionDegree - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the maximum nurb curve U knot value.
|
||||
* @return the maximum nurb curve knot value
|
||||
*/
|
||||
private float getMaxUNurbKnot() {
|
||||
return knots[0].get(knots[0].size() - basisUFunctionDegree);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the minimum nurb curve U knot value.
|
||||
* @return the minimum nurb curve knot value
|
||||
*/
|
||||
private float getMinVNurbKnot() {
|
||||
return knots[1].get(basisVFunctionDegree - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the maximum nurb curve U knot value.
|
||||
* @return the maximum nurb curve knot value
|
||||
*/
|
||||
private float getMaxVNurbKnot() {
|
||||
return knots[1].get(knots[1].size() - basisVFunctionDegree);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method adds a normal to a normals' map. This map is used to merge normals of a vertor that should be rendered smooth.
|
||||
* @param normalToAdd
|
||||
* a normal to be added
|
||||
* @param normalMap
|
||||
* merges normals of faces that will be rendered smooth; the key is the vertex and the value - its normal vector
|
||||
* @param smooth
|
||||
* the variable that indicates wheather to merge normals (creating the smooth mesh) or not
|
||||
* @param vertices
|
||||
* a list of vertices read from the blender file
|
||||
*/
|
||||
private void addNormal(Vector3f normalToAdd, Map<Vector3f, Vector3f> normalMap, boolean smooth, Vector3f... vertices) {
|
||||
for (Vector3f v : vertices) {
|
||||
Vector3f n = normalMap.get(v);
|
||||
if (!smooth || n == null) {
|
||||
normalMap.put(v, normalToAdd.clone());
|
||||
} else {
|
||||
n.addLocal(normalToAdd).normalizeLocal();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method validates the input data. It throws {@link IllegalArgumentException} if
|
||||
* the data is invalid.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
*/
|
||||
private void validateInputData(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments) {
|
||||
int uPointsAmount = controlPoints.get(0).size();
|
||||
for (int i = 1; i < controlPoints.size(); ++i) {
|
||||
if (controlPoints.get(i).size() != uPointsAmount) {
|
||||
throw new IllegalArgumentException("The amount of 'U' control points is invalid!");
|
||||
}
|
||||
}
|
||||
if (uSegments <= 0) {
|
||||
throw new IllegalArgumentException("U segments amount should be positive!");
|
||||
}
|
||||
if (vSegments < 0) {
|
||||
throw new IllegalArgumentException("V segments amount cannot be negative!");
|
||||
}
|
||||
if (nurbKnots.length != 2) {
|
||||
throw new IllegalArgumentException("Nurb surface should have two rows of knots!");
|
||||
}
|
||||
for (int i = 0; i < nurbKnots.length; ++i) {
|
||||
for (int j = 0; j < nurbKnots[i].size() - 1; ++j) {
|
||||
if (nurbKnots[i].get(j) > nurbKnots[i].get(j + 1)) {
|
||||
throw new IllegalArgumentException("The knots' values cannot decrease!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2009-2012 jMonkeyEngine
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
package com.jme3.scene.shape;
|
||||
|
||||
import com.jme3.math.CurveAndSurfaceMath;
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Spline.SplineType;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.math.Vector4f;
|
||||
import com.jme3.scene.Mesh;
|
||||
import com.jme3.scene.VertexBuffer;
|
||||
import com.jme3.util.BufferUtils;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* This class represents a surface described by knots, weights and control points.
|
||||
* Currently the following types are supported:
|
||||
* a) NURBS
|
||||
* @author Marcin Roguski (Kealthas)
|
||||
*/
|
||||
public class Surface extends Mesh {
|
||||
|
||||
private SplineType type; //the type of the surface
|
||||
private List<List<Vector4f>> controlPoints; //space control points and their weights
|
||||
private List<Float>[] knots; //knots of the surface
|
||||
private int basisUFunctionDegree; //the degree of basis U function
|
||||
private int basisVFunctionDegree; //the degree of basis V function
|
||||
private int uSegments; //the amount of U segments
|
||||
private int vSegments; //the amount of V segments
|
||||
|
||||
/**
|
||||
* Constructor. Constructs required surface.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
* @param basisUFunctionDegree the degree of basis U function
|
||||
* @param basisVFunctionDegree the degree of basis V function
|
||||
*/
|
||||
private Surface(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments, int basisUFunctionDegree, int basisVFunctionDegree) {
|
||||
this.validateInputData(controlPoints, nurbKnots, uSegments, vSegments);
|
||||
this.type = SplineType.Nurb;
|
||||
this.uSegments = uSegments;
|
||||
this.vSegments = vSegments;
|
||||
this.controlPoints = controlPoints;
|
||||
this.knots = nurbKnots;
|
||||
this.basisUFunctionDegree = basisUFunctionDegree;
|
||||
CurveAndSurfaceMath.prepareNurbsKnots(nurbKnots[0], basisUFunctionDegree);
|
||||
if (nurbKnots[1] != null) {
|
||||
this.basisVFunctionDegree = basisVFunctionDegree;
|
||||
CurveAndSurfaceMath.prepareNurbsKnots(nurbKnots[1], basisVFunctionDegree);
|
||||
}
|
||||
|
||||
this.buildSurface();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method creates a NURBS surface.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
* @param basisUFunctionDegree the degree of basis U function
|
||||
* @param basisVFunctionDegree the degree of basis V function
|
||||
* @return an instance of NURBS surface
|
||||
*/
|
||||
public static final Surface createNurbsSurface(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments, int basisUFunctionDegree, int basisVFunctionDegree) {
|
||||
Surface result = new Surface(controlPoints, nurbKnots, uSegments, vSegments, basisUFunctionDegree, basisVFunctionDegree);
|
||||
result.type = SplineType.Nurb;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method creates the surface.
|
||||
*/
|
||||
private void buildSurface() {
|
||||
boolean smooth = true;//TODO: take smoothing into consideration
|
||||
float minUKnot = this.getMinUNurbKnot();
|
||||
float maxUKnot = this.getMaxUNurbKnot();
|
||||
float deltaU = (maxUKnot - minUKnot) / uSegments;
|
||||
|
||||
float minVKnot = this.getMinVNurbKnot();
|
||||
float maxVKnot = this.getMaxVNurbKnot();
|
||||
float deltaV = (maxVKnot - minVKnot) / vSegments;
|
||||
|
||||
Vector3f[] vertices = new Vector3f[(uSegments + 1) * (vSegments + 1)];
|
||||
|
||||
float u = minUKnot, v = minVKnot;
|
||||
int arrayIndex = 0;
|
||||
|
||||
for (int i = 0; i <= vSegments; ++i) {
|
||||
for (int j = 0; j <= uSegments; ++j) {
|
||||
Vector3f interpolationResult = new Vector3f();
|
||||
CurveAndSurfaceMath.interpolate(u, v, controlPoints, knots, basisUFunctionDegree, basisVFunctionDegree, interpolationResult);
|
||||
vertices[arrayIndex++] = interpolationResult;
|
||||
u += deltaU;
|
||||
}
|
||||
u = minUKnot;
|
||||
v += deltaV;
|
||||
}
|
||||
|
||||
//adding indexes
|
||||
int uVerticesAmount = uSegments + 1;
|
||||
int[] indices = new int[uSegments * vSegments * 6];
|
||||
arrayIndex = 0;
|
||||
for (int i = 0; i < vSegments; ++i) {
|
||||
for (int j = 0; j < uSegments; ++j) {
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount + 1;
|
||||
indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
|
||||
}
|
||||
}
|
||||
|
||||
//normalMap merges normals of faces that will be rendered smooth
|
||||
Map<Vector3f, Vector3f> normalMap = new HashMap<Vector3f, Vector3f>(vertices.length);
|
||||
for (int i = 0; i < indices.length; i += 3) {
|
||||
Vector3f n = FastMath.computeNormal(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
|
||||
this.addNormal(n, normalMap, smooth, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
|
||||
}
|
||||
//preparing normal list (the order of normals must match the order of vertices)
|
||||
float[] normals = new float[vertices.length * 3];
|
||||
arrayIndex = 0;
|
||||
for (int i = 0; i < vertices.length; ++i) {
|
||||
Vector3f n = normalMap.get(vertices[i]);
|
||||
normals[arrayIndex++] = n.x;
|
||||
normals[arrayIndex++] = n.y;
|
||||
normals[arrayIndex++] = n.z;
|
||||
}
|
||||
|
||||
this.setBuffer(VertexBuffer.Type.Position, 3, BufferUtils.createFloatBuffer(vertices));
|
||||
this.setBuffer(VertexBuffer.Type.Index, 3, indices);
|
||||
this.setBuffer(VertexBuffer.Type.Normal, 3, normals);
|
||||
this.updateBound();
|
||||
this.updateCounts();
|
||||
}
|
||||
|
||||
public List<List<Vector4f>> getControlPoints() {
|
||||
return controlPoints;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the amount of U control points.
|
||||
* @return the amount of U control points
|
||||
*/
|
||||
public int getUControlPointsAmount() {
|
||||
return controlPoints.size();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the amount of V control points.
|
||||
* @return the amount of V control points
|
||||
*/
|
||||
public int getVControlPointsAmount() {
|
||||
return controlPoints.get(0) == null ? 0 : controlPoints.get(0).size();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the degree of basis U function.
|
||||
* @return the degree of basis U function
|
||||
*/
|
||||
public int getBasisUFunctionDegree() {
|
||||
return basisUFunctionDegree;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the degree of basis V function.
|
||||
* @return the degree of basis V function
|
||||
*/
|
||||
public int getBasisVFunctionDegree() {
|
||||
return basisVFunctionDegree;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the knots for specified dimension (U knots - value: '0',
|
||||
* V knots - value: '1').
|
||||
* @param dim an integer specifying if the U or V knots are required
|
||||
* @return an array of knots
|
||||
*/
|
||||
public List<Float> getKnots(int dim) {
|
||||
return knots[dim];
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the type of the surface.
|
||||
* @return the type of the surface
|
||||
*/
|
||||
public SplineType getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the minimum nurb curve U knot value.
|
||||
* @return the minimum nurb curve knot value
|
||||
*/
|
||||
private float getMinUNurbKnot() {
|
||||
return knots[0].get(basisUFunctionDegree - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the maximum nurb curve U knot value.
|
||||
* @return the maximum nurb curve knot value
|
||||
*/
|
||||
private float getMaxUNurbKnot() {
|
||||
return knots[0].get(knots[0].size() - basisUFunctionDegree);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the minimum nurb curve U knot value.
|
||||
* @return the minimum nurb curve knot value
|
||||
*/
|
||||
private float getMinVNurbKnot() {
|
||||
return knots[1].get(basisVFunctionDegree - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the maximum nurb curve U knot value.
|
||||
* @return the maximum nurb curve knot value
|
||||
*/
|
||||
private float getMaxVNurbKnot() {
|
||||
return knots[1].get(knots[1].size() - basisVFunctionDegree);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method adds a normal to a normal's map. This map is used to merge
|
||||
* normals of a vector that should be rendered smooth.
|
||||
*
|
||||
* @param normalToAdd
|
||||
* a normal to be added
|
||||
* @param normalMap
|
||||
* merges normals of faces that will be rendered smooth; the key is the vertex and the value - its normal vector
|
||||
* @param smooth the variable that indicates whether to merge normals
|
||||
* (creating the smooth mesh) or not
|
||||
* @param vertices
|
||||
* a list of vertices read from the blender file
|
||||
*/
|
||||
private void addNormal(Vector3f normalToAdd, Map<Vector3f, Vector3f> normalMap, boolean smooth, Vector3f... vertices) {
|
||||
for (Vector3f v : vertices) {
|
||||
Vector3f n = normalMap.get(v);
|
||||
if (!smooth || n == null) {
|
||||
normalMap.put(v, normalToAdd.clone());
|
||||
} else {
|
||||
n.addLocal(normalToAdd).normalizeLocal();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method validates the input data. It throws {@link IllegalArgumentException} if
|
||||
* the data is invalid.
|
||||
* @param controlPoints space control points
|
||||
* @param nurbKnots knots of the surface
|
||||
* @param uSegments the amount of U segments
|
||||
* @param vSegments the amount of V segments
|
||||
*/
|
||||
private void validateInputData(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
|
||||
int uSegments, int vSegments) {
|
||||
int uPointsAmount = controlPoints.get(0).size();
|
||||
for (int i = 1; i < controlPoints.size(); ++i) {
|
||||
if (controlPoints.get(i).size() != uPointsAmount) {
|
||||
throw new IllegalArgumentException("The amount of 'U' control points is invalid!");
|
||||
}
|
||||
}
|
||||
if (uSegments <= 0) {
|
||||
throw new IllegalArgumentException("U segments amount should be positive!");
|
||||
}
|
||||
if (vSegments < 0) {
|
||||
throw new IllegalArgumentException("V segments amount cannot be negative!");
|
||||
}
|
||||
if (nurbKnots.length != 2) {
|
||||
throw new IllegalArgumentException("Nurb surface should have two rows of knots!");
|
||||
}
|
||||
for (int i = 0; i < nurbKnots.length; ++i) {
|
||||
for (int j = 0; j < nurbKnots[i].size() - 1; ++j) {
|
||||
if (nurbKnots[i].get(j) > nurbKnots[i].get(j + 1)) {
|
||||
throw new IllegalArgumentException("The knots' values cannot decrease!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -57,9 +57,13 @@ public class Torus extends Mesh {
|
||||
private int circleSamples;
|
||||
|
||||
private int radialSamples;
|
||||
|
||||
/**
|
||||
* minor radius of the torus
|
||||
*/
|
||||
private float innerRadius;
|
||||
|
||||
/**
|
||||
* major radius of the torus
|
||||
*/
|
||||
private float outerRadius;
|
||||
|
||||
public Torus() {
|
||||
@ -73,10 +77,8 @@ public class Torus extends Mesh {
|
||||
* The number of samples along the circles.
|
||||
* @param radialSamples
|
||||
* The number of samples along the radial.
|
||||
* @param innerRadius
|
||||
* The radius of the inner begining of the Torus.
|
||||
* @param outerRadius
|
||||
* The radius of the outter end of the Torus.
|
||||
* @param innerRadius minor radius of the torus
|
||||
* @param outerRadius major radius of the torus
|
||||
*/
|
||||
public Torus(int circleSamples, int radialSamples,
|
||||
float innerRadius, float outerRadius) {
|
||||
@ -226,8 +228,8 @@ public class Torus extends Mesh {
|
||||
*
|
||||
* @param circleSamples the number of samples along the circles.
|
||||
* @param radialSamples the number of samples along the radial.
|
||||
* @param innerRadius the radius of the inner begining of the Torus.
|
||||
* @param outerRadius the radius of the outter end of the Torus.
|
||||
* @param innerRadius minor radius of the torus
|
||||
* @param outerRadius major radius of the torus
|
||||
*/
|
||||
public void updateGeometry(int circleSamples, int radialSamples, float innerRadius, float outerRadius) {
|
||||
this.circleSamples = circleSamples;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user