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

* @SuppressWarnings("fallthrough") to prevent warnings

Browse Source 
* Fixed rest of the warnings

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@7241 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
3.0
sha..rd 14 years ago
parent 7dd3d52e9e
commit d729da9e78
7 changed files with 273 additions and 255 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. 7
      engine/src/core-plugins/com/jme3/export/binary/BinaryOutputCapsule.java
  2. 10
      engine/src/core/com/jme3/math/Matrix3f.java
  3. 2
      engine/src/core/com/jme3/math/Matrix4f.java
  4. 447
      engine/src/core/com/jme3/scene/shape/Surface.java
  5. 8
      engine/src/core/com/jme3/scene/shape/Torus.java
  6. 3
      engine/src/desktop-fx/com/jme3/shadow/PssmShadowRenderer.java
  7. 5
      engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglRenderer.java

7
engine/src/core-plugins/com/jme3/export/binary/BinaryOutputCapsule.java
Unescape View File

@ -416,6 +416,13 @@ final class BinaryOutputCapsule implements OutputCapsule {
return Arrays.equals(bytes, other); return Arrays.equals(bytes, other);
} }
@Override
public int hashCode() {
int hash = 7;
hash = 23 * hash + Arrays.hashCode(this.bytes);
return hash;
}
public void finish() { public void finish() {
// renamed to finish as 'finalize' in java.lang.Object should not be // renamed to finish as 'finalize' in java.lang.Object should not be
// overridden like this // overridden like this

10
engine/src/core/com/jme3/math/Matrix3f.java
Unescape View File

@ -170,6 +170,7 @@ public final class Matrix3f implements Savable, Cloneable {
* the colum index. * the colum index.
* @return the value at (i, j). * @return the value at (i, j).
*/ */
@SuppressWarnings("fallthrough")
public float get(int i, int j) { public float get(int i, int j) {
switch (i) { switch (i) {
case 0: case 0:
@ -489,6 +490,7 @@ public final class Matrix3f implements Savable, Cloneable {
* the value for (i, j). * the value for (i, j).
* @return this * @return this
*/ */
@SuppressWarnings("fallthrough")
public Matrix3f set(int i, int j, float value) { public Matrix3f set(int i, int j, float value) {
switch (i) { switch (i) {
case 0: case 0:
@ -846,7 +848,6 @@ public final class Matrix3f implements Savable, Cloneable {
* @return This matrix, after the multiplication * @return This matrix, after the multiplication
*/ */
public Matrix3f multLocal(Matrix3f mat) { public Matrix3f multLocal(Matrix3f mat) {
return mult(mat, this); return mult(mat, this);
} }
@ -1050,8 +1051,9 @@ public final class Matrix3f implements Savable, Cloneable {
* *
* @return the string representation of this object. * @return the string representation of this object.
*/ */
@Override
public String toString() { public String toString() {
StringBuffer result = new StringBuffer("Matrix3f\n[\n"); StringBuilder result = new StringBuilder("Matrix3f\n[\n");
result.append(" "); result.append(" ");
result.append(m00); result.append(m00);
result.append(" "); result.append(" ");
@ -1085,6 +1087,7 @@ public final class Matrix3f implements Savable, Cloneable {
* @return the hashcode for this instance of Matrix4f. * @return the hashcode for this instance of Matrix4f.
* @see java.lang.Object#hashCode() * @see java.lang.Object#hashCode()
*/ */
@Override
public int hashCode() { public int hashCode() {
int hash = 37; int hash = 37;
hash = 37 * hash + Float.floatToIntBits(m00); hash = 37 * hash + Float.floatToIntBits(m00);
@ -1109,6 +1112,7 @@ public final class Matrix3f implements Savable, Cloneable {
* the object to compare for equality * the object to compare for equality
* @return true if they are equal * @return true if they are equal
*/ */
@Override
public boolean equals(Object o) { public boolean equals(Object o) {
if (!(o instanceof Matrix3f) || o == null) { if (!(o instanceof Matrix3f) || o == null) {
return false; return false;
@ -1270,7 +1274,7 @@ public final class Matrix3f implements Savable, Cloneable {
m22 *= scale.z; m22 *= scale.z;
} }
static final boolean equalIdentity(Matrix3f mat) { static boolean equalIdentity(Matrix3f mat) {
if (Math.abs(mat.m00 - 1) > 1e-4) return false; if (Math.abs(mat.m00 - 1) > 1e-4) return false;
if (Math.abs(mat.m11 - 1) > 1e-4) return false; if (Math.abs(mat.m11 - 1) > 1e-4) return false;
if (Math.abs(mat.m22 - 1) > 1e-4) return false; if (Math.abs(mat.m22 - 1) > 1e-4) return false;

2
engine/src/core/com/jme3/math/Matrix4f.java
Unescape View File

@ -280,6 +280,7 @@ public final class Matrix4f implements Savable, Cloneable {
* the colum index. * the colum index.
* @return the value at (i, j). * @return the value at (i, j).
*/ */
@SuppressWarnings("fallthrough")
public float get(int i, int j) { public float get(int i, int j) {
switch (i) { switch (i) {
case 0: case 0:
@ -450,6 +451,7 @@ public final class Matrix4f implements Savable, Cloneable {
* @param value * @param value
* the value for (i, j). * the value for (i, j).
*/ */
@SuppressWarnings("fallthrough")
public void set(int i, int j, float value) { public void set(int i, int j, float value) {
switch (i) { switch (i) {
case 0: case 0:

447
engine/src/core/com/jme3/scene/shape/Surface.java
Unescape View File

@ -20,264 +20,265 @@ import com.jme3.util.BufferUtils;
* @author Marcin Roguski (Kealthas) * @author Marcin Roguski (Kealthas)
*/ */
public class Surface extends Mesh { 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
/** private SplineType type; //the type of the surface
* Constructor. Constructs required surface. private List<List<Vector4f>> controlPoints; //space control points and their weights
* @param controlPoints space control points private List<Float>[] knots; //knots of the surface
* @param nurbKnots knots of the surface private int basisUFunctionDegree; //the degree of basis U function
* @param uSegments the amount of U segments private int basisVFunctionDegree; //the degree of basis V function
* @param vSegments the amount of V segments private int uSegments; //the amount of U segments
* @param basisUFunctionDegree the degree of basis U function private int vSegments; //the amount of V segments
* @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(); /**
} * 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. * This method creates a NURBS surface.
*/ * @param controlPoints space control points
private void buildSurface() { * @param nurbKnots knots of the surface
boolean smooth = true;//TODO: take smoothing into consideration * @param uSegments the amount of U segments
float minUKnot = this.getMinUNurbKnot(); * @param vSegments the amount of V segments
float maxUKnot = this.getMaxUNurbKnot(); * @param basisUFunctionDegree the degree of basis U function
float deltaU = (maxUKnot - minUKnot)/uSegments; * @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;
}
float minVKnot = this.getMinVNurbKnot(); /**
float maxVKnot = this.getMaxVNurbKnot(); * This method creates the surface.
float deltaV = (maxVKnot - minVKnot)/vSegments; */
private void buildSurface() {
boolean smooth = true;//TODO: take smoothing into consideration
float minUKnot = this.getMinUNurbKnot();
float maxUKnot = this.getMaxUNurbKnot();
float deltaU = (maxUKnot - minUKnot) / uSegments;
Vector3f[] vertices = new Vector3f[(uSegments + 1) * (vSegments + 1)]; float minVKnot = this.getMinVNurbKnot();
float maxVKnot = this.getMaxVNurbKnot();
float deltaV = (maxVKnot - minVKnot) / vSegments;
float u = minUKnot, v = minVKnot; Vector3f[] vertices = new Vector3f[(uSegments + 1) * (vSegments + 1)];
int arrayIndex = 0;
for(int i=0;i<=vSegments; ++i) { float u = minUKnot, v = minVKnot;
for(int j=0;j<=uSegments; ++j) { int arrayIndex = 0;
Vector3f interpolationResult = new Vector3f();
CurveAndSurfaceMath.interpolate(u, v, controlPoints, knots, basisUFunctionDegree, basisVFunctionDegree, interpolationResult);
vertices[arrayIndex++] = interpolationResult;
u += deltaU;
}
u = minUKnot;
v += deltaV;
}
//adding indexes for (int i = 0; i <= vSegments; ++i) {
int uVerticesAmount = uSegments + 1; for (int j = 0; j <= uSegments; ++j) {
int[] indices = new int[uSegments * vSegments * 6]; Vector3f interpolationResult = new Vector3f();
arrayIndex = 0; CurveAndSurfaceMath.interpolate(u, v, controlPoints, knots, basisUFunctionDegree, basisVFunctionDegree, interpolationResult);
for(int i=0;i<vSegments; ++i) { vertices[arrayIndex++] = interpolationResult;
for(int j=0;j<uSegments; ++j) { u += deltaU;
indices[arrayIndex++] = j + i*uVerticesAmount; }
indices[arrayIndex++] = j + i*uVerticesAmount + 1; u = minUKnot;
indices[arrayIndex++] = j + i*uVerticesAmount + uVerticesAmount; v += deltaV;
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 //adding indexes
Map<Vector3f, Vector3f> normalMap = new HashMap<Vector3f, Vector3f>(vertices.length); int uVerticesAmount = uSegments + 1;
for(int i=0;i<indices.length;i+=3) { int[] indices = new int[uSegments * vSegments * 6];
Vector3f n = FastMath.computeNormal(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]); arrayIndex = 0;
this.addNormal(n, normalMap, smooth, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]); for (int i = 0; i < vSegments; ++i) {
} for (int j = 0; j < uSegments; ++j) {
//preparing normal list (the order of normals must match the order of vertices) indices[arrayIndex++] = j + i * uVerticesAmount;
float[] normals = new float[vertices.length * 3]; indices[arrayIndex++] = j + i * uVerticesAmount + 1;
arrayIndex = 0; indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
for(int i=0;i<vertices.length;++i) { indices[arrayIndex++] = j + i * uVerticesAmount + 1;
Vector3f n = normalMap.get(vertices[i]); indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount + 1;
normals[arrayIndex++] = n.x; indices[arrayIndex++] = j + i * uVerticesAmount + uVerticesAmount;
normals[arrayIndex++] = n.y; }
normals[arrayIndex++] = n.z; }
}
this.setBuffer(VertexBuffer.Type.Position, 3, BufferUtils.createFloatBuffer(vertices)); //normalMap merges normals of faces that will be rendered smooth
this.setBuffer(VertexBuffer.Type.Index, 3, indices); Map<Vector3f, Vector3f> normalMap = new HashMap<Vector3f, Vector3f>(vertices.length);
this.setBuffer(VertexBuffer.Type.Normal, 3, normals); for (int i = 0; i < indices.length; i += 3) {
this.updateBound(); Vector3f n = FastMath.computeNormal(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]);
this.updateCounts(); 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;
}
public List<List<Vector4f>> getControlPoints() { this.setBuffer(VertexBuffer.Type.Position, 3, BufferUtils.createFloatBuffer(vertices));
return controlPoints; this.setBuffer(VertexBuffer.Type.Index, 3, indices);
} this.setBuffer(VertexBuffer.Type.Normal, 3, normals);
this.updateBound();
this.updateCounts();
}
/** public List<List<Vector4f>> getControlPoints() {
* This method returns the amount of U control points. return controlPoints;
* @return the amount of U control points }
*/
public int getUControlPointsAmount() {
return controlPoints.size();
}
/** /**
* This method returns the amount of V control points. * This method returns the amount of U control points.
* @return the amount of V control points * @return the amount of U control points
*/ */
public int getVControlPointsAmount() { public int getUControlPointsAmount() {
return controlPoints.get(0)==null ? 0 : controlPoints.get(0).size(); return controlPoints.size();
} }
/** /**
* This method returns the degree of basis U function. * This method returns the amount of V control points.
* @return the degree of basis U function * @return the amount of V control points
*/ */
public int getBasisUFunctionDegree() { public int getVControlPointsAmount() {
return basisUFunctionDegree; return controlPoints.get(0) == null ? 0 : controlPoints.get(0).size();
} }
/** /**
* This method returns the degree of basis V function. * This method returns the degree of basis U function.
* @return the degree of basis V function * @return the degree of basis U function
*/ */
public int getBasisVFunctionDegree() { public int getBasisUFunctionDegree() {
return basisVFunctionDegree; return basisUFunctionDegree;
} }
/** /**
* This method returns the knots for specified dimension (U knots - value: '0', * This method returns the degree of basis V function.
* V knots - value: '1'). * @return the degree of basis V function
* @param dim an integer specifying if the U or V knots are required */
* @return an array of knots public int getBasisVFunctionDegree() {
*/ return basisVFunctionDegree;
public List<Float> getKnots(int dim) { }
return knots[dim];
}
/** /**
* This method returns the type of the surface. * This method returns the knots for specified dimension (U knots - value: '0',
* @return the type of the surface * V knots - value: '1').
*/ * @param dim an integer specifying if the U or V knots are required
public SplineType getType() { * @return an array of knots
return type; */
} public List<Float> getKnots(int dim) {
return knots[dim];
}
/** /**
* This method returns the minimum nurb curve U knot value. * This method returns the type of the surface.
* @return the minimum nurb curve knot value * @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() { private float getMinUNurbKnot() {
return knots[0].get(basisUFunctionDegree - 1); return knots[0].get(basisUFunctionDegree - 1);
} }
/** /**
* This method returns the maximum nurb curve U knot value. * This method returns the maximum nurb curve U knot value.
* @return the maximum nurb curve knot value * @return the maximum nurb curve knot value
*/ */
private float getMaxUNurbKnot() { private float getMaxUNurbKnot() {
return knots[0].get(knots[0].size() - basisUFunctionDegree); return knots[0].get(knots[0].size() - basisUFunctionDegree);
} }
/** /**
* This method returns the minimum nurb curve U knot value. * This method returns the minimum nurb curve U knot value.
* @return the minimum nurb curve knot value * @return the minimum nurb curve knot value
*/ */
private float getMinVNurbKnot() { private float getMinVNurbKnot() {
return knots[1].get(basisVFunctionDegree - 1); return knots[1].get(basisVFunctionDegree - 1);
} }
/** /**
* This method returns the maximum nurb curve U knot value. * This method returns the maximum nurb curve U knot value.
* @return the maximum nurb curve knot value * @return the maximum nurb curve knot value
*/ */
private float getMaxVNurbKnot() { private float getMaxVNurbKnot() {
return knots[1].get(knots[1].size() - basisVFunctionDegree); 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. * 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 * @param normalToAdd
* a normal to be added * a normal to be added
* @param normalMap * @param normalMap
* merges normals of faces that will be rendered smooth; the key is the vertex and the value - its normal vector * merges normals of faces that will be rendered smooth; the key is the vertex and the value - its normal vector
* @param smooth * @param smooth
* the variable that indicates wheather to merge normals (creating the smooth mesh) or not * the variable that indicates wheather to merge normals (creating the smooth mesh) or not
* @param vertices * @param vertices
* a list of vertices read from the blender file * a list of vertices read from the blender file
*/ */
private void addNormal(Vector3f normalToAdd, Map<Vector3f, Vector3f> normalMap, boolean smooth, Vector3f... vertices) { private void addNormal(Vector3f normalToAdd, Map<Vector3f, Vector3f> normalMap, boolean smooth, Vector3f... vertices) {
for(Vector3f v : vertices) { for (Vector3f v : vertices) {
Vector3f n = normalMap.get(v); Vector3f n = normalMap.get(v);
if(!smooth || n == null) { if (!smooth || n == null) {
normalMap.put(v, normalToAdd.clone()); normalMap.put(v, normalToAdd.clone());
} else { } else {
n.addLocal(normalToAdd).normalizeLocal(); n.addLocal(normalToAdd).normalizeLocal();
} }
} }
} }
/** /**
* This method validates the input data. It throws {@link IllegalArgumentException} if * This method validates the input data. It throws {@link IllegalArgumentException} if
* the data is invalid. * the data is invalid.
* @param controlPoints space control points * @param controlPoints space control points
* @param nurbKnots knots of the surface * @param nurbKnots knots of the surface
* @param uSegments the amount of U segments * @param uSegments the amount of U segments
* @param vSegments the amount of V segments * @param vSegments the amount of V segments
*/ */
private void validateInputData(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots, private void validateInputData(List<List<Vector4f>> controlPoints, List<Float>[] nurbKnots,
int uSegments, int vSegments) { int uSegments, int vSegments) {
int uPointsAmount = controlPoints.get(0).size(); int uPointsAmount = controlPoints.get(0).size();
for(int i=1;i<controlPoints.size();++i) { for (int i = 1; i < controlPoints.size(); ++i) {
if(controlPoints.get(i).size()!=uPointsAmount) { if (controlPoints.get(i).size() != uPointsAmount) {
throw new IllegalArgumentException("The amount of 'U' control points is invalid!"); throw new IllegalArgumentException("The amount of 'U' control points is invalid!");
} }
} }
if(uSegments<=0) { if (uSegments <= 0) {
throw new IllegalArgumentException("U segments amount should be positive!"); throw new IllegalArgumentException("U segments amount should be positive!");
} }
if(vSegments<0) { if (vSegments < 0) {
throw new IllegalArgumentException("V segments amount cannot be negative!"); throw new IllegalArgumentException("V segments amount cannot be negative!");
} }
if (nurbKnots.length != 2) { if (nurbKnots.length != 2) {
throw new IllegalArgumentException("Nurb surface should have two rows of knots!"); throw new IllegalArgumentException("Nurb surface should have two rows of knots!");
} }
for (int i = 0; i < nurbKnots.length; ++i) { for (int i = 0; i < nurbKnots.length; ++i) {
for (int j = 0; j < nurbKnots[i].size() - 1; ++j) { for (int j = 0; j < nurbKnots[i].size() - 1; ++j) {
if (nurbKnots[i].get(j) > nurbKnots[i].get(j+1)) { if (nurbKnots[i].get(j) > nurbKnots[i].get(j + 1)) {
throw new IllegalArgumentException("The knots' values cannot decrease!"); throw new IllegalArgumentException("The knots' values cannot decrease!");
} }
} }
} }
} }
} }

8
engine/src/core/com/jme3/scene/shape/Torus.java
Unescape View File

@ -153,12 +153,8 @@ public class Torus extends Mesh {
float sinPhi = FastMath.sin(phi); float sinPhi = FastMath.sin(phi);
tempNormal.set(radialAxis).multLocal(cosPhi); tempNormal.set(radialAxis).multLocal(cosPhi);
tempNormal.z += sinPhi; tempNormal.z += sinPhi;
if (true) fnb.put(tempNormal.x).put(tempNormal.y).put(
fnb.put(tempNormal.x).put(tempNormal.y).put( tempNormal.z);
tempNormal.z);
else
fnb.put(-tempNormal.x).put(-tempNormal.y)
.put(-tempNormal.z);
tempNormal.multLocal(innerRadius).addLocal(torusMiddle); tempNormal.multLocal(innerRadius).addLocal(torusMiddle);
fpb.put(tempNormal.x).put(tempNormal.y).put( fpb.put(tempNormal.x).put(tempNormal.y).put(

3
engine/src/desktop-fx/com/jme3/shadow/PssmShadowRenderer.java
Unescape View File

@ -286,6 +286,7 @@ public class PssmShadowRenderer implements SceneProcessor {
this.direction.set(direction).normalizeLocal(); this.direction.set(direction).normalizeLocal();
} }
@SuppressWarnings("fallthrough")
public void postQueue(RenderQueue rq) { public void postQueue(RenderQueue rq) {
GeometryList occluders = rq.getShadowQueueContent(ShadowMode.Cast); GeometryList occluders = rq.getShadowQueueContent(ShadowMode.Cast);
if (occluders.size() == 0) if (occluders.size() == 0)
@ -317,6 +318,8 @@ public class PssmShadowRenderer implements SceneProcessor {
shadowCam.updateViewProjection(); shadowCam.updateViewProjection();
PssmShadowUtil.updateFrustumSplits(splitsArray, viewCam.getFrustumNear(), zFar, lambda); PssmShadowUtil.updateFrustumSplits(splitsArray, viewCam.getFrustumNear(), zFar, lambda);
switch (splitsArray.length){ switch (splitsArray.length){
case 5: case 5:
splits.a = splitsArray[4]; splits.a = splitsArray[4];

5
engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglRenderer.java
Unescape View File

@ -82,6 +82,7 @@ import java.util.logging.Logger;
//import org.lwjgl.opengl.ARBVertexArrayObject; //import org.lwjgl.opengl.ARBVertexArrayObject;
//import org.lwjgl.opengl.ARBHalfFloatVertex; //import org.lwjgl.opengl.ARBHalfFloatVertex;
//import org.lwjgl.opengl.ARBVertexArrayObject; //import org.lwjgl.opengl.ARBVertexArrayObject;
//import jme3tools.converters.MipMapGenerator;
import org.lwjgl.opengl.ARBDrawBuffers; import org.lwjgl.opengl.ARBDrawBuffers;
//import org.lwjgl.opengl.ARBDrawInstanced; //import org.lwjgl.opengl.ARBDrawInstanced;
import org.lwjgl.opengl.ARBDrawInstanced; import org.lwjgl.opengl.ARBDrawInstanced;
@ -168,6 +169,7 @@ public class LwjglRenderer implements Renderer {
return caps; return caps;
} }
@SuppressWarnings("fallthrough")
public void initialize() { public void initialize() {
ContextCapabilities ctxCaps = GLContext.getCapabilities(); ContextCapabilities ctxCaps = GLContext.getCapabilities();
if (ctxCaps.OpenGL20) { if (ctxCaps.OpenGL20) {
@ -1514,6 +1516,7 @@ public class LwjglRenderer implements Renderer {
} }
} }
@SuppressWarnings("fallthrough")
private void setupTextureParams(Texture tex) { private void setupTextureParams(Texture tex) {
Image image = tex.getImage(); Image image = tex.getImage();
int target = convertTextureType(tex.getType(), image != null ? image.getMultiSamples() : 1); int target = convertTextureType(tex.getType(), image != null ? image.getMultiSamples() : 1);
@ -1618,6 +1621,8 @@ public class LwjglRenderer implements Renderer {
|| img.getWidth() != img.getHeight()){ || img.getWidth() != img.getHeight()){
logger.log(Level.WARNING, "Encountered NPOT texture {0}, " logger.log(Level.WARNING, "Encountered NPOT texture {0}, "
+ "it might not display correctly.", img); + "it might not display correctly.", img);
//MipMapGenerator.resizeToPowerOf2(img);
} }
} }
} }

Write Preview
Loading…
Cancel
Save