Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *

/* ----------------------------------------------------------------------- *

 * This file is part of GEL, http://www.imm.dtu.dk/GEL

 * This file is part of GEL, http://www.imm.dtu.dk/GEL

 * Copyright (C) the authors and DTU Informatics

 * Copyright (C) the authors and DTU Informatics

 * For license and list of authors, see ../../doc/intro.pdf

 * For license and list of authors, see ../../doc/intro.pdf

 * ----------------------------------------------------------------------- */

 * ----------------------------------------------------------------------- */

/**

/**

 * @file ManifoldRenderer.h

 * @file ManifoldRenderer.h

 * @brief Tool for rendering a HMesh Manifold.

 * @brief Tool for rendering a HMesh Manifold.

 */

 */

#ifndef __MESHEDIT_RENDERER_H__

#ifndef __MESHEDIT_RENDERER_H__

#define __MESHEDIT_RENDERER_H__

#define __MESHEDIT_RENDERER_H__

#include "../CGLA/Vec2d.h"

#include "../CGLA/Vec2d.h"

#include "../GL/glew.h"

#include "../GL/glew.h"

#include "../HMesh/harmonics.h"

#include "../HMesh/harmonics.h"

#include "../GLGraphics/draw.h"

#include "../GLGraphics/draw.h"

#include "../GLGraphics/Console.h"

#include "../GLGraphics/Console.h"

#include "../GLGraphics/IDBufferWireFrameRenderer.h"

#include "../GLGraphics/IDBufferWireFrameRenderer.h"

#include "../CGLA/Vec4d.h"

#include "../CGLA/Vec4d.h"

namespace HMesh

namespace HMesh

{

{

    template<typename ITEM>

    template<typename ITEM>

    class VertexAttributeVector;

    class VertexAttributeVector;

}

}

namespace GLGraphics {

namespace GLGraphics {

    /** Ancestral class for Manifold rendering. Do not use directly. Its only purpose is to

    /** Ancestral class for Manifold rendering. Do not use directly. Its only purpose is to

     create a display list and remove it when the object is destroyed. This is an example

     create a display list and remove it when the object is destroyed. This is an example

     of the RAII "resource acquisition is initialization" idiom */

     of the RAII "resource acquisition is initialization" idiom */

    class ManifoldRenderer

    class ManifoldRenderer

	{

	{

	protected:

	protected:

		GLuint display_list;

		GLuint display_list;

	public:

	public:

		ManifoldRenderer(): display_list(glGenLists(1))	{}

		ManifoldRenderer(): display_list(glGenLists(1))	{}

		virtual ~ManifoldRenderer()

		virtual ~ManifoldRenderer()

		{

		{

			glDeleteLists(display_list, 1);

			glDeleteLists(display_list, 1);

		}

		}

        /// Produce a display list containing geometry and normals (which may be smooth or per face).

        /// Produce a display list containing geometry and normals (which may be smooth or per face).

		virtual void compile_display_list(const HMesh::Manifold& m, bool smooth) {}

		virtual void compile_display_list(const HMesh::Manifold& m, bool smooth) {}

		virtual void draw()

		virtual void draw()

		{

		{

			glCallList(display_list);

			glCallList(display_list);

		}

		}

	};

	};

    /** Wireframe rendering. This is a nasty complex class that relies on other classes. The trouble

    /** Wireframe rendering. This is a nasty complex class that relies on other classes. The trouble

     is that for non-triangle meshes, we need to use another approach than for triangle meshes.

     is that for non-triangle meshes, we need to use another approach than for triangle meshes.

     This class is really a front end for a couple of other classes. */

     This class is really a front end for a couple of other classes. */

    class WireframeRenderer: public ManifoldRenderer

    class WireframeRenderer: public ManifoldRenderer

	{

	{

		GLGraphics::IDBufferWireframeRenderer* idbuff_renderer;

		GLGraphics::IDBufferWireframeRenderer* idbuff_renderer;

		int maximum_face_valency(const HMesh::Manifold& m);

		int maximum_face_valency(const HMesh::Manifold& m);

	public:

	public:

		~WireframeRenderer()

		~WireframeRenderer()

		{

		{

			delete idbuff_renderer;

			delete idbuff_renderer;

		}

		}

		WireframeRenderer(HMesh::Manifold& m, bool flat);

		WireframeRenderer(HMesh::Manifold& m, bool flat);

		void draw();

		void draw();

	};

	};

