/home/master/UCL/VisualizationLibrary/src/vlVG/VectorGraphics.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2010, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef VectorGraphics_INCLUDE_ONCE
#define VectorGraphics_INCLUDE_ONCE

#include <vlVG/link_config.hpp>
#include <vlCore/Image.hpp>
#include <vlCore/VisualizationLibrary.hpp>
#include <vlGraphics/Actor.hpp>
#include <vlGraphics/Text.hpp>
#include <vlGraphics/FontManager.hpp>
#include <vlGraphics/Effect.hpp>
#include <vlGraphics/SceneManager.hpp>
#include <vlGraphics/Clear.hpp>
#include <vlGraphics/Scissor.hpp>
#include <vlGraphics/Geometry.hpp>
#include <vlGraphics/FontManager.hpp>

namespace vl
{
  typedef enum
  {
    TextureMode_Clamp,
    TextureMode_Repeat
  } ETextureMode;

  typedef enum
  {
    PolygonStipple_Solid,
    PolygonStipple_Dot,
    PolygonStipple_Chain,
    PolygonStipple_HLine,
    PolygonStipple_VLine
  } EPolygonStipple;

  typedef enum
  {
    LineStipple_Solid,
    LineStipple_Dot,
    LineStipple_Dash,
    LineStipple_Dash4,
    LineStipple_Dash8,
    LineStipple_DashDot,
    LineStipple_DashDotDot
  } ELineStipple;

//-------------------------------------------------------------------------------------------------------------------------------------------
// VectorGraphics
//-------------------------------------------------------------------------------------------------------------------------------------------
  class VLVG_EXPORT VectorGraphics: public Object
  {
    VL_INSTRUMENT_CLASS(vl::VectorGraphics, Object)

  private:
    //------------------------------------------------------------------------- start internal
    class ImageState
    {
    public:
      ImageState(const Image* img, ETextureMode mode): mImage(img), mTextureMode(mode) {}

      bool operator<(const ImageState& other) const
      {
        if (mImage != other.mImage)
          return mImage < other.mImage;
        else
        if (mTextureMode != other.mTextureMode)
          return mTextureMode < other.mTextureMode;
        else
          return false;
      }
    protected:
      const Image* mImage;
      ETextureMode mTextureMode;
    };
    //------------------------------------------------------------------------- start internal
    class State
    {
    public:
      State()
      {
        mColor         = white;
        mPointSize     = 5;
        mImage         = NULL;
        mTextureMode   = TextureMode_Clamp;
        mLogicOp       = LO_COPY;
        mPointSmoothing= true;
        mLineSmoothing = true;
        mPolygonSmoothing = false;
        mLineWidth     = 1.0;
        mLineStipple   = 0xFFFF;
        memset(mPolyStipple, 0xFF, 32*32/8);

        // blend equation
        mBlendEquationRGB    = BE_FUNC_ADD;
        mBlendEquationAlpha  = BE_FUNC_ADD;
        // blend factor
        mBlendFactorSrcRGB   = BF_SRC_ALPHA;
        mBlendFactorDstRGB   = BF_ONE_MINUS_SRC_ALPHA;
        mBlendFactorSrcAlpha = BF_SRC_ALPHA;
        mBlendFactorDstAlpha = BF_ONE_MINUS_SRC_ALPHA;
        // alpha func
        mAlphaFuncRefValue = 0.0f;
        mAlphaFunc         = FU_ALWAYS;
        // font
        mFont              = defFontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10, false);
        // masks
        /*mDepthMask   = true;*/
        mColorMask   = ivec4(1,1,1,1);
        // stencil
        mStencilMask = 0xFFFFFFFF;
        mStencilTestEnabled = false;
        mStencil_SFail  = SO_KEEP;
        mStencil_SFail  = SO_KEEP;
        mStencil_DpFail = SO_KEEP;
        mStencil_Function = FU_ALWAYS;
        mStencil_RefValue = 0;
        mStencil_FunctionMask = ~(unsigned int)0;
      }

      fvec4 mColor;
      int mPointSize;
      ref<Image> mImage;
      ETextureMode mTextureMode;
      ELogicOp mLogicOp;
      float mLineWidth;
      bool mPointSmoothing;
      bool mLineSmoothing;
      bool mPolygonSmoothing;
      unsigned short mLineStipple;
      unsigned char mPolyStipple[32*32/8];
      EBlendEquation mBlendEquationRGB;
      EBlendEquation mBlendEquationAlpha;
      EBlendFactor mBlendFactorSrcRGB;
      EBlendFactor mBlendFactorDstRGB;
      EBlendFactor mBlendFactorSrcAlpha;
      EBlendFactor mBlendFactorDstAlpha;
      float mAlphaFuncRefValue;
      EFunction mAlphaFunc;
      ref<Font> mFont;
      /*bool mDepthMask;*/
      ivec4 mColorMask;
      // stencil
      bool mStencilTestEnabled;
      unsigned int mStencilMask;
      EStencilOp mStencil_SFail;
      EStencilOp mStencil_DpFail;
      EStencilOp mStencil_DpPass;
      EFunction  mStencil_Function;
      int          mStencil_RefValue;
      unsigned int         mStencil_FunctionMask;

