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 "vtkRenderingOpenGLModule.h" // For export macro
#include "vtkObject.h"
#include "vtkWeakPointer.h" // for render context

class vtkFloatArray;
class vtkTextureObject;
class vtkRenderWindow;
class vtkOpenGLRenderWindow;
class vtkOpenGLExtensionManager;
class vtkPixelBufferObject;

class VTKRENDERINGOPENGL_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
  };

  // DepthTextureMode values.
  enum
  {
    Luminance=0, // (R,G,B,A)=(r,r,r,1)
    Intensity, // (R,G,B,A)=(r,r,r,r)
    Alpha, // (R,G,B,A)=(0,0,0,r)
    NumberOfDepthTextureModes
  };

  // Wrap values.
  enum
  {
    Clamp=0,
    ClampToEdge,
    Repeat,
    ClampToBorder,
    MirroredRepeat,
    NumberOfWrapModes
  };

  // 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
  };

  static vtkTextureObject* New();
  vtkTypeMacro(vtkTextureObject, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  void SetContext(vtkRenderWindow*);
  vtkRenderWindow* 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);


  void Bind();
  void UnBind();


  void Activate(unsigned int texUnit);
  void Deactivate(unsigned int texUnit);


  bool IsBound();


  void SendParameters();
  vtkSetMacro(AutoParameters, int);
  vtkGetMacro(AutoParameters, int);

  bool Create1D(int numComps,
                vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);

  bool Create2D(unsigned int width, unsigned int height, int numComps,
                vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);

  bool CreateDepth(unsigned int width,
                   unsigned int height,
                   int internalFormat,
                   vtkPixelBufferObject *pbo);

  bool CreateDepthFromRaw(unsigned int width,
                          unsigned int height,
                          int internalFormat,
                          int rawType,
                          void *raw);

  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 Create3D(unsigned int width, unsigned int height, unsigned int depth,
                int numComps, vtkPixelBufferObject *pbo,
                bool shaderSupportsTextureInt);



  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);

  vtkPixelBufferObject* Download();

  int GetDataType();

  unsigned int GetInternalFormat(int vtktype, int numComps,
                                 bool shaderSupportsTextureInt);
  unsigned int GetFormat(int vtktype, int numComps,
                         bool shaderSupportsTextureInt);


  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(Priority, float);
  vtkGetMacro(Priority, 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(DepthTextureMode, int);
  vtkSetMacro(DepthTextureMode, int);


  vtkGetMacro(GenerateMipmap, bool);
  vtkSetMacro(GenerateMipmap, bool);

  static bool IsSupported(
        vtkRenderWindow* renWin,
        bool requireTexFloat,
        bool requireDepthFloat,
        bool requireTexInt);

  static bool IsSupported(vtkRenderWindow* renWin)
    { return vtkTextureObject::IsSupported(renWin, false, false, false); }

  void CopyToFrameBuffer(int srcXmin,
                         int srcYmin,
                         int srcXmax,
                         int srcYmax,
                         int dstXmin,
                         int dstYmin,
                         int width,
                         int height);


  void CopyFromFrameBuffer(int srcXmin,
                           int srcYmin,
                           int dstXmin,
                           int dstYmin,
                           int width,
                           int height);

protected:
  vtkTextureObject();
  ~vtkTextureObject();

  bool LoadRequiredExtensions(vtkRenderWindow *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 Type; // GLenum
  int Components;

  vtkWeakPointer<vtkRenderWindow> 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 BorderColor[4];

  float Priority;
  float MinLOD;
  float MaxLOD;
  int BaseLevel;
  int MaxLevel;


  bool DepthTextureCompare;
  int DepthTextureCompareFunction;
  int DepthTextureMode;

  bool GenerateMipmap;

  int AutoParameters;
  vtkTimeStamp SendParametersTime;

private:
  vtkTextureObject(const vtkTextureObject&) VTK_DELETE_FUNCTION;
  void operator=(const vtkTextureObject&) VTK_DELETE_FUNCTION;

};

#endif