vtkTexture.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkTexture.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 vtkTexture_h
#define vtkTexture_h
 
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkImageAlgorithm.h"
 
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 vtkTexture : public vtkImageAlgorithm
{
public:
  static vtkTexture* New();
  vtkTypeMacro(vtkTexture, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual void Render(vtkRenderer* ren);
 
  virtual void PostRender(vtkRenderer*) {}
 
  virtual void ReleaseGraphicsResources(vtkWindow*) {}
 
  virtual void Load(vtkRenderer*) {}
 
 
  vtkGetMacro(Repeat, int);
  vtkSetMacro(Repeat, int);
  vtkBooleanMacro(Repeat, int);
 
 
  vtkGetMacro(EdgeClamp, int);
  vtkSetMacro(EdgeClamp, int);
  vtkBooleanMacro(EdgeClamp, int);
 
 
  vtkGetMacro(Interpolate, int);
  vtkSetMacro(Interpolate, int);
  vtkBooleanMacro(Interpolate, int);
 
 
  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); }
 
 
  vtkGetMacro(MapColorScalarsThroughLookupTable, int);
  vtkSetMacro(MapColorScalarsThroughLookupTable, int);
  vtkBooleanMacro(MapColorScalarsThroughLookupTable, int);
 
//BTX
 
  vtkImageData* GetInput();
//ETX
 
 
  void SetLookupTable(vtkScalarsToColors *);
  vtkGetObjectMacro(LookupTable, vtkScalarsToColors);
 
 
  vtkGetObjectMacro(MappedScalars, vtkUnsignedCharArray);
 
  unsigned char* MapScalarsToColors(vtkDataArray* scalars);
 
 
  void SetTransform(vtkTransform *transform);
  vtkGetObjectMacro(Transform, vtkTransform);
 
//BTX
 
  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
  };
//ETX
 
 
  vtkGetMacro(BlendingMode, int);
  vtkSetMacro(BlendingMode, int);
 
 
  vtkGetMacro(PremultipliedAlpha, bool);
  vtkSetMacro(PremultipliedAlpha, bool);
  vtkBooleanMacro(PremultipliedAlpha, bool);
 
 
  vtkGetMacro(RestrictPowerOf2ImageSmaller, int);
  vtkSetMacro(RestrictPowerOf2ImageSmaller, int);
  vtkBooleanMacro(RestrictPowerOf2ImageSmaller, int);
 
  virtual int IsTranslucent();
 
  virtual int GetTextureUnit() { return 0; }
 
protected:
  vtkTexture();
  ~vtkTexture();
 
  // 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.
  virtual void ExecuteData(vtkDataObject *)
  {
  }
 
  int Repeat;
  int EdgeClamp;
  int Interpolate;
  int Quality;
  int MapColorScalarsThroughLookupTable;
  vtkScalarsToColors* LookupTable;
  vtkUnsignedCharArray* MappedScalars;
  vtkTransform * Transform;
 
  int BlendingMode;
  int RestrictPowerOf2ImageSmaller;
  // this is to duplicated the previous behavior of SelfCreatedLookUpTable
  int SelfAdjustingTableRange;
  bool PremultipliedAlpha;
 
  // the result of HasTranslucentPolygonalGeometry is cached
  vtkTimeStamp TranslucentComputationTime;
  int TranslucentCachedResult;
 
private:
  vtkTexture(const vtkTexture&);  // Not implemented.
  void operator=(const vtkTexture&);  // Not implemented.
};
 
#endif