vtkTextureObject.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkTextureObject_h
#define vtkTextureObject_h
 
#include "vtkObject.h"
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkWeakPointer.h"            // for render context
#include "vtkWrappingHints.h"          // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkOpenGLBufferObject;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkOpenGLVertexArrayObject;
class vtkPixelBufferObject;
class vtkShaderProgram;
class vtkWindow;
class vtkGenericOpenGLResourceFreeCallback;
 
class VTKRENDERINGOPENGL2_EXPORT VTK_MARSHALAUTO 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
  };
 
  // Wrap values.
  enum
  {
    ClampToEdge = 0,
    Repeat,
    MirroredRepeat,
    ClampToBorder,
    NumberOfWrapModes
  };
 
  // MinificationFilter values.
  enum
  {
    Nearest = 0,
    Linear,
    NearestMipmapNearest,
    NearestMipmapLinear,
    LinearMipmapNearest,
    LinearMipmapLinear,
    NumberOfMinificationModes
  };
 
  // depth/color format
  enum
  {
    Native = 0, // will try to match with the depth buffer format.
    Fixed8,
    Fixed16,
    Fixed24,
    Fixed32,
    Float16,
    Float32,
    NumberOfDepthFormats
  };
 
  static vtkTextureObject* New();
  vtkTypeMacro(vtkTextureObject, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetContext(vtkOpenGLRenderWindow*);
  vtkOpenGLRenderWindow* GetContext();


  vtkGetMacro(Width, unsigned int);
  vtkGetMacro(Height, unsigned int);
  vtkGetMacro(Depth, unsigned int);
  vtkGetMacro(Samples, unsigned int);
  vtkGetMacro(Components, int);
  unsigned int GetTuples() { return this->Width * this->Height * this->Depth; }
 
  vtkGetMacro(NumberOfDimensions, int);
 
  // for MSAA textures set the number of samples
  vtkSetMacro(Samples, unsigned int);


  vtkGetMacro(Target, unsigned int);


  vtkGetMacro(Handle, unsigned int);

  int GetTextureUnit();


  void Bind();

  virtual void Activate();

  void Deactivate();

  virtual void ReleaseGraphicsResources(vtkWindow* win);

  bool IsBound();

  void SendParameters();


  vtkSetMacro(AutoParameters, int);
  vtkGetMacro(AutoParameters, int);
  vtkBooleanMacro(AutoParameters, int);

  bool Create2DFromRaw(
    unsigned int width, unsigned int height, int numComps, int dataType, void* data);

  bool Create2DArrayFromRaw(
    unsigned int width, unsigned int height, int numComps, int dataType, int nbLayers, 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);

  bool EmulateTextureBufferWith2DTextures(
    unsigned int numValues, int numComps, int dataType, vtkOpenGLBufferObject* bo);

  bool EmulateTextureBufferWith2DTexturesFromRaw(
    unsigned int numValues, int numComps, int dataType, void* data);

  bool UpdateTextureBuffer2DRegion(
    unsigned int texelOffset, unsigned int numTexels, int numComps, int dataType, void* data);

  bool CreateCubeFromRaw(
    unsigned int width, unsigned int height, int numComps, int dataType, void* data[6]);

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

  bool Create1DFromRaw(unsigned int width, int numComps, int dataType, void* data);

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

  bool AllocateProxyTexture3D(
    unsigned int width, unsigned int height, unsigned int depth, int numComps, int dataType);

  vtkPixelBufferObject* Download();
  vtkPixelBufferObject* Download(unsigned int target, unsigned int level);

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

  bool AllocateDepth(unsigned int width, unsigned int height, int internalFormat);

  bool AllocateDepthStencil(unsigned int width, unsigned int height);

  bool Allocate1D(unsigned int width, int numComps, int vtkType);

  bool Allocate2D(
    unsigned int width, unsigned int height, int numComps, int vtkType, int level = 0);

  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)
  {
    return this->Allocate2D(width, height, numComps, vtktype);
  }
  bool Create3D(
    unsigned int width, unsigned int height, unsigned int depth, int numComps, int vtktype, bool)
  {
    return this->Allocate3D(width, height, depth, numComps, vtktype);
  }


  int GetVTKDataType();


  int GetDataType(int vtk_scalar_type);
  void SetDataType(unsigned int glType);
  int GetDefaultDataType(int vtk_scalar_type);


  unsigned int GetFormat() { return this->Format; }
  unsigned int GetInternalFormat() { return this->InternalFormat; }
  unsigned int GetInternalFormat(int vtktype, int numComps, bool shaderSupportsTextureInt);
  void SetInternalFormat(unsigned int glInternalFormat);
  unsigned int GetDefaultInternalFormat(int vtktype, int numComps, bool shaderSupportsTextureInt);


  unsigned int GetFormat(int vtktype, int numComps, bool shaderSupportsTextureInt);
  void SetFormat(unsigned int glFormat);
  unsigned int GetDefaultFormat(int vtktype, int numComps, bool shaderSupportsTextureInt);

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


  vtkSetMacro(MaximumAnisotropicFiltering, float);
  vtkGetMacro(MaximumAnisotropicFiltering, float);


  static int GetMaximumTextureSize(vtkOpenGLRenderWindow* context);
  static int GetMaximumTextureSize3D(vtkOpenGLRenderWindow* context);

  int GetMaximumTextureSize3D();

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

  void GetShiftAndScale(float& shift, float& scale);
 
  // resizes an existing texture, any existing
  // data values are lost
  void Resize(unsigned int width, unsigned int height);


  vtkGetMacro(UseSRGBColorSpace, bool);
  vtkSetMacro(UseSRGBColorSpace, bool);
  vtkBooleanMacro(UseSRGBColorSpace, bool);

  void AssignToExistingTexture(unsigned int handle, unsigned int target);
 
protected:
  vtkTextureObject();
  ~vtkTextureObject() override;
 
  vtkGenericOpenGLResourceFreeCallback* ResourceCallback;

  bool LoadRequiredExtensions(vtkOpenGLRenderWindow* renWin);

  void CreateTexture();

  void DestroyTexture();
 
  int NumberOfDimensions;
  unsigned int Width;
  unsigned int Height;
  unsigned int Depth;
  unsigned int Samples;
  bool UseSRGBColorSpace;
 
  float MaximumAnisotropicFiltering;
 
  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 OwnHandle;
  bool RequireTextureInteger;
  bool SupportsTextureInteger;
  bool RequireTextureFloat;
  bool SupportsTextureFloat;
  bool RequireDepthBufferFloat;
  bool SupportsDepthBufferFloat;
 
  int WrapS;
  int WrapT;
  int WrapR;
  int MinificationFilter;
  int MagnificationFilter;
 
  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&) = delete;
  void operator=(const vtkTextureObject&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif