Primitive.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLGeom/src/ICLGeom/Primitive.h                        **
** Module : ICLGeom                                                **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#ifndef HAVE_OPENGL
#warning "this header must not be included if HAVE_OPENGL is not defined"
#else

#include <ICLGeom/GeomDefs.h>
#include <ICLCore/Img.h>
#include <ICLMath/FixedVector.h>
#include <ICLUtils/Array2D.h>
#include <ICLQt/GLImg.h>

namespace icl{
  namespace geom{
    class SceneObject;


    struct Primitive{
  
      enum Type{
        vertex   = 1<<0, //<! vertex
        line     = 1<<1, //<! line primitive (adressing two vertices -> start and end position of the line)
        triangle = 1<<2, //<! triange primitive (adressing three vertices)
        quad     = 1<<3, //<! quad primitve (adressing four vertices)
        polygon  = 1<<4, //<! polygon primitive (adressing at least 3 vertices)
        texture  = 1<<5, //<! texture primitive (using 4 vertices like a quad as textured rectangle)
        text     = 1<<6, //<! text primitive (internally implmented as texture or as billboard)
        nothing  = 1<<7, //<! internally used type
        custom   = 1<<20, //<! for custom primitives
        PRIMITIVE_TYPE_COUNT = 8,                //<! also for internal use only
        all      = (1<<PRIMITIVE_TYPE_COUNT)-1,    //<! all types
        faces    = triangle | quad | polygon | texture | text
      };
    
      Type type;        
      GeomColor color;  
      

      struct RenderContext{
        const std::vector<Vec> &vertices;            
        const std::vector<Vec> &normals;             
        const std::vector<GeomColor> &vertexColors;  
        const std::vector<utils::SmartPtr<qt::GLImg> > &sharedTextures; 
        bool lineColorsFromVertices;                 
        bool triangleColorsFromVertices;             
        bool quadColorsFromVertices;                 
        bool polygonColorsFromVertices;              
        SceneObject *object;                         
      };
  
      Primitive(Type type=nothing, const GeomColor &color=GeomColor(255,255,255,255)):type(type),color(color){}
  
      virtual ~Primitive() {}
  
      virtual void render(const Primitive::RenderContext &ctx) = 0;
      
      virtual Primitive *copy() const = 0;
    };
    
    struct LinePrimitive : public math::FixedColVector<int,2>, public Primitive{
      typedef math::FixedColVector<int,2> super; 
      
      LinePrimitive(int a, int b, const GeomColor &color):
      math::FixedColVector<int,2>(a,b),Primitive(Primitive::line,color){}
        
      virtual void render(const Primitive::RenderContext &ctx);
  
      inline int i(int idx) const { return super::operator[](idx); }
      
      virtual Primitive *copy() const { return new LinePrimitive(*this); }
    };
  
    struct TrianglePrimitive : public math::FixedColVector<int,6>, public Primitive{
      typedef  math::FixedColVector<int,6> super; 
      
      TrianglePrimitive(int a, int b, int c, const GeomColor &color, int na=-1, int nb=-1, int nc=-1):
      super(a,b,c,na,nb,nc),Primitive(Primitive::triangle,color){}
      
      virtual void render(const Primitive::RenderContext &ctx);
      
      inline int i(int idx) const { return super::operator[](idx); }
      
      virtual Primitive *copy() const { return new TrianglePrimitive(*this); }


      Vec computeNormal(const std::vector<Vec> &vertices) const;

    };
  
    struct QuadPrimitive : public math::FixedColVector<int,8>, public Primitive{
      typedef math::FixedColVector<int,8> super; 
      
      bool trySurfaceOptimization;
      

      int tesselationResolution;
  
      QuadPrimitive(int a, int b, int c, int d, const GeomColor &color, int na=-1, int nb=-1, int nc=-1, int nd=-1, 
                    bool trySurfaceOptimization=false,int tesselationResolution=1):
      super(a,b,c,d,na,nb,nc,nd),Primitive(Primitive::quad,color),trySurfaceOptimization(trySurfaceOptimization),
      tesselationResolution(tesselationResolution){}
      
