vee_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 _VEE_GL_RENDERER_H_
#define _VEE_GL_RENDERER_H_

#include <GL/gl.h>

#ifdef __OS_LINUX__

// NVidia fixes...
#define GL_GLEXT_PROTOTYPES 1

#ifndef GLAPI
#define GLAPI 
#endif

#ifdef APIENTRY
#undef APIENTRY
#endif

#include <GL/glext.h>

#endif

#include <vee_color.h>
#include <vee_gl_material.h>
#include <vee_gl_texture.h>
#include <vee_render_class.h>
#include <vee_renderer.h>
#include <vee_scene.h>
#include <vee_object.h>

#include <Solar/GraphicTriangleMesh.hpp>


#include <GL/glu.h>

class VEE_Collector;
class VEE_CurveParticle;
class VEE_GlTexture2D;
class VEE_GlTexture2DBank;
class VEE_OrdererCollector;
class VEE_TailParticle;
class VEE_RigidParticle;
class VEE_TCBSpline3;
class VEE_VolumeGrid;
class VEE_VolumeGrid2;

class VEE_CameraPosition
{
public:
  VEE_CameraPosition() : m_azi(0.0), m_ele(0.0) 
  { m_camPos.clear(); }
  VEE_CameraPosition(const VEE_Vector3 &pos, float azi, float ele)
    : m_camPos(pos), m_azi(azi), m_ele(ele) {  }

  void describe(char * buf);

  VEE_Vector3 m_camPos;
  float       m_azi, m_ele;

};

class VEE_GlRenderer : public VEE_Renderer
{
public:
  enum Mode {
    RenderNothing ,
    RenderTriangles,
    RenderQuads,
    RenderPoints,
    RenderLines
  };

  enum Order {
    OrderRandom1,
    OrderRandom2,
    OrderBackToFront1,
    OrderBackToFront2,
    OrderSizeof
  };

  enum Material {
    POLYGON,
    CHECK,
    SWIRL,
    BLOW,
    MATERIALS
  };

  VEE_GlRenderer(VEE_SceneBox *box = 0);
  virtual ~VEE_GlRenderer();
  
  virtual void initRenderState();
  virtual void closeRenderState();

  virtual void renderParticle(VEE_Particle *);
  virtual void renderPolygon(VEE_Polygon *);
  virtual void renderForceObject(VEE_ForceObject *);

  virtual bool setValue(const char *, VEE_Value *);

  void setSceneBox(VEE_SceneBox *box) {m_vps = box;}
  VEE_SceneBox *sceneBox() { return m_vps; }
  
  virtual void initializeGL();
  virtual void resizeGL(int w, int h );
  virtual void prepareGlMode();
  virtual void endGlMode();
  
  virtual void paintGL(bool drawBoxEdges, bool moveCamera, bool clear, 
           float dt = 0.04);

  void drawRecursed(VEE_SceneBox *vps);
  void drawBackToFront(VEE_SceneBox *vps);
  void drawBackToFront2(VEE_OrdererCollector *);
  void drawRandom(VEE_Collector *);

  void clearGlScreen();
  void moveGlCamera();

  void setParticleSize(float size) { m_particleSize = size; }
  float particleSize() const { return m_particleSize; }
  
  float alphaMul() const { return m_alphaMul; }
  void  setAlphaMul(float a) { m_alphaMul = a; }

  VEE_RenderClass & defaultRenderClass() { return m_defaultRenderClass; }

  float lengthScale() const { return m_defaultRenderClass.lengthScale(); }
  void  setLengthScale(float scale) 
  { m_defaultRenderClass.setLengthScale(scale); }

  float maxLengthScale() const { return m_defaultRenderClass.maxLengthScale();}

  void setParticleMode(Mode m) { m_particleMode = m; }
  Mode setParticleMode() const { return m_particleMode; }

  void setPolygonMode(Mode m) { m_polygonMode = m; }
  Mode getPolygonMode() const { return m_polygonMode; }

  void setForceMode(Mode m) { m_forceMode = m; }
  Mode getForceMode() const { return m_forceMode; }

  VEE_Vector3 & camPos() { return m_camPos; }
  void setCameraPosition(const VEE_Vector3 &pos) { m_camPos = pos;}
  void setCameraPosition3f(float x, float y, float z) { m_camPos.make(x,y,z);}
  void addCamAzi(float azi) { m_azi += azi; }
  void addCamEle(float ele) { m_ele += ele; }
  void setCameraAngles(float azi, float ele) { m_azi = azi; m_ele = ele; }
  void moveCameraUp(float z) { m_camPos[1] += z; }
  
