vtkLightKit.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLightKit.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 vtkLightKit_h
#define vtkLightKit_h
 
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"
 
class vtkLight;
class vtkPiecewiseFunction;
class vtkRenderer;
 
class VTKRENDERINGCORE_EXPORT vtkLightKit : public vtkObject
{
public:
  static vtkLightKit *New();
  vtkTypeMacro(vtkLightKit, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  //BTX
  enum LightKitType {
    TKeyLight,
    TFillLight,
    TBackLight,
    THeadLight
  };
 
  enum  LightKitSubType {
    Warmth,
    Intensity,
    Elevation,
    Azimuth,
    KFRatio,
    KBRatio,
    KHRatio
  };
 
  //ETX
 
 
  vtkSetMacro(KeyLightIntensity, double);
  vtkGetMacro(KeyLightIntensity, double);
 
 
  vtkSetClampMacro(KeyToFillRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToFillRatio, double);
 
 
  vtkSetClampMacro(KeyToHeadRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToHeadRatio, double);
 
 
  vtkSetClampMacro(KeyToBackRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToBackRatio, double);
 
 
  vtkSetMacro(KeyLightWarmth, double);
  vtkGetMacro(KeyLightWarmth, double);
 
  vtkSetMacro(FillLightWarmth, double);
  vtkGetMacro(FillLightWarmth, double);
 
  vtkSetMacro(HeadLightWarmth, double);
  vtkGetMacro(HeadLightWarmth, double);
 
  vtkSetMacro(BackLightWarmth, double);
  vtkGetMacro(BackLightWarmth, double);
 
 
  vtkGetVectorMacro(KeyLightColor,  double, 3);
  vtkGetVectorMacro(FillLightColor, double, 3);
  vtkGetVectorMacro(HeadLightColor, double, 3);
  vtkGetVectorMacro(BackLightColor, double, 3);
 
 
  vtkBooleanMacro(MaintainLuminance, int);
  vtkGetMacro(MaintainLuminance, int);
  vtkSetMacro(MaintainLuminance, int);
 
 
  void SetKeyLightAngle(double elevation, double azimuth);
  void SetKeyLightAngle(double angle[2])
    { this->SetKeyLightAngle(angle[0], angle[1]); }
 
  void SetKeyLightElevation(double x)
    { this->SetKeyLightAngle(x, this->KeyLightAngle[1]); }
 
  void SetKeyLightAzimuth(double x)
    { this->SetKeyLightAngle(this->KeyLightAngle[0], x); }
 
  vtkGetVectorMacro(KeyLightAngle, double, 2);
  double GetKeyLightElevation()
    { double ang[2]; this->GetKeyLightAngle(ang); return ang[0]; }
 
  double GetKeyLightAzimuth()
    { double ang[2]; this->GetKeyLightAngle(ang); return ang[1]; }
 
  void SetFillLightAngle(double elevation, double azimuth);
  void SetFillLightAngle(double angle[2])
    { this->SetFillLightAngle(angle[0], angle[1]); }
 
  void SetFillLightElevation(double x)
    { this->SetFillLightAngle(x, this->FillLightAngle[1]); }
 
  void SetFillLightAzimuth(double x)
    { this->SetFillLightAngle(this->FillLightAngle[0], x); }
 
  vtkGetVectorMacro(FillLightAngle, double, 2);
  double GetFillLightElevation() {
    double ang[2]; this->GetFillLightAngle(ang); return ang[0]; }
 
  double GetFillLightAzimuth()
    { double ang[2]; this->GetFillLightAngle(ang); return ang[1]; }
 
  void SetBackLightAngle(double elevation, double azimuth);
  void SetBackLightAngle(double angle[2])
    { this->SetBackLightAngle(angle[0], angle[1]); }
 
  void SetBackLightElevation(double x)
    { this->SetBackLightAngle(x, this->BackLightAngle[1]); }
 
  void SetBackLightAzimuth(double x)
    { this->SetBackLightAngle(this->BackLightAngle[0], x); }
 
  vtkGetVectorMacro(BackLightAngle, double, 2);
  double GetBackLightElevation()
    { double ang[2]; this->GetBackLightAngle(ang); return ang[0]; }
 
  double GetBackLightAzimuth()
    { double ang[2]; this->GetBackLightAngle(ang); return ang[1]; }
 
 
  void AddLightsToRenderer(vtkRenderer *renderer);
  void RemoveLightsFromRenderer(vtkRenderer *renderer);
 
  void DeepCopy(vtkLightKit *kit);
 
  void Modified();
  void Update();
 
  static const char *GetStringFromType(int type);
 
  static const char *GetStringFromSubType(int type);
 
  static const char *GetShortStringFromSubType(int subtype);
 
  static LightKitSubType GetSubType(LightKitType type, int i);
 
protected:
  vtkLightKit();
  ~vtkLightKit();
 
  void WarmthToRGBI(double w, double rgb[3], double& i);
  void WarmthToRGB(double w, double rgb[3]);
  void InitializeWarmthFunctions();
  double WarmthToIntensity(double w);
 
 
  double KeyLightIntensity;
  double KeyToFillRatio;
  double KeyToHeadRatio;
  double KeyToBackRatio;
 
  vtkLight *KeyLight;
  double KeyLightWarmth;
  double KeyLightAngle[2];
  double KeyLightColor[3];
 
  vtkLight *FillLight;
  double FillLightWarmth;
  double FillLightAngle[2];
  double FillLightColor[3];
 
  double BackLightWarmth;
  double BackLightColor[3];
 
  vtkLight *BackLight0;
  vtkLight *BackLight1;
 
  double BackLightAngle[2];
 
  vtkLight *HeadLight;
  double HeadLightWarmth;
  double HeadLightColor[3];
 
  int MaintainLuminance;
 
  vtkPiecewiseFunction *WarmthFunction[4]; // r, g, b, perceptual length
 
private:
  vtkLightKit(const vtkLightKit&);  // Not implemented.
  void operator=(const vtkLightKit&);  // Not implemented.
};
 
#endif