      virtual void render(const Primitive::RenderContext &ctx);
  
      inline int i(int idx) const { return super::operator[](idx); }
  
      virtual Primitive *copy() const { return new QuadPrimitive(*this); }
      

      Vec computeNormal(const std::vector<Vec> &vertices) const;
    };
  

    struct PolygonPrimitive : public Primitive{
      

      utils::Array2D<int> idx;
      
      PolygonPrimitive(int n,const int *vidx, const GeomColor &color,const int *nidx=0):
      Primitive(Primitive::polygon,color),idx(n,nidx?2:1){
        std::copy(vidx,vidx+n,idx.begin());
        if(nidx) std::copy(nidx,nidx+n,idx.begin()+n);
      }
      
      virtual void render(const Primitive::RenderContext &ctx);
      
      virtual Primitive *copy() const { 
        PolygonPrimitive *p = new PolygonPrimitive(*this);
        p->idx.detach();
        return p;
      }
      
      inline int getNumPoints() const { return idx.getWidth(); }
      
      inline int getVertexIndex(int i) const { return idx(i,0); }
  

      inline int getNormalIndex(int i) const { return idx(i,1); }
      
      inline bool hasNormals() const { return idx.getHeight() == 2; }
    };
  
    struct AlphaFuncProperty{
      AlphaFuncProperty();
      AlphaFuncProperty(int alphaFunc, float alphaValue):alphaFunc(alphaFunc),alphaValue(alphaValue){}
    
      int alphaFunc;         
      float alphaValue;      
      
      void setAlphaFunc(int func, float value){
        alphaFunc = func;
        alphaValue = value;
      }
      
      void restoreAlphaDefaults();
    };
  
    

    struct TexturePrimitive : public QuadPrimitive, public AlphaFuncProperty{
      qt::GLImg texture;         
      const core::ImgBase *image;  
  
      TexturePrimitive(int a, int b, int c, int d, 
                       const core::ImgBase *image=0, bool createTextureOnce=true, 
                       int na=-1, int nb=-1, int nc=-1, int nd=-1, core::scalemode sm=core::interpolateLIN):
      QuadPrimitive(a,b,c,d,na,nb,nc,nd), texture(image,sm),
        image(createTextureOnce ? 0 : image){
        type = Primitive::texture;
      }
  
      TexturePrimitive(int a, int b, int c, int d, 
                       const core::Img8u &image,
                       int na=-1, int nb=-1, int nc=-1, int nd=-1, core::scalemode sm=core::interpolateLIN):
      QuadPrimitive(a,b,c,d,na,nb,nc,nd), texture(&image,sm), 
        image(0){
        type = Primitive::texture;
      }
  
      virtual void render(const Primitive::RenderContext &ctx);
  
      virtual Primitive *copy() const { 
        return new TexturePrimitive(i(0),i(1),i(2),i(3),
                                    image ? image : texture.extractImage(),
                                    !image,
                                    i(4),i(5),i(6),i(7),
                                    texture.getScaleMode());
      }
      
  
    };
  

    class TextureGridPrimitive : public Primitive, public AlphaFuncProperty{
      protected:
      friend class SceneObject;
      int w,h;
      qt::GLImg texture;
      const icl32f *px, *py, *pz, *pnx,  *pny, *pnz;
      int stride;
      const core::ImgBase *image;
      
      public:
      TextureGridPrimitive(int w, int h, const core::ImgBase *image,
                           const icl32f *px, const icl32f *py, const icl32f *pz,
                           const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0,
                           int stride = 1,bool createTextureOnce=true,core::scalemode sm=core::interpolateLIN):
      Primitive(Primitive::texture),w(w),h(h),texture(image,sm),px(px),py(py),pz(pz),
      pnx(pnx),pny(pny),pnz(pnz),stride(stride),image(createTextureOnce ? 0 : image){}
  
      virtual void render(const Primitive::RenderContext &ctx);
      
