vtkTextureObject.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkTextureObject.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkTextureObject_h
#define vtkTextureObject_h
 
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkObject.h"
#include "vtkWeakPointer.h" // for render context
 
class vtkOpenGLBufferObject;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkOpenGLVertexArrayObject;
class vtkShaderProgram;
class vtkWindow;
 
#if GL_ES_VERSION_2_0 != 1 || GL_ES_VERSION_3_0 == 1
class vtkPixelBufferObject;
#endif
 
class VTKRENDERINGOPENGL2_EXPORT vtkTextureObject : public vtkObject
{
public:
 
  // DepthTextureCompareFunction values.
  enum
  {
    Lequal=0, // r=R<=Dt ? 1.0 : 0.0
    Gequal, // r=R>=Dt ? 1.0 : 0.0
    Less, // r=R<D_t ? 1.0 : 0.0
    Greater, // r=R>Dt ? 1.0 : 0.0
    Equal, // r=R==Dt ? 1.0 : 0.0
    NotEqual, // r=R!=Dt ? 1.0 : 0.0
    AlwaysTrue, //  r=1.0 // WARNING "Always" is macro defined in X11/X.h...
    Never, // r=0.0
    NumberOfDepthTextureCompareFunctions
  };
 
// ClampToBorder is not supported in ES 2.0
// Wrap values.
#if GL_ES_VERSION_2_0 != 1
  enum
  {
    ClampToEdge=0,
    Repeat,
    MirroredRepeat,
    ClampToBorder,
    NumberOfWrapModes
  };
#else
  enum
  {
    ClampToEdge=0,
    Repeat,
    MirroredRepeat,
    NumberOfWrapModes
  };
#endif
 
  // MinificationFilter values.
  enum
  {
    Nearest=0,
    Linear,
    NearestMipmapNearest,
    NearestMipmapLinear,
    LinearMipmapNearest,
    LinearMipmapLinear,
    NumberOfMinificationModes
  };
 
  // Internal depth format
  enum
  {
    Native=0, // will try to match with the depth buffer format.
    Fixed16,
    Fixed24,
    Fixed32,
    Float32,
    NumberOfDepthFormats
  };
 
  // Internal alpha format
  enum
  {
    alpha=0,
    alpha8,
    alpha16,
    alpha16f,
    alpha32f,
    NumberOfAlphaFormats
  };
 
  // Depth mode formats
  enum
  {
    DepthAlpha=0,
    DepthLuminance,
    DepthIntensity,
    NumberOfDepthModeFormats
  };
 
