Rename GPURenderPipeline to RenderPipeline and GPUShaderModule to ShaderModule. (#954)

Author: domchen

src/gpu/GPU.h

@@ -21,9 +21,9 @@
 #include <memory>
 #include "gpu/CommandEncoder.h"
 #include "gpu/CommandQueue.h"
-#include "gpu/GPURenderPipeline.h"
 #include "gpu/GPUSampler.h"
-#include "gpu/GPUShaderModule.h"
+#include "gpu/RenderPipeline.h"
+#include "gpu/ShaderModule.h"
 #include "gpu/YUVFormat.h"
 #include "tgfx/gpu/Backend.h"
 #include "tgfx/gpu/Caps.h"
@@ -141,18 +141,18 @@ class GPU {
   virtual std::shared_ptr<GPUSampler> createSampler(const GPUSamplerDescriptor& descriptor) = 0;
 
   /**
-   * Creates a GPUShaderModule from the provided shader code. The shader code must be valid and
+   * Creates a ShaderModule from the provided shader code. The shader code must be valid and
    * compatible with the GPU backend. Returns nullptr if the shader module creation fails.
    */
-  virtual std::shared_ptr<GPUShaderModule> createShaderModule(
-      const GPUShaderModuleDescriptor& descriptor) = 0;
+  virtual std::shared_ptr<ShaderModule> createShaderModule(
+      const ShaderModuleDescriptor& descriptor) = 0;
 
   /**
-   * Creates a GPURenderPipeline that manages the vertex and fragment shader stages for use in a
+   * Creates a RenderPipeline that manages the vertex and fragment shader stages for use in a
    * RenderPass. Returns nullptr if pipeline creation fails.
    */
-  virtual std::shared_ptr<GPURenderPipeline> createRenderPipeline(
-      const GPURenderPipelineDescriptor& descriptor) = 0;
+  virtual std::shared_ptr<RenderPipeline> createRenderPipeline(
+      const RenderPipelineDescriptor& descriptor) = 0;
 
   /**
    * Creates a command encoder that can be used to encode commands to be issued to the GPU.

src/gpu/ProgramInfo.h

@@ -19,8 +19,8 @@
 #pragma once
 
 #include <unordered_map>
-#include "gpu/GPURenderPipeline.h"
 #include "gpu/RenderPass.h"
+#include "gpu/RenderPipeline.h"
 #include "gpu/processors/EmptyXferProcessor.h"
 #include "gpu/processors/FragmentProcessor.h"
 #include "gpu/processors/GeometryProcessor.h"

src/gpu/RenderPass.h

@@ -20,9 +20,9 @@
 
 #include "core/utils/Log.h"
 #include "gpu/GPUBuffer.h"
-#include "gpu/GPURenderPipeline.h"
 #include "gpu/GPUSampler.h"
 #include "gpu/GPUTexture.h"
+#include "gpu/RenderPipeline.h"
 #include "tgfx/core/Color.h"
 
 namespace tgfx {
@@ -266,7 +266,7 @@ class RenderPass {
    * Sets the render pipeline to be used for subsequent draw calls. The pipeline defines the shader
    * programs and fixed-function state used during rendering.
    */
-  virtual void setPipeline(std::shared_ptr<GPURenderPipeline> pipeline) = 0;
+  virtual void setPipeline(std::shared_ptr<RenderPipeline> pipeline) = 0;
 
   /**
    * Sets the uniform data to a specified binding index in the shader's UBO table.

src/gpu/GPURenderPipeline.cpp renamed to src/gpu/RenderPipeline.cpp

@@ -16,7 +16,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include "GPURenderPipeline.h"
+#include "RenderPipeline.h"
 
 namespace tgfx {
 VertexDescriptor::VertexDescriptor(std::vector<Attribute> attribs, size_t stride)

src/gpu/GPURenderPipeline.h renamed to src/gpu/RenderPipeline.h

@@ -26,7 +26,7 @@
 #include "gpu/BlendOperation.h"
 #include "gpu/ColorWriteMask.h"
 #include "gpu/CompareFunction.h"
-#include "gpu/GPUShaderModule.h"
+#include "gpu/ShaderModule.h"
 #include "gpu/StencilOperation.h"
 #include "gpu/Uniform.h"
 #include "tgfx/gpu/PixelFormat.h"
@@ -95,9 +95,9 @@ class PipelineColorAttachment {
 class FragmentDescriptor {
  public:
   /**
-   * A GPUShaderModule object containing the fragment shader code.
+   * A ShaderModule object containing the fragment shader code.
    */
-  std::shared_ptr<GPUShaderModule> module = nullptr;
+  std::shared_ptr<ShaderModule> module = nullptr;
 
   /**
    * The name of the entry point function in the shader code.
@@ -129,9 +129,9 @@ class VertexDescriptor {
   VertexDescriptor(std::vector<Attribute> attributes, size_t vertexStride = 0);
 
   /**
-   * A GPUShaderModule object containing the vertex shader code.
+   * A ShaderModule object containing the vertex shader code.
    */
-  std::shared_ptr<GPUShaderModule> module = nullptr;
+  std::shared_ptr<ShaderModule> module = nullptr;
 
   /**
    * The name of the entry point function in the shader code.
@@ -263,7 +263,7 @@ class DepthStencilDescriptor {
 /**
  * Options you provide to a GPU device to create a render pipeline state.
  */
-class GPURenderPipelineDescriptor {
+class RenderPipelineDescriptor {
  public:
   /**
    * The vertex shader entry point and its input buffer layouts.
@@ -289,11 +289,11 @@ class GPURenderPipelineDescriptor {
 };
 
 /**
- * GPURenderPipeline represents a graphics pipeline configuration for a render pass, which the pass
+ * RenderPipeline represents a graphics pipeline configuration for a render pass, which the pass
  * applies to the draw commands you encode.
  */
-class GPURenderPipeline {
+class RenderPipeline {
  public:
-  virtual ~GPURenderPipeline() = default;
+  virtual ~RenderPipeline() = default;
 };
 }  // namespace tgfx

src/gpu/GPUShaderModule.h renamed to src/gpu/ShaderModule.h

@@ -23,12 +23,12 @@
 
 namespace tgfx {
 /**
- * GPUShaderModuleDescriptor describes the properties required to create a GPUShaderModule.
+ * ShaderModuleDescriptor describes the properties required to create a ShaderModule.
  */
-class GPUShaderModuleDescriptor {
+class ShaderModuleDescriptor {
  public:
   /**
-   * The shader code to be compiled into a GPUShaderModule.
+   * The shader code to be compiled into a ShaderModule.
    */
   std::string code;
 
@@ -40,11 +40,11 @@ class GPUShaderModuleDescriptor {
 };
 
 /**
- * GPUShaderModule is an internal object that serves as a container for shader code，allowing it to
+ * ShaderModule is an internal object that serves as a container for shader code，allowing it to
  * be submitted to the GPU for execution within a pipeline.
  */
-class GPUShaderModule {
+class ShaderModule {
  public:
-  virtual ~GPUShaderModule() = default;
+  virtual ~ShaderModule() = default;
 };
 }  // namespace tgfx

src/gpu/glsl/GLSLProgramBuilder.cpp

@@ -173,21 +173,21 @@ std::shared_ptr<PipelineProgram> GLSLProgramBuilder::finalize() {
   }
   finalizeShaders();
   auto gpu = context->gpu();
-  GPUShaderModuleDescriptor vertexModule = {};
+  ShaderModuleDescriptor vertexModule = {};
   vertexModule.code = vertexShaderBuilder()->shaderString();
   vertexModule.stage = ShaderStage::Vertex;
   auto vertexShader = gpu->createShaderModule(vertexModule);
   if (vertexShader == nullptr) {
     return nullptr;
   }
-  GPUShaderModuleDescriptor fragmentModule = {};
+  ShaderModuleDescriptor fragmentModule = {};
   fragmentModule.code = fragmentShaderBuilder()->shaderString();
   fragmentModule.stage = ShaderStage::Fragment;
   auto fragmentShader = gpu->createShaderModule(fragmentModule);
   if (fragmentShader == nullptr) {
     return nullptr;
   }
-  GPURenderPipelineDescriptor descriptor = {};
+  RenderPipelineDescriptor descriptor = {};
   descriptor.vertex = {programInfo->getVertexAttributes()};
   descriptor.vertex.module = vertexShader;
   descriptor.fragment.module = fragmentShader;

src/gpu/opengl/GLGPU.cpp

@@ -225,8 +225,7 @@ std::shared_ptr<GPUSampler> GLGPU::createSampler(const GPUSamplerDescriptor& des
                                      ToGLWrap(descriptor.addressModeY), minFilter, magFilter);
 }
 
-std::shared_ptr<GPUShaderModule> GLGPU::createShaderModule(
-    const GPUShaderModuleDescriptor& descriptor) {
+std::shared_ptr<ShaderModule> GLGPU::createShaderModule(const ShaderModuleDescriptor& descriptor) {
   if (descriptor.code.empty()) {
     LOGE("GLGPU::createShaderModule() shader code is empty!");
     return nullptr;
@@ -260,8 +259,8 @@ std::shared_ptr<GPUShaderModule> GLGPU::createShaderModule(
   return makeResource<GLShaderModule>(shader);
 }
 
-std::shared_ptr<GPURenderPipeline> GLGPU::createRenderPipeline(
-    const GPURenderPipelineDescriptor& descriptor) {
+std::shared_ptr<RenderPipeline> GLGPU::createRenderPipeline(
+    const RenderPipelineDescriptor& descriptor) {
   auto vertexModule = static_cast<GLShaderModule*>(descriptor.vertex.module.get());
   auto fragmentModule = static_cast<GLShaderModule*>(descriptor.fragment.module.get());
   if (vertexModule == nullptr || vertexModule->shader() == 0 || vertexModule == nullptr ||

src/gpu/opengl/GLGPU.h

@@ -71,11 +71,11 @@ class GLGPU : public GPU {
 
   std::shared_ptr<GPUSampler> createSampler(const GPUSamplerDescriptor& descriptor) override;
 
-  std::shared_ptr<GPUShaderModule> createShaderModule(
-      const GPUShaderModuleDescriptor& descriptor) override;
+  std::shared_ptr<ShaderModule> createShaderModule(
+      const ShaderModuleDescriptor& descriptor) override;
 
-  std::shared_ptr<GPURenderPipeline> createRenderPipeline(
-      const GPURenderPipelineDescriptor& descriptor) override;
+  std::shared_ptr<RenderPipeline> createRenderPipeline(
+      const RenderPipelineDescriptor& descriptor) override;
 
   std::shared_ptr<CommandEncoder> createCommandEncoder() override;
 

src/gpu/opengl/GLRenderPass.cpp

@@ -84,7 +84,7 @@ void GLRenderPass::setScissorRect(int x, int y, int width, int height) {
   }
 }
 
-void GLRenderPass::setPipeline(std::shared_ptr<GPURenderPipeline> pipeline) {
+void GLRenderPass::setPipeline(std::shared_ptr<RenderPipeline> pipeline) {
   if (renderPipeline == pipeline) {
     return;
   }