fish/simplecoords/SimpleCoords.cpp

#include <ocean/GLvish/VRenderObject.hpp>

#include <fish/lakeview/bone/FishSlice.hpp>
#include <fish/lakeview/bone/FishField.hpp>

#include <field/DirectProductArray.hpp>
#include <ocean/GLvish/BoundingBox.hpp>

using namespace Wizt;
using namespace Fiber;


class SimpleCoords : public virtual VRenderObject,  virtual public Fish<Slice>, virtual public Fish<Grid>
{
public:
        // Shortcut some Datatypes used to acess coordinate and vector data.
        // Note that coordinates can come procedural or numerical and need different 
        // data types to be handled.
        typedef MemArray<1, Eagle::point3>             CoordsArray_t; 

        TypedSlot<double> PointSize;

        // Inner class to save local state Information. Besides the control parameters also 
        // pointers to the vector and coordinate data are saved here.
        struct  MyState : State
        {
                bool recalc_dl;
                RefPtr< CoordsArray_t > Crds; 
        };

        override RefPtr<State> newState() const
        {
                return new MyState();
        }

        SimpleCoords(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VRenderObject(name, p, VP)
        , Fish<VObject>(this)
        , Fish<Grid>("coords")
        , PointSize(this, "pointsize", 2.0)
        {
                PointSize.setProperty("max", 10.0); 

        }

        override bool update( VRequest&R, double precision );
        override void render( VRenderContext&R ) const;
};



bool SimpleCoords::update( VRequest&R, double precision )
{
//      printf("SimpleCoords::update(): updating\n"); 

GridSelector GS; 
        MyGrid << R >> GS;

// get the grid from the fiber bundle
RefPtr<Grid> G = findMostRecentGrid( GS, R );
        if (!G) { puts("SimpleCoords::update(), ERROR: No Grid"); return true; } 

// get the coordinates of the grid
RefPtr<Field> Coords  = G->CartesianPositions(); 
        if (!Coords)  { puts("SimpleCoords::update(): ERROR: No coord field!"); return true; } 


// get the actual state object
RefPtr<MyState> S = myState(R); 
        assert(S); 

        S->Crds = Coords->getData(); 
        S->recalc_dl = true; // force recalcing the displaylinst on each update call

        return true;
}


void SimpleCoords::render( VRenderContext& Context ) const
{
//      printf("SimpleCoords::render(): starting to render\n");

double point_size = 0.0; 
        PointSize  << Context >> point_size; 

        if(point_size <= 0.0) point_size = 1.0;

        glEnable(GL_DEPTH_TEST); 
        glDisable(GL_LIGHTING); 

        glPointSize(point_size);

        // get current state
        RefPtr<MyState>  state = myState(Context); 

        // return if no valid coord data is available 
        if(!state)
        {
                printf("SimpleCoords::render(): Invalid State!\n");
                return; 
        }
        if (!state->Crds)
        {
                printf("SimpleCoords::render(): Invalid Coordinates!\n");
                return; 
        }
        
        RefPtr<ValueSet> RenderParameterSpace = new ValueSet(); 


        RefPtr<DisplayList> DL; 
        try{
        DL = Context(*state)(this)( RenderParameterSpace ); 
        } 
        catch(...){}
        if ( DL && !state->recalc_dl )   //call display list if availlable
        {
                if(DL->call())
                {
                        //printf("SimpleCoords::render(): Called List\n");
                        return;
                } 
        } 
        else                                                   //prepare display list
        {
                DL = Context[*state][this][ RenderParameterSpace ]; 
                if (!DL) throw "SimpleCoords::render() No Display List!?"; 

                state->recalc_dl = false;

                // Get the coordinates saved in actual state. 
                // They can come as procedural or numerical coordinates. 
                // Be prepared for both types, because they need different handling.

                if (state->Crds)  // found numerical coordinates
                {
                point Start = state->Crds->first(); 
                point End   = state->Crds->last(); 
                        setBoundingBall(Context, new BoundingBox(Start, End) ); 
                        printf("SimpleCoords::render(): got numerical coordinates\n" ); 
                } 

        // create a Multiindex for traversing coordinate data. 
        MultiIndex<1> M; 
        MultiArray<1, point>&Cr = *state->Crds;

        glCompile( *DL ) 
                {
                        printf("SimpleCoords::render(): compiling new list\n");
                        glBegin(GL_POINTS); 
                        glColor3f(1.0,1.0,1.0); 

                        do
                        {
                        point Vertex; 

                                Vertex = Cr[M];

                                glVertex(Vertex); 
                                
                        }
                        while( M.inc( Cr.Size() ) ); // proceed to next Multiindex 
                        
                        glEnd();
 
                } 
        }
}


static Ref<VCreator<SimpleCoords, AcceptList<Fiber::Grid> > > myCreator("Tutorial/SimpleCoords");

VISH_DEFAULT_INIT

---