      virtual Primitive *copy() const { 
        return new TextureGridPrimitive(w,h,image ? image : texture.extractImage(),
                                        px,py,pz,pnx,pny,pnz,stride,!image,
                                        texture.getScaleMode()); 
      }
      void getAABB(utils::Range32f aabb[3]);
      
      inline Vec getPos(int x, int y) const {
        const int idx = stride*(x + w*y);
        return Vec(px[idx],py[idx],pz[idx],1);
      }
    };
  
    class TwoSidedTextureGridPrimitive : public TextureGridPrimitive{
      qt::GLImg back;
      const core::ImgBase *iback;
      public:
      TwoSidedTextureGridPrimitive(int w, int h, const core::ImgBase *front, const core::ImgBase *back,
                                   const icl32f *px, const icl32f *py, const icl32f *pz,
                                   const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0,
                                   int stride = 1,bool createFrontOnce=true,
                                   bool createBackOnce=true, core::scalemode sm=core::interpolateLIN):
      TextureGridPrimitive(w,h,front,px,py,pz,pnx,pny,pnz,stride,createFrontOnce,sm),back(back,sm),
      iback(createBackOnce ? 0 : back){}
      
      virtual void render(const Primitive::RenderContext &ctx);
    };
    

    struct SharedTexturePrimitive : public QuadPrimitive, public AlphaFuncProperty{
      int sharedTextureIndex;
      
      SharedTexturePrimitive(int a, int b, int c, int d, 
                       int sharedTextureIndex,
                       int na=-1, int nb=-1, int nc=-1, int nd=-1):
      QuadPrimitive(a,b,c,d,na,nb,nc,nd), sharedTextureIndex(sharedTextureIndex){
        type = Primitive::texture;
      }
  
      virtual void render(const Primitive::RenderContext &ctx);
  
      virtual Primitive *copy() const { 
        return new SharedTexturePrimitive(*this);
      }
    };
  
    struct GenericTexturePrimitive : public Primitive, public AlphaFuncProperty{
      utils::SmartPtr<qt::GLImg> texture;
      const core::ImgBase *image;
  
      std::vector<Vec> ps;
      std::vector<utils::Point32f> texCoords;
      std::vector<Vec> normals;
      
      std::vector<int> vertexIndices;
      std::vector<int> normalIndices;
  
      GenericTexturePrimitive(const core::ImgBase *image, int numPoints,
                              const float *xs, const float *ys, const float *zs, int xyzStride,
                              const utils::Point32f *texCoords, const float *nxs=0, const float *nys=0,
                              const float *nzs=0, int nxyzStride=1, bool createTextureOnce=true);
      
      GenericTexturePrimitive(const core::ImgBase *image, int numPoints, const int *vertexIndices,
                              const utils::Point32f *texCoords, const int *normalIndices = 0,
                              bool createTextureOnce=true);
      
      virtual void render(const Primitive::RenderContext &ctx);    
  
      virtual Primitive *copy() const {
        GenericTexturePrimitive *cpy = new GenericTexturePrimitive(*this);
        cpy->texture = new qt::GLImg(image ? image : texture->extractImage());
        return cpy;
      }
    };
    

    struct TextPrimitive : public TexturePrimitive{
      int textSize;
  
      GeomColor textColor;
      
      static core::Img8u create_texture(const std::string &text, const GeomColor &color, int textSize);
      

      float billboardHeight; 
      
      TextPrimitive(int a, int b, int c, int d, 
                    const std::string &text,
                    int textSize=20,
                    const GeomColor &textColor=GeomColor(255,255,255,255),
                    int na=-1, int nb=-1, int nc=-1, int nd=-1,
                    float billboardHeight=0,
                    core::scalemode sm=core::interpolateLIN);
      ~TextPrimitive();
  
      virtual void render(const Primitive::RenderContext &ctx);
  
      virtual Primitive *copy() const {
        Primitive *p = TexturePrimitive::copy();
        p->type = text;
        return p;
      }
  
      inline void updateText(const std::string &newText){
        core::Img8u t = create_texture(newText,textColor,textSize);
        texture.update(&t);
      }
  
    };
  
    
  } // namespace geom
}

#endif