TnFXGraph.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                              2D and 3D Graphing                               *
*                                                                               *
*********************************************************************************
* Copyright (C) 2006 by Niall Douglas.   All Rights Reserved.                   *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/
#ifndef FX_DISABLEGL

#if FX_GRAPHINGMODULE

#ifndef TNFXGRAPH_H
#define TNFXGRAPH_H

#include "FXApp.h"
#include "FXGLObject.h"
#include "FXVec4f.h"
#include "qmemarray.h"

namespace FX {

class FXGLVertices;
class FXVec3d;
template<class type> class QPtrVector;


struct TnFXGraphItem;
class FXGRAPHINGMODULEAPI TnFXGraph : public FXGLGroup
{
    FXDECLARE_ABSTRACT(TnFXGraph)
    TnFXGraph(const TnFXGraph &);
    TnFXGraph &operator=(const TnFXGraph &);
    inline FXDLLLOCAL TnFXGraphItem *int_item(FXuint item);
protected:
    QPtrVector<TnFXGraphItem> *items;
    virtual void int_prepareItems(FXGLViewer *viewer)=0;
    TnFXGraph();
public:
    ~TnFXGraph();

    typedef void (*ExpandFunc)(QMemArray<FXVec3f> &out, const QMemArray<FXVec2f> &in);
    typedef void (*ReduceFunc)(QMemArray<FXVec3f> &out, const QMemArray<FXVec3f> &in);

    FXGLVertices *setItemDetails(FXuint item, const FXString &title, const FXGLColor &colour, FXfloat pointsize=4.0f, FXfloat linesize=2.0f);
    FXGLVertices *setItemData(FXuint item, const FXVec2f *data, FXuint elements, ExpandFunc expand=Expand);
    FXGLVertices *setItemData(FXuint item, const QMemArray<FXVec2f> *data, ExpandFunc expand=Expand);
    FXGLVertices *setItemData(FXuint item, const FXVec3f *data, FXuint elements, ReduceFunc reduce=ReduceZ);
    FXGLVertices *setItemData(FXuint item, const QMemArray<FXVec3f> *data, ReduceFunc reduce=ReduceZ);
    FXGLVertices *itemChanged(FXuint item);

    virtual void bounds(FXRangef& box);
    virtual void draw(FXGLViewer *viewer);
    virtual void hit(FXGLViewer *viewer);
public:
    template<FXint zval> static void Expand(QMemArray<FXVec3f> &out, const QMemArray<FXVec2f> &in)
    {
        out.resize(in.count());
        for(FXuint n=0; n<in.count(); n++)
        {
            out[n].x=in[n].x;
            out[n].y=in[n].y;
            out[n].z=zval;
        }
    }
    static void Expand(QMemArray<FXVec3f> &out, const QMemArray<FXVec2f> &in)
    {
        out.resize(in.count());
        for(FXuint n=0; n<in.count(); n++)
        {
            out[n].x=in[n].x;
            out[n].y=in[n].y;
            out[n].z=0.0f;
        }
    }
    template<int offset, int stepe, int stepm> static void ReduceE(QMemArray<FXVec3f> &out, const QMemArray<FXVec3f> &in)
    {
        out.resize(in.count()*3/(stepe+stepm));
        FXfloat *FXRESTRICT o=(FXfloat *) out.data();
        const FXfloat *FXRESTRICT i=(const FXfloat *) in.data();
        for(FXuint n=offset; n<in.count()*3; n+=stepe)
        {
            *o++=i[n];
            *o++=i[n+stepm];
            *o++=0;
        }
    }
    template<int yinc, int offset, int step> static void ReduceE2x(QMemArray<FXVec3f> &out, const QMemArray<FXVec3f> &in)
    {
        out.resize(in.count()*3/step);
        FXfloat y=0;
        FXfloat *FXRESTRICT o=(FXfloat *) out.data();
        const FXfloat *FXRESTRICT i=(const FXfloat *) in.data();
        for(FXuint n=offset; n<in.count()*3; n+=step)
        {
            *o++=i[n];
            *o++=y;
            *o++=0;
            y+=yinc;
        }
    }
    template<int xinc, int offset, int step> static void ReduceE2y(QMemArray<FXVec3f> &out, const QMemArray<FXVec3f> &in)
    {
        out.resize(in.count()*3/step);
        FXfloat x=0;
        FXfloat *FXRESTRICT o=(FXfloat *) out.data();
        const FXfloat *FXRESTRICT i=(const FXfloat *) in.data();
        for(FXuint n=offset; n<in.count()*3; n+=step)
        {
            *o++=x;
            x+=xinc;
            *o++=i[n];
            *o++=0;
        }
    }
    static void ReduceZ(QMemArray<FXVec3f> &out, const QMemArray<FXVec3f> &in)
    {
        out.resize(in.count());
        for(FXuint n=0; n<in.count(); n++)
        {
            out[n].x=in[n].x/in[n].z;
            out[n].y=in[n].y/in[n].z;
            out[n].z=0;
        }
    }
};


struct TnFX2DGraphPrivate;
class FXGRAPHINGMODULEAPI TnFX2DGraph : public TnFXGraph
{
    FXDECLARE(TnFX2DGraph)
    TnFX2DGraphPrivate *p;
    TnFX2DGraph(const TnFX2DGraph &);
    TnFX2DGraph &operator=(const TnFX2DGraph &);
    void init();
    virtual void int_prepareItems(FXGLViewer *viewer);
    void int_drawLabels(FXGLViewer *viewer);
public:
    TnFX2DGraph();
    TnFX2DGraph(const QMemArray<FXVec2f> *data, ExpandFunc expand=Expand);
    TnFX2DGraph(const QMemArray<FXVec3f> *data, ReduceFunc reduce=ReduceZ);
    ~TnFX2DGraph();

    FXGLVertices *setAxes(const FXVec4f &range=FXVec4f(Generic::BiggestValue<float>::value, Generic::BiggestValue<float>::value, Generic::BiggestValue<float>::value, Generic::BiggestValue<float>::value), FXfloat lineSize=4.0f);
    FXGLVertices *setAxesMajor(FXfloat granx=0, FXfloat grany=0, FXfloat lineSize=2.0f, const FXFont *font=FXApp::instance()->getNormalFont());

    virtual void bounds(FXRangef& box);
    virtual void draw(FXGLViewer *viewer);
    virtual void hit(FXGLViewer *viewer);
};


struct TnFX3DGraphPrivate;
class FXGRAPHINGMODULEAPI TnFX3DGraph : public TnFXGraph
{
    FXDECLARE(TnFX3DGraph)
    TnFX3DGraphPrivate *p;
    TnFX3DGraph(const TnFX3DGraph &);
    TnFX3DGraph &operator=(const TnFX3DGraph &);
    void init();
    virtual void int_prepareItems(FXGLViewer *viewer);
public:
    TnFX3DGraph();
    TnFX3DGraph(const QMemArray<FXVec2f> *data, ExpandFunc expand=Expand);
    TnFX3DGraph(const QMemArray<FXVec3f> *data, ReduceFunc reduce=ReduceZ);
    ~TnFX3DGraph();
};

}

#endif
#endif
#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.