/*========================================================================= 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. =========================================================================*/ /** * @class vtkLight * @brief a virtual light for 3D rendering * * vtkLight is a virtual light for 3D rendering. It provides methods to locate * and point the light, turn it on and off, and set its brightness and color. * In addition to the basic infinite distance point light source attributes, * you also can specify the light attenuation values and cone angle. * These attributes are only used if the light is a positional light. * The default is a directional light (e.g. infinite point light source). * * Lights have a type that describes how the light should move with respect * to the camera. A Headlight is always located at the current camera position * and shines on the camera's focal point. A CameraLight also moves with * the camera, but may not be coincident to it. CameraLights are defined * in a normalized coordinate space where the camera is located at (0, 0, 1), * the camera is looking at (0, 0, 0), and up is (0, 1, 0). Finally, a * SceneLight is part of the scene itself and does not move with the camera. * (Renderers are responsible for moving the light based on its type.) * * Lights have a transformation matrix that describes the space in which * they are positioned. A light's world space position and focal point * are defined by their local position and focal point, transformed by * their transformation matrix (if it exists). */ #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; /** * Create a light with the focal point at the origin and its position * set to (0,0,1). The light is a SceneLight, its color is white * (black ambient, white diffuse, white specular), * intensity=1, the light is turned on, positional lighting is off, * ConeAngle=30, AttenuationValues=(1,0,0), Exponent=1 and the * TransformMatrix is NULL. */ static vtkLight* New(); /** * Create a new light object with the same light parameters than the current * object (any ivar from the superclasses (vtkObject and vtkObjectBase), * like reference counting, timestamp and observers are not copied). * This is a shallow clone (TransformMatrix is referenced) */ virtual vtkLight* ShallowClone(); /** * Abstract interface to renderer. Each concrete subclass of vtkLight * will load its data into the graphics system in response to this method * invocation. The actual loading is performed by a vtkLightDevice * subclass, which will get created automatically. */ virtual void Render(vtkRenderer*, int) {} //@{ /** * Set/Get the color of the light. It is possible to set the ambient, * diffuse and specular colors separately. The SetColor() method sets * the diffuse and specular colors to the same color (this is a feature * to preserve backward compatibility.) */ 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]); } //@} //@{ /** * Set/Get the position of the light. * Note: The position of the light is defined in the coordinate * space indicated by its transformation matrix (if it exists). * Thus, to get the light's world space position, use * vtkGetTransformedPosition() instead of vtkGetPosition(). */ vtkSetVector3Macro(Position, double); vtkGetVectorMacro(Position, double, 3); void SetPosition(const float* a) { this->SetPosition(a[0], a[1], a[2]); } //@} //@{ /** * Set/Get the point at which the light is shining. * Note: The focal point of the light is defined in the coordinate * space indicated by its transformation matrix (if it exists). * Thus, to get the light's world space focal point, use * vtkGetTransformedFocalPoint() instead of vtkGetFocalPoint(). */ vtkSetVector3Macro(FocalPoint, double); vtkGetVectorMacro(FocalPoint, double, 3); void SetFocalPoint(const float* a) { this->SetFocalPoint(a[0], a[1], a[2]); } //@} //@{ /** * Set/Get the brightness of the light (from one to zero). */ vtkSetMacro(Intensity, double); vtkGetMacro(Intensity, double); //@} //@{ /** * Turn the light on or off. */ vtkSetMacro(Switch, vtkTypeBool); vtkGetMacro(Switch, vtkTypeBool); vtkBooleanMacro(Switch, vtkTypeBool); //@} //@{ /** * Turn positional lighting on or off. */ vtkSetMacro(Positional, vtkTypeBool); vtkGetMacro(Positional, vtkTypeBool); vtkBooleanMacro(Positional, vtkTypeBool); //@} //@{ /** * Set/Get the exponent of the cosine used in positional lighting. */ vtkSetClampMacro(Exponent, double, 0.0, 128.0); vtkGetMacro(Exponent, double); //@} //@{ /** * Set/Get the lighting cone angle of a positional light in degrees. * This is the angle between the axis of the cone and a ray along the edge of * the cone. * A value of 90 (or more) indicates that you want no spot lighting effects * just a positional light. */ vtkSetMacro(ConeAngle, double); vtkGetMacro(ConeAngle, double); //@} //@{ /** * Set/Get the quadratic attenuation constants. They are specified as * constant, linear, and quadratic, in that order. */ vtkSetVector3Macro(AttenuationValues, double); vtkGetVectorMacro(AttenuationValues, double, 3); //@} //@{ /** * Set/Get the light's transformation matrix. If a matrix is set for * a light, the light's parameters (position and focal point) are * transformed by the matrix before being rendered. */ virtual void SetTransformMatrix(vtkMatrix4x4*); vtkGetObjectMacro(TransformMatrix, vtkMatrix4x4); //@} //@{ /** * Get the position of the light, modified by the transformation matrix * (if it exists). */ void GetTransformedPosition(double& a0, double& a1, double& a2); void GetTransformedPosition(double a[3]); double* GetTransformedPosition() VTK_SIZEHINT(3); //@} //@{ /** * Get the focal point of the light, modified by the transformation matrix * (if it exists). */ void GetTransformedFocalPoint(double& a0, double& a1, double& a2); void GetTransformedFocalPoint(double a[3]); double* GetTransformedFocalPoint() VTK_SIZEHINT(3); //@} /** * Use transform matrix to transform point (if it exists). */ void TransformPoint(double a[3], double b[3]); /** * Use transform matrix to transform vector (if it exists). */ void TransformVector(double a[3], double b[3]); //@{ /** * Set the position and focal point of a light based on elevation and * azimuth. The light is moved so it is shining from the given angle. * Angles are given in degrees. If the light is a * positional light, it is made directional instead. */ void SetDirectionAngle(double elevation, double azimuth); void SetDirectionAngle(const double ang[2]) { this->SetDirectionAngle(ang[0], ang[1]); } //@} /** * Perform deep copy of this light. */ void DeepCopy(vtkLight* light); //@{ /** * Set/Get the type of the light. * A SceneLight is a light located in the world coordinate space. A light * is initially created as a scene light. * A Headlight is always located at the camera and is pointed at the * camera's focal point. The renderer is free to modify the position and * focal point of the camera at any time. * A CameraLight is also attached to the camera, but is not necessarily * located at the camera's position. CameraLights are defined in a * coordinate space where the camera is located at (0, 0, 1), looking * towards (0, 0, 0) at a distance of 1, with up being (0, 1, 0). * CameraLight uses the transform matrix to establish this space. * Note: All SetLightType(), and SetLightTypeTo*() calls clear the * light's transform matrix. */ 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); } //@} //@{ /** * Query the type of the light. */ int LightTypeIsHeadlight(); int LightTypeIsSceneLight(); int LightTypeIsCameraLight(); //@} //@{ /** * Set/Get the shadow intensity * By default a light will be completely blocked when in shadow * by setting this value to less than 1.0 you can control how much * light is attenuated when in shadow */ vtkSetMacro(ShadowAttenuation, float); vtkGetMacro(ShadowAttenuation, float); //@} //@{ /** * Set/Get the information object associated with the light. */ 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