Logo Search packages:      
Sourcecode: k3d version File versions

ayamreader.cpp

Go to the documentation of this file.
// K-3D
// Copyright (c) 1995-2004, Timothy M. Shead
//
// Contact: tshead@k-3d.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 2 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

/** \file
            \brief Implements the AyamReader K-3D object, which reads Ayam .ay files
            \author Romain Behar (romainbehar@yahoo.com)
*/

#include <k3dsdk/algebra.h>
#include <k3dsdk/classes.h>
#include <k3dsdk/color.h>
#include <k3dsdk/file_helpers.h>
#include <k3dsdk/iapplication.h>
#include <k3dsdk/idag.h>
#include <k3dsdk/ideletable.h>
#include <k3dsdk/idocument.h>
#include <k3dsdk/ifile_format.h>
#include <k3dsdk/igeometry_read_format.h>
#include <k3dsdk/imaterial.h>
#include <k3dsdk/imaterial_collection.h>
#include <k3dsdk/iobject.h>
#include <k3dsdk/iobject_collection.h>
#include <k3dsdk/material.h>
#include <k3dsdk/mesh.h>
#include <k3dsdk/module.h>
#include <k3dsdk/plugins.h>
#include <k3dsdk/property.h>
#include <k3dsdk/result.h>
#include <k3dsdk/selection.h>
#include <k3dsdk/string_modifiers.h>
#include <k3dsdk/utility.h>
#include <k3dsdk/vectors.h>

#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/path.hpp>

#include <iostream>
#include <sstream>
#include <stack>

