TexturedStreamLines.cpp

Like SimpleStreamline but uses multitextring and texturebase illumination to draw nicer streamlines.

Textures should not be stored in the state, as it is still done here...

See also:

Required tutorials: - SimpleStreamline.cpp

#include <ocean/GLvish/VRenderObject.hpp>
#include <fish/lakeview/bone/FishField.hpp>

#include <ocean/GLvish/Colormap.hpp> // use of color_t

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

#include <fish/fiber/vector/Interpolate.hpp>
#include <fish/fiber/vector/LinearIpol.hpp>
#include <fish/fiber/vector/CubicIpol.hpp>

#include <ocean/GLvish/GlossyTexture.hpp>

#include <ocean/plankton/VOperatorCache.hpp>



using namespace Wizt;
using namespace Fiber;

/*
  bla
*/
class   RampTexture : public GLTexture1D
{
        typedef FixedArray<float,3> rgb;

public: 
        RampTexture(const int tex_unit):GLTexture1D(tex_unit){}


        void enlighten()
                {
                rgb     texture[512]; 
                rgb col; 
                        col = 0,0,0;

                        for(int i = 0; i < 512 ; i++)
                        {
                                col[0] = (float)i/512; 
                                col[1] = 1 - col[0];
                                texture[i] = col; 
                        } 

                        bind(); 
                        GL::TexImage1D( texture, 512, GL_RGB); 
                        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP); 
                        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
                        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
                }

        void prerender()
                {
                        enable(); 
                        //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); //not really nesseccasy ? 
                        bind();  // should do corresponding glActiveTexture(GL_TEXTURE1);  ?? automatically ??
                }
        
};


