mondschein_core.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 "types.h"
#include "core/camera.h"
#include "core/light.h"
#include "core/material.h"
#include "core/mesh.h"
#include "core/pose.h"
#include "core/texture.h"
#include "core/scenegraph.h"
#include "core/beziercurve.h"
#include "core/bezierpatch.h"
#include "core/nurbscurve.h"
#include "core/nurbspatch.h"

using namespace mondschein;

scene::Camera_p Core::create_camera()
{
  return scene::Camera_p(new scene::Camera());
}

scene::Camera_p Core::create_camera(const std::string& _id,float64 _v,float64 _a,float64 _n,float64 _f,
                                            float64 _x,float64 _y,float64 _w,float64 _h)
{
  return scene::Camera_p(new scene::Camera(_id,scene::camera_attribs_t(_v,_a,_n,_f,_x,_y,_w,_h)));
}

scene::Camera_p Core::create_camera(scene::Camera_c _c)
{
  return scene::Camera_p(new scene::Camera(_c));
}

scene::Light_p Core::create_light()
{
  return scene::Light_p(new scene::Light());
}

scene::Light_p Core::create_light(const std::string& _id,const Eigen::Vector4d &_a,const Eigen::Vector4d &_d,
                                          const Eigen::Vector4d &_s,const Eigen::Vector4d &_p,const Eigen::Vector4d &_sd,
                                          float64 _se,float64 _sc,float64 _ca,float64 _la,float64 _qa,uint8 _l)
{
  return scene::Light_p(new scene::Light(_id,scene::light_attribs_t(_a,_d,_s,_p,_sd,_se,_sc,_ca,_la,_qa,_l)));
}

scene::Light_p Core::create_light(scene::Light_c _l)
{
  return scene::Light_p(new scene::Light(_l));
}

scene::Material_p Core::create_material()
{
  return scene::Material_p(new scene::Material());
}

scene::Material_p Core::create_material(const std::string& _id,const Eigen::Vector4d &_a,const Eigen::Vector4d &_d,
                                                const Eigen::Vector4d &_s,const Eigen::Vector4d &_e,float64 _sh)
{
  return scene::Material_p(new scene::Material(_id,scene::material_attribs_t(_a,_d,_s,_e,_sh)));
}

scene::Material_p Core::create_material(scene::Material_c _m)
{
  return scene::Material_p(new scene::Material(_m));
}

scene::Mesh_p Core::create_mesh()
{
  return scene::Mesh_p(new scene::Mesh());
}

scene::Mesh_p Core::create_mesh(const std::string& _id,const std::vector<Eigen::Vector4d> &_v,
                                        const std::vector<Eigen::Vector3d> &_vn,const std::vector<Eigen::Vector4d> &_vt,
                                        const std::vector<Eigen::Vector4d> &_vc)
{
  return scene::Mesh_p(new scene::Mesh(_id,scene::mesh_attribs_t(_v,_vn,_vt,_vc)));
}

scene::Mesh_p Core::create_mesh(scene::Mesh_c _m)
{
  return scene::Mesh_p(new scene::Mesh(_m));
}

scene::Pose_p Core::create_pose()
{
  return scene::Pose_p(new scene::Pose());
}

scene::Pose_p Core::create_pose(const std::string& _id,const Eigen::Matrix4d &_m)
{
  return scene::Pose_p(new scene::Pose(_id,_m));
}

scene::Pose_p Core::create_pose(scene::Pose_c _p)
{
  return scene::Pose_p(new scene::Pose(_p));
}

scene::Texture_p Core::create_texture()
{
  return scene::Texture_p(new scene::Texture());
}

scene::Texture_p Core::create_texture(const std::string& _id,uint32 _w,uint32 _h,uint8 _bpp,bool _f,
                                              texture_filtering_e _tf,uint8 _af,uint8 _tu,const std::vector<uint8> &_d)
{
  return scene::Texture_p(new scene::Texture(_id,scene::texture_attribs_t(_w,_h,_bpp,_f,_tf,_af,_tu,_d)));
}

scene::Texture_p Core::create_texture(scene::Texture_c _t)
{
  return scene::Texture_p(new scene::Texture(_t));
}

scene::Scenegraph_p Core::create_scenegraph()
{
  return scene::Scenegraph_p(new scene::Scenegraph());
}

scene::Scenegraph_p Core::create_scenegraph(const std::vector<scene::Scenenode_c> &_n,
                                                    const boost::adjacency_list<> &_e)
{
  return scene::Scenegraph_p(new scene::Scenegraph(scene::scenegraph_attribs_t(_n,_e)));
}

scene::Scenegraph_p Core::create_scenegraph(scene::Scenegraph_c _sg)
{
  return scene::Scenegraph_p(new scene::Scenegraph(_sg));
}

math::Beziercurve_p Core::create_beziercurve()
{
  return math::Beziercurve_p(new math::Beziercurve());
}

math::Beziercurve_p Core::create_beziercurve(const std::vector<Eigen::Vector4d> &_p)
{
  return math::Beziercurve_p(new math::Beziercurve(_p));
}

math::Beziercurve_p Core::create_beziercurve(math::Beziercurve_c _c)
{
  return math::Beziercurve_p(new math::Beziercurve(_c));
}

math::Bezierpatch_p Core::create_bezierpatch()
{
  return math::Bezierpatch_p(new math::Bezierpatch());
}

math::Bezierpatch_p Core::create_bezierpatch(const std::vector<math::Beziercurve_p> &_c)
{
  return math::Bezierpatch_p(new math::Bezierpatch(_c));
}

math::Bezierpatch_p Core::create_bezierpatch(math::Bezierpatch_c _p)
{
  return math::Bezierpatch_p(new math::Bezierpatch(_p));
}

math::NURBScurve_p Core::create_nurbscurve()
{
  return math::NURBScurve_p(new math::NURBScurve());
}

math::NURBScurve_p Core::create_nurbscurve(uint32 _d,const std::vector<Eigen::Vector4d> &_p, bool _cl)
{
  math::NURBScurve_p c(new math::NURBScurve(_d,_p));
  c->calc_knots(_cl);
  return c;
}

math::NURBScurve_p Core::create_nurbscurve(math::NURBScurve_c _c)
{
  return math::NURBScurve_p(new math::NURBScurve(_c));
}

math::NURBSpatch_p Core::create_nurbspatch()
{
  return math::NURBSpatch_p(new math::NURBSpatch());
}

math::NURBSpatch_p Core::create_nurbspatch(uint32 _d,const std::vector<math::NURBScurve_p> &_c,bool _cl)
{
  math::NURBSpatch_p p(new math::NURBSpatch(_d,_c));
  p->calc_knots(_cl);
  return p;
}

math::NURBSpatch_p Core::create_nurbspatch(math::NURBSpatch_c _p)
{
  return math::NURBSpatch_p(new math::NURBSpatch(_p));
}