  VEE_Vector3 & camDir() { return m_direction; }

  void setCameraParams(const VEE_CameraPosition &p)
  { m_camPos = p.m_camPos; m_azi = p.m_azi; m_ele = p.m_ele; }
  VEE_CameraPosition cameraParams() const
  { return VEE_CameraPosition(m_camPos, m_azi, m_ele); }
  void forward(float distance)
  { m_camPos += (m_direction * distance); }

  void forwardAcceleration(float acceleration)
  { m_velocity[2] += acceleration; }

  void sidewaysAcceleration(float acceleration)
  { m_velocity[0] += acceleration; }

  void moveCamera(float dt);

  void stopMotion() { m_velocity.clear(); }

  void setBlend(bool b) { m_blend = b; }
  bool getBlend() const { return m_blend; }

  void setBlendType(VEE_Blending b) { m_blendType = b; }

  void setUseTextures(bool u) { m_useTextures = u; }
  bool getUseTextures() const { return m_useTextures; }

  bool getDrawForceBoxes () { return m_drawForceBoxes; }
  void setDrawForceBoxes(bool b) { m_drawForceBoxes = b; }

  bool drawBoxEdges() const { return m_drawBoxEdges; }
  void setDrawBoxEdges(bool b) { m_drawBoxEdges = b; }

  void setBackgroundColor(const VEE_Rgba &color) { m_bgColor = color; }
  const VEE_Rgba &backgroundColor() const { return m_bgColor; }
  void setRange(float minDist, float fadeDist, float maxDist);

  static void createPrivateTextures(bool create) 
  { m_privateTextures = create; }

  void setTexture(GLuint texId) { m_texId = texId; }
  GLuint getTexture() const { return m_texId; }

  ulong  modeChanges() const { return m_modeChanges; }

  void setFade(float fade) { m_fade = fade; }

  int subTextureCount() const { return m_textureDivision * m_textureDivision; }
  int subTextureDivision() const { return m_textureDivision; }
  int currentSubTexture() const
  { return m_textureDivision * m_textureRow + m_textureCol; }
  void setSubTexture(int tex)
  { 
    m_textureRow = tex / m_textureDivision; 
    m_textureCol = tex % m_textureDivision;
  }

  // bool  stretchParticles() const { return m_stretchParticles; }
  // void setStretchParticles(bool s) { m_stretchParticles = s; }

  /* bool  alignParticles() const 
     { return m_alignParticlesWithVelocity; }
     void setAlignParticles(bool s) 
     { m_alignParticlesWithVelocity = s; } */

  void buildTextures(VEE_GlTexture2D *tex, float radius,
         const char * configFile = 0);
  void buildPolygonTextures(VEE_GlTexture2D *tex);

  bool continuousTails() const { return m_continuousTails; }
  void setContinuousTails(bool b) { m_continuousTails = b; }

  float tailDispersion() const { return m_tailDispersion; }
  float fov() const { return m_fov; }
  
  void setExternalTextures(VEE_GlTexture2D *blob,
         VEE_GlTexture2D *polygon)
  { m_blobTexture = blob; m_polygonTexture = polygon; }

  void setTexId();

  void drawVolumeGrid(const VEE_Vector3 &, VEE_VolumeGrid *);
  void drawVolumeGrid2(const VEE_Vector3 &, VEE_VolumeGrid2 *, 
           bool blend = true);

  inline VEE_Rgba transformColor(const VEE_Rgba &) const;

  void nextAlignMent() { m_defaultRenderClass.nextAlignMent(); }
  VEE_MotionAlign align() const { return m_defaultRenderClass.align(); }

  virtual void renderParticleVisual(VEE_ParticleVisualInfo *p);
  void renderTailParticle(VEE_TailParticle *p);
  void renderCurveParticle(VEE_CurveParticle *p);
  void renderRigidParticle(VEE_RigidParticle *p);

  static void drawBox(VEE_Vector3 low, VEE_Vector3 high);

  float farDistance()  const { return m_farDistance; }
  float fadeDistance() const { return m_fadeDistance; }
  float nearDistance() const { return m_nearDistance; }
  float fadeRange()    const { return m_fadeRange; }
  
  int textureNameToId(const char *name);
  int shaderNameToId(const char *name);
  
