DirectRendering:

[platform/core/uifw/dali-core.git] / dali / graphics-api / graphics-command-buffer.h

diff --git a/dali/graphics-api/graphics-command-buffer.h b/dali/graphics-api/graphics-command-buffer.h
index 4ef92c5..61dd8df 100644 (file)
--- a/dali/graphics-api/graphics-command-buffer.h
+++ b/dali/graphics-api/graphics-command-buffer.h
@@ -2,7 +2,7 @@
 #define DALI_GRAPHICS_COMMAND_BUFFER_H
 
 /*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,10 +25,11 @@ namespace Dali::Graphics
 {
 class Buffer;
 class Pipeline;
-class Texture;
-class Sampler;
 class RenderTarget;
 class RenderPass;
+class Sampler;
+class SyncObject;
+class Texture;
 
 /**
  * @brief Uniform buffer bindings.
@@ -87,6 +88,22 @@ struct ClearValue
   };
 };
 
+// Native rendering (using native APIs)
+
+enum class DrawNativeAPI
+{
+  GLES,
+  UNDEFINED
+};
+
+struct DrawNativeInfo
+{
+  DrawNativeAPI       api;      //< API used by the callback
+  Dali::CallbackBase* callback; //< Callback pointer
+  void*               userData; //< Data passed into the callback (unspecified type, callback should decode it)
+  void*               reserved; //< Reserved for internal use
+};
+
 /**
  * @brief CommandBuffer contains a stream of commands to be executed
  * by the controller.
@@ -110,9 +127,9 @@ public:
    * @param[in] buffers List of buffers to bind
    * @param[in] offsets List of offsets for each buffer
    */
-  virtual void BindVertexBuffers(uint32_t                   firstBinding,
-                                 std::vector<const Buffer*> buffers,
-                                 std::vector<uint32_t>      offsets) = 0;
+  virtual void BindVertexBuffers(uint32_t                          firstBinding,
+                                 const std::vector<const Buffer*>& buffers,
+                                 const std::vector<uint32_t>&      offsets) = 0;
 
   /**
    * @brief Binds uniform buffers
@@ -133,14 +150,14 @@ public:
    *
    * @param[in] textureBindings List of texture bindings
    */
-  virtual void BindTextures(std::vector<TextureBinding>& textureBindings) = 0;
+  virtual void BindTextures(const std::vector<TextureBinding>& textureBindings) = 0;
 
   /**
    * @brief Binds samplers
    *
    * @param[in] samplerBindings List of sampler bindings
    */
-  virtual void BindSamplers(std::vector<SamplerBinding>& samplerBindings) = 0;
+  virtual void BindSamplers(const std::vector<SamplerBinding>& samplerBindings) = 0;
 
   /**
    * @brief Binds buffer containing push constants
@@ -182,10 +199,10 @@ public:
    * @param[in] clearValues clear values (compatible with renderpass spec)
    */
   virtual void BeginRenderPass(
-    RenderPass*             renderPass,
-    RenderTarget*           renderTarget,
-    Rect2D                  renderArea,
-    std::vector<ClearValue> clearValues) = 0;
+    RenderPass*                    renderPass,
+    RenderTarget*                  renderTarget,
+    Rect2D                         renderArea,
+    const std::vector<ClearValue>& clearValues) = 0;
 
   /**
    * @brief Ends current render pass
@@ -195,8 +212,15 @@ public:
    * the Controller may use end RP marker in order to resolve resource
    * dependencies (for example, to know when target texture is ready
    * before passing it to another render pass).
+   *
+   * The caller may query the sync object to determine when this render
+   * pass has actually finished on the GPU.
+   *
+   * @param[in] syncObject If non-null, this object will ensure an
+   * appropriate fence sync object is created after the render pass is
+   * executed.
    */
-  virtual void EndRenderPass() = 0;
+  virtual void EndRenderPass(Graphics::SyncObject* syncObject) = 0;
 
   /**
    * @brief Executes a list of secondary command buffers
@@ -258,6 +282,21 @@ public:
     uint32_t stride) = 0;
 
   /**
+   * @brief Draws using native API (via callback)
+   *
+   * DrawNative should be use in order to acquire direct access to the
+   * graphics API like GL. Upon command execution, the backend will
+   * invoke given callback and pass API-specific arguments (for example,
+   * the GL callback will receive EGL context used for rendering).
+   *
+   * The client side must make sure the callback is valid for the
+   * time of execution.
+   *
+   * @param[in] drawInfo NativeDrawInfo structure
+   */
+  virtual void DrawNative(const DrawNativeInfo* drawInfo) = 0;
+
+  /**
    * @brief Resets CommandBuffer
    *
    * This function resets the command buffer and discards all previously