vtkTexture.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 vtkTexture_h
#define vtkTexture_h

#include "vtkImageAlgorithm.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSystemIncludes.h"      // For VTK_COLOR_MODE_*
#include "vtkWrappingHints.h"       // For VTK_MARSHALMANUAL

VTK_ABI_NAMESPACE_BEGIN
class vtkImageData;
class vtkScalarsToColors;
class vtkRenderer;
class vtkUnsignedCharArray;
class vtkWindow;
class vtkDataArray;
class vtkTransform;

#define VTK_TEXTURE_QUALITY_DEFAULT 0
#define VTK_TEXTURE_QUALITY_16BIT 16
#define VTK_TEXTURE_QUALITY_32BIT 32

class VTKRENDERINGCORE_EXPORT VTK_MARSHALMANUAL vtkTexture : public vtkImageAlgorithm
{
public:
  static vtkTexture* New();
  vtkTypeMacro(vtkTexture, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void Render(vtkRenderer* ren);

  virtual void PostRender(vtkRenderer*) {}

  virtual void ReleaseGraphicsResources(vtkWindow*) {}

  virtual void Load(vtkRenderer*) {}


  vtkGetMacro(Interpolate, vtkTypeBool);
  vtkSetMacro(Interpolate, vtkTypeBool);
  vtkBooleanMacro(Interpolate, vtkTypeBool);


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


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


  vtkSetMacro(Quality, int);
  vtkGetMacro(Quality, int);
  void SetQualityToDefault() { this->SetQuality(VTK_TEXTURE_QUALITY_DEFAULT); }
  void SetQualityTo16Bit() { this->SetQuality(VTK_TEXTURE_QUALITY_16BIT); }
  void SetQualityTo32Bit() { this->SetQuality(VTK_TEXTURE_QUALITY_32BIT); }


  vtkSetMacro(ColorMode, int);
  vtkGetMacro(ColorMode, int);
  void SetColorModeToDefault() { this->SetColorMode(VTK_COLOR_MODE_DEFAULT); }
  void SetColorModeToMapScalars() { this->SetColorMode(VTK_COLOR_MODE_MAP_SCALARS); }
  void SetColorModeToDirectScalars() { this->SetColorMode(VTK_COLOR_MODE_DIRECT_SCALARS); }

  vtkImageData* GetInput();


  void SetLookupTable(vtkScalarsToColors*);
  vtkGetObjectMacro(LookupTable, vtkScalarsToColors);


  vtkGetObjectMacro(MappedScalars, vtkUnsignedCharArray);

  unsigned char* MapScalarsToColors(vtkDataArray* scalars);


  void SetTransform(vtkTransform* transform);
  vtkGetObjectMacro(Transform, vtkTransform);

  enum VTKTextureBlendingMode
  {
    VTK_TEXTURE_BLENDING_MODE_NONE = 0,
    VTK_TEXTURE_BLENDING_MODE_REPLACE,
    VTK_TEXTURE_BLENDING_MODE_MODULATE,
    VTK_TEXTURE_BLENDING_MODE_ADD,
    VTK_TEXTURE_BLENDING_MODE_ADD_SIGNED,
    VTK_TEXTURE_BLENDING_MODE_INTERPOLATE,
    VTK_TEXTURE_BLENDING_MODE_SUBTRACT
  };


  vtkGetMacro(BlendingMode, int);
  vtkSetMacro(BlendingMode, int);


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


  vtkGetMacro(RestrictPowerOf2ImageSmaller, vtkTypeBool);
  vtkSetMacro(RestrictPowerOf2ImageSmaller, vtkTypeBool);
  vtkBooleanMacro(RestrictPowerOf2ImageSmaller, vtkTypeBool);

  virtual int IsTranslucent();

  virtual int GetTextureUnit() { return 0; }


  vtkGetMacro(CubeMap, bool);
  vtkBooleanMacro(CubeMap, bool);
  void SetCubeMap(bool val);


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


  vtkSetVector4Macro(BorderColor, float);
  vtkGetVector4Macro(BorderColor, float);

  enum
  {
    ClampToEdge = 0,
    Repeat,
    MirroredRepeat,
    ClampToBorder,
    NumberOfWrapModes
  };


  vtkGetMacro(Wrap, int);
  vtkSetClampMacro(Wrap, int, ClampToEdge, ClampToBorder);


  virtual void SetRepeat(vtkTypeBool r) { this->SetWrap(r ? Repeat : ClampToEdge); }
  virtual vtkTypeBool GetRepeat() { return (this->GetWrap() == Repeat); }
  virtual void RepeatOn() { this->SetRepeat(true); }
  virtual void RepeatOff() { this->SetRepeat(false); }
  virtual void SetEdgeClamp(vtkTypeBool) { /* This wasn't doing anything before. */ }
  virtual vtkTypeBool GetEdgeClamp() { return (this->GetWrap() == ClampToEdge); }
  virtual void EdgeClampOn() { this->SetEdgeClamp(true); }
  virtual void EdgeClampOff() { this->SetEdgeClamp(false); }

protected:
  vtkTexture();
  ~vtkTexture() override;

  // A texture is a sink, so there is no need to do anything.
  // This definition avoids a warning when doing Update() on a vtkTexture object.
  void ExecuteData(vtkDataObject*) override {}

  bool Mipmap;
  float MaximumAnisotropicFiltering;
  int Wrap;
  float BorderColor[4];
  vtkTypeBool Interpolate;
  int Quality;
  int ColorMode;
  vtkScalarsToColors* LookupTable;
  vtkUnsignedCharArray* MappedScalars;
  vtkTransform* Transform;

  int BlendingMode;
  vtkTypeBool RestrictPowerOf2ImageSmaller;
  // this is to duplicated the previous behavior of SelfCreatedLookUpTable
  int SelfAdjustingTableRange;
  bool PremultipliedAlpha;
  bool CubeMap;
  bool UseSRGBColorSpace;

  // the result of HasTranslucentPolygonalGeometry is cached
  vtkTimeStamp TranslucentComputationTime;
  int TranslucentCachedResult;

private:
  vtkTexture(const vtkTexture&) = delete;
  void operator=(const vtkTexture&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif