gee_gl_renderer.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef GEE_GL_RENDERER_H
#define GEE_GL_RENDERER_H

#include <gee_renderer.h>

#include <gee_gl_light.h>

#include <GL/gl.h>
#include <GL/glu.h>

#include <vector>

class GEE_Geometry;
class GEE_GlDisplayLists;
class GEE_GlMaterial;
class GEE_GlMaterialBank;
class GEE_Material;

class VEE_GlRenderer;
class VEE_GlTexture2DBank;

class GEE_GlRenderer : public GEE_Renderer
{
public:
  GEE_GlRenderer();
  virtual ~GEE_GlRenderer();
  
  virtual void renderGroupStructure(GEE_Group *);
  virtual void renderLines3D(GEE_Lines3D *);
  virtual void renderPath3D(GEE_Path3D *);
  virtual void renderParticleObject(GEE_ParticleObject *);
  virtual void renderPolygonMesh(GEE_PolygonMesh *);
  virtual void renderProfile(GEE_Profile *);
  virtual void renderSphere(GEE_Sphere *);
  virtual void renderTriangleMesh(GEE_TriangleMesh *);
  virtual void renderVeeObject(VEE_Object *, 
             const VEE_Matrix4 * m = 0,
             float scale = 0.0f);

  virtual void pushTransform(const VEE_Matrix4d &);
  virtual void pushTransform(const VEE_Matrix4 &);
  virtual void popTransform();
  virtual void enableTransforms(bool enable);
  virtual bool enableTransforms();
  
  void setDisplayLists(GEE_GlDisplayLists * lists) { m_displayLists = lists; }
  void setHighlightDisplayLists(GEE_GlDisplayLists * lists) 
  { m_highlightDisplayLists = lists; }
  void setMaterials(GEE_GlMaterialBank *materials) { m_materials = materials; }
  void setTextures(VEE_GlTexture2DBank *textures)  { m_textures = textures; }

  void addLights(const GEE_GlLights & lights);
  void loadLights(const char * nameBase = "lights-%d", int maximum = 100);
  uint lightCount() const { return m_lights.size(); }
  GEE_GlLights & light(int i) { return m_lights[i]; }
  void selectLights(uint i) 
  { if(i < m_lights.size()) m_currentLight = & m_lights[i]; }
  void clearLights();

  virtual void initGlState();
  virtual void closeGlState();

  void applyGlTexture2D(GLuint tex);
  void applyGlBlend(bool blend);
  void applyGlLighting(bool lighting);
  void applyGlSmooth(bool smooth);
  void applyGlTwoSided(bool twoSided);

  void applyMaterial(GEE_Material *);

  void setShowroupSructure(bool show) { m_showGroups = show; }

  long renderCount() const { return m_renderCount; }
  long renderDisplayListCount() const { return m_renderDisplayListCount; }
  long generateDisplayListCount() const { return m_generateDisplayListCount; }

  void setVeeRenderer(VEE_GlRenderer *r) { m_veeRenderer = r; }

  long vertexCount()   const { return m_vertexCount; }
  long triangleCount() const { return m_triangleCount; }
  long polygonCount()  const { return m_polygonCount; }
  long particleCount() const { return m_particleCount; }
  long geometryCount() const { return m_geometryCount; }

  void resetCounters();

  static void setDebug(bool d) { m_debug = d; }

protected:

  enum ListMode {
    RENDERED_LIST,
    GENERATE_LIST,
    NO_LIST
  };

  enum SelectionRender {
    RENDER_USUAL,
    RENDER_FACES_NS_HIGH1,
    RENDER_FACES_IS_HIGH1,

    RENDER_EDGES_NS_HIGH1,
    RENDER_EDGES_IS_HIGH1,
    RENDER_EDGES_NS_HIGH2,
    RENDER_EDGES_IS_HIGH2,

    RENDER_POINTS_NS_HIGH2,
    RENDER_POINTS_IS_HIGH2
  };

  void renderLines3DInternal(GEE_Lines3D *);
  void renderTriangleMeshInternal(GEE_TriangleMesh *);

  virtual void preRender(GEE_Geometry *);
  ListMode renderDisplayList(GEE_Geometry *);

  void enterVee();
  void exitVee();

  GEE_GlDisplayLists   *m_displayLists;
  GEE_GlDisplayLists   *m_highlightDisplayLists;
  GEE_GlMaterialBank   *m_materials;
  const GEE_Material   *m_currentMaterial;
  std::vector<GEE_GlLights> m_lights;
  GEE_GlLights             *m_currentLight;

  VEE_GlRenderer       *m_veeRenderer;
  VEE_GlTexture2DBank  *m_textures;

  GLuint          m_currentTexture;
  bool            m_blend;
  bool            m_lighting;
  bool            m_smooth;
  bool            m_twoSided;
  bool            m_inVee;
  bool            m_ignoreTransforms;

  bool            m_showGroups;

  long            m_renderCount;
  long            m_renderDisplayListCount;
  long            m_generateDisplayListCount;

  long            m_vertexCount;
  long            m_triangleCount;
  long            m_polygonCount;
  long            m_particleCount;
  long            m_geometryCount;

  // uint               m_selectionState;
  SelectionRender m_selectionRender;

  /* enum {  STACK_MAXIMUM = 32 };
  VEE_Matrix4     m_stack[STACK_MAXIMUM];
  int             m_stackIndex;*/
  VEE_Matrix4     m_worldMatrix;

  GLUquadric    * m_quadric;

  static bool m_debug;
};

#endif

---