gfxclient/src/GfxAnimesh.C

Go to the documentation of this file.

// $Id: GfxAnimesh.C 7357 2008-08-07 02:38:57Z furtak $

// This is an ORTS file (c) Keith Yerex, licensed under the GPL

#include "GfxGlobal.H"
#include "GameStateModule.H"
#include "GfxAnimesh.H"
#include "GfxModule.H"
#include "CycleCounter.H"
#include "GameObj.H"
#include "Image.H"
#include "Game.H"
#include "MD2.H"
#include "MD3.H"
#include "Profiler.H"

#include "GfxEmitter.H"

#ifndef GCC
static sint4 round(real8 x) { return (sint4)floor(x+0.5); }
#endif

using namespace std;

//===================================================================

map<string, Model::TexPair> Model::textures;
Vector<Vec4<real4> > Model::colors;

map<string, Model*> GfxAnimesh::name2mdl;
map<string, CustomShaderProgram*> GfxAnimesh::name2shader; // modelfile -> shader
CustomShaderProgram* GfxAnimesh::default_shader = 0;
real4 GfxAnimesh::gamma = 1.0; // gamma correct all model textures by this value
sint4 GfxAnimesh::mode = 0;
sint4 GfxAnimesh::texmode = 2;
sint4 GfxAnimesh::texlevel = 0;
GLuint GfxAnimesh::default_shadow_tex = 0;

bool Model::clear_fast = false;
bool Model::verbose_load = false;

//===================================================================

GfxAnimesh::GfxAnimesh(GfxModule &g, const std::string &modelfile, const std::string &texfile,
                       sint4 team, real4 scale, real4 dy)
{
  set_gfxm(g);
  shadow_tex = default_shadow_tex;
  shadow_on = 0;
  shadow_sc = 0.0;

  mdl = 0;
  shader = 0;

  load(modelfile, texfile, team, scale, dy);
}

//===================================================================

void GfxAnimesh::load(const string &modelfile, const string &texfile, sint4 team_,
                      real4 scale_, real4 dy)
{
  PROFILE("GfxAnimesh::load");

  team = team_;
  map<string, Model*>::const_iterator it;

  if ((it = name2mdl.find(modelfile)) != name2mdl.end()) mdl = it->second;
  else {

    string ext;
    size_t p = modelfile.rfind(".");
    if (p != string::npos) {
      ext = modelfile.substr(p+1);
    }

    if (ext == "md3") {
      switch(mode) {
      case 1:  mdl = new MD3_Model; break;
        //case 2:  mdl = new MD3_Model_VB; break;
      default: mdl = new MD3_Model_DL; break;
      }
      
    } else if (ext == "md2"){
      switch(mode) {
      case 1:  mdl = new MD2_Model; break;
      case 2:  mdl = new MD2_Model_VB; break;
      default: mdl = new MD2_Model_DL; break;
      }
    } else {
      ERR2("unknown extension:", modelfile.c_str());
    }
    mdl->load(modelfile, texfile, 100.0, dy, gamma);
    name2mdl[modelfile] = mdl;

    CustomShaderProgram *csp = new CustomShaderProgram;
    if (csp->load(modelfile + ".custom")) {
      name2shader[modelfile] = csp;
    } else {
      ShaderProgram *sp = new ShaderProgram();
      sp->vertex_shader(modelfile + ".vert");
      sp->fragment_shader(modelfile + ".frag");
      if (sp->id()) {
        csp->load(sp);
        name2shader[modelfile] = csp;
      } else {
        delete sp;
        delete csp;
      }
    }
  }

  {
    FIND (name2shader, it2, modelfile);
    if (it2 != name2shader.end()) shader = it2->second;
  }

  centroid = mdl->centroid;
  radius = mdl->radius;
  set_scale(scale_ * 0.01);

  idle.frame = 0;
  idle.first = 0;
  idle.loop_first = 0;
  idle.last = 0;
  idle.fps = 0;
  idle.mode = FrameSet::REPEAT;
  idle.f1 = 0;
  idle.f2 = 0;
  idle.blend = 0.0;

  current.frame = 0;
  current.first = 0;
  current.loop_first = 0;
  current.last = 0;
  current.fps = 0;
  current.mode = FrameSet::STOP;
  current.f1 = 0;
  current.f2 = 0;
  current.blend = 0.0;
}

