0024872: Support of emission color in Phong shader and ray-tracing
[occt.git] / src / Shaders / PhongShading.fs
1 // Created on: 2013-10-10
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 varying vec3 View;          //!< Direction to the viewer
17 varying vec3 Normal;        //!< Vertex normal in view space
18 varying vec4 Position;      //!< Vertex position in view space.
19 varying vec4 PositionWorld; //!< Vertex position in world space
20
21 vec3 Ambient;  //!< Ambient  contribution of light sources
22 vec3 Diffuse;  //!< Diffuse  contribution of light sources
23 vec3 Specular; //!< Specular contribution of light sources
24
25 //! Computes contribution of isotropic point light source
26 void pointLight (in int  theId,
27                  in vec3 theNormal,
28                  in vec3 theView,
29                  in vec3 thePoint)
30 {
31   vec3 aLight = occLight_Position (theId).xyz;
32   if (occLight_IsHeadlight (theId) == 0)
33   {
34     aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 1.0));
35   }
36   aLight -= thePoint;
37
38   float aDist = length (aLight);
39   aLight = aLight * (1.0 / aDist);
40
41   float anAtten = 1.0 / (occLight_ConstAttenuation  (theId)
42                        + occLight_LinearAttenuation (theId) * aDist);
43
44   vec3 aHalf = normalize (aLight + theView);
45
46   vec3  aFaceSideNormal = gl_FrontFacing ? theNormal : -theNormal;
47   float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));
48   float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));
49
50   float aSpecl = 0.0;
51   if (aNdotL > 0.0)
52   {
53     aSpecl = pow (aNdotH, gl_FrontFacing ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());
54   }
55
56   Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL * anAtten;
57   Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;
58 }
59
60 //! Computes contribution of spotlight source
61 void spotLight (in int  theId,
62                 in vec3 theNormal,
63                 in vec3 theView,
64                 in vec3 thePoint)
65 {
66   vec3 aLight   = occLight_Position      (theId).xyz;
67   vec3 aSpotDir = occLight_SpotDirection (theId).xyz;
68   if (occLight_IsHeadlight (theId) == 0)
69   {
70     aLight   = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight,   1.0));
71     aSpotDir = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aSpotDir, 0.0));
72   }
73   aLight -= thePoint;
74
75   float aDist = length (aLight);
76   aLight = aLight * (1.0 / aDist);
77
78   aSpotDir = normalize (aSpotDir);
79
80   // light cone
81   float aCosA = dot (aSpotDir, -aLight);
82   if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))
83   {
84     return;
85   }
86
87   float anExponent = occLight_SpotExponent (theId);
88   float anAtten    = 1.0 / (occLight_ConstAttenuation  (theId)
89                           + occLight_LinearAttenuation (theId) * aDist);
90   if (anExponent > 0.0)
91   {
92     anAtten *= pow (aCosA, anExponent * 128.0);
93   }
94
95   vec3 aHalf = normalize (aLight + theView);
96
97   vec3  aFaceSideNormal = gl_FrontFacing ? theNormal : -theNormal;
98   float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));
99   float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));
100
101   float aSpecl = 0.0;
102   if (aNdotL > 0.0)
103   {
104     aSpecl = pow (aNdotH, gl_FrontFacing ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());
105   }
106
107   Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL * anAtten;
108   Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;
109 }
110
111 //! Computes contribution of directional light source
112 void directionalLight (in int  theId,
113                        in vec3 theNormal,
114                        in vec3 theView)
115 {
116   vec3 aLight = normalize (occLight_Position (theId).xyz);
117   if (occLight_IsHeadlight (theId) == 0)
118   {
119     aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 0.0));
120   }
121
122   vec3 aHalf = normalize (aLight + theView);
123
124   vec3  aFaceSideNormal = gl_FrontFacing ? theNormal : -theNormal;
125   float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));
126   float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));
127
128   float aSpecl = 0.0;
129   if (aNdotL > 0.0)
130   {
131     aSpecl = pow (aNdotH, gl_FrontFacing ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());
132   }
133
134   Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL;
135   Specular += occLight_Specular (theId).rgb * aSpecl;
136 }
137
138 //! Computes illumination from light sources
139 vec4 computeLighting (in vec3 theNormal,
140                       in vec3 theView,
141                       in vec4 thePoint)
142 {
143   // Clear the light intensity accumulators
144   Ambient  = occLightAmbient.rgb;
145   Diffuse  = vec3 (0.0);
146   Specular = vec3 (0.0);
147   vec3 aPoint = thePoint.xyz / thePoint.w;
148   for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)
149   {
150     int aType = occLight_Type (anIndex);
151     if (aType == OccLightType_Direct)
152     {
153       directionalLight (anIndex, theNormal, theView);
154     }
155     else if (aType == OccLightType_Point)
156     {
157       pointLight (anIndex, theNormal, theView, aPoint);
158     }
159     else if (aType == OccLightType_Spot)
160     {
161       spotLight (anIndex, theNormal, theView, aPoint);
162     }
163   }
164
165   vec4 aMaterialAmbient  = gl_FrontFacing ? occFrontMaterial_Ambient()  : occBackMaterial_Ambient();
166   vec4 aMaterialDiffuse  = gl_FrontFacing ? occFrontMaterial_Diffuse()  : occBackMaterial_Diffuse();
167   vec4 aMaterialSpecular = gl_FrontFacing ? occFrontMaterial_Specular() : occBackMaterial_Specular();
168   vec4 aMaterialEmission = gl_FrontFacing ? occFrontMaterial_Emission() : occBackMaterial_Emission();
169   return vec4 (Ambient,  1.0) * aMaterialAmbient
170        + vec4 (Diffuse,  1.0) * aMaterialDiffuse
171        + vec4 (Specular, 1.0) * aMaterialSpecular
172                               + aMaterialEmission;
173 }
174
175 //! Entry point to the Fragment Shader
176 void main()
177 {
178   // process clipping planes
179   for (int anIndex = 0; anIndex < occClipPlaneCount; ++anIndex)
180   {
181     vec4 aClipEquation = occClipPlaneEquations[anIndex];
182     int  aClipSpace    = occClipPlaneSpaces[anIndex];
183     if (aClipSpace == OccEquationCoords_World)
184     {
185       if (dot (aClipEquation.xyz, PositionWorld.xyz) + aClipEquation.w < 0.0)
186       {
187         discard;
188       }
189     }
190     else if (aClipSpace == OccEquationCoords_View)
191     {
192       if (dot (aClipEquation.xyz, Position.xyz) + aClipEquation.w < 0.0)
193       {
194         discard;
195       }
196     }
197   }
198
199   gl_FragColor = computeLighting (normalize (Normal),
200                                   normalize (View),
201                                   Position);
202 }