xref: /ohos5.0/foundation/graphic/graphic_2d/rosen/modules/2d_graphics/drawing_ndk/src/drawing_shader_effect.cpp

/*
 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 "drawing_shader_effect.h"

#include "drawing_canvas_utils.h"

#include "effect/shader_effect.h"

using namespace OHOS;
using namespace Rosen;
using namespace Drawing;

static const Point* CastToPoint(const OH_Drawing_Point* cPoint)
{
    return reinterpret_cast<const Point*>(cPoint);
}

static const Point* CastToPoint(const OH_Drawing_Point2D* cPoint)
{
    return reinterpret_cast<const Point*>(cPoint);
}

static const Image& CastToImage(const OH_Drawing_Image& cImage)
{
    return reinterpret_cast<const Image&>(cImage);
}

static const SamplingOptions& CastToSamplingOptions(const OH_Drawing_SamplingOptions& cSamplingOptions)
{
    return reinterpret_cast<const SamplingOptions&>(cSamplingOptions);
}

static const Matrix* CastToMatrix(const OH_Drawing_Matrix* cMatrix)
{
    return reinterpret_cast<const Matrix*>(cMatrix);
}

static ShaderEffect* CastToShaderEffect(OH_Drawing_ShaderEffect* cShaderEffect)
{
    return reinterpret_cast<ShaderEffect*>(cShaderEffect);
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateColorShader(const uint32_t color)
{
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::COLOR_SHADER, color);
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateLinearGradient(const OH_Drawing_Point* cStartPt,
    const OH_Drawing_Point* cEndPt, const uint32_t* colors, const float* pos, uint32_t size,
    OH_Drawing_TileMode cTileMode)
{
    if (cStartPt == nullptr || cEndPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
    }
    if (pos != nullptr) {
        for (uint32_t i = 0; i < size; i++) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::LINEAR_GRADIENT,
        *CastToPoint(cStartPt), *CastToPoint(cEndPt), colorsVector, posVector, static_cast<TileMode>(cTileMode));
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(
    const OH_Drawing_Point2D* startPt, const OH_Drawing_Point2D* endPt, const uint32_t* colors, const float* pos,
    uint32_t size, OH_Drawing_TileMode cTileMode, const OH_Drawing_Matrix* cMatrix)
{
    if (startPt == nullptr || endPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
    }
    if (pos != nullptr) {
        for (uint32_t i = 0; i < size; i++) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(
        ShaderEffect::ShaderEffectType::LINEAR_GRADIENT, *CastToPoint(startPt), *CastToPoint(endPt), colorsVector,
        posVector, static_cast<TileMode>(cTileMode), cMatrix ? CastToMatrix(cMatrix) : nullptr);
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateRadialGradient(const OH_Drawing_Point* cCenterPt, float radius,
    const uint32_t* colors, const float* pos, uint32_t size, OH_Drawing_TileMode cTileMode)
{
    if (cCenterPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
        if (pos) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::RADIAL_GRADIENT,
        *CastToPoint(cCenterPt), radius, colorsVector, posVector, static_cast<TileMode>(cTileMode));
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(
    const OH_Drawing_Point2D* centerPt, float radius, const uint32_t* colors, const float* pos, uint32_t size,
    OH_Drawing_TileMode cTileMode, const OH_Drawing_Matrix* cMatrix)
{
    if (centerPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
        if (pos) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(
        ShaderEffect::ShaderEffectType::RADIAL_GRADIENT, *CastToPoint(centerPt), radius, colorsVector, posVector,
        static_cast<TileMode>(cTileMode), cMatrix ? CastToMatrix(cMatrix) : nullptr);
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateSweepGradient(const OH_Drawing_Point* cCenterPt,
    const uint32_t* colors, const float* pos, uint32_t size, OH_Drawing_TileMode cTileMode)
{
    if (cCenterPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
        if (pos) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::SWEEP_GRADIENT,
        *CastToPoint(cCenterPt), colorsVector, posVector, static_cast<TileMode>(cTileMode), 0,
        360, nullptr); // 360: endAngle
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateImageShader(OH_Drawing_Image* cImage, OH_Drawing_TileMode tileX,
    OH_Drawing_TileMode tileY, const OH_Drawing_SamplingOptions* cSampling, const OH_Drawing_Matrix* cMatrix)
{
    if (cImage == nullptr || cSampling == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (tileX < CLAMP || tileX > DECAL || tileY < CLAMP || tileY > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    if (cMatrix == nullptr) {
        Matrix matrix;
        return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::IMAGE, CastToImage(*cImage),
            static_cast<TileMode>(tileX), static_cast<TileMode>(tileY), CastToSamplingOptions(*cSampling), matrix);
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::IMAGE, CastToImage(*cImage),
        static_cast<TileMode>(tileX), static_cast<TileMode>(tileY), CastToSamplingOptions(*cSampling),
        *CastToMatrix(cMatrix));
}

OH_Drawing_ShaderEffect* OH_Drawing_ShaderEffectCreateTwoPointConicalGradient(const OH_Drawing_Point2D* startPt,
    float startRadius, const OH_Drawing_Point2D* endPt, float endRadius, const uint32_t* colors, const float* pos,
    uint32_t size, OH_Drawing_TileMode cTileMode, const OH_Drawing_Matrix* cMatrix)
{
    if (startPt == nullptr || endPt == nullptr || colors == nullptr) {
        g_drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER;
        return nullptr;
    }
    if (cTileMode < CLAMP || cTileMode > DECAL) {
        g_drawingErrorCode = OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE;
        return nullptr;
    }
    std::vector<ColorQuad> colorsVector;
    std::vector<scalar> posVector;
    for (uint32_t i = 0; i < size; i++) {
        colorsVector.emplace_back(colors[i]);
        if (pos) {
            posVector.emplace_back(pos[i]);
        }
    }
    return (OH_Drawing_ShaderEffect*)new ShaderEffect(ShaderEffect::ShaderEffectType::CONICAL_GRADIENT,
        *CastToPoint(startPt), startRadius, *CastToPoint(endPt), endRadius, colorsVector, posVector,
        static_cast<TileMode>(cTileMode), cMatrix ? CastToMatrix(cMatrix) : nullptr);
}

void OH_Drawing_ShaderEffectDestroy(OH_Drawing_ShaderEffect* cShaderEffect)
{
    if (!cShaderEffect) {
        return;
    }
    delete CastToShaderEffect(cShaderEffect);
}