//===================================================================

GfxAnimesh::~GfxAnimesh()
{
}

//===================================================================

void GfxAnimesh::update(real4 dt)
{
  PROFILE("GfxAnimesh::update");

  if (!current.update(dt)) current = idle;

  assert(mdl);
  if (current.f1 >= (sint4)mdl->bbox.size()) return;

  aabb_o = pose.center + mdl->bbox[current.f1].min * pose.scale;
  aabb_d = (mdl->bbox[current.f1].max - mdl->bbox[current.f1].min) * pose.scale; 

  FORALL (sub_objects, it) (*it)->update(dt);
  FORALL (emitters, it) (*it)->update(dt);

  FORALL (sub_objects_tag, it) (*it).obj->update(dt);
  FORALL (emitters_tag, it) (*it).obj->update(dt);
}

//===================================================================

void GfxAnimesh::beginDraw()
{
  glEnable(GL_BLEND);
  glDisable(GL_LIGHTING);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
  if (glBlendEquationEXT) {
    glBlendEquationEXT(GL_FUNC_ADD_EXT);
  } else {
    glBlendEquation(GL_FUNC_ADD);   
  }
  
  glCullFace(GL_FRONT);

  glActiveTextureARB(GL_TEXTURE0);
  glEnable(GL_TEXTURE_2D);
  glColor4f(1, 1, 1, 1);
}

//-------------------------------------------------------------------

void GfxAnimesh::endDraw()
{
  glDisable(GL_BLEND);
  glActiveTextureARB(GL_TEXTURE0);
  glDisable(GL_TEXTURE_2D);

  glCullFace(GL_BACK);

  glDisable(GL_LIGHTING);
}

//===================================================================

void GfxAnimesh::draw()
{
  PROFILE("GfxAnimesh::draw");

  glerror("GfxAnimesh::draw 0");
  glLoadName(my_id << GfxObject::SUB_ID_LOG);
  
  glPushMatrix();
  apply_pose();

  CustomShaderProgram *prog;
  if (shader) {
    prog = shader;
  } else {
    prog = default_shader;
  }

  if (prog) {

    glActiveTextureARB(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, mdl->tex->team_tex);
    glActiveTextureARB(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, mdl->tex->base_tex);
    glColor4fv(mdl->get_color(team).ptr());

    FORT (i, prog->num_passes()) {
      ShaderProgram *sp = prog->get_pass(i).prog;
      if (!sp || !sp->begin()) continue;
      prog->get_pass(i).setup();

      GLint tex = glGetUniformLocation(sp->id(), "tex");
      //      cout << "tex = " << tex << endl;
      if (tex >= 0) glUniform1i(tex, 0);
      
      GLint shadow = glGetUniformLocation(sp->id(), "shadow");
      if (shadow >= 0) glUniform1i(shadow, 1);
      
      GLint team = glGetUniformLocation(sp->id(), "team");
      if (team >= 0) glUniform1i(team, 2);
      
      GLint ntex = glGetUniformLocation(sp->id(), "ntex");
      if (ntex >= 0) glUniform1i(ntex, 3);

      mdl->draw(current.f1);
      
      sp->end();
    }

  } else {
    
    if (current.first == current.last) {
      mdl->draw(current.first, team);
    } else {
      mdl->draw_interp(current.f1, current.f2, current.blend, team);
    }

  }

  FORALL (sub_objects, it) (*it)->draw();

  FORALL (sub_objects_tag, it) {
    GfxObject *o = (*it).obj;
    sint4 tag_num = (*it).tag_num;
    Mat4<real4> &mat = mdl->tag[tag_num][current.f1].axis;
    o->draw_at(mat);
  }

  glPopMatrix();
  glerror("GfxAnimesh::draw 1");
}

//===================================================================

