Render compiles

include/Entity.h

 
     SkeletalModel &getModel();
     void setSkeletalModel(unsigned int model);
+    MoveType getMoveType();
     void setMoveType(MoveType m);
     int getObjectId();
     void setAngles(vec_t yaw, vec_t pitch);
     vec_t getPos(unsigned int i);
     vec_t getAngle(unsigned int i);
+    int getRoom();
 
     // Animation State
     unsigned int getAnimation();

include/SkeletalModel.h

 
 class BoneTag {
 public:
-    BoneTag();
+    BoneTag(TombRaider &tr, unsigned int index, int j, unsigned int *l);
+    void display();
+
+    void getOffset(vec3_t o);
+    void getRotation(vec3_t r);
+    char getFlag();
 
 private:
     int mesh;
 
 class BoneFrame {
 public:
-    BoneFrame();
+    BoneFrame(TombRaider &tr, unsigned int index, unsigned int i, unsigned int frame_offset);
     ~BoneFrame();
 
     unsigned int size();
 
 class AnimationFrame {
 public:
-    AnimationFrame();
+    AnimationFrame(TombRaider &tr, unsigned int index, unsigned int i, int a);
     ~AnimationFrame();
 
     unsigned int size();
 public:
     SkeletalModel(TombRaider &tr, unsigned int index, unsigned int i, int objectId);
     ~SkeletalModel();
+    void display(unsigned int aframe, unsigned int bframe);
+
     int getId();
     void setPigTail(bool b);
     void setPonyPos(vec_t x, vec_t y, vec_t z, vec_t angle);

src/Entity.cpp

 
 #include "Entity.h"
 #include "main.h"
+#include "Render.h"
 
 #include "games/TombRaider1.h"
 
 }
 
 void Entity::display() {
-    /*
     glPushMatrix();
     glTranslatef(pos[0], pos[1], pos[2]);
     glRotatef(angles[1], 0, 1, 0);
-    getWorld().getSkeletalModel(skeletalModel).display();
+    getWorld().getSkeletalModel(skeletalModel).display(animationFrame, boneFrame);
     glPopMatrix();
-    */
+
+    // Cycle frames
+    if (getRender().getFlags() & Render::fAnimateAllModels) {
+        if (boneFrame < (getModel().get(animationFrame).size() - 1))
+            boneFrame++;
+        else
+            boneFrame = 0;
+    }
 }
 
 void Entity::move(char movement) {

src/Render.cpp

 #include "Render.h"
 #include "utils/strings.h"
 
-bool compareEntites(const void *voidA, const void *voidB)
-{
-    entity_t *a = (entity_t *)voidA, *b = (entity_t *)voidB;
-    vec_t distA, distB;
-
-    if (!a || !b)
-        return false; // error really
-
-    distA = getRender().mViewVolume.getDistToSphereFromNear(a->pos[0],
-            a->pos[1],
-            a->pos[2],
-            1.0f);
-    distB = getRender().mViewVolume.getDistToSphereFromNear(b->pos[0],
-            b->pos[1],
-            b->pos[2],
-            1.0f);
-
-    return (distA < distB);
-}
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-Render::Render()
-{
+Render::Render() {
     mSkyMesh = -1;
     mSkyMeshRotation = false;
     mMode = Render::modeDisabled;
 }
 
 
-Render::~Render()
-{
+Render::~Render() {
     ClearWorld();
 }
 
 
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
 void Render::screenShot(char *filenameBase)
 {
     mTexture.glScreenShot(filenameBase, getWindow().mWidth, getWindow().mHeight);
     return mFlags;
 }
 
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
 
 void Render::loadTexture(unsigned char *image,
         unsigned int width, unsigned int height,
 
 void Render::ClearWorld() {
     mRoomRenderList.clear();
-
-    for (unsigned int i = 0; i < mModels.size(); i++) {
-        if (mModels[i])
-            delete mModels[i];
-    }
-    mModels.clear();
 }
 
 
 
 void Render::clearFlags(unsigned int flags)
 {
-    // _defaults |= flags; // Force removal if it wasn't set
-    mFlags ^= flags;
+    mFlags &= ~flags;
 
     if (flags & Render::fFog)
     {
 
 void Render::display()
 {
-    vec3_t curPos;
-    vec3_t camPos;
-    vec3_t atPos;
-    int index;
-
     switch (mMode)
     {
         case Render::modeDisabled:
             drawLoadScreen();
             return;
         default:
-            ;
+            break;
     }
 
     if (mMode == Render::modeWireframe)
     else
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
-    index = -1;
+    float camOffsetH = 0.0f;
 
-    if (getGame().mLara)
+    switch (getGame().getLara().getMoveType())
     {
-        float yaw;
-        int sector;
-        float camOffsetH = 0.0f;
-
-
-        switch (getGame().mLara->moveType)
-        {
-            case worldMoveType_fly:
-            case worldMoveType_noClipping:
-            case worldMoveType_swim:
-                camOffsetH = 64.0f;
-                break;
-            case worldMoveType_walk:
-            case worldMoveType_walkNoSwim:
-                camOffsetH = 512.0f;
-                break;
-        }
-
-        curPos[0] = getGame().mLara->pos[0];
-        curPos[1] = getGame().mLara->pos[1];
-        curPos[2] = getGame().mLara->pos[2];
-        yaw = getGame().mLara->angles[1];
-
-        index = getGame().mLara->room;
+        case Entity::MoveTypeFly:
+        case Entity::MoveTypeNoClipping:
+        case Entity::MoveTypeSwim:
+            camOffsetH = 64.0f;
+            break;
+        case Entity::MoveTypeWalk:
+        case Entity::MoveTypeWalkNoSwim:
+            camOffsetH = 512.0f;
+            break;
+    }
 
-        // Mongoose 2002.08.24, New 3rd person camera hack
-        camPos[0] = curPos[0];
-        camPos[1] = curPos[1] - camOffsetH; // UP is lower val
-        camPos[2] = curPos[2];
+    vec3_t curPos;
+    vec3_t camPos;
+    vec3_t atPos;
 
-        camPos[0] -= (1024.0f * sinf(yaw));
-        camPos[2] -= (1024.0f * cosf(yaw));
+    curPos[0] = getGame().getLara().getPos(0);
+    curPos[1] = getGame().getLara().getPos(1);
+    curPos[2] = getGame().getLara().getPos(2);
+    vec_t yaw = getGame().getLara().getAngle(1);
 
-        sector = getWorld().getSector(index, camPos[0], camPos[2]);
+    // Mongoose 2002.08.24, New 3rd person camera hack
+    camPos[0] = curPos[0] - (1024.0f * sinf(yaw));
+    camPos[1] = curPos[1] - camOffsetH; // UP is lower val
+    camPos[2] = curPos[2] - (1024.0f * cosf(yaw));
 
-        // Handle camera out of world
-        if (sector < 0 || getWorld().isWall(index, sector))
-        {
-            camPos[0] = curPos[0] + (64.0f * sinf(yaw));
-            camPos[1] -= 64.0f;
-            camPos[2] = curPos[2] + (64.0f * cosf(yaw));
-        }
+    int index = getGame().getLara().getRoom();
+    int sector = getWorld().getSector(index, camPos[0], camPos[2]);
 
-        getCamera().setPosition(camPos);
+    // Handle camera out of world
+    if (sector < 0 || getWorld().isWall(index, sector)) {
+        camPos[0] = curPos[0] + (64.0f * sinf(yaw));
+        camPos[1] -= 64.0f;
+        camPos[2] = curPos[2] + (64.0f * cosf(yaw));
     }
 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
 
     // Setup view in OpenGL with camera
+    getCamera().setPosition(camPos);
     getCamera().update();
-    getCamera().getPosition(camPos);
     getCamera().getTarget(atPos);
     // Mongoose 2002.08.13, Quick fix to render OpenRaider upside down
-
     gluLookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
 
     // Update view volume for vising
     updateViewVolume();
 
-    // Let's see the LoS -- should be event controled
-    if (getGame().mLara)
-    {
-        // SkeletalModel *mdl = getGame().mLara->tmpHook;
-
-        // Draw in solid colors
-        glDisable(GL_TEXTURE_2D);
-        glDisable(GL_CULL_FACE);
-
-        if (getGame().mLara->state == 64) // eWeaponFire
-        {
-            vec3_t u, v; //, s, t;
-
-            // Center of getGame().mLara
-            u[0] = curPos[0];
-            u[1] = curPos[1] - 512.0f;
-            u[2] = curPos[2];
-
-            // Location getGame().mLara is aiming at?  ( Not finished yet )
-            v[0] = u[0] + (9000.0f * sinf(getGame().mLara->angles[1]));
-            v[1] = u[1] + (9000.0f * sinf(getGame().mLara->angles[2]));
-            v[2] = u[2] + (9000.0f * cosf(getGame().mLara->angles[1]));
-
-            // Test tracing of aim
-            renderTrace(0, u, v); // v = target
-        }
-
-        glEnable(GL_CULL_FACE);
-        glEnable(GL_TEXTURE_2D);
-    }
-
     // Render world
     glColor3fv(DIM_WHITE); // was WHITE
     drawSkyMesh(96.0);
     newRoomRenderList(index);
 
     // Room solid pass, need to do depth sorting to avoid 2 pass render
-    for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
-    {
+    for (unsigned int i = 0; i < mRoomRenderList.size(); i++) {
         Room &room = *mRoomRenderList[i];
 
         if (mFlags & Render::fGL_Lights)
-        {
             lightRoom(room);
-        }
 
         room.display(false);
     }
 
     // Draw all visible enities
-    if (mFlags & Render::fEntityModels)
-    {
-        entity_t *e;
-        std::vector<entity_t *> entityRenderList;
-        std::vector<entity_t *> *entities = getWorld().getEntities();
+    if (mFlags & Render::fEntityModels) {
+        std::vector<Entity *> entityRenderList;
 
-        for (unsigned int i = 0; i < entities->size(); i++)
-        {
-            e = entities->at(i);
+        for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
+            Entity &e = getWorld().getEntity(i);
 
-            // Mongoose 2002.03.26, Don't show lara to it's own player
-            if (!e || e == getGame().mLara)
-            {
+            // Don't show Lara to the player
+            if (&e == &getGame().getLara())
                 continue;
-            }
 
             // Mongoose 2002.08.15, Nothing to draw, skip
-            // Mongoose 2002.12.24, Some entities have no animation  =p
-            if (e->tmpHook)
-                if (e->tmpHook->model->animation.empty())
+            // Mongoose 2002.12.24, Some entities have no animation =p
+            if (e.getModel().size() == 0)
                     continue;
 
             // Is it in view volume? ( Hack to use sphere )
-            if (!isVisible(e->pos[0], e->pos[1], e->pos[2], 512.0f))
+            if (!isVisible(e.getPos(0), e.getPos(1), e.getPos(2), 512.0f))
                 continue;
 
             //! \fixme Is it in a room we're rendering?
             //  continue;
             //}
 
-            entityRenderList.push_back(e);
+            entityRenderList.push_back(&e);
         }
 
         // Draw objects not tied to rooms
         glPopMatrix();
 
         // Depth sort entityRenderList with qsort
-        std::sort(entityRenderList.begin(), entityRenderList.end(), compareEntites);
-
-        for (unsigned int i = 0; i < entityRenderList.size(); i++)
-        {
-            e = entityRenderList[i];
+        std::sort(entityRenderList.begin(), entityRenderList.end());
 
-            glPushMatrix();
-            glTranslatef(e->pos[0], e->pos[1], e->pos[2]);
-            glRotatef(e->angles[1], 0, 1, 0);
-            drawModel(e->tmpHook);
-            glPopMatrix();
+        for (unsigned int i = 0; i < entityRenderList.size(); i++) {
+            entityRenderList[i]->display();
         }
     }
 
     // Room alpha pass
     // Skip room alpha pass for modes w/o texture
-    if (!(mMode == Render::modeSolid || mMode == Render::modeWireframe))
-    {
+    if (!(mMode == Render::modeSolid || mMode == Render::modeWireframe)) {
         for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
-        {
             mRoomRenderList[i]->display(true);
-        }
     }
 
     if (mMode == Render::modeWireframe)
 
 void Render::drawSkyMesh(float scale)
 {
-    skeletal_model_t *model = getWorld().getModel(mSkyMesh);
-
-
-    if (!model)
-        return;
+    //skeletal_model_t *model = getWorld().getModel(mSkyMesh);
+    //if (!model)
+    //    return;
 
     glDisable(GL_DEPTH_TEST);
     glPushMatrix();
 }
 
 
-void Render::drawObjects()
-{
+void Render::drawObjects() {
     // Draw lara or other player model ( move to entity rendering method )
-    if (mFlags & Render::fViewModel && getGame().mLara && getGame().mLara->tmpHook)
-    {
-        glPushMatrix();
-
-        glTranslated(getGame().mLara->pos[0], getGame().mLara->pos[1], getGame().mLara->pos[2]);
-        glRotated(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
+    if (mFlags & Render::fViewModel)
+        getGame().getLara().display();
 
-        drawModel(getGame().mLara->tmpHook);
-        glPopMatrix();
-    }
-
-    // Mongoose 2002.03.22, Draw sprites after player to handle alpha
+    // Draw sprites after player to handle alpha
     for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
         SpriteSequence &sprite = getWorld().getSprite(i);
         for (unsigned int j = 0; j < sprite.size(); j++)
 }
 
 
-void Render::drawModel(SkeletalModel *model)
-{
-    animation_frame_t *animation;
-    bone_frame_t *boneframe;
-    bone_frame_t *boneframe2 = 0x0;
-    bone_tag_t *tag;
-    bone_tag_t *tag2;
-    int bframe, aframe;
-    skeletal_model_t *mdl;
-
-
-    if (!model || !model->model)
-        return;
-
-    mdl = model->model;
-    aframe = model->getAnimation();
-    bframe = model->getFrame();
-    animation = mdl->animation[aframe];
-
-    if (!animation)
-    {
-#ifdef DEBUG
-        printf("ERROR: No animation for model[%i].aframe[%i] %lu\n",
-                mdl->id, aframe, mdl->animation.size());
-#endif
-        return;
-    }
-
-    if (animation->frame.empty())
-    {
-#ifdef DEBUG
-        printf("ERROR: No boneframes?!?!  *** %i:%i ***\n",
-                mdl->id, bframe);
-#endif
-        return;
-    }
-
-    boneframe = animation->frame[bframe];
-
-    if (!boneframe)
-        return;
-
-    if (boneframe->tag.empty())
-    {
-        printf("Empty bone frame?!?!\n");
-        return;
-    }
-
-    glTranslatef(boneframe->pos[0], boneframe->pos[1], boneframe->pos[2]);
-
-    for (unsigned int a = 0; a < boneframe->tag.size(); a++)
-    {
-        tag = boneframe->tag[a];
-
-        if (!tag)
-            continue;
-
-        if (a == 0)
-        {
-            if (!equalEpsilon(tag->rot[1], 0.0f)) // was just if (tag->rot[1])
-                glRotatef(tag->rot[1], 0, 1, 0);
-
-            if (!equalEpsilon(tag->rot[0], 0.0f))
-                glRotatef(tag->rot[0], 1, 0, 0);
-
-            if (!equalEpsilon(tag->rot[2], 0.0f))
-                glRotatef(tag->rot[2], 0, 0, 1);
-        }
-        else
-        {
-            if (tag->flag & 0x01)
-                glPopMatrix();
-
-            if (tag->flag & 0x02)
-                glPushMatrix();
-
-            glTranslatef(tag->off[0], tag->off[1], tag->off[2]);
-
-            if (!equalEpsilon(tag->rot[1], 0.0f))
-                glRotatef(tag->rot[1], 0, 1, 0);
-
-            if (!equalEpsilon(tag->rot[0], 0.0f))
-                glRotatef(tag->rot[0], 1, 0, 0);
-
-            if (!equalEpsilon(tag->rot[2], 0.0f))
-                glRotatef(tag->rot[2], 0, 0, 1);
-        }
-
-        // Draw layered lara in TR4 ( 2 meshes per tag )
-        if (mdl->tr4Overlay == 1)
-        {
-            boneframe2 = (mdl->animation[0])->frame[0];
-
-            if (boneframe2)
-            {
-                tag2 = boneframe2->tag[a];
-
-                if (tag2)
-                {
-                    drawModelMesh(getWorld().getMesh(tag2->mesh));
-                }
-            }
-        }
-
-        if (mFlags & Render::fRenderPonytail)
-        {
-            if (mdl->ponytailId > 0 &&
-                    a == 14)
-            {
-                glPushMatrix();
-
-                // Mongoose 2002.08.30, TEST to align offset
-                glTranslatef(mdl->ponytail[0], mdl->ponytail[1], mdl->ponytail[2]);
-                glRotatef(mdl->ponytailAngle, 1, 0, 0);
-
-                // HACK: To fill TR4 void between ponytail/head
-                //   since no vertex welds are implemented yet
-                if (mdl->tr4Overlay == 1)
-                {
-                    glScalef(1.20f, 1.20f, 1.20f);
-                }
-
-#ifdef EXPERIMENTAL_NON_ITEM_RENDER
-                drawModel(mModels[mdl->ponytail], 0, 0);
-#else
-                for (unsigned int i = 0; i < mdl->ponytailNumMeshes; ++i)
-                {
-                    glPushMatrix();
-
-                    if (i > 0)
-                    {
-                        glRotatef(randomNum(-8.0f, -10.0f), 1, 0, 0);
-                        glRotatef(randomNum(-5.0f, 5.0f), 0, 1, 0);
-                        glRotatef(randomNum(-5.0f, 5.0f), 0, 0, 1);
-
-                        glTranslatef(0.0, 0.0, mdl->ponyOff);
-                    }
-
-                    if (mdl->pigtails)
-                    {
-                        glPushMatrix();
-                        glTranslatef(mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
-                        glPopMatrix();
-
-                        glPushMatrix();
-                        glTranslatef(-mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
-                        glPopMatrix();
-                    }
-                    else
-                    {
-                        drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
-                    }
-                }
-
-                for (unsigned int i = 0; i < mdl->ponytailNumMeshes; ++i)
-                {
-                    glPopMatrix();
-                }
-#endif
-                glPopMatrix();
-            }
-        }
-
-        drawModelMesh(getWorld().getMesh(tag->mesh));
-    }
-
-    // Cycle frames ( cheap hack from old ent state based system )
-    if (mFlags & fAnimateAllModels)
-    {
-        if (model->getFrame() + 1 > (int)animation->frame.size()-1)
-        {
-            model->setFrame(0);
-        }
-        else
-        {
-            model->setFrame(model->getFrame()+1);
-        }
-    }
-}
-
-
 void Render::tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri)
 {
     glBegin(GL_TRIANGLES);
 }
 
 
-void Render::addSkeletalModel(SkeletalModel *mdl)
-{
-    mModels.push_back(mdl);
-}
-
-
 void Render::updateViewVolume()
 {
     matrix_t proj;
 bool Render::isVisible(BoundingBox &box) {
     vec3_t bbox[2];
     box.getBoundingBox(bbox);
+
     // For debugging purposes
     if (mMode == Render::modeWireframe)
         box.display(true, PINK, RED);
+
     return mViewVolume.isBboxInFrustum(bbox[0], bbox[1]);
 }
 

src/SkeletalModel.cpp

 #include "SkeletalModel.h"
 
 BoneTag::BoneTag(TombRaider &tr, unsigned int index, int j, unsigned int *l) {
-    tr2_moveable_t *moveable = mTombRaider.Moveable();
-    tr2_meshtree_t *meshtree = mTombRaider.MeshTree();
+    tr2_moveable_t *moveable = tr.Moveable();
+    tr2_meshtree_t *meshtree = tr.MeshTree();
 
     off[0] = 0.0;
     off[1] = 0.0;
     // Setup offsets to produce skeleton
     if (j == 0) {
         // Always push tag[0], this isn't really used either
-        tag->flag = 0x02;
+        flag = 0x02;
     } else { // Nonprimary tag - position relative to first tag
 
         // Hack: moveable[index].mesh_tree is a byte offset
     tr.computeRotationAngles(&frame, &frame_offset, l, rot, rot+1, rot+2);
 }
 
+BoneTag::display() {
+    getRender().drawModelMesh(getWorld().getMesh(mesh));
+}
+
 BoneFrame::BoneFrame(TombRaider &tr, unsigned int index, unsigned int i, unsigned int frame_offset) {
-    tr2_moveable_t *moveable = mTombRaider.Moveable();
-    unsigned short *frame = mTombRaider.Frame();
+    tr2_moveable_t *moveable = tr.Moveable();
+    unsigned short *frame = tr.Frame();
 
     pos[0] = (short)frame[frame_offset + 6];
     pos[1] = (short)frame[frame_offset + 7];
 }
 
 AnimationFrame::AnimationFrame(TombRaider &tr, unsigned int index, unsigned int i, int a) {
-    tr2_moveable_t *moveable = mTombRaider.Moveable();
-    tr2_animation_t *animation = mTombRaider.Animation();
+    tr2_moveable_t *moveable = tr.Moveable();
+    tr2_animation_t *animation = tr.Animation();
 
     unsigned int frame_offset = animation[a].frame_offset / 2;
     int frame_step = animation[a].frame_size;
 }
 
 SkeletalModel::SkeletalModel(TombRaider &tr, unsigned int index, unsigned int i, int objectId) {
-    tr2_moveable_t *moveable = mTombRaider.Moveable();
-    tr2_animation_t *anim = mTombRaider.Animation();
+    tr2_moveable_t *moveable = tr.Moveable();
+    tr2_animation_t *anim = tr.Animation();
 
     id = objectId;
 
     // Gather more info if this is lara
     if (id == 0) {
         // Only TR4 lara has 2 layer bone tags/meshes per bone frame
-        tr4Overlay = (mTombRaider.Engine() == TR_VERSION_4);
+        tr4Overlay = (tr.Engine() == TR_VERSION_4);
         ponytailId = 0;
     } else {
         tr4Overlay = false;
         ponytailId = -1;
     }
 
-    switch (mTombRaider.Engine()) {
+    switch (tr.Engine()) {
         case TR_VERSION_4:
             if (moveable[index].object_id == 30) {
                 ponytailId = getWorld().sizeSkeletalModel(); //! \fixme Why is this even needed?
         delete animation[i];
 }
 
+void SkeletalModel::display(unsigned int aframe, unsigned int bframe) {
+    assert(aframe < size());
+    assert(bframe < get(aframe).size());
+
+    AnimationFrame &animation = get(aframe);
+    BoneFrame &boneframe = animation.get(bframe);
+
+    if (boneframe.size() == 0) {
+        printf("Empty bone frame?!?!\n");
+        return;
+    }
+
+    glTranslatef(boneframe->pos[0], boneframe->pos[1], boneframe->pos[2]);
+
+    for (unsigned int a = 0; a < boneframe.size(); a++) {
+        BoneTag &tag = boneframe.get(a);
+        vec3_t rot, off;
+        tag.getRotation(rot);
+        tag.getOffset(off);
+
+        if (a == 0) {
+            if (!equalEpsilon(rot[1], 0.0f))
+                glRotatef(rot[1], 0, 1, 0);
+
+            if (!equalEpsilon(rot[0], 0.0f))
+                glRotatef(rot[0], 1, 0, 0);
+
+            if (!equalEpsilon(rot[2], 0.0f))
+                glRotatef(rot[2], 0, 0, 1);
+        } else {
+            if (tag.getFlag() & 0x01)
+                glPopMatrix();
+
+            if (tag.getFlag() & 0x02)
+                glPushMatrix();
+
+            glTranslatef(off[0], off[1], off[2]);
+
+            if (!equalEpsilon(rot[1], 0.0f))
+                glRotatef(rot[1], 0, 1, 0);
+
+            if (!equalEpsilon(rot[0], 0.0f))
+                glRotatef(rot[0], 1, 0, 0);
+
+            if (!equalEpsilon(rot[2], 0.0f))
+                glRotatef(rot[2], 0, 0, 1);
+        }
+
+        // Draw layered lara in TR4 (2 meshes per tag)
+        if (tr4Overlay) {
+            BoneFrame &boneframe2 = get(0).get(0); //! \fixme Woot?
+            if (a < boneframe2.size())
+                boneframe2.get(a).display();
+        }
+
+        if (getRender().getFlags() & Render::fRenderPonytail) {
+            if ((mdl->ponytailId > 0) && (a == 14)) {
+                glPushMatrix();
+
+                // Mongoose 2002.08.30, TEST to align offset
+                glTranslatef(ponytail[0], ponytail[1], ponytail[2]);
+                glRotatef(ponytailAngle, 1, 0, 0);
+
+                // HACK: To fill TR4 void between ponytail/head
+                //   since no vertex welds are implemented yet
+                if (tr4Overlay)
+                    glScalef(1.20f, 1.20f, 1.20f);
+
+#ifdef EXPERIMENTAL_NON_ITEM_RENDER
+                getWorld().getSkeletalModel(mdl->ponytail).display(0, 0);
+#else
+                for (unsigned int i = 0; i < ponytailNumMeshes; i++) {
+                    glPushMatrix();
+
+                    if (i > 0) {
+                        glRotatef(randomNum(-8.0f, -10.0f), 1, 0, 0);
+                        glRotatef(randomNum(-5.0f, 5.0f), 0, 1, 0);
+                        glRotatef(randomNum(-5.0f, 5.0f), 0, 0, 1);
+                        glTranslatef(0.0, 0.0, ponyOff);
+                    }
+
+                    if (pigtails) {
+                        glPushMatrix();
+                        glTranslatef(mdl->ponyOff2, 0.0, 0.0);
+                        getRender().drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
+                        glPopMatrix();
+
+                        glPushMatrix();
+                        glTranslatef(-mdl->ponyOff2, 0.0, 0.0);
+                        getRender().drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
+                        glPopMatrix();
+                    } else {
+                        getRender().drawModelMesh(getWorld().getMesh(mdl->ponytailMeshId + i));
+                    }
+                }
+
+                for (unsigned int i = 0; i < ponytailNumMeshes; i++)
+                    glPopMatrix();
+#endif
+                glPopMatrix();
+            }
+        }
+
+        tag.display();
+    }
+}
+
 int SkeletalModel::getId() {
     return id;
 }