src/ui/effects/inc/renderer/engine-model/FUiEffects_RendererEngineModelBuffer.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 /**
  19  * @file                FUiEffects_RendererEngineModelBuffer.h
  20  * @brief               Shaders attributes data buffers
  21  *
  22  */
  23
  24 #ifndef _FUI_EFFECTS_INTERNAL_RENDERER_ENGINE_MODEL_BUFFER_H_
  25 #define _FUI_EFFECTS_INTERNAL_RENDERER_ENGINE_MODEL_BUFFER_H_
  26
  27 #include <renderer/engine-model/FUiEffects_RendererEngineModelForwardDeclaration.h>
  28 #include <renderer/engine-model/FUiEffects_RendererEngineModelCache.h>
  29 #include <renderer/engine-model/FUiEffects_RendererEngineModelBufferVisitor.h>
  30
  31 #include <vector>
  32
  33 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace EngineModel
  34 {
  35 class Buffer
  36 {
  37 public:
  38         Buffer(void);
  39         virtual ~Buffer(void);
  40
  41         virtual void Visit(BufferVisitor& v)
  42         {
  43                 v.OnBuffer(*this);
  44                 return;
  45         }
  46 };
  47
  48 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<Buffer> BufferPtr;
  49
  50 class SolidBufferStrategy
  51 {
  52 public:
  53         class BufferUsage
  54         {
  55                 public:
  56                         enum BufferUsageEnum
  57                         {
  58                                 STREAM_DRAW = 0,
  59                                 STREAM_READ    ,
  60                                 STREAM_COPY    ,
  61                                 STATIC_DRAW    ,
  62                                 STATIC_READ    ,
  63                                 STATIC_COPY    ,
  64                                 DYNAMIC_DRAW   ,
  65                                 DYNAMIC_READ   ,
  66                                 DYNAMIC_COPY
  67                         };
  68                         typedef BufferUsageEnum Value;
  69         };
  70
  71         SolidBufferStrategy(void) {}
  72         virtual ~SolidBufferStrategy(void)
  73         {
  74                 if (_pCache)
  75                 {
  76                         _pCache->Die();
  77                 }
  78         }
  79
  80         virtual void* GetData(void) = 0;
  81         virtual size_t GetSize(void) const = 0;
  82         virtual BufferUsage::Value GetUsage(void) const = 0;
  83         virtual CachePtr GetCache(void)
  84         {
  85                 return _pCache;
  86         }
  87         virtual void SetCache(CachePtr aCache)
  88         {
  89                 if (_pCache)
  90                 {
  91                         _pCache->Die();
  92                 }
  93                 _pCache = aCache;
  94         }
  95
  96 protected:
  97         CachePtr _pCache;
  98 };
  99
 100 class TypedBufferStrategy
 101 {
 102 public:
 103         class DataType
 104         {
 105                 public:
 106                         enum DataTypeEnum
 107                         {
 108                                 BYTE = 0                ,
 109                                 UNSIGNED_BYTE   ,
 110                                 SHORT           ,
 111                                 UNSIGNED_SHORT  ,
 112                                 INT                             ,
 113                                 UNSIGNED_INT    ,
 114                                 FLOAT                   ,
 115                                 DOUBLE
 116                         };
 117                         typedef DataTypeEnum Value;
 118         };
 119
 120         TypedBufferStrategy(void) {}
 121         virtual ~TypedBufferStrategy(void) {}
 122
 123         virtual DataType::Value GetDataType(void) const = 0;
 124 };
 125
 126 class VertexBuffer: public Buffer, public SolidBufferStrategy, public TypedBufferStrategy
 127 {
 128 public:
 129         VertexBuffer(void) {}
 130         virtual ~VertexBuffer(void) {}
 131
 132         virtual void Visit(BufferVisitor& v) { v.OnVertexBuffer(*this); }
 133         virtual size_t GetComponentsPerElement(void) const = 0;
 134 };
 135
 136 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<VertexBuffer> VertexBufferPtr;
 137
 138 class IndexBuffer:
 139         public Buffer,
 140         public SolidBufferStrategy,
 141         public TypedBufferStrategy
 142 {
 143 public:
 144         class PrimitiveType
 145         {
 146                 public:
 147                         enum PrimitiveTypeEnum
 148                         {
 149                                 POINTS = 0              ,
 150                                 LINE_STRIP      ,
 151                                 LINE_LOOP       ,
 152                                 LINES           ,
 153                                 TRIANGLE_STRIP  ,
 154                                 TRIANGLE_FAN    ,
 155                                 TRIANGLES       ,
 156                                 QUAD_STRIP      ,
 157                                 QUADS           ,
 158                                 POLYGON
 159                         };
 160                         typedef PrimitiveTypeEnum Value;
 161         };
 162
 163         IndexBuffer(void) {}
 164         virtual ~IndexBuffer(void) {}
 165
 166         virtual void Visit(BufferVisitor& v) { v.OnIndexBuffer(*this); }
 167         virtual PrimitiveType::Value GetPrimitiveType() const = 0;
 168 };
 169
 170 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<IndexBuffer> IndexBufferPtr;
 171
 172 class CompositeVertexBuffer:
 173         public Buffer,
 174         public SolidBufferStrategy,
 175         public TypedBufferStrategy
 176 {
 177 public:
 178         CompositeVertexBuffer(void) {}
 179         virtual ~CompositeVertexBuffer(void) {}
 180
 181         virtual void Visit(BufferVisitor& v)
 182         {
 183                 v.OnCompositeVertexBuffer(*this);
 184                 return;
 185         }
 186 };
 187
 188 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<CompositeVertexBuffer> CompositeVertexBufferPtr;
 189
 190 class PartVertexBuffer:
 191         public Buffer,
 192         public TypedBufferStrategy
 193 {
 194 public:
 195         PartVertexBuffer(void) {}
 196         virtual ~PartVertexBuffer(void)
 197         {
 198                 if (_pCache)
 199                 {
 200                         _pCache->Die();
 201                 }
 202         }
 203
 204         virtual void Visit(BufferVisitor& v)
 205         {
 206                 v.OnPartVertexBuffer(*this);
 207                 return;
 208         }
 209
 210         virtual CachePtr GetCache(void) {return _pCache;}
 211
 212         virtual void SetCache(CachePtr pCache)
 213         {
 214                 if (_pCache)
 215                 {
 216                         _pCache->Die();
 217                 }
 218                 _pCache = pCache;
 219                 return;
 220         }
 221
 222         virtual size_t GetStride(void) const = 0;
 223         virtual size_t GetOffset(void) const = 0;
 224         virtual CompositeVertexBufferPtr GetCompositeBuffer(void) const = 0;
 225         virtual size_t GetComponentsPerElement(void) const = 0;
 226
 227 protected:
 228         CachePtr _pCache;
 229 };
 230
 231 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<PartVertexBuffer> PartVertexBufferPtr;
 232
 233 }}}}} //Tizen::Ui::Effects::_Renderer::EngineModel
 234
 235 #endif //_FUI_EFFECTS_INTERNAL_RENDERER_ENGINE_MODEL_BUFFER_H_