gered/gdx-tilemap3d
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

TileMesh now uses completely "client-side" storage of vertex data

Browse source 
Since TileMesh objects are not rendered directly, using a Mesh object
to store their vertices is a bit of a waste since on GL 2.0+ libgdx
uses a VBO for each Mesh
This commit is contained in:
Gered 2013-07-16 11:10:40 -04:00
parent 382da2985f
commit 4a881184fb
4 changed files with 238 additions and 266 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/com/blarg/gdx/tilemap3d/ChunkVertexGenerator.java
View file

@ -136,9 +136,9 @@ public class ChunkVertexGenerator {
if (visible) { if (visible) {
if (mesh.alpha) if (mesh.alpha)
addMesh(alphaBuilder, mesh, chunk, tmpPosition, transform, tmpColor, 0, mesh.getMesh().getNumVertices()); addMesh(alphaBuilder, mesh, chunk, tmpPosition, transform, tmpColor, 0, mesh.getVertices().count());
else else
addMesh(builder, mesh, chunk, tmpPosition, transform, tmpColor, 0, mesh.getMesh().getNumVertices()); addMesh(builder, mesh, chunk, tmpPosition, transform, tmpColor, 0, mesh.getVertices().count());
} }
} }
} }
@ -168,17 +168,7 @@ public class ChunkVertexGenerator {
} }
private void copyVertex(MeshBuilder builder, TileMesh sourceMesh, int sourceVertexIndex, Vector3 positionOffset, Matrix4 transform, Color color, TileChunk chunk) { private void copyVertex(MeshBuilder builder, TileMesh sourceMesh, int sourceVertexIndex, Vector3 positionOffset, Matrix4 transform, Color color, TileChunk chunk) {
FloatBuffer buffer = sourceMesh.getMesh().getVerticesBuffer(); sourceMesh.getVertices().getVertex(sourceVertexIndex, vertex);
int strideInFloats = sourceMesh.getMesh().getVertexSize() / (Float.SIZE / 8);
int offset = (sourceVertexIndex * strideInFloats);
vertex.setPos(buffer.get(offset), buffer.get(offset + 1), buffer.get(offset + 2));
offset += 3;
vertex.setCol(buffer.get(offset), buffer.get(offset + 1), buffer.get(offset + 2), buffer.get(offset + 3));
offset += 4;
vertex.setNor(buffer.get(offset), buffer.get(offset + 1), buffer.get(offset + 2));
offset += 3;
vertex.setUV(buffer.get(offset), buffer.get(offset + 1));
// transform if applicable... (this will probably just be per-tile rotation) // transform if applicable... (this will probably just be per-tile rotation)
if (transform != null) { if (transform != null) {

422
src/com/blarg/gdx/tilemap3d/CubeTileMesh.java
View file

@ -1,25 +1,20 @@
package com.blarg.gdx.tilemap3d; package com.blarg.gdx.tilemap3d;
import com.badlogic.gdx.graphics.Color; import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Mesh; import com.badlogic.gdx.graphics.VertexAttribute;
import com.badlogic.gdx.graphics.VertexAttributes;
import com.badlogic.gdx.graphics.g2d.TextureRegion; import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.g3d.utils.MeshBuilder;
import com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3; import com.badlogic.gdx.math.Vector3;
import com.blarg.gdx.Bitfield; import com.blarg.gdx.Bitfield;
import com.blarg.gdx.graphics.TextureAtlas; import com.blarg.gdx.graphics.TextureAtlas;
import com.blarg.gdx.graphics.Vertices;
import com.blarg.gdx.math.MathHelpers; import com.blarg.gdx.math.MathHelpers;
import java.nio.FloatBuffer;
public class CubeTileMesh extends TileMesh { public class CubeTileMesh extends TileMesh {
static final Vector3 A = new Vector3(-0.5f, -0.5f, -0.5f); static final Vector3 A = new Vector3(-0.5f, -0.5f, -0.5f);
static final Vector3 B = new Vector3(0.5f, 0.5f, 0.5f); static final Vector3 B = new Vector3(0.5f, 0.5f, 0.5f);
final Mesh mesh; Vertices vertices;
final Vector3[] collisionVertices; Vector3[] collisionVertices;
public final byte faces; public final byte faces;
public final int topFaceVertexOffset; public final int topFaceVertexOffset;
@ -34,8 +29,8 @@ public class CubeTileMesh extends TileMesh {
} }
@Override @Override
public Mesh getMesh() { public Vertices getVertices() {
return mesh; return vertices;
} }
@Override @Override
@ -95,11 +90,12 @@ public class CubeTileMesh extends TileMesh {
} else } else
rightFaceVertexOffset = 0; rightFaceVertexOffset = 0;
mesh = setupFaceVertices(topTexture, bottomTexture, frontTexture, backTexture, leftTexture, rightTexture); setupFaceVertices(numVertices, topTexture, bottomTexture, frontTexture, backTexture, leftTexture, rightTexture);
collisionVertices = setupCollisionVertices(); setupCollisionVertices();
} }
private Mesh setupFaceVertices( private void setupFaceVertices(
int numVertices,
TextureRegion topTexture, TextureRegion topTexture,
TextureRegion bottomTexture, TextureRegion bottomTexture,
TextureRegion frontTexture, TextureRegion frontTexture,
@ -107,267 +103,253 @@ public class CubeTileMesh extends TileMesh {
TextureRegion leftTexture, TextureRegion leftTexture,
TextureRegion rightTexture TextureRegion rightTexture
) { ) {
MeshPartBuilder.VertexInfo vertex = new MeshPartBuilder.VertexInfo(); vertices = new Vertices(
numVertices,
MeshBuilder builder = new MeshBuilder(); VertexAttribute.Position(),
builder.begin( VertexAttribute.ColorUnpacked(),
VertexAttributes.Usage.Position | VertexAttribute.Normal(),
VertexAttributes.Usage.Color | VertexAttribute.TexCoords(0)
VertexAttributes.Usage.Normal |
VertexAttributes.Usage.TextureCoordinates
); );
if (hasFace(SIDE_TOP)) { if (hasFace(SIDE_TOP)) {
vertex.setPos(A.x, B.y, B.z); vertices.setPos(A.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, B.z); vertices.setPos(B.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, A.z); vertices.setPos(A.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, B.z); vertices.setPos(B.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(1.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, A.z); vertices.setPos(B.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, A.z); vertices.setPos(A.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.UP_VECTOR3); vertices.setNor(MathHelpers.UP_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, topTexture), TextureAtlas.scaleTexCoordV(0.0f, topTexture));
builder.vertex(vertex); vertices.moveNext();
} }
if (hasFace(SIDE_BOTTOM)) { if (hasFace(SIDE_BOTTOM)) {
vertex.setPos(B.x, A.y, B.z); vertices.setPos(B.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, B.z); vertices.setPos(A.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, A.z); vertices.setPos(B.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, B.z); vertices.setPos(A.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(1.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, A.z); vertices.setPos(A.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, A.z); vertices.setPos(B.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.DOWN_VECTOR3); vertices.setNor(MathHelpers.DOWN_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, bottomTexture), TextureAtlas.scaleTexCoordV(0.0f, bottomTexture));
builder.vertex(vertex); vertices.moveNext();
} }
if (hasFace(SIDE_FRONT)) { if (hasFace(SIDE_FRONT)) {
vertex.setPos(B.x, A.y, A.z); vertices.setPos(B.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, A.z); vertices.setPos(A.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, A.z); vertices.setPos(B.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, A.z); vertices.setPos(A.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(1.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, A.z); vertices.setPos(A.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, A.z); vertices.setPos(B.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.FORWARD_VECTOR3); vertices.setNor(MathHelpers.FORWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, frontTexture), TextureAtlas.scaleTexCoordV(0.0f, frontTexture));
builder.vertex(vertex); vertices.moveNext();
} }
if (hasFace(SIDE_BACK)) { if (hasFace(SIDE_BACK)) {
vertex.setPos(A.x, A.y, B.z); vertices.setPos(A.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, B.z); vertices.setPos(B.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, B.z); vertices.setPos(A.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, B.z); vertices.setPos(B.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(1.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, B.z); vertices.setPos(B.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, B.z); vertices.setPos(A.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.BACKWARD_VECTOR3); vertices.setNor(MathHelpers.BACKWARD_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, backTexture), TextureAtlas.scaleTexCoordV(0.0f, backTexture));
builder.vertex(vertex); vertices.moveNext();
} }
if (hasFace(SIDE_LEFT)) { if (hasFace(SIDE_LEFT)) {
vertex.setPos(A.x, A.y, A.z); vertices.setPos(A.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, B.z); vertices.setPos(A.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, A.z); vertices.setPos(A.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, A.y, B.z); vertices.setPos(A.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(1.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, B.z); vertices.setPos(A.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(A.x, B.y, A.z); vertices.setPos(A.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.LEFT_VECTOR3); vertices.setNor(MathHelpers.LEFT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, leftTexture), TextureAtlas.scaleTexCoordV(0.0f, leftTexture));
builder.vertex(vertex); vertices.moveNext();
} }
if (hasFace(SIDE_RIGHT)) { if (hasFace(SIDE_RIGHT)) {
vertex.setPos(B.x, A.y, B.z); vertices.setPos(B.x, A.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, A.z); vertices.setPos(B.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, B.z); vertices.setPos(B.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, A.y, A.z); vertices.setPos(B.x, A.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(1.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, A.z); vertices.setPos(B.x, B.y, A.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(1.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
vertex.setPos(B.x, B.y, B.z); vertices.setPos(B.x, B.y, B.z);
vertex.setCol(color); vertices.setCol(color);
vertex.setNor(MathHelpers.RIGHT_VECTOR3); vertices.setNor(MathHelpers.RIGHT_VECTOR3);
vertex.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture)); vertices.setUV(TextureAtlas.scaleTexCoordU(0.0f, rightTexture), TextureAtlas.scaleTexCoordV(0.0f, rightTexture));
builder.vertex(vertex); vertices.moveNext();
} }
return builder.end();
} }
private Vector3[] setupCollisionVertices() { private void setupCollisionVertices() {
Vector3[] vertices = new Vector3[mesh.getNumVertices()]; collisionVertices = new Vector3[vertices.count()];
FloatBuffer meshVertices = mesh.getVerticesBuffer(); for (int i = 0; i < vertices.count(); ++i) {
int strideInFloats = mesh.getVertexSize() / (Float.SIZE / 8);
for (int i = 0; i < mesh.getNumVertices(); ++i) {
int offset = i * strideInFloats;
// NOTE: we assume position is always at the start of each vertex... I believe libgdx will _always_ do this
Vector3 v = new Vector3(); Vector3 v = new Vector3();
v.x = meshVertices.get(offset); vertices.getPos(i, v);
v.y = meshVertices.get(offset + 1); collisionVertices[i] = v;
v.z = meshVertices.get(offset + 2);
vertices[i] = v;
} }
return vertices;
} }
@Override @Override
public void dispose() { public void dispose() {
mesh.dispose();
} }
} }

62
src/com/blarg/gdx/tilemap3d/ModelTileMesh.java
View file

@ -1,36 +1,34 @@
package com.blarg.gdx.tilemap3d; package com.blarg.gdx.tilemap3d;
import com.badlogic.gdx.graphics.Color; import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Mesh; import com.badlogic.gdx.graphics.VertexAttribute;
import com.badlogic.gdx.graphics.VertexAttributes; import com.badlogic.gdx.graphics.VertexAttributes;
import com.badlogic.gdx.graphics.g2d.TextureRegion; import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.g3d.Model; import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.model.MeshPart; import com.badlogic.gdx.graphics.g3d.model.MeshPart;
import com.badlogic.gdx.graphics.g3d.model.Node; import com.badlogic.gdx.graphics.g3d.model.Node;
import com.badlogic.gdx.graphics.g3d.model.NodePart; import com.badlogic.gdx.graphics.g3d.model.NodePart;
import com.badlogic.gdx.graphics.g3d.utils.MeshBuilder;
import com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder;
import com.badlogic.gdx.math.Matrix4; import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Vector2; import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3; import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Array; import com.badlogic.gdx.utils.Array;
import com.blarg.gdx.graphics.TextureAtlas; import com.blarg.gdx.graphics.TextureAtlas;
import com.blarg.gdx.graphics.Vertices;
import java.nio.FloatBuffer; import java.nio.FloatBuffer;
import java.nio.ShortBuffer; import java.nio.ShortBuffer;
import java.util.Map; import java.util.Map;
public class ModelTileMesh extends TileMesh { public class ModelTileMesh extends TileMesh {
final MeshPartBuilder.VertexInfo vertex = new MeshPartBuilder.VertexInfo();
final Vector3 tmpPosition = new Vector3(); final Vector3 tmpPosition = new Vector3();
final Vector3 tmpNormal = new Vector3(); final Vector3 tmpNormal = new Vector3();
Mesh mesh; Vertices vertices;
Array<Vector3> collisionVertices; Array<Vector3> collisionVertices;
@Override @Override
public Mesh getMesh() { public Vertices getVertices() {
return mesh; return vertices;
} }
@Override @Override
@ -51,21 +49,20 @@ public class ModelTileMesh extends TileMesh {
} }
private void setupMesh(Model model, Map<String, TextureRegion> textures) { private void setupMesh(Model model, Map<String, TextureRegion> textures) {
MeshBuilder builder = new MeshBuilder(); int numVertices = countModelVertices(model);
builder.begin( vertices = new Vertices(
VertexAttributes.Usage.Position | numVertices,
VertexAttributes.Usage.Color | VertexAttribute.Position(),
VertexAttributes.Usage.Normal | VertexAttribute.ColorUnpacked(),
VertexAttributes.Usage.TextureCoordinates VertexAttribute.Normal(),
VertexAttribute.TexCoords(0)
); );
for (int i = 0; i < model.nodes.size; ++i) for (int i = 0; i < model.nodes.size; ++i)
addModelNodeVertices(model.nodes.get(i), builder, textures); addModelNodeVertices(model.nodes.get(i), textures);
mesh = builder.end();
} }
private void addModelNodeVertices(Node node, MeshBuilder builder, Map<String, TextureRegion> textures) { private void addModelNodeVertices(Node node, Map<String, TextureRegion> textures) {
final Matrix4 transform = node.globalTransform; // TODO: test that this is the right transform to use? final Matrix4 transform = node.globalTransform; // TODO: test that this is the right transform to use?
for (int i = 0; i < node.parts.size; ++i) { for (int i = 0; i < node.parts.size; ++i) {
@ -82,47 +79,44 @@ public class ModelTileMesh extends TileMesh {
tmpPosition.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2)); tmpPosition.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2));
tmpPosition.mul(transform); tmpPosition.mul(transform);
vertex.setPos(tmpPosition); this.vertices.setPos(tmpPosition);
offset += 3; offset += 3;
if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.Color) != null) { if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.Color) != null) {
vertex.setCol(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2), vertices.get(offset + 3)); this.vertices.setCol(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2), vertices.get(offset + 3));
offset += 4; offset += 4;
} else } else
vertex.setCol(Color.WHITE); this.vertices.setCol(Color.WHITE);
// TODO: better to throw exception (or check beforehand) if this is missing? setting zero's doesn't feel like the best solution // TODO: better to throw exception (or check beforehand) if this is missing? setting zero's doesn't feel like the best solution
if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.Normal) != null) { if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.Normal) != null) {
tmpNormal.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2)); tmpNormal.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2));
tmpNormal.mul(transform); tmpNormal.mul(transform);
vertex.setNor(tmpNormal); this.vertices.setNor(tmpNormal);
offset += 3; offset += 3;
} else } else
vertex.setNor(Vector3.Zero); this.vertices.setNor(Vector3.Zero);
// TODO: better to throw exception (or check beforehand) if this is missing? setting zero's doesn't feel like the best solution // TODO: better to throw exception (or check beforehand) if this is missing? setting zero's doesn't feel like the best solution
if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.TextureCoordinates) != null) { if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.TextureCoordinates) != null) {
vertex.setUV( this.vertices.setUV(
TextureAtlas.scaleTexCoordU(vertices.get(offset), texture), TextureAtlas.scaleTexCoordU(vertices.get(offset), texture),
TextureAtlas.scaleTexCoordV(vertices.get(offset + 1), texture) TextureAtlas.scaleTexCoordV(vertices.get(offset + 1), texture)
); );
offset += 3; offset += 3;
} else } else
vertex.setUV(Vector2.Zero); this.vertices.setUV(Vector2.Zero);
builder.vertex(vertex); this.vertices.moveNext();
} }
} }
for (int i = 0; i < node.children.size; ++i) for (int i = 0; i < node.children.size; ++i)
addModelNodeVertices(node.children.get(i), builder, textures); addModelNodeVertices(node.children.get(i), textures);
} }
private void setupCollisionVertices(Model collisionModel) { private void setupCollisionVertices(Model collisionModel) {
int numVertices = 0; int numVertices = countModelVertices(collisionModel);
for (int i = 0; i < collisionModel.meshParts.size; ++i)
numVertices += collisionModel.meshParts.get(i).numVertices;
collisionVertices = new Array<Vector3>(true, numVertices, Vector3.class); collisionVertices = new Array<Vector3>(true, numVertices, Vector3.class);
for (int i = 0; i < collisionModel.nodes.size; ++i) for (int i = 0; i < collisionModel.nodes.size; ++i)
addModelNodeCollisionVertices(collisionModel.nodes.get(i)); addModelNodeCollisionVertices(collisionModel.nodes.get(i));
@ -152,8 +146,14 @@ public class ModelTileMesh extends TileMesh {
addModelNodeCollisionVertices(node.children.get(i)); addModelNodeCollisionVertices(node.children.get(i));
} }
private int countModelVertices(Model model) {
int numVertices = 0;
for (int i = 0; i < model.meshParts.size; ++i)
numVertices += model.meshParts.get(i).numVertices;
return numVertices;
}
@Override @Override
public void dispose() { public void dispose() {
mesh.dispose();
} }
} }

4
src/com/blarg/gdx/tilemap3d/TileMesh.java
View file

@ -1,10 +1,10 @@
package com.blarg.gdx.tilemap3d; package com.blarg.gdx.tilemap3d;
import com.badlogic.gdx.graphics.Color; import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Mesh;
import com.badlogic.gdx.math.Vector3; import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Disposable; import com.badlogic.gdx.utils.Disposable;
import com.blarg.gdx.Bitfield; import com.blarg.gdx.Bitfield;
import com.blarg.gdx.graphics.Vertices;
public abstract class TileMesh implements Disposable { public abstract class TileMesh implements Disposable {
public static final Vector3 OFFSET = new Vector3(0.5f, 0.5f, 0.5f); public static final Vector3 OFFSET = new Vector3(0.5f, 0.5f, 0.5f);
@ -25,7 +25,7 @@ public abstract class TileMesh implements Disposable {
public final byte lightValue; public final byte lightValue;
public final Color color; public final Color color;
public abstract Mesh getMesh(); public abstract Vertices getVertices();
public abstract Vector3[] getCollisionVertices(); public abstract Vector3[] getCollisionVertices();
public boolean isCompletelyOpaque() { public boolean isCompletelyOpaque() {