source: GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.h @ 1990

#ifndef __GLOBALLINESRENDERER_H
#define __GLOBALLINESRENDERER_H

#include "common.h"
#include "Containers.h"
#include "Vector3.h"


class RenderTexture;

namespace GtpVisibilityPreprocessor {

class Beam;
class Intersectable;
class Preprocessor;
class GlRenderer;
struct SimpleRay;

struct VssRayContainer;

class GlobalLinesRenderer
{
public:
        
        GlobalLinesRenderer(Preprocessor *preprocessor, 
                                                const int texHeight,
                                                const int mTexWidth,
                                                const float eps,
                                                const int maxDepth,
                                                const bool sampleReverse);

        GlobalLinesRenderer(Preprocessor *preprocessor);

        ~GlobalLinesRenderer();

        /** Casts global lines in the angle specified by alpha and
                beta. The computed samples are stored in the ray container.
                @returns # of layers
        */
        int CastGlobalLines(const float alpha, 
                                                 const float beta, 
                                                 VssRayContainer &rays);

        /** Casts global lines using the given ray as origin and 
                direction vector.
                @returns Computed samples in the container rays
        */
        int CastGlobalLines(const SimpleRay &ray, 
                                                VssRayContainer &rays);


        void ComputeBoundingQuad(int &xMin, 
                                                         int &yMin, 
                                                         int &xMax,
                                                         int &yMax);

        void InitGl();

        /** Computes rays from information gained with hw sampling
        */
        void ComputeRays(Intersectable *sourceObj, VssRayContainer &rays);

        float GetPixelError(int &pvsSize);

        int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const;

        /** Draws the geometry for one pass.
        */
        void DrawGeometry();
        void Run();
        void GrabDepthBuffer(float *data, RenderTexture *rt);
        void GrabItemBuffer(unsigned char *data, RenderTexture *rt);
        int ApplyDepthPeeling(VssRayContainer &rays);
        void ExportDepthBuffer();
        void ExportItemBuffer();
        bool ProcessDepthBuffer(VssRayContainer &vssRays, 
                                                        const bool oldBufferInitialised, 
                                                        const int pass);

        void DisplayBuffer(const bool isDepth);
        
        bool ClipToViewSpaceBox(const Vector3 &origin,
                                                        const Vector3 &termination,
                                                        Vector3 &clippedOrigin,
                                                        Vector3 &clippedTermination);

        Intersectable *ExtractSamplePoint(float *depthBuffer,
                                                                          unsigned char *itemBuffer,
                                                                          const int x, 
                                                                          const int y,
                                                                          Vector3 &hitPoint,
                                                                          const bool isFrontBuffer) const;

        void Visualize(const VssRayContainer &vssRays);

        int mMaxDepth;
        
        Vector3 mEyeVec;
        Vector3 mLeftVec;
        Vector3 mUpVec;
        Vector3 mTermination;

        float mFar;
        float mNear;
        float mWidth;

        Vector3 mViewPoint;

        float *mNewDepthBuffer;
        float *mOldDepthBuffer;

        unsigned char *mNewItemBuffer;
        unsigned char *mOldItemBuffer;
        
        RenderTexture *mNewTexture;
        RenderTexture *mOldTexture;

        void ComputeLookAt(const float alpha, 
                                           const float beta,
                                           Vector3 &eye, 
                                           Vector3 &up, 
                                           Vector3 &left);

        Preprocessor *mPreprocessor;

protected:

        void SwitchRenderTextures();

        void InitScene(const float alpha, const float beta);
        void InitScene(const SimpleRay &ray);

        void InitRenderTexture(RenderTexture *rt);

        

        GlRenderer *mRenderer;

        int mTexWidth;
        int mTexHeight;
        float mEpsilon;

        bool mSampleReverse;
};

extern GlobalLinesRenderer *globalLinesRenderer;

};

#endif