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

corrections to com.jme3.scene.* comments as discussed at http://hub.jmonkeyengine.org/forum/topic/typos-in-com-jme3-scene/

Browse Source
experimental
sgold@sonic.net 11 years ago
parent 5372cb505d
commit 4a69eee64f
7 changed files with 342 additions and 340 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. 11
      jme3-core/src/main/java/com/jme3/scene/Geometry.java
  2. 5
      jme3-core/src/main/java/com/jme3/scene/Node.java
  3. 11
      jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java
  4. 5
      jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java
  5. 2
      jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java
  6. 630
      jme3-core/src/main/java/com/jme3/scene/shape/Surface.java
  7. 18
      jme3-core/src/main/java/com/jme3/scene/shape/Torus.java

11
jme3-core/src/main/java/com/jme3/scene/Geometry.java
Unescape View File

@ -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() {

5
jme3-core/src/main/java/com/jme3/scene/Node.java
Unescape View File

@ -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);

11
jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java
Unescape View File

@ -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,
/**

5
jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java
Unescape View File

@ -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.

2
jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java
Unescape View File

@ -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);

630
jme3-core/src/main/java/com/jme3/scene/shape/Surface.java
Unescape View File

@ -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!");
}
}
}
}
}

18
jme3-core/src/main/java/com/jme3/scene/shape/Torus.java
Unescape View File

@ -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;

Write Preview
Loading…
Cancel
Save