/** * Returns this geometry's mesh vertex count. * * @return this geometry's mesh vertex count. * * @see Mesh#getVertexCount() */ public int getVertexCount() { return mesh.getVertexCount(); }
/** * Called by the Renderer when a mesh has been drawn. */ public void onMeshDrawn(Mesh mesh, int lod, int count){ if( !enabled ) return; numObjects += 1; numTriangles += mesh.getTriangleCount(lod) * count; numVertices += mesh.getVertexCount() * count; }
protected float[] getPoints(Mesh mesh) { FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); vertices.rewind(); int components = mesh.getVertexCount() * 3; float[] pointsArray = new float[components]; for (int i = 0; i < components; i += 3) { pointsArray[i] = vertices.get(); pointsArray[i + 1] = vertices.get(); pointsArray[i + 2] = vertices.get(); } return pointsArray; } }
/** * Copy the vertex positions from a JME mesh. * * @param mesh the mesh to read (not null) * @return a new array (not null, length a multiple of 3) */ protected float[] getPoints(Mesh mesh) { FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); vertices.rewind(); int components = mesh.getVertexCount() * 3; float[] pointsArray = new float[components]; for (int i = 0; i < components; i += 3) { pointsArray[i] = vertices.get(); pointsArray[i + 1] = vertices.get(); pointsArray[i + 2] = vertices.get(); } return pointsArray; } }
private void pushBoneAssign(String vertIndex, String boneIndex, String weight) throws SAXException { int vert = parseInt(vertIndex); float w = parseFloat(weight); byte bone = (byte) parseInt(boneIndex); assert bone >= 0; assert vert >= 0 && vert < mesh.getVertexCount(); int i; float v = 0; // see which weights are unused for a given bone for (i = vert * 4; i < vert * 4 + 4; i++) { v = weightsFloatData.get(i); if (v == 0) { break; } } if (v != 0) { logger.log(Level.WARNING, "Vertex {0} has more than 4 weights per vertex! Ignoring..", vert); return; } weightsFloatData.put(i, w); indicesData.put(i, bone); actuallyHasWeights = true; }
public MikkTSpaceImpl(Mesh mesh) { this.mesh = mesh; //replacing any existing tangent buffer, if you came here you want them new. mesh.clearBuffer(VertexBuffer.Type.Tangent); FloatBuffer fb = BufferUtils.createFloatBuffer(mesh.getVertexCount() * 4); mesh.setBuffer(VertexBuffer.Type.Tangent, 4, fb); }
boneWeight.rewind(); int vertexComponents = mesh.getVertexCount() * 3; int k, start, index; float maxWeight = 0;
/** * Handles collision detection, internal use only. * User code should only use collideWith() on scene * graph elements such as {@link Spatial}s. */ public int collideWith(Collidable other, Matrix4f worldMatrix, BoundingVolume worldBound, CollisionResults results){ switch (mode) { case Points: case Lines: case LineStrip: case LineLoop: /* * Collisions can be detected only with triangles, * and there are no triangles in this mesh. */ return 0; } if (getVertexCount() == 0) { return 0; } if (collisionTree == null){ createCollisionData(); } return collisionTree.collideWith(other, worldMatrix, worldBound, results); }
public static synchronized IndexedMesh convert(Mesh mesh) { IndexedMesh jBulletIndexedMesh = new IndexedMesh(); jBulletIndexedMesh.triangleIndexBase = ByteBuffer.allocate(mesh.getTriangleCount() * 3 * 4); jBulletIndexedMesh.vertexBase = ByteBuffer.allocate(mesh.getVertexCount() * 3 * 4); IndexBuffer indices = mesh.getIndicesAsList(); FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); vertices.rewind(); int verticesLength = mesh.getVertexCount() * 3; jBulletIndexedMesh.numVertices = mesh.getVertexCount(); jBulletIndexedMesh.vertexStride = 12; //3 verts * 4 bytes per. for (int i = 0; i < verticesLength; i++) { float tempFloat = vertices.get(); jBulletIndexedMesh.vertexBase.putFloat(tempFloat); } int indicesLength = mesh.getTriangleCount() * 3; jBulletIndexedMesh.numTriangles = mesh.getTriangleCount(); jBulletIndexedMesh.triangleIndexStride = 12; //3 index entries * 4 bytes each. for (int i = 0; i < indicesLength; i++) { jBulletIndexedMesh.triangleIndexBase.putInt(indices.get(i)); } vertices.rewind(); vertices.clear(); return jBulletIndexedMesh; }
private void createCollisionMesh(Mesh mesh) { this.triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4); this.vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); this.numVertices = mesh.getVertexCount(); this.vertexStride = 12; // 3 verts * 4 bytes per. this.numTriangles = mesh.getTriangleCount(); this.triangleIndexStride = 12; // 3 index entries * 4 bytes each. IndexBuffer indices = mesh.getIndicesAsList(); FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); vertices.rewind(); int verticesLength = mesh.getVertexCount() * 3; for (int i = 0; i < verticesLength; i++) { float tempFloat = vertices.get(); vertexBase.putFloat(tempFloat); } int indicesLength = mesh.getTriangleCount() * 3; for (int i = 0; i < indicesLength; i++) { triangleIndexBase.putInt(indices.get(i)); } vertices.rewind(); vertices.clear(); this.createShape(null); }
private void createCollisionMesh(Mesh mesh) { triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4); vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); // triangleIndexBase = ByteBuffer.allocate(mesh.getTriangleCount() * 3 * 4); // vertexBase = ByteBuffer.allocate(mesh.getVertexCount() * 3 * 4); numVertices = mesh.getVertexCount(); vertexStride = 12; //3 verts * 4 bytes per. numTriangles = mesh.getTriangleCount(); triangleIndexStride = 12; //3 index entries * 4 bytes each. IndexBuffer indices = mesh.getIndicesAsList(); FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); vertices.rewind(); int verticesLength = mesh.getVertexCount() * 3; for (int i = 0; i < verticesLength; i++) { float tempFloat = vertices.get(); vertexBase.putFloat(tempFloat); } int indicesLength = mesh.getTriangleCount() * 3; for (int i = 0; i < indicesLength; i++) { triangleIndexBase.putInt(indices.get(i)); } vertices.rewind(); vertices.clear(); createShape(); }
private void setColor(Geometry g, ColorRGBA color) { float[] colors = new float[g.getMesh().getVertexCount() * 4]; for (int i = 0; i < g.getMesh().getVertexCount() * 4; i += 4) { colors[i] = color.r; colors[i + 1] = color.g; colors[i + 2] = color.b; colors[i + 3] = color.a; } VertexBuffer colorBuff = g.getMesh().getBuffer(VertexBuffer.Type.Color); if (colorBuff == null) { g.getMesh().setBuffer(VertexBuffer.Type.Color, 4, colors); } else { FloatBuffer cBuff = (FloatBuffer) colorBuff.getData(); cBuff.rewind(); cBuff.put(colors); colorBuff.updateData(cBuff); } }
ByteBuffer vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); int numVertices = mesh.getVertexCount(); int vertexStride = 12; //3 verts * 4 bytes each int numTriangles = mesh.getTriangleCount(); vertices.rewind(); int verticesLength = mesh.getVertexCount() * 3; for (int i = 0; i < verticesLength; i++) { float tempFloat = vertices.get();
public WrappedIndexBuffer(Mesh mesh){ super(mesh.getVertexCount(), mesh.getMode()); this.ib = mesh.getIndexBuffer(); switch (meshMode){ case Points: numIndices = mesh.getTriangleCount(); break; case Lines: case LineLoop: case LineStrip: numIndices = mesh.getTriangleCount() * 2; break; case Triangles: case TriangleStrip: case TriangleFan: numIndices = mesh.getTriangleCount() * 3; break; default: throw new UnsupportedOperationException(); } }
private static void applyAtlasCoords(List<Geometry> geometries, Mesh outMesh, TextureAtlas atlas) { int globalVertIndex = 0; for (Geometry geom : geometries) { Mesh inMesh = geom.getMesh(); geom.computeWorldMatrix(); int geomVertCount = inMesh.getVertexCount(); VertexBuffer inBuf = inMesh.getBuffer(Type.TexCoord); VertexBuffer outBuf = outMesh.getBuffer(Type.TexCoord); if (inBuf == null || outBuf == null) { continue; } atlas.applyCoords(geom, globalVertIndex, outMesh); globalVertIndex += geomVertCount; } }
public BIHTree(Mesh mesh, int maxTrisPerNode) { this.mesh = mesh; this.maxTrisPerNode = maxTrisPerNode; if (maxTrisPerNode < 1) { throw new IllegalArgumentException("maxTrisPerNode cannot be less than 1"); } if (mesh == null) { throw new IllegalArgumentException("Mesh cannot be null"); } bihSwapTmp = new float[9]; VertexBuffer vBuffer = mesh.getBuffer(Type.Position); if(vBuffer == null){ throw new IllegalArgumentException("A mesh should at least contain a Position buffer"); } IndexBuffer ib = mesh.getIndexBuffer(); FloatBuffer vb = (FloatBuffer) vBuffer.getData(); if (ib == null) { ib = new VirtualIndexBuffer(mesh.getVertexCount(), mesh.getMode()); } else if (mesh.getMode() != Mode.Triangles) { ib = new WrappedIndexBuffer(mesh); } numTris = ib.size() / 3; initTriList(vb, ib); }
private void initOpenCL2() { //bind vertex buffer to OpenCL VertexBuffer vb = geom.getMesh().getBuffer(VertexBuffer.Type.Position); buffer = clContext.bindVertexBuffer(vb, MemoryAccess.READ_WRITE).register(); ws = new com.jme3.opencl.Kernel.WorkSize(geom.getMesh().getVertexCount()); } private void updateOpenCL(float tpf) {
public void renderMesh(Mesh mesh, int lod, int count, VertexBuffer[] instanceData) { if (mesh.getVertexCount() == 0 || mesh.getTriangleCount() == 0 || count == 0) { return; } if (count > 1 && !caps.contains(Caps.MeshInstancing)) { throw new RendererException("Mesh instancing is not supported by the video hardware"); } if (mesh.getLineWidth() != 1f && context.lineWidth != mesh.getLineWidth()) { gl.glLineWidth(mesh.getLineWidth()); context.lineWidth = mesh.getLineWidth(); } if (gl4 != null && mesh.getMode().equals(Mode.Patch)) { gl4.glPatchParameter(mesh.getPatchVertexCount()); } statistics.onMeshDrawn(mesh, lod, count); // if (ctxCaps.GL_ARB_vertex_array_object){ // renderMeshVertexArray(mesh, lod, count); // }else{ renderMeshDefault(mesh, lod, count, instanceData); // } }
private void renderMeshVertexArray(Mesh mesh, int lod, int count, VertexBuffer instanceData) { if (mesh.getId() == -1) { updateVertexArray(mesh, instanceData); } else { // TODO: Check if it was updated } if (context.boundVertexArray != mesh.getId()) { gl3.glBindVertexArray(mesh.getId()); context.boundVertexArray = mesh.getId(); } // IntMap<VertexBuffer> buffers = mesh.getBuffers(); VertexBuffer indices; if (mesh.getNumLodLevels() > 0) { indices = mesh.getLodLevel(lod); } else { indices = mesh.getBuffer(Type.Index); } if (indices != null) { drawTriangleList(indices, mesh, count); } else { drawTriangleArray(mesh.getMode(), count, mesh.getVertexCount()); } clearVertexAttribs(); }
public static void convertToList(Mesh mesh){ IndexBuffer inBuf = mesh.getIndicesAsList(); IndexBuffer outBuf = IndexBuffer.createIndexBuffer(mesh.getVertexCount(), inBuf.size()); for (int i = 0; i < inBuf.size(); i++){ outBuf.put(i, inBuf.get(i)); } mesh.clearBuffer(Type.Index); switch (mesh.getMode()){ case LineLoop: case LineStrip: mesh.setMode(Mode.Lines); break; case TriangleStrip: case TriangleFan: mesh.setMode(Mode.Triangles); break; default: break; } if (outBuf instanceof IndexIntBuffer){ mesh.setBuffer(Type.Index, 3, (IntBuffer)outBuf.getBuffer()); }else{ mesh.setBuffer(Type.Index, 3, (ShortBuffer)outBuf.getBuffer()); } }