      bool operator<(const State& other) const
      {
        // lexicographic sorting
        if (mColor.r() != other.mColor.r())
          return mColor.r() < other.mColor.r();
        else
        if (mColor.g() != other.mColor.g())
          return mColor.g() < other.mColor.g();
        else
        if (mColor.b() != other.mColor.b())
          return mColor.b() < other.mColor.b();
        else
        if (mColor.a() != other.mColor.a())
          return mColor.a() < other.mColor.a();
        else
        if(mPointSize != other.mPointSize)
          return mPointSize < other.mPointSize;
        else
        if(mImage != other.mImage)
          return mImage < other.mImage;
        else
        if (mTextureMode != other.mTextureMode)
          return mTextureMode < other.mTextureMode;
        else
        if (mPolygonSmoothing != other.mPolygonSmoothing)
          return mPolygonSmoothing < other.mPolygonSmoothing;
        else
        if (mPointSmoothing!= other.mPointSmoothing)
          return mPointSmoothing < other.mPointSmoothing;
        else
        if (mLineSmoothing!= other.mLineSmoothing)
          return mLineSmoothing < other.mLineSmoothing;
        else
        if (mLineWidth != other.mLineWidth)
          return mLineWidth < other.mLineWidth;
        else
        if (mLineStipple != other.mLineStipple)
          return mLineStipple < other.mLineStipple;
        else
        if (mLogicOp != other.mLogicOp)
          return mLogicOp < other.mLogicOp;
        else
        if ( memcmp(mPolyStipple, other.mPolyStipple, 32*32/8) != 0 )
          return memcmp(mPolyStipple, other.mPolyStipple, 32*32/8) < 0;
        else
        if ( mBlendEquationRGB != other.mBlendEquationRGB)
          return mBlendEquationRGB < other.mBlendEquationRGB;
        else
        if ( mBlendEquationAlpha != other.mBlendEquationAlpha)
          return mBlendEquationAlpha < other.mBlendEquationAlpha;
        else
        if ( mBlendFactorSrcRGB != other.mBlendFactorSrcRGB)
          return mBlendFactorSrcRGB < other.mBlendFactorSrcRGB;
        else
        if ( mBlendFactorDstRGB != other.mBlendFactorDstRGB)
          return mBlendFactorDstRGB < other.mBlendFactorDstRGB;
        else
        if ( mBlendFactorSrcAlpha != other.mBlendFactorSrcAlpha)
          return mBlendFactorSrcAlpha < other.mBlendFactorSrcAlpha;
        else
        if ( mBlendFactorDstAlpha != other.mBlendFactorDstAlpha)
          return mBlendFactorDstAlpha < other.mBlendFactorDstAlpha;
        else
        if ( mAlphaFuncRefValue != other.mAlphaFuncRefValue)
          return mAlphaFuncRefValue < other.mAlphaFuncRefValue;
        else
        if ( mAlphaFunc != other.mAlphaFunc)
          return mAlphaFunc < other.mAlphaFunc;
        else
        if ( mFont != other.mFont)
          return mFont < other.mFont;
        else
        /*if ( mDepthMask != other.mDepthMask)
          return mDepthMask < other.mDepthMask;
        else*/
        if ( mColorMask.r() != other.mColorMask.r())
          return mColorMask.r() < other.mColorMask.r();
        else
        if ( mColorMask.g() != other.mColorMask.g())
          return mColorMask.g() < other.mColorMask.g();
        else
        if ( mColorMask.b() != other.mColorMask.b())
          return mColorMask.b() < other.mColorMask.b();
        else
        if ( mColorMask.a() != other.mColorMask.a())
          return mColorMask.a() < other.mColorMask.a();
        else
        if ( mStencilMask != other.mStencilMask)
          return mStencilMask < other.mStencilMask;
        else
        if ( mStencilTestEnabled != other.mStencilTestEnabled)
          return mStencilTestEnabled < other.mStencilTestEnabled;
        else
        if ( mStencil_SFail != other.mStencil_SFail )
          return mStencil_SFail < other.mStencil_SFail;
        else
        if ( mStencil_DpFail != other.mStencil_DpFail )
          return mStencil_DpFail < other.mStencil_DpFail;
        else
        if ( mStencil_DpPass != other.mStencil_DpPass )
          return mStencil_DpPass < other.mStencil_DpPass;
        else
        if ( mStencil_Function != other.mStencil_Function )
          return mStencil_Function < other.mStencil_Function;
        else
        if ( mStencil_RefValue != other.mStencil_RefValue )
          return mStencil_RefValue < other.mStencil_RefValue;
        else
        if ( mStencil_FunctionMask != other.mStencil_FunctionMask )
          return mStencil_FunctionMask < other.mStencil_FunctionMask;
        else
          return false;
      }
    };
    //------------------------------------------------------------------------- end internal

