buffer.cpp

/* Mondschein Engine is a fast, powerful, and easy-to-use 3D realtime rendering engine.
 *
 * Copyright (C) 2009-2013 by Andreas Amereller
 * E-Mail: andreas.amereller.dev@googlemail.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "mbd/buffer.h"
#include "freeimage/buffer.h"
#include <fstream>

using namespace mondschein;
using namespace io;

MBD_Buffer::MBD_Buffer() : Buffer(), version(std::string("MBD\1\0\0",7))
{
  return;
}

MBD_Buffer::MBD_Buffer(MBD_Buffer_c _b) : Buffer(_b), version(std::string("MBD\1\0\0",7))
{
  return;
}

MBD_Buffer::~MBD_Buffer()
{
  return;
}

MBD_Buffer &MBD_Buffer::operator=(MBD_Buffer_c _b)
{
  Buffer::operator=(_b);
  return *this;
}

void MBD_Buffer::parse_istream(std::istream &_in)
{
  std::string file_version;
  for (uint32 i=0; i<6; ++i)
  {
    file_version+=_in.get();
  }
  if (!check_version(file_version))
  {
    std::string err("Mondschein Engine ERROR: MBD version <");
    err+=file_version;
    err+="> not supported by this implementation (up to <";
    err+=version;
    err+=">. Exception raised in function\n\t";
    err+="void mondschein::io::MBD_Buffer::parse_istream(std::istream& _in)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  mbd::data data;
  data.ParseFromIstream(&_in);
  parse_pb(data);
}

void MBD_Buffer::parse_string(const std::string &_in)
{
  std::string file_version;
  for (uint32 i=0; i<6; ++i)
  {
    file_version+=_in.at(i);
  }
  if (!check_version(file_version))
  {
    std::string err("Mondschein Engine ERROR: MBD version <");
    err+=file_version;
    err+="> not supported by this implementation (up to <";
    err+=version;
    err+=">. Exception raised in function\n\t";
    err+="void mondschein::io::MBD_Buffer::parse_istream(std::istream& _in)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  std::string in=_in.substr(6,_in.size()-6);
  mbd::data data;
  data.ParseFromString(in);
  parse_pb(data);
}

void MBD_Buffer::serialize_ostream(std::ostream &_out) const
{

}

void MBD_Buffer::serialize_string(std::string &_out) const
{

}

bool MBD_Buffer::check_version(const std::string &_version) const
{
  if (version<_version) return false;
  else return true;
}

void MBD_Buffer::parse_pb(const mbd::data &_data)
{
  io_objects_t objects;
  for (uint32 c=0; c<_data.cameras_size(); ++c) parse_camera(_data.cameras(c),objects);
  for (uint32 l=0; l<_data.lights_size(); ++l) parse_light(_data.lights(l),objects);
  for (uint32 m=0; m<_data.materials_size(); ++m) parse_material(_data.materials(m),objects);
  for (uint32 m=0; m<_data.meshes_size(); ++m) parse_mesh(_data.meshes(m),objects);
  for (uint32 p=0; p<_data.poses_size(); ++p) parse_pose(_data.poses(p),objects);
  for (uint32 t=0; t<_data.textures_size(); ++t) parse_texture(_data.textures(t),objects);
  for (uint32 sg=0; sg<_data.scenegraphs_size(); ++sg) parse_scenegraph(_data.scenegraphs(sg),objects);
  for (uint32 bc=0; bc<_data.beziercurves_size(); ++bc) parse_beziercurve(_data.beziercurves(bc),objects);
  for (uint32 bp=0; bp<_data.bezierpatches_size(); ++bp) parse_bezierpatch(_data.bezierpatches(bp),objects);
  for (uint32 nc=0; nc<_data.nurbscurves_size(); ++nc) parse_nurbscurve(_data.nurbscurves(nc),objects);
  for (uint32 np=0; np<_data.nurbspatches_size(); ++np) parse_nurbspatch(_data.nurbspatches(np),objects);
  return;
}

void MBD_Buffer::parse_camera(const mbd::data_camera &_pb,io_objects_t &_io)
{
  _io.nodes.insert(std::make_pair(_pb.name(),
                                  scene::Camera_p(new scene::Camera(_pb.name(),scene::camera_attribs_t(_pb.fovy(),_pb.aspect(),_pb.near(),_pb.far(),
                                      _pb.x(),_pb.y(),_pb.w(),_pb.h())))));
  return;
}

void MBD_Buffer::parse_light(const mbd::data_light &_pb,io_objects_t &_io)
{
  Eigen::Vector4d ambient(_pb.ambient().x(),_pb.ambient().y(),_pb.ambient().z(),_pb.ambient().w());
  Eigen::Vector4d diffuse(_pb.diffuse().x(),_pb.diffuse().y(),_pb.diffuse().z(),_pb.diffuse().w());
  Eigen::Vector4d specular(_pb.specular().x(),_pb.specular().y(),_pb.specular().z(),_pb.specular().w());
  Eigen::Vector4d position(_pb.position().x(),_pb.position().y(),_pb.position().z(),_pb.position().w());
  Eigen::Vector4d direction(_pb.direction().x(),_pb.direction().y(),_pb.direction().z(),_pb.direction().w());
  _io.nodes.insert(std::make_pair(_pb.name(),
                                  scene::Light_p(new scene::Light(_pb.name(),scene::light_attribs_t(ambient,diffuse,specular,position,direction,
                                      _pb.exponent(),_pb.cutoff(),_pb.const_att(),
                                      _pb.lin_att(),_pb.quad_att(),_pb.light_nr())))));
  return;
}

void MBD_Buffer::parse_material(const mbd::data_material &_pb,io_objects_t &_io)
{
  Eigen::Vector4d ambient(_pb.ambient().x(),_pb.ambient().y(),_pb.ambient().z(),_pb.ambient().w());
  Eigen::Vector4d diffuse(_pb.diffuse().x(),_pb.diffuse().y(),_pb.diffuse().z(),_pb.diffuse().w());
  Eigen::Vector4d specular(_pb.specular().x(),_pb.specular().y(),_pb.specular().z(),_pb.specular().w());
  Eigen::Vector4d emission(_pb.emission().x(),_pb.emission().y(),_pb.emission().z(),_pb.emission().w());
  _io.nodes.insert(std::make_pair(_pb.name(),
                                  scene::Material_p(new scene::Material(_pb.name(),scene::material_attribs_t(ambient,diffuse,specular,
                                      emission,_pb.shininess())))));
  return;
}

void MBD_Buffer::parse_mesh(const mbd::data_mesh &_pb,io_objects_t &_io)
{
  std::vector<Eigen::Vector4d> v;
  std::vector<Eigen::Vector3d> vn;
  std::vector<Eigen::Vector4d> vt;
  std::vector<Eigen::Vector4d> vc;
  for (uint32 i=0; i<_pb.v_size(); ++i) v.push_back(Eigen::Vector4d(_pb.v(i).x(),_pb.v(i).y(),_pb.v(i).z(),_pb.v(i).w()));
  for (uint32 j=0; j<_pb.vn_size(); ++j) vn.push_back(Eigen::Vector3d(_pb.vn(j).x(),_pb.vn(j).y(),_pb.vn(j).z()));
  for (uint32 k=0; k<_pb.vt_size(); ++k) vt.push_back(Eigen::Vector4d(_pb.vt(k).x(),_pb.vt(k).y(),_pb.vt(k).z(),_pb.vt(k).w()));
  for (uint32 l=0; l<_pb.vc_size(); ++l) vc.push_back(Eigen::Vector4d(_pb.vc(l).x(),_pb.vc(l).y(),_pb.vc(l).z(),_pb.vc(l).w()));
  _io.nodes.insert(std::make_pair(_pb.name(),scene::Mesh_p(new scene::Mesh(_pb.name(),scene::mesh_attribs_t(v,vn,vt,vc)))));
  return;
}

void MBD_Buffer::parse_pose(const mbd::data_pose &_pb,io_objects_t &_io)
{
  Eigen::Matrix4d m;
  m << _pb.c1().x(), _pb.c1().x(), _pb.c3().x(), _pb.c4().x(),
    _pb.c1().y(), _pb.c1().y(), _pb.c3().y(), _pb.c4().y(),
    _pb.c1().z(), _pb.c1().z(), _pb.c3().z(), _pb.c4().z(),
    _pb.c1().w(), _pb.c1().w(), _pb.c3().w(), _pb.c4().w();
  _io.nodes.insert(std::make_pair(_pb.name(),scene::Pose_p(new scene::Pose(_pb.name(),m))));
  return;
}

void MBD_Buffer::parse_texture(const mbd::data_texture &_pb,io_objects_t &_io)
{
  FI_Buffer_p texture;
  std::ifstream texfile(_pb.image());
  texture->parse_istream(texfile);
  scene::Texture_p tex=boost::dynamic_pointer_cast<scene::Texture>(texture->get_io_objects().nodes.at("ID_FI_TEXTURE"));
  if (tex.get()==NULL)
  {
    std::string err("Mondschein Engine ERROR: Conversion to <mondschein::scene::Texture_p> is not possible. ");
    err+="Exception raised in function\n\t";
    err+="void mondschein::io::MBD_Buffer::parse_texture(const mondschein::io::mbd::data_texture& _pb,";
    err+="mondscheim::io_objects_t& _io)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  scene::texture_attribs_t t=tex->get_texture_attribs();
  t.unit=_pb.unit();
  t.texture_filter=static_cast<texture_filtering_e>(_pb.texture_filter());
  t.anisotropic_filter=_pb.anisotropic_filter();
  tex->set_texture_attribs(t);
  tex->set_id(_pb.name());
  _io.nodes.insert(std::make_pair(_pb.name(),tex));
  return;
}

void MBD_Buffer::parse_scenegraph(const mbd::data_scenegraph &_pb,io_objects_t &_io)
{
  std::vector<scene::Scenenode_c> nodes;
  for (uint32 i=0; i<_pb.nodes_size(); ++i) nodes.push_back(_io.nodes.at(_pb.nodes(i)));
  boost::adjacency_list<> edges;
  for (uint32 j=0; j<_pb.edges_size(); ++j) boost::add_edge(_pb.edges(j).src(),_pb.edges(j).dst(),edges);
  _io.scenegraphs.insert(std::make_pair(_pb.name(),scene::Scenegraph_p(new scene::Scenegraph(scene::scenegraph_attribs_t(nodes,edges)))));
  return;
}

void MBD_Buffer::parse_beziercurve(const mbd::data_beziercurve &_pb,io_objects_t &_io)
{
  std::vector<Eigen::Vector4d> points;
  for (uint32 i=0; i<_pb.points_size(); ++i) points.push_back(Eigen::Vector4d(_pb.points(i).x(),_pb.points(i).y(),
        _pb.points(i).z(),_pb.points(i).w()));
  _io.beziercurves.insert(std::make_pair(_pb.name(),math::Beziercurve_p(new math::Beziercurve(points))));
  return;
}

void MBD_Buffer::parse_bezierpatch(const mbd::data_bezierpatch &_pb,io_objects_t &_io)
{
  std::vector<math::Beziercurve_p> curves;
  for (uint32 i=0; i<_pb.curves_size(); ++i) curves.push_back(generate_beziercurve(_pb.curves(i)));
  _io.bezierpatches.insert(std::make_pair(_pb.name(),math::Bezierpatch_p(new math::Bezierpatch(curves))));
  return;
}

void MBD_Buffer::parse_nurbscurve(const mbd::data_nurbscurve &_pb,io_objects_t &_io)
{
  std::vector<Eigen::Vector4d> points;
  for (uint32 i=0; i<_pb.points_size(); ++i) points.push_back(Eigen::Vector4d(_pb.points(i).x(),_pb.points(i).y(),
        _pb.points(i).z(),_pb.points(i).w()));
  _io.nurbscurves.insert(std::make_pair(_pb.name(),math::NURBScurve_p(new math::NURBScurve(_pb.dimension(),points))));
  return;
}

void MBD_Buffer::parse_nurbspatch(const mbd::data_nurbspatch &_pb,io_objects_t &_io)
{
  std::vector<math::NURBScurve_p> curves;
  for (uint32 i=0; i<_pb.curves_size(); ++i) curves.push_back(generate_nurbscurve(_pb.curves(i)));
  _io.nurbspatches.insert(std::make_pair(_pb.name(),math::NURBSpatch_p(new math::NURBSpatch(_pb.dimension(),curves))));
  return;
}

math::Beziercurve_p MBD_Buffer::generate_beziercurve(const mbd::data_beziercurve &_pb)
{
  std::vector<Eigen::Vector4d> points;
  for (uint32 i=0; i<_pb.points_size(); ++i) points.push_back(Eigen::Vector4d(_pb.points(i).x(),_pb.points(i).y(),
        _pb.points(i).z(),_pb.points(i).w()));
  return math::Beziercurve_p(new math::Beziercurve(points));
}

math::NURBScurve_p MBD_Buffer::generate_nurbscurve(const mbd::data_nurbscurve &_pb)
{
  std::vector<Eigen::Vector4d> points;
  for (uint32 i=0; i<_pb.points_size(); ++i) points.push_back(Eigen::Vector4d(_pb.points(i).x(),_pb.points(i).y(),
        _pb.points(i).z(),_pb.points(i).w()));
  return math::NURBScurve_p(new math::NURBScurve(_pb.dimension(),points));
}