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 flag to object: ~S",
  85                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
  86       }
  87
  88     return SCM_UNSPECIFIED;
  89   }
  90
  91   SCM
  92   irr_scene_getAbsoluteTransformation (SCM wrapped_scene_node)
  93   {
  94     irr::scene::ISceneNode* node = unwrap_scene_node (wrapped_scene_node);
  95     return scm_from_matrix4 (node->getAbsoluteTransformation ());
  96   }
  97
  98   SCM
  99   irr_scene_getPosition (SCM wrapped_scene_node)
 100   {
 101     irr::scene::ISceneNode* node = unwrap_scene_node (wrapped_scene_node, false);
 102     return scm_from_vector3df (node->getPosition ());
 103   }
 104
 105   SCM
 106   irr_scene_ISceneNode_setMaterialFlag (SCM wrapped_scene_node,
 107                                         SCM flag,
 108                                         SCM newvalue)
 109   {
 110 #define SET_MATERIAL_FLAG(NODE) NODE->setMaterialFlag (scm_to_material_flag (flag), \
 111                                                        scm_to_bool (newvalue));
 112
 113     if (animated_mesh_scene_node_p (wrapped_scene_node))
 114       {
 115         SET_MATERIAL_FLAG (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 116       }
 117     else if (mesh_scene_node_p (wrapped_scene_node))
 118       {
 119         SET_MATERIAL_FLAG (unwrap_mesh_scene_node (wrapped_scene_node));
 120       }
 121     else if (scene_node_p (wrapped_scene_node))
 122       {
 123         SET_MATERIAL_FLAG (unwrap_scene_node (wrapped_scene_node));
 124       }
 125     else
 126       {
 127         scm_error (scm_arg_type_key, NULL, "Cannot set material flag to object: ~S",
 128                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 129       }
 130
 131     return SCM_UNSPECIFIED;
 132   }
 133
 134   SCM
 135   irr_scene_setMaterialTexture (SCM wrapped_scene_node,
 136                                 SCM texture_layer,
 137                                 SCM texture)
 138   {
 139 #define SET_MATERIAL_TEXTURE(NODE) NODE->setMaterialTexture (scm_to_uint32 (texture_layer), \
 140                                                              unwrap_texture (texture));
 141
 142     if (animated_mesh_scene_node_p (wrapped_scene_node))
 143       {
 144         SET_MATERIAL_TEXTURE (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 145       }
 146     else if (mesh_scene_node_p (wrapped_scene_node))
 147       {
 148         SET_MATERIAL_TEXTURE (unwrap_mesh_scene_node (wrapped_scene_node));
 149       }
 150     else if (scene_node_p (wrapped_scene_node))
 151       {
 152         SET_MATERIAL_TEXTURE (unwrap_scene_node (wrapped_scene_node));
 153       }
 154     else
 155       {
 156         scm_error (scm_arg_type_key, NULL, "Cannot set material texture to object: ~S",
 157                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 158       }
 159
 160     return SCM_UNSPECIFIED;
 161   }
 162
 163   SCM
 164   irr_scene_setPosition (SCM wrapped_scene_node,
 165                          SCM position)
 166   {
 167 #define SET_POSITION(NODE) NODE->setPosition (scm_to_vector3df (position));
 168
 169     if (scene_node_p (wrapped_scene_node))
 170       {
 171         SET_POSITION (unwrap_scene_node (wrapped_scene_node));
 172       }
 173     else if (mesh_scene_node_p (wrapped_scene_node))
 174       {
 175         SET_POSITION (unwrap_mesh_scene_node (wrapped_scene_node));
 176       }
 177     else
 178       {
 179         scm_error (scm_arg_type_key, NULL, "Cannot set position to object: ~S",
 180                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 181       }
 182
 183     return SCM_UNSPECIFIED;
 184   }
 185
 186   SCM
 187   irr_scene_setRotation (SCM wrapped_scene_node,
 188                          SCM rotation)
 189   {
 190 #define SET_ROTATION(NODE) NODE->setRotation (scm_to_vector3df (rotation));
 191
 192     if (animated_mesh_scene_node_p (wrapped_scene_node))
 193       {
 194         SET_ROTATION (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 195       }
 196     else if (camera_scene_node_p (wrapped_scene_node))
 197       {
 198         SET_ROTATION (unwrap_camera_scene_node (wrapped_scene_node));
 199       }
 200     else if (scene_node_p (wrapped_scene_node))
 201       {
 202         SET_ROTATION (unwrap_scene_node (wrapped_scene_node));
 203       }
 204     else
 205       {
 206         scm_error (scm_arg_type_key, NULL, "Cannot set rotation to object: ~S",
 207                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 208       }
 209
 210     return SCM_UNSPECIFIED;
 211   }
 212
 213   SCM
 214   irr_scene_setScale (SCM wrapped_scene_node,
 215                       SCM scale)
 216   {
 217 #define SET_SCALE(NODE) NODE->setScale (scm_to_vector3df (scale));
 218
 219     if (animated_mesh_scene_node_p (wrapped_scene_node))
 220       {
 221         SET_SCALE (unwrap_animated_mesh_scene_node (wrapped_scene_node));
 222       }
 223     else if (scene_node_p (wrapped_scene_node))
 224       {
 225         SET_SCALE (unwrap_scene_node (wrapped_scene_node));
 226       }
 227     else
 228       {
 229         scm_error (scm_arg_type_key, NULL, "Cannot set scale to object: ~S",
 230                    scm_list_1 (wrapped_scene_node), scm_list_1 (wrapped_scene_node));
 231       }
 232
 233     return SCM_UNSPECIFIED;
 234   }
 235
 236 }