namespace
{

// K-3D is left handed and Ayam right handed

// Core object IDs
const int AY_ROOT       =     0;
const int AY_NPATCH           =     1;
const int AY_NCURVE           =     2;
const int AY_LEVEL            =     3;
const int AY_LIGHT            =     4;
const int AY_BOX        =     5;
const int AY_BPATCH           =     6;
const int AY_VIEW       =     7;
const int AY_CAMERA           =     8;
const int AY_INSTANCE         =     9;
const int AY_SPHERE           =     10;
const int AY_DISK       =     11;
const int AY_CONE       =     12;
const int AY_CYLINDER         =     13;
const int AY_PARABOLOID       =     14;
const int AY_HYPERBOLOID      =     15;
const int AY_TORUS            =     16;
const int AY_RIINC            =     17;
const int AY_MATERIAL         =     18;
const int AY_ICURVE           =     19;
const int AY_REVOLVE          =     20;
const int AY_EXTRUDE          =     21;
const int AY_SWEEP            =     22;
const int AY_SKIN       =     23;
const int AY_CAP        =     24;
const int AY_PATCHMESH        =     25;
const int AY_POLYMESH         =     26;
const int AY_CONCATNC         =     27;
const int AY_CLONE            =     28;
const int AY_SUBDIVMESH       =     29;

// Shader argument types
const int SHADER_ARG_SCALAR   =     0;
const int SHADER_ARG_POINT    =     1;
const int SHADER_ARG_NORMAL   =     2;
const int SHADER_ARG_VECTOR   =     3;
const int SHADER_ARG_COLOR    =     4;
const int SHADER_ARG_STRING   =     5;
const int SHADER_ARG_MATRIX   =     6;

// Level types
const int LEVEL_END           =     0;
const int LEVEL_LEVEL         =     1;
const int LEVEL_UNION         =     2;
const int LEVEL_DIFFERENCE    =     3;
const int LEVEL_INTERSECT     =     4;
const int LEVEL_PRIMITIVE     =     5;

// Knot vector types
const int KNOT_BEZIER         =     0;
const int KNOT_BSPLINE        =     1;
const int KNOT_NURBS          =     2;
const int KNOT_CUSTOM         =     3;

// View types
const int VIEW_FRONT          =     0;
const int VIEW_SIDE           =     1;
const int VIEW_TOP            =     2;
const int VIEW_PERSP          =     3;
const int VIEW_TRIM           =     4;


k3d::quaternion RotationQuaternion(const k3d::vector3& axis, const double cos_angle)
{
      // The quaternion requires half angles
      double angle = std::acos(k3d::Clamp<double>(-1.0, cos_angle, 1.0));

      return k3d::quaternion(std::cos(angle / 2.0), axis * std::sin(angle / 2.0));
}

k3d::quaternion LookAt(k3d::vector3 direction, k3d::vector3 up_vector)
{
      k3d::vector3 axis = direction.Normalize();
      k3d::vector3 up = up_vector.Normalize();

      // Find the rotation that lines up the view directions ...
      k3d::quaternion direction_rotation = k3d::quaternion(1.0, k3d::vector3(0.0, 0.0, 0.0));
      k3d::vector3 norm_axis = k3d::vector3(axis.n[1], -axis.n[0], 0.0);
      if(norm_axis * norm_axis > 1e-8)
            {
                  direction_rotation = RotationQuaternion(norm_axis.Normalize(), -axis.n[2]);
            }

      // Now find the rotation that aligns the up vectors ...
      k3d::quaternion inverse_direction_rotation(direction_rotation.w, -1 * direction_rotation.v);

      // Rotate the world y vector to see where it ends up ...
      k3d::quaternion y(0.0, k3d::vector3(0.0, 1.0, 0.0));
      k3d::quaternion new_y = direction_rotation * y * inverse_direction_rotation;

      // Build the rotation needed to align the up vectors in the final position ...
      k3d::vector3 angle = (up - axis * (up * axis)).Normalize();
      k3d::quaternion y_rotation = RotationQuaternion(k3d::vector3(0.0, 0.0, 1.0), new_y.v * angle);

      // Put the two rotations together
      return direction_rotation * y_rotation;
}

// Ayam doesn't create RenderMan primitives with the same orientation as K-3D
void PrimitiveTransformation(k3d::iobject* object)
{
      // Get current object rotation
      k3d::angle_axis aa = boost::any_cast<k3d::angle_axis>(k3d::get_property_value(*object, "orientation"));

      // Make it a quaternion
      k3d::quaternion qaa(aa);

      // Rotate object 90 degrees around X
      k3d::quaternion transf = k3d::quaternion(k3d::angle_axis(k3d::radians(90.0), k3d::vector3(1.0, 0.0, 0.0)));

      // Set updated rotation
      k3d::set_property_value(*object, "orientation", k3d::angle_axis(qaa*transf));

      // Get current object scale
      k3d::vector3 scale = boost::any_cast<k3d::vector3>(k3d::get_property_value(*object, "scale"));
      // Swap Y and Z
      std::swap(scale.n[1], scale.n[2]);
      // Set updated scale
      k3d::set_property_value(*object, "scale", scale);
}

/////////////////////////////////////////////////////////////////////////////
// ayam_reader_implementation

class ayam_reader_implementation :
      public k3d::ifile_format,
      public k3d::igeometry_read_format,
      public k3d::ideletable
{
public:
      unsigned long priority()
      {
            return 0;
      }

      bool query_can_handle(const boost::filesystem::path& FilePath)
      {
            return "ay" == k3d::file_extension(FilePath);
      }

      bool pre_read(k3d::idocument& Document, const boost::filesystem::path& FilePath)
      {
            return true;
      }

      bool read_options(k3d::idocument& Document, const boost::filesystem::path& FilePath)
      {
            return true;
      }

      bool read_file(k3d::idocument& Document, const boost::filesystem::path& FilePath);

      k3d::iplugin_factory& factory()
      {
            return get_factory();
      }

      static k3d::iplugin_factory& get_factory()
      {
            static k3d::plugin_factory<k3d::application_plugin<ayam_reader_implementation>, k3d::interface_list<k3d::igeometry_read_format> > factory(
                  k3d::uuid(0x175b6856, 0x659db40d, 0x4d783caa, 0xfa348ece),
                  "AyamReader",
                  "Ayam Modeler ( .ay )",
                  "");

            return factory;
      }

private:
      int ayam_minor_version;

      double ri_x_samples;
      double ri_y_samples;
      int ri_pixel_filter_width;
      int ri_pixel_filter_height;
      int ri_texture_memory;
      int output_pixel_width;
      int output_pixel_height;

      // File helpers
      int get_int()
      {
            std::string buffer;
            getline(input_file, buffer);
            return k3d::from_string<int>(buffer, 0);
      }

      double get_float()
      {
            std::string buffer;
            getline(input_file, buffer);
            return k3d::from_string<double>(buffer, 0);
      }

      k3d::vector3 get_vector3()
      {
            double x = get_float();
            double y = get_float();
            double z = get_float();

            return k3d::vector3(x, y, z);
      }

      k3d::vector4 get_vector4()
      {
            double x = get_float();
            double y = get_float();
            double z = get_float();
            double w = get_float();

            return k3d::vector4(x, y, z, w);
      }

      k3d::iobject* CreateObject(const k3d::uuid plugin_id, k3d::idocument& Document)
      {
            k3d::iobject* const object = k3d::create_document_plugin(plugin_id, Document);
            assert_warning(object);

            return object;
      }

      k3d::iobject* CreateInstance(k3d::idocument& Document)
      {
            // Render Mesh plugin
            k3d::iobject* instance = CreateObject(k3d::classes::MeshInstance(), Document);
            assert_warning(instance);

            return instance;
      }

      // Load core objects
      void LoadRoot()
      {
            double variance = get_float();
            ri_x_samples = get_float();
            ri_y_samples = get_float();
            int filter = get_int();
            ri_pixel_filter_width = get_int();
            ri_pixel_filter_height = get_int();
            double gain = get_float();
            double gamma = get_float();
            double rgba_one = get_float();
            double rgba_min = get_float();
            double rgba_max = get_float();
            double rgba_dither = get_float();
            int minsamples = get_int();
            int maxsamples = get_int();
            int maxray = get_int();
            double shadow_bias = get_float();
            int prman = get_int();
            int radsteps = get_int();
            int patchsamples = get_int();

            std::string textures;
            getline(input_file, textures);
            std::string archives;
            getline(input_file, archives);
            std::string shaders;
            getline(input_file, shaders);

            ri_texture_memory = get_int();
            int geommem = get_int();
            output_pixel_width = get_int();
            output_pixel_height = get_int();

            int has_atmosphere = get_int();
            if(has_atmosphere)
                  LoadShader();

            int has_imager = get_int();
            if(has_imager)
                  LoadShader();
      }

      void LoadView(k3d::iobject* camera)
      {
            int width = get_int();
            int height = get_int();

            int type = get_int();
            k3d::vector3 up(0.0, 0.0, 0.0);
            if(type != VIEW_TOP)
                  up.n[1] = 1.0;
            else
                  up.n[2] = -1.0;

            double grid = get_float();
            int drawsel = get_int();
            int drawlevel = get_int();
            int redraw = get_int();
            int drawgrid = get_int();
            int usegrid = get_int();
            int local = get_int();
            int shade = get_int();

            double fromx = get_float();
            double fromy = get_float();
            double fromz = get_float();
            double tox = get_float();
            double toy = get_float();
            double toz = get_float();
            double upx = get_float();
            double upy = get_float();
            double upz = get_float();
            double roll = get_float();
            double zoom = get_float();

            int posx = get_int();
            int posy = get_int();

            double rotx = get_float();
            double roty = get_float();
            double rotz = get_float();

            if(ayam_minor_version >= 2)
                  {
                        std::string bgimage;
                        getline(input_file, bgimage);

                        int drawbg = get_int();
                  }

            if(ayam_minor_version >= 4)
                  {
                        double near_plane = get_float();
                        double far_plane = get_float();
                  }

            // Set properties ...
            k3d::set_property_value(*camera, "position", k3d::vector3(fromx, fromy, fromz));
            k3d::quaternion q = LookAt(k3d::vector3(fromx - tox, fromy - toy, fromz - toz), k3d::vector3(upx, upy, upz));
            k3d::set_property_value(*camera, "orientation", k3d::angle_axis(q.Normalize()));
      }

      void LoadInstance(k3d::iobject* instance)
      {
            k3d::set_property_value(*instance, "offsetx", translation.n[0]);
            k3d::set_property_value(*instance, "offsety", translation.n[1]);
            k3d::set_property_value(*instance, "offsetz", translation.n[2]);
            k3d::set_property_value(*instance, "rotatex", -rotation.n[0]);
            k3d::set_property_value(*instance, "rotatey", rotation.n[1]);
            k3d::set_property_value(*instance, "rotatez", rotation.n[2]);
      }

      void MakeKnotVector(int knot_type, std::vector<double>& knots, int knot_count, int order)
      {
            switch(knot_type)
                  {
                        case KNOT_BEZIER:
                        {
                              for(int n = 0; n < knot_count/2; n++)
                                    knots.push_back(0.0);

                              for(int n = knot_count/2; n < knot_count; n++)
                                    knots.push_back(1.0);
                        }
                        break;

                        case KNOT_BSPLINE:
                        {
                              double d_kc = static_cast<double>(knot_count);
                              for(int n = 0; n < knot_count; n++)
                                    {
                                          double d_n = static_cast<double>(n);
                                          knots.push_back(d_n/d_kc);
                                    }
                        }
                        break;

                        case KNOT_NURBS:
                        {
                              for(int n = 0; n < order; n++)
                                    knots.push_back(0.0);

                              int j = 1;
                              int kts = 1 + knot_count - (order*2);
                              for(int n = order; n < knot_count - order; n++)
                                    knots.push_back(static_cast<double>(j++)/static_cast<double>(kts));
                              for(int n = knot_count - order; n < knot_count; n++)
                                    knots.push_back(1.0);
                        }
                        break;

                        case KNOT_CUSTOM:
                        {
                              for(int n = 0; n < knot_count; n++)
                                    {
                                          double k = get_float();
                                          knots.push_back(k);
                                    }
                        }
                        break;

                        default:
                              assert_warning("unkown knot type");
                  }
      }

      k3d::mesh* LoadNCurve()
      {
            k3d::mesh* const mesh = new k3d::mesh();
            k3d::nucurve* const nucurve = new k3d::nucurve();
            k3d::nucurve_group* const nucurve_group = new k3d::nucurve_group();
            mesh->nucurve_groups.push_back(nucurve_group);
            nucurve_group->curves.push_back(nucurve);

            int length = get_int();
            int order = get_int();
            int knot_type = get_int();

            nucurve->order = order;

            int knot_count = length + order;
            MakeKnotVector(knot_type, nucurve->knots, knot_count, order);

            // Control vertices
            for(int n = 0; n < length; n++)
                  {
                        std::string buffer;
                        getline(input_file, buffer);
                        std::istringstream stream(buffer);

                        double x, y, z, w;
                        stream >> x >> y >> z >> w;

                        k3d::point* p = new k3d::point(x, y, z);
                        mesh->points.push_back(p);
                        nucurve->control_points.push_back(k3d::nucurve::control_point(p, w));
                  }

            assert_warning(is_valid(*nucurve));

            // Properties
            int closed = get_int();
            double glu_sampling_tolerance = get_float();
            int display_mode = get_int();

            if(ayam_minor_version >= 1)
                  {
                        int createmp = get_int();
                  }

            return mesh;
      }

      k3d::mesh* LoadNPatch()
      {
            k3d::mesh* const mesh = new k3d::mesh();
            k3d::nupatch* const nupatch = new k3d::nupatch();
            mesh->nupatches.push_back(nupatch);

            int width = get_int();
            int height = get_int();
            int u_order = get_int();
            int v_order = get_int();
            int u_knot_type = get_int();
            int v_knot_type = get_int();

            nupatch->u_order = u_order;
            nupatch->v_order = v_order;

            int u_knot_count = width + u_order;
            int v_knot_count = height + v_order;

            MakeKnotVector(u_knot_type, nupatch->u_knots, u_knot_count, u_order);
            MakeKnotVector(v_knot_type, nupatch->v_knots, v_knot_count, v_order);

            // Control vertices
            for(int n = 0; n < width*height; n++)
                  {
                        std::string buffer;
                        getline(input_file, buffer);
                        std::istringstream stream(buffer);

                        double x, y, z, w;
                        stream >> x >> y >> z >> w;

                        k3d::point* p = new k3d::point(x, y, z);
                        mesh->points.push_back(p);
                        nupatch->control_points.push_back(k3d::nupatch::control_point(p, w));
                  }

            assert_warning(is_valid(*nupatch));

            // Properties
            double glu_sampling_tolerance = get_float();
            int display_mode = get_int();

            return mesh;
      }

      void LoadMaterial()
      {
            int registered = get_int();
            int color_r = get_int();
            int color_g = get_int();
            int color_b = get_int();
            int op_r = get_int();
            int op_g = get_int();
            int op_b = get_int();
            double shading_rate = get_float();
            int shading_interpolation = get_int();
            int dbound = get_int();
            double dbound_val = get_float();
            int true_displacement = get_int();
            int cast_shadows = get_int();
            int camera = get_int();
            int reflection = get_int();
            int shadow = get_int();

            int has_s_shader = get_int();
            if(has_s_shader)
                  LoadShader();
            int has_d_shader = get_int();
            if(has_d_shader)
                  LoadShader();
            int has_i_shader = get_int();
            if(has_i_shader)
                  LoadShader();
            int has_shader = get_int();
            if(has_shader)
                  LoadShader();

            if(ayam_minor_version >= 4)
                  {
                        int sides = get_int();
                  }
      }

      void LoadSkin()
      {
            int interpolate = get_int();
            int uorder = get_int();
            int uknot_type = get_int();
            int has_start_cap = get_int();
            int has_end_cap = get_int();
            int glu_display_mode = get_int();
            double glu_sampling_tolerance = get_float();
      }

      void LoadLight()
      {
            int shadows = get_int();
            int samples = get_int();
            int type = get_int();
            int on = get_int();
            double intensity = get_float();
            int color_r = get_int();
            int color_g = get_int();
            int color_b = get_int();
            double cone_angle = get_float();
            double cone_delta_angle = get_float();
            double beam_distribution = get_float();
            int use_sm = get_int();
            int sm_resolution = get_int();
            double from_x = get_float();
            double from_y = get_float();
            double from_z = get_float();
            double to_x = get_float();
            double to_y = get_float();
            double to_z = get_float();

            int has_shader= get_int();
            if(has_shader)
                  {
                        LoadShader();
                  }

            if(ayam_minor_version >= 5)
                  {
                        int local = get_int();
                  }
      }

      // Core objects attributes
      void GetAttributes()
      {
            int params = get_int();
            if(params)
                  {
                        translation = get_vector3();
                        rotation = get_vector3();
                        quaternion = get_vector4();
                        scale = get_vector3();
                  }

            // Can have children
            children = get_int();
            // Inherits tranformation properties
            inherit_transf = get_int();
            hide = get_int();
            hide_children = get_int();

            getline(input_file, name);
      }

      void SetAttributes(k3d::idocument& Document, k3d::iobject* object, const std::string& default_name)
      {
            k3d::set_property_value(*object, "position", translation);
            k3d::set_property_value(*object, "orientation", k3d::angle_axis(k3d::quaternion(k3d::euler_angles(k3d::radians(-rotation.n[0]), k3d::radians(rotation.n[1]), k3d::radians(rotation.n[2]), k3d::euler_angles::XYZstatic))));
            k3d::set_property_value(*object, "scale", scale);

            if(name.empty())
                  object->set_name(default_name);
            else
            {
                  std::cerr << "Name : " << name << std::endl;
                  object->set_name(name);
            }

            //std::cerr << "Parent : " << children << ", inherit : " << inherit_transf << std::endl;

assert_warning(0);
/*
            // Set parent in hierarchy
            if(!hierarchy_levels.empty())
                  {
                        Document.hierarchy().SetObjectParent(object, hierarchy_levels.top());
                  }
*/
      }

      // Load objects tags
      void GetTags()
      {
            int tags = get_int();
            for(int i = 0; i < tags; i++)
                  {
                        std::string name;
                        getline(input_file, name);

                        //if(name registered)
                        std::string value;
                        getline(input_file, value);
                  }
      }

      void LoadShader()
      {
            std::string name;
            getline(input_file, name);

            int type = get_int();
            int argc = get_int();

            for(int j = 0; j < argc; j++)
                  {
                        std::string arg_name;
                        getline(input_file, arg_name);

                        int arg_type = get_int();
                        switch(arg_type)
                              {
                                    case SHADER_ARG_SCALAR:
                                    {
                                          double scalar = get_float();
                                    }
                                    break;

                                    case SHADER_ARG_POINT:
                                    case SHADER_ARG_NORMAL:
                                    case SHADER_ARG_VECTOR:
                                    {
                                          k3d::vector3 v = get_vector3();
                                    }
                                    break;

                                    case SHADER_ARG_COLOR:
                                    {
                                          k3d::color color = k3d::color(get_float(), get_float(), get_float());
                                    }
                                    break;

                                    case SHADER_ARG_STRING:
                                    {
                                          std::string s;
                                          getline(input_file, s);
                                    }
                                    break;

                                    case SHADER_ARG_MATRIX:
                                    {
                                          std::string m;
                                          getline(input_file, m);
                                    }
                                    break;

                                    default:
                                    break;
                              }
                  }
      }

      boost::filesystem::ifstream input_file;

      std::stack<k3d::iobject*> hierarchy_levels;
      k3d::iobject* last_object;

      k3d::vector3 translation;
      k3d::vector3 rotation;
      k3d::vector4 quaternion;
      k3d::vector3 scale;
      int children;
      int inherit_transf;
      int hide;
      int hide_children;
      std::string name;

};

bool ayam_reader_implementation::read_file(k3d::idocument& Document, const boost::filesystem::path& FilePath)
{
      // Try to open the input file ...
      input_file.open(FilePath);
      if(!input_file.good())
            {
                  std::cerr << __PRETTY_FUNCTION__ << ": error opening [" << FilePath.native_file_string() << "]" << std::endl;
                  return false;
            }

      std::string line_buffer;
      getline(input_file, line_buffer);
      if(line_buffer.empty() && !input_file.good())
            {
                  std::cerr << __PRETTY_FUNCTION__ << ": empty file [" << FilePath.native_file_string() << "]" << std::endl;
                  return false;
            }

      // Format name : "Ayam"
      if(line_buffer != "Ayam")
            {
                  std::cerr << __PRETTY_FUNCTION__ << ": " << FilePath.native_file_string() << " not an Ayam file" << std::endl;
                  return false;
            }

      // Ayam version
      getline(input_file, line_buffer);
      if(line_buffer.empty() && !input_file.good())
            {
                  std::cerr << __PRETTY_FUNCTION__ << ": " << FilePath.native_file_string() << " couldn't get Ayam version" << std::endl;
                  return false;
            }

      double ayam_version = k3d::from_string<double>(line_buffer, 0);
      ayam_minor_version = 0;
      if(ayam_version > 1.0)
            ayam_minor_version = static_cast<int>(10 * (ayam_version - 1.0));

      // Read objects ...
      while(input_file.good())
      {
            // An object is marked by one or more bells
            bool skip = true;
            do
            {
                  std::ifstream::int_type c = input_file.get();
                  if(static_cast<char>(c) == '\a')
                        {
                              while(static_cast<char>(input_file.peek()) == '\a')
                                    input_file.get();

                              break;
                        }
                  else
                        {
                              if(skip)
                                    {
                                          std::cerr << "Skipping : " << std::endl;
                                          skip = false;
                                    }

                              std::cerr << static_cast<char>(c);
                        }
            }
            while(input_file.good());

            if(!input_file.good())
                  return true;

            // Get object type ...
            int has_name;
            input_file >> has_name;
            input_file.get();
            int type = -1;
            if(has_name)
                  {
                        // Named object
                        std::string type_name;
                        getline(input_file, type_name);
std::cerr << "Named object : " << type_name << std::endl;
                  }
            else
                  {
                        // Object with ID
                        type = get_int();
                  }

            int has_child = 0;
            if(ayam_minor_version)
                  has_child = get_int();

            GetAttributes();

            GetTags();

            switch(type)
                  {
                        case AY_ROOT:
                        {
                              LoadRoot();
                        }
                        break;

                        case AY_LEVEL:
                        {
                              int type = get_int();
                              if(type == LEVEL_END)
                                    {
                                          if(!hierarchy_levels.empty())
                                                hierarchy_levels.pop();
                                          break;
                                    }

                              k3d::iobject* transform = CreateObject(k3d::classes::Transform(), Document);
                              SetAttributes(Document, transform, "Transform");
                              switch(type)
                                    {
                                          case LEVEL_LEVEL:
                                                hierarchy_levels.push(transform);
                                          break;
                                          case LEVEL_UNION:
                                                hierarchy_levels.push(transform);
                                          break;
                                          case LEVEL_DIFFERENCE:
                                                hierarchy_levels.push(transform);
                                          break;
                                          case LEVEL_INTERSECT:
                                                hierarchy_levels.push(transform);
                                          break;
                                          case LEVEL_PRIMITIVE:
                                                hierarchy_levels.push(transform);
                                          break;
                                          default:
                                                assert_warning("unknown level type");
                                          break;
                                    }

                              last_object = transform;
                        }
                        break;

                        case AY_VIEW:
                        {
                              k3d::iobject* camera = CreateObject(k3d::classes::RenderManEngine(), Document);
                              SetAttributes(Document, camera, "View");
                              LoadView(camera);
                        }
                        break;

                        case AY_INSTANCE:
                        {
                              k3d::iobject* instance = CreateInstance(Document);
                              LoadInstance(instance);

                              k3d::idag::dependencies_t dependencies;
                              dependencies[k3d::get_property(*instance, "input")] = k3d::get_property(*last_object, "output");
                              Document.dag().set_dependencies(dependencies);

assert_warning(0);
/*
                              Document.hierarchy().SetObjectParent(instance, Document.hierarchy().ObjectParent(last_object));
*/

                              SetAttributes(Document, instance, "Instance");
                        }
                        break;

                        case AY_BOX:
                        {
                              get_float(); // width
                              get_float(); // length
                              get_float(); // height

                              //last_object = ;
                        }
                        break;

                        case AY_SPHERE:
                        {
                              k3d::iobject* sphere = CreateObject(k3d::classes::Sphere(), Document);
                              get_int(); // closed
                              k3d::set_property_value(*sphere, "radius", get_float());
                              k3d::set_property_value(*sphere, "zmin", get_float());
                              k3d::set_property_value(*sphere, "zmax", get_float());
                              k3d::set_property_value(*sphere, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, sphere, "Sphere");
                              PrimitiveTransformation(sphere);

                              last_object = sphere;
                        }
                        break;

                        case AY_DISK:
                        {
                              k3d::iobject* disk = CreateObject(k3d::classes::Disk(), Document);
                              k3d::set_property_value(*disk, "radius", get_float());
                              k3d::set_property_value(*disk, "height", get_float());
                              k3d::set_property_value(*disk, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, disk, "Disk");
                              PrimitiveTransformation(disk);

                              last_object = disk;
                        }
                        break;

                        case AY_CONE:
                        {
                              k3d::iobject* cone = CreateObject(k3d::classes::Cone(), Document);
                              get_int(); // closed
                              k3d::set_property_value(*cone, "radius", get_float());
                              k3d::set_property_value(*cone, "height", get_float());
                              k3d::set_property_value(*cone, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, cone, "Cone");
                              PrimitiveTransformation(cone);

                              last_object = cone;
                        }
                        break;

                        case AY_CYLINDER:
                        {
                              k3d::iobject* cylinder = CreateObject(k3d::classes::Cylinder(), Document);
                              get_int(); // closed
                              k3d::set_property_value(*cylinder, "radius", get_float());
                              k3d::set_property_value(*cylinder, "zmin", get_float());
                              k3d::set_property_value(*cylinder, "zmax", get_float());
                              k3d::set_property_value(*cylinder, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, cylinder, "Cylinder");
                              PrimitiveTransformation(cylinder);

                              last_object = cylinder;
                        }
                        break;

                        case AY_PARABOLOID:
                        {
                              k3d::iobject* paraboloid = CreateObject(k3d::classes::Paraboloid(), Document);
                              get_int(); // closed
                              k3d::set_property_value(*paraboloid, "radius", get_float());
                              k3d::set_property_value(*paraboloid, "height", get_float());
                              k3d::set_property_value(*paraboloid, "zmin", get_float());
                              k3d::set_property_value(*paraboloid, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, paraboloid, "Paraboloid");
                              PrimitiveTransformation(paraboloid);

                              last_object = paraboloid;
                        }
                        break;

                        case AY_HYPERBOLOID:
                        {
                              k3d::iobject* hyperboloid = CreateObject(k3d::classes::Hyperboloid(), Document);
                              int closed = get_int();

                              // Vector3
                              std::string buffer;
                              getline(input_file, buffer);
                              std::istringstream stream(buffer);
                              double x, y, z;
                              stream >> x >> y >> z;
                              k3d::set_property_value(*hyperboloid, "p1x", x);
                              k3d::set_property_value(*hyperboloid, "p1y", y);
                              k3d::set_property_value(*hyperboloid, "p1z", z);

                              getline(input_file, buffer);
                              std::istringstream stream2(buffer);
                              stream2 >> x >> y >> z;
                              k3d::set_property_value(*hyperboloid, "p2x", x);
                              k3d::set_property_value(*hyperboloid, "p2y", y);
                              k3d::set_property_value(*hyperboloid, "p2z", z);

                              k3d::set_property_value(*hyperboloid, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, hyperboloid, "Hyperboloid");
                              PrimitiveTransformation(hyperboloid);

                              last_object = hyperboloid;
                        }
                        break;

                        case AY_TORUS:
                        {
                              k3d::iobject* torus = CreateObject(k3d::classes::Torus(), Document);
                              get_int(); // closed
                              k3d::set_property_value(*torus, "majorradius", get_float());
                              k3d::set_property_value(*torus, "minorradius", get_float());
                              k3d::set_property_value(*torus, "phimin", get_float());
                              k3d::set_property_value(*torus, "phimax", get_float());
                              k3d::set_property_value(*torus, "sweepangle", k3d::radians(get_float()));

                              SetAttributes(Document, torus, "Torus");
                              PrimitiveTransformation(torus);

                              last_object = torus;
                        }
                        break;

                        case AY_POLYMESH:
                        {
                              int mesh_type = get_int();

                              unsigned long poly_count = static_cast<unsigned int>(get_int());
                              std::vector<unsigned long> loops;
                              for(unsigned long n = 0; n < poly_count; n++)
                                    loops.push_back(static_cast<unsigned long>(get_int()));

                              unsigned long loop_count = static_cast<unsigned int>(get_int());
                              std::vector<unsigned long> nverts;
                              for(unsigned long n = 0; n < loop_count; n++)
                                    nverts.push_back(static_cast<unsigned long>(get_int()));

                              unsigned long vertice_counts = static_cast<unsigned int>(get_int());
                              std::vector<unsigned long> verts;
                              for(unsigned long n = 0; n < vertice_counts; n++)
                                    verts.push_back(static_cast<unsigned long>(get_int()));


std::cerr << "POMESH :" << std::endl;
std::cerr << "poly_count :" << poly_count << std::endl;
std::cerr << "loop_count :" << loop_count << std::endl;
std::cerr << "vertice_counts :" << vertice_counts << std::endl;
                              unsigned long point_count = static_cast<unsigned int>(get_int());
std::cerr << "point_count :" << point_count << std::endl;
                              int has_normals = get_int();

                              for(unsigned long n = 0; n < point_count; n++)
                                    {
                                          std::string buffer;
                                          getline(input_file, buffer);
                                          std::istringstream stream(buffer);

                                          double x, y, z;
                                          stream >> x >> y >> z;

                                          if(has_normals)
                                                getline(input_file, buffer);
                                    }
                        }
                        break;

                        case AY_NCURVE:
                        {
                              k3d::mesh* mesh = LoadNCurve();
                              k3d::iobject* frozen_mesh = CreateObject(k3d::classes::FrozenMesh(), Document);
                              k3d::set_property_value(*frozen_mesh, "input", mesh);
                              SetAttributes(Document, frozen_mesh, "NCurve");

                              k3d::iobject* instance = CreateInstance(Document);

                              k3d::idag::dependencies_t dependencies;
                              dependencies[k3d::get_property(*instance, "input")] = k3d::get_property(*frozen_mesh, "output");
                              Document.dag().set_dependencies(dependencies);

assert_warning(0);
/*
                              Document.hierarchy().SetObjectParent(instance, Document.hierarchy().ObjectParent(frozen_mesh));
*/

                              last_object = frozen_mesh;
                        }
                        break;

                        case AY_NPATCH:
                        {
                              k3d::mesh* mesh = LoadNPatch();
                              k3d::iobject* frozen_mesh = CreateObject(k3d::classes::FrozenMesh(), Document);
                              k3d::set_property_value(*frozen_mesh, "input", mesh);
                              SetAttributes(Document, frozen_mesh, "NPatch");

                              k3d::iobject* instance = CreateInstance(Document);

                              k3d::idag::dependencies_t dependencies;
                              dependencies[k3d::get_property(*instance, "input")] = k3d::get_property(*frozen_mesh, "output");
                              Document.dag().set_dependencies(dependencies);

assert_warning(0);
/*
                              Document.hierarchy().SetObjectParent(instance, Document.hierarchy().ObjectParent(frozen_mesh));
*/

                              last_object = frozen_mesh;
                        }
                        break;

                        case AY_MATERIAL:
                        {
                              LoadMaterial();
                        }
                        break;

                        case AY_SKIN:
                        {
                              k3d::iobject* transform = CreateObject(k3d::classes::Transform(), Document);
                              LoadSkin();
                              SetAttributes(Document, transform, "Skin");
                              hierarchy_levels.push(transform);
                        }
                        break;

                        case AY_LIGHT:
                        {
                              LoadLight();
                        }
                        break;

                        case AY_REVOLVE:
                        {
                              k3d::iobject* transform = CreateObject(k3d::classes::Transform(), Document);

                              double thetamax = get_float();
                              int has_upper_cap = get_int();
                              int has_lower_cap = get_int();
                              int has_start_cap = get_int();
                              int has_end_cap = get_int();
                              int glu_display_mode = get_int();
                              double glu_sampling_tolerance = get_float();

                              SetAttributes(Document, transform, "Revolve");
                              hierarchy_levels.push(transform);
                        }
                        break;

                        default:
                              std::cerr << "Unknown Ayam object type : " << type << std::endl;
                  }

            if(ayam_minor_version == 0)
                  {
                        has_child = get_int();
                  }
      }

      return true;
}

} // namespace

01215 namespace libk3dgeometry
{

k3d::iplugin_factory& ayam_reader_factory()
{
      return ayam_reader_implementation::get_factory();
}

} // namespace libk3dgeometry



Generated by  Doxygen 1.6.0   Back to index