dali/internal/graphics/gles-impl/gles-graphics-program.h

   1 #ifndef DALI_GRAPHICS_GLES_PROGRAM_H
   2 #define DALI_GRAPHICS_GLES_PROGRAM_H
   3
   4 /*
   5  * Copyright (c) 2021 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 // EXTERNAL INCLUDES
  21 #include <dali/graphics-api/graphics-program-create-info.h>
  22 #include <dali/graphics-api/graphics-program.h>
  23
  24 // INTERNAL INCLUDES
  25 #include "gles-graphics-resource.h"
  26
  27 namespace Dali::Graphics::GLES
  28 {
  29 class Reflection;
  30
  31 /**
  32  * @brief Program implementation
  33  *
  34  * Program implementation is owned only by the PipelineCache
  35  *
  36  * Like pipeline, it's created and managed by the PipelineCache
  37  */
  38 class ProgramImpl
  39 {
  40 public:
  41   /**
  42    * @brief Constructor
  43    *
  44    * @param[in] createInfo  Valid create info structure
  45    * @param[in] controller Valid reference to the controller object
  46    */
  47   ProgramImpl(const Graphics::ProgramCreateInfo& createInfo, Graphics::EglGraphicsController& controller);
  48
  49   /**
  50    * @brief Destructor
  51    */
  52   ~ProgramImpl();
  53
  54   /**
  55    * @brief Destroys GL resources associated with the Program
  56    *
  57    * @return True on success
  58    */
  59   bool Destroy();
  60
  61   /**
  62    * @brief Creates GL resource for this Program
  63    *
  64    * @return True on success
  65    */
  66   bool Create();
  67
  68   /**
  69    * @brief Returns GL program id
  70    *
  71    * @return GL program id
  72    */
  73   [[nodiscard]] uint32_t GetGlProgram() const;
  74
  75   /**
  76    * @brief Increases ref count
  77    *
  78    * @return new refcount
  79    */
  80   uint32_t Retain();
  81
  82   /**
  83    * @brief Decreases ref count
  84    *
  85    * @return New refcount
  86    */
  87   uint32_t Release();
  88
  89   /**
  90    * @brief Returns reflection
  91    *
  92    * @return Valid reflection associated with the Program
  93    */
  94   [[nodiscard]] const GLES::Reflection& GetReflection() const;
  95
  96   /**
  97    * @brief Returns controller
  98    *
  99    * @return Valid Controller object
 100    */
 101   [[nodiscard]] EglGraphicsController& GetController() const;
 102
 103   /**
 104    * @brief Returns create info structure
 105    *
 106    * @return Reference to valid create info structure
 107    */
 108   [[nodiscard]] const ProgramCreateInfo& GetCreateInfo() const;
 109
 110   /**
 111    * @brief Returns parameter value specified by parameterId
 112    *
 113    * This function can be used as a backdoor into the implementation
 114    * used to retrieve internal data.
 115    *
 116    * @param[in] parameterId Integer parameter id
 117    * @param[out] out Pointer to write to
 118    *
 119    * @return True on success
 120    */
 121   bool GetParameter(uint32_t parameterId, void* out);
 122
 123 private:
 124   friend class Program;
 125
 126   struct Impl;
 127   std::unique_ptr<Impl> mImpl;
 128 };
 129
 130 ///////////////////////////////////////////////////////////////
 131
 132 /**
 133  * @brief Wrapper for the pipeline implementation
 134  *
 135  * This object is returned back to the client-side
 136  */
 137 class Program : public Graphics::Program
 138 {
 139 public:
 140   /**
 141    * @brief Constructor
 142    *
 143    * @param[in] impl Pointer to valid implementation
 144    */
 145   explicit Program(ProgramImpl* impl)
 146   : mProgram(impl)
 147   {
 148     mProgram->Retain();
 149   }
 150
 151   /**
 152    * @brief Destructor
 153    */
 154   ~Program() override;
 155
 156   /**
 157    * @brief Returns reference to the Reflection object
 158
 159    * @return Reflection
 160    */
 161   [[nodiscard]] const GLES::Reflection& GetReflection() const;
 162
 163   /**
 164    * @brief Retrieves internal program implementation
 165    *
 166    * @return Valid pointer to the ProgramImpl object
 167    */
 168   [[nodiscard]] ProgramImpl* GetImplementation() const
 169   {
 170     return mProgram;
 171   }
 172
 173   /**
 174    * @brief Returns controller
 175    *
 176    * @return controller
 177    */
 178   [[nodiscard]] EglGraphicsController& GetController() const;
 179
 180   /**
 181    * @brief Returns create info structure
 182    *
 183    * @return create info structure
 184    */
 185   [[nodiscard]] const ProgramCreateInfo& GetCreateInfo() const;
 186
 187   bool operator==(const GLES::Program& program) const
 188   {
 189     return (program.mProgram == mProgram);
 190   }
 191
 192   bool operator==(const GLES::ProgramImpl* programImpl) const
 193   {
 194     return (programImpl == mProgram);
 195   }
 196
 197   bool operator!=(const GLES::Program& program) const
 198   {
 199     return (program.mProgram != mProgram);
 200   }
 201
 202   /**
 203    * @brief Run by UniquePtr to discard resource
 204    */
 205   void DiscardResource();
 206
 207   /**
 208    * @brief Destroying GL resources
 209    *
 210    * This function is kept for compatibility with Resource<> class
 211    * so can the object can be use with templated functions.
 212    */
 213   void DestroyResource()
 214   {
 215     // nothing to do here
 216   }
 217
 218 private:
 219   ProgramImpl* mProgram{nullptr};
 220 };
 221 } // namespace Dali::Graphics::GLES
 222
 223 #endif //DALI_GRAPHICS_GLES_PROGRAM_H