spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void AnimatedModel::load(const char* name)
{
  Resource::File file(name, "MODEL");

  const TowerModelFileFormat::Header& header = file.get<TowerModelFileFormat::Header>();

  if (header.magic != TowerModelFileFormat::magic_id)
    throw std::runtime_error("Invalid File Format");

  size_t vertex_count = file.get<TowerModelFileFormat::size_t>();
  vertices.resize(vertex_count);

  for (size_t i = 0; i < vertex_count; ++i)
  {
    const TowerModelFileFormat::Vertex& v = file.get<TowerModelFileFormat::Vertex>();
    vertices[i].pos[0] = v.pos[0];
    vertices[i].pos[1] = v.pos[1];
    vertices[i].pos[2] = v.pos[2];
    vertices[i].n[0] = v.n[0];
    vertices[i].n[1] = v.n[1];
    vertices[i].n[2] = v.n[2];
    vertices[i].t[0] = v.t[0];
    vertices[i].t[1] = v.t[1];
    vertices[i].t[2] = v.t[2];
    vertices[i].b[0] = v.b[0];
    vertices[i].b[1] = v.b[1];
    vertices[i].b[2] = v.b[2];
    vertices[i].texcoord[0] = v.texcoord[0];
    vertices[i].texcoord[1] = v.texcoord[1];
    vertices[i].bone = v.bone;
  }

  size_t face_count = file.get<TowerModelFileFormat::size_t>();
  size_t index_count = 3 * face_count;
  indices.resize(index_count);

  for (size_t i = 0; i < face_count; ++i)
  {
    const TowerModelFileFormat::Face& t = file.get<TowerModelFileFormat::Face>();
    for (int j = 0; j < 3; ++j)
      indices[3 * i + j] = t.v[j];
  }

  size_t material_count = file.get<TowerModelFileFormat::size_t>();
  groups.resize(material_count);

  for (size_t i = 0; i < material_count; ++i)
  {
    const TowerModelFileFormat::Material& material = file.get<TowerModelFileFormat::Material>();
    if (material.texture_name[0] != '\0')
    {
      std::string tex_name = material.texture_name;
      try
      {
        groups[i].diffuse_tex = GL::Texture2D((tex_name + ".diffuse").c_str());
        groups[i].normal_map = GL::Texture2D((tex_name + ".normal").c_str());
      }
      catch (...)
      {
      }
      groups[i].start_index = material.start * 3;
      groups[i].index_count = material.face_count * 3;
    }
  }

  size_t joint_count = file.get<TowerModelFileFormat::size_t>();

  for (size_t i = 0; i < joint_count; ++i)
  {
    const TowerModelFileFormat::Joint& j = file.get<TowerModelFileFormat::Joint>();

    SbRotation rot  = SbRotation(SbVec3f(1.0f, 0.0f, 0.0f), j.rotation[0]);
               rot *= SbRotation(SbVec3f(0.0f, 1.0f, 0.0f), j.rotation[1]);
               rot *= SbRotation(SbVec3f(0.0f, 0.0f, 1.0f), j.rotation[2]);

    SbMatrix mat;
    mat.setTransform(SbVec3f(j.position[0], j.position[1], j.position[2]),
                     rot,
                     SbVec3f(1.0f, 1.0f, 1.0f));

    joints.push_back(Joint(mat, i, j.parent == -1 ? 0 : &joints[j.parent], j.parent));
  }

  size_t anim_count = file.get<TowerModelFileFormat::size_t>();

  for (size_t i = 0; i < anim_count; ++i)
  {
    const TowerModelFileFormat::Animation& anim = file.get<TowerModelFileFormat::Animation>();

    Animation::channel_vector channels(joint_count);

    for (size_t j = 0; j < joint_count; ++j)
    {
      channels[j] = Animation::Channel(file);
    }

    animations.insert(std::make_pair(anim.name, new Animation(*this, channels)));
  }


  for (size_t i = 0; i < vertex_count; ++i)
  {
    if (vertices[i].bone != -1)
    {
      SbVec3f pos;
      const SbMatrix& absolute = joints[vertices[i].bone].bind_absolute();
      SbMatrix inv_absolute = absolute.inverse();
      inv_absolute.multVecMatrix(vertices[i].pos, pos);
      vertices[i].pos = pos;
    }
  }

  vb = GL::VertexBuffer<Vertex>(&vertices[0], vertex_count);
  ib = GL::IndexBuffer<index_t>(&indices[0], index_count);
}

Quellcode

function blablubb(a, b)
{
  c = machirgendwas(a)
  d = tuwasanderes(b)
  e = berechneergebnis(c, d)
  debug(e)

  return e
}