class TexturedStreamLines : public virtual VRenderObject,  
//                          public virtual Fish<Grid>, 
                            public virtual Fish<Field>
{
public:
        typedef MemArray<3, tvector>           VectorArray_t; 
        typedef MemArray<3, point>             CoordsArray_t; 
        typedef DirectProductMemArray<point>   ProceduralArray_t; 

        typedef FixedArray<float,3> rgb; 

        GlossyTexture::Parameters  GlossyParameters;

        // define data type for storing a line
        typedef std::vector<point> Line_t;

        // prepare caching of computed lines
        typedef VOperatorCache<std::vector<Line_t> > OpCache_t;

        TypedSlot<int> LineLength;
        TypedSlot<int> LineWidth;
        TypedSlot<int> PointSize;
        TypedSlot<int> LineNumber;
        TypedSlot<double> StepSize;
        TypedSlot<double> FanDelta;

        TypedSlot<double> X,
                          Y,
                          Z;

        // Inner class to save local state Information. Besides the control parameters also 
        // pointers to the vector and coordinate data are saved here.
        // This causes an error when exiting vish, because the textures must be freed inside the openGL context, 
        // which is then not longer available.
        struct  MyState : State
        {
                RefPtr<RampTexture>   MyTexture;     
                RefPtr<GlossyTexture> LineTexture;
        };

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



        TexturedStreamLines(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VRenderObject(name, p, VP)
        , Fish<VObject>(this)
        , Fish<Field>("datafield")
        , GlossyParameters(this)
        , LineLength(this, "LineLength", 40)
        , LineWidth(this, "LineWidth", 2)
        , PointSize(this, "PointSize", 2)
        , LineNumber(this, "LineNumber", 10)
        , StepSize(this, "StepSize", 0.1)
        , FanDelta(this, "FanDelta", 0.05)
        , X(this, "X", 0.271)
        , Y(this, "Y", 0.294)
        , Z(this, "Z", 0.531)
        {
                LineLength.setProperty("max", 100); 
                LineLength.setProperty("min", 1); 
                LineWidth.setProperty("max", 20); 
                PointSize.setProperty("max", 20); 
                LineNumber.setProperty("min", 1);
                X.setProperty("max", 1.0); 
                Y.setProperty("max", 1.0); 
                Z.setProperty("max", 1.0); 
        }


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

        void getCoordinates(const point& float_index, point& position_cordinates);
};


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

FieldSelector FS = getFieldSelector(R);

// get the grid of the fiber bundle 
RefPtr<Grid>  G = FS.GridSource();
        if (!G)
                return true;

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


// get the vector data of the grid
RefPtr<Field> Vectors = FS.getField();
        if (!Vectors) { puts("SimpleStreamline::update(): No vector field!"); return true; } 



// associate the caching object to the field. As long as the field is valid the 
// cached lines can by used. If a new field is load (e.g. from another time step)
RefPtr<OpCache_t>&OC = OpCache_t::retrieve( *Vectors ) [ self() ]; 
       if (!OC) OC = new OpCache_t(); 

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

        assert(S); 

        RefPtr<VectorArray_t> Vctrs = Vectors->getData(); 

        if( !Vctrs)
        {
                printf("TexturedStreamLines::update(): Could get vector field data yet!\n"); 
                if (OC)
                {
                        OC->resize( 0 );
                        GLCache::clear( *OC );
                }
                return true;
        } 
        else
                printf("TexturedStreamLines::update(): Gotvector field data!\n"); 

        RefPtr<ProceduralArray_t>   PCrds = Coords->getData(); 
        RefPtr<CoordsArray_t>       Crds  = Coords->getData(); 
        if (!(Crds || PCrds))
                {
                        printf("TexturedStreamLines::update(): Did not find any coordinates :  %s\n",
                               Typename( Coords->getType() ).c_str() ); 
                        return true;
                } 




RefPtr<ValueSet> Changeables = new ValueSet(); 
Changeables & R += X, Y, Z, LineLength, PointSize, StepSize, FanDelta, LineNumber; 


int line_number = 1; 
        LineNumber << R >> line_number; 


        if (OC->unchanged( Changeables ) )
        {
                printf("TexturedStreamLines::update(): Line Calc Skipped, Lines in Cache...\n");
                return true;
        } 

        OC->resize( line_number ); // resize std::vector to number of lines
        GLCache::clear( *OC );

// Now do the Interpolation of the Coordinates 
// Get index Range of Data (and Coordinates)
        MultiIndex<3> FieldSize = Vctrs->Size(); 


double x, y, z; 
point float_index; 
point max_float_index; 
point vertex; 
int line_length; 
double hh; 
double fan_delta;

        LineLength << R >> line_length; 
        //LineNumber << R >> line_number; 
        StepSize << R >> hh; 
        FanDelta<< R >> fan_delta;

// Get user specified position ranging from 0 to 1.0 in each coordinate covering the whole dataset 
        X << R >> x; 
        Y << R >> y; 
        Z << R >> z; 

        max_float_index = FieldSize[0] - 1, FieldSize[1] - 1, FieldSize[2] - 1;
        float_index = x * FieldSize[0] - 1, y * FieldSize[1] -1 , z * FieldSize[2] - 1; 

// Clamp wrong inputs
        for (int i = 0; i < 3; i++)
        {
                if( float_index[i] < 0 )
                        float_index[i] = 0.0; 

                if( float_index[i] >= FieldSize[i] )
                        float_index[i] = FieldSize[i] - 1;
        } 

// assume uniform PCrds here (noch auszuweiten) 
point DomainStart = PCrds->first(); 
point DomaintEnd = PCrds->last(); 

tvector DomainDiagonal = DomaintEnd - DomainStart; 


// Calc StartPoint 
std::vector<point> StartVertex; 
StartVertex.resize(line_number);
StartVertex[0] = ( DomainStart + tvector(component_wise( component_wise(DomainDiagonal, max_float_index, Eagle::Operator<'/'>() ), float_index, Eagle::Operator<'*'>() ) ) ); 


tvector CurrentDir; 
point CurrentVertex; 
point CurrentFloatIndex; 
tvector FanOffset; 
        FanOffset = 1, 0, 0;

        resetBBox( R ); 
        embrace( R, StartVertex[0]);

        for(int l = 0; l < line_number; l++)
        {
                //printf("update: line: %d\n", l);
                StartVertex[l] = StartVertex[0] + FanOffset * l * fan_delta;
                
        Line_t&myLine = (*OC)[l]; 
                myLine.clear(); 
                
                for(int i = 0; i < line_length; i++)
                {
                        if (i == 0)
                        {
                                CurrentVertex = StartVertex[l]; 

                                Interpolate<3, tvector, CubicIpol <tvector> > VecField(*Vctrs, float_index); 
                                CurrentDir = VecField.eval(); 
                        }
                        else
                        {
                                CurrentFloatIndex = point( tvector( component_wise(component_wise(CurrentVertex - DomainStart, DomainDiagonal, Eagle::Operator<'/'>() ), max_float_index, Eagle::Operator<'*'>()) )); 

                                if(CurrentFloatIndex [0] < 0.0 ||CurrentFloatIndex [0] > max_float_index[0])
                                        break; 
                                if(CurrentFloatIndex [1] < 0.0 ||CurrentFloatIndex [1] > max_float_index[1])
                                        break; 
                                if(CurrentFloatIndex [2] < 0.0 ||CurrentFloatIndex [2] > max_float_index[2])
                                        break; 
                                Interpolate<3, tvector, CubicIpol <tvector> > VecField(*Vctrs, CurrentFloatIndex); 
                                CurrentDir = VecField.eval(); 
                        } 

                        
                                CurrentVertex += CurrentDir * hh; 
                                myLine.push_back(CurrentVertex); 
                                embrace( R, CurrentVertex); 
                }
        } 

        printf("TexturedStreamLines::update(): Integrated into Cache\n");
        closeBBox( R ); 
        
        return true;
}


