pg_draw.h

/*
    Copyright (c) 2007-2009 Takashi Kitao
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
    `  notice, this list of conditions and the following disclaimer.

    2. 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.

    3. The name of the author may not be used to endorse or promote products
    `  derived from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/


class PG_API pgDraw
{
    friend class pgScr;
    friend class pgDrawMgr;

public:
    pgDefineException(ExceptionInvalidArgument);
    pgDefineException(ExceptionInvalidCall);
    pgDefineException(ExceptionNotInitialized);

    enum DrawType
    {
        TYPE_NODE, 
        TYPE_PRIM, 
        TYPE_SPRT 
    };

    enum DepthTest
    {
        DEPTH_TEST_ALWAYS, 
        DEPTH_TEST_LESS, 
        DEPTH_TEST_GREATER, 
        DEPTH_TEST_LEQUAL, 
        DEPTH_TEST_GEQUAL 
    };

    enum BlendMode
    {
        BLEND_OFF, 
        BLEND_HALF, 
        BLEND_ADD, 
        BLEND_DEST_ALPHA 
    };

    enum DrawFlag
    {
        FLAG_BOUND_CLIP, 
        FLAG_SORT, 
        FLAG_WRITE_RGB, 
        FLAG_WRITE_ALPHA, 
        FLAG_WRITE_DEPTH, 
        FLAG_BACKFACE_CULLING, 
        FLAG_BILINEAR 
    };

    virtual ~pgDraw();

    bool hasScreen() const;

    pgID getScreenID() const;

    void setScreenID(pgID scr_id);

    bool hasParent() const;

    pgDraw* getParentN() const;

    void setParent(pgDraw* parent);

    pgDraw* getPrevAllN() const;

    pgDraw* getNextAllN() const;

    pgDraw* getPrevSiblingN() const;

    pgDraw* getNextSiblingN() const;

    pgDraw* getLastDesc() const;

    bool hasChild() const;

    pgDraw* getFirstChildN() const;

    pgDraw* getLastChildN() const;

    void moveFirst();

    void moveLast();

    void moveBefore(pgDraw* draw);

    void moveAfter(pgDraw* draw);

    DrawType getType() const;

    bool isVisible() const;

    void setVisible(bool is_visible);

    pgCol getColor() const;

    void setColor(pgCol col);

    DepthTest getDepthTest() const;

    void setDepthTest(DepthTest depth_test);

    BlendMode getBlendMode() const;

    void setBlendMode(BlendMode blend_mode);

    bool isDrawFlag(DrawFlag draw_flag) const;

    void setDrawFlag(DrawFlag draw_flag, bool is_on);

    void clearDrawFlag();

    void copyDrawFlag(const pgDraw* src);

    void setPreset_defaultBlendOff();

    void setPreset_defaultBlendHalf();

    void setPreset_defaultBlendAdd();

    const pgVec& getClipBoundMin() const;

    const pgVec& getClipBoundMax() const;

    void setClipBound(const pgVec& bound_min, const pgVec& bound_max);

    const pgVec& getSortCenter() const;

    void setSortCenter(const pgVec& sort_center);

    r32 getSortOffset() const;

    void setSortOffset(r32 sort_offset);

    pgID getTextureID() const;

    void setTextureID(pgID tex_id);

    pgMat& local();

    pgMat calcWorld() const;

    pgCol calcFinalColor() const;

protected:
    enum PrivateFlag
    {
        FLAG_INITIALIZED, //
        FLAG_VISIBLE
    };

    pgDraw();

    void setupWorld();
    void setupFinalColor();
    void setupSortValue(const pgMat& view);
    void setupDrawState();

    virtual void render(const pgMat& view);

    pgTree<pgDraw> m_tree;
    pgType<u8, DrawType> m_type;
    pgType<u8, DepthTest> m_depth_test;
    pgType<u8, BlendMode> m_blend_mode;
    pgFlag<u8, PrivateFlag> m_private_flag;
    pgFlag<u16, DrawFlag> m_draw_flag;
    pgID m_scr_id;
    pgTex* m_tex;
    pgMat m_local;
    pgMat m_world;
    pgCol m_local_col;
    pgCol m_final_col;
    pgVec m_bound_min;
    pgVec m_bound_max;
    pgVec m_sort_center;
    r32 m_sort_offset;
    r32 m_sort_value;
    pgDraw* m_next_sort;

private:
    pgDraw(const pgDraw&);
    void operator=(const pgDraw&);
};

---