react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/gpu/Backend.cpp

@@ -0,0 +1,275 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "tgfx/gpu/Backend.h"
+#include "metal/MetalDefines.h"
+#include "opengl/GLDefines.h"
+#include "vulkan/VulkanDefines.h"
+#include "webgpu/WebGPUDefines.h"
+
+namespace tgfx {
+
+static PixelFormat GLSizeFormatToPixelFormat(unsigned sizeFormat) {
+  switch (sizeFormat) {
+    case GL_BGRA:
+    case GL_BGRA8:
+      return PixelFormat::BGRA_8888;
+    case GL_R8:
+    case GL_RED:
+    case GL_ALPHA8:
+    case GL_ALPHA:
+      return PixelFormat::ALPHA_8;
+    case GL_LUMINANCE8:
+    case GL_LUMINANCE:
+      return PixelFormat::GRAY_8;
+    case GL_RG8:
+    case GL_RG:
+      return PixelFormat::RG_88;
+    default:
+      break;
+  }
+  return PixelFormat::RGBA_8888;
+}
+
+BackendTexture& BackendTexture::operator=(const BackendTexture& that) {
+  if (!that.isValid()) {
+    _width = _height = 0;
+    return *this;
+  }
+  _width = that._width;
+  _height = that._height;
+  _backend = that._backend;
+  switch (that._backend) {
+    case Backend::OpenGL:
+      glInfo = that.glInfo;
+      break;
+    case Backend::Metal:
+      metalInfo = that.metalInfo;
+      break;
+    case Backend::Vulkan:
+      vulkanInfo = that.vulkanInfo;
+      break;
+    case Backend::WebGPU:
+      webgpuInfo = that.webgpuInfo;
+      break;
+    default:
+      break;
+  }
+  return *this;
+}
+
+PixelFormat BackendTexture::format() const {
+  if (!isValid()) {
+    return PixelFormat::Unknown;
+  }
+  switch (_backend) {
+    case Backend::OpenGL:
+      return GLSizeFormatToPixelFormat(glInfo.format);
+    case Backend::Metal:
+      return MetalPixelFormatToPixelFormat(metalInfo.format);
+    case Backend::Vulkan:
+      return VulkanFormatToPixelFormat(vulkanInfo.format);
+    case Backend::WebGPU:
+      return WebGPUTextureFormatToPixelFormat(webgpuInfo.format);
+    default:
+      break;
+  }
+  return PixelFormat::Unknown;
+}
+
+bool BackendTexture::getGLTextureInfo(GLTextureInfo* glTextureInfo) const {
+  if (!isValid() || _backend != Backend::OpenGL) {
+    return false;
+  }
+  *glTextureInfo = glInfo;
+  return true;
+}
+
+bool BackendTexture::getMetalTextureInfo(MetalTextureInfo* metalTextureInfo) const {
+  if (!isValid() || _backend != Backend::Metal) {
+    return false;
+  }
+  *metalTextureInfo = metalInfo;
+  return true;
+}
+
+bool BackendTexture::getVulkanImageInfo(VulkanImageInfo* vulkanImageInfo) const {
+  if (!isValid() || _backend != Backend::Vulkan) {
+    return false;
+  }
+  *vulkanImageInfo = vulkanInfo;
+  return true;
+}
+
+bool BackendTexture::getWebGPUTextureInfo(WebGPUTextureInfo* webgpuTextureInfo) const {
+  if (!isValid() || _backend != Backend::WebGPU) {
+    return false;
+  }
+  *webgpuTextureInfo = webgpuInfo;
+  return true;
+}
+
+BackendRenderTarget& BackendRenderTarget::operator=(const BackendRenderTarget& that) {
+  if (!that.isValid()) {
+    _width = _height = 0;
+    return *this;
+  }
+  _width = that._width;
+  _height = that._height;
+  _backend = that._backend;
+  switch (that._backend) {
+    case Backend::OpenGL:
+      glInfo = that.glInfo;
+      break;
+    case Backend::Metal:
+      metalInfo = that.metalInfo;
+      break;
+    case Backend::Vulkan:
+      vulkanInfo = that.vulkanInfo;
+      break;
+    case Backend::WebGPU:
+      webgpuInfo = that.webgpuInfo;
+      break;
+    default:
+      break;
+  }
+  return *this;
+}
+
+PixelFormat BackendRenderTarget::format() const {
+  if (!isValid()) {
+    return PixelFormat::Unknown;
+  }
+  switch (_backend) {
+    case Backend::OpenGL:
+      return GLSizeFormatToPixelFormat(glInfo.format);
+    case Backend::Metal:
+      return MetalPixelFormatToPixelFormat(metalInfo.format);
+    case Backend::Vulkan:
+      return VulkanFormatToPixelFormat(vulkanInfo.format);
+    case Backend::WebGPU:
+      return WebGPUTextureFormatToPixelFormat(webgpuInfo.format);
+    default:
+      break;
+  }
+  return PixelFormat::Unknown;
+}
+
+bool BackendRenderTarget::getGLFramebufferInfo(GLFrameBufferInfo* glFrameBufferInfo) const {
+  if (!isValid() || _backend != Backend::OpenGL) {
+    return false;
+  }
+  *glFrameBufferInfo = glInfo;
+  return true;
+}
+
+bool BackendRenderTarget::getMetalTextureInfo(MetalTextureInfo* metalTextureInfo) const {
+  if (!isValid() || _backend != Backend::Metal) {
+    return false;
+  }
+  *metalTextureInfo = metalInfo;
+  return true;
+}
+
+bool BackendRenderTarget::getVulkanImageInfo(VulkanImageInfo* vulkanImageInfo) const {
+  if (!isValid() || _backend != Backend::Vulkan) {
+    return false;
+  }
+  *vulkanImageInfo = vulkanInfo;
+  return true;
+}
+
+bool BackendRenderTarget::getWebGPUTextureInfo(WebGPUTextureInfo* webgpuTextureInfo) const {
+  if (!isValid() || _backend != Backend::WebGPU) {
+    return false;
+  }
+  *webgpuTextureInfo = webgpuInfo;
+  return true;
+}
+
+BackendSemaphore& BackendSemaphore::operator=(const BackendSemaphore& that) {
+  _backend = that._backend;
+  switch (that._backend) {
+    case Backend::OpenGL:
+      glSyncInfo = that.glSyncInfo;
+      break;
+    case Backend::Metal:
+      metalSyncInfo = that.metalSyncInfo;
+      break;
+    case Backend::Vulkan:
+      vulkanSyncInfo = that.vulkanSyncInfo;
+      break;
+    case Backend::WebGPU:
+      webgpuSyncInfo = that.webgpuSyncInfo;
+      break;
+    default:
+      break;
+  }
+  return *this;
+}
+
+bool BackendSemaphore::isInitialized() const {
+  switch (_backend) {
+    case Backend::OpenGL:
+      return glSyncInfo.sync != nullptr;
+    case Backend::Metal:
+      return metalSyncInfo.event != nullptr;
+    case Backend::Vulkan:
+      return vulkanSyncInfo.semaphore != 0;
+    case Backend::WebGPU:
+      // WebGPU has no explicit semaphore handle; synchronization is managed by the browser.
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+bool BackendSemaphore::getGLSync(GLSyncInfo* syncInfo) const {
+  if (_backend != Backend::OpenGL || glSyncInfo.sync == nullptr) {
+    return false;
+  }
+  *syncInfo = glSyncInfo;
+  return true;
+}
+
+bool BackendSemaphore::getMetalSync(MetalSyncInfo* metalInfo) const {
+  if (_backend != Backend::Metal || metalSyncInfo.event == nullptr) {
+    return false;
+  }
+  *metalInfo = metalSyncInfo;
+  return true;
+}
+
+bool BackendSemaphore::getVulkanSync(VulkanSyncInfo* vulkanSyncInfo) const {
+  if (_backend != Backend::Vulkan || this->vulkanSyncInfo.semaphore == 0) {
+    return false;
+  }
+  *vulkanSyncInfo = this->vulkanSyncInfo;
+  return true;
+}
+
+bool BackendSemaphore::getWebGPUSync(WebGPUSyncInfo* webgpuInfo) const {
+  if (_backend != Backend::WebGPU) {
+    return false;
+  }
+  *webgpuInfo = webgpuSyncInfo;
+  return true;
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/BackingFit.h

@@ -0,0 +1,37 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace tgfx {
+/**
+ * Indicates whether a backing store needs to be an exact match or can be larger than is strictly
+ * necessary.
+*/
+enum class BackingFit {
+  /**
+   * The backing store must be an exact match for the requested size.
+   */
+  Exact = 0,
+
+  /**
+   * The backing store can be larger than the requested size, but should not be smaller.
+   */
+  Approx = 1,
+};
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/BlendFormula.cpp

@@ -0,0 +1,162 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "BlendFormula.h"
+
+namespace tgfx {
+
+/**
+ * When there is no coverage, or the blend mode can tweak alpha for coverage, we use the standard
+ * Porter Duff formula.
+ */
+constexpr BlendFormula MakeCoeffFormula(BlendFactor srcCoeff, BlendFactor dstCoeff) {
+  // When the coeffs are (Zero, Zero) or (Zero, One) we set the primary output to none.
+  return (BlendFactor::Zero == srcCoeff &&
+          (BlendFactor::Zero == dstCoeff || BlendFactor::One == dstCoeff))
+             ? BlendFormula{BlendFormula::OutputType::None, BlendFormula::OutputType::None,
+                            BlendOperation::Add, BlendFactor::Zero, dstCoeff}
+             : BlendFormula{BlendFormula::OutputType::Modulate, BlendFormula::OutputType::None,
+                            BlendOperation::Add, srcCoeff, dstCoeff};
+}
+
+/**
+ * Basic coeff formula similar to MakeCoeffFormula but we will make the src f*Sa.
+ */
+constexpr BlendFormula MakeSAModulateFormula(BlendFactor srcCoeff, BlendFactor dstCoeff) {
+  return {BlendFormula::OutputType::SAModulate, BlendFormula::OutputType::None, BlendOperation::Add,
+          srcCoeff, dstCoeff};
+}
+
+/**
+ * When there is coverage, the equation with f=coverage is:
+ * D' = f * S * srcCoeff + D * (1 - [f * (1 - dstCoeff)])
+ */
+constexpr BlendFormula MakeCoverageFormula(BlendFormula::OutputType oneMinusDstCoeffModulateOutput,
+                                           BlendFactor srcCoeff) {
+  return {BlendFormula::OutputType::Modulate, oneMinusDstCoeffModulateOutput, BlendOperation::Add,
+          srcCoeff, BlendFactor::OneMinusSrc1};
+}
+
+/**
+ * When there is coverage and the src coeff is Zero.
+ */
+constexpr BlendFormula MakeCoverageSrcCoeffZeroFormula(
+    BlendFormula::OutputType oneMinusDstCoeffModulateOutput) {
+  return {oneMinusDstCoeffModulateOutput, BlendFormula::OutputType::None,
+          BlendOperation::ReverseSubtract, BlendFactor::Dst, BlendFactor::One};
+}
+
+/**
+ * When there is coverage and the dst coeff is Zero.
+ */
+constexpr BlendFormula MakeCoverageDstCoeffZeroFormula(BlendFactor srcCoeff) {
+  return {BlendFormula::OutputType::Modulate, BlendFormula::OutputType::Coverage,
+          BlendOperation::Add, srcCoeff, BlendFactor::OneMinusSrc1Alpha};
+}
+
+static constexpr BlendFormula Coeffs[2][15] = {
+    {
+        /* clear */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::Zero),
+        /* src */ MakeCoeffFormula(BlendFactor::One, BlendFactor::Zero),
+        /* dst */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::One),
+        /* src-over */ MakeCoeffFormula(BlendFactor::One, BlendFactor::OneMinusSrcAlpha),
+        /* dst-over */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::One),
+        /* src-in */ MakeCoeffFormula(BlendFactor::DstAlpha, BlendFactor::Zero),
+        /* dst-in */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::SrcAlpha),
+        /* src-out */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::Zero),
+        /* dst-out */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::OneMinusSrcAlpha),
+        /* src-atop */ MakeCoeffFormula(BlendFactor::DstAlpha, BlendFactor::OneMinusSrcAlpha),
+        /* dst-atop */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::SrcAlpha),
+        /* xor */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::OneMinusSrcAlpha),
+        /* plus */ MakeCoeffFormula(BlendFactor::One, BlendFactor::One),
+        /* modulate */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::Src),
+        /* screen */ MakeCoeffFormula(BlendFactor::One, BlendFactor::OneMinusSrc),
+    },
+    /*>> Has coverage, input color unknown <<*/ {
+        /* clear */ MakeCoverageSrcCoeffZeroFormula(BlendFormula::OutputType::Coverage),
+        /* src */ MakeCoverageDstCoeffZeroFormula(BlendFactor::One),
+        /* dst */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::One),
+        /* src-over */ MakeCoeffFormula(BlendFactor::One, BlendFactor::OneMinusSrcAlpha),
+        /* dst-over */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::One),
+        /* src-in */ MakeCoverageDstCoeffZeroFormula(BlendFactor::DstAlpha),
+        /* dst-in */ MakeCoverageSrcCoeffZeroFormula(BlendFormula::OutputType::ISAModulate),
+        /* src-out */ MakeCoverageDstCoeffZeroFormula(BlendFactor::OneMinusDstAlpha),
+        /* dst-out */ MakeCoeffFormula(BlendFactor::Zero, BlendFactor::OneMinusSrcAlpha),
+        /* src-atop */ MakeCoeffFormula(BlendFactor::DstAlpha, BlendFactor::OneMinusSrcAlpha),
+        /* dst-atop */
+        MakeCoverageFormula(BlendFormula::OutputType::ISAModulate, BlendFactor::OneMinusDstAlpha),
+        /* xor */ MakeCoeffFormula(BlendFactor::OneMinusDstAlpha, BlendFactor::OneMinusSrcAlpha),
+        /* plus */ MakeCoeffFormula(BlendFactor::One, BlendFactor::One),
+        /* modulate */ MakeCoverageSrcCoeffZeroFormula(BlendFormula::OutputType::ISCModulate),
+        /* screen */ MakeCoeffFormula(BlendFactor::One, BlendFactor::OneMinusSrc),
+    }};
+
+bool BlendModeAsCoeff(BlendMode mode, bool hasCoverage, BlendFormula* blendFormula) {
+  if (mode > BlendMode::Screen) {
+    return false;
+  }
+  if (blendFormula != nullptr) {
+    const auto& formula = Coeffs[hasCoverage][static_cast<int>(mode)];
+    *blendFormula = formula;
+  }
+  return true;
+}
+
+bool BlendModeIsOpaque(BlendMode mode, OpacityType srcColorOpacity) {
+  BlendFormula blendFormula = {};
+  if (!BlendModeAsCoeff(mode, false, &blendFormula)) {
+    return false;
+  }
+  switch (blendFormula.srcFactor()) {
+    case BlendFactor::Zero:
+    case BlendFactor::DstAlpha:
+    case BlendFactor::Dst:
+    case BlendFactor::OneMinusDstAlpha:
+    case BlendFactor::OneMinusDst:
+      return false;
+    default:
+      break;
+  }
+  switch (blendFormula.dstFactor()) {
+    case BlendFactor::Zero:
+      return true;
+    case BlendFactor::OneMinusSrcAlpha:
+      return srcColorOpacity == OpacityType::Opaque;
+    case BlendFactor::SrcAlpha:
+      return srcColorOpacity == OpacityType::TransparentBlack ||
+             srcColorOpacity == OpacityType::TransparentAlpha;
+    case BlendFactor::Src:
+      return srcColorOpacity == OpacityType::TransparentBlack;
+    default:
+      return false;
+  }
+}
+
+bool BlendModeNeedDstTexture(BlendMode mode, bool hasCoverage) {
+  if (mode == BlendMode::SrcOver) {
+    return false;
+  }
+  BlendFormula formula;
+  if (!BlendModeAsCoeff(mode, hasCoverage, &formula) || formula.needSecondaryOutput() ||
+      formula.primaryOutputType() != BlendFormula::OutputType::Modulate) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/BlendFormula.h

@@ -0,0 +1,121 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include "tgfx/core/BlendMode.h"
+#include "tgfx/gpu/BlendFactor.h"
+#include "tgfx/gpu/BlendOperation.h"
+
+namespace tgfx {
+struct BlendFormula {
+  /**
+    * Values the shader can write to primary and secondary outputs. These are all modulated by
+    * coverage. We will ignore the multiplies when not using coverage.
+    */
+  enum class OutputType {
+    None,         //<! 0
+    Coverage,     //<! inputCoverage
+    Modulate,     //<! inputColor * inputCoverage
+    SAModulate,   //<! inputColor.a * inputCoverage
+    ISAModulate,  //<! (1 - inputColor.a) * inputCoverage
+    ISCModulate,  //<! (1 - inputColor) * inputCoverage
+  };
+
+  BlendFormula() {
+    // default to src-over blendmode
+    bitFields.equation = static_cast<uint8_t>(BlendOperation::Add);
+    bitFields.srcCoeff = static_cast<uint8_t>(BlendFactor::One);
+    bitFields.dstCoeff = static_cast<uint8_t>(BlendFactor::OneMinusSrcAlpha);
+    bitFields.primaryOutputType = static_cast<uint8_t>(OutputType::Modulate);
+    bitFields.secondaryOutputType = static_cast<uint8_t>(OutputType::None);
+  }
+
+  constexpr BlendFormula(OutputType primaryOutputType, OutputType secondaryOutputType,
+                         BlendOperation eq, BlendFactor src, BlendFactor dst) {
+    bitFields.primaryOutputType = static_cast<uint8_t>(primaryOutputType);
+    bitFields.secondaryOutputType = static_cast<uint8_t>(secondaryOutputType);
+    bitFields.equation = static_cast<uint8_t>(eq);
+    bitFields.srcCoeff = static_cast<uint8_t>(src);
+    bitFields.dstCoeff = static_cast<uint8_t>(dst);
+  }
+
+  bool needSecondaryOutput() const {
+    return static_cast<OutputType>(bitFields.secondaryOutputType) != OutputType::None;
+  }
+
+  OutputType primaryOutputType() const {
+    return static_cast<OutputType>(bitFields.primaryOutputType);
+  }
+
+  OutputType secondaryOutputType() const {
+    return static_cast<OutputType>(bitFields.secondaryOutputType);
+  }
+
+  BlendOperation operation() const {
+    return static_cast<BlendOperation>(bitFields.equation);
+  }
+
+  BlendFactor srcFactor() const {
+    return static_cast<BlendFactor>(bitFields.srcCoeff);
+  }
+
+  BlendFactor dstFactor() const {
+    return static_cast<BlendFactor>(bitFields.dstCoeff);
+  }
+
+ private:
+  struct {
+    uint8_t primaryOutputType : 3;
+    uint8_t secondaryOutputType : 3;
+    uint8_t srcCoeff : 4;
+    uint8_t dstCoeff : 4;
+    uint8_t equation : 2;
+  } bitFields = {};
+};
+
+/**
+ * Determines if the given blend mode is coefficient-based and retrieves the blend formula if so.
+ */
+bool BlendModeAsCoeff(BlendMode mode, bool hasCoverage = false,
+                      BlendFormula* blendFormula = nullptr);
+
+enum class OpacityType {
+  // The opacity is unknown
+  Unknown,
+  // The src color is known to be opaque (alpha == 255)
+  Opaque,
+  // The src color is known to be fully transparent (color == 0)
+  TransparentBlack,
+  // The src alpha is known to be fully transparent (alpha == 0)
+  TransparentAlpha,
+};
+
+/**
+ * Returns true if 'mode' is opaque given the src color opacity.
+ */
+bool BlendModeIsOpaque(BlendMode mode, OpacityType srcColorOpacity);
+
+/**
+ * Returns true if the blend mode needs a destination texture.
+ */
+bool BlendModeNeedDstTexture(BlendMode mode, bool hasCoverage);
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/ColorSpaceXformHelper.cpp

@@ -0,0 +1,89 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#include "ColorSpaceXformHelper.h"
+namespace tgfx {
+
+void ColorSpaceXformHelper::emitCode(UniformHandler* uniformHandler,
+                                     const ColorSpaceXformSteps* colorSpaceXform,
+                                     ShaderStage shaderStage) {
+  if (colorSpaceXform) {
+    flags = colorSpaceXform->flags;
+    if (this->applySrcTF()) {
+      srcTFVar0 = uniformHandler->addUniform("SrcTF0", UniformFormat::Float4, shaderStage);
+      srcTFVar1 = uniformHandler->addUniform("SrcTF1", UniformFormat::Float4, shaderStage);
+      _srcTFType =
+          gfx::skcms_TransferFunction_getType(reinterpret_cast<const gfx::skcms_TransferFunction*>(
+              &colorSpaceXform->srcTransferFunction));
+    }
+    if (this->applySrcOOTF()) {
+      srcOOTFVar = uniformHandler->addUniform("SrcOOTF", UniformFormat::Float4, shaderStage);
+    }
+    if (this->applyGamutXform()) {
+      gamutXformVar =
+          uniformHandler->addUniform("ColorXform", UniformFormat::Float3x3, shaderStage);
+    }
+    if (this->applyDstOOTF()) {
+      dstOOTFVar = uniformHandler->addUniform("DstOOTF", UniformFormat::Float4, shaderStage);
+    }
+    if (this->applyDstTF()) {
+      dstTFVar0 = uniformHandler->addUniform("DstTF0", UniformFormat::Float4, shaderStage);
+      dstTFVar1 = uniformHandler->addUniform("DstTF1", UniformFormat::Float4, shaderStage);
+      _dstTFType =
+          gfx::skcms_TransferFunction_getType(reinterpret_cast<const gfx::skcms_TransferFunction*>(
+              &colorSpaceXform->dstTransferFunctionInverse));
+    }
+  }
+}
+
+void ColorSpaceXformHelper::setData(UniformData* uniformData,
+                                    const ColorSpaceXformSteps* colorSpaceXform) {
+  if (colorSpaceXform) {
+    flags = colorSpaceXform->flags;
+    if (this->applySrcTF()) {
+      float srcTF0[4] = {
+          colorSpaceXform->srcTransferFunction.g, colorSpaceXform->srcTransferFunction.a,
+          colorSpaceXform->srcTransferFunction.b, colorSpaceXform->srcTransferFunction.c};
+      float srcTF1[4] = {colorSpaceXform->srcTransferFunction.d,
+                         colorSpaceXform->srcTransferFunction.e,
+                         colorSpaceXform->srcTransferFunction.f, 0.0f};
+      uniformData->setData("SrcTF0", srcTF0);
+      uniformData->setData("SrcTF1", srcTF1);
+    }
+    if (this->applySrcOOTF()) {
+      uniformData->setData("SrcOOTF", colorSpaceXform->srcOOTF);
+    }
+    if (this->applyGamutXform()) {
+      uniformData->setData("ColorXform", colorSpaceXform->srcToDstMatrix);
+    }
+    if (this->applyDstOOTF()) {
+      uniformData->setData("DstOOTF", colorSpaceXform->dstOOTF);
+    }
+    if (this->applyDstTF()) {
+      float dstTF0[4] = {colorSpaceXform->dstTransferFunctionInverse.g,
+                         colorSpaceXform->dstTransferFunctionInverse.a,
+                         colorSpaceXform->dstTransferFunctionInverse.b,
+                         colorSpaceXform->dstTransferFunctionInverse.c};
+      float dstTF1[4] = {colorSpaceXform->dstTransferFunctionInverse.d,
+                         colorSpaceXform->dstTransferFunctionInverse.e,
+                         colorSpaceXform->dstTransferFunctionInverse.f, 0.0f};
+      uniformData->setData("DstTF0", dstTF0);
+      uniformData->setData("DstTF1", dstTF1);
+    }
+  }
+}
+}  // namespace tgfx