    /** SimpleShaderRenderer is a very basic class for drawing a Manifold with shading.

    /** SimpleShaderRenderer is a very basic class for drawing a Manifold with shading.

     It is a convenient way to draw a surface using vertex and fragment shaders since it takes

     It is a convenient way to draw a surface using vertex and fragment shaders since it takes

     care of initializing the shaders and producing a display list for the geometry.

     care of initializing the shaders and producing a display list for the geometry.

     Geometry shaders typically add more complexity and are left out of this class, so you cannot add a

     Geometry shaders typically add more complexity and are left out of this class, so you cannot add a

     geometry shader.

     geometry shader.

     While this class can be used directly, the normal procedure is to inherit from SimpleShaderRenderer

     While this class can be used directly, the normal procedure is to inherit from SimpleShaderRenderer

     and then pass the shaders to the constructor. The strings defining the shaders would fit

     and then pass the shaders to the constructor. The strings defining the shaders would fit

     nicely as static constant strings (see e.g. ToonRenderer or GlazedRenderer) in your inherited class.

     nicely as static constant strings (see e.g. ToonRenderer or GlazedRenderer) in your inherited class.

     If you need to define more attributes or uniforms, you need to take charge. Your inherited class's

     If you need to define more attributes or uniforms, you need to take charge. Your inherited class's

     constructor should then use the default constructor of SimpleShaderRenderer. You can call init_shaders

     constructor should then use the default constructor of SimpleShaderRenderer. You can call init_shaders

     to initialize the shaders and then compile the display list yourself with the needed uniforms and

     to initialize the shaders and then compile the display list yourself with the needed uniforms and

     attributes - rather than calling compile_display_list which only puts vertices and normals in the list.

     attributes - rather than calling compile_display_list which only puts vertices and normals in the list.

     */

     */

    class SimpleShaderRenderer: public ManifoldRenderer

    class SimpleShaderRenderer: public ManifoldRenderer

	{

	{

		/// Compile the vertex and fragment shaders and link to form shader program.

		/// Compile the vertex and fragment shaders and link to form shader program.

		void init_shaders(const std::string& vss,

		void init_shaders(const std::string& vss,

						  const std::string& fss);

						  const std::string& fss);

	protected:

	protected:

		GLuint prog,vs,fs;

		GLuint prog,vs,fs;

	public:

	public:

		/** This constructor simply initializes the shaders. It does not create the display list.

		/** This constructor simply initializes the shaders. It does not create the display list.

         Use if you shader has extra attributes. */

         Use if you shader has extra attributes. */

		SimpleShaderRenderer(const std::string& vss,

		SimpleShaderRenderer(const std::string& vss,

							 const std::string& fss) {init_shaders(vss,fss);}

							 const std::string& fss) {init_shaders(vss,fss);}

		/// Produce a display list containing geometry and normals (which may be smooth or per face).

		/// Produce a display list containing geometry and normals (which may be smooth or per face).

		virtual void compile_display_list(const HMesh::Manifold& m, bool smooth);

		virtual void compile_display_list(const HMesh::Manifold& m, bool smooth);

		/// Releases the program and shaders.

		/// Releases the program and shaders.

		~SimpleShaderRenderer()

		~SimpleShaderRenderer()

		{

		{

			glDeleteProgram(prog);

			glDeleteProgram(prog);

			glDeleteShader(vs);

			glDeleteShader(vs);

			glDeleteShader(fs);

			glDeleteShader(fs);

		}

		}

		/// Do the actual drawing. Simply calls the display list if this function is not overloaded.

		/// Do the actual drawing. Simply calls the display list if this function is not overloaded.

		virtual void draw();

		virtual void draw();

	};

	};

    /** Ugly basic gouraud rendering. This class uses OpenGL's fixed function pipeline. */

    /** Ugly basic gouraud rendering. This class uses OpenGL's fixed function pipeline. */

    class NormalRenderer: public SimpleShaderRenderer

    class NormalRenderer: public SimpleShaderRenderer

    {

    {

        const static std::string vss;

        const static std::string vss;

        const static std::string fss;

        const static std::string fss;

    public:

    public:

        NormalRenderer():

        NormalRenderer():

        SimpleShaderRenderer(vss, fss) {}

        SimpleShaderRenderer(vss, fss) {}

    };

    };

    /** Debug renderer. Color code faces and show vertices as balls.*/

    /** Debug renderer. Color code faces and show vertices as balls.*/

