src/ISceneManager.cpp

   1 /* c-irrlicht --- C bindings for Irrlicht Engine
   2
   3    Copyright (C) 2019 Javier Sancho <jsf@jsancho.org>
   4
   5    This file is part of c-irrlicht.
   6
   7    c-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    c-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 "ISceneManager.h"
  24
  25 class CustomSceneNode : public irr::scene::ISceneNode
  26 {
  27   void (*Render)();
  28   irr_core_aabbox3d_f32* (*GetBoundingBox)();
  29   uint32_t (*GetMaterialCount)();
  30   irr_video_SMaterial* (*GetMaterial)(unsigned int i);
  31
  32 public:
  33   CustomSceneNode(irr::scene::ISceneNode* parent,
  34                   irr::scene::ISceneManager* smgr,
  35                   irr::s32 id,
  36                   const irr::core::vector3df& position,
  37                   const irr::core::vector3df& rotation,
  38                   const irr::core::vector3df& scale,
  39                   void (*render)(),
  40                   irr_core_aabbox3d_f32* (*getBoundingBox)(),
  41                   uint32_t (*getMaterialCount)(),
  42                   irr_video_SMaterial* (*getMaterial)(unsigned int i))
  43   : irr::scene::ISceneNode(parent, smgr, id, position, rotation, scale)
  44   {
  45     Render = render;
  46     GetBoundingBox = getBoundingBox;
  47     GetMaterialCount = getMaterialCount;
  48     GetMaterial = getMaterial;
  49   }
  50
  51   virtual void OnRegisterSceneNode()
  52   {
  53     if (IsVisible) {
  54       SceneManager->registerNodeForRendering(this);
  55     }
  56
  57     ISceneNode::OnRegisterSceneNode();
  58   }
  59
  60   virtual void render()
  61   {
  62     Render();
  63   }
  64
  65   virtual const irr::core::aabbox3d<irr::f32>& getBoundingBox() const
  66   {
  67     return *(irr::core::aabbox3d<irr::f32>*)GetBoundingBox();
  68   }
  69
  70   virtual irr::u32 getMaterialCount() const
  71   {
  72     return GetMaterialCount();
  73   }
  74
  75   virtual irr::video::SMaterial& getMaterial(irr::u32 i)
  76   {
  77     return *(irr::video::SMaterial*)GetMaterial(i);
  78   }
  79 };
  80
  81 extern "C" {
  82   irr_scene_IAnimatedMeshSceneNode*
  83   irr_scene_addAnimatedMeshSceneNode(irr_scene_ISceneManager* smgr,
  84                                      irr_scene_IAnimatedMesh* mesh,
  85                                      irr_scene_ISceneNode* parent,
  86                                      int32_t id,
  87                                      irr_core_vector3df* position,
  88                                      irr_core_vector3df* rotation,
  89                                      irr_core_vector3df* scale,
  90                                      bool alsoAddIfMeshPointerZero)
  91   {
  92     const irr::core::vector3df iPosition =
  93       position ?
  94       irr::core::vector3df(position->x, position->y, position->z) :
  95       irr::core::vector3df(0, 0, 0);
  96
  97     const irr::core::vector3df iRotation =
  98       rotation ?
  99       irr::core::vector3df(rotation->x, rotation->y, rotation->z) :
 100       irr::core::vector3df(0, 0, 0);
 101
 102     const irr::core::vector3df& iScale =
 103       scale ?
 104       irr::core::vector3df(scale->x, scale->y, scale->z) :
 105       irr::core::vector3df(1, 1, 1);
 106
 107     return (irr_scene_IAnimatedMeshSceneNode*)
 108       ((irr::scene::ISceneManager*)smgr)
 109       ->addAnimatedMeshSceneNode((irr::scene::IAnimatedMesh*)mesh,
 110                                  (irr::scene::ISceneNode*)parent,
 111                                  id,
 112                                  iPosition,
 113                                  iRotation,
 114                                  iScale,
 115                                  alsoAddIfMeshPointerZero);
 116   }
 117
 118   irr_scene_ICameraSceneNode*
 119   irr_scene_addCameraSceneNode(irr_scene_ISceneManager* smgr,
 120                                irr_scene_ISceneNode* parent,
 121                                irr_core_vector3df* position,
 122                                irr_core_vector3df* lookat,
 123                                int32_t id,
 124                                bool makeActive)
 125   {
 126     const irr::core::vector3df& iPosition =
 127       position ?
 128       irr::core::vector3df(position->x, position->y, position->z) :
 129       irr::core::vector3df(0, 0, 0);
 130
 131     const irr::core::vector3df& iLookat =
 132       lookat ?
 133       irr::core::vector3df(lookat->x, lookat->y, lookat->z) :
 134       irr::core::vector3df(0, 0, 100);
 135
 136     return (irr_scene_ICameraSceneNode*)
 137       ((irr::scene::ISceneManager*)smgr)
 138       ->addCameraSceneNode((irr::scene::ISceneNode*)parent,
 139                            iPosition,
 140                            iLookat,
 141                            id,
 142                            makeActive);
 143   }
 144
 145   irr_scene_ICameraSceneNode*
 146   irr_scene_addCameraSceneNodeFPS(irr_scene_ISceneManager* smgr,
 147                                   irr_scene_ISceneNode* parent,
 148                                   float_t rotateSpeed,
 149                                   float_t moveSpeed,
 150                                   int32_t id,
 151                                   irr_SkeyMap* keyMapArray,
 152                                   int32_t keyMapSize,
 153                                   bool noVerticalMovement,
 154                                   float_t jumpSpeed,
 155                                   bool invertMouse,
 156                                   bool makeActive)
 157   {
 158     return ((irr::scene::ISceneManager*)smgr)
 159       ->addCameraSceneNodeFPS((irr::scene::ISceneNode*)parent,
 160                               rotateSpeed,
 161                               moveSpeed,
 162                               id,
 163                               (irr::SKeyMap*)keyMapArray,
 164                               keyMapSize,
 165                               noVerticalMovement,
 166                               jumpSpeed,
 167                               invertMouse,
 168                               makeActive);
 169   }
 170
 171   irr_scene_ISceneNode*
 172   irr_scene_addCustomSceneNode(irr_scene_ISceneManager* smgr,
 173                                irr_scene_ISceneNode* parent,
 174                                int32_t id,
 175                                irr_core_vector3df* position,
 176                                irr_core_vector3df* rotation,
 177                                irr_core_vector3df* scale,
 178                                void (*render)(),
 179                                irr_core_aabbox3d_f32* (*getBoundingBox)(),
 180                                uint32_t (*getMaterialCount)(),
 181                                irr_video_SMaterial* (*getMaterial)(unsigned int i))
 182   {
 183     if (parent == NULL)
 184       {
 185         parent = irr_scene_getRootSceneNode(smgr);
 186       }
 187
 188     const irr::core::vector3df iPosition =
 189       position ?
 190       irr::core::vector3df(position->x, position->y, position->z) :
 191       irr::core::vector3df(0, 0, 0);
 192
 193     const irr::core::vector3df iRotation =
 194       rotation ?
 195       irr::core::vector3df(rotation->x, rotation->y, rotation->z) :
 196       irr::core::vector3df(0, 0, 0);
 197
 198     const irr::core::vector3df& iScale =
 199       scale ?
 200       irr::core::vector3df(scale->x, scale->y, scale->z) :
 201       irr::core::vector3df(1, 1, 1);
 202
 203     CustomSceneNode *node =
 204       new CustomSceneNode((irr::scene::ISceneNode*)parent,
 205                           (irr::scene::ISceneManager*)smgr,
 206                           id,
 207                           iPosition,
 208                           iRotation,
 209                           iScale,
 210                           render,
 211                           getBoundingBox,
 212                           getMaterialCount,
 213                           getMaterial);
 214     return node;
 215   }
 216
 217   irr_scene_IMeshSceneNode*
 218   irr_scene_addOctreeSceneNode(irr_scene_ISceneManager* smgr,
 219                                irr_scene_IAnimatedMesh* mesh,
 220                                irr_scene_ISceneNode* parent,
 221                                int32_t id,
 222                                int32_t minimalPolysPerNode,
 223                                bool alsoAddIfMeshPointerZero)
 224   {
 225     return ((irr::scene::ISceneManager*)smgr)
 226       ->addOctreeSceneNode((irr::scene::IAnimatedMesh*)mesh,
 227                            (irr::scene::ISceneNode*)parent,
 228                            id,
 229                            minimalPolysPerNode,
 230                            alsoAddIfMeshPointerZero);
 231   }
 232
 233   irr_scene_ISceneNodeAnimator*
 234   irr_scene_createRotationAnimator(irr_scene_ISceneManager* smgr,
 235                                    irr_core_vector3df* rotationSpeed)
 236   {
 237     const irr::core::vector3df& irrRotationSpeed =
 238       irr::core::vector3df(rotationSpeed->x, rotationSpeed->y, rotationSpeed->z);
 239
 240     return ((irr::scene::ISceneManager*)smgr)
 241       ->createRotationAnimator(irrRotationSpeed);
 242   }
 243
 244   void
 245   irr_scene_drawAll(irr_scene_ISceneManager* smgr)
 246   {
 247     ((irr::scene::ISceneManager*)smgr)->drawAll();
 248   }
 249
 250
 251   irr_scene_IAnimatedMesh*
 252   irr_scene_getMesh(irr_scene_ISceneManager* smgr,
 253                     const char* filename)
 254   {
 255     return (irr_scene_IAnimatedMesh*)
 256       ((irr::scene::ISceneManager*)smgr)->getMesh(filename);
 257   }
 258
 259   irr_scene_ISceneNode*
 260   irr_scene_getRootSceneNode(irr_scene_ISceneManager* smgr)
 261   {
 262     return (irr_scene_ISceneNode*)
 263       ((irr::scene::ISceneManager*)smgr)->getRootSceneNode();
 264   }
 265 }