void GfxAnimesh::draw_emitters()
{
  PROFILE("GfxAnimesh::draw_emitters");

  glerror("GfxObject::draw_emitters 0");

  glPushMatrix();
  apply_pose();

  FORALL (emitters, i) (*i)->draw_emitters();

  //  glScalef(pose.scale, pose.scale, pose.scale);

  FORALL (sub_objects, i) (*i)->draw_emitters();

  FORALL (sub_objects_tag, it) {
    GfxObject *o = (*it).obj;
    sint4 tag_num = (*it).tag_num;
    Mat4<real4> &mat = mdl->tag[tag_num][current.f1].axis;
    o->draw_emitters_at(mat);
  }

  FORALL (emitters_tag, it) {
    GfxObject *o = (*it).obj;
    sint4 tag_num = (*it).tag_num;
    Mat4<real4> &mat = mdl->tag[tag_num][current.f1].axis;
    o->draw_emitters_at(mat);
  }

  glPopMatrix();
  glerror("GfxObject::draw_emitters 1");
}

//===================================================================

void GfxAnimesh::pick()
{
  glerror("GfxAnimesh::pick 0");
  glCullFace(GL_FRONT);
  glLoadName(my_id << GfxObject::SUB_ID_LOG);
  
  glPushMatrix();
  apply_pose();

  mdl->select(current.f1);

  FORALL (sub_objects, it) (*it)->pick();

  FORALL (sub_objects_tag, it) {
    GfxObject *o = (*it).obj;
    sint4 tag_num = (*it).tag_num;
    Mat4<real4> &mat = mdl->tag[tag_num][current.f1].axis;

    glPushMatrix();
    glMultMatrixf(mat.ptr());
    o->pick();
    glPopMatrix();
  }

  glPopMatrix();
  glCullFace(GL_BACK);
  glerror("GfxAnimesh::pick 1");
}

//===================================================================

void GfxAnimesh::draw_shadow()
{
  PROFILE("GfxAnimesh::draw_shadow");

  if (!shadow_on) return;
  glerror("GfxAnimesh::drawshadow 0");
  glPushMatrix();
  apply_pose();

  if (shadow_tex > 0) {

    glColor4f(1, 1, 1, 1);
    glActiveTextureARB(GL_TEXTURE0);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, shadow_tex);
    mdl->draw_shadow(current.f1, shadow_sc);

  } else {

    glColor4f(0, 0, 0, 0.5);
    glActiveTextureARB(GL_TEXTURE1);
    glDisable(GL_TEXTURE_2D);
    glActiveTextureARB(GL_TEXTURE0);
    glDisable(GL_TEXTURE_2D);

    mdl->draw(current.f1);
  }

  FORALL (sub_objects, it) (*it)->draw_shadow();

  FORALL (sub_objects_tag, it) {
    GfxObject *o = (*it).obj;
    sint4 tag_num = (*it).tag_num;
    Mat4<real4> &mat = mdl->tag[tag_num][current.f1].axis;

    glPushMatrix();
    glMultMatrixf(mat.ptr());
    o->draw_shadow();
    glPopMatrix();
  }


  glPopMatrix();
  glerror("GfxAnimesh::drawshadow");
}

//===================================================================

void GfxAnimesh::draw_bbox()
{
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_CULL_FACE);
  glDisable(GL_BLEND);
  
  real4 x0 = aabb_o.x;
  real4 x1 = aabb_o.x + aabb_d.x;
  real4 y0 = aabb_o.y;
  real4 y1 = aabb_o.y + aabb_d.y;
  real4 z0 = aabb_o.z;
  real4 z1 = aabb_o.z + aabb_d.z;
  
  glColor4f(1,1,1,1);
  glBegin(GL_LINES);
  glVertex3f(x0, y0, z0);
  glVertex3f(x0, y0, z1);
  glVertex3f(x0, y1, z0);
  glVertex3f(x0, y1, z1);
  glVertex3f(x1, y0, z0);
  glVertex3f(x1, y0, z1);
  glVertex3f(x1, y1, z0);
  glVertex3f(x1, y1, z1);
  
  glVertex3f(x0, y0, z0);
  glVertex3f(x0, y1, z0);
  glVertex3f(x0, y0, z1);
  glVertex3f(x0, y1, z1);
  glVertex3f(x1, y0, z0);
  glVertex3f(x1, y1, z0);
  glVertex3f(x1, y0, z1);
  glVertex3f(x1, y1, z1);
  
  glVertex3f(x0, y0, z0);
  glVertex3f(x1, y0, z0);
  glVertex3f(x0, y0, z1);
  glVertex3f(x1, y0, z1);
  glVertex3f(x0, y1, z0);
  glVertex3f(x1, y1, z0);
  glVertex3f(x0, y1, z1);
  glVertex3f(x1, y1, z1);
  
  glEnd();
}