    class DebugRenderer: public SimpleShaderRenderer

    class DebugRenderer: public SimpleShaderRenderer

    {

    {

        const static std::string vss;

        const static std::string vss;

        const static std::string fss;

        const static std::string fss;

    public:

    public:

        static HMesh::VertexAttributeVector<CGLA::Vec3f> vertex_colors;

        static HMesh::VertexAttributeVector<CGLA::Vec3f> vertex_colors;

        static HMesh::FaceAttributeVector<CGLA::Vec3f> face_colors;

        static HMesh::FaceAttributeVector<CGLA::Vec3f> face_colors;

        static HMesh::HalfEdgeAttributeVector<CGLA::Vec3f> edge_colors;

        static HMesh::HalfEdgeAttributeVector<CGLA::Vec3f> edge_colors;

    public:

    public:

        DebugRenderer(): SimpleShaderRenderer(vss, fss) {}

        DebugRenderer(): SimpleShaderRenderer(vss, fss) {}

    };

    };

    /** Render reflection lines. This class renders the object as if it is specular and inside

    /** Render reflection lines. This class renders the object as if it is specular and inside

     an infinitely long, vertical cylinder with white strips (also vertical). Useful if you

     an infinitely long, vertical cylinder with white strips (also vertical). Useful if you

     want to see whether the surface is smooth or has kinks. */

     want to see whether the surface is smooth or has kinks. */

    class ReflectionLineRenderer: public SimpleShaderRenderer

    class ReflectionLineRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		ReflectionLineRenderer(): SimpleShaderRenderer(vss, fss) {}

