dali/public-api/modeling/model-data.h

   1 #ifndef __DALI_MODEL_DATA_H__
   2 #define __DALI_MODEL_DATA_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21
  22 // EXTERNAL INCLUDES
  23 #include <string>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/modeling/model-animation-map.h>
  27 #include <dali/public-api/object/base-handle.h>
  28
  29 namespace Dali DALI_IMPORT_API
  30 {
  31
  32 class Entity;
  33 class MeshData;
  34 class Material;
  35 class Light;
  36
  37 namespace Internal DALI_INTERNAL
  38 {
  39 class ModelData;
  40 }
  41
  42 /**
  43  * @brief Encapsulates a Dali 3D model/scene.
  44  *
  45  * This is usually generated by an external model loader (and is also
  46  * used internally with the default model loader).
  47  */
  48 class ModelData : public BaseHandle
  49 {
  50 public:
  51
  52   /**
  53    * @brief Constructs an uninitialized handle.
  54    */
  55   ModelData();
  56
  57   /**
  58    * @brief Create an initialized ModelData.
  59    *
  60    * @param[in] name The name of the model.
  61    * @return A handle to a newly allocated Dali resource.
  62    */
  63   static ModelData New(const std::string& name);
  64
  65   /**
  66    * @brief Downcast an Object handle to ModelData handle.
  67    *
  68    * If handle points to a ModelData object the downcast produces
  69    * valid handle. If not the returned handle is left uninitialized.
  70    *
  71    * @param[in] handle to An object
  72    * @return handle to a ModelData object or an uninitialized handle
  73    */
  74   static ModelData DownCast( BaseHandle handle );
  75
  76   /**
  77    * @brief Destructor
  78    *
  79    * This is non-virtual since derived Handle types must not contain data or virtual methods.
  80    */
  81   ~ModelData();
  82
  83   /**
  84    * @brief This copy constructor is required for (smart) pointer semantics.
  85    *
  86    * @param [in] handle A reference to the copied handle
  87    */
  88   ModelData(const ModelData& handle);
  89
  90   /**
  91    * @brief This assignment operator is required for (smart) pointer semantics.
  92    *
  93    * @param [in] rhs  A reference to the copied handle
  94    * @return A reference to this
  95    */
  96   ModelData& operator=(const ModelData& rhs);
  97
  98   /**
  99    * @brief This method is defined to allow assignment of the NULL value,
 100    * and will throw an exception if passed any other value.
 101    *
 102    * Assigning to NULL is an alias for Reset().
 103    * @param [in] rhs  A NULL pointer
 104    * @return A reference to this handle
 105    */
 106   ModelData& operator=(BaseHandle::NullType* rhs);
 107
 108   /**
 109    * @brief Returns the name of the model.
 110    *
 111    * @return The model name
 112    */
 113   const std::string& GetName() const;
 114
 115   /**
 116    * @brief Set the root Entity of the model.
 117    *
 118    * @param root A handle to the root entity
 119    */
 120   void SetRootEntity(Entity root);
 121
 122   /**
 123    * @brief Get the root Entity of the model.
 124    *
 125    * @return The root entity
 126    */
 127   Entity GetRootEntity() const;
 128
 129   /**
 130    * @brief Add a mesh to the model.
 131    *
 132    * @param mesh The mesh data to add.
 133    */
 134   void AddMesh(MeshData& mesh);
 135
 136   /**
 137    * @brief Get a mesh by index.
 138    *
 139    * @param[in] index The zero based index to a mesh
 140    * @return          The mesh.
 141    */
 142   const MeshData& GetMesh(unsigned int index) const;
 143
 144   /**
 145    * @brief Get a mesh by index.
 146    *
 147    * @param[in] index The zero based index to a mesh
 148    * @return          The mesh.
 149    */
 150   MeshData& GetMesh(unsigned int index);
 151
 152   /**
 153    * @brief Get Mesh count.
 154    *
 155    * @returns number of meshes
 156    */
 157   unsigned int NumberOfMeshes() const;
 158
 159   /**
 160    * @brief Add material to the model.
 161    *
 162    * @param[in] material - the material to add to the model
 163    */
 164   void AddMaterial(Material material);
 165
 166   /**
 167    * @brief Get a material by index.
 168    *
 169    * @param[in] index The index to a material
 170    * @return          A handle to a material, or NULL.
 171    */
 172   Material GetMaterial(unsigned int index) const;
 173
 174   /**
 175    * @brief Get material count.
 176    *
 177    * @return The Number of materials
 178    */
 179   unsigned int NumberOfMaterials() const;
 180
 181   /**
 182    * @brief Get animation map container.
 183    *
 184    * @return reference to the animation map container.
 185    */
 186    ModelAnimationMapContainer& GetAnimationMapContainer();
 187
 188   /**
 189    * @brief Find the index for the given animation name.
 190    *
 191    * @param[in] name The name of the animation map to search for.
 192    * @param[out] index The index of the found map
 193    * @return true if the name was found, false otherwise.
 194    */
 195   bool FindAnimation (const std::string& name, unsigned int& index) const;
 196
 197   /**
 198    * @return the number of animations defined for this model
 199    */
 200   unsigned int NumberOfAnimationMaps() const;
 201
 202   /**
 203    * @brief Add a light to the model.
 204    *
 205    * @param light - the light to add to the model
 206    */
 207   void AddLight(Light light);
 208
 209   /**
 210    * @brief Get a light by index.
 211    *
 212    * @param[in] index The zero based index to a light
 213    * @return          A pointer to a light, or NULL.
 214    */
 215   Light GetLight(unsigned int index) const;
 216
 217   /**
 218    * @brief Get the number of lights contained in the model.
 219    *
 220    * @return The number of lights contained in the model.
 221    */
 222   unsigned int NumberOfLights() const;
 223
 224   /**
 225    * @brief Read the model data from an open streambuf.
 226    *
 227    * @param[in] buf A streambuf opened for reading
 228    * @return true if data was read successfully.
 229    */
 230   bool Read(std::streambuf& buf);
 231
 232   /**
 233    * @brief Write the model data to an open streambuf.
 234    *
 235    * @param[in] buf A streambuf opened for writing
 236    * @return true if data was written successfully.
 237    */
 238   bool Write(std::streambuf& buf) const;
 239
 240 public: // Not intended for application developers
 241   /**
 242    * @brief This constructor is used by Dali New() methods.
 243    *
 244    * @param[in] modelData A pointer to a newly allocated modelData
 245    */
 246   explicit DALI_INTERNAL ModelData(Internal::ModelData* modelData);
 247
 248 }; // Class ModelData
 249
 250 } // namespace Dali
 251
 252 #endif // __DALI_MODEL_DATA_H__