?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / System / State / Shader / Chunks / OSGShaderExecutableChunk.cpp
blobeb13b5ca9f0c05490670ca279ab9f7c0b3a8f80c
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2006 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 //---------------------------------------------------------------------------
40 // Includes
41 //---------------------------------------------------------------------------
42
43 #include <cstdlib>
44 #include <cstdio>
45
46 #include <boost/bind.hpp>
47
48 #include "OSGConfig.h"
49
50 #include "OSGShaderExecutableChunk.h"
51 #include "OSGShaderProgramChunk.h"
52 #include "OSGShaderVariables.h"
53
54 #include "OSGGLFuncProtos.h"
55 #include "OSGConceptPropertyChecks.h"
56
57 OSG_BEGIN_NAMESPACE
58
59 // Documentation for this class is emitted in the
60 // OSGShaderExecutableChunkBase.cpp file.
61 // To modify it, please change the .fcd file (OSGShaderExecutableChunk.fcd) and
62 // regenerate the base file.
63
64 /***************************************************************************\
65 * Class variables *
66 \***************************************************************************/
67
68 StateChunkClass ShaderExecutableChunk::_class("ShaderExecutable", 1, 7);
69 volatile UInt16 ShaderExecutableChunk::_uiChunkCounter = 1;
70
71 UInt32 ShaderExecutableChunk::_extSHL = Window::invalidExtensionID;
72
73 /***************************************************************************\
74 * Class methods *
75 \***************************************************************************/
76
77 void ShaderExecutableChunk::initMethod(InitPhase ePhase)
78 {
79 Inherited::initMethod(ePhase);
80
81 if(ePhase == TypeObject::SystemPost)
82 {
83 _extSHL = Window::registerExtension("GL_ARB_shading_language_100");
84 }
85 }
86
87 void ShaderExecutableChunk::resolveLinks(void)
88 {
89 FragmentShaderIt fIt = _mfFragmentShader.begin();
90 FragmentShaderIt fEnd = _mfFragmentShader.end ();
91
92 for(; fIt != fEnd; ++fIt)
93 {
94 if(*fIt != NULL)
95 (*fIt)->subParent(this);
96 }
97
98 GeometryShaderIt gIt = _mfGeometryShader.begin();
99 GeometryShaderIt gEnd = _mfGeometryShader.end ();
100
101 for(; gIt != gEnd; ++gIt)
102 {
103 if(*gIt != NULL)
104 (*gIt)->subParent(this);
105 }
106
107 TessEvalShaderIt teIt = _mfTessEvaluationShader.begin();
108 TessEvalShaderIt teEnd = _mfTessEvaluationShader.end ();
109
110 for(; teIt != teEnd; ++teIt)
111 {
112 if(*teIt != NULL)
113 (*teIt)->subParent(this);
114 }
115
116 TessControlShaderIt tcIt = _mfTessControlShader.begin();
117 TessControlShaderIt tcEnd = _mfTessControlShader.end ();
118
119 for(; tcIt != tcEnd; ++tcIt)
120 {
121 if(*tcIt != NULL)
122 (*tcIt)->subParent(this);
123 }
124
125 VertexShaderIt vIt = _mfVertexShader.begin();
126 VertexShaderIt vEnd = _mfVertexShader.end ();
127
128 for(; vIt != vEnd; ++vIt)
129 {
130 if(*vIt != NULL)
131 (*vIt)->subParent(this);
132 }
133
134 Inherited::resolveLinks();
135 }
136
137 /***************************************************************************\
138 * Instance methods *
139 \***************************************************************************/
140
141 /*-------------------------------------------------------------------------*\
142 - private -
143 \*-------------------------------------------------------------------------*/
144
145 /*----------------------- constructors & destructors ----------------------*/
146
147 ShaderExecutableChunk::ShaderExecutableChunk(void) :
148 Inherited( ),
149 _uiChunkId(0)
150 {
151 }
152
153 ShaderExecutableChunk::ShaderExecutableChunk(
154 const ShaderExecutableChunk &source) :
155
156 Inherited(source),
157 _uiChunkId(0 )
158 {
159 }
160
161 ShaderExecutableChunk::~ShaderExecutableChunk(void)
162 {
163 }
164
165 void ShaderExecutableChunk::onCreate(const ShaderExecutableChunk *source)
166 {
167 Inherited::onCreate(source);
168
169 // ignore prototypes.
170 if(GlobalSystemState == Startup)
171 return;
172
173 setGLId(
174 Window::registerGLObject(
175 boost::bind(&ShaderExecutableChunk::handleGL,
176 ShaderExecutableChunkMTUncountedPtr(this),
177 _1, _2, _3, _4),
178 &ShaderExecutableChunk::handleDestroyGL));
179
180 _uiChunkId = _uiChunkCounter++;
181 }
182
183 void ShaderExecutableChunk::onCreateAspect(
184 const ShaderExecutableChunk *createAspect,
185 const ShaderExecutableChunk *source )
186 {
187 Inherited::onCreateAspect(createAspect, source);
188
189 _uiChunkId = createAspect->_uiChunkId;
190 }
191
192 void ShaderExecutableChunk::onDestroy(UInt32 uiId)
193 {
194 if(getGLId() > 0)
195 Window::destroyGLObject(getGLId(), 1);
196
197 Inherited::onDestroy(uiId);
198 }
199
200 const StateChunkClass *ShaderExecutableChunk::getClass(void) const
201 {
202 return &_class;
203 }
204
205 UInt16 ShaderExecutableChunk::getChunkId(void)
206 {
207 return _uiChunkId;
208 }
209
210 UInt32 ShaderExecutableChunk::handleGL(DrawEnv *pEnv,
211 UInt32 id,
212 Window::GLObjectStatusE mode,
213 UInt64 uiOptions)
214 {
215 UInt32 returnValue = 0;
216 Window *pWin = pEnv->getWindow();
217
218 if(!pWin->hasExtOrVersion(_extSHL, 0x0200, 0x0200))
219 {
220 FWARNING(("OpenGL Shading Language is not supported, couldn't find "
221 "extension 'GL_ARB_shading_language_100'!\n"));
222
223 pWin->setGLObjectId(getGLId(), 0);
224
225 return returnValue;
226 }
227
228 if(mode == Window::initialize ||
229 mode == Window::reinitialize ||
230 mode == Window::needrefresh )
231 {
232 GLuint uiProgram = GLuint(pWin->getGLObjectId(getGLId()));;
233
234 if(mode != Window::needrefresh)
235 {
236 if(uiProgram != 0)
237 {
238 OSGGETGLFUNCBYID_GL3_ES(
239 glDeleteProgram,
240 osgGlDeleteProgram,
241 ShaderProgram::getFuncIdDeleteProgram(),
242 pWin);
243
244 osgGlDeleteProgram(uiProgram);
245 }
246
247 OSGGETGLFUNCBYID_GL3_ES(glCreateProgram,
248 osgGlCreateProgram,
249 ShaderProgram::getFuncIdCreateProgram(),
250 pWin);
251
252 OSGGETGLFUNCBYID_GL3_ES(glAttachShader,
253 osgGlAttachShader,
254 ShaderProgram::getFuncIdAttachShader(),
255 pWin);
256
257 OSGGETGLFUNCBYID_GL3_ES(glLinkProgram,
258 osgGlLinkProgram,
259 ShaderProgram::getFuncIdLinkProgram(),
260 pWin);
261
262 uiProgram = osgGlCreateProgram();
263
264 FragmentShaderIt fIt = _mfFragmentShader.begin();
265 FragmentShaderIt fEnd = _mfFragmentShader.end ();
266
267 for(; fIt != fEnd; ++fIt)
268 {
269 (*fIt)->validate(pEnv);
270
271 GLuint uiShader =
272 GLuint(pWin->getGLObjectId((*fIt)->getGLId()));
273
274 if(uiShader != 0)
275 osgGlAttachShader(uiProgram, uiShader);
276 }
277
278 std::vector<const Char8 *> vTFVaryings;
279 UInt32 uiVaryingBufferIndex = 0;
280
281 GeometryShaderIt gIt = _mfGeometryShader.begin();
282 GeometryShaderIt gEnd = _mfGeometryShader.end ();
283
284 for(; gIt != gEnd; ++gIt)
285 {
286 (*gIt)->validate(pEnv);
287
288 GLuint uiShader =
289 GLuint(pWin->getGLObjectId((*gIt)->getGLId()));
290
291 if(uiShader != 0)
292 {
293 osgGlAttachShader(uiProgram, uiShader);
294
295 (*gIt)->accumulateFeedback(pEnv,
296 uiProgram,
297 vTFVaryings,
298 uiVaryingBufferIndex);
299 }
300 }
301
302 TessEvalShaderIt teIt = _mfTessEvaluationShader.begin();
303 TessEvalShaderIt teEnd = _mfTessEvaluationShader.end ();
304
305 for(; teIt != teEnd; ++teIt)
306 {
307 (*teIt)->validate(pEnv);
308
309 GLuint uiShader =
310 GLuint(pWin->getGLObjectId((*teIt)->getGLId()));
311
312 if(uiShader != 0)
313 osgGlAttachShader(uiProgram, uiShader);
314 }
315
316
317 TessControlShaderIt tcIt = _mfTessControlShader.begin();
318 TessControlShaderIt tcEnd = _mfTessControlShader.end ();
319
320 for(; tcIt != tcEnd; ++tcIt)
321 {
322 (*tcIt)->validate(pEnv);
323
324 GLuint uiShader =
325 GLuint(pWin->getGLObjectId((*tcIt)->getGLId()));
326
327 if(uiShader != 0)
328 osgGlAttachShader(uiProgram, uiShader);
329 }
330
331
332 VertexShaderIt vIt = _mfVertexShader.begin();
333 VertexShaderIt vEnd = _mfVertexShader.end ();
334
335 for(; vIt != vEnd; ++vIt)
336 {
337 (*vIt)->validate(pEnv);
338
339 GLuint uiShader =
340 GLuint(pWin->getGLObjectId((*vIt)->getGLId()));
341
342 if(uiShader != 0)
343 osgGlAttachShader(uiProgram, uiShader);
344 }
345
346 if(vTFVaryings.size() != 0)
347 {
348 OSGGETGLFUNCBYID_GL3(
349 glTransformFeedbackVaryings,
350 osgGlTransformFeedbackVaryings,
351 ShaderProgram::getFuncIdTransformFeedbackVaryings(),
352 pEnv->getWindow() );
353
354 osgGlTransformFeedbackVaryings(uiProgram,
355 GLsizei(vTFVaryings.size()),
356 &(vTFVaryings.front()),
357 GL_INTERLEAVED_ATTRIBS);
358 }
359
360 // attribute binding must be done before linking
361 updateAttribBindings(pEnv, uiProgram);
362
363 // parameters must be set before linking
364 updateParameters(pEnv, uiProgram);
365
366 osgGlLinkProgram(uiProgram);
367
368 GLint iInfoLength;
369 Char8 *szInfoBuffer = NULL;
370
371 OSGGETGLFUNCBYID_GL3_ES(glGetProgramiv,
372 osgGlGetProgramiv,
373 ShaderProgram::getFuncIdGetProgramiv(),
374 pWin);
375
376 osgGlGetProgramiv(uiProgram,
377 GL_OBJECT_INFO_LOG_LENGTH_ARB,
378 &iInfoLength);
379
380 if(iInfoLength > 0)
381 {
382 szInfoBuffer = new Char8[iInfoLength];
383 szInfoBuffer[0] = '\0';
384
385 OSGGETGLFUNCBYID_GL3_ES(
386 glGetProgramInfoLog,
387 osgGlGetProgramInfoLog,
388 ShaderProgram::getFuncIdGetProgramInfoLog(),
389 pWin);
390
391 osgGlGetProgramInfoLog( uiProgram,
392 iInfoLength,
393 &iInfoLength,
394 szInfoBuffer);
395 }
396
397 GLint iStatus = 0;
398
399 osgGlGetProgramiv(uiProgram, GL_LINK_STATUS, &iStatus);
400
401 GLint iNumAttribs = 0;
402 GLint iMaxAttribLength = 0;
403
404 osgGlGetProgramiv(uiProgram, GL_ACTIVE_ATTRIBUTES, &iNumAttribs);
405
406 osgGlGetProgramiv( uiProgram,
407 GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
408 &iMaxAttribLength);
409
410 if(iMaxAttribLength > 0)
411 {
412 Char8 *szAttribBuffer = NULL;
413 GLsizei iNameLength;
414 GLint iSizeTmp;
415 GLenum eTypeTmp;
416
417 szAttribBuffer = new Char8[iMaxAttribLength];
418 szAttribBuffer[0] = '\0';
419
420 OSGGETGLFUNCBYID_GL3_ES(
421 glGetActiveAttrib,
422 osgGlGetActiveAttrib,
423 ShaderProgram::getFuncIdGetActiveAttrib(),
424 pWin);
425
426 for(GLint i = 0; i < iNumAttribs; ++i)
427 {
428 osgGlGetActiveAttrib( uiProgram,
429 i,
430 iMaxAttribLength,
431 &iNameLength,
432 &iSizeTmp,
433 &eTypeTmp,
434 szAttribBuffer);
435
436 if(iNameLength != 0)
437 {
438 if(iNameLength < 3 ||
439 szAttribBuffer[0] != 'g' ||
440 szAttribBuffer[1] != 'l' ||
441 szAttribBuffer[2] != '_' )
442 {
443 pWin->setGLObjectInfo(getGLId(), UsesAttribs);
444
445 break;
446 }
447
448 }
449 }
450
451 delete [] szAttribBuffer;
452 }
453
454 if(iStatus == 0)
455 {
456 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
457 {
458 FFATAL(("Couldn't link vertex and fragment program!\n%s\n",
459 szInfoBuffer));
460
461 #ifdef OSG_DEBUG
462 if(!getMFVertexShader()->empty())
463 {
464 SINFO << "Vertex Shader Code:\n";
465
466 vIt = getMFVertexShader()->begin();
467 vEnd = getMFVertexShader()->end ();
468
469 for(; vIt != vEnd; ++vIt)
470 {
471 PINFO << (*vIt)->getProgram()
472 << "\n";
473 }
474 }
475
476 if(!getMFTessControlShader()->empty())
477 {
478 SINFO << "TessControl Shader Code:\n";
479
480 tcIt = getMFTessControlShader()->begin();
481 tcEnd = getMFTessControlShader()->end ();
482
483 for(; tcIt != tcEnd; ++tcIt)
484 {
485 PINFO << (*tcIt)->getProgram()
486 << "\n";
487 }
488 }
489
490 if(!getMFTessEvaluationShader()->empty())
491 {
492 SINFO << "TessEvaluation Shader Code:\n";
493
494 teIt = getMFTessEvaluationShader()->begin();
495 teEnd = getMFTessEvaluationShader()->end ();
496
497 for(; teIt != teEnd; ++teIt)
498 {
499 PINFO << (*teIt)->getProgram()
500 << "\n";
501 }
502 }
503
504 if(!getMFGeometryShader()->empty())
505 {
506 SINFO << "Geometry Shader Code:\n";
507
508 gIt = getMFGeometryShader()->begin();
509 gEnd = getMFGeometryShader()->end ();
510
511 for(; gIt != gEnd; ++gIt)
512 {
513 PINFO << (*gIt)->getProgram()
514 << "\n";
515 }
516 }
517
518 if(!getMFFragmentShader()->empty())
519 {
520 SINFO << "Fragment Shader Code:\n";
521
522 fIt = getMFFragmentShader()->begin();
523 fEnd = getMFFragmentShader()->end ();
524
525 for(; fIt != fEnd; ++fIt)
526 {
527 PINFO << (*fIt)->getProgram()
528 << "\n";
529 }
530 }
531 #endif // OSG_DEBUG
532 }
533 else
534 {
535 FFATAL(("Couldn't link vertex and fragment program!\n"
536 "No further info available\n"));
537 }
538
539 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
540 osgGlDeleteProgram,
541 ShaderProgram::getFuncIdDeleteProgram(),
542 pWin);
543
544 osgGlDeleteProgram(uiProgram);
545
546 uiProgram = 0;
547 }
548 else
549 {
550 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
551 {
552 FWARNING(("SHLChunk: link status: %s\n", szInfoBuffer));
553 }
554 }
555
556 pWin->setGLObjectId(getGLId(), uiProgram);
557
558 updateVariableLocations(pEnv, uiProgram);
559
560 delete [] szInfoBuffer;
561 }
562
563 if(uiProgram != 0)
564 {
565 OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
566 osgGlUseProgram,
567 ShaderProgram::getFuncIdUseProgram(),
568 pWin);
569
570 pEnv->setActiveShader(uiProgram);
571 osgGlUseProgram (uiProgram);
572
573 updateVariables(pEnv, uiProgram);
574
575 if(0x0000 == (uiOptions & KeepProgActive))
576 {
577 pEnv->setActiveShader(0);
578 osgGlUseProgram (0);
579 }
580 else
581 {
582 returnValue |= ProgActive;
583 }
584 }
585 }
586
587 return returnValue;
588 }
589
590 void ShaderExecutableChunk::handleDestroyGL(DrawEnv *pEnv,
591 UInt32 id,
592 Window::GLObjectStatusE mode)
593 {
594 Window *pWin = pEnv->getWindow();
595
596 if(!pWin->hasExtOrVersion(_extSHL, 0x0200, 0x0200))
597 {
598 FWARNING(("OpenGL Shading Language is not supported, couldn't find "
599 "extension 'GL_ARB_shading_language_100'!\n"));
600
601 pWin->setGLObjectId(id, 0);
602
603 return;
604 }
605
606 // BUG this is not called for every window!
607 if(mode == Window::destroy)
608 {
609 GLuint uiProgram = GLuint(pWin->getGLObjectId(id));
610
611 if(uiProgram != 0)
612 {
613 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
614 osgGlDeleteProgram,
615 ShaderProgram::getFuncIdDeleteProgram(),
616 pWin);
617
618 osgGlDeleteProgram(uiProgram);
619
620 pWin->setGLObjectId(id, 0);
621 }
622 }
623 else if(mode == Window::finaldestroy)
624 {
625 ;//SWARNING << "Last program user destroyed" << std::endl;
626 }
627 }
628
629 /*----------------------------- class specific ----------------------------*/
630
631 void ShaderExecutableChunk::changed(ConstFieldMaskArg whichField,
632 UInt32 origin,
633 BitVector details)
634 {
635 bool bMarkChanged = false;
636
637 if(0x0000 != (whichField & VariablesFieldMask))
638 {
639 ShaderProgramVariables *pVars = _sfVariables.getValue();
640
641 if(pVars != NULL)
642 {
643 if(details == 0x0001)
644 {
645 // be save reset all locations
646
647 if(pVars->getMFVariables()->size() == 0)
648 {
649 editMFVariableLocations()->clear();
650 }
651 else
652 {
653 editMFVariableLocations()->resize(
654 pVars->getMFVariables()->size(),
655 -1);
656
657 std::fill(editMFVariableLocations()->begin(),
658 editMFVariableLocations()->end (),
659 -1);
660 }
661
662 // be save reset all locations
663
664 if(pVars->getMFProceduralVariables()->size() == 0 )
665 {
666 editMFProceduralVariableLocations()->clear();
667 }
668 else
669 {
670 editMFProceduralVariableLocations()->resize(
671 pVars->getMFProceduralVariables()->size(),
672 -1);
673
674 std::fill(editMFProceduralVariableLocations()->begin(),
675 editMFProceduralVariableLocations()->end (),
676 -1);
677 }
678 }
679 }
680
681 Window::refreshGLObject(this->getGLId());
682 }
683
684 if(0x0000 != (whichField & (VertexShaderFieldMask |
685 GeometryShaderFieldMask |
686 FragmentShaderFieldMask )))
687 {
688 if(details == ShaderProgram::ProgramFieldMask)
689 {
690 Window::reinitializeGLObject(this->getGLId());
691 }
692
693 else if(details == ShaderProgram::VariablesFieldMask)
694 {
695 this->remergeVariables();
696
697 Window::refreshGLObject(this->getGLId());
698 }
699
700 bMarkChanged = true;
701 }
702
703 if(0x0000 != (whichField & (GeometryVerticesOutFieldMask |
704 GeometryInputTypeFieldMask |
705 GeometryOutputTypeFieldMask )))
706 {
707 // changing parameters requires re-linking the shader
708 Window::reinitializeGLObject(this->getGLId());
709 }
710
711 if(bMarkChanged == true)
712 {
713 // be save reset all locations
714
715 std::fill(editMFVariableLocations()->begin(),
716 editMFVariableLocations()->end (),
717 -1);
718
719 std::fill(editMFProceduralVariableLocations()->begin(),
720 editMFProceduralVariableLocations()->end (),
721 -1);
722
723 if(_sfVariables.getValue() != NULL)
724 {
725 _sfVariables.getValue()->markAllChanged();
726 }
727 }
728
729 Inherited::changed(whichField, origin, details);
730 }
731
732 void ShaderExecutableChunk::dump( UInt32 ,
733 const BitVector ) const
734 {
735 SLOG << "Dump ShaderExecutableChunk NI" << std::endl;
736 }
737
738 void ShaderExecutableChunk::activate(DrawEnv *pEnv,
739 UInt32 uiIdx)
740 {
741 Window *pWin = pEnv->getWindow();
742 UInt32 uiValRes = pWin->validateGLObject(getGLId(),
743 pEnv,
744 KeepProgActive);
745
746 GLuint uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
747
748 if(uiProgId == 0)
749 return;
750
751 if(0x0000 == (uiValRes & ProgActive))
752 {
753 OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
754 osgGlUseProgram,
755 ShaderProgram::getFuncIdUseProgram(),
756 pWin);
757
758 pEnv->setActiveShader(uiProgId);
759 osgGlUseProgram (uiProgId);
760 }
761
762 if(_mfAttributes.size() == 0 &&
763 (pWin->getGLObjectInfo(getGLId()) & UsesAttribs) == 0x0000 )
764 {
765 pEnv->addRequiredOGLFeature(HardwareContext::HasAttribAliasing);
766 }
767
768 pEnv->incNumShaderChanges();
769
770 updateProceduralVariables(pEnv, ShaderProcVariable::SHDAll);
771
772 if(_sfPointSize.getValue() == true)
773 {
774 glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
775 }
776 }
777
778 void ShaderExecutableChunk::changeFrom(DrawEnv *pEnv,
779 StateChunk *pOther,
780 UInt32 uiIdx)
781 {
782 ShaderExecutableChunk *pOld = dynamic_cast<ShaderExecutableChunk *>(pOther);
783
784 // pOther can be a SimpleSHLChunk, since we share our StateClass id with it
785 if(pOld != NULL)
786 {
787 Window *pWin = pEnv->getWindow();
788 GLuint uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
789
790 UInt32 uiDep = ShaderProcVariable::SHDObject;
791
792 if(uiProgId != pEnv->getActiveShader())
793 {
794 UInt32 uiValRes = pWin->validateGLObject(getGLId(),
795 pEnv,
796 KeepProgActive);
797
798
799 uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
800
801 if(uiProgId == 0)
802 return;
803
804 if(0x0000 == (uiValRes & ProgActive))
805 {
806 OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
807 osgGlUseProgram,
808 ShaderProgram::getFuncIdUseProgram(),
809 pWin);
810
811 pEnv->setActiveShader(uiProgId);
812 osgGlUseProgram (uiProgId);
813 }
814
815 if(_mfAttributes.size() == 0 &&
816 (pWin->getGLObjectInfo(getGLId()) & UsesAttribs) == 0x0000 )
817 {
818 pEnv->addRequiredOGLFeature(
819 HardwareContext::HasAttribAliasing);
820 }
821
822 if(_sfPointSize.getValue() == true)
823 {
824 if(pOld->getPointSize() == false)
825 {
826 glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
827 }
828 }
829 else
830 {
831 if(pOld->getPointSize() == true)
832 {
833 glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
834 }
835 }
836
837 uiDep = ShaderProcVariable::SHDAll;
838
839 pEnv->incNumShaderChanges();
840 }
841
842 updateProceduralVariables(pEnv, uiDep);
843 }
844 else
845 {
846 pOther->deactivate(pEnv, uiIdx);
847 activate (pEnv, uiIdx);
848
849 pEnv->incNumShaderChanges();
850 }
851 }
852
853 void ShaderExecutableChunk::deactivate(DrawEnv *pEnv,
854 UInt32 uiIdx)
855 {
856 if(pEnv->getWindow()->getGLObjectId(getGLId()) == 0)
857 return;
858
859 OSGGETGLFUNC_GL3_ES(glUseProgram,
860 osgGlUseProgram,
861 ShaderProgram::getFuncIdUseProgram());
862
863 if(_sfPointSize.getValue() == true)
864 {
865 glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
866 }
867
868 pEnv->setActiveShader(0);
869
870 pEnv->subRequiredOGLFeature(HardwareContext::HasAttribAliasing);
871
872 if(pEnv->_openGLState.isTransformFeedbackActive() == true)
873 {
874 pEnv->_openGLState.setTransformFeedbackInactive();
875
876 OSGGETGLFUNCBYID_GL3(glEndTransformFeedback,
877 osgGlEndTransformFeedback,
878 ShaderProgram::getFuncIdEndTransformFeedback(),
879 pEnv->getWindow());
880
881 osgGlEndTransformFeedback();
882 }
883
884 osgGlUseProgram(0);
885 }
886
887 void ShaderExecutableChunk::updateObjectDependencies(DrawEnv *pEnv,
888 UInt32 index)
889 {
890 updateProceduralVariables(pEnv, ShaderProcVariable::SHDObject);
891 }
892
893 void ShaderExecutableChunk::merge(const ShaderProgramChunk *pChunk)
894 {
895 editMField(VertexShaderFieldMask, _mfVertexShader );
896 editMField(TessControlShaderFieldMask, _mfTessControlShader );
897 editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
898 editMField(GeometryShaderFieldMask, _mfGeometryShader );
899 editMField(FragmentShaderFieldMask, _mfFragmentShader );
900 editMField(AttributesFieldMask, _mfAttributes );
901
902 if(_sfVariables.getValue() == NULL)
903 {
904 ShaderProgramVariablesUnrecPtr pVar =
905 ShaderProgramVariables::createDependent(
906 this->getFieldFlags()->_bNamespaceMask);
907
908 setVariables(pVar);
909 }
910
911 _mfVertexShader.reserve(_mfVertexShader.size() +
912 pChunk->getMFVertexShader()->size());
913
914 ShaderProgramChunk::MFVertexShaderType::const_iterator sIt =
915 pChunk->getMFVertexShader()->begin();
916
917 ShaderProgramChunk::MFVertexShaderType::const_iterator sEnd =
918 pChunk->getMFVertexShader()->end();
919
920 _mfAttributes.clear();
921
922 bool bPointSize = false;
923
924 for(; sIt != sEnd; ++sIt)
925 {
926 (*sIt)->addParent(this, VertexShaderFieldId);
927
928 _mfVertexShader.push_back(*sIt);
929
930 _sfVariables.getValue()->merge(
931 (*sIt)->getVariables(),
932 this->editMFVariableLocations(),
933 this->editMFProceduralVariableLocations());
934
935 bPointSize |= (*sIt)->getPointSize();
936
937 if((*sIt)->hasAttributes() == true)
938 {
939 _mfAttributes.reserve(_mfAttributes.size() +
940 (*sIt)->getMFAttributes()->size());
941
942 _mfAttributes.insert(_mfAttributes.end(),
943 (*sIt)->getMFAttributes()->begin(),
944 (*sIt)->getMFAttributes()->end ());
945 }
946 }
947
948 if(bPointSize != _sfPointSize.getValue())
949 {
950 this->setPointSize(bPointSize);
951 }
952
953 _mfTessControlShader.reserve(_mfTessControlShader.size() +
954 pChunk->getMFTessControlShader()->size());
955
956 sIt = pChunk->getMFTessControlShader()->begin();
957 sEnd = pChunk->getMFTessControlShader()->end ();
958
959 for(; sIt != sEnd; ++sIt)
960 {
961 (*sIt)->addParent(this, TessControlShaderFieldId);
962
963 _mfTessControlShader.push_back(*sIt);
964
965 _sfVariables.getValue()->merge(
966 (*sIt)->getVariables(),
967 this->editMFVariableLocations(),
968 this->editMFProceduralVariableLocations());
969 }
970
971 _mfTessEvaluationShader.reserve(
972 _mfTessEvaluationShader.size() +
973 pChunk->getMFTessEvaluationShader()->size());
974
975 sIt = pChunk->getMFTessEvaluationShader()->begin();
976 sEnd = pChunk->getMFTessEvaluationShader()->end ();
977
978 for(; sIt != sEnd; ++sIt)
979 {
980 (*sIt)->addParent(this, TessEvaluationShaderFieldId);
981
982 _mfTessEvaluationShader.push_back(*sIt);
983
984 _sfVariables.getValue()->merge(
985 (*sIt)->getVariables(),
986 this->editMFVariableLocations(),
987 this->editMFProceduralVariableLocations());
988 }
989
990
991
992 _mfGeometryShader.reserve(_mfGeometryShader.size() +
993 pChunk->getMFGeometryShader()->size());
994
995 sIt = pChunk->getMFGeometryShader()->begin();
996 sEnd = pChunk->getMFGeometryShader()->end ();
997
998 for(; sIt != sEnd; ++sIt)
999 {
1000 (*sIt)->addParent(this, GeometryShaderFieldId);
1001
1002 _mfGeometryShader.push_back(*sIt);
1003
1004 _sfVariables.getValue()->merge(
1005 (*sIt)->getVariables(),
1006 this->editMFVariableLocations(),
1007 this->editMFProceduralVariableLocations());
1008
1009 if((*sIt)->hasParameter() == true)
1010 {
1011 ShaderProgram::MFParameterType::const_iterator pIt =
1012 (*sIt)->getMFParameter()->begin();
1013
1014 ShaderProgram::MFParameterType::const_iterator pEnd =
1015 (*sIt)->getMFParameter()->end ();
1016
1017 while(pIt != pEnd)
1018 {
1019 switch(pIt->first)
1020 {
1021 case GL_GEOMETRY_INPUT_TYPE_EXT:
1022 this->setGeometryInputType(pIt->second);
1023 break;
1024
1025 case GL_GEOMETRY_OUTPUT_TYPE_EXT:
1026 this->setGeometryOutputType(pIt->second);
1027 break;
1028
1029 case GL_GEOMETRY_VERTICES_OUT_EXT:
1030 this->setGeometryVerticesOut(pIt->second);
1031 break;
1032 }
1033
1034 ++pIt;
1035 }
1036 }
1037 }
1038
1039
1040 _mfFragmentShader.reserve(_mfFragmentShader.size() +
1041 pChunk->getMFFragmentShader()->size());
1042
1043 sIt = pChunk->getMFFragmentShader()->begin();
1044 sEnd = pChunk->getMFFragmentShader()->end ();
1045
1046 for(; sIt != sEnd; ++sIt)
1047 {
1048 (*sIt)->addParent(this, FragmentShaderFieldId);
1049
1050 _mfFragmentShader.push_back(*sIt);
1051
1052 _sfVariables.getValue()->merge(
1053 (*sIt)->getVariables(),
1054 this->editMFVariableLocations(),
1055 this->editMFProceduralVariableLocations());
1056 }
1057 }
1058
1059 void ShaderExecutableChunk::remergeVariables(void)
1060 {
1061 OSG_ASSERT(_sfVariables.getValue() != NULL);
1062
1063 _sfVariables.getValue()->clearVariables();
1064 _sfVariables.getValue()->clearProceduralVariables();
1065
1066 this->editMFVariableLocations ()->clear();
1067 this->editMFProceduralVariableLocations()->clear();
1068
1069
1070 ShaderExecutableChunk::MFVertexShaderType::const_iterator sIt =
1071 _mfVertexShader.begin();
1072
1073 ShaderExecutableChunk::MFVertexShaderType::const_iterator sEnd =
1074 _mfVertexShader.end();
1075
1076
1077 for(; sIt != sEnd; ++sIt)
1078 {
1079 if(*sIt != NULL)
1080 {
1081 _sfVariables.getValue()->merge(
1082 (*sIt)->getVariables(),
1083 this->editMFVariableLocations(),
1084 this->editMFProceduralVariableLocations());
1085 }
1086 }
1087
1088
1089
1090 sIt = _mfTessControlShader.begin();
1091 sEnd = _mfTessControlShader.end ();
1092
1093 for(; sIt != sEnd; ++sIt)
1094 {
1095 if(*sIt != NULL)
1096 {
1097 _sfVariables.getValue()->merge(
1098 (*sIt)->getVariables(),
1099 this->editMFVariableLocations (),
1100 this->editMFProceduralVariableLocations());
1101 }
1102 }
1103
1104
1105
1106 sIt = _mfTessEvaluationShader.begin();
1107 sEnd = _mfTessEvaluationShader.end ();
1108
1109 for(; sIt != sEnd; ++sIt)
1110 {
1111 if(*sIt != NULL)
1112 {
1113 _sfVariables.getValue()->merge(
1114 (*sIt)->getVariables(),
1115 this->editMFVariableLocations (),
1116 this->editMFProceduralVariableLocations());
1117 }
1118 }
1119
1120
1121
1122 sIt = _mfGeometryShader.begin();
1123 sEnd = _mfGeometryShader.end ();
1124
1125 for(; sIt != sEnd; ++sIt)
1126 {
1127 if(*sIt != NULL)
1128 {
1129 _sfVariables.getValue()->merge(
1130 (*sIt)->getVariables(),
1131 this->editMFVariableLocations (),
1132 this->editMFProceduralVariableLocations());
1133 }
1134 }
1135
1136
1137
1138 sIt = _mfFragmentShader.begin();
1139 sEnd = _mfFragmentShader.end ();
1140
1141 for(; sIt != sEnd; ++sIt)
1142 {
1143 if(*sIt != NULL)
1144 {
1145 _sfVariables.getValue()->merge(
1146 (*sIt)->getVariables(),
1147 this->editMFVariableLocations (),
1148 this->editMFProceduralVariableLocations());
1149 }
1150 }
1151 }
1152
1153 void ShaderExecutableChunk::updateVariableLocations(DrawEnv *pEnv,
1154 UInt32 uiProgram)
1155 {
1156 if(uiProgram == 0)
1157 return;
1158
1159 const ShaderProgramVariables::MFVariablesType *pMFVars = NULL;
1160 const ShaderProgramVariables::MFProceduralVariablesType *pMFProcVars = NULL;
1161
1162 if(_sfVariables.getValue() != NULL)
1163 {
1164 pMFVars = _sfVariables.getValue()->getMFVariables ();
1165 pMFProcVars = _sfVariables.getValue()->getMFProceduralVariables();
1166 }
1167
1168 if(pMFVars != NULL && pMFVars->size() != 0)
1169 {
1170 MFInt32 &vVarLocations = *this->editMFVariableLocations();
1171
1172 OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1173
1174 MFInt32::iterator mLocIt = vVarLocations.begin();
1175
1176 ShaderProgramVariables::MFVariablesType::const_iterator mVarIt =
1177 pMFVars->begin();
1178 ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
1179 pMFVars->end ();
1180
1181 OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
1182 osgGlGetUniformLocation,
1183 ShaderProgram::getFuncIdGetUniformLocation());
1184
1185 for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1186 {
1187 *mLocIt = osgGlGetUniformLocation(uiProgram,
1188 (*mVarIt)->getName().c_str());
1189 }
1190 }
1191
1192 if(pMFProcVars != NULL && pMFProcVars->size() != 0)
1193 {
1194 MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
1195
1196 OSG_ASSERT(pMFProcVars->size() == vVarLocations.size());
1197
1198 MFInt32::iterator mLocIt = vVarLocations.begin();
1199
1200 ShaderProgramVariables::MFProceduralVariablesType::const_iterator
1201 mVarIt = pMFProcVars->begin();
1202 ShaderProgramVariables::MFProceduralVariablesType::const_iterator
1203 mVarEnd = pMFProcVars->end ();
1204
1205 OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
1206 osgGlGetUniformLocation,
1207 ShaderProgram::getFuncIdGetUniformLocation());
1208
1209 for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1210 {
1211 *mLocIt = osgGlGetUniformLocation(uiProgram,
1212 (*mVarIt)->getName().c_str());
1213 }
1214 }
1215 }
1216
1217 void ShaderExecutableChunk::updateVariables(DrawEnv *pEnv,
1218 UInt32 uiProgram)
1219 {
1220 if(uiProgram == 0)
1221 return;
1222
1223 const ShaderProgramVariables::MFVariablesType *pMFVars = NULL;
1224 ShaderProgramVariables::MFVariableChangedType *pMFVarChg = NULL;
1225
1226 if(_sfVariables.getValue() != NULL)
1227 {
1228 pMFVars = _sfVariables.getValue()->getMFVariables ();
1229 pMFVarChg = _sfVariables.getValue()->editMFVariableChanged();
1230 }
1231
1232 if(pMFVars == NULL || pMFVars->size() == 0 || pMFVarChg == NULL)
1233 {
1234 return;
1235 }
1236
1237 OSG_ASSERT(pMFVars->size() == pMFVarChg->size());
1238
1239 MFInt32 &vVarLocations = *this->editMFVariableLocations();
1240
1241 OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1242
1243 MFInt32::iterator mLocIt = vVarLocations.begin();
1244
1245 ShaderProgramVariables::MFVariablesType::const_iterator mVarIt =
1246 pMFVars->begin();
1247 ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
1248 pMFVars->end ();
1249
1250 ShaderProgramVariables::MFVariableChangedType::iterator mVarChgIt =
1251 pMFVarChg->begin();
1252
1253 bool warnUnknown = ShaderVariable::WarnUnknown;
1254
1255 for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt, ++mVarChgIt)
1256 {
1257 ShaderVariable *pVar = *mVarIt;
1258
1259 if(pVar == NULL)
1260 continue;
1261
1262 if(*mVarChgIt == false)
1263 continue;
1264
1265 *mVarChgIt = false;
1266
1267 osgUniformShaderVariableSwitch(pEnv, pVar,
1268 *mLocIt, uiProgram, warnUnknown);
1269 }
1270 }
1271
1272 void ShaderExecutableChunk::updateAttribBindings(DrawEnv *pEnv,
1273 UInt32 uiProgram)
1274 {
1275 MFAttributesType::const_iterator aIt = _mfAttributes.begin();
1276 MFAttributesType::const_iterator aEnd = _mfAttributes.end ();
1277
1278 if(aIt == aEnd)
1279 return;
1280
1281 OSGGETGLFUNC_GL3_ES(glBindAttribLocation,
1282 osgGlBindAttribLocation,
1283 ShaderProgram::getFuncIdBindAttribLocation());
1284
1285 for(; aIt != aEnd; ++aIt)
1286 {
1287 osgGlBindAttribLocation(uiProgram, (*aIt).first, (*aIt).second.c_str());
1288 }
1289 }
1290
1291 void ShaderExecutableChunk::updateParameters(DrawEnv *pEnv,
1292 UInt32 uiProgram)
1293 {
1294 if(uiProgram == 0 || this->getGeometryVerticesOut() == 0)
1295 return;
1296
1297 OSGGETGLFUNC_EXT(glProgramParameteriEXT,
1298 osgGlProgramParameteriEXT,
1299 ShaderProgram::getFuncIdProgramParameteri());
1300
1301 osgGlProgramParameteriEXT(uiProgram,
1302 GL_GEOMETRY_VERTICES_OUT_EXT,
1303 this->getGeometryVerticesOut());
1304 osgGlProgramParameteriEXT(uiProgram,
1305 GL_GEOMETRY_INPUT_TYPE_EXT,
1306 this->getGeometryInputType());
1307 osgGlProgramParameteriEXT(uiProgram,
1308 GL_GEOMETRY_OUTPUT_TYPE_EXT,
1309 this->getGeometryOutputType());
1310 }
1311
1312 void ShaderExecutableChunk::updateProceduralVariables(
1313 DrawEnv *pEnv,
1314 UInt32 uiUpdateDependents)
1315 {
1316 UInt32 uiProgram = pEnv->getActiveShader();
1317
1318 if(uiProgram == 0)
1319 return;
1320
1321 const ShaderProgramVariables::MFProceduralVariablesType *pMFVars = NULL;
1322
1323 if(_sfVariables.getValue() != NULL)
1324 {
1325 pMFVars = _sfVariables.getValue()->getMFProceduralVariables();
1326 }
1327
1328 if(pMFVars == NULL || pMFVars->size() == 0)
1329 {
1330 return;
1331 }
1332
1333 MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
1334
1335 OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1336
1337 MFInt32::iterator mLocIt = vVarLocations.begin();
1338
1339 ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarIt =
1340 pMFVars->begin();
1341 ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarEnd =
1342 pMFVars->end ();
1343
1344 Window *pWin = pEnv->getWindow();
1345
1346 osgSinkUnusedWarning(pWin);
1347
1348 #ifdef OSG_1_COMPATX
1349 if(_fParameterCallback)
1350 {
1351 OSGGETGLFUNCBYID_GL3_ES(glGetUniformLocation,
1352 osgGlGetUniformLocation,
1353 ShaderProgram::getFuncIdGetUniformLocation(),
1354 pWin);
1355
1356 _fParameterCallback(osgGlGetUniformLocation, pEnv, uiProgram);
1357 }
1358 #endif
1359
1360 for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1361 {
1362 ShaderVariable *pVar = *mVarIt;
1363
1364 switch(pVar->getTypeId())
1365 {
1366 case ShaderVariable::SHVTypeOSG:
1367 {
1368 ShaderVariableOSG *p =
1369 dynamic_cast<ShaderVariableOSG *>(pVar);
1370
1371 if(0x0000 == (p->getDependency() & uiUpdateDependents))
1372 continue;
1373
1374 if(*mLocIt == -1)
1375 {
1376 OSGGETGLFUNCBYID_GL3_ES(
1377 glGetUniformLocation,
1378 osgGlGetUniformLocation,
1379 ShaderProgram::getFuncIdGetUniformLocation(),
1380 pWin);
1381
1382 *mLocIt = osgGlGetUniformLocation(uiProgram,
1383 p->getName().c_str());
1384
1385 #ifdef OSG_MULTISHADER_VARCHUNK
1386 if(*mLocIt == -1)
1387 *mLocIt = -2;
1388 #endif
1389 }
1390
1391 p->evaluate(pEnv, *mLocIt);
1392 }
1393 break;
1394
1395 case ShaderVariable::SHVTypeFunctor:
1396 {
1397 ShaderVariableFunctor *p =
1398 dynamic_cast<ShaderVariableFunctor *>(pVar);
1399
1400 if(0x0000 == (p->getDependency() & uiUpdateDependents))
1401 continue;
1402
1403 if(*mLocIt == -1)
1404 {
1405 OSGGETGLFUNCBYID_GL3_ES(
1406 glGetUniformLocation,
1407 osgGlGetUniformLocation,
1408 ShaderProgram::getFuncIdGetUniformLocation(),
1409 pWin);
1410
1411 *mLocIt = osgGlGetUniformLocation(uiProgram,
1412 p->getName().c_str());
1413 #ifdef OSG_MULTISHADER_VARCHUNK
1414 if(*mLocIt == -1)
1415 *mLocIt = -2;
1416 #endif
1417 }
1418
1419 #ifdef OSG_1_COMPAT
1420 switch(p->getFuncMode())
1421 {
1422 case 0:
1423 {
1424 p->evaluate(pEnv, *mLocIt);
1425 }
1426 break;
1427
1428 case 1:
1429 {
1430 OSGGETGLFUNCBYID_GL3_ES(
1431 glGetUniformLocation,
1432 osgGlGetUniformLocation,
1433 ShaderProgram::getFuncIdGetUniformLocation(),
1434 pWin);
1435
1436 p->evaluate(osgGlGetUniformLocation,
1437 pEnv,
1438 uiProgram);
1439 }
1440 break;
1441
1442 case 2:
1443 {
1444 p->evaluate(p,
1445 pEnv,
1446 uiProgram);
1447 }
1448 break;
1449 }
1450 #else
1451 p->evaluate(pEnv, *mLocIt);
1452 #endif
1453 }
1454 break;
1455
1456 default:
1457 break;
1458 }
1459 }
1460 }
1461
1462 OSG_END_NAMESPACE