  public:    
    VectorGraphics();

    const ActorCollection* actors() const { return &mActors; }

    ActorCollection* actors() { return &mActors; }

    Actor* drawLine(double x1, double y1, double x2, double y2);

    Actor* drawLines(const std::vector<dvec2>& ln);

    Actor* drawLineStrip(const std::vector<dvec2>& ln);

    Actor* drawLineLoop(const std::vector<dvec2>& ln);

    Actor* fillPolygon(const std::vector<dvec2>& poly);

    Actor* fillTriangles(const std::vector<dvec2>& triangles);

    Actor* fillTriangleFan(const std::vector<dvec2>& fan);

    Actor* fillTriangleStrip(const std::vector<dvec2>& strip);

    Actor* fillQuads(const std::vector<dvec2>& quads);

    Actor* fillQuadStrip(const std::vector<dvec2>& quad_strip);

    Actor* drawPoint(double x, double y);

    Actor* drawPoints(const std::vector<dvec2>& pt);

    Actor* drawEllipse(double origx, double origy, double xaxis, double yaxis, int segments = 64);

    Actor* fillEllipse(double origx, double origy, double xaxis, double yaxis, int segments = 64);

    Actor* drawQuad(double left, double bottom, double right, double top);

    Actor* fillQuad(double left, double bottom, double right, double top);

    void startDrawing() { clear(); }

    void continueDrawing();

    void endDrawing(bool release_cache=true);

    void clear();

    void setColor(const fvec4& color) { mState.mColor = color; }

    const fvec4& color() const { return mState.mColor; }

    void setPointSize(int size) { mState.mPointSize = size; }

    int pointSize() const { return mState.mPointSize; }

    void setImage(Image* image) { mState.mImage = image; }

    const Image* image() const { return mState.mImage.get(); }

    Image* image() { return mState.mImage.get(); }

    void setPoint(Image* image) { setImage(image); setPointSize(image->width()); }

    void setTextureMode(ETextureMode mode) { mState.mTextureMode = mode; }

    ETextureMode textureMode() const { return mState.mTextureMode; }

    void setLogicOp(ELogicOp op) { mState.mLogicOp = op; }

    ELogicOp logicOp() const { return mState.mLogicOp; }

    void setLineWidth(float width) { mState.mLineWidth = width; }

    float lineWidth() const { return mState.mLineWidth; }

    void setPointSmoothing(bool smooth) { mState.mPointSmoothing = smooth; }

    bool pointSmoothing() const { return mState.mPointSmoothing; }

    void setLineSmoothing(bool smooth) { mState.mLineSmoothing = smooth; }

    bool lineSmoothing() const { return mState.mLineSmoothing; }

    void setPolygonSmoothing(bool smooth) { mState.mPolygonSmoothing = smooth; }

    bool polygonSmoothing() const { return mState.mPolygonSmoothing; }

    void setLineStipple(ELineStipple stipple) ;

    void setLineStipple(unsigned short stipple) { mState.mLineStipple = stipple; }

    unsigned short lineStipple() const { return mState.mLineStipple; }

    void setPolygonStipple(EPolygonStipple stipple);

    void setPolygonStipple(unsigned char* stipple) { memcpy(mState.mPolyStipple, stipple, 32*32/8); }

    const unsigned char* polygonStipple() const { return mState.mPolyStipple; }

    unsigned char* polygonStipple() { return mState.mPolyStipple; }

    void setAlphaFunc(EFunction func, float ref_value)   { mState.mAlphaFuncRefValue=ref_value; mState.mAlphaFunc=func; }

    void getAlphaFunc(EFunction& func, float& ref_value) const { ref_value=mState.mAlphaFuncRefValue; func=mState.mAlphaFunc; }

    void setBlendFunc(EBlendFactor src_rgb, EBlendFactor dst_rgb, EBlendFactor src_alpha, EBlendFactor dst_alpha);

    void getBlendFunc(EBlendFactor& src_rgb, EBlendFactor& dst_rgb, EBlendFactor& src_alpha, EBlendFactor& dst_alpha) const;

    void setBlendEquation( EBlendEquation rgb_eq, EBlendEquation alpha_eq );

