UT/UT_Ramp.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT library (C++)
 *
 * COMMENTS:    Ramp class
 *
 */


#ifndef _UT_Ramp_
#define _UT_Ramp_

#include "UT_API.h"
/*
 *  UT_Ramp is the utility class for containing a color ramp.
 */

#include <iostream.h>
#include <SYS/SYS_Types.h>
#include "UT_AssocArray.h"
#include "UT_Color.h"
#include "UT_Spline.h"

class UT_Raster;
class UT_RGBA;
class UT_BIG_RGBA;
class UT_IStream;
class UT_IntArray;

enum UT_RampOrient {    // Pass to redraw
        UT_RAMP_HORIZONTAL,
        UT_RAMP_VERTICAL,
        UT_RAMP_RADIAL,
        UT_RAMP_CONCENTRIC
};

class UT_API UT_FRGBA {
public:
    UT_FRGBA()  {};
    UT_FRGBA(fpreal red, fpreal green, fpreal blue, fpreal alpha)
    { r = red; g = green; b = blue; a = alpha; }

    float       r, g, b, a;
};

class UT_API UT_ColorNode {     // Floating point RGBA values
public:
    UT_ColorNode() {}
    UT_ColorNode(fpreal offset, const UT_FRGBA &color,
                 UT_SPLINE_BASIS basis_ = UT_SPLINE_LINEAR,
                 bool enable_pos_ = true,
                 bool enable_val_ = true,
                 bool enable_interp_ = true)
    {
        t = offset;
        rgba = color;
        basis = basis_;
        enable_pos = enable_pos_;
        enable_val = enable_val_;
        enable_interp = enable_interp_;
    }

    float           t;
    UT_FRGBA        rgba;
    UT_SPLINE_BASIS basis;
    bool            enable_pos:1,
                    enable_val:1,
                    enable_interp:1;
};

//==========================================================================

class UT_API UT_Ramp {
public:
     UT_Ramp();
     UT_Ramp(const UT_Ramp &copy);
    ~UT_Ramp();

    void                 setColorType(UT_ColorType color_space)
                            { myColorType = color_space; }
    UT_ColorType         getColorType() const
                            { return myColorType; }

    void                 clearAndDestroy();

    bool                 getGlobalEnable() const
                            { return myGlobalEnable; }
    void                 setGlobalEnable(bool enable)
                            { myGlobalEnable = enable; }

    int                  getNodeCount() const { return myNumNodes; };
    const UT_ColorNode  *getNode(int i) const;

    UT_ColorNode        *getRamp() { return myNodes; };
    const UT_ColorNode  *getRamp() const { return myNodes; };

    void                 convertToRaster(   UT_Raster     *raster,
                                            UT_RampOrient  dir,
                                            int            doInterping = 1,
                                            // Currently only for radial and
                                            // concentric
                                            fpreal         cx = 0.0f,
                                            fpreal         cy = 0.0f,
                                            fpreal         phase = 0.0f,
                                            // For radial, this means "repeat"
                                            fpreal         radius = 1.0f);

    const UT_ColorNode  *getClosestNode(fpreal pos) const;
    int                  getClosestNodeIndex(fpreal pos) const;

    const UT_ColorNode  *getCurrentNode() const;
    int                  getCurrentNodeIndex() const;
    void                 setCurrentNodeIndex(int i, bool add_to_selection);

    void                 getColor(fpreal pos, UT_FRGBA *clr,
                                        int doInterping = 1) const;
    void                 getColor(fpreal pos, float fvals[4],
                                        int doInterping = 1) const;
    void                 getColor(UT_FRGBA *values, int num,
                                        int doInterping = 1) const;

    void                 setColorAt(int i, float fvals[4]);
    void                 setColorAt(int i, const UT_FRGBA &clr);
    void                 setCurrentNodeColor(float fvals[4]);
    void                 setCurrentNodeColor(const UT_FRGBA &clr);

    void                 setCurrentNodeBasis(UT_SPLINE_BASIS basis);
    void                 setNodeBasis(int i, UT_SPLINE_BASIS basis);

    void                 setEnable(int i, bool enable_pos, bool enable_val,
                                          bool enable_interp);
    bool                 getEnablePos(int i) const;
    bool                 getEnableVal(int i) const;
    bool                 getEnableInterp(int i) const;

    void                 clearSelection();
    bool                 isNodeSelected(int i);
    void                 selectNode(int i, bool add);
    void                 selectRange(int first_i, int last_i, bool add);
    void                 deselectNode(int i);
    void                 toggleSelectNode(int i);
    void                 getSelectionIndices(UT_IntArray &indices);
    void                 setSelectionIndices(const UT_IntArray &indices);

    void                 addNode(fpreal pos);
    void                 addNode(fpreal pos, float fvals[4],
                                 UT_SPLINE_BASIS basis = UT_SPLINE_LINEAR);
    void                 addNode(fpreal pos, const UT_FRGBA &color,
                                 UT_SPLINE_BASIS basis = UT_SPLINE_LINEAR);

    bool                 deleteNode(fpreal pos);
    bool                 deleteNodeAt(int i);
    void                 deleteSelectedNodes();

    void                 moveNode(const UT_ColorNode *node, fpreal pos);

    int                  load(const char *pathname);
    bool                 load(UT_IStream &is);
    int                  save(const char *pathname) const;
    int                  save(ostream &os) const;

    UT_Ramp             &operator=(const UT_Ramp &from);
    
    void                 setRamp(const UT_ColorNode *r, int size);

    void                 rampLookup(fpreal pos, float values[4]) const;
    void                 rampLookupNoInterp(fpreal pos, float values[4]) const;
    void                 rampLookup(fpreal u0, fpreal u1, float values[4],
                                    int ns) const;
    void                 rampLookupNoInterp(fpreal u0, fpreal u1, float values[4],
                                    int ns) const;

private:
    UT_RGBA             *sampleColors  (int nsamples, int doInterp);
    UT_BIG_RGBA         *sampleColors16(int nsamples, int doInterp);
    void                 convertToRaster8 (UT_Raster *raster,UT_RampOrient dir,
                            int doInterp, fpreal cx, fpreal cy, fpreal phase,
                            fpreal radius);
    void                 convertToRaster16(UT_Raster *raster,UT_RampOrient dir,
                            int doInterp, fpreal cx, fpreal cy, fpreal phase,
                            fpreal radius);

    void                 getColorAndMultiply(fpreal pos, int do_interp,
                                UT_RGBA *pixel);
    void                 getColorAndMultiply(fpreal pos, int do_interp,
                                UT_BIG_RGBA *pixel);

    void                 interpColor(fpreal pos, int i1, float vals[4]) const;

    void                 updateSpline() const;
    void                 evaluateSpline(fpreal pos, fpreal t0, fpreal t1,
                                        int i, float *val) const;

private:
    int                  myNumNodes;
    UT_ColorNode        *myNodes;
    UT_ColorNode        *myCurrentNode;

    UT_AssocArray<int, UT_ColorNode *>  mySelectedNodes;

    UT_ColorType         myColorType;

    mutable UT_Spline    mySpline;
    mutable bool         mySplineDirty;

    bool                 myGlobalEnable;
};

#endif

---