src/ui/effects/inc/FUiEffects_RendererRendererGeometry.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file    FUiEffects_RendererRendererGeometry.h
  19  * @brief               This is the header file for the RendererGeometry class
  20  */
  21
  22 #ifndef _FUI_EFFECTS_INTERNAL_RENDERER_RENDERERGEOMETRY_H_
  23 #define _FUI_EFFECTS_INTERNAL_RENDERER_RENDERERGEOMETRY_H_
  24
  25 #include <renderer/engine-model/FUiEffects_RendererEngineModelAabb.h>
  26 #include <renderer/system/FUiEffects_RendererSystemData.h>
  27 #include <renderer/engine-model/FUiEffects_RendererEngineModelBuffer.h>
  28 #include <renderer/engine-model/FUiEffects_RendererEngineModelGeometry.h>
  29 #include <renderer/system/FUiEffects_RendererSystemSmartPtr.h>
  30
  31 #include <FUiEffects_RuntimeRenderDataSurface.h>
  32
  33 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer
  34 {
  35
  36 /**
  37  * @class       RendererGeometry
  38  * @brief       Class for renderer object geometry. Holds pointers to pData locations in memory.
  39  *
  40  */
  41 class RendererGeometry
  42         : public EngineModel::Geometry
  43 {
  44 public:
  45
  46         /**
  47          * Constructor
  48          */
  49         RendererGeometry(void);
  50
  51
  52         /**
  53          * Destructor
  54          */
  55         ~RendererGeometry(void);
  56
  57         EngineModel::BufferPtr GetBuffer(const std::string& aName) const;
  58
  59         EngineModel::BufferPtr GetIndexBuffer(void) const
  60         {
  61                 return __indexTriangles;
  62         }
  63
  64         EngineModel::IndexBuffer::PrimitiveType::Value GetPrimitiveType(void) const
  65         {
  66                 return __indexTriangles->GetPrimitiveType();
  67         }
  68
  69         const EngineModel::Aabb& GetBoundBox(void) const
  70         {
  71                 return __bBox;
  72         }
  73
  74
  75         /**
  76          * Set vertex pData pointer
  77          *
  78          * @param [in]  newdata     Vertex pData
  79          *
  80          * @return              void
  81          */
  82         void SetVertData(Tizen::Ui::Effects::_Runtime::VertexDataCollection& newdata)
  83         {
  84                 __composite->pData = &newdata;
  85                 InvalidateVertexData();
  86
  87                 return;
  88         }
  89
  90
  91         /**
  92          * Set indices pData pointer
  93          *
  94          * @param [in]  newdata     Indices pData
  95          *
  96          * @return              void
  97          */
  98         void SetIndices(Tizen::Ui::Effects::_Runtime::IndicesCollection& newdata)
  99         {
 100                 __indexTriangles->pData = &newdata;
 101                 InvalidateIndices();
 102
 103                 return;
 104         }
 105
 106
 107         /**
 108          * Invalidates vertex pData
 109          *
 110          * @return              void
 111          */
 112         void InvalidateVertexData(void)
 113         {
 114                 if (__composite->GetCache() != 0)
 115                 {
 116                         __composite->GetCache()->Invalidate();
 117                 }
 118
 119                 return;
 120         }
 121
 122
 123         /**
 124          * Invalidates indices pData
 125          *
 126          * @return              void
 127          */
 128         void InvalidateIndices(void)
 129         {
 130                 if(__indexTriangles->GetCache() != 0)
 131                 {
 132                         __indexTriangles->GetCache()->Invalidate();
 133                 }
 134
 135                 return;
 136         }
 137
 138 private:
 139
 140         /**
 141          * Hidden copy constructor
 142          */
 143         RendererGeometry(const RendererGeometry &rhs);
 144
 145
 146         /**
 147          * Hidden assignment operator
 148          */
 149         RendererGeometry& operator=(const RendererGeometry &rhs);
 150
 151 private:
 152         class _Buffer_UShortIndex
 153                 : public EngineModel::IndexBuffer
 154         {
 155         public:
 156                 _Buffer_UShortIndex(void)
 157                         : pData(null)
 158                 {
 159                 }
 160
 161                 ~_Buffer_UShortIndex(void)
 162                 {
 163                 }
 164
 165                 EngineModel::TypedBufferStrategy::DataType::Value GetDataType(void) const
 166                 {
 167                         return EngineModel::TypedBufferStrategy::DataType::UNSIGNED_SHORT;
 168                 }
 169
 170                 void* GetData(void)
 171                 {
 172                         return &(*pData)[0];
 173                 }
 174
 175                 size_t GetSize(void) const
 176                 {
 177                         return pData->size() * sizeof(Tizen::Ui::Effects::_Runtime::IndicesCollection::value_type);
 178                 }
 179
 180                 EngineModel::SolidBufferStrategy::BufferUsage::Value GetUsage(void) const
 181                 {
 182                         return EngineModel::SolidBufferStrategy::BufferUsage::STATIC_DRAW;
 183                 }
 184
 185                 EngineModel::IndexBuffer::PrimitiveType::Value GetPrimitiveType(void) const
 186                 {
 187                         return EngineModel::IndexBuffer::PrimitiveType::TRIANGLES;
 188                 }
 189
 190                 Tizen::Ui::Effects::_Runtime::IndicesCollection* pData;
 191         };
 192         typedef System::SmartPtr<_Buffer_UShortIndex> Buffer_UIntIndexPtr;
 193
 194         class _Buffer_CompositeFloatVertex
 195                 : public EngineModel::CompositeVertexBuffer
 196         {
 197         public:
 198                 _Buffer_CompositeFloatVertex(void)
 199                         : pData(null)
 200                 {
 201                 }
 202
 203                 ~_Buffer_CompositeFloatVertex(void)
 204                 {
 205                 }
 206
 207                 EngineModel::TypedBufferStrategy::DataType::Value GetDataType(void) const
 208                 {
 209                         return EngineModel::TypedBufferStrategy::DataType::FLOAT;
 210                 }
 211
 212                 void* GetData(void)
 213                 {
 214                         return &(*pData)[0];
 215                 }
 216
 217                 size_t GetSize(void) const
 218                 {
 219                         return pData->size() * sizeof(Tizen::Ui::Effects::_Runtime::VertexData);
 220                 }
 221
 222                 EngineModel::SolidBufferStrategy::BufferUsage::Value GetUsage(void) const
 223                 {
 224                         return EngineModel::SolidBufferStrategy::BufferUsage::DYNAMIC_DRAW;
 225                 }
 226
 227                 Tizen::Ui::Effects::_Runtime::VertexDataCollection* pData;
 228         };
 229         typedef System::SmartPtr<_Buffer_CompositeFloatVertex> Buffer_CompositeFloatVertexPtr;
 230
 231
 232         class _Buffer_VertexAttribute
 233                 : public EngineModel::PartVertexBuffer
 234         {
 235         public:
 236                 _Buffer_VertexAttribute(EngineModel::CompositeVertexBufferPtr aBuffer, size_t aComponents, size_t aOffset, size_t aStride):
 237                                                                 __stride(aStride), __offset(aOffset), __components(aComponents), __buffer(aBuffer)
 238                 {
 239                 }
 240
 241                 ~_Buffer_VertexAttribute(void)
 242                 {
 243                 }
 244
 245                 EngineModel::TypedBufferStrategy::DataType::Value GetDataType(void) const
 246                 {
 247                         return __buffer->GetDataType();
 248                 }
 249
 250                 size_t GetStride(void) const
 251                 {
 252                         return __stride;
 253                 }
 254
 255                 size_t GetOffset(void) const
 256                 {
 257                         return __offset;
 258                 }
 259
 260                 EngineModel::CompositeVertexBufferPtr GetCompositeBuffer(void) const
 261                 {
 262                         return __buffer;
 263                 }
 264
 265                 size_t GetComponentsPerElement(void) const
 266                 {
 267                         return __components;
 268                 }
 269
 270         private:
 271                 size_t __stride;
 272                 size_t __offset;
 273                 size_t __components;
 274                 EngineModel::CompositeVertexBufferPtr __buffer;
 275         };
 276         typedef System::SmartPtr<_Buffer_VertexAttribute> Buffer_VertexAttributePtr;
 277
 278
 279 private:
 280         Buffer_CompositeFloatVertexPtr __composite;
 281         Buffer_VertexAttributePtr __partVertex;
 282         Buffer_VertexAttributePtr __partNormal;
 283         Buffer_VertexAttributePtr __partTexCoords;
 284         Buffer_UIntIndexPtr __indexTriangles;
 285
 286         EngineModel::Aabb __bBox;
 287 };
 288
 289
 290 typedef System::SmartPtr<RendererGeometry> RendererGeometryPtr;
 291
 292 } } } } // Tizen::Ui::Effects::_EffectRenderer
 293
 294 #endif //_FUI_EFFECTS_INTERNAL_RENDERER_RENDERERGEOMETRY_H_