		ReflectionLineRenderer(): SimpleShaderRenderer(vss, fss) {}

	};

	};

    /** Render isophotes with respect to a lightsource in the eye. Useful if you

    /** Render isophotes with respect to a lightsource in the eye. Useful if you

     want to see whether the surface is smooth or has kinks. */

     want to see whether the surface is smooth or has kinks. */

    class IsophoteLineRenderer: public SimpleShaderRenderer

    class IsophoteLineRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		IsophoteLineRenderer(): SimpleShaderRenderer(vss, fss) {}

		IsophoteLineRenderer(): SimpleShaderRenderer(vss, fss) {}

	};

	};

    /** The toon renderer simply quantizes the shading to give a toonish appearance

    /** The toon renderer simply quantizes the shading to give a toonish appearance

     with a fat black silhouette. */

     with a fat black silhouette. */

    class ToonRenderer: public SimpleShaderRenderer

    class ToonRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		ToonRenderer(): SimpleShaderRenderer(vss, fss) {}

		ToonRenderer(): SimpleShaderRenderer(vss, fss) {}

	};

	};

    /** Render like glazed ceramics. Looks cool. I will add more to this. */

    /** Render like glazed ceramics. Looks cool. I will add more to this. */

    class GlazedRenderer: public SimpleShaderRenderer

    class GlazedRenderer: public SimpleShaderRenderer

	{

	{

		float bsphere_rad;

		float bsphere_rad;

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		GlazedRenderer(): SimpleShaderRenderer(vss, fss) {}

		GlazedRenderer(): SimpleShaderRenderer(vss, fss) {}

        void compile_display_list(const HMesh::Manifold& m, bool smooth);

        void compile_display_list(const HMesh::Manifold& m, bool smooth);

	};

	};

    /** Render a scalar field. Positive scalars are mapped to blue and negative to red.

    /** Render a scalar field. Positive scalars are mapped to blue and negative to red.

     This class also has controls for gamma correction which is highly useful if the

     This class also has controls for gamma correction which is highly useful if the

     scalars are mostly small or large and simply scaling to the 0-1 range does not

     scalars are mostly small or large and simply scaling to the 0-1 range does not

     produce a good result. */

     produce a good result. */

    class ScalarFieldRenderer: public SimpleShaderRenderer

    class ScalarFieldRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		ScalarFieldRenderer(): SimpleShaderRenderer(vss, fss) {}

		ScalarFieldRenderer(): SimpleShaderRenderer(vss, fss) {}

        void compile_display_list(const HMesh::Manifold& m, bool smooth,

        void compile_display_list(const HMesh::Manifold& m, bool smooth,

                                  HMesh::VertexAttributeVector<double>& field, double max_val, float gamma = 2.2);

                                  HMesh::VertexAttributeVector<double>& field, double max_val, float gamma = 2.2);

	};

	};

    /** Render a checkerboard pattern based on input texture map */

    /** Render a checkerboard pattern based on input texture map */

    class CheckerBoardRenderer: public SimpleShaderRenderer

    class CheckerBoardRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

        static HMesh::VertexAttributeVector<CGLA::Vec2f> param;

        static HMesh::VertexAttributeVector<CGLA::Vec2f> param;

		CheckerBoardRenderer(): SimpleShaderRenderer(vss, fss) {}

		CheckerBoardRenderer(): SimpleShaderRenderer(vss, fss) {}

        void compile_display_list(const HMesh::Manifold& m, bool smooth);

        void compile_display_list(const HMesh::Manifold& m, bool smooth);

	};

	};

    /** Ambient occlusion renderer. Very similar to ScalarFieldRender. Simply assumes that the input values are

    /** Ambient occlusion renderer. Very similar to ScalarFieldRender. Simply assumes that the input values are

     mean curvatures which in some sense indicate how concave the surface is.*/

     mean curvatures which in some sense indicate how concave the surface is.*/

    class AmbientOcclusionRenderer: public SimpleShaderRenderer

    class AmbientOcclusionRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		AmbientOcclusionRenderer(): SimpleShaderRenderer(vss, fss) {}

		AmbientOcclusionRenderer(): SimpleShaderRenderer(vss, fss) {}

        void compile_display_list(const HMesh::Manifold& m, HMesh::VertexAttributeVector<double>& field, double max_val);

        void compile_display_list(const HMesh::Manifold& m, HMesh::VertexAttributeVector<double>& field, double max_val);

	};

	};

    /** Line fields are rendered by convolving a noise function in the direction of the line.

    /** Line fields are rendered by convolving a noise function in the direction of the line.

     This is useful, for instance, for curvature rendering. */

     This is useful, for instance, for curvature rendering. */

    class LineFieldRenderer: public SimpleShaderRenderer

    class LineFieldRenderer: public SimpleShaderRenderer

	{

	{

		const static std::string vss;

		const static std::string vss;

		const static std::string fss;

		const static std::string fss;

	public:

	public:

		LineFieldRenderer(): SimpleShaderRenderer(vss, fss) {}

		LineFieldRenderer(): SimpleShaderRenderer(vss, fss) {}

        void compile_display_list(const HMesh::Manifold& m,HMesh::VertexAttributeVector<CGLA::Vec3d>& lines);

        void compile_display_list(const HMesh::Manifold& m,HMesh::VertexAttributeVector<CGLA::Vec3d>& lines);

	};

	};

    class HarmonicsRenderer: public GLGraphics::ManifoldRenderer

    class HarmonicsRenderer: public GLGraphics::ManifoldRenderer

    {

    {

        static GLuint prog_P0;

        static GLuint prog_P0;

        static GLGraphics::Console::variable<float> display_harmonics_time;

        static GLGraphics::Console::variable<float> display_harmonics_time;

        static GLGraphics::Console::variable<int> display_harmonics_diffuse;

        static GLGraphics::Console::variable<int> display_harmonics_diffuse;

        static GLGraphics::Console::variable<int> display_harmonics_highlight;

        static GLGraphics::Console::variable<int> display_harmonics_highlight;

        static GLGraphics::Console::variable<int> display_harmonics_e0;

        static GLGraphics::Console::variable<int> display_harmonics_e0;

        static GLGraphics::Console::variable<int> display_harmonics_e1;

        static GLGraphics::Console::variable<int> display_harmonics_e1;

        HMesh::Manifold* m;

        HMesh::Manifold* m;

        HMesh::Harmonics* h;

        HMesh::Harmonics* h;

        /// Draw with eigenvalues

        /// Draw with eigenvalues

        void draw_adf();

        void draw_adf();

        void draw_esum();

        void draw_esum();

    public:

    public:

        HarmonicsRenderer(HMesh::Manifold& _m, HMesh::Harmonics* _h, GLGraphics::Console& cs);

        HarmonicsRenderer(HMesh::Manifold& _m, HMesh::Harmonics* _h, GLGraphics::Console& cs);

        /// Parse keystrokes that would influence the interactive display

        /// Parse keystrokes that would influence the interactive display

        void parse_key(unsigned char key);

        void parse_key(unsigned char key);

    };

    };

}

}

#endif

#endif

Generated by GNU Enscript 1.6.6.

Generated by GNU Enscript 1.6.6.