Create a gist now

Instantly share code, notes, and snippets.

@hdon /frag-md5.glsl Secret
Created Jan 3, 2015

md5.d
#version 150
/* MD5 fragment shader */
#define AMB 0.2
uniform sampler2D colorMap;
uniform float ambU;
in vec2 uvF;
in vec3 normalF;
out vec4 outputF;
void main()
{
outputF = texture(colorMap, uvF) * (smoothstep(-1, 1, dot(normalize(normalF), vec3(0,1,0))) * (1.0-ambU) + ambU);
}
module ants.md5;
import file = std.file;
import std.string;
import std.conv;
import std.algorithm : map, appender;
import std.exception : enforce;
import std.path : dirName;
import derelict.opengl3.gl3;
import gl3n.linalg;
import gl3n.interpolate : lerp;
import ants.vertexer;
import ants.material;
import ants.shader;
import ants.texture;
import ants.gametime;
import ants.glutil;
import main = ants.main;
import lines = ants.lines;
import std.math : sqrt;
import std.stdio : writeln, writefln;
alias sum = reduce!"a + b";
private
{
Vertexer vertexer;
Material emptyMaterial;
ShaderProgram shaderProgram;
ShaderProgram shaderProgram1;
ShaderProgram md5ShaderProgram;
ShaderProgram shaderProgram2;
/* Attribute locations */
GLint sp2_Aposition;
GLint sp2_Anormal;
GLint sp2_Auv;
GLint sp2_UviewMatrix;
GLint sp2_UprojMatrix;
GLint sp2_UnormalMatrix;
GLint sp2_UcolorMap;
GLint sp2_Uamb;
}
private struct Ray
{
vec3 pos;
quat orient;
this(vec3 pos, quat orient)
{
this.pos = pos;
this.orient = orient;
}
this(float px, float py, float pz, float ow, float ox, float oy, float oz)
{
this.pos = vec3(px, py, pz);
this.orient = quat(ow, ox, oy, oz);
}
this(float px, float py, float pz, float ox, float oy, float oz)
{
this.pos = vec3(px, py, pz);
this.orient = quat(0, ox, oy, oz);
}
}
private struct Joint
{
int parentIndex;
Ray ray;
this(int parentIndex, float px, float py, float pz, float ox, float oy, float oz)
{
this.parentIndex = parentIndex;
this.ray = Ray(vec3(px, py, pz), quat(0.0, ox, oy, oz));
}
this(int parentIndex, vec3 pos, quat orient)
{
this.parentIndex = parentIndex;
this.ray.pos = pos;
this.ray.orient = orient;
}
}
struct Vert
{
vec2 uv;
vec3 normal;
uint weightIndex;
uint numWeights;
this(vec2 uv, uint weightIndex, uint numWeights)
{
this.uv = uv;
this.weightIndex = weightIndex;
this.numWeights = numWeights;
}
}
/* This layout should eventually replace Vert I think. Right now I will just copy a mesh's Verts
* into a GPUVert[] and send the data to a GL Buffer Object.
*/
struct GPUVert
{
vec4[4] weightPos;
float[4] weightBiases;
float[4] boneIndices;
vec2 uv;
vec3 normal;
}
struct Tri
{
uint[3] vi; // verts
this(uint a, uint b, uint c)
{
this.vi[0] = a;
this.vi[1] = b;
this.vi[2] = c;
}
}
struct Weight
{
size_t jointIndex;
float weightBias;
vec3 pos;
this(size_t jointIndex, float weightBias, float posx, float posy, float posz)
{
this.jointIndex = jointIndex;
this.weightBias = weightBias;
this.pos.x = posx;
this.pos.y = posy;
this.pos.z = posz;
}
}
class Mesh
{
size_t numVerts;
Material material;
Vert[] verts;
size_t numTris;
Tri[] tris;
size_t numWeights;
Weight[] weights;
this() {}
/* Renderers of mesh may consolidate all mesh data into a single vertex buffer.
* This may help with that.
*/
size_t firstVertexIndex;
size_t firstElementIndex;
}
private enum ParserMode
{
open,
joints,
meshes,
bounds,
baseframe,
frame
}
/* Changes q.w so that the quaternion is a unit quaternion.
* If the other three components do not represent a unit
* vector, q.w will be set to 0.
*/
void computeUnitQuatW(ref quat q)
{
float t = 1f - q.x.sq() - q.y.sq() - q.z.sq();
if (t<=0f)
q.w = 0;
else
q.w = -sqrt(t);
}
class MD5Model
{
Joint[] joints;
size_t[string] namedJoints;
Mesh[] meshes;
/* Generate bone-space weight normals */
static struct BindPoseVert
{
vec3 pos;
vec3 normal;
vec2 uv;
}
static BindPoseVert[] bindPoseVerts;
void generateBindPose(size_t iMesh, bool inBoneSpace=false)
{
auto mesh = meshes[iMesh];
if (bindPoseVerts.length < mesh.verts.length)
bindPoseVerts.length = mesh.verts.length;
foreach (iVert, vert; mesh.verts)
{
Weight[] weights = mesh.weights[vert.weightIndex .. vert.weightIndex + vert.numWeights];
auto pos = vec3(0, 0, 0);
foreach (weight; weights)
{
auto joint = joints[weight.jointIndex].ray;
pos += weight.weightBias *
//(joint.orient * weight.pos + joint.pos) * weight.weightBias
//weight.pos * weight.weightBias
//(joint.pos + joint.orient * weight.pos)
(joint.orient * weight.pos + joint.pos)
//weight.pos
;
}
bindPoseVerts[iVert] = BindPoseVert(pos, vec3(0,0,0), vert.uv);
writefln("mesh %d vert %d = %s", iMesh, iVert, pos);
}
foreach (iTri, tri; mesh.tris)
{
auto a = bindPoseVerts[tri.vi[0]].pos;
auto b = bindPoseVerts[tri.vi[1]].pos;
auto c = bindPoseVerts[tri.vi[2]].pos;
auto normal = cross((b-a).normalized, (b-c).normalized).normalized;
bindPoseVerts[tri.vi[0]].normal += normal;
bindPoseVerts[tri.vi[1]].normal += normal;
bindPoseVerts[tri.vi[2]].normal += normal;
}
foreach (iVert; 0..mesh.verts.length)
{
auto meshVert = mesh.verts[iVert];
auto n = bindPoseVerts[iVert].normal.normalized;
if (inBoneSpace)
{
auto n2 = vec3(0,0,0);
foreach (iWeight, weight; mesh.weights[meshVert.weightIndex .. meshVert.weightIndex + meshVert.numWeights])
n2 += joints[weight.jointIndex].ray.orient.inverse * n * weight.weightBias;
bindPoseVerts[iVert].normal = n2;
}
else
bindPoseVerts[iVert].normal = n;
}
}
/* Vertex Array Object, and Buffer Objects */
GLuint vao, vbo, ibo;
static Tri[] triBuf;
void render(mat4 viewMatrix, mat4 projMatrix)
{
if (shaderProgram2 is null)
{
shaderProgram2 = new ShaderProgram("vert-uv-norm--uv-norm.glsl", "frag-colorMap--uv-normal--uv-normal.glsl");
glGenBuffers(2, &vbo);
glGenVertexArrays(1, &vao);
shaderProgram2.use;
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
auto numTris = sum(map!"a.tris.length"(meshes));
writeln("numTris=", numTris);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, numTris * Tri.sizeof, null, GL_STREAM_DRAW);
auto numVerts = sum(map!"a.verts.length"(meshes));
glBufferData(GL_ARRAY_BUFFER, numVerts * BindPoseVert.sizeof, null, GL_STREAM_DRAW);
size_t vboWriteCursor, iboWriteCursor;
int vertexCounter, triCounter;
auto maxTris = reduce!"a>b?a:b"(map!"a.tris.length"(meshes));
if (triBuf.length < maxTris)
triBuf.length = maxTris;
foreach (iMesh, mesh; meshes)
{
mesh.firstVertexIndex = vertexCounter;
mesh.firstElementIndex = triCounter * 3;
writefln("mesh[%d].firstElementIndex = %d", iMesh, mesh.firstElementIndex);
generateBindPose(iMesh);
auto vboWriteLen = mesh.verts.length * BindPoseVert.sizeof;
glBufferSubData(GL_ARRAY_BUFFER, vboWriteCursor, vboWriteLen, bindPoseVerts.ptr);
writefln("mesh %d writing %d vertices starting at index %d (%d bytes): %s",
iMesh, mesh.verts.length, vertexCounter, vboWriteCursor, bindPoseVerts[0..mesh.verts.length]);
foreach (iTri, tri; mesh.tris)
{
triBuf[iTri] = Tri(
vertexCounter + tri.vi[0]
, vertexCounter + tri.vi[1]
, vertexCounter + tri.vi[2]
);
}
auto iboWriteLen = mesh.tris.length * triBuf[0].sizeof;
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, iboWriteCursor, iboWriteLen, triBuf.ptr);
writefln("mesh %d writing %d triangles / %d elements / %d bytes starting at tri index %d / element index %d (%d bytes): %s",
iMesh, mesh.tris.length, mesh.tris.length * 3, iboWriteLen, triCounter, triCounter * 3, iboWriteCursor,
triBuf[0..mesh.tris.length]);
vboWriteCursor += vboWriteLen;
iboWriteCursor += iboWriteLen;
vertexCounter += mesh.verts.length;
triCounter += mesh.tris.length;
glFinish();
}
assert(triCounter == numTris);
assert(vertexCounter == numVerts);
sp2_UviewMatrix = shaderProgram2.getUniformLocation("viewMatrix");
sp2_UprojMatrix = shaderProgram2.getUniformLocation("projMatrix");
sp2_UnormalMatrix = shaderProgram2.getUniformLocation("normalMatrix");
sp2_UcolorMap = shaderProgram2.getUniformLocation("colorMap");
sp2_Uamb = shaderProgram2.getUniformLocation("ambU");
sp2_Aposition = shaderProgram2.getAttribLocation ("positionV");
sp2_Anormal = shaderProgram2.getAttribLocation ("normalV");
sp2_Auv = shaderProgram2.getAttribLocation ("uvV");
assert(sp2_UviewMatrix >= 0);
assert(sp2_UprojMatrix >= 0);
assert(sp2_Aposition >= 0);
BindPoseVert VT;
glEnableVertexAttribArray(sp2_Aposition);
glVertexAttribPointer(sp2_Aposition, 3, GL_FLOAT, GL_FALSE,
VT.sizeof, cast(void*) VT.pos.offsetof);
if (sp2_Anormal >= 0)
{
glEnableVertexAttribArray(sp2_Anormal);
glVertexAttribPointer(sp2_Anormal, 3, GL_FLOAT, GL_FALSE,
VT.sizeof, cast(void*) VT.normal.offsetof);
}
if (sp2_Auv >= 0)
{
glEnableVertexAttribArray(sp2_Auv);
glVertexAttribPointer(sp2_Auv, 3, GL_FLOAT, GL_FALSE,
VT.sizeof, cast(void*) VT.uv.offsetof);
}
}
else
{
shaderProgram2.use;
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
}
glUniformMatrix4fv(sp2_UviewMatrix, 1, GL_TRUE, viewMatrix.value_ptr);
glUniformMatrix4fv(sp2_UprojMatrix, 1, GL_TRUE, projMatrix.value_ptr);
static if (0)
if (sp2_UnormalMatrix >= 0)
{
mat3 normalMatrix = viewMatrix.get_rotation;
glUniformMatrix3fv(sp2_UnormalMatrix, 1, GL_TRUE, normalMatrix.value_ptr);
}
//auto buf = new float[1536/float.sizeof];
//glGetBufferSubData(GL_ARRAY_BUFFER, 0, buf.length * buf[0].sizeof, buf.ptr);
//writeln("got: ", buf);
foreach (iMesh, mesh; meshes)
{
if (sp2_UcolorMap >= 0)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh.material.texes[0].texture);
glUniform1i(sp2_UcolorMap, 0);
}
if (sp2_Uamb >= 0)
glUniform1f(sp2_Uamb, mesh.material.amb);
GLint start = cast(GLint) mesh.firstElementIndex;
GLint count = cast(GLint) mesh.tris.length * 3;
GLint end = start + count;
//writefln("mesh[%d].firstElementIndex == %d", iMesh, mesh.firstElementIndex);
//writefln("meshes[%d] glDrawRangeElements(GL_TRIANGLES, %s, %s, %s, GL_UNSIGNED_INT, null)", iMesh, start, end, count);
glDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_INT, cast(void*) (start * uint.sizeof));
}
if (sp2_UcolorMap >= 0)
glBindTexture(GL_TEXTURE_2D, 0);
glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
/* Generates a frequency distribution of vertex weight counts */
uint[] getWeightingInfo()
{
uint[] rval;
foreach (mesh; meshes)
{
foreach (vert; mesh.verts)
{
auto nw = vert.numWeights;
if (nw >= rval.length)
rval.length = nw+1;
rval[nw]++;
}
}
return rval;
}
this(string filename)
{
int mode = ParserMode.open;
size_t nJoints;
size_t nMeshes;
//string dir = dirName(filename) ~ "/";
foreach (lineNo, line; splitLines(to!string(cast(char[])file.read(filename))))
{
auto words = split(line);
if (words.length > 0)
switch (mode)
{
case ParserMode.open:
if (words[0] == "MD5Version")
{
assert(to!int(words[1]) == 10);
}
else if (words[0] == "commandline")
{
// do nothing
}
else if (words[0] == "numJoints")
{
nJoints = to!int(words[1]);
joints.reserve(nJoints);
}
else if (words[0] == "numMeshes")
{
nMeshes = to!int(words[1]);
meshes.reserve(nMeshes);
}
else if (words[0] == "joints")
{
// TODO this parser is bullshit
enforce(words[1] == "{");
mode = ParserMode.joints;
}
else if (words[0] == "mesh")
{
enforce(words[1] == "{");
meshes ~= new Mesh();
mode = ParserMode.meshes;
}
break;
case ParserMode.joints:
if (words[0] == "}")
{
enforce(joints.length == nJoints, "wrong number of joints");
mode = ParserMode.open;
}
else
{
enforce(words[0][0] == '"', "joint syntax error 0");
enforce(words[0][$-1] == '"', "joint syntax error 1");
enforce(words[2] == "(", "joint syntax error 2");
enforce(words[6] == ")", "joint syntax error 3");
enforce(words[7] == "(", "joint syntax error 4");
enforce(words[11] == ")", "joint syntax error 5");
quat orient = quat(
0f,
to!float(words[8]),
to!float(words[9]),
to!float(words[10]));
orient.computeUnitQuatW();
vec3 pos = vec3(
to!float(words[3]),
to!float(words[4]),
to!float(words[5]));
Joint joint = Joint(to!int(words[1]), pos, orient);
if (joint.parentIndex >= 0)
{
Ray parentBone = joints[joint.parentIndex].ray;
// I used to do this, because you do it for md5anim, but looking at io_scene_md5.py
// MD5 exporter for blender, it looks like the joints{} block in the .md5mesh, providing
// the "bind pose," each bone is already expressed in object space, so there is no reason
// to compose it with the transform of its parent, down to the root bone.
// joint.ray.pos = parentBone.pos + (parentBone.orient * joint.ray.pos);
// joint.ray.orient = parentBone.orient * joint.ray.orient;
// joint.ray.orient.normalize();
}
namedJoints[words[0][1..$-1]] = joints.length;
joints ~= joint;
}
break;
case ParserMode.meshes:
if (words[0] == "}")
{
//enforce(meshes.length == nMeshes, "wrong number of meshes");
mode = ParserMode.open;
}
else if (words[0] == "shader")
{
//string textureFilename = dir ~ words[1][1..$-1];
string textureFilename = words[1][1..$-1];
auto materialTexture = new MaterialTexture();
materialTexture.application = TextureApplication.Color;
auto material = new Material();
if (textureFilename == "Framebuffer")
{
materialTexture.texture = main.marioTex;
material.amb = 1.0;
}
else
{
materialTexture.texture = getTexture(textureFilename);
material.amb = 0.2;
}
material.texes ~= materialTexture;
meshes[$-1].material = material;
}
else if (words[0] == "numverts")
{
meshes[$-1].numVerts = to!uint(words[1]);
meshes[$-1].verts.reserve(meshes[$-1].numVerts);
}
else if (words[0] == "vert")
{
enforce(to!int(words[1]) == meshes[$-1].verts.length, "mesh vertices out of order");
enforce(words[2] == "(", "vert syntax error 0");
enforce(words[5] == ")", "vert syntax error 1");
Vert vert = Vert(
vec2(to!float(words[3]),
to!float(words[4])), // uv
to!uint(words[6]), // Vert.weightIndex
to!uint(words[7])); // Vert.numWeights
meshes[$-1].verts ~= vert;
}
else if (words[0] == "numtris")
{
meshes[$-1].numTris = to!size_t(words[1]);
meshes[$-1].tris.reserve(meshes[$-1].numTris);
}
else if (words[0] == "tri")
{
enforce(to!size_t(words[1]) == meshes[$-1].tris.length, "mesh tris out of order");
Tri tri = Tri(to!uint(words[2]),
to!uint(words[3]),
to!uint(words[4]));
meshes[$-1].tris ~= tri;
}
else if (words[0] == "numweights")
{
meshes[$-1].numWeights = to!size_t(words[1]);
meshes[$-1].weights.reserve(meshes[$-1].numWeights);
}
else if (words[0] == "weight")
{
enforce(to!size_t(words[1]) == meshes[$-1].weights.length, "mesh weights out of order");
enforce(words[4] == "(", "mesh weight syntax error 0");
enforce(words[8] == ")", "mesh weight syntax error 1");
Weight weight = Weight(to!size_t(words[2]),
to!float(words[3]),
to!float(words[5]),
to!float(words[6]),
to!float(words[7]));
meshes[$-1].weights ~= weight;
}
break;
default:
assert(0, "internal error");
}
}
debug
{
//writeln(joints);
//writeln(meshes);
}
auto weightInfo = getWeightingInfo();
if (weightInfo.length > 4)
writeln("[warning] some vertices have too many weights: ", filename, ": ", getWeightingInfo());
}
static vec3[] vertPosBuf;
static const(const(vec4)[]) someColors = [
vec4(1,0,0,1)
, vec4(0,1,0,1)
, vec4(0,0,1,1)
, vec4(1,1,0,1)
, vec4(1,0,1,1)
, vec4(0,1,1,1)
];
void render(mat4 mvmat, mat4 pmat, Ray[] skeleton, vec4 color=vec4(1,1,1,1))
{
foreach (iMesh, mesh; meshes)
{
if (vertPosBuf.length < mesh.verts.length)
{
vertPosBuf.length = mesh.verts.length;
}
/* Calculate mesh vertex positions from animation weight positions */
foreach (vi; 0..mesh.verts.length)
{
Vert vert = mesh.verts[vi];
Weight[] weights = mesh.weights[vert.weightIndex .. vert.weightIndex + vert.numWeights];
vec3 pos = vec3(0,0,0);
foreach (weight; weights)
{
auto joint = skeleton[weight.jointIndex];
pos += (joint.orient * weight.pos + joint.pos) * weight.weightBias;
// Or do it with matrices
//pos += (vec4(weight.pos,1) *
// (mat4.translation(joint.pos.x, joint.pos.y, joint.pos.z)
// * joint.orient.to_matrix!(4,4))
// ).xyz * weight.weightBias;
}
vertPosBuf[vi] = pos;
}
/* Calculate and accumulate triangle normals */
foreach (ti, tri; mesh.tris)
{
auto vi0 = tri.vi[0],
vi1 = tri.vi[1],
vi2 = tri.vi[2];
auto v0 = vertPosBuf[vi0],
v1 = vertPosBuf[vi1],
v2 = vertPosBuf[vi2];
/* Calculate triangle's normal */
auto normal = cross(v2-v0, v1-v0);
}
/* Draw some triangular outlines */
lines.Vert lineVerts[6] = [
lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
];
foreach (tri; mesh.tris)
{
lineVerts[0].pos = vertPosBuf[tri.vi[0]];
lineVerts[1].pos = vertPosBuf[tri.vi[1]];
lineVerts[2].pos = vertPosBuf[tri.vi[1]];
lineVerts[3].pos = vertPosBuf[tri.vi[2]];
lineVerts[4].pos = vertPosBuf[tri.vi[2]];
lineVerts[5].pos = vertPosBuf[tri.vi[0]];
lines.drawLines(lineVerts[]);
}
lines.draw(mvmat, pmat, 2);
}
}
}
T sq(T)(T v)
{
return v*v;
}
private struct LoadingBone
{
int parentIndex;
uint componentBits;
int firstComponentIndex;
}
class MD5Animation
{
MD5Model model;
size_t numFrames;
uint frameRate; // frames per second
size_t frameStride; // number of joints in animation
Joint[] animation;
size_t numJoints;
static ulong interpolatedSkeletonTime;
static Ray[] interpolatedSkeleton;
static bool optRenderFull = true;
static bool optRenderSoftware;
static bool optRenderWireframe;
static bool optRenderJoints;
static bool optRenderVerts;
static bool optRenderWeights;
/* t is provided in hecto-nano seconds */
void calculateFrame(ulong t, ref size_t frameNumber0, ref size_t frameNumber1, ref float tween)
{
frameNumber0 = (t * cast(ulong)frameRate / 10_000_000) % numFrames;
frameNumber1 = (frameNumber0 + 1) % numFrames;
tween = t * frameRate % 10_000_000 / 10_000_000f;
}
// Bone/joint position+orientation for the "base frame." The "base frame" contains all the default
// values for each component in the position and orientation of any bone in any frame. Which components
// are derived from these default values and which are animated, or derived from frame{} block data,
// is specified in the "flags" field, called LoadingBone.componentBits here.
Ray[] baseframeBones;
// These are the position+orientation for each bone in each frame. This information is derived both
// from frame{} blocks and even sometimes the baseframe{} block. See baseframeBones for more.
Ray[] frameBones;
this(MD5Model model, string filename)
{
LoadingBone[] loadingBones;
float[] frameAnimatedComponents;
size_t numAnimatedComponents;
size_t loadingFrameNumber;
this.model = model;
int mode = 0;
//auto animationAppender = appender(animation);
foreach (lineNo, line; splitLines(to!string(cast(char[])file.read(filename))))
{
auto words = split(line);
if (words.length > 0)
switch (mode)
{
case ParserMode.open:
if (words[0] == "MD5Version")
{
assert(to!int(words[1]) == 10);
}
else if (words[0] == "commandline")
{
// do nothing
}
else if (words[0] == "numFrames")
{
numFrames = to!size_t(words[1]);
}
else if (words[0] == "numJoints")
{
numJoints = to!size_t(words[1]);
enforce(numJoints == model.joints.length, "animation joint count does not equal model joint count");
baseframeBones.reserve(numJoints);
}
else if (words[0] == "frameRate")
{
frameRate = to!uint(words[1]);
}
else if (words[0] == "numAnimatedComponents")
{
numAnimatedComponents = to!size_t(words[1]);
// TODO FIXME
enforce(numAnimatedComponents % 6 == 0, "numAnimatedComponents: only multiples of 6 supported");
// XXX this seems like a good time to reserve
// some memory though it may not be ideal
// for all MD5 files
loadingBones.reserve(numJoints);
frameAnimatedComponents.reserve(numJoints * numAnimatedComponents);
}
else if (words[0] == "hierarchy")
{
enforce(words[1] == "{");
mode = ParserMode.joints;
}
else if (words[0] == "bounds")
{
enforce(words[1] == "{");
mode = ParserMode.bounds;
}
else if (words[0] == "baseframe")
{
enforce(words[1] == "{");
mode = ParserMode.baseframe;
}
else if (words[0] == "frame")
{
//writefln("animation.length: %d, frame # %d", animation.length, to!size_t(words[1]));
//enforce(to!size_t(words[1]) == animation.length, "frames out of order");
enforce(words[2] == "{");
loadingFrameNumber = to!int(words[1]);
frameAnimatedComponents.length = 0;
mode = ParserMode.frame;
}
break;
case ParserMode.joints:
if (words[0] == "}")
{
enforce(loadingBones.length == numJoints, "numJoints and hierarchy mismatch");
mode = ParserMode.open;
}
else
{
loadingBones ~= LoadingBone(
to!int(words[1]),
to!uint(words[2]),
to!int(words[3]));
}
break;
case ParserMode.bounds:
if (words[0] == "}")
{
// TODO sanity check
mode = ParserMode.open;
}
break;
case ParserMode.baseframe:
if (words[0] == "}")
{
// TODO sanity check
mode = ParserMode.open;
}
else
{
enforce(words[0] == "(", "baseframe syntax error 0");
enforce(words[4] == ")", "baseframe syntax error 1");
enforce(words[5] == "(", "baseframe syntax error 2");
enforce(words[9] == ")", "baseframe syntax error 3");
baseframeBones ~= Ray(
to!float(words[1]),
to!float(words[2]),
to!float(words[3]),
to!float(words[6]),
to!float(words[7]),
to!float(words[8]));
}
break;
case ParserMode.frame:
if (words[0] == "}")
{
enforce(frameAnimatedComponents.length == numAnimatedComponents,
"frame{} block has wrong number of elements");
foreach (boneIndex, loadingBone; loadingBones)
{
size_t animatedComponentIndex = 0;
//enforce(animatedComponentIndex == loadingBone.firstComponentIndex,
// "got bad animated component ordering data from hierarchy{} block");
Ray bone = baseframeBones[boneIndex];
if (loadingBone.componentBits & 1)
bone.pos.x = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
if (loadingBone.componentBits & 2)
bone.pos.y = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
if (loadingBone.componentBits & 4)
bone.pos.x = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
if (loadingBone.componentBits & 8)
bone.orient.x = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
if (loadingBone.componentBits & 16)
bone.orient.y = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
if (loadingBone.componentBits & 32)
bone.orient.z = frameAnimatedComponents[loadingBone.firstComponentIndex + animatedComponentIndex++];
// Normalize orientation quaternion
computeUnitQuatW(bone.orient);
// Reposition and reorient bone relative to its parent, unless it is the root bone
if (loadingBone.parentIndex >= 0)
{
Ray parentBone = frameBones[loadingFrameNumber*numJoints + loadingBone.parentIndex];
bone.pos = parentBone.pos + (parentBone.orient * bone.pos);
bone.orient = parentBone.orient * bone.orient;
bone.orient.normalize();
}
// Add bone to the animation
frameBones ~= bone;
}
mode = ParserMode.open;
}
else
{
//writeln("animationAppender.put()");
//animationAppender.put(map!(to!float)(words));
// TODO FIXME
enforce(words.length == 6, "only 6 components per frame{} block lines supported");
frameAnimatedComponents ~= to!float(words[0]);
frameAnimatedComponents ~= to!float(words[1]);
frameAnimatedComponents ~= to!float(words[2]);
frameAnimatedComponents ~= to!float(words[3]);
frameAnimatedComponents ~= to!float(words[4]);
frameAnimatedComponents ~= to!float(words[5]);
}
break;
default:
writefln("internal error: unknown parse mode: %d", mode);
assert(0, "internal error");
}
}
debug
{
//writeln(animation);
}
}
void renderSkeleton(mat4 mvmat, mat4 pmat)
{
/* TODO draw joint positions? draw joint axes? */
// Draw bones
lines.Vert[2] verts = [
lines.Vert(vec3(0,0,0), vec4(1,0,1,1))
, lines.Vert(vec3(0,0,0), vec4(1,0,1,1))
];
foreach(boneIndex, bone; interpolatedSkeleton)
{
auto parentIndex = model.joints[boneIndex].parentIndex;
if (parentIndex != -1)
{
verts[0].pos = bone.pos;
Ray parentBone = interpolatedSkeleton[parentIndex];
verts[1].pos = parentBone.pos;
lines.drawLines(verts[]);
}
}
lines.draw(mvmat, pmat, 3);
}
/* Right now, render() just renders the outline of each triangle, and will draw
* them in up to six different colors, one for each mesh.
*/
static vec3[] vertPosBuf;
static const(const(vec4)[]) someColors = [
vec4(1,0,0,1)
, vec4(0,1,0,1)
, vec4(0,0,1,1)
, vec4(1,1,0,1)
, vec4(1,0,1,1)
, vec4(0,1,1,1)
];
void render(mat4 mvmat, mat4 pmat, Ray[] skeleton, vec4 color=vec4(1,1,1,1))
{
foreach (iMesh, mesh; model.meshes)
{
if (vertPosBuf.length < mesh.verts.length)
{
vertPosBuf.length = mesh.verts.length;
}
/* Calculate mesh vertex positions from animation weight positions */
foreach (vi; 0..mesh.verts.length)
{
Vert vert = mesh.verts[vi];
Weight[] weights = mesh.weights[vert.weightIndex .. vert.weightIndex + vert.numWeights];
vec3 pos = vec3(0,0,0);
foreach (weight; weights)
{
auto joint = skeleton[weight.jointIndex];
pos += (joint.orient * weight.pos + joint.pos) * weight.weightBias;
// Or do it with matrices
//pos += (vec4(weight.pos,1) *
// (mat4.translation(joint.pos.x, joint.pos.y, joint.pos.z)
// * joint.orient.to_matrix!(4,4))
// ).xyz * weight.weightBias;
}
vertPosBuf[vi] = pos;
}
/* Calculate and accumulate triangle normals */
foreach (ti, tri; mesh.tris)
{
auto vi0 = tri.vi[0],
vi1 = tri.vi[1],
vi2 = tri.vi[2];
auto v0 = vertPosBuf[vi0],
v1 = vertPosBuf[vi1],
v2 = vertPosBuf[vi2];
/* Calculate triangle's normal */
auto normal = cross(v2-v0, v1-v0);
}
/* Draw some triangular outlines */
lines.Vert lineVerts[6] = [
lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
, lines.Vert(vec3(0,0,0), someColors[iMesh % someColors.length])
];
foreach (tri; mesh.tris)
{
lineVerts[0].pos = vertPosBuf[tri.vi[0]];
lineVerts[1].pos = vertPosBuf[tri.vi[1]];
lineVerts[2].pos = vertPosBuf[tri.vi[1]];
lineVerts[3].pos = vertPosBuf[tri.vi[2]];
lineVerts[4].pos = vertPosBuf[tri.vi[2]];
lineVerts[5].pos = vertPosBuf[tri.vi[0]];
lines.drawLines(lineVerts[]);
}
lines.draw(mvmat, pmat, 2);
}
}
// renderGPU()
mat4[] boneMatrices;
bool gpuInitialized;
GLint mvmatUniloc;
GLint pmatUniloc;
GLint boneMatricesUniloc;
GLint colorMapUniloc;
GLint ambUniloc;
GLint uvAttloc;
GLint normalAttloc;
GLint boneIndicesAttloc;
GLint weightBiasesAttloc;
GLint weightPosAttloc;
GLint indBuf;
/* GL Buffer Objects to hold vertex attributes and face indices. One per mesh. */
GLuint[] vbo;
GLuint[] ibo;
void renderGPU(mat4 mvmat, mat4 pmat, vec4 color=vec4(1,1,1,1))
{
initGPU();
/* Create our array of bone matrices describing the armature/skeleton */
/* Resize if necessary the array we reuse for storing bone matrices */
if (boneMatrices.length < numJoints)
boneMatrices.length = numJoints;
/* Calculate the value of each bone matrix */
foreach (iBone, bone; interpolatedSkeleton[0..numJoints])
boneMatrices[iBone] = bone.orient.to_matrix!(4,4).translate(bone.pos.x, bone.pos.y, bone.pos.z);
/* Select our shader program */
md5ShaderProgram.use();
/* Send our uniforms to the GL shader program */
/* Send our bone matrices */
glUniformMatrix4fv(boneMatricesUniloc, cast(GLint)numJoints, GL_TRUE, cast(float*)boneMatrices.ptr);
glErrorCheck("sent bone matrices");
/* Send model-view matrix */
glUniformMatrix4fv(mvmatUniloc, 1, GL_TRUE, mvmat.value_ptr);
glErrorCheck("sent mvmat uniform");
/* Send projection matrix */
glUniformMatrix4fv(pmatUniloc, 1, GL_TRUE, pmat.value_ptr);
glErrorCheck("sent pmat uniform");
/* Send draw command for each mesh! */
foreach (iMesh, mesh; model.meshes)
{
/* Select our GL buffer object containing our vertex data */
glBindBuffer(GL_ARRAY_BUFFER, vbo[iMesh]);
glErrorCheck("md5 1");
if (ambUniloc >= 0)
glUniform1f(ambUniloc, mesh.material.amb);
/* Enable our vertex attributes */
// TODO Use VAO
if (uvAttloc >= 0)
glEnableVertexAttribArray(uvAttloc);
if (normalAttloc >= 0)
glEnableVertexAttribArray(normalAttloc);
glEnableVertexAttribArray(boneIndicesAttloc+0);
glEnableVertexAttribArray(weightBiasesAttloc);
glEnableVertexAttribArray(weightPosAttloc+0);
glEnableVertexAttribArray(weightPosAttloc+1);
glEnableVertexAttribArray(weightPosAttloc+2);
glEnableVertexAttribArray(weightPosAttloc+3);
GPUVert VT;
/* Specify our vertex attribute layout (actual data in VBO already) */
foreach (i; 0..4)
glVertexAttribPointer(weightPosAttloc+i, 4, GL_FLOAT, GL_FALSE, VT.sizeof,
cast(void*) (VT.weightPos.offsetof + (i * VT.weightPos[0].sizeof)));
glVertexAttribPointer(weightBiasesAttloc, 4, GL_FLOAT, GL_FALSE, VT.sizeof,
cast(void*) VT.weightBiases.offsetof);
glVertexAttribPointer(boneIndicesAttloc, 4, GL_FLOAT, GL_FALSE, VT.sizeof,
cast(void*) VT.boneIndices.offsetof);
if (uvAttloc >= 0)
glVertexAttribPointer(uvAttloc, 2, GL_FLOAT, GL_FALSE, VT.sizeof,
cast(void*) VT.uv.offsetof);
if (normalAttloc >= 0)
glVertexAttribPointer(normalAttloc, 3, GL_FLOAT, GL_FALSE, VT.sizeof,
cast(void*) VT.normal.offsetof);
/* Set texture sampler for color map TODO use Material better! */
if (colorMapUniloc >= 0)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh.material.texes[0].texture);
glUniform1i(colorMapUniloc, 0);
}
glErrorCheck("md5 9.1");
/* Draw! */
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo[iMesh]);
glErrorCheck("md5 9");
glDrawElements(GL_TRIANGLES, cast(int)(mesh.numTris*3), GL_UNSIGNED_INT, cast(void*)0);
glErrorCheck("md5 10");
}
/* Release XXX */
/* Release vert attributes */
if (uvAttloc >= 0)
glDisableVertexAttribArray(uvAttloc);
if (normalAttloc >= 0)
glDisableVertexAttribArray(normalAttloc);
glDisableVertexAttribArray(boneIndicesAttloc);
glDisableVertexAttribArray(weightBiasesAttloc);
glDisableVertexAttribArray(weightPosAttloc+0);
glDisableVertexAttribArray(weightPosAttloc+1);
glDisableVertexAttribArray(weightPosAttloc+2);
glDisableVertexAttribArray(weightPosAttloc+3);
/* Disable the buffer objects we've used */
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
/* Unset texture samplers TODO use Material better! */
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glErrorCheck("renderGPU finished");
}
bool initGPUDone;
void initGPU()
{
if (initGPUDone)
return;
/* Calculate normals for each weight. A "weight" in MD5 parlance is a bone-space
* vertex. To calculate the position of a vertex in the mesh, we must calculate
* a bone space for each bone, transform each weight into this space, and then
* calculated a weighted average of each weight corresponding to a given vertex.
* I'm going to try to do the same now with vertex normals.
*/
/* Generate needed buffers */
/* Vertex buffer objects for each mesh */
vbo.length = model.meshes.length;
/* Index buffer objects for face indices */
ibo.length = vbo.length;
/* Create buffer objects for both vertex data and face data */
glGenBuffers(cast(GLint)vbo.length, vbo.ptr);
glGenBuffers(cast(GLint)ibo.length, ibo.ptr);
glErrorCheck("glGenBuffers()");
GPUVert[] data;
foreach (iMesh, mesh; model.meshes)
{
if (data.length < mesh.verts.length)
data.length = mesh.verts.length;
/* TODO Calculate weight normals */
model.generateBindPose(iMesh, true);
foreach (iVert, vert; mesh.verts)
{
GPUVert v;
v.uv = vec2(vert.uv.x, vert.uv.y);
v.normal = MD5Model.bindPoseVerts[iVert].normal;
foreach (iWeight; 0..4)
{
if (iWeight < vert.numWeights)
{
auto weight = mesh.weights[vert.weightIndex + iWeight];
//writefln("vert %d weight %d joint %d", iVert, iWeight, weight.jointIndex);
v.boneIndices [iWeight] = cast(uint)weight.jointIndex;
v.weightBiases[iWeight] = cast(float)weight.weightBias;
v.weightPos [iWeight] = vec4(weight.pos.x, weight.pos.y, weight.pos.z, 1f);
}
else
{
v.boneIndices [iWeight] = 0f;
v.weightBiases[iWeight] = 0f;
v.weightPos [iWeight] = vec4(0,0,0,0);
}
}
data[iVert] = v;
}
/* Send vertex attributes to its GL Buffer Object */
/* Create the buffer object in the GL */
glBindBuffer(GL_ARRAY_BUFFER, vbo[iMesh]);
/* Fill the buffer object with our data */
//writeln("vbo data: ");
version (debugMD5)
{
static if (0)
foreach(v; data) if (v.pad.x == 1f) writefln(`
weight 0 pos: %s
weight 1 pos: %s
weight 2 pos: %s
weight 3 pos: %s
weight biases: %s
weight indices: %s
uv: %s
pad: %s`,
v.weightPos[0],
v.weightPos[1],
v.weightPos[2],
v.weightPos[3],
v.weightBiases,
v.boneIndices,
v.uv, v.pad);
GLint maxVA;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVA);
writefln("%d %d-byte triangles %d bytes tota (%d max!): %s",
mesh.tris.length, Tri.sizeof, Tri.sizeof * mesh.tris.length, maxVA, mesh.tris);
}
glBufferData(GL_ARRAY_BUFFER, mesh.verts.length * data[0].sizeof, data.ptr, GL_STATIC_DRAW);
/* Send face index data to its GL Buffer Object */
/* Create the buffer object in the GL */
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo[iMesh]);
/* Fill the buffer object with our data */
glBufferData(GL_ELEMENT_ARRAY_BUFFER, Tri.sizeof * mesh.tris.length, mesh.tris.ptr, GL_STATIC_DRAW);
glErrorCheck("md5 end of initGPU()");
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
/* Grab shader variable locations */
mvmatUniloc = md5ShaderProgram.getUniformLocation("viewMatrix");
pmatUniloc = md5ShaderProgram.getUniformLocation("projMatrix");
boneMatricesUniloc = md5ShaderProgram.getUniformLocation("boneMatrices");
colorMapUniloc = md5ShaderProgram.getUniformLocation("colorMap");
ambUniloc = md5ShaderProgram.getUniformLocation("ambU");
uvAttloc = md5ShaderProgram.getAttribLocation ("uvV");
normalAttloc = md5ShaderProgram.getAttribLocation ("normalV");
boneIndicesAttloc = md5ShaderProgram.getAttribLocation ("boneIndices");
weightBiasesAttloc = md5ShaderProgram.getAttribLocation ("weightBiases");
weightPosAttloc = md5ShaderProgram.getAttribLocation ("weightPos[0]");
assert(mvmatUniloc >= 0);
assert(pmatUniloc >= 0);
assert(boneMatricesUniloc >= 0);
//assert(colorMapUniloc >= 0);
//assert(uvAttloc >= 0);
assert(boneIndicesAttloc >= 0);
assert(weightBiasesAttloc >= 0);
assert(weightPosAttloc >= 0);
glErrorCheck("initGPU finished");
initGPUDone = true;
}
void renderVerts(mat4 mvmat, mat4 pmat)
{
size_t frameNumber, frameNumber1;
float tween;
foreach (mesh; model.meshes)
{
foreach (tri; mesh.tris)
{
vec3[3] outVerts;
foreach (outVertI, vi; tri.vi)
{
outVerts[outVertI] = vec3(0, 0, 0);
Vert vert = mesh.verts[vi];
Weight[] weights = mesh.weights[vert.weightIndex .. vert.weightIndex + vert.numWeights];
foreach (weight; weights)
{
auto joint = interpolatedSkeleton[weight.jointIndex];
outVerts[outVertI] += (joint.orient * weight.pos + joint.pos) * weight.weightBias;
}
}
vertexer.add(outVerts[0], vec2(0,0), vec3(0,0,0), vec3(.2,.2,1));
vertexer.add(outVerts[1], vec2(1,1), vec3(1,1,1), vec3(.2,.2,1));
vertexer.add(outVerts[2], vec2(2,2), vec3(2,2,2), vec3(.2,.2,1));
vertexer.add(outVerts[0], vec2(0,0), vec3(0,0,0), vec3(.2,.2,1));
}
vertexer.draw(shaderProgram, mvmat, pmat, mesh.material, GL_LINES);
}
}
void draw(mat4 mvmat, mat4 pmat, ulong t, vec4 color=vec4(1,1,1,1))
{
if (vertexer is null)
{
vertexer = new Vertexer();
emptyMaterial = new Material();
shaderProgram = new ShaderProgram("vert.glsl", "frag-red.glsl");
shaderProgram1 = new ShaderProgram("vert-color3-uv2--color3-uv2.glsl", "frag-color3-uv2.glsl");
md5ShaderProgram = new ShaderProgram("vert-md5.glsl", "frag-md5.glsl");
}
calculateInterpolatedSkeleton(t);
if (optRenderFull)
{
if (optRenderSoftware)
render(mvmat, pmat, interpolatedSkeleton, color);
else
renderGPU(mvmat, pmat, color);
}
static if (0)
if (optRenderWeights)
{
glDisable(GL_DEPTH_TEST);
glPointSize(5f);
renderWeights(mvmat, pmat);
glPointSize(1f);
glEnable(GL_DEPTH_TEST);
}
if (optRenderWireframe)
renderSkeleton(mvmat, pmat);
if (optRenderVerts)
renderVerts(mvmat, pmat);
}
/* We can store an interpolated skeleton (a slice of frameBones) here, allowing us to
* avoid recalculating a given skeleton, and also providing a place in memory to store
* it, sans alloca.
*/
void calculateInterpolatedSkeleton(ulong t)
{
if (interpolatedSkeletonTime == t)
return;
size_t f0, f1;
float f01;
calculateFrame(t, f0, f1, f01);
if (interpolatedSkeleton.length < numJoints)
interpolatedSkeleton.length = numJoints;
foreach (iBone; 0..numJoints)
{
auto b0 = frameBones[f0 * numJoints + iBone];
auto b1 = frameBones[f1 * numJoints + iBone];
interpolatedSkeleton[iBone].pos = lerp(b0.pos, b1.pos, f01);
interpolatedSkeleton[iBone].orient = lerp(b0.orient, b1.orient, f01); // TODO use slerp!
}
interpolatedSkeletonTime = t;
}
}
/* TODO animation sequences instead of just looping the same animation */
class MD5Animator
{
MD5Animation anim;
ulong start; // hnsecs!
this(MD5Animation anim)
{
this.anim = anim;
this.start = GameTime.gt;
}
void draw(mat4 mvmat, mat4 pmat, vec4 color=vec4(1,1,1,1))
{
anim.draw(mvmat, pmat, GameTime.gt-start, color);
}
/* This is a little bypass that allows us to calculate an interpolated skeleton
* without skinning or rendering the model. This is convenient if we need to
* get something from the skeleton before rendering, for instance a camera bone
* position.
*/
void calculateInterpolatedSkeleton()
{
anim.calculateInterpolatedSkeleton(GameTime.gt-start);
}
}
void stop() {
writeln("STOP");
}
#version 150
/* MD5 vertex shader */
uniform mat4 viewMatrix, projMatrix;
uniform mat4 boneMatrices[32];
in vec2 uvV;
in vec4 boneIndices;
in vec4 weightBiases;
in vec4 weightPos[4];
in vec3 normalV;
out vec2 uvF;
out vec3 normalF;
mat3 mat423(mat4 m)
{
return mat3(
m[0][0], m[0][1], m[0][2],
m[1][0], m[1][1], m[1][2],
m[2][0], m[2][1], m[2][2]
);
}
void main()
{
vec4 positionObjectSpace;
vec3 normalObjectSpace;
positionObjectSpace =
boneMatrices[int(boneIndices[0])] * weightPos[0] * weightBiases[0] +
boneMatrices[int(boneIndices[1])] * weightPos[1] * weightBiases[1] +
boneMatrices[int(boneIndices[2])] * weightPos[2] * weightBiases[2] +
boneMatrices[int(boneIndices[3])] * weightPos[3] * weightBiases[3];
normalObjectSpace =
(mat423(boneMatrices[int(boneIndices[0])])) * normalV * weightBiases[0] +
(mat423(boneMatrices[int(boneIndices[1])])) * normalV * weightBiases[1] +
(mat423(boneMatrices[int(boneIndices[2])])) * normalV * weightBiases[2] +
(mat423(boneMatrices[int(boneIndices[3])])) * normalV * weightBiases[3];
gl_Position = projMatrix * (viewMatrix * positionObjectSpace);
normalF = normalObjectSpace;
uvF = uvV;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment