0026973: Visualization - selection of entities hidden by clipping planes is broken
[occt.git] / src / OpenGl / OpenGl_ShaderProgram.cxx
CommitLineData
30f0ad28 1// Created on: 2013-09-19
2// Created by: Denis BOGOLEPOV
d5f74e42 3// Copyright (c) 2013-2014 OPEN CASCADE SAS
30f0ad28 4//
973c2be1 5// This file is part of Open CASCADE Technology software library.
30f0ad28 6//
d5f74e42 7// This library is free software; you can redistribute it and/or modify it under
8// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 9// by the Free Software Foundation, with special exception defined in the file
10// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11// distribution for complete text of the license and disclaimer of any warranty.
30f0ad28 12//
973c2be1 13// Alternatively, this file may be used under the terms of Open CASCADE
14// commercial license or contractual agreement.
30f0ad28 15
16#include <OSD_File.hxx>
17#include <OSD_Protection.hxx>
18
7d3e64ef 19#include <Graphic3d_Buffer.hxx>
30f0ad28 20#include <Standard_Assert.hxx>
21#include <Standard_Atomic.hxx>
22#include <TCollection_ExtendedString.hxx>
23
24#include <OpenGl_Context.hxx>
25#include <OpenGl_ShaderProgram.hxx>
26#include <OpenGl_ShaderManager.hxx>
25ef750e 27#include <OpenGl_ArbTexBindless.hxx>
30f0ad28 28
47e9c178 29#include <OpenGl_GlCore32.hxx>
30f0ad28 30
92efcf78 31IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderProgram,OpenGl_Resource)
32
30f0ad28 33OpenGl_VariableSetterSelector OpenGl_ShaderProgram::mySetterSelector = OpenGl_VariableSetterSelector();
34
35// Declare OCCT-specific OpenGL/GLSL shader variables
36Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
37{
12381341 38 "occModelWorldMatrix", // OpenGl_OCC_MODEL_WORLD_MATRIX
39 "occWorldViewMatrix", // OpenGl_OCC_WORLD_VIEW_MATRIX
40 "occProjectionMatrix", // OpenGl_OCC_PROJECTION_MATRIX
41 "occModelWorldMatrixInverse", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE
42 "occWorldViewMatrixInverse", // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE
43 "occProjectionMatrixInverse", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE
44 "occModelWorldMatrixTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE
45 "occWorldViewMatrixTranspose", // OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE
46 "occProjectionMatrixTranspose", // OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE
47 "occModelWorldMatrixInverseTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE
48 "occWorldViewMatrixInverseTranspose", // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE
49 "occProjectionMatrixInverseTranspose", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE
50
51 "occClipPlaneEquations", // OpenGl_OCC_CLIP_PLANE_EQUATIONS
52 "occClipPlaneSpaces", // OpenGl_OCC_CLIP_PLANE_SPACES
5495fa7e 53 "occClipPlaneCount", // OpenGl_OCC_CLIP_PLANE_COUNT
12381341 54
55 "occLightSourcesCount", // OpenGl_OCC_LIGHT_SOURCE_COUNT
56 "occLightSourcesTypes", // OpenGl_OCC_LIGHT_SOURCE_TYPES
57 "occLightSources", // OpenGl_OCC_LIGHT_SOURCE_PARAMS
58 "occLightAmbient", // OpenGl_OCC_LIGHT_AMBIENT
59
60 "occActiveSampler", // OpenGl_OCCT_ACTIVE_SAMPLER
61 "occTextureEnable", // OpenGl_OCCT_TEXTURE_ENABLE
62 "occDistinguishingMode", // OpenGl_OCCT_DISTINGUISH_MODE
63 "occFrontMaterial", // OpenGl_OCCT_FRONT_MATERIAL
8625ef7e 64 "occBackMaterial", // OpenGl_OCCT_BACK_MATERIAL
65 "occColor", // OpenGl_OCCT_COLOR
66
79f4f036 67 "occTexTrsf2d", // OpenGl_OCCT_TEXTURE_TRSF2D
8625ef7e 68 "occPointSize" // OpenGl_OCCT_POINT_SIZE
30f0ad28 69
70};
71
72// =======================================================================
73// function : OpenGl_VariableSetterSelector
74// purpose : Creates new variable setter selector
75// =======================================================================
76OpenGl_VariableSetterSelector::OpenGl_VariableSetterSelector()
77{
78 // Note: Add new variable setters here
79 mySetterList = OpenGl_HashMapInitializer::CreateListOf<size_t, OpenGl_SetterInterface*>
80 (Graphic3d_UniformValueTypeID<int>::ID, new OpenGl_VariableSetter<int>())
81 (Graphic3d_UniformValueTypeID<float>::ID, new OpenGl_VariableSetter<float>())
82 (Graphic3d_UniformValueTypeID<OpenGl_Vec2>::ID, new OpenGl_VariableSetter<OpenGl_Vec2>())
83 (Graphic3d_UniformValueTypeID<OpenGl_Vec3>::ID, new OpenGl_VariableSetter<OpenGl_Vec3>())
84 (Graphic3d_UniformValueTypeID<OpenGl_Vec4>::ID, new OpenGl_VariableSetter<OpenGl_Vec4>())
85 (Graphic3d_UniformValueTypeID<OpenGl_Vec2i>::ID, new OpenGl_VariableSetter<OpenGl_Vec2i>())
86 (Graphic3d_UniformValueTypeID<OpenGl_Vec3i>::ID, new OpenGl_VariableSetter<OpenGl_Vec3i>())
87 (Graphic3d_UniformValueTypeID<OpenGl_Vec4i>::ID, new OpenGl_VariableSetter<OpenGl_Vec4i>());
88}
89
90// =======================================================================
91// function : ~OpenGl_VariableSetterSelector
92// purpose : Releases memory resources of variable setter selector
93// =======================================================================
94OpenGl_VariableSetterSelector::~OpenGl_VariableSetterSelector()
95{
96 for (OpenGl_SetterList::Iterator anIt (mySetterList); anIt.More(); anIt.Next())
97 {
98 delete anIt.Value();
99 }
100
101 mySetterList.Clear();
102}
103
104// =======================================================================
105// function : Set
106// purpose : Sets generic variable to specified shader program
107// =======================================================================
108void OpenGl_VariableSetterSelector::Set (const Handle(OpenGl_Context)& theCtx,
109 const Handle(Graphic3d_ShaderVariable)& theVariable,
110 OpenGl_ShaderProgram* theProgram) const
111{
112 Standard_ASSERT_RETURN (mySetterList.IsBound (theVariable->Value()->TypeID()),
113 "The type of user-defined uniform variable is not supported...", );
114
115 mySetterList.Find (theVariable->Value()->TypeID())->Set (theCtx, theVariable, theProgram);
116}
117
118// =======================================================================
119// function : OpenGl_ShaderProgram
120// purpose : Creates uninitialized shader program
121// =======================================================================
122OpenGl_ShaderProgram::OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProxy)
123: myProgramID (NO_PROGRAM),
392ac980 124 myProxy (theProxy),
125 myShareCount(1)
30f0ad28 126{
127 memset (myCurrentState, 0, sizeof (myCurrentState));
128 for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
129 {
130 myStateLocations[aVar] = INVALID_LOCATION;
131 }
132}
133
134// =======================================================================
135// function : Initialize
136// purpose : Initializes program object with the list of shader objects
137// =======================================================================
138Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)& theCtx,
139 const Graphic3d_ShaderObjectList& theShaders)
140{
141 if (theCtx.IsNull() || !Create (theCtx))
142 {
143 return Standard_False;
144 }
145
12381341 146 OSD_File aDeclFile (Graphic3d_ShaderProgram::ShadersFolder() + "/Declarations.glsl");
147 OSD_File aDeclImplFile (Graphic3d_ShaderProgram::ShadersFolder() + "/DeclarationsImpl.glsl");
148 if (!aDeclFile.Exists()
149 || !aDeclImplFile.Exists())
30f0ad28 150 {
392ac980 151 const TCollection_ExtendedString aMsg = "Error! Failed to load OCCT shader declarations file";
3b523c4c 152 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
153 GL_DEBUG_TYPE_ERROR,
30f0ad28 154 0,
3b523c4c 155 GL_DEBUG_SEVERITY_HIGH,
30f0ad28 156 aMsg);
30f0ad28 157 return Standard_False;
158 }
159
b86bb3df 160 TCollection_AsciiString aHeader = !myProxy.IsNull() && !myProxy->Header().IsEmpty()
161 ? (myProxy->Header() + "\n")
162 : TCollection_AsciiString();
163
30f0ad28 164 TCollection_AsciiString aDeclarations;
30f0ad28 165 aDeclFile.Open (OSD_ReadOnly, OSD_Protection());
bd0b3e60 166 aDeclFile.Read (aDeclarations, (int)aDeclFile.Size());
30f0ad28 167 aDeclFile.Close();
168
12381341 169 TCollection_AsciiString aDeclImpl;
170 aDeclImplFile.Open (OSD_ReadOnly, OSD_Protection());
171 aDeclImplFile.Read (aDeclImpl, (int)aDeclImplFile.Size());
172 aDeclImplFile.Close();
173 aDeclarations += aDeclImpl;
174
30f0ad28 175 for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders);
176 anIter.More(); anIter.Next())
177 {
178 if (!anIter.Value()->IsDone())
179 {
392ac980 180 const TCollection_ExtendedString aMsg = "Error! Failed to get shader source";
3b523c4c 181 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
182 GL_DEBUG_TYPE_ERROR,
30f0ad28 183 0,
3b523c4c 184 GL_DEBUG_SEVERITY_HIGH,
30f0ad28 185 aMsg);
30f0ad28 186 return Standard_False;
187 }
188
189 Handle(OpenGl_ShaderObject) aShader;
190
191 // Note: Add support of other shader types here
192 switch (anIter.Value()->Type())
193 {
194 case Graphic3d_TOS_VERTEX:
195 aShader = new OpenGl_ShaderObject (GL_VERTEX_SHADER);
196 break;
197 case Graphic3d_TOS_FRAGMENT:
198 aShader = new OpenGl_ShaderObject (GL_FRAGMENT_SHADER);
199 break;
200 }
201
202 // Is unsupported shader type?
203 if (aShader.IsNull())
204 {
205 TCollection_ExtendedString aMsg = "Error! Unsupported shader type";
3b523c4c 206 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
207 GL_DEBUG_TYPE_ERROR,
30f0ad28 208 0,
3b523c4c 209 GL_DEBUG_SEVERITY_HIGH,
30f0ad28 210 aMsg);
30f0ad28 211 return Standard_False;
212 }
213
214 if (!aShader->Create (theCtx))
215 {
392ac980 216 aShader->Release (theCtx.operator->());
30f0ad28 217 return Standard_False;
218 }
219
220 TCollection_AsciiString aSource = aDeclarations + anIter.Value()->Source();
8625ef7e 221 switch (anIter.Value()->Type())
30f0ad28 222 {
8625ef7e 223 case Graphic3d_TOS_VERTEX:
224 {
b86bb3df 225 aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + aSource;
8625ef7e 226 break;
227 }
228 case Graphic3d_TOS_FRAGMENT:
229 {
230 #if defined(GL_ES_VERSION_2_0)
231 TCollection_AsciiString aPrefix (theCtx->hasHighp
232 ? "precision highp float;\n"
8a53d1c4 233 "precision highp int;\n"
234 : "precision mediump float;\n"
235 "precision mediump int;\n");
b86bb3df 236 aSource = aHeader + aPrefix + aSource;
4e1523ef 237 #else
238 aSource = aHeader + aSource;
8625ef7e 239 #endif
240 break;
241 }
30f0ad28 242 }
243
244 if (!aShader->LoadSource (theCtx, aSource))
245 {
392ac980 246 const TCollection_ExtendedString aMsg = "Error! Failed to set shader source";
3b523c4c 247 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
248 GL_DEBUG_TYPE_ERROR,
30f0ad28 249 0,
3b523c4c 250 GL_DEBUG_SEVERITY_HIGH,
30f0ad28 251 aMsg);
392ac980 252 aShader->Release (theCtx.operator->());
30f0ad28 253 return Standard_False;
254 }
255
256 if (!aShader->Compile (theCtx))
257 {
392ac980 258 TCollection_AsciiString aLog;
259 aShader->FetchInfoLog (theCtx, aLog);
260 if (aLog.IsEmpty())
261 {
262 aLog = "Compilation log is empty.";
263 }
3b523c4c 264 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
265 GL_DEBUG_TYPE_ERROR,
30f0ad28 266 0,
3b523c4c 267 GL_DEBUG_SEVERITY_HIGH,
392ac980 268 TCollection_ExtendedString ("Failed to compile shader object. Compilation log:\n") + aLog);
269 aShader->Release (theCtx.operator->());
270 return Standard_False;
271 }
272 else if (theCtx->caps->glslWarnings)
273 {
274 TCollection_AsciiString aLog;
275 aShader->FetchInfoLog (theCtx, aLog);
276 if (!aLog.IsEmpty()
277 && !aLog.IsEqual ("No errors.\n"))
30f0ad28 278 {
3b523c4c 279 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
280 GL_DEBUG_TYPE_PORTABILITY,
392ac980 281 0,
3b523c4c 282 GL_DEBUG_SEVERITY_LOW,
392ac980 283 TCollection_ExtendedString ("Shader compilation log:\n") + aLog);
30f0ad28 284 }
30f0ad28 285 }
286
287 if (!AttachShader (theCtx, aShader))
288 {
392ac980 289 aShader->Release (theCtx.operator->());
30f0ad28 290 return Standard_False;
291 }
292 }
293
7d3e64ef 294 // bind locations for pre-defined Vertex Attributes
295 SetAttributeName (theCtx, Graphic3d_TOA_POS, "occVertex");
296 SetAttributeName (theCtx, Graphic3d_TOA_NORM, "occNormal");
297 SetAttributeName (theCtx, Graphic3d_TOA_UV, "occTexCoord");
8625ef7e 298 SetAttributeName (theCtx, Graphic3d_TOA_COLOR, "occVertColor");
7d3e64ef 299
30f0ad28 300 if (!Link (theCtx))
301 {
392ac980 302 TCollection_AsciiString aLog;
303 FetchInfoLog (theCtx, aLog);
304 if (aLog.IsEmpty())
305 {
306 aLog = "Linker log is empty.";
307 }
3b523c4c 308 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
309 GL_DEBUG_TYPE_ERROR,
30f0ad28 310 0,
3b523c4c 311 GL_DEBUG_SEVERITY_HIGH,
12381341 312 TCollection_ExtendedString ("Failed to link program object! Linker log:\n") + aLog);
392ac980 313 return Standard_False;
314 }
315 else if (theCtx->caps->glslWarnings)
316 {
317 TCollection_AsciiString aLog;
318 FetchInfoLog (theCtx, aLog);
319 if (!aLog.IsEmpty()
320 && !aLog.IsEqual ("No errors.\n"))
30f0ad28 321 {
3b523c4c 322 theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
323 GL_DEBUG_TYPE_PORTABILITY,
392ac980 324 0,
3b523c4c 325 GL_DEBUG_SEVERITY_LOW,
392ac980 326 TCollection_ExtendedString ("GLSL linker log:\n") + aLog);
30f0ad28 327 }
30f0ad28 328 }
329
330 return Standard_True;
331}
332
333// =======================================================================
334// function : ~OpenGl_ShaderProgram
335// purpose : Releases resources of shader program
336// =======================================================================
337OpenGl_ShaderProgram::~OpenGl_ShaderProgram()
338{
339 Release (NULL);
340}
341
342// =======================================================================
343// function : AttachShader
344// purpose : Attaches shader object to the program object
345// =======================================================================
346Standard_Boolean OpenGl_ShaderProgram::AttachShader (const Handle(OpenGl_Context)& theCtx,
347 const Handle(OpenGl_ShaderObject)& theShader)
348{
349 if (myProgramID == NO_PROGRAM || theShader.IsNull())
350 {
351 return Standard_False;
352 }
353
354 for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
355 {
356 if (theShader == anIter.Value())
357 {
358 return Standard_False;
359 }
360 }
361
362 myShaderObjects.Append (theShader);
4e1523ef 363 theCtx->core20fwd->glAttachShader (myProgramID, theShader->myShaderID);
30f0ad28 364 return Standard_True;
365}
366
367// =======================================================================
368// function : DetachShader
369// purpose : Detaches shader object to the program object
370// =======================================================================
371Standard_Boolean OpenGl_ShaderProgram::DetachShader (const Handle(OpenGl_Context)& theCtx,
372 const Handle(OpenGl_ShaderObject)& theShader)
373{
374 if (myProgramID == NO_PROGRAM
375 || theShader.IsNull())
376 {
377 return Standard_False;
378 }
379
380 OpenGl_ShaderList::Iterator anIter (myShaderObjects);
381 while (anIter.More())
382 {
383 if (theShader == anIter.Value())
384 {
385 myShaderObjects.Remove (anIter);
386 break;
387 }
388
389 anIter.Next();
390 }
391
392 if (!anIter.More())
393 {
394 return Standard_False;
395 }
396
4e1523ef 397 theCtx->core20fwd->glDetachShader (myProgramID, theShader->myShaderID);
30f0ad28 398 return Standard_True;
399}
400
401// =======================================================================
402// function : Link
403// purpose : Links the program object
404// =======================================================================
405Standard_Boolean OpenGl_ShaderProgram::Link (const Handle(OpenGl_Context)& theCtx)
406{
407 if (myProgramID == NO_PROGRAM)
408 {
409 return Standard_False;
410 }
411
30f0ad28 412 GLint aStatus = GL_FALSE;
4e1523ef 413 theCtx->core20fwd->glLinkProgram (myProgramID);
414 theCtx->core20fwd->glGetProgramiv (myProgramID, GL_LINK_STATUS, &aStatus);
fc73a202 415 if (aStatus == GL_FALSE)
416 {
417 return Standard_False;
418 }
30f0ad28 419
420 for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
421 {
422 myStateLocations[aVar] = GetUniformLocation (theCtx, PredefinedKeywords[aVar]);
423 }
fc73a202 424 return Standard_True;
30f0ad28 425}
426
427// =======================================================================
428// function : FetchInfoLog
429// purpose : Fetches information log of the last link operation
430// =======================================================================
431Standard_Boolean OpenGl_ShaderProgram::FetchInfoLog (const Handle(OpenGl_Context)& theCtx,
432 TCollection_AsciiString& theOutput)
433{
434 if (myProgramID == NO_PROGRAM)
435 {
436 return Standard_False;
437 }
438
439 GLint aLength = 0;
4e1523ef 440 theCtx->core20fwd->glGetProgramiv (myProgramID, GL_INFO_LOG_LENGTH, &aLength);
30f0ad28 441 if (aLength > 0)
442 {
443 GLchar* aLog = (GLchar*) alloca (aLength);
444 memset (aLog, 0, aLength);
4e1523ef 445 theCtx->core20fwd->glGetProgramInfoLog (myProgramID, aLength, NULL, aLog);
30f0ad28 446 theOutput = aLog;
447 }
448 return Standard_True;
449}
450
451// =======================================================================
30f0ad28 452// function : ApplyVariables
453// purpose : Fetches uniform variables from proxy shader program
454// =======================================================================
455Standard_Boolean OpenGl_ShaderProgram::ApplyVariables(const Handle(OpenGl_Context)& theCtx)
456{
457 if (myProxy.IsNull() || myProxy->Variables().IsEmpty())
458 {
459 return Standard_False;
460 }
461
462 for (Graphic3d_ShaderVariableList::Iterator anIter (myProxy->Variables()); anIter.More(); anIter.Next())
463 {
464 mySetterSelector.Set (theCtx, anIter.Value(), this);
465 }
466
467 myProxy->ClearVariables();
468 return Standard_True;
469}
470
471// =======================================================================
30f0ad28 472// function : ActiveState
473// purpose : Returns index of last modification for specified state type
474// =======================================================================
475Standard_Size OpenGl_ShaderProgram::ActiveState (const OpenGl_UniformStateType theType) const
476{
477 if (theType < MaxStateTypes)
478 {
479 return myCurrentState[theType];
480 }
481 return 0;
482}
483
484// =======================================================================
485// function : UpdateState
486// purpose : Updates index of last modification for specified state type
487// =======================================================================
488void OpenGl_ShaderProgram::UpdateState (const OpenGl_UniformStateType theType,
489 const Standard_Size theIndex)
490{
491 if (theType < MaxStateTypes)
492 {
493 myCurrentState[theType] = theIndex;
494 }
495}
496
497// =======================================================================
498// function : GetUniformLocation
499// purpose : Returns location (index) of the specific uniform variable
500// =======================================================================
501GLint OpenGl_ShaderProgram::GetUniformLocation (const Handle(OpenGl_Context)& theCtx,
502 const GLchar* theName) const
503{
504 return myProgramID != NO_PROGRAM
4e1523ef 505 ? theCtx->core20fwd->glGetUniformLocation (myProgramID, theName)
30f0ad28 506 : INVALID_LOCATION;
507}
508
509// =======================================================================
510// function : GetAttributeLocation
511// purpose : Returns location (index) of the generic vertex attribute
512// =======================================================================
513GLint OpenGl_ShaderProgram::GetAttributeLocation (const Handle(OpenGl_Context)& theCtx,
514 const GLchar* theName) const
515{
516 return myProgramID != NO_PROGRAM
4e1523ef 517 ? theCtx->core20fwd->glGetAttribLocation (myProgramID, theName)
30f0ad28 518 : INVALID_LOCATION;
519}
520
521// =======================================================================
522// function : GetStateLocation
523// purpose : Returns location of the OCCT state uniform variable
524// =======================================================================
525GLint OpenGl_ShaderProgram::GetStateLocation (const GLuint theVariable) const
526{
527 if (theVariable < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES)
528 {
529 return myStateLocations[theVariable];
530 }
531 return INVALID_LOCATION;
532}
533
534// =======================================================================
535// function : GetUniform
536// purpose : Returns the value of the integer uniform variable
537// =======================================================================
538Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
539 const GLchar* theName,
540 OpenGl_Vec4i& theValue) const
541{
542 return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
543}
544
545// =======================================================================
546// function : GetUniform
547// purpose : Returns the value of the integer uniform variable
548// =======================================================================
549Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
550 GLint theLocation,
551 OpenGl_Vec4i& theValue) const
552{
553 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
554 {
555 return Standard_False;
556 }
557
4e1523ef 558 theCtx->core20fwd->glGetUniformiv (myProgramID, theLocation, theValue);
30f0ad28 559 return Standard_True;
560}
561
562// =======================================================================
563// function : GetUniform
564// purpose : Returns the value of the floating-point uniform variable
565// =======================================================================
566Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
567 const GLchar* theName,
568 OpenGl_Vec4& theValue) const
569{
570 return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
571}
572
573// =======================================================================
574// function : GetUniform
575// purpose : Returns the value of the floating-point uniform variable
576// =======================================================================
577Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
578 GLint theLocation,
579 OpenGl_Vec4& theValue) const
580{
581 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
582 {
583 return Standard_False;
584 }
585
4e1523ef 586 theCtx->core20fwd->glGetUniformfv (myProgramID, theLocation, theValue);
30f0ad28 587 return Standard_True;
588}
589
590// =======================================================================
591// function : GetAttribute
592// purpose : Returns the integer vertex attribute
593// =======================================================================
594Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
595 const GLchar* theName,
596 OpenGl_Vec4i& theValue) const
597{
598 return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
599}
600
601// =======================================================================
602// function : GetAttribute
603// purpose : Returns the integer vertex attribute
604// =======================================================================
605Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
606 GLint theIndex,
607 OpenGl_Vec4i& theValue) const
608{
609 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
610 {
611 return Standard_False;
612 }
613
4e1523ef 614 theCtx->core20fwd->glGetVertexAttribiv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
30f0ad28 615 return Standard_True;
616}
617
618// =======================================================================
619// function : GetAttribute
620// purpose : Returns the floating-point vertex attribute
621// =======================================================================
622Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
623 const GLchar* theName,
624 OpenGl_Vec4& theValue) const
625{
626 return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
627}
628
629// =======================================================================
630// function : GetAttribute
631// purpose : Returns the floating-point vertex attribute
632// =======================================================================
633Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
634 GLint theIndex,
635 OpenGl_Vec4& theValue) const
636{
637 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
638 {
639 return Standard_False;
640 }
641
4e1523ef 642 theCtx->core20fwd->glGetVertexAttribfv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
30f0ad28 643 return Standard_True;
644}
645
646// =======================================================================
fc73a202 647// function : SetAttributeName
648// purpose :
649// =======================================================================
650Standard_Boolean OpenGl_ShaderProgram::SetAttributeName (const Handle(OpenGl_Context)& theCtx,
651 GLint theIndex,
652 const GLchar* theName)
653{
654 theCtx->core20fwd->glBindAttribLocation (myProgramID, theIndex, theName);
655 return Standard_True;
656}
b86bb3df 657
fc73a202 658// =======================================================================
659// function : SetAttribute
660// purpose :
661// =======================================================================
662Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
663 const GLchar* theName,
664 GLfloat theValue)
665{
666 return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
667}
668
669// =======================================================================
670// function : SetAttribute
671// purpose :
672// =======================================================================
673Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
674 GLint theIndex,
675 GLfloat theValue)
676{
677 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
678 {
679 return Standard_False;
680 }
681
682 theCtx->core20fwd->glVertexAttrib1f (theIndex, theValue);
683 return Standard_True;
684}
685
686// =======================================================================
687// function : SetAttribute
688// purpose :
689// =======================================================================
690Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
691 const GLchar* theName,
692 const OpenGl_Vec2& theValue)
693{
694 return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
695}
696
697// =======================================================================
698// function : SetAttribute
699// purpose :
700// =======================================================================
701Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
702 GLint theIndex,
703 const OpenGl_Vec2& theValue)
704{
705 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
706 {
707 return Standard_False;
708 }
709
710 theCtx->core20fwd->glVertexAttrib2fv (theIndex, theValue);
711 return Standard_True;
712}
713
714// =======================================================================
715// function : SetAttribute
716// purpose :
717// =======================================================================
718Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
719 const GLchar* theName,
720 const OpenGl_Vec3& theValue)
721{
722 return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
723}
724
725// =======================================================================
726// function : SetAttribute
727// purpose :
728// =======================================================================
729Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
730 GLint theIndex,
731 const OpenGl_Vec3& theValue)
732{
733 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
734 {
735 return Standard_False;
736 }
737
738 theCtx->core20fwd->glVertexAttrib3fv (theIndex, theValue);
739 return Standard_True;
740}
741
742// =======================================================================
743// function : SetAttribute
744// purpose :
745// =======================================================================
746Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
747 const GLchar* theName,
748 const OpenGl_Vec4& theValue)
749{
750 return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
751}
752
753// =======================================================================
754// function : SetAttribute
755// purpose :
756// =======================================================================
757Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
758 GLint theIndex,
759 const OpenGl_Vec4& theValue)
760{
761 if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
762 {
763 return Standard_False;
764 }
765
766 theCtx->core20fwd->glVertexAttrib4fv (theIndex, theValue);
767 return Standard_True;
768}
769
770// =======================================================================
30f0ad28 771// function : SetUniform
772// purpose : Specifies the value of the integer uniform variable
773// =======================================================================
774Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
775 const GLchar* theName,
776 GLint theValue)
777{
778 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
779}
780
781// =======================================================================
782// function : SetUniform
783// purpose : Specifies the value of the integer uniform variable
784// =======================================================================
785Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
786 GLint theLocation,
787 GLint theValue)
788{
789 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
790 {
791 return Standard_False;
792 }
793
4e1523ef 794 theCtx->core20fwd->glUniform1i (theLocation, theValue);
30f0ad28 795 return Standard_True;
796}
797
798// =======================================================================
799// function : SetUniform
47e9c178 800// purpose :
25ef750e 801// =======================================================================
802Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
803 const GLchar* theName,
47e9c178 804 const OpenGl_Vec2u& theValue)
25ef750e 805{
806 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
807}
808
809// =======================================================================
810// function : SetUniform
47e9c178 811// purpose :
25ef750e 812// =======================================================================
813Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
814 GLint theLocation,
47e9c178 815 const OpenGl_Vec2u& theValue)
25ef750e 816{
47e9c178 817 if (theCtx->core32 == NULL || myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
25ef750e 818 {
819 return Standard_False;
820 }
821
822#if !defined(GL_ES_VERSION_2_0)
47e9c178 823 theCtx->core32->glUniform2uiv (theLocation, 1, theValue.GetData());
25ef750e 824#endif
825
826 return Standard_True;
827}
828
829// =======================================================================
830// function : SetUniform
47e9c178 831// purpose :
25ef750e 832// =======================================================================
833Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
834 const GLchar* theName,
835 const GLsizei theCount,
47e9c178 836 const OpenGl_Vec2u* theValue)
25ef750e 837{
838 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theCount, theValue);
839}
840
841// =======================================================================
842// function : SetUniform
47e9c178 843// purpose :
25ef750e 844// =======================================================================
845Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
846 GLint theLocation,
847 const GLsizei theCount,
47e9c178 848 const OpenGl_Vec2u* theValue)
25ef750e 849{
47e9c178 850 if (theCtx->core32 == NULL || myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
25ef750e 851 {
852 return Standard_False;
853 }
854
855#if !defined(GL_ES_VERSION_2_0)
47e9c178 856 theCtx->core32->glUniform2uiv (theLocation, theCount, theValue->GetData());
25ef750e 857#endif
858
859 return Standard_True;
860}
861
862// =======================================================================
863// function : SetUniform
30f0ad28 864// purpose : Specifies the value of the floating-point uniform variable
865// =======================================================================
866Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
867 const GLchar* theName,
868 GLfloat theValue)
869{
870 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
871}
872
873// =======================================================================
874// function : SetUniform
875// purpose : Specifies the value of the floating-point uniform variable
876// =======================================================================
877Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
878 GLint theLocation,
879 GLfloat theValue)
880{
881 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
882 {
883 return Standard_False;
884 }
885
4e1523ef 886 theCtx->core20fwd->glUniform1f (theLocation, theValue);
30f0ad28 887 return Standard_True;
888}
889
890// =======================================================================
891// function : SetUniform
892// purpose : Specifies the value of the integer uniform 2D vector
893// =======================================================================
894Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
895 const GLchar* theName,
896 const OpenGl_Vec2i& theValue)
897{
898 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
899}
900
901// =======================================================================
902// function : SetUniform
903// purpose : Specifies the value of the integer uniform 2D vector
904// =======================================================================
905Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
906 GLint theLocation,
907 const OpenGl_Vec2i& theValue)
908{
909 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
910 {
911 return Standard_False;
912 }
913
4e1523ef 914 theCtx->core20fwd->glUniform2iv (theLocation, 1, theValue);
30f0ad28 915 return Standard_True;
916}
917
918// =======================================================================
919// function : SetUniform
920// purpose : Specifies the value of the integer uniform 3D vector
921// =======================================================================
922Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
923 const GLchar* theName,
924 const OpenGl_Vec3i& theValue)
925{
926 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
927}
928
929// =======================================================================
930// function : SetUniform
931// purpose : Specifies the value of the integer uniform 3D vector
932// =======================================================================
933Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
934 GLint theLocation,
935 const OpenGl_Vec3i& theValue)
936{
937 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
938 {
939 return Standard_False;
940 }
941
4e1523ef 942 theCtx->core20fwd->glUniform3iv (theLocation, 1, theValue);
30f0ad28 943 return Standard_True;
944}
945
946// =======================================================================
947// function : SetUniform
948// purpose : Specifies the value of the integer uniform 4D vector
949// =======================================================================
950Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
951 const GLchar* theName,
952 const OpenGl_Vec4i& theValue)
953{
954 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
955}
956
957// =======================================================================
958// function : SetUniform
959// purpose : Specifies the value of the integer uniform 4D vector
960// =======================================================================
961Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
962 GLint theLocation,
963 const OpenGl_Vec4i& theValue)
964{
965 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
966 {
967 return Standard_False;
968 }
969
4e1523ef 970 theCtx->core20fwd->glUniform4iv (theLocation, 1, theValue);
30f0ad28 971 return Standard_True;
972}
973
974// =======================================================================
975// function : SetUniform
976// purpose : Specifies the value of the floating-point uniform 2D vector
977// =======================================================================
978Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
979 const GLchar* theName,
980 const OpenGl_Vec2& theValue)
981{
982 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
983}
984
985// =======================================================================
986// function : SetUniform
987// purpose : Specifies the value of the floating-point uniform 2D vector
988// =======================================================================
989Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
990 GLint theLocation,
991 const OpenGl_Vec2& theValue)
992{
993 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
994 {
995 return Standard_False;
996 }
997
4e1523ef 998 theCtx->core20fwd->glUniform2fv (theLocation, 1, theValue);
30f0ad28 999 return Standard_True;
1000}
1001
1002// =======================================================================
1003// function : SetUniform
1004// purpose : Specifies the value of the floating-point uniform 3D vector
1005// =======================================================================
1006Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1007 const GLchar* theName,
1008 const OpenGl_Vec3& theValue)
1009{
1010 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1011}
1012
1013// =======================================================================
1014// function : SetUniform
1015// purpose : Specifies the value of the floating-point uniform 3D vector
1016// =======================================================================
1017Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1018 GLint theLocation,
1019 const OpenGl_Vec3& theValue)
1020{
1021 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1022 {
1023 return Standard_False;
1024 }
1025
4e1523ef 1026 theCtx->core20fwd->glUniform3fv (theLocation, 1, theValue);
30f0ad28 1027 return Standard_True;
1028}
1029
1030// =======================================================================
1031// function : SetUniform
1032// purpose : Specifies the value of the floating-point uniform 4D vector
1033// =======================================================================
1034Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1035 const GLchar* theName,
1036 const OpenGl_Vec4& theValue)
1037{
1038 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1039}
1040
1041// =======================================================================
1042// function : SetUniform
1043// purpose : Specifies the value of the floating-point uniform 4D vector
1044// =======================================================================
1045Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1046 GLint theLocation,
1047 const OpenGl_Vec4& theValue)
1048{
1049 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1050 {
1051 return Standard_False;
1052 }
1053
4e1523ef 1054 theCtx->core20fwd->glUniform4fv (theLocation, 1, theValue);
30f0ad28 1055 return Standard_True;
1056}
1057
1058// =======================================================================
1059// function : SetUniform
1060// purpose : Specifies the value of the floating-point uniform 4x4 matrix
1061// =======================================================================
1062Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1063 const GLchar* theName,
25ef750e 1064 const OpenGl_Mat4& theValue,
1065 GLboolean theTranspose)
1066{
1067 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1068}
1069
1070// =======================================================================
1071// function : SetUniform
1072// purpose : Specifies the value of the floating-point uniform 4x4 matrix
1073// =======================================================================
1074Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1075 GLint theLocation,
1076 const OpenGl_Mat4& theValue,
1077 GLboolean theTranspose)
1078{
1079 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1080 {
1081 return Standard_False;
1082 }
1083
4e1523ef 1084 theCtx->core20fwd->glUniformMatrix4fv (theLocation, 1, GL_FALSE, theTranspose ? theValue.Transposed() : theValue);
25ef750e 1085 return Standard_True;
1086}
1087
1088// =======================================================================
1089// function : SetUniform
1090// purpose : Specifies the value of the floating-point uniform 4x4 matrix
1091// =======================================================================
1092Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1093 const GLchar* theName,
30f0ad28 1094 const OpenGl_Matrix& theValue,
1095 GLboolean theTranspose)
1096{
1097 return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1098}
1099
1100// =======================================================================
1101// function : SetUniform
1102// purpose : Specifies the value of the floating-point uniform 4x4 matrix
1103// =======================================================================
1104Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1105 GLint theLocation,
1106 const OpenGl_Matrix& theValue,
1107 GLboolean theTranspose)
1108{
c827ea3a 1109 return SetUniform (theCtx, theLocation, OpenGl_Mat4::Map (*theValue.mat), theTranspose);
30f0ad28 1110}
1111
1112// =======================================================================
4fe9ad57 1113// function : SetUniform
1114// purpose : Specifies the value of the float uniform array
1115// =======================================================================
1116Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1117 GLint theLocation,
1118 GLuint theCount,
1119 const Standard_ShortReal* theData)
1120{
1121 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1122 {
1123 return Standard_False;
1124 }
1125
4e1523ef 1126 theCtx->core20fwd->glUniform1fv (theLocation, theCount, theData);
4fe9ad57 1127 return Standard_True;
1128}
1129
1130// =======================================================================
1131// function : SetUniform
1132// purpose : Specifies the value of the float2 uniform array
1133// =======================================================================
1134Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1135 GLint theLocation,
1136 GLuint theCount,
1137 const OpenGl_Vec2* theData)
1138{
1139 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1140 {
1141 return Standard_False;
1142 }
1143
4e1523ef 1144 theCtx->core20fwd->glUniform2fv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1145 return Standard_True;
1146}
1147
1148// =======================================================================
1149// function : SetUniform
1150// purpose : Specifies the value of the float3 uniform array
1151// =======================================================================
1152Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1153 GLint theLocation,
1154 GLuint theCount,
1155 const OpenGl_Vec3* theData)
1156{
1157 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1158 {
1159 return Standard_False;
1160 }
1161
4e1523ef 1162 theCtx->core20fwd->glUniform3fv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1163 return Standard_True;
1164}
1165
1166// =======================================================================
1167// function : SetUniform
1168// purpose : Specifies the value of the float4 uniform array
1169// =======================================================================
1170Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1171 GLint theLocation,
1172 GLuint theCount,
1173 const OpenGl_Vec4* theData)
1174{
1175 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1176 {
1177 return Standard_False;
1178 }
1179
4e1523ef 1180 theCtx->core20fwd->glUniform4fv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1181 return Standard_True;
1182}
1183
1184// =======================================================================
1185// function : SetUniform
1186// purpose : Specifies the value of the integer uniform array
1187// =======================================================================
1188Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1189 GLint theLocation,
1190 GLuint theCount,
1191 const Standard_Integer* theData)
1192{
1193 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1194 {
1195 return Standard_False;
1196 }
1197
4e1523ef 1198 theCtx->core20fwd->glUniform1iv (theLocation, theCount, theData);
4fe9ad57 1199 return Standard_True;
1200}
1201
1202// =======================================================================
1203// function : SetUniform
1204// purpose : Specifies the value of the int2 uniform array
1205// =======================================================================
1206Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1207 GLint theLocation,
1208 GLuint theCount,
1209 const OpenGl_Vec2i* theData)
1210{
1211 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1212 {
1213 return Standard_False;
1214 }
1215
4e1523ef 1216 theCtx->core20fwd->glUniform2iv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1217 return Standard_True;
1218}
1219
1220// =======================================================================
1221// function : SetUniform
1222// purpose : Specifies the value of the int3 uniform array
1223// =======================================================================
1224Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1225 GLint theLocation,
1226 GLuint theCount,
1227 const OpenGl_Vec3i* theData)
1228{
1229 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1230 {
1231 return Standard_False;
1232 }
1233
4e1523ef 1234 theCtx->core20fwd->glUniform3iv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1235 return Standard_True;
1236}
1237
1238// =======================================================================
1239// function : SetUniform
1240// purpose : Specifies the value of the int4 uniform array
1241// =======================================================================
1242Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1243 GLint theLocation,
1244 GLuint theCount,
1245 const OpenGl_Vec4i* theData)
1246{
1247 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1248 {
1249 return Standard_False;
1250 }
1251
4e1523ef 1252 theCtx->core20fwd->glUniform4iv (theLocation, theCount, theData[0].GetData());
4fe9ad57 1253 return Standard_True;
1254}
1255
1256// =======================================================================
30f0ad28 1257// function : SetSampler
1258// purpose : Specifies the value of the sampler uniform variable
1259// =======================================================================
1260Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1261 const GLchar* theName,
1262 const GLenum theTextureUnit)
1263{
1264 return SetSampler (theCtx, GetUniformLocation (theCtx, theName), theTextureUnit);
1265}
1266
1267// =======================================================================
1268// function : SetSampler
1269// purpose : Specifies the value of the sampler uniform variable
1270// =======================================================================
1271Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1272 GLint theLocation,
1273 const GLenum theTextureUnit)
1274{
1275 if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1276 {
1277 return Standard_False;
1278 }
1279
4e1523ef 1280 theCtx->core20fwd->glUniform1i (theLocation, theTextureUnit);
30f0ad28 1281 return Standard_True;
1282}
1283
1284// =======================================================================
1285// function : Create
1286// purpose : Creates new empty shader program of specified type
1287// =======================================================================
1288Standard_Boolean OpenGl_ShaderProgram::Create (const Handle(OpenGl_Context)& theCtx)
1289{
1290 if (myProgramID == NO_PROGRAM
4e1523ef 1291 && theCtx->core20fwd != NULL)
30f0ad28 1292 {
4e1523ef 1293 myProgramID = theCtx->core20fwd->glCreateProgram();
30f0ad28 1294 }
1295
1296 return myProgramID != NO_PROGRAM;
1297}
1298
1299// =======================================================================
1300// function : Release
1301// purpose : Destroys shader program
1302// =======================================================================
10b9c7df 1303void OpenGl_ShaderProgram::Release (OpenGl_Context* theCtx)
30f0ad28 1304{
1305 if (myProgramID == NO_PROGRAM)
1306 {
1307 return;
1308 }
1309
1310 Standard_ASSERT_RETURN (theCtx != NULL,
1311 "OpenGl_ShaderProgram destroyed without GL context! Possible GPU memory leakage...",);
1312
1313 for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
1314 {
fc73a202 1315 if (!anIter.Value().IsNull())
1316 {
1317 anIter.ChangeValue()->Release (theCtx);
1318 anIter.ChangeValue().Nullify();
1319 }
30f0ad28 1320 }
1321
4e1523ef 1322 if (theCtx->core20fwd != NULL
ec2eeb2d 1323 && theCtx->IsValid())
30f0ad28 1324 {
4e1523ef 1325 theCtx->core20fwd->glDeleteProgram (myProgramID);
30f0ad28 1326 }
1327
1328 myProgramID = NO_PROGRAM;
1329}