RenderObject.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
 
#pragma once
 
 
#include <ACG/GL/gl.hh>
#include <ACG/Math/GLMatrixT.hh>
#include <ACG/GL/ShaderGenerator.hh>
#include <ACG/ShaderUtils/UniformPool.hh>
 
#include <map>
 
 
namespace GLSL{
  class Program;
}
 
namespace ACG
{
 
// forward declaration
class VertexDeclaration;
class GLState;
 
namespace SceneGraph {
  namespace DrawModes {
    class DrawModeProperties;
  }
  class Material;
}
 
 
struct ACGDLLEXPORT RenderObject
{
  friend class IRenderer;
 
  RenderObject();
 
  ~RenderObject();
 
 
  int priority;
 
  std::string name;
 
  bool overlay;
 
  GLMatrixd modelview;
 
  GLMatrixd proj;
 
 
  //===========================================================================
  //===========================================================================
 
  GLuint vertexArrayObject;
 
 
  GLuint vertexBuffer,
        indexBuffer;
 
  const void* sysmemIndexBuffer;
 
  GLenum primitiveMode;
 
  unsigned int patchVertices; // GL_PATCH_VERTICES
 
  unsigned int numIndices;
 
  unsigned int indexOffset;
 
  GLenum indexType;
 
  GLsizei numInstances;
 
 
  const VertexDeclaration* vertexDecl;
 
  ShaderGenDesc shaderDesc;
 
  // opengl states
  //  queried from glState in initFromState()
  bool culling;
  bool blending;
  bool alphaTest;
  bool depthTest;
  bool depthWrite;
 
  GLenum fillMode; // GL_POINT, GL_LINE, GL_FILL,  default: GL_FILL
 
  GLboolean colorWriteMask[4]; // {r,g,b,a},  default: all true
 
//  GLenum shadeModel; // GL_FACE, GL_SMOOTH   obsolete in shader pipeline
  GLenum depthFunc;  
 
  // alpha testing function
  GLenum alphaFunc; 
  float alphaRef; // reference value for alpha function
 
  // alpha blending
  GLenum blendSrc, blendDest; 
 
  Vec2f depthRange; 
 
 
  // enable/disable clip planes
  //  bit i decides whether the vertex shader output gl_ClipDistance[i] is enabled or disabled
  //  default: all zero (disabled)
  GLuint clipDistanceMask;
 
  // GL_PROGRAM_POINT_SIZE : default false
  //  if true, use gl_PointSize from shader
  //  otherwise, use pointSize from render object
  bool programPointSize; 
  
  // glPointSize(), default: 0.1
  float pointSize;
 
  // ---------------------------
  // default tessellation lod, if only a tess-eval, but no tess-control shader is specified
  // this is ignored otherwise
 
  Vec2f patchDefaultInnerLevel; // GL_PATCH_DEFAULT_INNER_LEVEL
  Vec4f patchDefaultOuterLevel; // GL_PATCH_DEFAULT_OUTER_LEVEL
 
  // ---------------------------
  Vec3f diffuse,
        ambient,
        specular,
        emissive;
 
  float alpha,
        shininess;
 
 
  bool inZPrePass;
 
  const char* depthMapUniformName;
 
 
  struct Texture
  {
    GLuint id;
    GLenum type;
    bool shadow;
    Texture(GLuint _id = 0, GLenum _type = GL_TEXTURE_2D, bool _shadow = false):
      id(_id),
      type(_type),
      shadow(_shadow){}
  };
 
 
  void addTexture(const Texture& _t)
  {
    addTexture(_t,numTextures());
  }
 
  void addTexture(const Texture& _t,const size_t _stage, bool _addToShaderGen = true)
  {
    if (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS < numTextures())
    {
      std::cerr << "Texturestage " << _stage << " is too big. Allowed stages: "<< GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS << std::endl;
      return;
    }
    textures_[_stage] = _t;
    if (_addToShaderGen)
      shaderDesc.addTextureType(_t.type,_t.shadow,_stage);
  }
 
  void clearTextures() {textures_.clear(); shaderDesc.clearTextures();}
 
  const std::map<size_t,Texture>& textures(){return textures_;}
 
  size_t numTextures()  {return textures_.size();}
 
private:
  std::map<size_t,Texture> textures_;
public:
 
 
  int debugID;
  std::string debugName;
 
  unsigned int internalFlags_;
 
 
  // opengl style helper function interface: 
  // provided for easier setup of RenderObjects,
  //  usage is not necessary
  inline void glBindBuffer(GLenum target, GLuint buffer)
  {
    switch (target)
    {
    case GL_ARRAY_BUFFER: vertexBuffer = buffer; break;
    case GL_ELEMENT_ARRAY_BUFFER: indexBuffer = buffer; break;
    }
  }
 
  inline void glDrawArrays(GLenum mode, GLint first, GLsizei count)
  {
    this->glDrawInstancedArrays(mode, first, count, 0);
  }
 
  inline void glDrawInstancedArrays(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
  {
    indexBuffer = 0;
    sysmemIndexBuffer = 0;
 
    primitiveMode = mode;
    indexOffset = first;
    numIndices = count;
    numInstances = primcount;
  }
 
  inline void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
  {
    this->glDrawElementsInstanced(mode, count, type, indices, 0);
  }
 
  inline void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
  {
    primitiveMode = mode;
    numIndices = count;
    indexType = type;
 
    sysmemIndexBuffer = indices;
 
    numInstances = primcount;
  }
 
  inline void glColorMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a)
  {
    colorWriteMask[0] = r; colorWriteMask[1] = g; colorWriteMask[2] = b; colorWriteMask[3] = a;
  }
 
  inline void glAlphaFunc(GLenum func, float ref)
  {
    alphaFunc = func;
    alphaRef = ref;
  }
  
  void initFromState(GLState* _glState);
 
  void setMaterial(const SceneGraph::Material* _mat);
 
  void setupShaderGenFromDrawmode(const SceneGraph::DrawModes::DrawModeProperties* _props);
 
 
  void setupLineRendering(float _lineWidth, const Vec2f& _screenSize);
 
  bool isDefaultLineObject() const;
 
  void resetLineRendering();
 
  void setupPointRendering(float _pointSize, const Vec2f& _screenSize);
 
  bool isDefaultPointObject() const;
 
  void resetPointRendering();
 
 
 
  QString toString() const;
 
  void setUniform(const char *_name, GLint _value);
 
  void setUniform(const char *_name, GLfloat _value);
 
  void setUniform(const char *_name, const ACG::Vec2f &_value);
 
  void setUniform(const char *_name, const ACG::Vec3f &_value);
 
  void setUniform(const char *_name, const ACG::Vec4f &_value);
 
  void setUniform(const char *_name, const ACG::GLMatrixf &_value, bool _transposed = false);
  void setUniformMat3(const char *_name, const ACG::GLMatrixf &_value, bool _transposed = false);
 
 
  void setUniform(const char *_name, GLint *_values, int _count);
  void setUniform(const char *_name, GLfloat *_values, int _count);
 
 
  void addUniformPool(const GLSL::UniformPool& _pool);
 
private:
  GLSL::UniformPool uniformPool_;
};
 
 
class ACGDLLEXPORT RenderObjectModifier
{
public:
  RenderObjectModifier(const std::string& _name = "") : name_(_name) {}
  virtual ~RenderObjectModifier() {}
 
  virtual void apply(RenderObject* _obj) = 0;
 
  const std::string& name() const { return name_; }
 
private:
  std::string name_;
};
 
 
 
//=============================================================================
} // namespace ACG
//=============================================================================