diff --git a/jme3-core/src/main/java/com/jme3/scene/Geometry.java b/jme3-core/src/main/java/com/jme3/scene/Geometry.java
index 7c381c15e..5c5bea10d 100644
--- a/jme3-core/src/main/java/com/jme3/scene/Geometry.java
+++ b/jme3-core/src/main/java/com/jme3/scene/Geometry.java
@@ -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() {
diff --git a/jme3-core/src/main/java/com/jme3/scene/Node.java b/jme3-core/src/main/java/com/jme3/scene/Node.java
index b5bd45b10..f22c5b4b0 100644
--- a/jme3-core/src/main/java/com/jme3/scene/Node.java
+++ b/jme3-core/src/main/java/com/jme3/scene/Node.java
@@ -76,9 +76,8 @@ public class Node extends Spatial implements Savable {
* Constructor instantiates a new Node 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);
diff --git a/jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java b/jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java
index 59bb66411..4158be132 100644
--- a/jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java
+++ b/jme3-core/src/main/java/com/jme3/scene/VertexBuffer.java
@@ -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,
/**
diff --git a/jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java b/jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java
index 7def0e252..dee565782 100644
--- a/jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java
+++ b/jme3-core/src/main/java/com/jme3/scene/control/AreaUtils.java
@@ -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.
diff --git a/jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java b/jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java
index 83b08402b..ef6a36fcc 100644
--- a/jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java
+++ b/jme3-core/src/main/java/com/jme3/scene/debug/SkeletonPoints.java
@@ -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);
diff --git a/jme3-core/src/main/java/com/jme3/scene/shape/Surface.java b/jme3-core/src/main/java/com/jme3/scene/shape/Surface.java
index 2773212eb..d3ad08ac8 100644
--- a/jme3-core/src/main/java/com/jme3/scene/shape/Surface.java
+++ b/jme3-core/src/main/java/com/jme3/scene/shape/Surface.java
@@ -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> controlPoints; //space control points and their weights
- private List[] 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> controlPoints, List[] 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> controlPoints, List[] 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 normalMap = new HashMap(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> 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 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 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> controlPoints, List[] 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> controlPoints; //space control points and their weights
+ private List[] 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> controlPoints, List[] 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> controlPoints, List[] 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 normalMap = new HashMap(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> 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 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 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> controlPoints, List[] 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!");
+ }
+ }
+ }
+ }
+}
diff --git a/jme3-core/src/main/java/com/jme3/scene/shape/Torus.java b/jme3-core/src/main/java/com/jme3/scene/shape/Torus.java
index 1be4146c6..21d77a541 100644
--- a/jme3-core/src/main/java/com/jme3/scene/shape/Torus.java
+++ b/jme3-core/src/main/java/com/jme3/scene/shape/Torus.java
@@ -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;