//===================================================================

void GfxAnimesh::play(const string &name, real4 fps, sint2 mode, sint2 looping)
{
  pair<sint2,sint2> p = mdl->name2frames[name];
  play(p.first, p.second, fps, mode, looping);
}

//-------------------------------------------------------------------

void GfxAnimesh::play(sint2 start, sint2 end, real4 fps, sint2 mode, sint2 looping)
{
  current.fps = fps;
  current.mode = mode;
  current.first = start;
  if (looping >= 0 && looping < (end-start+1))
    current.loop_first = end - looping + 1;
  else
    current.loop_first = start;
  current.last = end;
  current.is_custom = false;
  if (fps >= 0) {
    current.frame = static_cast<real4>(current.first);
    current.f1 = current.f2 = current.first;
  } else {
    current.frame = static_cast<real4>(current.last) + 0.99;
    current.f1 = current.f2 = current.last;
  }
}

//-------------------------------------------------------------------

void GfxAnimesh::play_custom(const Vector<sint4> &f, real4 fps, sint2 mode)
{
  current.fps = fps;
  current.mode = mode;
  current.set_custom(f);
}

//===================================================================

void GfxAnimesh::set_idle(const string &name, real4 fps, sint2 mode, sint2 looping)
{
  pair<sint2,sint2> p = mdl->name2frames[name];
  
  idle.fps = fps;
  idle.mode = mode;
  idle.first = p.first;
  idle.last = p.second;
  if (looping >= 0 && looping < (idle.last - idle.first + 1))
    idle.loop_first = idle.last - looping + 1;
  else
    idle.loop_first = idle.first;
  idle.is_custom = false;
  if (fps >= 0) {
    idle.frame = static_cast<real4>(idle.first);
    idle.f1 = idle.f2 = idle.first;
  } else {
    idle.frame = static_cast<real4>(idle.last) + 0.99;
    idle.f1 = idle.f2 = idle.last;
  }
}

//===================================================================

void GfxAnimesh::set_frame(const string &name, sint2 frame)
{
  pair<sint2,sint2> p = mdl->name2frames[name];

  current.mode = FrameSet::HALT;
  current.fps = 0;
  current.f1 = frame + p.first;
  current.f2 = frame + p.first;
  current.blend = 0.0;
  current.frame = static_cast<real4>(frame + p.first);
  current.first = p.first;
  current.last  = p.second;
}

//===================================================================

void GfxAnimesh::attachGfxObject_tag(GfxObject *go, const string &tag)
{
  if (!mdl) {
    cout << "no model" << endl;
    return;
  }

  sint4 tag_id = -1;
  FORALL (mdl->tag_name, i) {
    if (*i == tag) {
      tag_id = i-mdl->tag_name.begin();
      break;
    }
  }
  if (tag_id == -1) {
    cout << "no such tag" << endl;
    return;
  }

  GfxTag gt;
  gt.obj = go;
  gt.tag_num = tag_id;

  sub_objects_tag.push_back(gt);
}

//-------------------------------------------------------------------

void GfxAnimesh::attachEmitter_tag(GfxObject *go, const string &tag)
{
  if (!mdl) return;

  sint4 tag_id = -1;
  FORALL (mdl->tag_name, i) {
    if (*i == tag) {
      tag_id = i - mdl->tag_name.begin();
      break;
    }
  }
  if (tag_id == -1) return;

  GfxTag gt;
  gt.obj = go;
  gt.tag_num = tag_id;

  emitters_tag.push_back(gt);
}

//===================================================================

Model::~Model()
{
  delete [] all_tags;
}

