Context Navigation

CreateAdvancedHierachy.cpp @ 10284

Revision 10284, 33.4 kB (checked in by robert, 4 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
18	using 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
30	char 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
44	char 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
50	char 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
59	char 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
81	char 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
92	char 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
99	char 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
105	char 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
111	char 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
121	char 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	////////////////////////////////////////////////////////////////////////////////
143	osg::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 ...
199	void 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	///////////////////////////////////////////////////////////////////////////////
211	void 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	////////////////////////////////////////////////////////////////////////////////
243	osg::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
405	char 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(specgl_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
450	char 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 dd); \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
509	char 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 dd); \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
555	char 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.

Context Navigation

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

Download in other formats: