vtkLight.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLight.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 vtkLight_h
#define vtkLight_h
 
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
 
/* need for virtual function */
class vtkInformation;
class vtkRenderer;
class vtkMatrix4x4;
 
#define VTK_LIGHT_TYPE_HEADLIGHT 1
#define VTK_LIGHT_TYPE_CAMERA_LIGHT 2
#define VTK_LIGHT_TYPE_SCENE_LIGHT 3
 
class VTKRENDERINGCORE_EXPORT vtkLight : public vtkObject
{
public:
  vtkTypeMacro(vtkLight, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkLight* New();
 
  virtual vtkLight* ShallowClone();
 
  virtual void Render(vtkRenderer*, int) {}
 
 
  vtkSetVector3Macro(AmbientColor, double);
  vtkGetVectorMacro(AmbientColor, double, 3);
  vtkSetVector3Macro(DiffuseColor, double);
  vtkGetVectorMacro(DiffuseColor, double, 3);
  vtkSetVector3Macro(SpecularColor, double);
  vtkGetVectorMacro(SpecularColor, double, 3);
  void SetColor(double, double, double);
  void SetColor(const double a[3]) { this->SetColor(a[0], a[1], a[2]); }
 
 
  vtkSetVector3Macro(Position, double);
  vtkGetVectorMacro(Position, double, 3);
  void SetPosition(const float* a) { this->SetPosition(a[0], a[1], a[2]); }
 
 
  vtkSetVector3Macro(FocalPoint, double);
  vtkGetVectorMacro(FocalPoint, double, 3);
  void SetFocalPoint(const float* a) { this->SetFocalPoint(a[0], a[1], a[2]); }
 
 
  vtkSetMacro(Intensity, double);
  vtkGetMacro(Intensity, double);
 
 
  vtkSetMacro(Switch, vtkTypeBool);
  vtkGetMacro(Switch, vtkTypeBool);
  vtkBooleanMacro(Switch, vtkTypeBool);
 
 
  vtkSetMacro(Positional, vtkTypeBool);
  vtkGetMacro(Positional, vtkTypeBool);
  vtkBooleanMacro(Positional, vtkTypeBool);
 
 
  vtkSetClampMacro(Exponent, double, 0.0, 128.0);
  vtkGetMacro(Exponent, double);
 
 
  vtkSetMacro(ConeAngle, double);
  vtkGetMacro(ConeAngle, double);
 
 
  vtkSetVector3Macro(AttenuationValues, double);
  vtkGetVectorMacro(AttenuationValues, double, 3);
 
 
  virtual void SetTransformMatrix(vtkMatrix4x4*);
  vtkGetObjectMacro(TransformMatrix, vtkMatrix4x4);
 
 
  void GetTransformedPosition(double& x, double& y, double& z);
  void GetTransformedPosition(double a[3]);
  double* GetTransformedPosition() VTK_SIZEHINT(3);
 
 
  void GetTransformedFocalPoint(double& x, double& y, double& z);
  void GetTransformedFocalPoint(double a[3]);
  double* GetTransformedFocalPoint() VTK_SIZEHINT(3);
 
  void TransformPoint(double a[3], double b[3]);
 
  void TransformVector(double a[3], double b[3]);
 
 
  void SetDirectionAngle(double elevation, double azimuth);
  void SetDirectionAngle(const double ang[2]) { this->SetDirectionAngle(ang[0], ang[1]); }
 
  void DeepCopy(vtkLight* light);
 
 
  virtual void SetLightType(int);
  vtkGetMacro(LightType, int);
 
  void SetLightTypeToHeadlight() { this->SetLightType(VTK_LIGHT_TYPE_HEADLIGHT); }
  void SetLightTypeToSceneLight() { this->SetLightType(VTK_LIGHT_TYPE_SCENE_LIGHT); }
  void SetLightTypeToCameraLight() { this->SetLightType(VTK_LIGHT_TYPE_CAMERA_LIGHT); }
 
 
  int LightTypeIsHeadlight();
  int LightTypeIsSceneLight();
  int LightTypeIsCameraLight();
 
 
  vtkSetMacro(ShadowAttenuation, float);
  vtkGetMacro(ShadowAttenuation, float);
 
 
  vtkGetObjectMacro(Information, vtkInformation);
  virtual void SetInformation(vtkInformation*);
 
protected:
  vtkLight();
  ~vtkLight() override;
 
  double FocalPoint[3];
  double Position[3];
  double Intensity;
  double AmbientColor[3];
  double DiffuseColor[3];
  double SpecularColor[3];
  vtkTypeBool Switch;
  vtkTypeBool Positional;
  double Exponent;
  double ConeAngle;
  double AttenuationValues[3];
  vtkMatrix4x4* TransformMatrix;
  double TransformedFocalPointReturn[3];
  double TransformedPositionReturn[3];
  int LightType;
  float ShadowAttenuation;
 
  // Arbitrary extra information associated with this light.
  vtkInformation* Information;
 
private:
  vtkLight(const vtkLight&) = delete;
  void operator=(const vtkLight&) = delete;
};
 
#endif