root/OpenSceneGraph/trunk/examples/osgvirtualprogram/CreateAdvancedHierachy.cpp @ 10271

Revision 10271, 34.0 kB (checked in by robert, 6 years ago)

Fixed warnings

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