root/OpenSceneGraph/trunk/examples/osgshadercompositor/CreateAdvancedHierachy.cpp @ 10284

Revision 10284, 33.4 kB (checked in by robert, 5 years ago)

From Wojciech Lewandowski, "I suppose this error is caused by using 4 component tex coord in texture2D call. I always forget about adding .xy swizzle at the end of tex coord. I have attached code (hopefully fixed). My NVidia seems to ignore such errors. Cannot test it myself. Simple example works because I actually use textture2Dproj there."

Line 
1#include <iostream>
2#include <osg/Geode>
3#include <osg/TexGen>
4#include <osg/Material>
5#include <osg/Texture2D>
6#include <osg/MatrixTransform>
7#include <osg/ShapeDrawable>
8#include <osg/BlendFunc>
9#include <osgText/Text>
10#include <osgDB/ReadFile>
11#include <osgViewer/Viewer>
12#include <osgViewer/View>
13#include <osgViewer/CompositeViewer>
14#include <osgGA/TrackballManipulator>
15
16#include "VirtualProgram.h"
17
18using osgCandidate::VirtualProgram;
19
20////////////////////////////////////////////////////////////////////////////////
21// Example shaders assume:
22// one texture
23// one directional light
24// front face lighting
25// color material mode not used (its not supported by GLSL anyway)
26// diffuse/ambient/emissive/specular factors defined in material structure
27// all coords and normal except gl_Position are in view space
28////////////////////////////////////////////////////////////////////////////////
29
30char MainVertexShaderSource[] =
31"vec4 texture( in vec3 position, in vec3 normal );                          \n" //1
32"void lighting( in vec3 position, in vec3 normal );                         \n" //2
33"                                                                           \n" //3
34"void main ()                                                               \n" //4
35"{                                                                          \n" //5
36"    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;                \n" //6
37"    vec4 position4 = gl_ModelViewMatrix * gl_Vertex;                       \n" //7
38"    vec3 position = position4.xyz / position4.w;                           \n" //8
39"    vec3 normal = normalize( gl_NormalMatrix * gl_Normal );                \n" //9
40"    gl_TexCoord[0] = texture( position, normal );                          \n" //10
41"    lighting( position, normal );                                          \n" //11
42"}                                                                          \n";//12
43
44char TexCoordTextureVertexShaderSource[] =
45"vec4 texture( in vec3 position, in vec3 normal )                           \n" //1
46"{                                                                          \n" //2
47"    return gl_TextureMatrix[0] * gl_MultiTexCoord0;                        \n" //3
48"}                                                                          \n";//4
49
50char SphereMapTextureVertexShaderSource[] =
51"vec4 texture( in vec3 position, in vec3 normal )                           \n" //1
52"{                                                                          \n" //2
53"    vec3 u = normalize( position );                                        \n" //3
54"    vec3 r = reflect(u, normal);                                           \n" //4
55"    float m = 2.0 * sqrt(r.x * r.x + r.y * r.y + (r.z+1.0) * (r.z+1.0));   \n" //5
56"    return vec4(r.x / m + 0.5, r.y / m + 0.5, 1.0, 1.0 );                  \n" //6
57"}                                                                          \n";//7
58
59char PerVertexDirectionalLightingVertexShaderSource[] =
60"void lighting( in vec3 position, in vec3 normal )                          \n" //1
61"{                                                                          \n" //2
62"    float NdotL = dot( normal, normalize(gl_LightSource[0].position.xyz) );\n" //3
63"    NdotL = max( 0.0, NdotL );                                             \n" //4
64"    float NdotHV = dot( normal, gl_LightSource[0].halfVector.xyz );        \n" //5
65"    NdotHV = max( 0.0, NdotHV );                                           \n" //6
66"                                                                           \n" //7
67"    gl_FrontColor = gl_FrontLightModelProduct.sceneColor +                 \n" //8
68"                    gl_FrontLightProduct[0].ambient +                      \n" //9
69"                    gl_FrontLightProduct[0].diffuse * NdotL;               \n" //10
70"                                                                           \n" //11
71"    gl_FrontSecondaryColor = vec4(0.0);                                    \n" //12
72"                                                                           \n" //13
73"    if ( NdotL * NdotHV > 0.0 )                                            \n" //14
74"        gl_FrontSecondaryColor = gl_FrontLightProduct[0].specular *        \n" //15
75"                                 pow( NdotHV, gl_FrontMaterial.shininess );\n" //16
76"                                                                           \n" //17
77"    gl_BackColor = gl_FrontColor;                                          \n" //18
78"    gl_BackSecondaryColor = gl_FrontSecondaryColor;                        \n" //19
79"}                                                                          \n";//20
80
81char MainFragmentShaderSource[] =
82"vec4 texture( void );                                                      \n" //1
83"void lighting( inout vec4 color );                                         \n" //2
84"                                                                           \n" //3
85"void main ()                                                               \n" //4
86"{                                                                          \n" //5
87"    vec4 color = texture();                                                \n" //6
88"    lighting( color );                                                     \n" //7
89"    gl_FragColor = color;                                                  \n" //8
90"}                                                                          \n";//9
91
92char TextureFragmentShaderSource[] =
93"uniform sampler2D baseTexture;                                             \n" //1
94"vec4 texture( void )                                                       \n" //2
95"{                                                                          \n" //3
96"    return texture2D( baseTexture, gl_TexCoord[0].xy );                    \n" //4
97"}                                                                          \n";//5
98
99char ProceduralBlueTextureFragmentShaderSource[] =
100"vec4 texture( void )                                                       \n" //1
101"{                                                                          \n" //2
102"    return vec4( 0.3, 0.3, 1.0, 1.0 );                                     \n" //3
103"}                                                                          \n";//4
104
105char PerVertexLightingFragmentShaderSource[] =
106"void lighting( inout vec4 color )                                          \n" //1
107"{                                                                          \n" //2
108"    color = color * gl_Color + gl_SecondaryColor;                          \n" //3
109"}                                                                          \n";//4
110
111char PerFragmentLightingVertexShaderSource[] =
112"varying vec3 Normal;                                                       \n" //1
113"varying vec3 Position;                                                     \n" //2
114"                                                                           \n" //3
115"void lighting( in vec3 position, in vec3 normal )                          \n" //4
116"{                                                                          \n" //5
117"    Normal = normal;                                                       \n" //6
118"    Position = position;                                                   \n" //7
119"}                                                                          \n";//8
120
121char PerFragmentDirectionalLightingFragmentShaderSource[] =
122"varying vec3 Normal;                                                       \n" //1
123"varying vec3 Position; // not used for directional lighting                \n" //2
124"                                                                           \n" //3
125"void lighting( inout vec4 color )                                          \n" //4
126"{                                                                          \n" //5
127"    vec3 n = normalize( Normal );                                          \n" //5
128"    float NdotL = dot( n, normalize(gl_LightSource[0].position.xyz) );     \n" //6
129"    NdotL = max( 0.0, NdotL );                                             \n" //7
130"    float NdotHV = dot( n, gl_LightSource[0].halfVector.xyz );             \n" //8
131"    NdotHV = max( 0.0, NdotHV );                                           \n" //9
132"                                                                           \n" //10
133"    color *= gl_FrontLightModelProduct.sceneColor +                        \n" //11
134"             gl_FrontLightProduct[0].ambient +                             \n" //12
135"             gl_FrontLightProduct[0].diffuse * NdotL;                      \n" //13
136"                                                                           \n" //14
137"    if ( NdotL * NdotHV > 0.0 )                                            \n" //15
138"        color += gl_FrontLightProduct[0].specular *                        \n" //16
139"                 pow( NdotHV, gl_FrontMaterial.shininess );                \n" //17
140"}                                                                          \n";//18
141
142////////////////////////////////////////////////////////////////////////////////
143osg::Node * CreateModel( const char * file )
144{
145    if ( file ) {
146        osg::Node * node = NULL;       
147        node = osgDB::readNodeFile( file );
148        if( node )
149            return node;
150    }
151
152    // File not found - create textured sphere
153    osg::Geode * geode = new osg::Geode;
154    osg::ref_ptr<osg::TessellationHints> hints = new osg::TessellationHints;
155    hints->setDetailRatio( 0.3 );
156
157#if 1
158    osg::ref_ptr<osg::ShapeDrawable> shape = new osg::ShapeDrawable
159        ( new osg::Sphere(osg::Vec3(0.0f, 0.0f, 0.0f), 4.0 ), hints.get() );
160#else
161    osg::ref_ptr<osg::ShapeDrawable> shape = new osg::ShapeDrawable
162        ( new osg::Box( osg::Vec3(-1.0f, -1.0f, -1.0f), 2.0, 2.0, 2.0 ) );
163#endif
164
165    shape->setColor(osg::Vec4(0.8f, 0.8f, 0.8f, 1.0f));
166
167    geode->addDrawable( shape.get() );
168
169    osg::StateSet * stateSet = new osg::StateSet;
170
171    osg::Texture2D * texture =  new osg::Texture2D(
172        osgDB::readImageFile("Images/land_shallow_topo_2048.jpg")
173    );
174
175    osg::Material * material = new osg::Material;
176
177    material->setAmbient
178        ( osg::Material::FRONT_AND_BACK, osg::Vec4( 0.9, 0.9, 0.9, 1.0 ) );
179
180    material->setDiffuse
181        ( osg::Material::FRONT_AND_BACK, osg::Vec4( 0.9, 0.9, 0.9, 1.0 ) );
182
183#if 1
184    material->setSpecular
185        ( osg::Material::FRONT_AND_BACK, osg::Vec4( 0.7, 0.3, 0.3, 1.0 ) );
186
187    material->setShininess( osg::Material::FRONT_AND_BACK, 25 );
188
189#endif
190
191    stateSet->setAttributeAndModes( material );
192    stateSet->setTextureAttributeAndModes( 0,texture, osg::StateAttribute::ON );
193
194    geode->setStateSet( stateSet );
195    return geode;
196}
197////////////////////////////////////////////////////////////////////////////////
198// Convenience method to simplify code a little ...
199void SetVirtualProgramShader( VirtualProgram * virtualProgram,
200                              std::string shader_semantics,
201                              osg::Shader::Type shader_type,
202                              std::string shader_name,
203                              std::string shader_source )
204{
205    osg::Shader * shader = new osg::Shader( shader_type );
206    shader->setName( shader_name );
207    shader->setShaderSource( shader_source );
208    virtualProgram->setShader( shader_semantics, shader );
209}
210///////////////////////////////////////////////////////////////////////////////
211void AddLabel( osg::Group * group, const std::string & label, float offset )
212{
213    osg::Vec3 center( 0, 0, offset * 0.5 );
214    osg::Geode * geode = new osg::Geode;
215
216    // Make sure no program breaks text outputs
217    geode->getOrCreateStateSet()->setAttribute
218      ( new osg::Program, osg::StateAttribute::ON | osg::StateAttribute::PROTECTED );
219
220    // Turn off stage 1 texture set in parent transform (otherwise it darkens text)
221    geode->getOrCreateStateSet()->setTextureMode( 1, GL_TEXTURE_2D, osg::StateAttribute::OFF );
222
223    group->addChild( geode );
224
225    osgText::Text* text = new osgText::Text;
226    geode->addDrawable( text );
227    text->setFont("fonts/times.ttf");
228    text->setCharacterSize( offset * 0.1 );
229    text->setPosition(center);
230    text->setAlignment( osgText::TextBase::CENTER_CENTER );
231    text->setAxisAlignment(osgText::Text::SCREEN);
232
233    osg::Vec4 characterSizeModeColor(1.0f,0.0f,0.5f,1.0f);
234#if 1
235    // reproduce outline bounding box compute problem with backdrop on.
236    text->setBackdropType(osgText::Text::OUTLINE);
237    text->setDrawMode(osgText::Text::TEXT | osgText::Text::BOUNDINGBOX);
238#endif
239
240    text->setText( label );
241}
242////////////////////////////////////////////////////////////////////////////////
243osg::Node * CreateAdvancedHierarchy( const char * file = NULL )
244{
245    osg::Node * model = CreateModel( file );
246    if( !model ) return NULL;
247    float offset = model->getBound().radius() * 1.3; // diameter
248
249    // Create transforms for translated instances of the model
250    osg::MatrixTransform * transformCenterMiddle  = new osg::MatrixTransform( );
251    transformCenterMiddle->setMatrix( osg::Matrix::translate( 0,0, offset * 0.5 ) );
252    transformCenterMiddle->addChild( model );
253
254    osg::MatrixTransform * transformCenterTop  = new osg::MatrixTransform( );
255    transformCenterMiddle->addChild( transformCenterTop );
256    transformCenterTop->setMatrix( osg::Matrix::translate( 0,0,offset ) );
257    transformCenterTop->addChild( model );
258
259    osg::MatrixTransform * transformCenterBottom  = new osg::MatrixTransform( );
260    transformCenterMiddle->addChild( transformCenterBottom );
261    transformCenterBottom->setMatrix( osg::Matrix::translate( 0,0,-offset ) );
262    transformCenterBottom->addChild( model );
263
264    osg::MatrixTransform * transformLeftBottom  = new osg::MatrixTransform( );
265    transformCenterBottom->addChild( transformLeftBottom );
266    transformLeftBottom->setMatrix( osg::Matrix::translate( -offset * 0.8,0, -offset * 0.8 ) );
267    transformLeftBottom->addChild( model );
268
269    osg::MatrixTransform * transformRightBottom  = new osg::MatrixTransform( );
270    transformCenterBottom->addChild( transformRightBottom );
271    transformRightBottom->setMatrix( osg::Matrix::translate( offset * 0.8,0, -offset * 0.8 ) );
272    transformRightBottom->addChild( model );
273
274    // Set default VirtualProgram in root StateSet
275    // With main vertex and main fragment shaders calling
276    // lighting and texture functions defined in aditional shaders
277    // Lighting is done per vertex using simple directional light
278    // Texture uses stage 0 TexCoords and TexMap
279
280    if( 1 )
281    {
282        // NOTE:
283        // duplicating the same semantics name in virtual program
284        // is only possible if its used for shaders of differing types
285        // here for VERTEX and FRAGMENT
286
287        VirtualProgram * vp = new VirtualProgram( );
288        transformCenterMiddle->getOrCreateStateSet()->setAttribute( vp );
289        AddLabel( transformCenterMiddle, "Per Vertex Lighting Virtual Program", offset );
290
291        SetVirtualProgramShader( vp, "main", osg::Shader::VERTEX,
292            "Vertex Main", MainVertexShaderSource );
293
294        SetVirtualProgramShader( vp, "main", osg::Shader::FRAGMENT,
295            "Fragment Main", MainFragmentShaderSource );
296
297        SetVirtualProgramShader( vp, "texture",osg::Shader::VERTEX,
298            "Vertex Texture Coord 0", TexCoordTextureVertexShaderSource );
299
300        SetVirtualProgramShader( vp, "texture",osg::Shader::FRAGMENT,
301            "Fragment Texture", TextureFragmentShaderSource );
302
303        SetVirtualProgramShader( vp, "lighting",osg::Shader::VERTEX,
304            "Vertex Lighting", PerVertexDirectionalLightingVertexShaderSource );
305
306        SetVirtualProgramShader( vp, "lighting",osg::Shader::FRAGMENT,
307            "Fragment Lighting", PerVertexLightingFragmentShaderSource );
308
309        transformCenterMiddle->getOrCreateStateSet()->
310            addUniform( new osg::Uniform( "baseTexture", 0 ) );
311
312    }
313
314    // Override default vertex ligting with pixel lighting shaders
315    // For three bottom models
316    if( 1 )
317    {
318        AddLabel( transformCenterBottom, "Per Pixel Lighting VP", offset );
319        VirtualProgram * vp = new VirtualProgram( );
320        transformCenterBottom->getOrCreateStateSet()->setAttribute( vp );
321
322        SetVirtualProgramShader( vp, "lighting",osg::Shader::VERTEX,
323            "Vertex Shader For Per Pixel Lighting",
324            PerFragmentLightingVertexShaderSource );
325
326        SetVirtualProgramShader( vp, "lighting",osg::Shader::FRAGMENT,
327            "Fragment Shader For Per Pixel Lighting",
328            PerFragmentDirectionalLightingFragmentShaderSource );
329    }
330
331    // Additionaly set bottom left model texture to procedural blue to
332    // better observe smooth speculars done through per pixel lighting
333    if( 1 )
334    {
335        AddLabel( transformLeftBottom, "Blue Tex VP", offset );
336        VirtualProgram * vp = new VirtualProgram( );
337        transformLeftBottom->getOrCreateStateSet()->setAttribute( vp );
338
339        SetVirtualProgramShader( vp, "texture",osg::Shader::FRAGMENT,
340            "Fragment Shader Procedural Blue Tex",
341            ProceduralBlueTextureFragmentShaderSource );
342    }
343
344    // Additionaly change texture mapping to SphereMAp in bottom right model
345    if( 1 )
346    {
347        AddLabel( transformRightBottom, "EnvMap Sphere VP", offset );
348
349        osg::StateSet * ss = transformRightBottom->getOrCreateStateSet();
350        VirtualProgram * vp = new VirtualProgram( );
351        ss->setAttribute( vp );
352        SetVirtualProgramShader( vp, "texture",osg::Shader::VERTEX,
353            "Vertex Texture Sphere Map", SphereMapTextureVertexShaderSource );
354
355        osg::Texture2D * texture =  new osg::Texture2D(
356//            osgDB::readImageFile("Images/reflect.rgb")
357            osgDB::readImageFile("Images/skymap.jpg")
358        );
359
360        // Texture is set on stage 1 to not interfere with label text
361        // The same could be achieved with texture override
362        // but such approach also turns off label texture
363        ss->setTextureAttributeAndModes( 1, texture, osg::StateAttribute::ON );
364        ss->addUniform( new osg::Uniform( "baseTexture", 1 ) );
365
366#if 0 // Could be useful with Fixed Vertex Pipeline
367        osg::TexGen * texGen = new osg::TexGen();
368        texGen->setMode( osg::TexGen::SPHERE_MAP );
369
370        // Texture states applied
371        ss->setTextureAttributeAndModes( 1, texGen, osg::StateAttribute::ON );
372#endif
373
374    }
375
376
377    // Top center model usues osg::Program overriding VirtualProgram in model
378    if( 1 )
379    {
380        AddLabel( transformCenterTop, "Fixed Vertex + Simple Fragment osg::Program", offset );
381        osg::Program * program = new osg::Program;
382        program->setName( "Trivial Fragment + Fixed Vertex Program" );
383
384        transformCenterTop->getOrCreateStateSet( )->setAttributeAndModes
385            ( program, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
386
387        osg::Shader * shader = new osg::Shader( osg::Shader::FRAGMENT );
388        shader->setName( "Trivial Fragment Shader" );
389        shader->setShaderSource(
390            "uniform sampler2D baseTexture;                                          \n"
391            "void main(void)                                                         \n"
392            "{                                                                       \n"
393            "    gl_FragColor = gl_Color * texture2D( baseTexture,gl_TexCoord[0].xy);\n"
394            "}                                                                       \n"
395            );
396
397        program->addShader( shader );
398    }
399
400    return transformCenterMiddle;
401}
402
403////////////////////////////////////////////////////////////////////////////////
404// Shders not used in the example but left for fun if anyone wants to play
405char LightingVertexShaderSource[] =
406"// Forward declarations                                                    \n" //1
407"                                                                           \n" //2
408"void SpotLight( in int i, in vec3 eye, in vec3 position, in vec3 normal,   \n" //3
409"            inout vec4 ambient, inout vec4 diffuse, inout vec4 specular ); \n" //4
410"                                                                           \n" //5
411"void PointLight( in int i, in vec3 eye, in vec3 position, in vec3 normal,  \n" //6
412"            inout vec4 ambient, inout vec4 diffuse, inout vec4 specular ); \n" //7
413"                                                                           \n" //8
414"void DirectionalLight( in int i, in vec3 normal,                           \n" //9
415"            inout vec4 ambient, inout vec4 diffuse, inout vec4 specular ); \n" //10
416"                                                                           \n" //11
417"const int NumEnabledLights = 1;                                            \n" //12
418"                                                                           \n" //13
419"void lighting( in vec3 position, in vec3 normal )                          \n" //14
420"{                                                                          \n" //15
421"    vec3  eye = vec3( 0.0, 0.0, 1.0 );                                     \n" //16
422"    //vec3  eye = -normalize(position);                                    \n" //17
423"                                                                           \n" //18
424"    // Clear the light intensity accumulators                              \n" //19
425"    vec4 amb  = vec4(0.0);                                                 \n" //20
426"    vec4 diff = vec4(0.0);                                                 \n" //21
427"    vec4 spec = vec4(0.0);                                                 \n" //22
428"                                                                           \n" //23
429"    // Loop through enabled lights, compute contribution from each         \n" //24
430"    for (int i = 0; i < NumEnabledLights; i++)                             \n" //25
431"   {                                                                       \n" //26
432"       if (gl_LightSource[i].position.w == 0.0)                            \n" //27
433"           DirectionalLight(i, normal, amb, diff, spec);                   \n" //28
434"       else if (gl_LightSource[i].spotCutoff == 180.0)                     \n" //29
435"           PointLight(i, eye, position, normal, amb, diff, spec);          \n" //30
436"       else                                                                \n" //31
437"           SpotLight(i, eye, position, normal, amb, diff, spec);           \n" //32
438"    }                                                                      \n" //33
439"                                                                           \n" //34
440"    gl_FrontColor = gl_FrontLightModelProduct.sceneColor +                 \n" //35
441"                    amb * gl_FrontMaterial.ambient +                       \n" //36
442"                    diff * gl_FrontMaterial.diffuse;                       \n" //37
443"                                                                           \n" //38
444"    gl_FrontSecondaryColor = vec4(spec*gl_FrontMaterial.specular);         \n" //39
445"                                                                           \n" //40
446"    gl_BackColor = gl_FrontColor;                                          \n" //41
447"    gl_BackSecondaryColor = gl_FrontSecondaryColor;                        \n" //42
448"}                                                                          \n";//43
449
450char SpotLightShaderSource[] =
451"void SpotLight(in int i,                                                   \n" //1
452"               in vec3 eye,                                                \n" //2
453"               in vec3 position,                                           \n" //3
454"               in vec3 normal,                                             \n" //4
455"               inout vec4 ambient,                                         \n" //5
456"               inout vec4 diffuse,                                         \n" //6
457"               inout vec4 specular)                                        \n" //7
458"{                                                                          \n" //8
459"    float nDotVP;          // normal . light direction                     \n" //9
460"    float nDotHV;          // normal . light half vector                   \n" //10
461"    float pf;              // power factor                                 \n" //11
462"    float spotDot;         // cosine of angle between spotlight            \n" //12
463"    float spotAttenuation; // spotlight attenuation factor                 \n" //13
464"    float attenuation;     // computed attenuation factor                  \n" //14
465"    float d;               // distance from surface to light source        \n" //15
466"    vec3 VP;               // direction from surface to light position     \n" //16
467"    vec3 halfVector;       // direction of maximum highlights              \n" //17
468"                                                                           \n" //18
469"    // Compute vector from surface to light position                       \n" //19
470"    VP = vec3(gl_LightSource[i].position) - position;                      \n" //20
471"                                                                           \n" //21
472"    // Compute distance between surface and light position                 \n" //22
473"    d = length(VP);                                                        \n" //23
474"                                                                           \n" //24
475"    // Normalize the vector from surface to light position                 \n" //25
476"    VP = normalize(VP);                                                    \n" //26
477"                                                                           \n" //27
478"    // Compute attenuation                                                 \n" //28
479"    attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +           \n" //29
480"                         gl_LightSource[i].linearAttenuation * d +         \n" //30
481"                         gl_LightSource[i].quadraticAttenuation *d*d);     \n" //31
482"                                                                           \n" //32
483"    // See if point on surface is inside cone of illumination              \n" //33
484"    spotDot = dot(-VP, normalize(gl_LightSource[i].spotDirection));        \n" //34
485"                                                                           \n" //35
486"    if (spotDot < gl_LightSource[i].spotCosCutoff)                         \n" //36
487"        spotAttenuation = 0.0; // light adds no contribution               \n" //37
488"    else                                                                   \n" //38
489"        spotAttenuation = pow(spotDot, gl_LightSource[i].spotExponent);    \n" //39
490"                                                                           \n" //40
491"    // Combine the spotlight and distance attenuation.                     \n" //41
492"    attenuation *= spotAttenuation;                                        \n" //42
493"                                                                           \n" //43
494"    halfVector = normalize(VP + eye);                                      \n" //44
495"                                                                           \n" //45
496"    nDotVP = max(0.0, dot(normal, VP));                                    \n" //46
497"    nDotHV = max(0.0, dot(normal, halfVector));                            \n" //47
498"                                                                           \n" //48
499"    if (nDotVP == 0.0)                                                     \n" //49
500"        pf = 0.0;                                                          \n" //50
501"    else                                                                   \n" //51
502"        pf = pow(nDotHV, gl_FrontMaterial.shininess);                      \n" //52
503"                                                                           \n" //53
504"    ambient  += gl_LightSource[i].ambient * attenuation;                   \n" //54
505"    diffuse  += gl_LightSource[i].diffuse * nDotVP * attenuation;          \n" //55
506"    specular += gl_LightSource[i].specular * pf * attenuation;             \n" //56
507"}                                                                          \n";//57
508
509char PointLightShaderSource[] =
510"void PointLight(in int i,                                                  \n" //1
511"                in vec3 eye,                                               \n" //2
512"                in vec3 position,                                          \n" //3
513"                in vec3 normal,                                            \n" //4
514"                inout vec4 ambient,                                        \n" //5
515"                inout vec4 diffuse,                                        \n" //6
516"                inout vec4 specular)                                       \n" //7
517"{                                                                          \n" //8
518"    float nDotVP;      // normal . light direction                         \n" //9
519"    float nDotHV;      // normal . light half vector                       \n" //10
520"    float pf;          // power factor                                     \n" //11
521"    float attenuation; // computed attenuation factor                      \n" //12
522"    float d;           // distance from surface to light source            \n" //13
523"    vec3  VP;          // direction from surface to light position         \n" //14
524"    vec3  halfVector;  // direction of maximum highlights                  \n" //15
525"                                                                           \n" //16
526"    // Compute vector from surface to light position                       \n" //17
527"    VP = vec3(gl_LightSource[i].position) - position;                      \n" //18
528"                                                                           \n" //19
529"    // Compute distance between surface and light position                 \n" //20
530"    d = length(VP);                                                        \n" //21
531"                                                                           \n" //22
532"    // Normalize the vector from surface to light position                 \n" //23
533"    VP = normalize(VP);                                                    \n" //24
534"                                                                           \n" //25
535"    // Compute attenuation                                                 \n" //26
536"    attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +           \n" //27
537"                         gl_LightSource[i].linearAttenuation * d +         \n" //28
538"                         gl_LightSource[i].quadraticAttenuation * d*d);    \n" //29
539"                                                                           \n" //30
540"    halfVector = normalize(VP + eye);                                      \n" //31
541"                                                                           \n" //32
542"    nDotVP = max(0.0, dot(normal, VP));                                    \n" //33
543"    nDotHV = max(0.0, dot(normal, halfVector));                            \n" //34
544"                                                                           \n" //35
545"    if (nDotVP == 0.0)                                                     \n" //36
546"        pf = 0.0;                                                          \n" //37
547"    else                                                                   \n" //38
548"        pf = pow(nDotHV, gl_FrontMaterial.shininess);                      \n" //39
549"                                                                           \n" //40
550"    ambient += gl_LightSource[i].ambient * attenuation;                    \n" //41
551"    diffuse += gl_LightSource[i].diffuse * nDotVP * attenuation;           \n" //42
552"    specular += gl_LightSource[i].specular * pf * attenuation;             \n" //43
553"}                                                                          \n";//44
554
555char DirectionalLightShaderSource[] =
556"void DirectionalLight(in int i,                                            \n" //1
557"                      in vec3 normal,                                      \n" //2
558"                      inout vec4 ambient,                                  \n" //3
559"                      inout vec4 diffuse,                                  \n" //4
560"                      inout vec4 specular)                                 \n" //5
561"{                                                                          \n" //6
562"     float nDotVP;         // normal . light direction                     \n" //7
563"     float nDotHV;         // normal . light half vector                   \n" //8
564"     float pf;             // power factor                                 \n" //9
565"                                                                           \n" //10
566"     nDotVP = max(0.0, dot(normal,                                         \n" //11
567"                normalize(vec3(gl_LightSource[i].position))));             \n" //12
568"     nDotHV = max(0.0, dot(normal,                                         \n" //13
569"                      vec3(gl_LightSource[i].halfVector)));                \n" //14
570"                                                                           \n" //15
571"     if (nDotVP == 0.0)                                                    \n" //16
572"         pf = 0.0;                                                         \n" //17
573"     else                                                                  \n" //18
574"         pf = pow(nDotHV, gl_FrontMaterial.shininess);                     \n" //19
575"                                                                           \n" //20
576"     ambient  += gl_LightSource[i].ambient;                                \n" //21
577"     diffuse  += gl_LightSource[i].diffuse * nDotVP;                       \n" //22
578"     specular += gl_LightSource[i].specular * pf;                          \n" //23
579"}                                                                          \n";//24
Note: See TracBrowser for help on using the browser.