eng_graph_draw.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef ENG_GRAPH_DRAW_HH
#define ENG_GRAPH_DRAW_HH 1

// Because of how the dot product formula used for polygon culling,
// normal vectors no longer should be transformed.
#define COMPILE_RETRANSFORM_NORMALS 0

#include "eng_node.hh"
#include "eng_node_visitor.hh"
#include "eng_graph.hh"

namespace eng {

class VisitorDraw : public Visitor
{
private:
#define VISITOR_DRAW_SPECIAL_NODE(CLASS)                                    \
                CLASS( void ) : SpecialNode() { }                           \
                CLASS( const CLASS& src ) : SpecialNode(src) { }            \
                ~CLASS() { }                                                \
    /* Cast is critical to select proper Visit() of derived class. */       \
    void        Accept( Visitor& visitor )                                  \
    {                                                                       \
         static_cast<VisitorDraw&>(visitor).Visit( *this );                 \
    }                                                                       \
    Node::Ptr   Clone( void ) const { return new CLASS( *this ); }

private:
    class PopMatrixNode : public SpecialNode
    {
    public:
        VISITOR_DRAW_SPECIAL_NODE(PopMatrixNode)
    };

public:
    VisitorDraw( Graph& graph, SharedPtr<Object> object );
    ~VisitorDraw( void );

    // Regular nodes:
    void    Visit( TransformNode& node );
    void    Visit( VertexsNode& node );
    void    Visit( NormalsNode& node );
    void    Visit( ModesNode& node );
    void    Visit( MaterialNode& node );
    void    Visit( TextureNode& node );
    void    Visit( ColorsNode& node );
    void    Visit( PolygonNode& node );
    void    Visit( PolygonNode_TriColor1& node );
    void    Visit( PolygonNode_TriColor3& node );
    void    Visit( PolygonNode_QuadColor1& node );
    void    Visit( PolygonNode_QuadColor4& node );
    void    Visit( PolygonNode_Tex& node );
    void    Visit( PolygonNode_TexTriColor1& node );
    void    Visit( PolygonNode_TexTriColor3& node );
    void    Visit( PolygonNode_TexQuadColor1& node );
    void    Visit( PolygonNode_TexQuadColor4& node );

    // Special nodes:
    void    Visit( SpecialNode& node ) { ASSERT(false); }
    void    Visit( PopMatrixNode& node );

    void    Begin( GraphTraversal::Ptr traversal );
    void    End( void );

private:
    void        ComputeEyeMatrix( void );
    void        ComputeNormals( NormalsNode& normalsNode );
#if COMPILE_RETRANSFORM_NORMALS
    void        TransformNormals( NormalsNode& normalsNode );
#endif
#if DEBUG
    void        DRAW_POLYGON_NODE_CHECKS( PolygonNode& node );
    void        DRAW_POLYGON_NODE_TEX_CHECKS( PolygonNode_Tex& node );
#endif

    enum ePolygonType
    {
        ePolygonType_NONE,
        ePolygonType_TRIANGLES,
        ePolygonType_QUADS
    };

    void BeginTriangle( void )
    {
        if ( UX( mPolygonType != ePolygonType_TRIANGLES ) )
        {
            if ( EX( mPolygonType != ePolygonType_NONE ) )  // end previous primitive
                GFX::End();
            GFX::Begin( GFX::ePrim_TRIANGLES );
            mPolygonType = ePolygonType_TRIANGLES;  // after the if
        }
    }

    void BeginQuad( void )
    {
        if ( UX( mPolygonType != ePolygonType_QUADS ) )
        {
            if ( EX( mPolygonType != ePolygonType_NONE ) )  // end previous primitive
                GFX::End();
            GFX::Begin( GFX::ePrim_QUADS );
            mPolygonType = ePolygonType_QUADS;  // after the if
        }
    }


    // EndTriangle()/EndQuad() vs. EndDrawing():
    // The purpose of EndDrawing() is to unconditionally stop drawing polygons.
    // The purpose of EndTriangle()/EndQuad() is to logically mark the end of a primitive
    // (in fact, the drawing mode is left enabled for speed).

    void EndTriangle( void )
    {
        // NOP
    }

    void EndQuad( void )
    {
        // NOP
    }

    void EndDrawing( void )
    {
        if ( mPolygonType != ePolygonType_NONE )
        {
            mPolygonType = ePolygonType_NONE;
            GFX::End();
        }
    }

private:
    SharedPtr<Object>               mObject;
    GraphTraversal::Ptr         mTraversal;         
    Matrix                      mMatrix;            
    Matrix                      mMatrixEye;         
    const Matrix                mMatrixView;        
    Stack<Matrix>               mMatrixStack;
    SharedPtr0<const LocalVertexs>  mLocalVertexs;
    EyeVertexs                  mEyeVertexs;        
    shptr0<NormalVertexs>       mPolygonNormals;    
    shptr0<NormalVertexs>       mVertexNormals;     
    ModesNode::Modes            mModes;             
    bool                        mLighting;          
    shptr<Texture>              mTexture;           
    bool                        mRestoreTextureMatrix;  
    fp                          mSavedTextureMatrix[16];
    ColorsNode::Colors          mColors;            
    ePolygonType                mPolygonType;       
#if DEBUG
    bool                        mDone;              
#endif
};

class VisitorComputeNormals : public Visitor
{
public:
            VisitorComputeNormals( Graph& graph, NormalsNode& normalsNode, const LocalVertexs& localVertexs );
            ~VisitorComputeNormals();
    void    Begin( void ) { }
    void    End( void );

private:
    template<typename VIXS>
    void ComputeAndTotalNormal( const Nix nix, const VIXS& vixs )
    {
        // Compute normal vector on this polygon.
        const Vector3 crossProduct = CrossProduct( mLocalVertexs[vixs[0]],  // 0,2,1
                                                   mLocalVertexs[vixs[2]],
                                                   mLocalVertexs[vixs[1]] );
        const NormalVertex polygonNormal = NormalVertex( Normalize( crossProduct ) );
        Expand( mPolygonNormals, nix );        // resize, polygon cnt is unknown so it wasn't pre-resized
        mPolygonNormals[nix] = polygonNormal;  // ref to NormalsNode::mPolygonNormals

        // For the first step of averaging normal vectors, add this vector to a total.
        // Later, Visitor will normalize the totals.
        for ( uint i = 0; i < vixs.size(); ++i )  // compile should unroll since TinyArray::size() is a constant
        {
        ASSERT( vixs[i] < mVertexNormals.size() );  // should be pre-resized since vertex cnt is known
            mVertexNormals[vixs[i]] += polygonNormal;
        }
    }

private:
    // One suffices since variants of Visitor::Visit(PolygonNode&) default to calling the base Visit().
    void    Visit( PolygonNode& node ) { ComputeAndTotalNormal( node.GetNix(), node.GetVixs() ); }

private:
    // Normal vectors exist and remain in Normal Space.
    // TransformNormals(), despite its name, really rotates normals within Normal Space.
    const LocalVertexs&     mLocalVertexs;      // ref to VertexsNode::mLocalVertexs
    NormalVertexs&          mPolygonNormals;    // ref to NormalsNode::mPolygonNormals
    NormalVertexs&          mVertexNormals;     // ref to NormalsNode::mVertexNormals
};

} // namespace eng

#endif // ENG_GRAPH_DRAW_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:08 2007