SimpleCoords.cpp

This is tutorial demostrates how to access some curvilienar coordinates and draw openGL points. For accessing the data the fiber data model is used, which is located in vish's fish (= Fiber Vish). You should be familiar with VRenderObject and the use of display lists in vish.

To see the SimpleCoords module connected to the PointDistribution start it by using the .vis file.

../../../bin/vish SimpleCoords.vis

See also:

Required tutorials: - Simple3DObject.cpp - DisplayListObject.cpp

Further tutorials: - InterpolatedVector.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

---