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 (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
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) {
FloatBuffer buffer = sourceMesh.getMesh().getVerticesBuffer();
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));
sourceMesh.getVertices().getVertex(sourceVertexIndex, vertex);
// transform if applicable... (this will probably just be per-tile rotation)
if (transform != null) {

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

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

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

@ -1,36 +1,34 @@
package com.blarg.gdx.tilemap3d;
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.g3d.Model;
import com.badlogic.gdx.graphics.g3d.model.MeshPart;
import com.badlogic.gdx.graphics.g3d.model.Node;
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.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Array;
import com.blarg.gdx.graphics.TextureAtlas;
import com.blarg.gdx.graphics.Vertices;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import java.util.Map;
public class ModelTileMesh extends TileMesh {
final MeshPartBuilder.VertexInfo vertex = new MeshPartBuilder.VertexInfo();
final Vector3 tmpPosition = new Vector3();
final Vector3 tmpNormal = new Vector3();
Mesh mesh;
Vertices vertices;
Array<Vector3> collisionVertices;
@Override
public Mesh getMesh() {
return mesh;
public Vertices getVertices() {
return vertices;
}
@Override
@ -51,21 +49,20 @@ public class ModelTileMesh extends TileMesh {
}
private void setupMesh(Model model, Map<String, TextureRegion> textures) {
MeshBuilder builder = new MeshBuilder();
builder.begin(
VertexAttributes.Usage.Position |
VertexAttributes.Usage.Color |
VertexAttributes.Usage.Normal |
VertexAttributes.Usage.TextureCoordinates
int numVertices = countModelVertices(model);
vertices = new Vertices(
numVertices,
VertexAttribute.Position(),
VertexAttribute.ColorUnpacked(),
VertexAttribute.Normal(),
VertexAttribute.TexCoords(0)
);
for (int i = 0; i < model.nodes.size; ++i)
addModelNodeVertices(model.nodes.get(i), builder, textures);
mesh = builder.end();
addModelNodeVertices(model.nodes.get(i), textures);
}
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?
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.mul(transform);
vertex.setPos(tmpPosition);
this.vertices.setPos(tmpPosition);
offset += 3;
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;
} 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
if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.Normal) != null) {
tmpNormal.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2));
tmpNormal.mul(transform);
vertex.setNor(tmpNormal);
this.vertices.setNor(tmpNormal);
offset += 3;
} 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
if (meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.TextureCoordinates) != null) {
vertex.setUV(
this.vertices.setUV(
TextureAtlas.scaleTexCoordU(vertices.get(offset), texture),
TextureAtlas.scaleTexCoordV(vertices.get(offset + 1), texture)
);
offset += 3;
} 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)
addModelNodeVertices(node.children.get(i), builder, textures);
addModelNodeVertices(node.children.get(i), textures);
}
private void setupCollisionVertices(Model collisionModel) {
int numVertices = 0;
for (int i = 0; i < collisionModel.meshParts.size; ++i)
numVertices += collisionModel.meshParts.get(i).numVertices;
int numVertices = countModelVertices(collisionModel);
collisionVertices = new Array<Vector3>(true, numVertices, Vector3.class);
for (int i = 0; i < collisionModel.nodes.size; ++i)
addModelNodeCollisionVertices(collisionModel.nodes.get(i));
@ -152,8 +146,14 @@ public class ModelTileMesh extends TileMesh {
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
public void dispose() {
mesh.dispose();
}
}

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

@ -1,10 +1,10 @@
package com.blarg.gdx.tilemap3d;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Mesh;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Disposable;
import com.blarg.gdx.Bitfield;
import com.blarg.gdx.graphics.Vertices;
public abstract class TileMesh implements Disposable {
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 Color color;
public abstract Mesh getMesh();
public abstract Vertices getVertices();
public abstract Vector3[] getCollisionVertices();
public boolean isCompletelyOpaque() {