COP2_FractalMatte.h

Go to the documentation of this file.

#pragma once

 // HDK
#include <COP2/COP2_PixelOp.h>
#include <RU/RU_PixelFunctions.h>

namespace CC
{

class COP2_FractalMatte : public COP2_PixelOp
{
public:

    static OP_TemplatePair myTemplatePair;
    static OP_VariablePair myVariablePair;
    static PRM_Template myTemplateList[];
    static CH_LocalVariable myVariableList[];

    static const char* myInputLabels[];

    friend class OP;

protected:
    virtual RU_PixelFunction* addPixelFunction(
        const TIL_Plane*,
        int,
        fpreal32 t,
        int,
        int,
        int thread);

    virtual bool updateParmsFlags() override;

private:

    COP2_FractalMatte(
        OP_Network* parent,
        const char* name,
        OP_Operator* entry);

    virtual ~COP2_FractalMatte();

};

class cop2_FractalMatteFunc : public RU_PixelFunction
{
public:

    enum class ModeType
    {
        MODULUS,
        COMPARISON,
        BLENDCOLOR
    };

    enum class ComparisonType
    {
        LESS_THAN,
        LESS_THAN_EQUALS,
        EQUALS,
        GREATER_THAN_EQUALS,
        GREATER_THAN,
        NOT_EQUALS
    };

    enum class BlendType
    {
        LINEAR,
        QUADRATIC,
        CONSTANT
    };

    cop2_FractalMatteFunc(
        fpreal modulo, fpreal offset, bool invert = false);

    cop2_FractalMatteFunc(
        fpreal compValue, ComparisonType compType, bool invert = false);

    cop2_FractalMatteFunc(
        std::vector<fpreal>sizes,
        std::vector<UT_Color>colors,
        BlendType blendType,
        fpreal32 offset,
        fpreal32 blendOffset,
        fpreal32 weightMult = 1.0f,  // Zero values here are really bad
        bool invert = false);
protected:
    virtual bool eachComponentDifferent() const
    {
        if (mode == ModeType::BLENDCOLOR)
            return true;
        // Unless a BLENDCOLOR, all components can be the same.
        return false;
    }

    virtual bool needAllComponents() const
    {
        return false;
    }

    static fpreal32 checkModulus(
        RU_PixelFunction* pf,  
        fpreal32 pixelValue,
        int comp);

    static fpreal32 checkComparison(
        RU_PixelFunction* pf,
        fpreal32 pixelValue,
        int comp);

    static fpreal32 checkBlendColors(
        RU_PixelFunction* pf,
        fpreal32 pixelValue,
        int comp);

    virtual RUPixelFunc getPixelFunction() const
    {
        switch (mode)
        {
        case ModeType::MODULUS:
            return checkModulus;
        case ModeType::COMPARISON:
            return checkComparison;
        case ModeType::BLENDCOLOR:
            return checkBlendColors;
        default:
            return checkModulus;
        }
    }

private:
    fpreal32 modulo{ 0.0f };
    fpreal32 offset{ 0.0f };
    bool invert{ false };
    fpreal32 compValue{ 0.0 };
    std::vector<fpreal> sizes;
    std::vector<UT_Color> colors;
    BlendType blendType;
    ComparisonType compType{ ComparisonType::LESS_THAN };
    ModeType mode{ ModeType::MODULUS };
    fpreal32 colorOffset{ 0.0f };
    fpreal32 blendOffset{ 1.0f };
};
}