dox/Rendering/Core/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