    void getBlendEquation( EBlendEquation& rgb_eq, EBlendEquation& alpha_eq ) const;

    void setColorMask(bool r, bool g, bool b, bool a) { mState.mColorMask = ivec4(r?1:0,g?1:0,b?1:0,a?1:0); }

    const ivec4& colorMask() const { return mState.mColorMask; }

    /*void setDetphMask(bool mask) { mState.mDepthMask = mask; }
    bool depthMask() const { return mState.mDepthMask; }*/

    void setStencilTestEnabled(bool enabled) { mState.mStencilTestEnabled = enabled; }

    bool stencilTestEnabled() const { return mState.mStencilTestEnabled; }

    void setStencilMask(unsigned int mask) { mState.mStencilMask = mask; }

    unsigned int stencilMask() const { return mState.mStencilMask; }

    void setStencilOp(EStencilOp sfail, EStencilOp dpfail, EStencilOp dppass);

    void getStencilOp(EStencilOp& sfail, EStencilOp& dpfail, EStencilOp& dppass);

    void setStencilFunc(EFunction func, int refval, unsigned int mask);

    void getStencilFunc(EFunction& func, int& refval, unsigned int& mask);

    void setFont(const String& name, int size, bool smooth=false) { mState.mFont = defFontManager()->acquireFont(name,size,smooth); }
    
    void setFont(const Font* font) { setFont(font->filePath(),font->size(),font->smooth()); }
    
    void setDefaultFont() { setFont(defFontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10, false)); }
    
    const Font* font() const { return mState.mFont.get(); }

    void setScissor(int x, int y, int width, int height)
    {
      mScissor = resolveScissor(x,y,width,height);
    }

    const Scissor* scissor() const { return mScissor.get(); }

    void removeScissor()
    {
      mScissor = NULL;
    }

    Actor* clearColor(const fvec4& color, int x=0, int y=0, int w=-1, int h=-1);

    Actor* clearStencil(int clear_val, int x=0, int y=0, int w=-1, int h=-1);

    Actor* drawText(Text* text);

    Actor* drawText(int x, int y, const String& text, int alignment = AlignBottom|AlignLeft);

    Actor* drawText(const String& text, int alignment = AlignBottom|AlignLeft);

    Actor* drawActor(Actor* actor, Transform* transform=NULL, bool keep_effect=false);

    Actor* drawActorCopy(Actor* actor, Transform* transform=NULL);

    const dmat4& matrix() const { return mMatrix; }

    void setMatrix(const dmat4& matrix) { mMatrix = matrix; }

    void resetMatrix() { mMatrix.setIdentity(); }

    void rotate(double deg);

    void translate(double x, double y, double z=0.0);

    void scale(double x, double y, double z=1.0);

    void pushMatrix() { mMatrixStack.push_back(matrix()); }

    void popMatrix();

    const std::vector<dmat4>& matrixStack() const { return mMatrixStack; }

    void pushState();

    void popState();

    /*const std::vector<State>& stateStack() const { return mStateStack; }*/

    void pushScissor(int x, int y, int w, int h);

    void popScissor();

    const std::vector< ref<Scissor> >& scissorStack() const { return mScissorStack; }

    void setTransform(Transform* transform) { for(int i=0; i<actors()->size(); ++i) actors()->at(i)->setTransform(transform); }

    Effect* currentEffect() { return currentEffect(mState); }

  private:
    void generateQuadsTexCoords(Geometry* geom, const std::vector<dvec2>& points);

    void generatePlanarTexCoords(Geometry* geom, const std::vector<dvec2>& points);

    void generateLinearTexCoords(Geometry* geom);

    ref<Geometry> prepareGeometry(const std::vector<dvec2>& ln);

    ref<Geometry> prepareGeometryPolyToTriangles(const std::vector<dvec2>& ln);
  
    Scissor* resolveScissor(int x, int y, int width, int height);

    Texture* resolveTexture(const Image* image);

    Effect* currentEffect(const State& vgs);

    Actor* addActor(Actor* actor) ;

  private:
    // state-machine state variables
    State mState;
    dmat4 mMatrix;
    ref<Scissor> mScissor;
    std::vector<State> mStateStack;
    std::vector<dmat4> mMatrixStack;
    std::vector< ref<Scissor> > mScissorStack;
    // state-machine state map
    std::map<State, ref<Effect> > mVGToEffectMap;
    std::map<ImageState, ref<Texture> > mImageToTextureMap;
    std::map<RectI, ref<Scissor> > mRectToScissorMap;
    ref<Effect> mDefaultEffect;
    ActorCollection mActors;
  };
//-------------------------------------------------------------------------------------------------------------------------------------------
}

#endif