src/scene-node.cpp

   1 /* guile-irrlicht --- GNU Guile bindings for Irrlicht Engine
   2
   3    Copyright (C) 2020 Javier Sancho <jsf@jsancho.org>
   4
   5    This file is part of guile-irrlicht.
   6
   7    guile-irrlicht is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU Lesser General Public License as
   9    published by the Free Software Foundation; either version 3 of the
  10    License, or (at your option) any later version.
  11
  12    guile-irrlicht is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with guile-irrlicht. If not, see
  19    <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include <irrlicht/irrlicht.h>
  23 #include <libguile.h>
  24
  25 #include "animated-mesh-scene-node.h"
  26 #include "camera-scene-node.h"
  27 #include "gsubr.h"
  28 #include "material-flags.h"
  29 #include "matrix4.h"
  30 #include "mesh-scene-node.h"
  31 #include "scene-node.h"
  32 #include "scene-node-animator.h"
  33 #include "texture.h"
  34 #include "vector3d.h"
  35 #include "wrapped.h"
  36
  37 extern "C" {
  38
  39   void
  40   init_scene_node (void)
  41   {
  42     init_scene_node_type ();
  43     DEFINE_GSUBR ("add-animator!", 2, 0, 0, irr_scene_addAnimator);
  44     DEFINE_GSUBR ("get-absolute-transformation", 1, 0, 0, irr_scene_getAbsoluteTransformation);
  45     DEFINE_GSUBR ("set-material-texture!", 3, 0, 0, irr_scene_setMaterialTexture);
  46     DEFINE_GSUBR ("set-rotation!", 2, 0, 0, irr_scene_setRotation);
  47     DEFINE_GSUBR ("set-scale!", 2, 0, 0, irr_scene_setScale);
  48   }
  49
  50   DEFINE_WRAPPED_TYPE (irr::scene::ISceneNode*, "scene-node",
  51                        init_scene_node_type, scene_node_p,
  52                        wrap_scene_node, unwrap_scene_node);
  53
  54   bool
  55   is_scene_node_object (SCM wrapped_scene_node)
  56   {
  57     return
  58       animated_mesh_scene_node_p (wrapped_scene_node) ||
  59       camera_scene_node_p (wrapped_scene_node) ||
  60       mesh_scene_node_p (wrapped_scene_node) ||
  61       scene_node_p (wrapped_scene_node);
  62   }
  63
  64   SCM
  65   irr_scene_addAnimator (SCM wrapped_scene_node,
  66                          SCM animator)
  67   {
  68 #define ADD_ANIMATOR(NODE) NODE->addAnimator (unwrap_scene_node_animator (animator));
  69
  70     if (animated_mesh_scene_node_p (wrapped_scene_node))
  71       {
  72         ADD_ANIMATOR (unwrap_animated_mesh_scene_node (wrapped_scene_node));
  73       }
  74     else if (mesh_scene_node_p (wrapped_scene_node))
  75       {
  76         ADD_ANIMATOR (unwrap_mesh_scene_node (wrapped_scene_node));
  77       }
  78     else if (scene_node_p (wrapped_scene_node))
  79       {
  80         ADD_ANIMATOR (unwrap_scene_node (wrapped_scene_node));
  81       }
  82     else
  83       {
  84         scm_error (scm_arg_type_key, NULL, "Cannot add animator to object: ~S",
  85                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
  86       }
  87     return SCM_UNSPECIFIED;
  88   }
  89
  90   SCM
  91   irr_scene_getAbsoluteTransformation (SCM wrapped_scene_node)
  92   {
  93     irr::scene::ISceneNode* node = unwrap_scene_node (wrapped_scene_node);
  94     return scm_from_matrix4 (node->getAbsoluteTransformation ());
  95   }
  96
  97   SCM
  98   irr_scene_getPosition (SCM wrapped_scene_node)
  99   {
 100 #define GET_POSITION(NODE) scm_from_vector3df (NODE->getPosition ());
 101
 102     if (scene_node_p (wrapped_scene_node))
 103       {
 104         return GET_POSITION (unwrap_scene_node (wrapped_scene_node));
 105       }
 106     else if (mesh_scene_node_p (wrapped_scene_node))
 107       {
 108         return GET_POSITION (unwrap_mesh_scene_node (wrapped_scene_node));
 109       }
 110     else
 111       {
 112         scm_error (scm_arg_type_key, NULL, "Cannot get position from object: ~S",
 113                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 114       }
 115   }
 116
 117   SCM
 118   irr_scene_ISceneNode_setMaterialFlag (SCM wrapped_scene_node,
 119                                         SCM flag,
 120                                         SCM newvalue)
 121   {
 122 #define SET_MATERIAL_FLAG(NODE) NODE->setMaterialFlag (scm_to_material_flag (flag), \
 123                                                        scm_to_bool (newvalue));
 124
 125     if (animated_mesh_scene_node_p (wrapped_scene_node))
 126       {
 127         SET_MATERIAL_FLAG (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 128       }
 129     else if (mesh_scene_node_p (wrapped_scene_node))
 130       {
 131         SET_MATERIAL_FLAG (unwrap_mesh_scene_node (wrapped_scene_node));
 132       }
 133     else if (scene_node_p (wrapped_scene_node))
 134       {
 135         SET_MATERIAL_FLAG (unwrap_scene_node (wrapped_scene_node));
 136       }
 137     else
 138       {
 139         scm_error (scm_arg_type_key, NULL, "Cannot set material flag to object: ~S",
 140                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 141       }
 142
 143     return SCM_UNSPECIFIED;
 144   }
 145
 146   SCM
 147   irr_scene_setMaterialTexture (SCM wrapped_scene_node,
 148                                 SCM texture_layer,
 149                                 SCM texture)
 150   {
 151 #define SET_MATERIAL_TEXTURE(NODE) NODE->setMaterialTexture (scm_to_uint32 (texture_layer), \
 152                                                              unwrap_texture (texture));
 153
 154     if (animated_mesh_scene_node_p (wrapped_scene_node))
 155       {
 156         SET_MATERIAL_TEXTURE (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 157       }
 158     else if (mesh_scene_node_p (wrapped_scene_node))
 159       {
 160         SET_MATERIAL_TEXTURE (unwrap_mesh_scene_node (wrapped_scene_node));
 161       }
 162     else if (scene_node_p (wrapped_scene_node))
 163       {
 164         SET_MATERIAL_TEXTURE (unwrap_scene_node (wrapped_scene_node));
 165       }
 166     else
 167       {
 168         scm_error (scm_arg_type_key, NULL, "Cannot set material texture to object: ~S",
 169                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 170       }
 171
 172     return SCM_UNSPECIFIED;
 173   }
 174
 175   SCM
 176   irr_scene_setPosition (SCM wrapped_scene_node,
 177                          SCM position)
 178   {
 179 #define SET_POSITION(NODE) NODE->setPosition (scm_to_vector3df (position));
 180
 181     if (scene_node_p (wrapped_scene_node))
 182       {
 183         SET_POSITION (unwrap_scene_node (wrapped_scene_node));
 184       }
 185     else if (mesh_scene_node_p (wrapped_scene_node))
 186       {
 187         SET_POSITION (unwrap_mesh_scene_node (wrapped_scene_node));
 188       }
 189     else
 190       {
 191         scm_error (scm_arg_type_key, NULL, "Cannot set position to object: ~S",
 192                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 193       }
 194
 195     return SCM_UNSPECIFIED;
 196   }
 197
 198   SCM
 199   irr_scene_setRotation (SCM wrapped_scene_node,
 200                          SCM rotation)
 201   {
 202 #define SET_ROTATION(NODE) NODE->setRotation (scm_to_vector3df (rotation));
 203
 204     if (animated_mesh_scene_node_p (wrapped_scene_node))
 205       {
 206         SET_ROTATION (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 207       }
 208     else if (camera_scene_node_p (wrapped_scene_node))
 209       {
 210         SET_ROTATION (unwrap_camera_scene_node (wrapped_scene_node));
 211       }
 212     else if (scene_node_p (wrapped_scene_node))
 213       {
 214         SET_ROTATION (unwrap_scene_node (wrapped_scene_node));
 215       }
 216     else
 217       {
 218         scm_error (scm_arg_type_key, NULL, "Cannot set rotation to object: ~S",
 219                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 220       }
 221
 222     return SCM_UNSPECIFIED;
 223   }
 224
 225   SCM
 226   irr_scene_setScale (SCM wrapped_scene_node,
 227                       SCM scale)
 228   {
 229 #define SET_SCALE(NODE) NODE->setScale (scm_to_vector3df (scale));
 230
 231     if (animated_mesh_scene_node_p (wrapped_scene_node))
 232       {
 233         SET_SCALE (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 234       }
 235     else if (scene_node_p (wrapped_scene_node))
 236       {
 237         SET_SCALE (unwrap_scene_node (wrapped_scene_node));
 238       }
 239     else
 240       {
 241         scm_error (scm_arg_type_key, NULL, "Cannot set scale to object: ~S",
 242                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 243       }
 244
 245     return SCM_UNSPECIFIED;
 246   }
 247
 248 }