//-------------------------------------------------------------------

sint4 Model::load_textures(const string &filename, real4 gamma)
{
  PROFILE("Model::load_textures");

  TexPair &tp = textures[filename];
  tex = &tp;
  if (tp.base_tex) return 1; // already loaded

  // Mesh texture
  string fileTex = filename + ".tga";
  Image imgTex(fileTex.c_str(), gamma);

  // Team colour texture
  string fileTeam = filename + "_color.tga";
  Image imgTeam(fileTeam.c_str(), gamma);
  uint1 *color_data = imgTeam.pixels();
  
  GLuint type;
  
  switch (imgTex.bpp()) {
  case 1:  type = GL_LUMINANCE; break;
  case 3:  type = GL_RGB;       break;
  case 4:  type = GL_RGBA;      break;
  default: ERR("bpp not handled");
  }
  
  //----------------------------------------
tp.base_tex=imgTex.createTexture(static_cast<Image::FILTER>(GfxAnimesh::get_texmode()),
                 GfxAnimesh::get_texlevel());
  
  if (imgTeam.bpp() == 1) { // no alpha for the team color map
    Image aTeam;
    aTeam.empty(imgTeam.width(), imgTeam.height(), 2); // with alpha
    uint1 *adata = aTeam.pixels();
    
    FORU (i, imgTeam.width() * imgTeam.height()) {
      uint1 l = color_data[i];
      adata[i*2] = l;
      adata[i*2+1] = l ? 255 : 0;
    }
    
tp.team_tex=aTeam.createTexture(static_cast<Image::FILTER>(GfxAnimesh::get_texmode()),
                GfxAnimesh::get_texlevel());
    
  } else if (imgTeam.bpp() == 2) {
tp.team_tex=imgTeam.createTexture(static_cast<Image::FILTER>(GfxAnimesh::get_texmode()),
                  GfxAnimesh::get_texlevel());
  } else {
    ERR("invalid color map bpp");
  }
  //----------------------------------------

  return 1;
}

//===================================================================

void FrameSet::set_custom(const Vector<sint4> &v)
{
  frame = 0;
  first = 0;
  loop_first = 0;
  last = v.size() - 1;
  
  is_custom = true;
  custom.clear();
  FORALL (v, i) custom.push_back(*i);
  custom.push_back(custom[0]);
  
  f1 = custom[0];
  f2 = custom[1];
  blend = 0.0;
}

//-------------------------------------------------------------------

bool FrameSet::update(real4 dt)
{
  frame += dt * fps;

  if (frame >= last+1.0 || frame < first) {
      
    switch (mode) {
      
    case FrameSet::STOP:
      return false;
      
    case FrameSet::REPEAT:
      first = loop_first;
      if (first == last) frame = first;
      else {
        if (fps > 0)
          do {
            frame -= (last-first+1);
          } while (frame >= last+1.0);
        else
          do {
            frame += (last-first+1);
          } while (frame < first);
      }
      break;
      
    case FrameSet::MIRROR:
      fps *= -1;
      frame += dt*fps;
      break;
      
    case FrameSet::HALT:
      if (fps > 0) {
        frame = last;
      } else if (fps < 0) {
        frame = first;
      }
      fps = 0;
      break;
    }
  }

  if (fps == 0) {

    f1 = f2 = static_cast<sint2>(frame);
    blend = 0;

  } else if (fps > 0) {

    sint4 f = static_cast<sint4>(floor(frame));
    f1 = f;
    f2 = f+1;
    if (f2 > last) {
      if (mode == FrameSet::REPEAT) {
        f2 = first;
      } else {
        f2 = last;
      }
    }
    blend = frame - f;

  } else {

    //    sint4 f = (sint4)ceil(frame);
    sint4 f = static_cast<sint4>(floor(frame));
    f1 = f;
    f2 = f-1;
    if (f2 < first) {
      if (mode == FrameSet::REPEAT) {
        f2 = last;
      } else {
        f2 = first;
      }
    }
    blend = f - frame;

  }

  if (is_custom) {
    f1 = custom[f1];
    f2 = custom[f2];
  }

  return true;
}

//===================================================================