dox/Rendering/vtkTextureObject.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkTextureObject.h,v $

  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 "vtkObject.h"
#include "vtkWeakPointer.h" // needed for vtkWeakPointer.

class vtkRenderWindow;
class vtkOpenGLExtensionManager;
class vtkPixelBufferObject;

class VTK_RENDERING_EXPORT vtkTextureObject : public vtkObject
{
public:

  //BTX
  // 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
  };
  
  // 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)
  };
  
  // Wrap values.
  enum
  {
    Clamp=0,
    ClampToEdge,
    Repeat,
    ClampToBorder,
    MirroredRepeat
  };
  
  // MinificationFilter values.
  enum
  {
    Nearest=0,
    Linear,
    NearestMipmapNearest,
    NearestMipmapLinear,
    LinearMipmapNearest,
    LinearMipmapLinear
  };
  //ETX
  
  static vtkTextureObject* New();
  vtkTypeRevisionMacro(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);

  vtkGetMacro(NumberOfDimensions, int);


  vtkGetMacro(Target, int);


  vtkGetMacro(Handle, unsigned int);


  void Bind();
  void UnBind();

  bool IsBound();
  
  void SendParameters();
  

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


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

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

  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(LinearMagnification,bool);
  vtkSetMacro(LinearMagnification,bool);
  

  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);
//BTX
protected:
  vtkTextureObject();
  ~vtkTextureObject();

  bool LoadRequiredExtensions(vtkOpenGLExtensionManager*);

  void CreateTexture();

  void DestroyTexture();

  int NumberOfDimensions;
  unsigned int Width;
  unsigned int Height;
  unsigned int Depth;

  int Target; // GLenum
  int Format; // GLint
  int Type; // GLint
  int Components;

  vtkWeakPointer<vtkRenderWindow> Context;
  unsigned int Handle;
  bool SupportsTextureInteger;

  int WrapS;
  int WrapT;
  int WrapR;
  int MinificationFilter;
  bool LinearMagnification;
  float BorderColor[4];
  
  float Priority;
  float MinLOD;
  float MaxLOD;
  int BaseLevel;
  int MaxLevel;
  
  
  bool DepthTextureCompare;
  int DepthTextureCompareFunction;
  int DepthTextureMode;
  
  bool GenerateMipmap;
  
  vtkTimeStamp SendParametersTime;
  
private:
  vtkTextureObject(const vtkTextureObject&); // Not implemented.
  void operator=(const vtkTextureObject&); // Not implemented.
//ETX
};

#endif

---