void TexturedStreamLines::render( VRenderContext& Context ) const
{
        //printf("TexturedStreamLines::render: START\n");

        //printf("TexturedStreamLines::render(): starting to render\n");

 RefPtr<Field> Vectors = getField( Context ); 
        if (!Vectors) 
        {
                puts("void TexturedStreamLines::render(VRenderContext&RenderContext): NO VECTORS");
                return;
        } 
const RefPtr<OpCache_t>&OC = OpCache_t::retrieve( *Vectors ) ( self() );
        if (!OC)
        {
                puts("void TexturedStreamLines::render(VRenderContext&RenderContext): NO LINE CACHE"); 
                return;
        } 
        if (OC->size()<1)
        {
                puts("void TexturedStreamLines::render(VRenderContext&RenderContext): NO LINES in CACHE"); 
                return;
        } 

int line_width, point_size; 
int line_length  = 1; 

        LineWidth  << Context >> line_width; 
        PointSize  << Context >> point_size; 
        LineLength << Context >> line_length;

        if(line_width < 1)
                line_width = 1; 

        glEnable(GL_DEPTH_TEST); 
        glDisable(GL_LIGHTING); 

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
        glBlendFunc(GL_ONE, GL_ONE); 
//      glEnable( GL_BLEND ); 

        glEnable ( GL_COLOR_MATERIAL );
        glLineWidth( line_width ); 

        if(point_size > 0)
                glPointSize( point_size ); 
        else
                glPointSize( 1 ); 

        RefPtr<MyState>  state = myState(Context); 

        if(!state)
        {
                printf("TexturedStreamLines::render(): Invalid State!\n");
                return; 
        } 

        if (!state->LineTexture)
        {
                //glActiveTexture(GL_TEXTURE0); 
                state->LineTexture = new GlossyTexture(0);
                state->LineTexture->enlighten(); 
                state->LineTexture->enlighten(GlossyParameters, Context); 
        } 

        if (!state->MyTexture)
        {
                printf("TexturedStreamLines::render, new RampTexture Created\n"); 
                //glActiveTexture(GL_TEXTURE1); 
                state->MyTexture = new RampTexture(1); 
                state->MyTexture->enlighten(); 
        } 

        RefPtr<ValueSet> RenderParameterSpace = new ValueSet(); 
        RefPtr<DisplayList> DL; 
        try{
                DL = Context(*OC)(this)( RenderParameterSpace ); 
        } 
        catch(...){}
        RefPtr<ValueSet> Changeables = new ValueSet(); 
Changeables & Context += LineLength, LineNumber, StepSize; 



        // glActiveTexture(GL_TEXTURE0); 
//      state->LineTexture->beginRender( Context.CameraSettings ); 


GlossyTexture::Render RenderLineTexture( *state->LineTexture, Context.CameraSettings ); 

        glActiveTexture(GL_TEXTURE1); 
        state->MyTexture->prerender(); 
        //glActiveTexture(GL_TEXTURE0); 

        if ( DL && OC->unchanged( Changeables  ))   //call display list if availlable/  
        {
                printf("TexturedStreamLines::render(): Calling List\n"); 
                DL->call(); 
        } 
        else                                                   //prepare display list
        {
                printf("TexturedStreamLines::render(): Rendering List\n");
 
                DL = Context[*OC][this][ RenderParameterSpace ]; 
                if (!DL) throw "TexturedStreamLines::render() No Display List!?"; 

                glCompile( *DL ) 
                {
                int l = 0; 
                int p = 0; 
                       
                        for( OpCache_t::const_iterator lbit = OC->begin(); lbit != OC->end(); lbit++ )
                        {
                                p = 0; 
                                //printf("TexturedStreamLines::render()> :Line %d\n", l);
                        Line_t::const_iterator lit = lbit->begin(); 

                                if (lit == lbit->end() )
                                        break; 

                                glBegin( GL_LINE_STRIP );    // GLCHECK must not be used in between a glBegin and glEnd statement
                        bivector dir;

                                for(; lit != lbit->end();)
                                {
//                                      printf("TexturedStreamLines::render()> :point %d\n", p);
                                point   P = *lit; 
                                        lit++; 
                                        if (lit != lbit->end()) 
                                                dir = (*lit - P).unit(); 

                                        glMultiTexCoord3dv(GL_TEXTURE0, dir.ptr()) ; 
                                        glMultiTexCoord1d (GL_TEXTURE1,  (double)p/lbit->size()); 
                                        glVertex( P ); 

                                        p++;
                                } 

                                l++; 
                                glEnd(); 
                        } 

                        glEnable( GL_BLEND ); 

                        if(point_size > 0 )
                        {
                                for( OpCache_t::const_iterator lbit = OC->begin(); lbit != OC->end(); lbit++ ) 
                                {
                                        p = 0; 
                                        //printf("TexturedStreamLines::render()> :Line %d\n", l); 
                                        Line_t::const_iterator lit = lbit->begin(); 

                                        if (lit == lbit->end() ) 
                                                break; 

                                tvector dir; 
                                        glBegin(GL_POINTS); 

                                        for(; lit != lbit->end();)
                                        {
                                                //printf("TexturedStreamLines::render()> :point %d\n", p);
                                        point   P = *lit; 
                                                lit++; 
                                                if (lit != lbit->end())
                                                        dir = (*lit - P).unit(); 

                                                glMultiTexCoord3dv(GL_TEXTURE0, dir.ptr()) ; 
                                                glMultiTexCoord1d (GL_TEXTURE1,  (double)p/lbit->size()); 
                                                glVertex( P ); 

                                                p++;
                                        } 
                                        glEnd(); 
                                } 
                        }
                }
        } 

        //printf("TexturedStreamLines::render: END\n"); 
//      glActiveTexture(GL_TEXTURE0); 
//      state->LineTexture->endRender(); 

        state->touch(); // synchinozes state, prevents unneccessary calls of the update function.
}


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

VISH_DEFAULT_INIT

---