  VEE_GlMaterialBank & materials() { return m_materials; }

  void setForceFrontColor(const VEE_Rgba *c) { m_forceFrontColor = c; }
  void setForceBackColor(const VEE_Rgba *c) { m_forceBackColor = c; }

  const VEE_Rgba * forceFrontColor() const { return m_forceFrontColor; }
  const VEE_Rgba * forceBackColor()  const { return m_forceBackColor; }

  void setMatrix(const VEE_Matrix4 & m) { m_matrix = m; }
  void setUseMatrix(bool use) { m_useMatrix = use; }

  const std::string & configFile() const { return m_configFile; }

  void setRenderOnlyOutline(bool outlines);

  int width()  const { return m_width; }
  int height() const { return m_height; }

  bool applyDepthMap() const { return m_applyDepthMap; }
  void createDepthMap();

  VEE_GlTexture2D & depthMap() { return m_depthMap; }

protected:

  VEE_Vector3 m_camPos;
  VEE_Vector3 m_direction;
  VEE_Vector3 m_velocity;
  VEE_Vector3 m_camUp;

  const VEE_Rgba * m_forceFrontColor;
  const VEE_Rgba * m_forceBackColor;

  // Vectors that define current View-Plane directions.
  VEE_Vector3 m_vpUp, m_vpRight;

  float m_azi, m_ele;

  VEE_SceneBox *m_vps;

  float m_farDistance;
  float m_fadeDistance;
  float m_nearDistance;
  float m_fadeRange;

  bool  m_renderOnlyOutline;

  void newMode(Mode);
  void beginTextured(Mode, GLuint);
  void endTextured();

  void pushTransform(const VEE_Matrix3 &rot,  
         const VEE_Vector3 &loc);
  
  void popTransform() { glPopMatrix(); }

  GLUquadric* m_cylinder;

  GLuint m_texId;
  
  bool m_blend;
  bool m_useTextures;

  bool m_drawBoxEdges;
  
  Mode m_mode, m_particleMode, m_forceMode, m_polygonMode;
  bool m_drawForceBoxes;
  GLuint m_currentTexture;
  int    m_currentMaterial;

  float m_pointSize;

  float m_particleSize;

  VEE_RenderClass m_defaultRenderClass;

  // float m_lengthScale;
  // float m_maxLengthScale;

  float m_alphaMul;
  float m_fade;
  float m_fixedFade;

  float m_fov;

  // bool  m_stretchParticles;
  // bool  m_alignParticlesWithVelocity;
  bool  m_continuousTails;
  float m_tailDispersion;

  VEE_TCBSpline3 * m_tcbSpline;

  Order m_renderOrder;

  int   m_width, m_height;

  ulong  m_modeChanges;

  VEE_GlMaterialBank m_materials;

  uint  m_textureDivision;
  uint  m_textureRow;
  uint  m_textureCol;
  float m_textureStep;

  VEE_Rgba m_bgColor;

  VEE_Blending m_blendType;

  VEE_GlTexture2D * m_blobTexture;
  VEE_GlTexture2D * m_polygonTexture;

  VEE_GlTexture2D   m_depthMap;
  bool              m_useDepthMap;
  bool              m_applyDepthMap;

  std::string  m_configFile;

  static bool  m_privateTextures;

  typedef std::map<int, Solar::GraphicTriangleMesh> meshStore;
  meshStore m_meshes;

  VEE_Matrix4 m_matrix;
  bool        m_useMatrix;

  // Map texture names ("flame" etc.) to a texture index.
  std::map<std::string, int> m_textureNames;

  std::map<std::string, int> m_shaderNames;

private:
  VEE_GlRenderer(const VEE_GlRenderer &) {}
  VEE_GlRenderer & operator = (const VEE_GlRenderer &) { return * this; }
};

inline VEE_Rgba VEE_GlRenderer::transformColor(const VEE_Rgba &rgb) const
{
  float a = rgb.alpha() * m_alphaMul;

  if(m_blendType == VEE_BLEND_NEW) {
    float cover = a * (1.0f - rgb.theta());
    float gain  = a;

    VEE_Rgba tmp(rgb.red() * gain, rgb.green() * gain, rgb.blue() * gain, 
     cover);
    tmp.normalize();

    return tmp;
  }

  return VEE_Rgba(rgb.red(), rgb.green(), rgb.blue(), a);
}

#endif // _VEE_GL_H_

---