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     return (irr_scene_IAnimatedMeshSceneNode*)
  93       ((irr::scene::ISceneManager*)smgr)
  94       ->addAnimatedMeshSceneNode((irr::scene::IAnimatedMesh*)mesh,
  95                                  (irr::scene::ISceneNode*)parent,
  96                                  id,
  97                                  position ? *(irr::core::vector3df*)position : irr::core::vector3df(0, 0, 0),
  98                                  rotation ? *(irr::core::vector3df*)rotation : irr::core::vector3df(0, 0, 0),
  99                                  scale ? *(irr::core::vector3df*)scale : irr::core::vector3df(1, 1, 1),
 100                                  alsoAddIfMeshPointerZero);
 101   }
 102
 103   irr_scene_ICameraSceneNode*
 104   irr_scene_addCameraSceneNode(irr_scene_ISceneManager* smgr,
 105                                irr_scene_ISceneNode* parent,
 106                                irr_core_vector3df* position,
 107                                irr_core_vector3df* lookat,
 108                                int32_t id,
 109                                bool makeActive)
 110   {
 111     return (irr_scene_ICameraSceneNode*)
 112       ((irr::scene::ISceneManager*)smgr)
 113       ->addCameraSceneNode((irr::scene::ISceneNode*)parent,
 114                            position ? *(irr::core::vector3df*)position : irr::core::vector3df(0, 0, 0),
 115                            lookat ? *(irr::core::vector3df*)lookat : irr::core::vector3df(0, 0, 100),
 116                            id,
 117                            makeActive);
 118   }
 119
 120   irr_scene_ICameraSceneNode*
 121   irr_scene_addCameraSceneNodeFPS(irr_scene_ISceneManager* smgr,
 122                                   irr_scene_ISceneNode* parent,
 123                                   float_t rotateSpeed,
 124                                   float_t moveSpeed,
 125                                   int32_t id,
 126                                   irr_SkeyMap* keyMapArray,
 127                                   int32_t keyMapSize,
 128                                   bool noVerticalMovement,
 129                                   float_t jumpSpeed,
 130                                   bool invertMouse,
 131                                   bool makeActive)
 132   {
 133     return ((irr::scene::ISceneManager*)smgr)
 134       ->addCameraSceneNodeFPS((irr::scene::ISceneNode*)parent,
 135                               rotateSpeed,
 136                               moveSpeed,
 137                               id,
 138                               (irr::SKeyMap*)keyMapArray,
 139                               keyMapSize,
 140                               noVerticalMovement,
 141                               jumpSpeed,
 142                               invertMouse,
 143                               makeActive);
 144   }
 145
 146   irr_scene_ISceneNode*
 147   irr_scene_addCustomSceneNode(irr_scene_ISceneManager* smgr,
 148                                irr_scene_ISceneNode* parent,
 149                                int32_t id,
 150                                irr_core_vector3df* position,
 151                                irr_core_vector3df* rotation,
 152                                irr_core_vector3df* scale,
 153                                void (*render)(),
 154                                irr_core_aabbox3d_f32* (*getBoundingBox)(),
 155                                uint32_t (*getMaterialCount)(),
 156                                irr_video_SMaterial* (*getMaterial)(unsigned int i))
 157   {
 158     if (parent == NULL)
 159       {
 160         parent = irr_scene_getRootSceneNode(smgr);
 161       }
 162
 163     CustomSceneNode *node =
 164       new CustomSceneNode((irr::scene::ISceneNode*)parent,
 165                           (irr::scene::ISceneManager*)smgr,
 166                           id,
 167                           position ? *(irr::core::vector3df*)position : irr::core::vector3df(0, 0, 0),
 168                           rotation ? *(irr::core::vector3df*)rotation : irr::core::vector3df(0, 0, 0),
 169                           scale ? *(irr::core::vector3df*)scale : irr::core::vector3df(1, 1, 1),
 170                           render,
 171                           getBoundingBox,
 172                           getMaterialCount,
 173                           getMaterial);
 174     return node;
 175   }
 176
 177   irr_scene_IMeshSceneNode*
 178   irr_scene_addOctreeSceneNode(irr_scene_ISceneManager* smgr,
 179                                irr_scene_IAnimatedMesh* mesh,
 180                                irr_scene_ISceneNode* parent,
 181                                int32_t id,
 182                                int32_t minimalPolysPerNode,
 183                                bool alsoAddIfMeshPointerZero)
 184   {
 185     return ((irr::scene::ISceneManager*)smgr)
 186       ->addOctreeSceneNode((irr::scene::IAnimatedMesh*)mesh,
 187                            (irr::scene::ISceneNode*)parent,
 188                            id,
 189                            minimalPolysPerNode,
 190                            alsoAddIfMeshPointerZero);
 191   }
 192
 193   irr_scene_ISceneNodeAnimator*
 194   irr_scene_createRotationAnimator(irr_scene_ISceneManager* smgr,
 195                                    irr_core_vector3df* rotationSpeed)
 196   {
 197     return ((irr::scene::ISceneManager*)smgr)
 198       ->createRotationAnimator(*(irr::core::vector3df*)rotationSpeed);
 199   }
 200
 201   void
 202   irr_scene_drawAll(irr_scene_ISceneManager* smgr)
 203   {
 204     ((irr::scene::ISceneManager*)smgr)->drawAll();
 205   }
 206
 207
 208   irr_scene_IAnimatedMesh*
 209   irr_scene_getMesh(irr_scene_ISceneManager* smgr,
 210                     const char* filename)
 211   {
 212     return (irr_scene_IAnimatedMesh*)
 213       ((irr::scene::ISceneManager*)smgr)->getMesh(filename);
 214   }
 215
 216   irr_scene_ISceneNode*
 217   irr_scene_getRootSceneNode(irr_scene_ISceneManager* smgr)
 218   {
 219     return (irr_scene_ISceneNode*)
 220       ((irr::scene::ISceneManager*)smgr)->getRootSceneNode();
 221   }
 222 }