You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
139 lines
5.1 KiB
C++
139 lines
5.1 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkEncodedGradientShader.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.
|
|
|
|
=========================================================================*/
|
|
|
|
/**
|
|
* @class vtkEncodedGradientShader
|
|
* @brief Compute shading tables for encoded normals.
|
|
*
|
|
*
|
|
* vtkEncodedGradientShader computes shading tables for encoded normals
|
|
* that indicates the amount of diffuse and specular illumination that is
|
|
* received from all light sources at a surface location with that normal.
|
|
* For diffuse illumination this is accurate, but for specular illumination
|
|
* it is approximate for perspective projections since the center view
|
|
* direction is always used as the view direction. Since the shading table is
|
|
* dependent on the volume (for the transformation that must be applied to
|
|
* the normals to put them into world coordinates) there is a shading table
|
|
* per volume. This is necessary because multiple volumes can share a
|
|
* volume mapper.
|
|
*/
|
|
|
|
#ifndef vtkEncodedGradientShader_h
|
|
#define vtkEncodedGradientShader_h
|
|
|
|
#include "vtkObject.h"
|
|
#include "vtkRenderingVolumeModule.h" // For export macro
|
|
|
|
class vtkVolume;
|
|
class vtkRenderer;
|
|
class vtkEncodedGradientEstimator;
|
|
|
|
#define VTK_MAX_SHADING_TABLES 100
|
|
|
|
class VTKRENDERINGVOLUME_EXPORT vtkEncodedGradientShader : public vtkObject
|
|
{
|
|
public:
|
|
static vtkEncodedGradientShader* New();
|
|
vtkTypeMacro(vtkEncodedGradientShader, vtkObject);
|
|
|
|
/**
|
|
* Print the vtkEncodedGradientShader
|
|
*/
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
//@{
|
|
/**
|
|
* Set / Get the intensity diffuse / specular light used for the
|
|
* zero normals.
|
|
*/
|
|
vtkSetClampMacro(ZeroNormalDiffuseIntensity, float, 0.0f, 1.0f);
|
|
vtkGetMacro(ZeroNormalDiffuseIntensity, float);
|
|
vtkSetClampMacro(ZeroNormalSpecularIntensity, float, 0.0f, 1.0f);
|
|
vtkGetMacro(ZeroNormalSpecularIntensity, float);
|
|
//@}
|
|
|
|
/**
|
|
* Cause the shading table to be updated
|
|
*/
|
|
void UpdateShadingTable(vtkRenderer* ren, vtkVolume* vol, vtkEncodedGradientEstimator* gradest);
|
|
|
|
//@{
|
|
/**
|
|
* Get the red/green/blue shading table.
|
|
*/
|
|
float* GetRedDiffuseShadingTable(vtkVolume* vol);
|
|
float* GetGreenDiffuseShadingTable(vtkVolume* vol);
|
|
float* GetBlueDiffuseShadingTable(vtkVolume* vol);
|
|
float* GetRedSpecularShadingTable(vtkVolume* vol);
|
|
float* GetGreenSpecularShadingTable(vtkVolume* vol);
|
|
float* GetBlueSpecularShadingTable(vtkVolume* vol);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set the active component for shading. This component's
|
|
* ambient / diffuse / specular / specular power values will
|
|
* be used to create the shading table. The default is 1.0
|
|
*/
|
|
vtkSetClampMacro(ActiveComponent, int, 0, 3);
|
|
vtkGetMacro(ActiveComponent, int);
|
|
//@}
|
|
|
|
protected:
|
|
vtkEncodedGradientShader();
|
|
~vtkEncodedGradientShader() override;
|
|
|
|
/**
|
|
* Build a shading table for a light with the specified direction,
|
|
* and color for an object of the specified material properties.
|
|
* material[0] = ambient, material[1] = diffuse, material[2] = specular
|
|
* and material[3] = specular exponent. If the ambient flag is 1,
|
|
* then ambient illumination is added. If not, then this means we
|
|
* are calculating the "other side" of two sided lighting, so no
|
|
* ambient intensity is added in. If the update flag is 0,
|
|
* the shading table is overwritten with these new shading values.
|
|
* If the updateFlag is 1, then the computed light contribution is
|
|
* added to the current shading table values. There is one shading
|
|
* table per volume, and the index value indicated which index table
|
|
* should be used. It is computed in the UpdateShadingTable method.
|
|
*/
|
|
void BuildShadingTable(int index, double lightDirection[3], double lightAmbientColor[3],
|
|
double lightDiffuseColor[3], double lightSpecularColor[3], double lightIntensity,
|
|
double viewDirection[3], double material[4], int twoSided, vtkEncodedGradientEstimator* gradest,
|
|
int updateFlag);
|
|
|
|
// The six shading tables (r diffuse ,g diffuse ,b diffuse,
|
|
// r specular, g specular, b specular ) - with an entry for each
|
|
// encoded normal plus one entry at the end for the zero normal
|
|
// There is one shading table per volume listed in the ShadingTableVolume
|
|
// array. A null entry indicates an available slot.
|
|
float* ShadingTable[VTK_MAX_SHADING_TABLES][6];
|
|
vtkVolume* ShadingTableVolume[VTK_MAX_SHADING_TABLES];
|
|
int ShadingTableSize[VTK_MAX_SHADING_TABLES];
|
|
|
|
int ActiveComponent;
|
|
|
|
// The intensity of light used for the zero normals, since it
|
|
// can not be computed from the normal angles. Defaults to 0.0.
|
|
float ZeroNormalDiffuseIntensity;
|
|
float ZeroNormalSpecularIntensity;
|
|
|
|
private:
|
|
vtkEncodedGradientShader(const vtkEncodedGradientShader&) = delete;
|
|
void operator=(const vtkEncodedGradientShader&) = delete;
|
|
};
|
|
|
|
#endif
|