private void allocateVertices() { final int verts = (2 * (_axisSamples + 1) * (_radialSamples + 1) + _radialSamples * 4); _meshData.setVertexBuffer(BufferUtils.createVector3Buffer(_meshData.getVertexBuffer(), verts)); _meshData.setNormalBuffer(BufferUtils.createVector3Buffer(_meshData.getNormalBuffer(), verts)); _meshData.setTextureBuffer(BufferUtils.createVector2Buffer(_meshData.getTextureBuffer(0), verts), 0); final int tris = (4 * _radialSamples * (1 + _axisSamples)); if (_meshData.getIndices() == null || _meshData.getIndices().getBufferLimit() != 3 * tris) { _meshData.setIndices(BufferUtils.createIndexBufferData(3 * tris, verts - 1)); } setGeometryData(); setIndexData(); }
/** * Construct a new TextCaret */ public TextCaret() { final MeshData md = _strip.getMeshData(); md.setVertexBuffer(BufferUtils.createVector3Buffer(4)); md.setIndices(BufferUtils.createIndexBufferData(new int[] { 0, 1, 3, 2 }, 3)); md.setIndexMode(IndexMode.TriangleStrip); final float[] vals = new float[] { 0, 0, 0, // 1, 0, 0, // 1, 1, 0, // 0, 1, 0 // }; md.getVertexBuffer().put(vals); _strip.updateGeometricState(0); setCaretColor(ColorRGBA.BLACK); }
/** * */ public void updateGeometry() { final int numPairs = _tessSteps + 1; final int totalVerts = _tessRings * numPairs * 2; final MeshData meshData = getMeshData(); FloatBuffer crdBuf = meshData.getVertexBuffer(); if (crdBuf == null || totalVerts != crdBuf.limit() / 3) { // allocate new buffers meshData.setVertexBuffer(BufferUtils.createVector3Buffer(totalVerts)); meshData.setNormalBuffer(BufferUtils.createVector3Buffer(totalVerts)); meshData.setTextureBuffer(BufferUtils.createVector2Buffer(totalVerts), 0); crdBuf = meshData.getVertexBuffer(); meshData.getVertexCoords().setVboAccessMode(VBOAccessMode.DynamicDraw); meshData.getNormalCoords().setVboAccessMode(VBOAccessMode.DynamicDraw); meshData.getTextureCoords(0).setVboAccessMode(VBOAccessMode.DynamicDraw); } final FloatBuffer nrmBuf = meshData.getNormalBuffer(); final FloatBuffer txcBuf = meshData.getTextureBuffer(0); calculateVertexData(_tessRings, numPairs, totalVerts, crdBuf, nrmBuf, txcBuf); // mark our data as needing updates meshData.markBufferDirty(MeshData.KEY_VertexCoords); meshData.markBufferDirty(MeshData.KEY_NormalCoords); meshData.markBufferDirty(MeshData.KEY_TextureCoords0); updateModelBound(); }
/** * Initialize the meshdata object with data. * * @param vertices * @param normals * @param colors * @param coords */ private void setupData(final FloatBuffer vertices, final FloatBuffer normals, final FloatBuffer colors, final FloatBufferData coords) { _meshData.setVertexBuffer(vertices); _meshData.setNormalBuffer(normals); _meshData.setColorBuffer(colors); _meshData.setTextureCoords(coords, 0); }
/** * Let this mesh know we want to change its indices to the provided new order. Override this to provide extra * functionality for sub types as needed. * * @param newIndices * the IntBufferData to switch to. * @param modes * the new segment modes to use. * @param lengths * the new lengths to use. */ public void reorderIndices(final IndexBufferData<?> newIndices, final IndexMode[] modes, final int[] lengths) { _meshData.setIndices(newIndices); _meshData.setIndexModes(modes); _meshData.setIndexLengths(lengths); }
/** * Sets the vertex buffer. * * @param vertexBuffer * the new vertex buffer */ public void setVertexBuffer(final FloatBuffer vertexBuffer) { if (vertexBuffer == null) { setVertexCoords(null); } else { setVertexCoords(new FloatBufferData(vertexBuffer, 3)); } refreshInterleaved(); }
final FloatBufferData verts = meshData.getVertexCoords().makeCopy(); final FloatBufferData norms = meshData.getNormalBuffer() != null ? meshData.getVertexCoords().makeCopy() : null; final FloatBufferData colors = meshData.getColorBuffer() != null ? meshData.getColorCoords().makeCopy() : null; final FloatBufferData tangents = meshData.getTangentBuffer() != null ? meshData.getTangentCoords().makeCopy() : null; final FloatBufferData[] uvs = new FloatBufferData[meshData.getMaxTextureUnitUsed() + 1]; for (int k = 0; k < uvs.length; k++) { final FloatBufferData tex = meshData.getTextureCoords(k); if (tex != null) { uvs[k] = tex.makeCopy(); for (int i = 0; i < meshData.getVertexCount(); i++) { vert = newVertexOrder[i]; if (vert == -1) { vert = i; BufferUtils.copy(meshData.getVertexBuffer(), i * verts.getValuesPerTuple(), verts.getBuffer(), vert * verts.getValuesPerTuple(), verts.getValuesPerTuple()); if (norms != null) { BufferUtils.copy(meshData.getNormalBuffer(), i * norms.getValuesPerTuple(), norms.getBuffer(), vert * norms.getValuesPerTuple(), norms.getValuesPerTuple()); BufferUtils.copy(meshData.getColorBuffer(), i * colors.getValuesPerTuple(), colors.getBuffer(), vert * colors.getValuesPerTuple(), colors.getValuesPerTuple()); BufferUtils.copy(meshData.getTangentBuffer(), i * tangents.getValuesPerTuple(), tangents.getBuffer(), vert * tangents.getValuesPerTuple(), tangents.getValuesPerTuple());
md.getVertexBuffer().rewind(); vertices.getBuffer().put(mesh.getWorldVectors(null)); final FloatBuffer nb = md.getNormalBuffer(); if (nb != null) { nb.rewind(); normals.getBuffer().put(mesh.getWorldNormals(null)); } else { for (int i = 0; i < md.getVertexCount(); i++) { normals.getBuffer().put(DEFAULT_NORMAL); final FloatBuffer cb = md.getColorBuffer(); if (cb != null) { cb.rewind(); colors.getBuffer().put(cb); } else { for (int i = 0; i < md.getVertexCount(); i++) { colors.getBuffer().put(DEFAULT_COLOR); for (int i = 0; i < maxTextures; i++) { final FloatBuffer dest = texCoordsList.get(i).getBuffer(); final FloatBuffer tb = md.getTextureBuffer(i); if (tb != null) { tb.rewind(); dest.put(tb); } else { for (int j = 0; j < md.getVertexCount() * texCoords; j++) { dest.put(DEFAULT_TEXCOORD);
lineFrustum.getMeshData().setIndexModes( new IndexMode[] { IndexMode.LineLoop, IndexMode.LineLoop, IndexMode.Lines, IndexMode.Lines }); lineFrustum.getMeshData().setIndexLengths(new int[] { 4, 4, 8, 8 }); lineFrustum.getSceneHints().setLightCombineMode(LightCombineMode.Off); extendedCamera.calculateFrustum(fNear, fFar); final FloatBuffer colors = lineFrustum.getMeshData().getColorBuffer(); for (int i = 0; i < 16; i++) { BufferUtils.setInBuffer(color, colors, i); final FloatBuffer verts = lineFrustum.getMeshData().getVertexBuffer(); BufferUtils.setInBuffer(corners[0], verts, 0); BufferUtils.setInBuffer(corners[1], verts, 1);
protected void renderVBO(final Renderer renderer, final MeshData meshData, final int primcount) { if (getSceneHints().getDataMode() == DataMode.VBOInterleaved) { if (meshData.getColorCoords() == null) { renderer.applyDefaultColor(_defaultColor); if (meshData.getInterleavedData() == null) { final FloatBufferData interleaved = new FloatBufferData(FloatBuffer.allocate(0), 1); meshData.setInterleavedData(interleaved); renderer.setupInterleavedDataVBO(meshData.getInterleavedData(), meshData.getVertexCoords(), meshData.getNormalCoords(), meshData.getColorCoords(), meshData.getTextureCoords()); } else { if (RENDER_VERTEX_ONLY) { renderer.applyNormalsMode(getSceneHints().getNormalsMode(), _worldTransform); if (getSceneHints().getNormalsMode() != NormalsMode.Off) { renderer.setupNormalDataVBO(meshData.getNormalCoords()); } else { renderer.setupNormalDataVBO(null); if (meshData.getColorCoords() != null) { renderer.setupColorDataVBO(meshData.getColorCoords()); } else { renderer.applyDefaultColor(_defaultColor); renderer.setupTextureDataVBO(meshData.getTextureCoords()); renderer.setupVertexDataVBO(meshData.getVertexCoords()); if (meshData.getIndices() != null) {
vertCoords = md.getVertexCoords().getValuesPerTuple(); volumeType = mesh.getModelBound(null); states = mesh.getLocalRenderStates(); first = false; } else if (vertCoords != md.getVertexCoords().getValuesPerTuple()) { throw new IllegalArgumentException("all MeshData vertex coords must use same tuple size."); totalVertices += md.getVertexCount(); if (useIndices || md.getIndices() != null) { useIndices = true; if (md.getIndices() != null) { totalIndices += md.getIndices().capacity(); } else { totalIndices += md.getVertexCount(); mode = md.getIndexMode(0); if (!useNormals && md.getNormalBuffer() != null) { useNormals = true; if (!useColors && md.getColorBuffer() != null) { useColors = true; if (md.getNumberOfUnits() > 0) { if (!useTextures) { useTextures = true; texCoords = md.getTextureCoords(0).getValuesPerTuple(); } else if (md.getTextureCoords(0) != null && texCoords != md.getTextureCoords(0).getValuesPerTuple()) {
vertCoords = md.getVertexCoords().getValuesPerTuple(); volumeType = mesh.getModelBound(null); states = mesh.getLocalRenderStates(); first = false; } else if (vertCoords != md.getVertexCoords().getValuesPerTuple()) { throw new IllegalArgumentException("all MeshData vertex coords must use same tuple size."); totalVertices += md.getVertexCount(); if (useIndices || md.getIndices() != null) { useIndices = true; if (md.getIndices() != null) { totalIndices += md.getIndices().capacity(); } else { totalIndices += md.getVertexCount(); mode = md.getIndexMode(0); if (!useNormals && md.getNormalBuffer() != null) { useNormals = true; if (!useColors && md.getColorBuffer() != null) { useColors = true; if (md.getMaxTextureUnitUsed() >= 0) { if (!useTextures) { useTextures = true; texCoords = md.getTextureCoords(0).getValuesPerTuple(); } else if (md.getTextureCoords(0) != null && texCoords != md.getTextureCoords(0).getValuesPerTuple()) {
/** * Check whether buffers have sufficient capacity to hold current string values; if not, increase capacity and set * the limit. * * @param text */ protected void checkBuffers(final String text) { final int chunkSize = 30; final int vertices = 6 * text.length(); final int chunks = 1 + (vertices / chunkSize); final int required = chunks * chunkSize; FloatBuffer vertexBuffer = getMeshData().getVertexBuffer(); FloatBuffer texCrdBuffer = getMeshData().getTextureBuffer(0); if (vertexBuffer == null || vertexBuffer.capacity() < required * 3) { vertexBuffer = BufferUtils.createVector3Buffer(required); texCrdBuffer = BufferUtils.createVector2Buffer(required); getMeshData().setVertexBuffer(vertexBuffer); getMeshData().setTextureBuffer(texCrdBuffer, 0); getMeshData().getVertexCoords().setVboAccessMode(VBOAccessMode.DynamicDraw); getMeshData().getTextureCoords(0).setVboAccessMode(VBOAccessMode.DynamicDraw); } vertexBuffer.limit(vertices * 3).rewind(); texCrdBuffer.limit(vertices * 2).rewind(); }
private static Mesh createMesh() { // create a triangle strip of 8 triangles. final Mesh mesh = new Mesh(); mesh.setRenderMaterial("ui/untextured/vertex_color_flat.yaml"); mesh.getMeshData().setVertexCoords(new FloatBufferData(BufferUtils.createVector2Buffer(8), 2)); mesh.getMeshData().setColorBuffer(BufferUtils.createColorBuffer(8)); mesh.getMeshData().setIndexMode(IndexMode.TriangleStrip); final IndexBufferData<?> indices = BufferUtils.createIndexBufferData(10, 7); indices.put(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1 }); mesh.getMeshData().setIndices(indices); // set up alpha blending. final BlendState blend = new BlendState(); blend.setBlendEnabled(true); blend.setSourceFunction(SourceFunction.SourceAlpha); blend.setDestinationFunction(DestinationFunction.OneMinusSourceAlpha); mesh.setRenderState(blend); mesh.updateWorldRenderStates(false); return mesh; } }
final IndexBufferData<?> finalIndices = BufferUtils.createIndexBufferData(max, data.getVertexCount() - 1); data.setIndices(finalIndices); final int[] sectionCounts = new int[sections.size()]; for (int i = 0; i < sectionCounts.length; i++) { data.setIndexLengths(sectionCounts); data.setIndexModes(modes.toArray(new IndexMode[modes.size()]));
indexBuffer.put(index); points.getMeshData().setIndices(indexBuffer); indexBuffer.put(index); line.getMeshData().setIndices(indexBuffer); if (_lineManager.getLengths().size() > 1) { final int[] lengths = new int[_lineManager.getLengths().size()]; lengths[i++] = l; line.getMeshData().setIndexLengths(lengths); mesh.getMeshData().setVertexBuffer(vertices); if (hasNormals) { mesh.getMeshData().setNormalBuffer(normals); mesh.getMeshData().setTextureBuffer(uvs, 0); indexBuffer.put(index); mesh.getMeshData().setIndices(indexBuffer);
private static Mesh createMesh() { final Mesh mesh = new Mesh(); mesh.setRenderMaterial("ui/untextured/vertex_color.yaml"); final MeshData meshData = mesh.getMeshData(); meshData.setVertexBuffer(BufferUtils.createVector3Buffer(4)); meshData.getVertexCoords().setVboAccessMode(VBOAccessMode.DynamicDraw); meshData.setColorBuffer(BufferUtils.createColorBuffer(4)); meshData.getColorCoords().setVboAccessMode(VBOAccessMode.DynamicDraw); meshData.setIndexMode(IndexMode.TriangleFan); final BlendState blend = new BlendState(); blend.setBlendEnabled(true); blend.setSourceFunction(SourceFunction.SourceAlpha); blend.setDestinationFunction(DestinationFunction.OneMinusSourceAlpha); mesh.setRenderState(blend); mesh.updateWorldRenderStates(false); return mesh; } }
/** * Sets every color of this geometry's color array to a random color. */ public void setRandomColors() { FloatBuffer colorBuf = _meshData.getColorBuffer(); if (colorBuf == null) { colorBuf = BufferUtils.createColorBuffer(_meshData.getVertexCount()); _meshData.setColorBuffer(colorBuf); } else { colorBuf.rewind(); } for (int x = 0, cLength = colorBuf.limit(); x < cLength; x += 4) { colorBuf.put(MathUtils.nextRandomFloat()); colorBuf.put(MathUtils.nextRandomFloat()); colorBuf.put(MathUtils.nextRandomFloat()); colorBuf.put(1); } colorBuf.flip(); }
/** * Initializes the vertices and indices. */ private void initialize() { final MeshData meshData = getMeshData(); meshData.setIndexMode(IndexMode.TriangleStrip); // clipSideSize is the number of vertices per clipmapside, so number of all vertices is clipSideSize * // clipSideSize final FloatBufferData vertices = new FloatBufferData( BufferUtils.createVector4Buffer(clipSideSize * clipSideSize), 4); vertices.setVboAccessMode(VBOAccessMode.DynamicDraw); meshData.setVertexCoords(vertices); final int indicesSize = 4 * (3 * frameSize * frameSize + clipSideSize * clipSideSize / 2 + 4 * frameSize - 10); final IndexBufferData<?> indices = BufferUtils.createIndexBufferData(indicesSize, vertices.getBufferCapacity() - 1); indices.setVboAccessMode(VBOAccessMode.DynamicDraw); tmpIndices = new int[indicesSize]; meshData.setIndices(indices); // Go through all rows and fill them with vertexindices. for (int z = 0; z < clipSideSize - 1; z++) { fillRow(0, clipSideSize - 1, z, z + 1); } }
private void setNormalData() { final Vector3 norm = new Vector3(); for (int i = 0; i < NUM_POINTS; i++) { BufferUtils.populateFromBuffer(norm, _meshData.getVertexBuffer(), i); norm.normalizeLocal(); BufferUtils.setInBuffer(norm, _meshData.getNormalBuffer(), i); } }