  static vtkTextureObject* New();
  vtkTypeMacro(vtkTextureObject, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  void SetContext(vtkOpenGLRenderWindow*);
  vtkOpenGLRenderWindow* GetContext();
 
 
  vtkGetMacro(Width, unsigned int);
  vtkGetMacro(Height, unsigned int);
  vtkGetMacro(Depth, unsigned int);
  vtkGetMacro(Components, int);
  unsigned int GetTuples()
  { return this->Width*this->Height*this->Depth; }
 
  vtkGetMacro(NumberOfDimensions, int);
 
 
  vtkGetMacro(Target, unsigned int);
 
 
  vtkGetMacro(Handle, unsigned int);
 
  int GetTextureUnit();
 
 
  void Bind();
  void UnBind();
 
  void Activate();
 
  void Deactivate();
 
  void ReleaseGraphicsResources(vtkWindow *win);
 
  bool IsBound();
 
 
  void SendParameters();
  vtkSetMacro(AutoParameters, int);
  vtkGetMacro(AutoParameters, int);
 
 
  bool Create2DFromRaw(unsigned int width, unsigned int height,
                       int numComps,  int dataType, void *data);
 
 
  bool CreateDepthFromRaw(unsigned int width, unsigned int height,
                          int internalFormat, int rawType,
                          void *raw);
 
 
  bool CreateTextureBuffer(unsigned int numValues, int numComps,
                           int dataType, vtkOpenGLBufferObject *bo);
 
// 1D  textures are not supported in ES 2.0 or 3.0
#if GL_ES_VERSION_2_0 != 1
 
 
  bool Create1D(int numComps,
                vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);
 
 
  bool Create1DFromRaw(unsigned int width, int numComps,
                       int dataType, void *data);
 
 
  bool CreateAlphaFromRaw(unsigned int width,
                          int internalFormat,
                          int rawType,
                          void *raw);
#endif
 
 
// PBO's, and 3D textures are not supported in ES 2.0
#if GL_ES_VERSION_2_0 != 1 || GL_ES_VERSION_3_0 == 1
 
 
  bool Create2D(unsigned int width, unsigned int height, int numComps,
                vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);
 
 
  bool Create3D(unsigned int width, unsigned int height, unsigned int depth,
                int numComps, vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);
 
 
  bool Create3DFromRaw(unsigned int width, unsigned int height,
                       unsigned int depth, int numComps,
                       int dataType, void *data);
 
  vtkPixelBufferObject* Download();
 
 
  bool CreateDepth(unsigned int width,
                   unsigned int height,
                   int internalFormat,
                   vtkPixelBufferObject *pbo);
 
#endif
 
 
  bool AllocateDepth(unsigned int width,unsigned int height,
                     int internalFormat);
 
  bool Allocate1D(unsigned int width, int numComps,int vtkType);
 
 
  bool Allocate2D(unsigned int width,unsigned int height, int numComps,
                  int vtkType);
 
 
  bool Allocate3D(unsigned int width,unsigned int height,
                  unsigned int depth, int numComps,
                  int vtkType);
 
 
 
  bool Create2D(unsigned int width, unsigned int height, int numComps,
                int vtktype, bool shaderSupportsTextureInt);
  bool Create3D(unsigned int width, unsigned int height, unsigned int depth,
                int numComps, int vtktype, bool shaderSupportsTextureInt);
 
  int GetVTKDataType();
 
 
  int GetDataType(int vtk_scalar_type);
  void SetDataType(unsigned int glType);
 
 
  unsigned int GetInternalFormat(int vtktype, int numComps,
                                 bool shaderSupportsTextureInt);
  void SetInternalFormat(unsigned int glInternalFormat);
 
 
  unsigned int GetFormat(int vtktype, int numComps,
                         bool shaderSupportsTextureInt);
  void SetFormat(unsigned int glFormat);
 
  void ResetFormatAndType();
 
  unsigned int GetDepthTextureModeFormat(int vtktype);
  unsigned int GetMinificationFilterMode(int vtktype);
  unsigned int GetMagnificationFilterMode(int vtktype);
  unsigned int GetWrapSMode(int vtktype);
  unsigned int GetWrapTMode(int vtktype);
  unsigned int GetWrapRMode(int vtktype);
 
 
  vtkSetMacro(RequireDepthBufferFloat, bool);
  vtkGetMacro(RequireDepthBufferFloat, bool);
  vtkGetMacro(SupportsDepthBufferFloat, bool);
 
 
  vtkSetMacro(RequireTextureFloat,bool);
  vtkGetMacro(RequireTextureFloat,bool);
  vtkGetMacro(SupportsTextureFloat,bool);
 
 
  vtkSetMacro(RequireTextureInteger,bool);
  vtkGetMacro(RequireTextureInteger,bool);
  vtkGetMacro(SupportsTextureInteger,bool);
 
 
  vtkGetMacro(WrapS,int);
  vtkSetMacro(WrapS,int);
 
 
  vtkGetMacro(WrapT,int);
  vtkSetMacro(WrapT,int);
 
 
  vtkGetMacro(WrapR,int);
  vtkSetMacro(WrapR,int);
 
 
  vtkGetMacro(MinificationFilter,int);
  vtkSetMacro(MinificationFilter,int);
 
 
  vtkGetMacro(MagnificationFilter,int);
  vtkSetMacro(MagnificationFilter,int);
 
 
  void SetLinearMagnification(bool val)
  { this->SetMagnificationFilter(val?Linear:Nearest); }
 
  bool GetLinearMagnification()
  { return this->MagnificationFilter==Linear; }
 
 
  vtkSetVector4Macro(BorderColor,float);
  vtkGetVector4Macro(BorderColor,float);
 
 
  vtkSetMacro(MinLOD,float);
  vtkGetMacro(MinLOD,float);
 
 
  vtkSetMacro(MaxLOD,float);
  vtkGetMacro(MaxLOD,float);
 
 
  vtkSetMacro(BaseLevel,int);
  vtkGetMacro(BaseLevel,int);
 
 
  vtkSetMacro(MaxLevel,int);
  vtkGetMacro(MaxLevel,int);
 
 
  vtkGetMacro(DepthTextureCompare,bool);
  vtkSetMacro(DepthTextureCompare,bool);
 
 
  vtkGetMacro(DepthTextureCompareFunction,int);
  vtkSetMacro(DepthTextureCompareFunction,int);
 
 
  vtkGetMacro(GenerateMipmap,bool);
  vtkSetMacro(GenerateMipmap,bool);
 
 
  static bool IsSupported(
        vtkOpenGLRenderWindow* renWin,
        bool requireTexFloat,
        bool requireDepthFloat,
        bool requireTexInt);
 
 
  static bool IsSupported(vtkOpenGLRenderWindow* renWin)
    { return vtkTextureObject::IsSupported(renWin, false, false, false); }
 
 
  void CopyToFrameBuffer(vtkShaderProgram *program,
                         vtkOpenGLVertexArrayObject *vao);
  // part of a texture to part of a viewport, scaling as needed
  void CopyToFrameBuffer(int srcXmin, int srcYmin,
                         int srcXmax, int srcYmax,
                         int dstXmin, int dstYmin,
                         int dstXmax, int dstYmax,
                         int dstSizeX, int dstSizeY,
                         vtkShaderProgram *program,
                         vtkOpenGLVertexArrayObject *vao
                         );
  // copy part of a texure to part of a viewport, no scalaing
  void CopyToFrameBuffer(int srcXmin, int srcYmin,
                         int srcXmax, int srcYmax,
                         int dstXmin, int dstYmin,
                         int dstSizeX, int dstSizeY,
                         vtkShaderProgram *program,
                         vtkOpenGLVertexArrayObject *vao
                         );
  // copy a texture to a quad using the provided tcoords and verts
  void CopyToFrameBuffer(float *tcoords, float *verts,
                         vtkShaderProgram *program,
                         vtkOpenGLVertexArrayObject *vao
                         );
 
 
 
  void CopyFromFrameBuffer(int srcXmin,
                           int srcYmin,
                           int dstXmin,
                           int dstYmin,
                           int width,
                           int height);
 
 
 
protected:
  vtkTextureObject();
  ~vtkTextureObject();
 
  bool LoadRequiredExtensions(vtkOpenGLRenderWindow *renWin);
 
  void CreateTexture();
 
  void DestroyTexture();
 
  int NumberOfDimensions;
  unsigned int Width;
  unsigned int Height;
  unsigned int Depth;
 
  unsigned int Target; // GLenum
  unsigned int Format; // GLenum
  unsigned int InternalFormat; // GLenum
  unsigned int Type; // GLenum
  int Components;
 
  vtkWeakPointer<vtkOpenGLRenderWindow> Context;
  unsigned int Handle;
  bool RequireTextureInteger;
  bool SupportsTextureInteger;
  bool RequireTextureFloat;
  bool SupportsTextureFloat;
  bool RequireDepthBufferFloat;
  bool SupportsDepthBufferFloat;
 
  int WrapS;
  int WrapT;
  int WrapR;
  int MinificationFilter;
  int MagnificationFilter;
  bool LinearMagnification;
 
  float MinLOD;
  float MaxLOD;
  int BaseLevel;
  int MaxLevel;
  float BorderColor[4];
 
  bool DepthTextureCompare;
  int DepthTextureCompareFunction;
 
  bool GenerateMipmap;
 
  int AutoParameters;
  vtkTimeStamp SendParametersTime;
 
  // used for copying to framebuffer
  vtkOpenGLHelper *ShaderProgram;
 
  // for texturebuffers we hold on to the Buffer
  vtkOpenGLBufferObject *BufferObject;
 
private:
  vtkTextureObject(const vtkTextureObject&); // Not implemented.
  void operator=(const vtkTextureObject&); // Not implemented.
};
 
#endif