src/ui/effects/inc/renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderDrawableCache.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_RendererGraphicsEngineRenderDrawableCache.h
  20  * @brief       Class for drawable objects cache
  21  *
  22  */
  23
  24 #ifndef _FUI_EFFECTS_INTERNAL_RENDERER_GRAPHICS_ENGINE_RENDER_DRAWABLE_CACHE_H_
  25 #define _FUI_EFFECTS_INTERNAL_RENDERER_GRAPHICS_ENGINE_RENDER_DRAWABLE_CACHE_H_
  26
  27 #include <renderer/engine-model/FUiEffects_RendererEngineModelForwardDeclaration.h>
  28 #include <renderer/engine-model/FUiEffects_RendererEngineModelProperty.h>
  29
  30 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineOpenGLImplementation.h>
  31 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderCommand.h>
  32 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderCache.h>
  33 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderRenderTargetCache.h>
  34 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderStateCache.h>
  35
  36 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace GraphicsEngine
  37 {
  38
  39 class Render;
  40 class IndexBufferCache;
  41 class VertexBufferCache;
  42 class VertexBufferCache;
  43 class VertexBufferCache;
  44 class CompositeVertexBufferCache;
  45 class CompositeVertexBufferCache;
  46 class CompositeVertexBufferCache;
  47 class RenderTexture2dCache;
  48 class RenderProgramCache;
  49
  50 class UseProgram:
  51         public RenderCommand
  52 {
  53 public:
  54         UseProgram(RenderProgramCache* pProgram);
  55         virtual ~UseProgram(void) {}
  56
  57         virtual void Apply(Render*);
  58
  59 private:
  60         RenderProgramCache* __pProgram;
  61 };
  62
  63 class DisableProgramAttributers:
  64         public RenderCommand
  65 {
  66 public:
  67         DisableProgramAttributers(RenderProgramCache* pProgram);
  68         virtual ~DisableProgramAttributers(void) {}
  69
  70         virtual void Apply(Render*);
  71
  72 private:
  73         RenderProgramCache* __pProgram;
  74 };
  75
  76 class Sampler2dUniform:
  77         public RenderCommand
  78 {
  79 public:
  80         Sampler2dUniform(RenderTexture2dCache* pTexture, GLuint unit);
  81         virtual ~Sampler2dUniform(void) {}
  82
  83         virtual void Apply(Render*);
  84
  85 private:
  86         RenderTexture2dCache* __pTexture;
  87         GLuint __stage;
  88 };
  89
  90 class Sampler2dAttachmentUniform:
  91         public RenderCommand
  92 {
  93 public:
  94         Sampler2dAttachmentUniform(Texture2dAttachmentCache* pTexture, GLuint unit);
  95         virtual ~Sampler2dAttachmentUniform(void) {}
  96
  97 virtual void Apply(Render*);
  98
  99 private:
 100         Texture2dAttachmentCache* __pTexture;
 101         GLuint __stage;
 102 };
 103
 104 class Matrix4fUniform:
 105         public RenderCommand
 106 {
 107 public:
 108         Matrix4fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Matrix4fProperty* pUniform, GLuint location);
 109         virtual ~Matrix4fUniform(void) {}
 110
 111         virtual void Apply(Render*);
 112
 113 private:
 114         Tizen::Ui::Effects::_Renderer::EngineModel::Matrix4fProperty* __pUniform;
 115         GLuint __location;
 116 };
 117
 118 class IntUniform:
 119         public RenderCommand
 120 {
 121 public:
 122                 IntUniform(Tizen::Ui::Effects::_Renderer::EngineModel::IntProperty* pUniform, GLuint location);
 123         virtual ~IntUniform(void) {}
 124
 125         virtual void Apply(Render*);
 126
 127 private:
 128         Tizen::Ui::Effects::_Renderer::EngineModel::IntProperty* __pUniform;
 129         GLuint __location;
 130 };
 131
 132 class FloatUniform:
 133         public RenderCommand
 134 {
 135 public:
 136         FloatUniform(Tizen::Ui::Effects::_Renderer::EngineModel::FloatProperty* pUniform, GLuint location);
 137         virtual ~FloatUniform(void) {}
 138
 139         virtual void Apply(Render*);
 140
 141 private:
 142         Tizen::Ui::Effects::_Renderer::EngineModel::FloatProperty* __pUniform;
 143         GLuint __location;
 144 };
 145
 146 class FloatArrayUniform:
 147         public RenderCommand
 148 {
 149 public:
 150         FloatArrayUniform(Tizen::Ui::Effects::_Renderer::EngineModel::FloatArrayProperty* pUniform, GLuint location);
 151         virtual ~FloatArrayUniform(void) {}
 152
 153         virtual void Apply(Render*);
 154
 155 private:
 156         Tizen::Ui::Effects::_Renderer::EngineModel::FloatArrayProperty* __pUniform;
 157         GLuint __location;
 158 };
 159
 160 class Vector2fUniform:
 161         public RenderCommand
 162 {
 163 public:
 164         Vector2fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector2fProperty* pUniform, GLuint location);
 165         virtual ~Vector2fUniform(void) {}
 166
 167         virtual void Apply(Render*);
 168
 169 private:
 170         Tizen::Ui::Effects::_Renderer::EngineModel::Vector2fProperty* __pUniform;
 171         GLuint __location;
 172 };
 173
 174 class Vector3fUniform:
 175         public RenderCommand
 176 {
 177 public:
 178         Vector3fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector3fProperty* pUniform, GLuint location);
 179         virtual ~Vector3fUniform(void) {}
 180
 181         virtual void Apply(Render*);
 182
 183 private:
 184         Tizen::Ui::Effects::_Renderer::EngineModel::Vector3fProperty* __pUniform;
 185         GLuint __location;
 186 };
 187
 188 class Vector4fUniform:
 189         public RenderCommand
 190 {
 191 public:
 192         Vector4fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector4fProperty* pUniform, GLuint location);
 193         virtual ~Vector4fUniform(void) {}
 194
 195         virtual void Apply(Render*);
 196
 197 private:
 198         Tizen::Ui::Effects::_Renderer::EngineModel::Vector4fProperty* _pUniform;
 199         GLuint __location;
 200 };
 201
 202 class ProgramAttribute:
 203         public RenderCommand
 204 {
 205 public:
 206         ProgramAttribute(VertexBufferCache* pAttribute, GLuint location);
 207         virtual ~ProgramAttribute(void) {}
 208
 209         virtual void Apply(Render*);
 210
 211 private:
 212         VertexBufferCache* __pAttribute;
 213         GLuint __location;
 214 };
 215
 216 class BindBuffer:
 217         public RenderCommand
 218 {
 219 public:
 220         BindBuffer(CompositeVertexBufferCache* pBuffer);
 221         virtual ~BindBuffer(void) {}
 222
 223         virtual void Apply(Render*);
 224
 225 private:
 226         CompositeVertexBufferCache* __pBuffer;
 227 };
 228
 229 class DrawIndexed:
 230         public RenderCommand
 231 {
 232 public:
 233         DrawIndexed(IndexBufferCache* pBuffer);
 234         virtual ~DrawIndexed(void) {}
 235
 236         virtual void Apply(Render*);
 237
 238 private:
 239         IndexBufferCache* __pBuffer;
 240 };
 241
 242 class SetState:
 243         public RenderCommand
 244 {
 245 public:
 246         SetState(RenderStateCache* pState);
 247         virtual ~SetState(void) {}
 248
 249         virtual void Apply(Render*);
 250
 251 private:
 252         RenderStateCache* __pState;
 253 };
 254
 255 class RenderDrawableCache:
 256         public RenderCache
 257 {
 258 public:
 259         typedef std::vector<RenderCommandPtr> RenderCommandsListType;
 260         typedef RenderCommandsListType::size_type RenderCommandsListSizeType;
 261
 262         typedef std::vector<Tizen::Ui::Effects::_Renderer::EngineModel::TextureAttachment*> ExternalTexturesListType;
 263         typedef ExternalTexturesListType::size_type ExternalTexturesListSizeType;
 264
 265         RenderDrawableCache(Render* pRender, Tizen::Ui::Effects::_Renderer::EngineModel::Drawable* pDrawable);
 266         virtual ~RenderDrawableCache(void);
 267
 268         virtual void Die(void);
 269         virtual void DropCache(void);
 270         virtual void DestroyCache(void);
 271
 272         virtual void Validate(Render*);
 273
 274         void Draw(Render*);
 275         const Math::Matrix4f& GetWorld(void);
 276         bool HasAlphaBlend(Render*);
 277
 278         ExternalTexturesListSizeType NumExternalTextures(void);
 279         Tizen::Ui::Effects::_Renderer::EngineModel::TextureAttachment* GetExternalTexture(ExternalTexturesListSizeType index);
 280
 281 private:
 282         RenderCommandsListType __commands;
 283         RenderCommandsListType __ownCommands;
 284         Tizen::Ui::Effects::_Renderer::EngineModel::Drawable* __pDrawable;
 285         ExternalTexturesListType __externalTextures;
 286
 287         RenderStateCache* __pAlphaBlend;
 288 };
 289
 290 typedef Tizen::Ui::Effects::_Renderer::System::SmartPtr<RenderDrawableCache> RenderDrawableCachePtr;
 291
 292 }}}}} //Tizen::Ui::Effects::_Renderer::GraphicsEngine
 293
 294 #endif //_FUI_EFFECTS_INTERNAL_RENDERER_GRAPHICS_ENGINE_RENDER_DRAWABLE_CACHE_H_