?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / State / Base / OSGUniformBufferObjChunk.cpp
blob7fb66fb880c280e86f7105cef9350e4a22ee8bb9
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2013 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net *
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 "OSGGL.h"
51 #include "OSGGLU.h"
52 #include "OSGGLEXT.h"
53 #include "OSGWindow.h"
54
55 #include "OSGGLFuncProtos.h"
56
57 #include "OSGDrawEnv.h"
58
59 #include "OSGUniformBufferObjChunk.h"
60
61 OSG_BEGIN_NAMESPACE
62
63 // Documentation for this class is emitted in the
64 // OSGUniformBufferObjChunkBase.cpp file.
65 // To modify it, please change the .fcd file (OSGUniformBufferObjChunk.fcd) and
66 // regenerate the base file.
67
68 /***************************************************************************\
69 * Class variables *
70 \***************************************************************************/
71
72 typedef OSG::Window Win;
73
74 UInt32 UniformBufferObjChunk::_extUniformBufferObject = Win::invalidExtensionID;
75 UInt32 UniformBufferObjChunk::_extVertexBufferObject = Win::invalidExtensionID;
76
77 UInt32 UniformBufferObjChunk::_funcBindBuffer = Win::invalidFunctionID;
78 UInt32 UniformBufferObjChunk::_funcMapBuffer = Win::invalidFunctionID;
79 UInt32 UniformBufferObjChunk::_funcUnmapBuffer = Win::invalidFunctionID;
80 UInt32 UniformBufferObjChunk::_funcBufferData = Win::invalidFunctionID;
81 UInt32 UniformBufferObjChunk::_funcBufferSubData = Win::invalidFunctionID;
82 UInt32 UniformBufferObjChunk::_funcGenBuffers = Win::invalidFunctionID;
83 UInt32 UniformBufferObjChunk::_funcDeleteBuffers = Win::invalidFunctionID;
84 UInt32 UniformBufferObjChunk::_funcGetBufferParameteriv = Win::invalidFunctionID;
85
86 UInt32 UniformBufferObjChunk::_funcBindBufferBase = Win::invalidFunctionID;
87 UInt32 UniformBufferObjChunk::_funcGetUniformBlockIndex = Win::invalidFunctionID;
88 UInt32 UniformBufferObjChunk::_funcGetActiveUniformBlockiv = Win::invalidFunctionID;
89 UInt32 UniformBufferObjChunk::_funcGetActiveUniformsiv = Win::invalidFunctionID;
90 UInt32 UniformBufferObjChunk::_funcGetUniformIndices = Win::invalidFunctionID;
91
92 /***************************************************************************\
93 * Class methods *
94 \***************************************************************************/
95
96 void UniformBufferObjChunk::initMethod(InitPhase ePhase)
97 {
98 Inherited::initMethod(ePhase);
99
100 if(ePhase == TypeObject::SystemPost)
101 {
102 _extVertexBufferObject=
103 Window::registerExtension("GL_ARB_vertex_buffer_object");
104
105 _funcBindBuffer = Window::registerFunction(
106 OSG_DLSYM_UNDERSCORE"glBindBufferARB",
107 _extVertexBufferObject);
108
109 _funcMapBuffer = Window::registerFunction(
110 OSG_DLSYM_UNDERSCORE"glMapBufferARB",
111 _extVertexBufferObject);
112
113 _funcUnmapBuffer = Window::registerFunction(
114 OSG_DLSYM_UNDERSCORE"glUnmapBufferARB",
115 _extVertexBufferObject);
116
117 _funcBufferData = Window::registerFunction(
118 OSG_DLSYM_UNDERSCORE"glBufferDataARB",
119 _extVertexBufferObject);
120
121 _funcBufferSubData = Window::registerFunction(
122 OSG_DLSYM_UNDERSCORE"glBufferSubDataARB",
123 _extVertexBufferObject);
124
125 _funcDeleteBuffers = Window::registerFunction(
126 OSG_DLSYM_UNDERSCORE"glDeleteBuffersARB",
127 _extVertexBufferObject);
128
129 _funcGenBuffers = Window::registerFunction(
130 OSG_DLSYM_UNDERSCORE"glGenBuffersARB",
131 _extVertexBufferObject);
132
133 _funcGetBufferParameteriv = Window::registerFunction(
134 OSG_DLSYM_UNDERSCORE"glGetBufferParameterivARB",
135 _extVertexBufferObject);
136
137
138 _extUniformBufferObject =
139 Window::registerExtension("GL_ARB_uniform_buffer_object" );
140
141 _funcBindBufferBase = Window::registerFunction(
142 OSG_DLSYM_UNDERSCORE"glBindBufferBase",
143 _extUniformBufferObject);
144
145 _funcGetUniformBlockIndex = Window::registerFunction(
146 OSG_DLSYM_UNDERSCORE"glGetUniformBlockIndex",
147 _extUniformBufferObject);
148
149 _funcGetActiveUniformBlockiv = Window::registerFunction(
150 OSG_DLSYM_UNDERSCORE"glGetActiveUniformBlockiv",
151 _extUniformBufferObject);
152
153 _funcGetActiveUniformsiv = Window::registerFunction(
154 OSG_DLSYM_UNDERSCORE"glGetActiveUniformsiv",
155 _extUniformBufferObject);
156
157 _funcGetUniformIndices = Window::registerFunction(
158 OSG_DLSYM_UNDERSCORE"glGetUniformIndices",
159 _extUniformBufferObject);
160 }
161 }
162
163
164 /***************************************************************************\
165 * Instance methods *
166 \***************************************************************************/
167
168 /*-------------------------------------------------------------------------*\
169 - private -
170 \*-------------------------------------------------------------------------*/
171
172 /*----------------------- constructors & destructors ----------------------*/
173
174 UniformBufferObjChunk::UniformBufferObjChunk(void) :
175 Inherited()
176 {
177 }
178
179 UniformBufferObjChunk::UniformBufferObjChunk(const UniformBufferObjChunk &source) :
180 Inherited(source)
181 {
182 }
183
184 UniformBufferObjChunk::~UniformBufferObjChunk(void)
185 {
186 }
187
188 /*----------------------------- class specific ----------------------------*/
189
190 void UniformBufferObjChunk::changed(ConstFieldMaskArg whichField,
191 UInt32 origin,
192 BitVector details)
193 {
194 GLenum id = _sfGLId.getValue();
195
196 if((whichField & ( UsageFieldMask |
197 BlockNameFieldMask |
198 FundamentalTypesFieldMask |
199 MainTypesFieldMask |
200 CardinalityFieldMask |
201 IndexFieldMask |
202 NamesFieldMask |
203 NameToIndexFieldMask |
204 FloatValuesFieldMask |
205 DoubleValuesFieldMask |
206 IntValuesFieldMask |
207 UIntValuesFieldMask |
208 BoolValuesFieldMask )) != 0)
209 {
210 Window::refreshGLObject(id);
211 }
212
213 Inherited::changed(whichField, origin, details);
214 }
215
216 /*----------------------------- onCreate --------------------------------*/
217
218 void UniformBufferObjChunk::onCreate(const UniformBufferObjChunk *source)
219 {
220 Inherited::onCreate(source);
221
222 if(GlobalSystemState == Startup)
223 return;
224
225 setGLId(Window::registerGLObject(
226 boost::bind(&UniformBufferObjChunk::handleGL,
227 UniformBufferObjChunkMTUncountedPtr(this),
228 _1, _2, _3, _4),
229 &UniformBufferObjChunk::handleDestroyGL));
230 }
231
232 void UniformBufferObjChunk::onCreateAspect(const UniformBufferObjChunk *createAspect,
233 const UniformBufferObjChunk *source )
234 {
235 Inherited::onCreateAspect(createAspect, source);
236 }
237
238 void UniformBufferObjChunk::onDestroy(UInt32 uiContainerId)
239 {
240 if(getGLId() > 0)
241 Window::destroyGLObject(getGLId(), 1);
242
243 Inherited::onDestroy(uiContainerId);
244 }
245
246 /*------------------------------ Output ----------------------------------*/
247
248 void UniformBufferObjChunk::dump( UInt32 uiIndent,
249 const BitVector bvFlags) const
250 {
251 Inherited::dump(uiIndent, bvFlags);
252
253 if((bvFlags & UsageFieldMask) != 0)
254 {
255 indentLog(uiIndent, PLOG);
256 PLOG << "usage " << _sfUsage.getValue() << "\n";
257 }
258 if((bvFlags & BlockNameFieldMask) != 0)
259 {
260 indentLog(uiIndent, PLOG);
261 PLOG << "block name " << _sfBlockName.getValue() << "\n";
262 }
263 }
264
265 /*------------------------------ GL -----------------------------------------*/
266
267 /*! GL object handler */
268 UInt32 UniformBufferObjChunk::handleGL(DrawEnv *pEnv,
269 UInt32 osgid,
270 Window::GLObjectStatusE mode,
271 UInt64 uiOptions)
272 {
273 Window *pWin = pEnv->getWindow();
274 GLuint id = pWin->getGLObjectId(osgid);
275
276 bool hasVBO = pWin->hasExtOrVersion(_extVertexBufferObject, 0x0105, 0x0200);
277 if(!hasVBO)
278 {
279 FWARNING(
280 ("UniformBufferObjChunk::handleGL: vertex buffer objects not "
281 "supported for this window!\n"));
282 return 0;
283 }
284
285 bool hasUBO = pWin->hasExtOrVersion(_extUniformBufferObject, 0x0300);
286 if(!hasUBO)
287 {
288 FWARNING(
289 ("UniformBufferObjChunk::handleGL: uniform buffer objects not "
290 "supported for this window!\n"));
291 return 0;
292 }
293
294 switch (mode)
295 {
296 case Window::initialize:
297 {
298 OSGGETGLFUNCBYID_GL3_ES( glGenBuffers,
299 osgGlGenBuffers,
300 _funcGenBuffers,
301 pWin);
302
303 OSGGETGLFUNCBYID_GL3_ES( glBindBuffer,
304 osgGlBindBuffer,
305 _funcBindBuffer,
306 pWin);
307
308 OSGGETGLFUNCBYID_GL3_ES( glBufferData,
309 osgGlBufferData,
310 _funcBufferData,
311 pWin);
312
313 OSGGETGLFUNCBYID_GL3_ES( glBindBufferBase,
314 osgGlBindBufferBase,
315 _funcBindBufferBase,
316 pWin);
317
318 osgGlGenBuffers(1, &id);
319 pWin->setGLObjectId(osgid, id);
320
321 std::vector<GLubyte> buffer = createBuffer(pEnv);
322
323 std::size_t sz = buffer.size();
324 if (sz > 0)
325 {
326 osgGlBindBuffer (GL_UNIFORM_BUFFER, id);
327 osgGlBufferData (GL_UNIFORM_BUFFER, sz, &buffer[0], _sfUsage.getValue());
328 osgGlBindBuffer (GL_UNIFORM_BUFFER, 0);
329 }
330
331 glErr("UniformBufferObjChunk::handleGL initialize");
332 }
333 break;
334
335 case Window::needrefresh:
336 {
337 OSGGETGLFUNCBYID_GL3_ES( glBindBuffer,
338 osgGlBindBuffer,
339 _funcBindBuffer,
340 pWin);
341
342 OSGGETGLFUNCBYID_GL3_ES( glMapBuffer,
343 osgGlMapBuffer,
344 _funcMapBuffer,
345 pWin);
346
347 OSGGETGLFUNCBYID_GL3_ES( glUnmapBuffer,
348 osgGlUnmapBuffer,
349 _funcUnmapBuffer,
350 pWin);
351
352 osgGlBindBuffer(GL_UNIFORM_BUFFER, id);
353 GLubyte* pBuffer = static_cast<GLubyte*>(
354 osgGlMapBuffer(GL_UNIFORM_BUFFER, GL_WRITE_ONLY_ARB));
355
356 std::vector<GLubyte> buffer = createBuffer(pEnv);
357 if (!buffer.empty())
358 memcpy(pBuffer, &buffer[0], sizeof(GLubyte) * buffer.size());
359
360 osgGlUnmapBuffer(GL_UNIFORM_BUFFER);
361 osgGlBindBuffer (GL_UNIFORM_BUFFER, 0);
362
363 glErr("UniformBufferObjChunk::handleGL needrefresh");
364 }
365 break;
366 default:
367 {
368 SWARNING << "UniformBufferObjChunk(" << this << "::handleGL: Illegal mode: "
369 << mode << " for id " << id << std::endl;
370 }
371 }
372
373 return 0;
374 }
375
376 /*! GL object handler
377 destroy it
378 */
379 void UniformBufferObjChunk::handleDestroyGL(DrawEnv *pEnv,
380 UInt32 osgid,
381 Window::GLObjectStatusE mode)
382 {
383 Window *pWin = pEnv->getWindow();
384 GLuint id = pWin->getGLObjectId(osgid);
385
386 if(mode == Window::destroy)
387 {
388 OSGGETGLFUNCBYID_GL3_ES( glDeleteBuffers,
389 osgGlDeleteBuffers,
390 _funcDeleteBuffers,
391 pWin);
392
393 osgGlDeleteBuffers(1, &id);
394 pWin->setGLObjectId(osgid, 0);
395
396 glErr("UniformBufferObjChunk::handleDestroyGL");
397 }
398 else if(mode == Window::finaldestroy)
399 {
400 //SWARNING << "Last buffer user destroyed" << std::endl;
401 }
402 else
403 {
404 SWARNING << "UniformBufferObjChunk::handleDestroyGL: Illegal mode: "
405 << mode << " for id " << id << std::endl;
406 }
407
408 }
409
410 /*------------------------------ tools --------------------------------------*/
411
412 void UniformBufferObjChunk::validate(DrawEnv *pEnv)
413 {
414 pEnv->getWindow()->validateGLObject(this->getGLId(),
415 pEnv );
416 }
417
418 Int32 UniformBufferObjChunk::getOpenGLId(DrawEnv *pEnv)
419 {
420 return pEnv->getWindow()->getGLObjectId(this->getGLId());
421 }
422
423 /*------------------------------ activate -----------------------------------*/
424
425 void UniformBufferObjChunk::activate(DrawEnv *pEnv, UInt32 idx)
426 {
427 Window *pWin = pEnv->getWindow();
428
429 pWin->validateGLObject(getGLId(), pEnv);
430
431 GLuint id = pWin->getGLObjectId(getGLId());
432
433 OSGGETGLFUNCBYID_GL3_ES( glBindBuffer,
434 osgGlBindBuffer,
435 _funcBindBuffer,
436 pWin);
437
438 OSGGETGLFUNCBYID_GL3_ES( glBindBufferBase,
439 osgGlBindBufferBase,
440 _funcBindBufferBase,
441 pWin);
442
443 osgGlBindBuffer (GL_UNIFORM_BUFFER, id);
444 osgGlBindBufferBase(GL_UNIFORM_BUFFER, idx, id);
445
446 glErr("UniformBufferObjChunk::activate");
447 }
448
449 /*------------------------------ deactivate ---------------------------------*/
450
451 void UniformBufferObjChunk::deactivate(DrawEnv *pEnv, UInt32 idx)
452 {
453 Window *pWin = pEnv->getWindow();
454
455 OSGGETGLFUNCBYID_GL3_ES( glBindBuffer,
456 osgGlBindBuffer,
457 _funcBindBuffer,
458 pWin);
459
460 OSGGETGLFUNCBYID_GL3_ES( glBindBufferBase,
461 osgGlBindBufferBase,
462 _funcBindBufferBase,
463 pWin);
464
465 osgGlBindBufferBase(GL_UNIFORM_BUFFER, idx, 0);
466 osgGlBindBuffer (GL_UNIFORM_BUFFER, 0);
467
468 glErr("UniformBufferObjChunk::deactivate");
469 }
470
471 /*------------------------------ changeFrom ---------------------------------*/
472
473 void UniformBufferObjChunk::changeFrom(DrawEnv *pEnv,
474 StateChunk *old,
475 UInt32 idx )
476 {
477 // change from me to me?
478 // this assumes I haven't changed in the meantime.
479 // is that a valid assumption?
480 if (old == this)
481 return;
482
483 old->deactivate(pEnv, idx);
484 this->activate(pEnv, idx);
485 }
486
487 /*------------------------------ buffer -------------------------------------*/
488
489 std::vector<GLubyte> UniformBufferObjChunk::createBuffer(DrawEnv *pEnv)
490 {
491 Window *pWin = pEnv->getWindow();
492
493 OSGGETGLFUNCBYID_GL3_ES( glGetUniformBlockIndex,
494 osgGlGetUniformBlockIndex,
495 _funcGetUniformBlockIndex,
496 pWin);
497
498 OSGGETGLFUNCBYID_GL3_ES( glGetActiveUniformBlockiv,
499 osgGlGetActiveUniformBlockiv,
500 _funcGetActiveUniformBlockiv,
501 pWin);
502
503 OSGGETGLFUNCBYID_GL3_ES( glGetActiveUniformsiv,
504 osgGlGetActiveUniformsiv,
505 _funcGetActiveUniformsiv,
506 pWin);
507
508 OSGGETGLFUNCBYID_GL3_ES( glGetUniformIndices,
509 osgGlGetUniformIndices,
510 _funcGetUniformIndices,
511 pWin);
512
513 std::vector<GLubyte> buffer;
514
515 GLuint index = osgGlGetUniformBlockIndex(pEnv->getActiveShader(), _sfBlockName.getValue().c_str());
516 if (index == GL_INVALID_INDEX) {
517 SWARNING << "UniformBufferObjChunk::createBuffer: Invalid block index" << std::endl;
518 return buffer;
519 }
520
521 GLint num;
522 osgGlGetActiveUniformBlockiv(pEnv->getActiveShader(), index, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &num);
523
524 if (SizeT(num) != _mfIndex.size())
525 {
526 SWARNING << "UniformBufferObjChunk::createBuffer: Invalid number of active uniforms in block" << std::endl;
527 return buffer;
528 }
529
530 std::vector<const GLchar*> names;
531 for (std::size_t i = 0; i < _mfNames.size(); ++i)
532 names.push_back(_mfNames[i].c_str());
533
534 std::vector<GLuint> indices(num);
535 osgGlGetUniformIndices(pEnv->getActiveShader(), num, &names[0], &indices[0]);
536 for (std::size_t i = 0; i < indices.size(); ++i) {
537 if (indices[i] == GL_INVALID_INDEX) {
538 SWARNING << "UniformBufferObjChunk::createBuffer: Invalid block indices" << std::endl;
539 return buffer;
540 }
541 }
542
543 std::vector<GLint> offsets(num), array_strides(num), matrix_strides(num);
544
545 osgGlGetActiveUniformsiv(pEnv->getActiveShader(), num, &indices[0], GL_UNIFORM_OFFSET, &offsets[0]);
546 osgGlGetActiveUniformsiv(pEnv->getActiveShader(), num, &indices[0], GL_UNIFORM_ARRAY_STRIDE, &array_strides[0]);
547 osgGlGetActiveUniformsiv(pEnv->getActiveShader(), num, &indices[0], GL_UNIFORM_MATRIX_STRIDE, &matrix_strides[0]);
548
549 GLint size;
550 osgGlGetActiveUniformBlockiv(pEnv->getActiveShader(), index, GL_UNIFORM_BLOCK_DATA_SIZE, &size);
551
552 buffer.resize(size);
553
554 for (GLint i = 0; i < num; ++i)
555 {
556 UInt32 idx = _mfIndex [i];
557 FundamentalTypes fType = static_cast<FundamentalTypes>(_mfFundamentalTypes[i]);
558 MainType mType = static_cast<MainType> (_mfMainTypes [i]);
559 UInt32 card = _mfCardinality [i];
560
561 UInt8 columns = 0;
562 UInt8 rows = 0;
563
564 switch (mType) {
565 case SIMPLE_T:
566 columns = 1;
567 rows = 1;
568 break;
569 case VEC2_T:
570 columns = 1;
571 rows = 2;
572 break;
573 case VEC3_T:
574 columns = 1;
575 rows = 3;
576 break;
577 case VEC4_T:
578 columns = 1;
579 rows = 4;
580 break;
581 case MAT2_T:
582 columns = 2;
583 rows = 2;
584 break;
585 case MAT3_T:
586 columns = 3;
587 rows = 3;
588 break;
589 case MAT4_T:
590 columns = 4;
591 rows = 4;
592 break;
593 case MAT2X3_T:
594 columns = 2;
595 rows = 3;
596 break;
597 case MAT2X4_T:
598 columns = 2;
599 rows = 4;
600 break;
601 case MAT3X4_T:
602 columns = 3;
603 rows = 4;
604 break;
605 case MAT3X2_T:
606 columns = 3;
607 rows = 2;
608 break;
609 case MAT4X2_T:
610 columns = 4;
611 rows = 2;
612 break;
613 case MAT4X3_T:
614 columns = 4;
615 rows = 3;
616 break;
617 }
618
619 GLint offset = offsets[i];
620 GLint array_stride = array_strides[i];
621 GLint matrix_stride = matrix_strides[i];
622
623 for (UInt32 j = 0; j < card; ++j)
624 {
625 GLint offset_ = offset;
626 for (UInt8 k = 0; k < columns; ++k)
627 {
628 for (UInt8 l = 0; l < rows; ++l)
629 {
630 UInt32 idx_ = idx + j * rows * columns + k * rows + l;
631 switch (fType) {
632 case FLOAT_T:
633 reinterpret_cast<Real32*>(&buffer[0] + offset)[l] = _mfFloatValues[idx_];
634 break;
635 case DOUBLE_T:
636 reinterpret_cast<Real64*>(&buffer[0] + offset)[l] = _mfDoubleValues[idx_];
637 break;
638 case INT_T:
639 reinterpret_cast<Int32*>(&buffer[0] + offset)[l] = _mfIntValues[idx_];
640 break;
641 case UINT_T:
642 reinterpret_cast<UInt32*>(&buffer[0] + offset)[l] = _mfUIntValues[idx_];
643 break;
644 case BOOL_T:
645 reinterpret_cast<Int32*>(&buffer[0] + offset)[l] = _mfBoolValues[idx_];
646 break;
647 }
648 }
649 offset += matrix_stride;
650 }
651 offset = offset_ + array_stride;
652 }
653 }
654
655 return buffer;
656 }
657
658 /*------------------------------ add-interface ------------------------------*/
659
660 UInt32 UniformBufferObjChunk::addFloat(const std::string& name, UInt32 cardinality)
661 {
662 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
663 editMField(MainTypesFieldMask, _mfMainTypes);
664 editMField(CardinalityFieldMask, _mfCardinality);
665 editMField(IndexFieldMask, _mfIndex);
666 editMField(NamesFieldMask, _mfNames);
667 editMField(FloatValuesFieldMask, _mfFloatValues);
668 editSField(NameToIndexFieldMask);
669
670 _mfFundamentalTypes.push_back(FLOAT_T);
671 _mfMainTypes .push_back(SIMPLE_T);
672 _mfCardinality .push_back(cardinality);
673 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
674 _mfNames .push_back(name);
675
676 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
677
678 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
679
680 for (UInt32 i = 0; i < cardinality; ++i)
681 _mfFloatValues.push_back(0.f);
682
683 OSG_ASSERT(invariantOnStorageSize());
684
685 return index;
686 }
687
688 UInt32 UniformBufferObjChunk::addDouble(const std::string& name, UInt32 cardinality)
689 {
690 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
691 editMField(MainTypesFieldMask, _mfMainTypes);
692 editMField(CardinalityFieldMask, _mfCardinality);
693 editMField(IndexFieldMask, _mfIndex);
694 editMField(NamesFieldMask, _mfNames);
695 editMField(DoubleValuesFieldMask, _mfDoubleValues);
696 editSField(NameToIndexFieldMask);
697
698 _mfFundamentalTypes.push_back(DOUBLE_T);
699 _mfMainTypes .push_back(SIMPLE_T);
700 _mfCardinality .push_back(cardinality);
701 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
702 _mfNames .push_back(name);
703
704 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
705
706 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
707
708 for (UInt32 i = 0; i < cardinality; ++i)
709 _mfDoubleValues.push_back(0.);
710
711 OSG_ASSERT(invariantOnStorageSize());
712
713 return index;
714 }
715
716 UInt32 UniformBufferObjChunk::addInt(const std::string& name, UInt32 cardinality)
717 {
718 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
719 editMField(MainTypesFieldMask, _mfMainTypes);
720 editMField(CardinalityFieldMask, _mfCardinality);
721 editMField(IndexFieldMask, _mfIndex);
722 editMField(NamesFieldMask, _mfNames);
723 editMField(IntValuesFieldMask, _mfIntValues);
724 editSField(NameToIndexFieldMask);
725
726 _mfFundamentalTypes.push_back(INT_T);
727 _mfMainTypes .push_back(SIMPLE_T);
728 _mfCardinality .push_back(cardinality);
729 _mfIndex .push_back(static_cast<UInt32>(_mfIntValues.size()));
730 _mfNames .push_back(name);
731
732 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
733
734 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
735
736 for (UInt32 i = 0; i < cardinality; ++i)
737 _mfIntValues.push_back(0);
738
739 OSG_ASSERT(invariantOnStorageSize());
740
741 return index;
742 }
743
744 UInt32 UniformBufferObjChunk::addUInt(const std::string& name, UInt32 cardinality)
745 {
746 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
747 editMField(MainTypesFieldMask, _mfMainTypes);
748 editMField(CardinalityFieldMask, _mfCardinality);
749 editMField(IndexFieldMask, _mfIndex);
750 editMField(NamesFieldMask, _mfNames);
751 editMField(UIntValuesFieldMask, _mfUIntValues);
752 editSField(NameToIndexFieldMask);
753
754 _mfFundamentalTypes.push_back(UINT_T);
755 _mfMainTypes .push_back(SIMPLE_T);
756 _mfCardinality .push_back(cardinality);
757 _mfIndex .push_back(static_cast<UInt32>(_mfUIntValues.size()));
758 _mfNames .push_back(name);
759
760 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
761
762 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
763
764 for (UInt32 i = 0; i < cardinality; ++i)
765 _mfUIntValues.push_back(0);
766
767 OSG_ASSERT(invariantOnStorageSize());
768
769 return index;
770 }
771
772 UInt32 UniformBufferObjChunk::addBool(const std::string& name, UInt32 cardinality)
773 {
774 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
775 editMField(MainTypesFieldMask, _mfMainTypes);
776 editMField(CardinalityFieldMask, _mfCardinality);
777 editMField(IndexFieldMask, _mfIndex);
778 editMField(NamesFieldMask, _mfNames);
779 editMField(BoolValuesFieldMask, _mfBoolValues);
780 editSField(NameToIndexFieldMask);
781
782 _mfFundamentalTypes.push_back(BOOL_T);
783 _mfMainTypes .push_back(SIMPLE_T);
784 _mfCardinality .push_back(cardinality);
785 _mfIndex .push_back(static_cast<UInt32>(_mfBoolValues.size()));
786 _mfNames .push_back(name);
787
788 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
789
790 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
791
792 for (UInt32 i = 0; i < cardinality; ++i)
793 _mfBoolValues.push_back(static_cast<UInt8>(false));
794
795 OSG_ASSERT(invariantOnStorageSize());
796
797 return index;
798 }
799
800 UInt32 UniformBufferObjChunk::addVec2(const std::string& name, UInt32 cardinality)
801 {
802 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
803 editMField(MainTypesFieldMask, _mfMainTypes);
804 editMField(CardinalityFieldMask, _mfCardinality);
805 editMField(IndexFieldMask, _mfIndex);
806 editMField(NamesFieldMask, _mfNames);
807 editMField(FloatValuesFieldMask, _mfFloatValues);
808 editSField(NameToIndexFieldMask);
809
810 _mfFundamentalTypes.push_back(FLOAT_T);
811 _mfMainTypes .push_back(VEC2_T);
812 _mfCardinality .push_back(cardinality);
813 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
814 _mfNames .push_back(name);
815
816 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
817
818 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
819
820 UInt8 rows = 2;
821
822 for (UInt32 i = 0; i < cardinality; ++i)
823 for (UInt8 j = 0; j < rows; ++j)
824 _mfFloatValues.push_back(0.f);
825
826 OSG_ASSERT(invariantOnStorageSize());
827
828 return index;
829 }
830
831 UInt32 UniformBufferObjChunk::addVec3(const std::string& name, UInt32 cardinality)
832 {
833 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
834 editMField(MainTypesFieldMask, _mfMainTypes);
835 editMField(CardinalityFieldMask, _mfCardinality);
836 editMField(IndexFieldMask, _mfIndex);
837 editMField(NamesFieldMask, _mfNames);
838 editMField(FloatValuesFieldMask, _mfFloatValues);
839 editSField(NameToIndexFieldMask);
840
841 _mfFundamentalTypes.push_back(FLOAT_T);
842 _mfMainTypes .push_back(VEC3_T);
843 _mfCardinality .push_back(cardinality);
844 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
845 _mfNames .push_back(name);
846
847 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
848
849 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
850
851 UInt8 rows = 3;
852
853 for (UInt32 i = 0; i < cardinality; ++i)
854 for (UInt8 j = 0; j < rows; ++j)
855 _mfFloatValues.push_back(0.f);
856
857 OSG_ASSERT(invariantOnStorageSize());
858
859 return index;
860 }
861
862 UInt32 UniformBufferObjChunk::addVec4(const std::string& name, UInt32 cardinality)
863 {
864 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
865 editMField(MainTypesFieldMask, _mfMainTypes);
866 editMField(CardinalityFieldMask, _mfCardinality);
867 editMField(IndexFieldMask, _mfIndex);
868 editMField(NamesFieldMask, _mfNames);
869 editMField(FloatValuesFieldMask, _mfFloatValues);
870 editSField(NameToIndexFieldMask);
871
872 _mfFundamentalTypes.push_back(FLOAT_T);
873 _mfMainTypes .push_back(VEC4_T);
874 _mfCardinality .push_back(cardinality);
875 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
876 _mfNames .push_back(name);
877
878 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
879
880 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
881
882 UInt8 rows = 4;
883
884 for (UInt32 i = 0; i < cardinality; ++i)
885 for (UInt8 j = 0; j < rows; ++j)
886 _mfFloatValues.push_back(0.f);
887
888 OSG_ASSERT(invariantOnStorageSize());
889
890 return index;
891 }
892
893 UInt32 UniformBufferObjChunk::addDVec2(const std::string& name, UInt32 cardinality)
894 {
895 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
896 editMField(MainTypesFieldMask, _mfMainTypes);
897 editMField(CardinalityFieldMask, _mfCardinality);
898 editMField(IndexFieldMask, _mfIndex);
899 editMField(NamesFieldMask, _mfNames);
900 editMField(DoubleValuesFieldMask, _mfDoubleValues);
901 editSField(NameToIndexFieldMask);
902
903 _mfFundamentalTypes.push_back(DOUBLE_T);
904 _mfMainTypes .push_back(VEC2_T);
905 _mfCardinality .push_back(cardinality);
906 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
907 _mfNames .push_back(name);
908
909 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
910
911 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
912
913 UInt8 rows = 2;
914
915 for (UInt32 i = 0; i < cardinality; ++i)
916 for (UInt8 j = 0; j < rows; ++j)
917 _mfDoubleValues.push_back(0.);
918
919 OSG_ASSERT(invariantOnStorageSize());
920
921 return index;
922 }
923
924 UInt32 UniformBufferObjChunk::addDVec3(const std::string& name, UInt32 cardinality)
925 {
926 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
927 editMField(MainTypesFieldMask, _mfMainTypes);
928 editMField(CardinalityFieldMask, _mfCardinality);
929 editMField(IndexFieldMask, _mfIndex);
930 editMField(NamesFieldMask, _mfNames);
931 editMField(DoubleValuesFieldMask, _mfDoubleValues);
932 editSField(NameToIndexFieldMask);
933
934 _mfFundamentalTypes.push_back(DOUBLE_T);
935 _mfMainTypes .push_back(VEC3_T);
936 _mfCardinality .push_back(cardinality);
937 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
938 _mfNames .push_back(name);
939
940 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
941
942 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
943
944 UInt8 rows = 3;
945
946 for (UInt32 i = 0; i < cardinality; ++i)
947 for (UInt8 j = 0; j < rows; ++j)
948 _mfDoubleValues.push_back(0.);
949
950 OSG_ASSERT(invariantOnStorageSize());
951
952 return index;
953 }
954
955 UInt32 UniformBufferObjChunk::addDVec4(const std::string& name, UInt32 cardinality)
956 {
957 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
958 editMField(MainTypesFieldMask, _mfMainTypes);
959 editMField(CardinalityFieldMask, _mfCardinality);
960 editMField(IndexFieldMask, _mfIndex);
961 editMField(NamesFieldMask, _mfNames);
962 editMField(DoubleValuesFieldMask, _mfDoubleValues);
963 editSField(NameToIndexFieldMask);
964
965 _mfFundamentalTypes.push_back(DOUBLE_T);
966 _mfMainTypes .push_back(VEC4_T);
967 _mfCardinality .push_back(cardinality);
968 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
969 _mfNames .push_back(name);
970
971 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
972
973 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
974
975 UInt8 rows = 4;
976
977 for (UInt32 i = 0; i < cardinality; ++i)
978 for (UInt8 j = 0; j < rows; ++j)
979 _mfDoubleValues.push_back(0.);
980
981 OSG_ASSERT(invariantOnStorageSize());
982
983 return index;
984 }
985
986 UInt32 UniformBufferObjChunk::addIVec2(const std::string& name, UInt32 cardinality)
987 {
988 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
989 editMField(MainTypesFieldMask, _mfMainTypes);
990 editMField(CardinalityFieldMask, _mfCardinality);
991 editMField(IndexFieldMask, _mfIndex);
992 editMField(NamesFieldMask, _mfNames);
993 editMField(IntValuesFieldMask, _mfIntValues);
994 editSField(NameToIndexFieldMask);
995
996 _mfFundamentalTypes.push_back(INT_T);
997 _mfMainTypes .push_back(VEC2_T);
998 _mfCardinality .push_back(cardinality);
999 _mfIndex .push_back(static_cast<UInt32>(_mfIntValues.size()));
1000 _mfNames .push_back(name);
1001
1002 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1003
1004 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1005
1006 UInt8 rows = 2;
1007
1008 for (UInt32 i = 0; i < cardinality; ++i)
1009 for (UInt8 j = 0; j < rows; ++j)
1010 _mfIntValues.push_back(0);
1011
1012 OSG_ASSERT(invariantOnStorageSize());
1013
1014 return index;
1015 }
1016
1017 UInt32 UniformBufferObjChunk::addIVec3(const std::string& name, UInt32 cardinality)
1018 {
1019 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1020 editMField(MainTypesFieldMask, _mfMainTypes);
1021 editMField(CardinalityFieldMask, _mfCardinality);
1022 editMField(IndexFieldMask, _mfIndex);
1023 editMField(NamesFieldMask, _mfNames);
1024 editMField(IntValuesFieldMask, _mfIntValues);
1025 editSField(NameToIndexFieldMask);
1026
1027 _mfFundamentalTypes.push_back(INT_T);
1028 _mfMainTypes .push_back(VEC3_T);
1029 _mfCardinality .push_back(cardinality);
1030 _mfIndex .push_back(static_cast<UInt32>(_mfIntValues.size()));
1031 _mfNames .push_back(name);
1032
1033 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1034
1035 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1036
1037 UInt8 rows = 3;
1038
1039 for (UInt32 i = 0; i < cardinality; ++i)
1040 for (UInt8 j = 0; j < rows; ++j)
1041 _mfIntValues.push_back(0);
1042
1043 OSG_ASSERT(invariantOnStorageSize());
1044
1045 return index;
1046 }
1047
1048 UInt32 UniformBufferObjChunk::addIVec4(const std::string& name, UInt32 cardinality)
1049 {
1050 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1051 editMField(MainTypesFieldMask, _mfMainTypes);
1052 editMField(CardinalityFieldMask, _mfCardinality);
1053 editMField(IndexFieldMask, _mfIndex);
1054 editMField(NamesFieldMask, _mfNames);
1055 editMField(IntValuesFieldMask, _mfIntValues);
1056 editSField(NameToIndexFieldMask);
1057
1058 _mfFundamentalTypes.push_back(INT_T);
1059 _mfMainTypes .push_back(VEC4_T);
1060 _mfCardinality .push_back(cardinality);
1061 _mfIndex .push_back(static_cast<UInt32>(_mfIntValues.size()));
1062 _mfNames .push_back(name);
1063
1064 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1065
1066 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1067
1068 UInt8 rows = 4;
1069
1070 for (UInt32 i = 0; i < cardinality; ++i)
1071 for (UInt8 j = 0; j < rows; ++j)
1072 _mfIntValues.push_back(0);
1073
1074 OSG_ASSERT(invariantOnStorageSize());
1075
1076 return index;
1077 }
1078
1079 UInt32 UniformBufferObjChunk::addUVec2(const std::string& name, UInt32 cardinality)
1080 {
1081 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1082 editMField(MainTypesFieldMask, _mfMainTypes);
1083 editMField(CardinalityFieldMask, _mfCardinality);
1084 editMField(IndexFieldMask, _mfIndex);
1085 editMField(NamesFieldMask, _mfNames);
1086 editMField(UIntValuesFieldMask, _mfUIntValues);
1087 editSField(NameToIndexFieldMask);
1088
1089 _mfFundamentalTypes.push_back(UINT_T);
1090 _mfMainTypes .push_back(VEC2_T);
1091 _mfCardinality .push_back(cardinality);
1092 _mfIndex .push_back(static_cast<UInt32>(_mfUIntValues.size()));
1093 _mfNames .push_back(name);
1094
1095 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1096
1097 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1098
1099 UInt8 rows = 2;
1100
1101 for (UInt32 i = 0; i < cardinality; ++i)
1102 for (UInt8 j = 0; j < rows; ++j)
1103 _mfUIntValues.push_back(0);
1104
1105 OSG_ASSERT(invariantOnStorageSize());
1106
1107 return index;
1108 }
1109
1110 UInt32 UniformBufferObjChunk::addUVec3(const std::string& name, UInt32 cardinality)
1111 {
1112 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1113 editMField(MainTypesFieldMask, _mfMainTypes);
1114 editMField(CardinalityFieldMask, _mfCardinality);
1115 editMField(IndexFieldMask, _mfIndex);
1116 editMField(NamesFieldMask, _mfNames);
1117 editMField(UIntValuesFieldMask, _mfUIntValues);
1118 editSField(NameToIndexFieldMask);
1119
1120 _mfFundamentalTypes.push_back(UINT_T);
1121 _mfMainTypes .push_back(VEC3_T);
1122 _mfCardinality .push_back(cardinality);
1123 _mfIndex .push_back(static_cast<UInt32>(_mfUIntValues.size()));
1124 _mfNames .push_back(name);
1125
1126 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1127
1128 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1129
1130 UInt8 rows = 3;
1131
1132 for (UInt32 i = 0; i < cardinality; ++i)
1133 for (UInt8 j = 0; j < rows; ++j)
1134 _mfUIntValues.push_back(0);
1135
1136 OSG_ASSERT(invariantOnStorageSize());
1137
1138 return index;
1139 }
1140
1141 UInt32 UniformBufferObjChunk::addUVec4(const std::string& name, UInt32 cardinality)
1142 {
1143 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1144 editMField(MainTypesFieldMask, _mfMainTypes);
1145 editMField(CardinalityFieldMask, _mfCardinality);
1146 editMField(IndexFieldMask, _mfIndex);
1147 editMField(NamesFieldMask, _mfNames);
1148 editMField(UIntValuesFieldMask, _mfUIntValues);
1149 editSField(NameToIndexFieldMask);
1150
1151 _mfFundamentalTypes.push_back(UINT_T);
1152 _mfMainTypes .push_back(VEC4_T);
1153 _mfCardinality .push_back(cardinality);
1154 _mfIndex .push_back(static_cast<UInt32>(_mfUIntValues.size()));
1155 _mfNames .push_back(name);
1156
1157 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1158
1159 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1160
1161 UInt8 rows = 4;
1162
1163 for (UInt32 i = 0; i < cardinality; ++i)
1164 for (UInt8 j = 0; j < rows; ++j)
1165 _mfUIntValues.push_back(0);
1166
1167 OSG_ASSERT(invariantOnStorageSize());
1168
1169 return index;
1170 }
1171
1172 UInt32 UniformBufferObjChunk::addBVec2(const std::string& name, UInt32 cardinality)
1173 {
1174 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1175 editMField(MainTypesFieldMask, _mfMainTypes);
1176 editMField(CardinalityFieldMask, _mfCardinality);
1177 editMField(IndexFieldMask, _mfIndex);
1178 editMField(NamesFieldMask, _mfNames);
1179 editMField(BoolValuesFieldMask, _mfBoolValues);
1180 editSField(NameToIndexFieldMask);
1181
1182 _mfFundamentalTypes.push_back(BOOL_T);
1183 _mfMainTypes .push_back(VEC2_T);
1184 _mfCardinality .push_back(cardinality);
1185 _mfIndex .push_back(static_cast<UInt32>(_mfBoolValues.size()));
1186 _mfNames .push_back(name);
1187
1188 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1189
1190 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1191
1192 UInt8 rows = 2;
1193
1194 for (UInt32 i = 0; i < cardinality; ++i)
1195 for (UInt8 j = 0; j < rows; ++j)
1196 _mfBoolValues.push_back(static_cast<UInt8>(false));
1197
1198 OSG_ASSERT(invariantOnStorageSize());
1199
1200 return index;
1201 }
1202
1203 UInt32 UniformBufferObjChunk::addBVec3(const std::string& name, UInt32 cardinality)
1204 {
1205 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1206 editMField(MainTypesFieldMask, _mfMainTypes);
1207 editMField(CardinalityFieldMask, _mfCardinality);
1208 editMField(IndexFieldMask, _mfIndex);
1209 editMField(NamesFieldMask, _mfNames);
1210 editMField(BoolValuesFieldMask, _mfBoolValues);
1211 editSField(NameToIndexFieldMask);
1212
1213 _mfFundamentalTypes.push_back(BOOL_T);
1214 _mfMainTypes .push_back(VEC3_T);
1215 _mfCardinality .push_back(cardinality);
1216 _mfIndex .push_back(static_cast<UInt32>(_mfBoolValues.size()));
1217 _mfNames .push_back(name);
1218
1219 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1220
1221 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1222
1223 UInt8 rows = 3;
1224
1225 for (UInt32 i = 0; i < cardinality; ++i)
1226 for (UInt8 j = 0; j < rows; ++j)
1227 _mfBoolValues.push_back(static_cast<UInt8>(false));
1228
1229 OSG_ASSERT(invariantOnStorageSize());
1230
1231 return index;
1232 }
1233
1234 UInt32 UniformBufferObjChunk::addBVec4(const std::string& name, UInt32 cardinality)
1235 {
1236 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1237 editMField(MainTypesFieldMask, _mfMainTypes);
1238 editMField(CardinalityFieldMask, _mfCardinality);
1239 editMField(IndexFieldMask, _mfIndex);
1240 editMField(NamesFieldMask, _mfNames);
1241 editMField(BoolValuesFieldMask, _mfBoolValues);
1242 editSField(NameToIndexFieldMask);
1243
1244 _mfFundamentalTypes.push_back(BOOL_T);
1245 _mfMainTypes .push_back(VEC4_T);
1246 _mfCardinality .push_back(cardinality);
1247 _mfIndex .push_back(static_cast<UInt32>(_mfBoolValues.size()));
1248 _mfNames .push_back(name);
1249
1250 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1251
1252 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1253
1254 UInt8 rows = 4;
1255
1256 for (UInt32 i = 0; i < cardinality; ++i)
1257 for (UInt8 j = 0; j < rows; ++j)
1258 _mfBoolValues.push_back(static_cast<UInt8>(false));
1259
1260 OSG_ASSERT(invariantOnStorageSize());
1261
1262 return index;
1263 }
1264
1265 UInt32 UniformBufferObjChunk::addMat2(const std::string& name, UInt32 cardinality)
1266 {
1267 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1268 editMField(MainTypesFieldMask, _mfMainTypes);
1269 editMField(CardinalityFieldMask, _mfCardinality);
1270 editMField(IndexFieldMask, _mfIndex);
1271 editMField(NamesFieldMask, _mfNames);
1272 editMField(FloatValuesFieldMask, _mfFloatValues);
1273 editSField(NameToIndexFieldMask);
1274
1275 _mfFundamentalTypes.push_back(FLOAT_T);
1276 _mfMainTypes .push_back(MAT2_T);
1277 _mfCardinality .push_back(cardinality);
1278 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1279 _mfNames .push_back(name);
1280
1281 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1282
1283 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1284
1285 UInt8 columns = 2;
1286 UInt8 rows = 2;
1287
1288 for (UInt32 i = 0; i < cardinality; ++i)
1289 for (UInt8 j = 0; j < columns; ++j)
1290 for (UInt8 k = 0; k < rows; ++k)
1291 _mfFloatValues.push_back(0.f);
1292
1293 OSG_ASSERT(invariantOnStorageSize());
1294
1295 return index;
1296 }
1297
1298 UInt32 UniformBufferObjChunk::addMat3(const std::string& name, UInt32 cardinality)
1299 {
1300 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1301 editMField(MainTypesFieldMask, _mfMainTypes);
1302 editMField(CardinalityFieldMask, _mfCardinality);
1303 editMField(IndexFieldMask, _mfIndex);
1304 editMField(NamesFieldMask, _mfNames);
1305 editMField(FloatValuesFieldMask, _mfFloatValues);
1306 editSField(NameToIndexFieldMask);
1307
1308 _mfFundamentalTypes.push_back(FLOAT_T);
1309 _mfMainTypes .push_back(MAT3_T);
1310 _mfCardinality .push_back(cardinality);
1311 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1312 _mfNames .push_back(name);
1313
1314 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1315
1316 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1317
1318 UInt8 columns = 3;
1319 UInt8 rows = 3;
1320
1321 for (UInt32 i = 0; i < cardinality; ++i)
1322 for (UInt8 j = 0; j < columns; ++j)
1323 for (UInt8 k = 0; k < rows; ++k)
1324 _mfFloatValues.push_back(0.f);
1325
1326 OSG_ASSERT(invariantOnStorageSize());
1327
1328 return index;
1329 }
1330
1331 UInt32 UniformBufferObjChunk::addMat4(const std::string& name, UInt32 cardinality)
1332 {
1333 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1334 editMField(MainTypesFieldMask, _mfMainTypes);
1335 editMField(CardinalityFieldMask, _mfCardinality);
1336 editMField(IndexFieldMask, _mfIndex);
1337 editMField(NamesFieldMask, _mfNames);
1338 editMField(FloatValuesFieldMask, _mfFloatValues);
1339 editSField(NameToIndexFieldMask);
1340
1341 _mfFundamentalTypes.push_back(FLOAT_T);
1342 _mfMainTypes .push_back(MAT4_T);
1343 _mfCardinality .push_back(cardinality);
1344 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1345 _mfNames .push_back(name);
1346
1347 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1348
1349 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1350
1351 UInt8 columns = 4;
1352 UInt8 rows = 4;
1353
1354 for (UInt32 i = 0; i < cardinality; ++i)
1355 for (UInt8 j = 0; j < columns; ++j)
1356 for (UInt8 k = 0; k < rows; ++k)
1357 _mfFloatValues.push_back(0.f);
1358
1359 OSG_ASSERT(invariantOnStorageSize());
1360
1361 return index;
1362 }
1363
1364 UInt32 UniformBufferObjChunk::addDMat2(const std::string& name, UInt32 cardinality)
1365 {
1366 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1367 editMField(MainTypesFieldMask, _mfMainTypes);
1368 editMField(CardinalityFieldMask, _mfCardinality);
1369 editMField(IndexFieldMask, _mfIndex);
1370 editMField(NamesFieldMask, _mfNames);
1371 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1372 editSField(NameToIndexFieldMask);
1373
1374 _mfFundamentalTypes.push_back(DOUBLE_T);
1375 _mfMainTypes .push_back(MAT2_T);
1376 _mfCardinality .push_back(cardinality);
1377 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1378 _mfNames .push_back(name);
1379
1380 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1381
1382 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1383
1384 UInt8 columns = 2;
1385 UInt8 rows = 2;
1386
1387 for (UInt32 i = 0; i < cardinality; ++i)
1388 for (UInt8 j = 0; j < columns; ++j)
1389 for (UInt8 k = 0; k < rows; ++k)
1390 _mfDoubleValues.push_back(0.f);
1391
1392 OSG_ASSERT(invariantOnStorageSize());
1393
1394 return index;
1395 }
1396
1397 UInt32 UniformBufferObjChunk::addDMat3(const std::string& name, UInt32 cardinality)
1398 {
1399 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1400 editMField(MainTypesFieldMask, _mfMainTypes);
1401 editMField(CardinalityFieldMask, _mfCardinality);
1402 editMField(IndexFieldMask, _mfIndex);
1403 editMField(NamesFieldMask, _mfNames);
1404 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1405 editSField(NameToIndexFieldMask);
1406
1407 _mfFundamentalTypes.push_back(DOUBLE_T);
1408 _mfMainTypes .push_back(MAT3_T);
1409 _mfCardinality .push_back(cardinality);
1410 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1411 _mfNames .push_back(name);
1412
1413 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1414
1415 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1416
1417 UInt8 columns = 3;
1418 UInt8 rows = 3;
1419
1420 for (UInt32 i = 0; i < cardinality; ++i)
1421 for (UInt8 j = 0; j < columns; ++j)
1422 for (UInt8 k = 0; k < rows; ++k)
1423 _mfDoubleValues.push_back(0.f);
1424
1425 OSG_ASSERT(invariantOnStorageSize());
1426
1427 return index;
1428 }
1429
1430 UInt32 UniformBufferObjChunk::addDMat4(const std::string& name, UInt32 cardinality)
1431 {
1432 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1433 editMField(MainTypesFieldMask, _mfMainTypes);
1434 editMField(CardinalityFieldMask, _mfCardinality);
1435 editMField(IndexFieldMask, _mfIndex);
1436 editMField(NamesFieldMask, _mfNames);
1437 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1438 editSField(NameToIndexFieldMask);
1439
1440 _mfFundamentalTypes.push_back(DOUBLE_T);
1441 _mfMainTypes .push_back(MAT4_T);
1442 _mfCardinality .push_back(cardinality);
1443 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1444 _mfNames .push_back(name);
1445
1446 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1447
1448 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1449
1450 UInt8 columns = 4;
1451 UInt8 rows = 4;
1452
1453 for (UInt32 i = 0; i < cardinality; ++i)
1454 for (UInt8 j = 0; j < columns; ++j)
1455 for (UInt8 k = 0; k < rows; ++k)
1456 _mfDoubleValues.push_back(0.f);
1457
1458 OSG_ASSERT(invariantOnStorageSize());
1459
1460 return index;
1461 }
1462
1463 UInt32 UniformBufferObjChunk::addMat2x3(const std::string& name, UInt32 cardinality)
1464 {
1465 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1466 editMField(MainTypesFieldMask, _mfMainTypes);
1467 editMField(CardinalityFieldMask, _mfCardinality);
1468 editMField(IndexFieldMask, _mfIndex);
1469 editMField(NamesFieldMask, _mfNames);
1470 editMField(FloatValuesFieldMask, _mfFloatValues);
1471 editSField(NameToIndexFieldMask);
1472
1473 _mfFundamentalTypes.push_back(FLOAT_T);
1474 _mfMainTypes .push_back(MAT2X3_T);
1475 _mfCardinality .push_back(cardinality);
1476 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1477 _mfNames .push_back(name);
1478
1479 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1480
1481 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1482
1483 UInt8 columns = 2;
1484 UInt8 rows = 3;
1485
1486 for (UInt32 i = 0; i < cardinality; ++i)
1487 for (UInt8 j = 0; j < columns; ++j)
1488 for (UInt8 k = 0; k < rows; ++k)
1489 _mfFloatValues.push_back(0.f);
1490
1491 OSG_ASSERT(invariantOnStorageSize());
1492
1493 return index;
1494 }
1495
1496 UInt32 UniformBufferObjChunk::addMat3x2(const std::string& name, UInt32 cardinality)
1497 {
1498 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1499 editMField(MainTypesFieldMask, _mfMainTypes);
1500 editMField(CardinalityFieldMask, _mfCardinality);
1501 editMField(IndexFieldMask, _mfIndex);
1502 editMField(NamesFieldMask, _mfNames);
1503 editMField(FloatValuesFieldMask, _mfFloatValues);
1504 editSField(NameToIndexFieldMask);
1505
1506 _mfFundamentalTypes.push_back(FLOAT_T);
1507 _mfMainTypes .push_back(MAT3X2_T);
1508 _mfCardinality .push_back(cardinality);
1509 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1510 _mfNames .push_back(name);
1511
1512 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1513
1514 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1515
1516 UInt8 columns = 3;
1517 UInt8 rows = 2;
1518
1519 for (UInt32 i = 0; i < cardinality; ++i)
1520 for (UInt8 j = 0; j < columns; ++j)
1521 for (UInt8 k = 0; k < rows; ++k)
1522 _mfFloatValues.push_back(0.f);
1523 OSG_ASSERT(invariantOnStorageSize());
1524
1525 return index;
1526 }
1527
1528 UInt32 UniformBufferObjChunk::addMat2x4(const std::string& name, UInt32 cardinality)
1529 {
1530 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1531 editMField(MainTypesFieldMask, _mfMainTypes);
1532 editMField(CardinalityFieldMask, _mfCardinality);
1533 editMField(IndexFieldMask, _mfIndex);
1534 editMField(NamesFieldMask, _mfNames);
1535 editMField(FloatValuesFieldMask, _mfFloatValues);
1536 editSField(NameToIndexFieldMask);
1537
1538 _mfFundamentalTypes.push_back(FLOAT_T);
1539 _mfMainTypes .push_back(MAT2X4_T);
1540 _mfCardinality .push_back(cardinality);
1541 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1542 _mfNames .push_back(name);
1543
1544 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1545
1546 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1547
1548 UInt8 columns = 2;
1549 UInt8 rows = 4;
1550
1551 for (UInt32 i = 0; i < cardinality; ++i)
1552 for (UInt8 j = 0; j < columns; ++j)
1553 for (UInt8 k = 0; k < rows; ++k)
1554 _mfFloatValues.push_back(0.f);
1555
1556 OSG_ASSERT(invariantOnStorageSize());
1557
1558 return index;
1559 }
1560
1561 UInt32 UniformBufferObjChunk::addMat4x2(const std::string& name, UInt32 cardinality)
1562 {
1563 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1564 editMField(MainTypesFieldMask, _mfMainTypes);
1565 editMField(CardinalityFieldMask, _mfCardinality);
1566 editMField(IndexFieldMask, _mfIndex);
1567 editMField(NamesFieldMask, _mfNames);
1568 editMField(FloatValuesFieldMask, _mfFloatValues);
1569 editSField(NameToIndexFieldMask);
1570
1571 _mfFundamentalTypes.push_back(FLOAT_T);
1572 _mfMainTypes .push_back(MAT4X2_T);
1573 _mfCardinality .push_back(cardinality);
1574 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1575 _mfNames .push_back(name);
1576
1577 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1578
1579 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1580
1581 UInt8 columns = 4;
1582 UInt8 rows = 2;
1583
1584 for (UInt32 i = 0; i < cardinality; ++i)
1585 for (UInt8 j = 0; j < columns; ++j)
1586 for (UInt8 k = 0; k < rows; ++k)
1587 _mfFloatValues.push_back(0.f);
1588
1589 OSG_ASSERT(invariantOnStorageSize());
1590
1591 return index;
1592 }
1593
1594 UInt32 UniformBufferObjChunk::addMat3x4(const std::string& name, UInt32 cardinality)
1595 {
1596 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1597 editMField(MainTypesFieldMask, _mfMainTypes);
1598 editMField(CardinalityFieldMask, _mfCardinality);
1599 editMField(IndexFieldMask, _mfIndex);
1600 editMField(NamesFieldMask, _mfNames);
1601 editMField(FloatValuesFieldMask, _mfFloatValues);
1602 editSField(NameToIndexFieldMask);
1603
1604 _mfFundamentalTypes.push_back(FLOAT_T);
1605 _mfMainTypes .push_back(MAT3X4_T);
1606 _mfCardinality .push_back(cardinality);
1607 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1608 _mfNames .push_back(name);
1609
1610 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1611
1612 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1613
1614 UInt8 columns = 3;
1615 UInt8 rows = 4;
1616
1617 for (UInt32 i = 0; i < cardinality; ++i)
1618 for (UInt8 j = 0; j < columns; ++j)
1619 for (UInt8 k = 0; k < rows; ++k)
1620 _mfFloatValues.push_back(0.f);
1621
1622 OSG_ASSERT(invariantOnStorageSize());
1623
1624 return index;
1625 }
1626
1627 UInt32 UniformBufferObjChunk::addMat4x3(const std::string& name, UInt32 cardinality)
1628 {
1629 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1630 editMField(MainTypesFieldMask, _mfMainTypes);
1631 editMField(CardinalityFieldMask, _mfCardinality);
1632 editMField(IndexFieldMask, _mfIndex);
1633 editMField(NamesFieldMask, _mfNames);
1634 editMField(FloatValuesFieldMask, _mfFloatValues);
1635 editSField(NameToIndexFieldMask);
1636
1637 _mfFundamentalTypes.push_back(FLOAT_T);
1638 _mfMainTypes .push_back(MAT4X3_T);
1639 _mfCardinality .push_back(cardinality);
1640 _mfIndex .push_back(static_cast<UInt32>(_mfFloatValues.size()));
1641 _mfNames .push_back(name);
1642
1643 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1644
1645 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1646
1647 UInt8 columns = 4;
1648 UInt8 rows = 3;
1649
1650 for (UInt32 i = 0; i < cardinality; ++i)
1651 for (UInt8 j = 0; j < columns; ++j)
1652 for (UInt8 k = 0; k < rows; ++k)
1653 _mfFloatValues.push_back(0.f);
1654
1655 OSG_ASSERT(invariantOnStorageSize());
1656
1657 return index;
1658 }
1659
1660 UInt32 UniformBufferObjChunk::addDMat2x3(const std::string& name, UInt32 cardinality)
1661 {
1662 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1663 editMField(MainTypesFieldMask, _mfMainTypes);
1664 editMField(CardinalityFieldMask, _mfCardinality);
1665 editMField(IndexFieldMask, _mfIndex);
1666 editMField(NamesFieldMask, _mfNames);
1667 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1668 editSField(NameToIndexFieldMask);
1669
1670 _mfFundamentalTypes.push_back(DOUBLE_T);
1671 _mfMainTypes .push_back(MAT2X3_T);
1672 _mfCardinality .push_back(cardinality);
1673 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1674 _mfNames .push_back(name);
1675
1676 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1677
1678 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1679
1680 UInt8 columns = 2;
1681 UInt8 rows = 3;
1682
1683 for (UInt32 i = 0; i < cardinality; ++i)
1684 for (UInt8 j = 0; j < columns; ++j)
1685 for (UInt8 k = 0; k < rows; ++k)
1686 _mfDoubleValues.push_back(0.f);
1687
1688 OSG_ASSERT(invariantOnStorageSize());
1689
1690 return index;
1691 }
1692
1693 UInt32 UniformBufferObjChunk::addDMat3x2(const std::string& name, UInt32 cardinality)
1694 {
1695 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1696 editMField(MainTypesFieldMask, _mfMainTypes);
1697 editMField(CardinalityFieldMask, _mfCardinality);
1698 editMField(IndexFieldMask, _mfIndex);
1699 editMField(NamesFieldMask, _mfNames);
1700 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1701 editSField(NameToIndexFieldMask);
1702
1703 _mfFundamentalTypes.push_back(DOUBLE_T);
1704 _mfMainTypes .push_back(MAT3X2_T);
1705 _mfCardinality .push_back(cardinality);
1706 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1707 _mfNames .push_back(name);
1708
1709 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1710
1711 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1712
1713 UInt8 columns = 3;
1714 UInt8 rows = 2;
1715
1716 for (UInt32 i = 0; i < cardinality; ++i)
1717 for (UInt8 j = 0; j < columns; ++j)
1718 for (UInt8 k = 0; k < rows; ++k)
1719 _mfDoubleValues.push_back(0.f);
1720
1721 OSG_ASSERT(invariantOnStorageSize());
1722
1723 return index;
1724 }
1725
1726 UInt32 UniformBufferObjChunk::addDMat2x4(const std::string& name, UInt32 cardinality)
1727 {
1728 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1729 editMField(MainTypesFieldMask, _mfMainTypes);
1730 editMField(CardinalityFieldMask, _mfCardinality);
1731 editMField(IndexFieldMask, _mfIndex);
1732 editMField(NamesFieldMask, _mfNames);
1733 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1734 editSField(NameToIndexFieldMask);
1735
1736 _mfFundamentalTypes.push_back(DOUBLE_T);
1737 _mfMainTypes .push_back(MAT2X4_T);
1738 _mfCardinality .push_back(cardinality);
1739 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1740 _mfNames .push_back(name);
1741
1742 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1743
1744 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1745
1746 UInt8 columns = 2;
1747 UInt8 rows = 4;
1748
1749 for (UInt32 i = 0; i < cardinality; ++i)
1750 for (UInt8 j = 0; j < columns; ++j)
1751 for (UInt8 k = 0; k < rows; ++k)
1752 _mfDoubleValues.push_back(0.f);
1753
1754 OSG_ASSERT(invariantOnStorageSize());
1755
1756 return index;
1757 }
1758
1759 UInt32 UniformBufferObjChunk::addDMat4x2(const std::string& name, UInt32 cardinality)
1760 {
1761 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1762 editMField(MainTypesFieldMask, _mfMainTypes);
1763 editMField(CardinalityFieldMask, _mfCardinality);
1764 editMField(IndexFieldMask, _mfIndex);
1765 editMField(NamesFieldMask, _mfNames);
1766 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1767 editSField(NameToIndexFieldMask);
1768
1769 _mfFundamentalTypes.push_back(DOUBLE_T);
1770 _mfMainTypes .push_back(MAT4X2_T);
1771 _mfCardinality .push_back(cardinality);
1772 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1773 _mfNames .push_back(name);
1774
1775 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1776
1777 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1778
1779 UInt8 columns = 4;
1780 UInt8 rows = 2;
1781
1782 for (UInt32 i = 0; i < cardinality; ++i)
1783 for (UInt8 j = 0; j < columns; ++j)
1784 for (UInt8 k = 0; k < rows; ++k)
1785 _mfDoubleValues.push_back(0.f);
1786
1787 OSG_ASSERT(invariantOnStorageSize());
1788
1789 return index;
1790 }
1791
1792 UInt32 UniformBufferObjChunk::addDMat3x4(const std::string& name, UInt32 cardinality)
1793 {
1794 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1795 editMField(MainTypesFieldMask, _mfMainTypes);
1796 editMField(CardinalityFieldMask, _mfCardinality);
1797 editMField(IndexFieldMask, _mfIndex);
1798 editMField(NamesFieldMask, _mfNames);
1799 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1800 editSField(NameToIndexFieldMask);
1801
1802 _mfFundamentalTypes.push_back(DOUBLE_T);
1803 _mfMainTypes .push_back(MAT3X4_T);
1804 _mfCardinality .push_back(cardinality);
1805 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1806 _mfNames .push_back(name);
1807
1808 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1809
1810 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1811
1812 UInt8 columns = 3;
1813 UInt8 rows = 4;
1814
1815 for (UInt32 i = 0; i < cardinality; ++i)
1816 for (UInt8 j = 0; j < columns; ++j)
1817 for (UInt8 k = 0; k < rows; ++k)
1818 _mfDoubleValues.push_back(0.f);
1819
1820 OSG_ASSERT(invariantOnStorageSize());
1821
1822 return index;
1823 }
1824
1825 UInt32 UniformBufferObjChunk::addDMat4x3(const std::string& name, UInt32 cardinality)
1826 {
1827 editMField(FundamentalTypesFieldMask, _mfFundamentalTypes);
1828 editMField(MainTypesFieldMask, _mfMainTypes);
1829 editMField(CardinalityFieldMask, _mfCardinality);
1830 editMField(IndexFieldMask, _mfIndex);
1831 editMField(NamesFieldMask, _mfNames);
1832 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1833 editSField(NameToIndexFieldMask);
1834
1835 _mfFundamentalTypes.push_back(DOUBLE_T);
1836 _mfMainTypes .push_back(MAT4X3_T);
1837 _mfCardinality .push_back(cardinality);
1838 _mfIndex .push_back(static_cast<UInt32>(_mfDoubleValues.size()));
1839 _mfNames .push_back(name);
1840
1841 UInt32 index = static_cast<UInt32>(_mfIndex.size()) - 1;
1842
1843 _sfNameToIndex.getValue().insert(StringToUInt32Map::value_type(name, index));
1844
1845 UInt8 columns = 4;
1846 UInt8 rows = 3;
1847
1848 for (UInt32 i = 0; i < cardinality; ++i)
1849 for (UInt8 j = 0; j < columns; ++j)
1850 for (UInt8 k = 0; k < rows; ++k)
1851 _mfDoubleValues.push_back(0.f);
1852
1853 OSG_ASSERT(invariantOnStorageSize());
1854
1855 return index;
1856 }
1857
1858 /*------------------------------ set-interface I ----------------------------*/
1859
1860 void UniformBufferObjChunk::setFloat(UInt32 handle, Real32 value, UInt32 array_idx)
1861 {
1862 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1863
1864 editMField(FloatValuesFieldMask, _mfFloatValues);
1865 _mfFloatValues[_mfIndex[handle] + array_idx] = value;
1866 }
1867
1868 void UniformBufferObjChunk::setDouble(UInt32 handle, Real64 value, UInt32 array_idx)
1869 {
1870 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1871
1872 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1873 _mfDoubleValues[_mfIndex[handle] + array_idx] = value;
1874 }
1875
1876 void UniformBufferObjChunk::setInt(UInt32 handle, Int32 value, UInt32 array_idx)
1877 {
1878 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1879
1880 editMField(IntValuesFieldMask, _mfIntValues);
1881 _mfIntValues[_mfIndex[handle] + array_idx] = value;
1882 }
1883
1884 void UniformBufferObjChunk::setUInt(UInt32 handle, UInt32 value, UInt32 array_idx)
1885 {
1886 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1887
1888 editMField(UIntValuesFieldMask, _mfUIntValues);
1889 _mfUIntValues[_mfIndex[handle] + array_idx] = value;
1890 }
1891
1892 void UniformBufferObjChunk::setBool(UInt32 handle, bool value, UInt32 array_idx)
1893 {
1894 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1895
1896 editMField(BoolValuesFieldMask, _mfBoolValues);
1897 _mfBoolValues[_mfIndex[handle] + array_idx] = static_cast<UInt8>(value);
1898 }
1899
1900 void UniformBufferObjChunk::setVec2(UInt32 handle, const Vec2f& value, UInt32 array_idx)
1901 {
1902 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1903
1904 editMField(FloatValuesFieldMask, _mfFloatValues);
1905
1906 int size = 2;
1907 for (int i = 0; i < size; ++i)
1908 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1909 }
1910
1911 void UniformBufferObjChunk::setVec2(UInt32 handle, const Pnt2f& value, UInt32 array_idx)
1912 {
1913 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1914
1915 editMField(FloatValuesFieldMask, _mfFloatValues);
1916
1917 int size = 2;
1918 for (int i = 0; i < size; ++i)
1919 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1920 }
1921
1922 void UniformBufferObjChunk::setVec3(UInt32 handle, const Vec3f& value, UInt32 array_idx)
1923 {
1924 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1925
1926 editMField(FloatValuesFieldMask, _mfFloatValues);
1927
1928 int size = 3;
1929 for (int i = 0; i < size; ++i)
1930 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1931 }
1932
1933 void UniformBufferObjChunk::setVec3(UInt32 handle, const Pnt3f& value, UInt32 array_idx)
1934 {
1935 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1936
1937 editMField(FloatValuesFieldMask, _mfFloatValues);
1938
1939 int size = 3;
1940 for (int i = 0; i < size; ++i)
1941 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1942 }
1943
1944 void UniformBufferObjChunk::setVec3(UInt32 handle, const Color3f& value, UInt32 array_idx)
1945 {
1946 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1947
1948 editMField(FloatValuesFieldMask, _mfFloatValues);
1949
1950 int size = 3;
1951 for (int i = 0; i < size; ++i)
1952 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1953 }
1954
1955 void UniformBufferObjChunk::setVec4(UInt32 handle, const Vec4f& value, UInt32 array_idx)
1956 {
1957 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1958
1959 editMField(FloatValuesFieldMask, _mfFloatValues);
1960
1961 int size = 4;
1962 for (int i = 0; i < size; ++i)
1963 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1964 }
1965
1966 void UniformBufferObjChunk::setVec4(UInt32 handle, const Pnt4f& value, UInt32 array_idx)
1967 {
1968 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1969
1970 editMField(FloatValuesFieldMask, _mfFloatValues);
1971
1972 int size = 4;
1973 for (int i = 0; i < size; ++i)
1974 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1975 }
1976
1977 void UniformBufferObjChunk::setVec4(UInt32 handle, const Color4f& value, UInt32 array_idx)
1978 {
1979 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1980
1981 editMField(FloatValuesFieldMask, _mfFloatValues);
1982
1983 int size = 4;
1984 for (int i = 0; i < size; ++i)
1985 _mfFloatValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1986 }
1987
1988 void UniformBufferObjChunk::setDVec2(UInt32 handle, const Vec2d& value, UInt32 array_idx)
1989 {
1990 OSG_ASSERT(array_idx < _mfCardinality[handle]);
1991
1992 editMField(DoubleValuesFieldMask, _mfDoubleValues);
1993
1994 int size = 2;
1995 for (int i = 0; i < size; ++i)
1996 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
1997 }
1998
1999 void UniformBufferObjChunk::setDVec2(UInt32 handle, const Pnt2d& value, UInt32 array_idx)
2000 {
2001 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2002
2003 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2004
2005 int size = 2;
2006 for (int i = 0; i < size; ++i)
2007 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2008 }
2009
2010 void UniformBufferObjChunk::setDVec3(UInt32 handle, const Vec3d& value, UInt32 array_idx)
2011 {
2012 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2013
2014 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2015
2016 int size = 3;
2017 for (int i = 0; i < size; ++i)
2018 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2019 }
2020
2021 void UniformBufferObjChunk::setDVec3(UInt32 handle, const Pnt3d& value, UInt32 array_idx)
2022 {
2023 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2024
2025 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2026
2027 int size = 3;
2028 for (int i = 0; i < size; ++i)
2029 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2030 }
2031
2032 void UniformBufferObjChunk::setDVec4(UInt32 handle, const Vec4d& value, UInt32 array_idx)
2033 {
2034 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2035
2036 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2037
2038 int size = 4;
2039 for (int i = 0; i < size; ++i)
2040 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2041 }
2042
2043 void UniformBufferObjChunk::setDVec4(UInt32 handle, const Pnt4d& value, UInt32 array_idx)
2044 {
2045 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2046
2047 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2048
2049 int size = 4;
2050 for (int i = 0; i < size; ++i)
2051 _mfDoubleValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2052 }
2053
2054 void UniformBufferObjChunk::setIVec2(UInt32 handle, const Vec2i& value, UInt32 array_idx)
2055 {
2056 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2057
2058 editMField(IntValuesFieldMask, _mfIntValues);
2059
2060 int size = 2;
2061 for (int i = 0; i < size; ++i)
2062 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2063 }
2064
2065 void UniformBufferObjChunk::setIVec2(UInt32 handle, const Pnt2i& value, UInt32 array_idx)
2066 {
2067 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2068
2069 editMField(IntValuesFieldMask, _mfIntValues);
2070
2071 int size = 2;
2072 for (int i = 0; i < size; ++i)
2073 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2074 }
2075
2076 void UniformBufferObjChunk::setIVec3(UInt32 handle, const Vec3i& value, UInt32 array_idx)
2077 {
2078 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2079
2080 editMField(IntValuesFieldMask, _mfIntValues);
2081
2082 int size = 3;
2083 for (int i = 0; i < size; ++i)
2084 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2085 }
2086 /*
2087 void UniformBufferObjChunk::setIVec3(UInt32 handle, const Pnt3i& value, UInt32 array_idx)
2088 {
2089 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2090
2091 editMField(IntValuesFieldMask, _mfIntValues);
2092
2093 int size = 3;
2094 for (int i = 0; i < size; ++i)
2095 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2096 }
2097 */
2098 void UniformBufferObjChunk::setIVec4(UInt32 handle, const Vec4i& value, UInt32 array_idx)
2099 {
2100 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2101
2102 editMField(IntValuesFieldMask, _mfIntValues);
2103
2104 int size = 4;
2105 for (int i = 0; i < size; ++i)
2106 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2107 }
2108 /*
2109 void UniformBufferObjChunk::setIVec4(UInt32 handle, const Pnt4i& value, UInt32 array_idx)
2110 {
2111 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2112
2113 editMField(IntValuesFieldMask, _mfIntValues);
2114
2115 int size = 4;
2116 for (int i = 0; i < size; ++i)
2117 _mfIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2118 }
2119 */
2120 void UniformBufferObjChunk::setUVec2(UInt32 handle, const Vec2u& value, UInt32 array_idx)
2121 {
2122 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2123
2124 editMField(UIntValuesFieldMask, _mfUIntValues);
2125
2126 int size = 2;
2127 for (int i = 0; i < size; ++i)
2128 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2129 }
2130 /*
2131 void UniformBufferObjChunk::setUVec2(UInt32 handle, const Pnt2u& value, UInt32 array_idx)
2132 {
2133 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2134
2135 editMField(UIntValuesFieldMask, _mfUIntValues);
2136
2137 int size = 2;
2138 for (int i = 0; i < size; ++i)
2139 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2140 }
2141 */
2142 void UniformBufferObjChunk::setUVec3(UInt32 handle, const Vec3u& value, UInt32 array_idx)
2143 {
2144 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2145
2146 editMField(UIntValuesFieldMask, _mfUIntValues);
2147
2148 int size = 3;
2149 for (int i = 0; i < size; ++i)
2150 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2151 }
2152 /*
2153 void UniformBufferObjChunk::setUVec3(UInt32 handle, const Pnt3u& value, UInt32 array_idx)
2154 {
2155 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2156
2157 editMField(UIntValuesFieldMask, _mfUIntValues);
2158
2159 int size = 3;
2160 for (int i = 0; i < size; ++i)
2161 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2162 }
2163 */
2164 void UniformBufferObjChunk::setUVec4(UInt32 handle, const Vec4u& value, UInt32 array_idx)
2165 {
2166 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2167
2168 editMField(UIntValuesFieldMask, _mfUIntValues);
2169
2170 int size = 4;
2171 for (int i = 0; i < size; ++i)
2172 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2173 }
2174 /*
2175 void UniformBufferObjChunk::setUVec4(UInt32 handle, const Pnt4u& value, UInt32 array_idx)
2176 {
2177 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2178
2179 editMField(UIntValuesFieldMask, _mfUIntValues);
2180
2181 int size = 4;
2182 for (int i = 0; i < size; ++i)
2183 _mfUIntValues[_mfIndex[handle] + (array_idx * size) + i] = value[i];
2184 }
2185 */
2186 void UniformBufferObjChunk::setBVec2(UInt32 handle, const Vec2b& value, UInt32 array_idx)
2187 {
2188 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2189
2190 editMField(BoolValuesFieldMask, _mfBoolValues);
2191
2192 int size = 2;
2193 for (int i = 0; i < size; ++i)
2194 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2195 }
2196
2197 void UniformBufferObjChunk::setBVec2(UInt32 handle, const Pnt2b& value, UInt32 array_idx)
2198 {
2199 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2200
2201 editMField(BoolValuesFieldMask, _mfBoolValues);
2202
2203 int size = 2;
2204 for (int i = 0; i < size; ++i)
2205 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2206 }
2207
2208 void UniformBufferObjChunk::setBVec3(UInt32 handle, const Vec3b& value, UInt32 array_idx)
2209 {
2210 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2211
2212 editMField(BoolValuesFieldMask, _mfBoolValues);
2213
2214 int size = 3;
2215 for (int i = 0; i < size; ++i)
2216 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2217 }
2218
2219 void UniformBufferObjChunk::setBVec3(UInt32 handle, const Pnt3b& value, UInt32 array_idx)
2220 {
2221 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2222
2223 editMField(BoolValuesFieldMask, _mfBoolValues);
2224
2225 int size = 3;
2226 for (int i = 0; i < size; ++i)
2227 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2228 }
2229
2230 void UniformBufferObjChunk::setBVec4(UInt32 handle, const Vec4b& value, UInt32 array_idx)
2231 {
2232 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2233
2234 editMField(BoolValuesFieldMask, _mfBoolValues);
2235
2236 int size = 4;
2237 for (int i = 0; i < size; ++i)
2238 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2239 }
2240
2241 void UniformBufferObjChunk::setBVec4(UInt32 handle, const Pnt4b& value, UInt32 array_idx)
2242 {
2243 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2244
2245 editMField(BoolValuesFieldMask, _mfBoolValues);
2246
2247 int size = 4;
2248 for (int i = 0; i < size; ++i)
2249 _mfBoolValues[_mfIndex[handle] + (array_idx * size) + i] = static_cast<UInt8>(value[i]);
2250 }
2251
2252 void UniformBufferObjChunk::setMat2(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2253 {
2254 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2255
2256 editMField(FloatValuesFieldMask, _mfFloatValues);
2257
2258 UInt8 columns = 2;
2259 UInt8 rows = 2;
2260
2261 for (int i = 0; i < columns; ++i) {
2262 const Vec4f& v = value[i];
2263 for (int j = 0; j < rows; ++j) {
2264 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2265 }
2266 }
2267 }
2268
2269 void UniformBufferObjChunk::setMat3(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2270 {
2271 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2272
2273 editMField(FloatValuesFieldMask, _mfFloatValues);
2274
2275 UInt8 columns = 3;
2276 UInt8 rows = 3;
2277
2278 for (int i = 0; i < columns; ++i) {
2279 const Vec4f& v = value[i];
2280 for (int j = 0; j < rows; ++j) {
2281 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2282 }
2283 }
2284 }
2285
2286 void UniformBufferObjChunk::setMat4(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2287 {
2288 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2289
2290 editMField(FloatValuesFieldMask, _mfFloatValues);
2291
2292 UInt8 columns = 4;
2293 UInt8 rows = 4;
2294
2295 for (int i = 0; i < columns; ++i) {
2296 const Vec4f& v = value[i];
2297 for (int j = 0; j < rows; ++j) {
2298 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2299 }
2300 }
2301 }
2302
2303 void UniformBufferObjChunk::setDMat2(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2304 {
2305 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2306
2307 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2308
2309 UInt8 columns = 2;
2310 UInt8 rows = 2;
2311
2312 for (int i = 0; i < columns; ++i) {
2313 const Vec4d& v = value[i];
2314 for (int j = 0; j < rows; ++j) {
2315 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2316 }
2317 }
2318 }
2319
2320 void UniformBufferObjChunk::setDMat3(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2321 {
2322 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2323
2324 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2325
2326 UInt8 columns = 3;
2327 UInt8 rows = 3;
2328
2329 for (int i = 0; i < columns; ++i) {
2330 const Vec4d& v = value[i];
2331 for (int j = 0; j < rows; ++j) {
2332 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2333 }
2334 }
2335 }
2336
2337 void UniformBufferObjChunk::setDMat4(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2338 {
2339 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2340
2341 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2342
2343 UInt8 columns = 4;
2344 UInt8 rows = 4;
2345
2346 for (int i = 0; i < columns; ++i) {
2347 const Vec4d& v = value[i];
2348 for (int j = 0; j < rows; ++j) {
2349 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2350 }
2351 }
2352 }
2353
2354 void UniformBufferObjChunk::setMat2x3(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2355 {
2356 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2357
2358 editMField(FloatValuesFieldMask, _mfFloatValues);
2359
2360 UInt8 columns = 2;
2361 UInt8 rows = 3;
2362
2363 for (int i = 0; i < columns; ++i) {
2364 const Vec4f& v = value[i];
2365 for (int j = 0; j < rows; ++j) {
2366 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2367 }
2368 }
2369 }
2370
2371 void UniformBufferObjChunk::setMat3x2(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2372 {
2373 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2374
2375 editMField(FloatValuesFieldMask, _mfFloatValues);
2376
2377 UInt8 columns = 3;
2378 UInt8 rows = 2;
2379
2380 for (int i = 0; i < columns; ++i) {
2381 const Vec4f& v = value[i];
2382 for (int j = 0; j < rows; ++j) {
2383 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2384 }
2385 }
2386 }
2387
2388 void UniformBufferObjChunk::setMat2x4(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2389 {
2390 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2391
2392 editMField(FloatValuesFieldMask, _mfFloatValues);
2393
2394 UInt8 columns = 2;
2395 UInt8 rows = 4;
2396
2397 for (int i = 0; i < columns; ++i) {
2398 const Vec4f& v = value[i];
2399 for (int j = 0; j < rows; ++j) {
2400 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2401 }
2402 }
2403 }
2404
2405 void UniformBufferObjChunk::setMat4x2(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2406 {
2407 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2408
2409 editMField(FloatValuesFieldMask, _mfFloatValues);
2410
2411 UInt8 columns = 4;
2412 UInt8 rows = 2;
2413
2414 for (int i = 0; i < columns; ++i) {
2415 const Vec4f& v = value[i];
2416 for (int j = 0; j < rows; ++j) {
2417 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2418 }
2419 }
2420 }
2421
2422 void UniformBufferObjChunk::setMat3x4(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2423 {
2424 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2425
2426 editMField(FloatValuesFieldMask, _mfFloatValues);
2427
2428 UInt8 columns = 3;
2429 UInt8 rows = 4;
2430
2431 for (int i = 0; i < columns; ++i) {
2432 const Vec4f& v = value[i];
2433 for (int j = 0; j < rows; ++j) {
2434 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2435 }
2436 }
2437 }
2438
2439 void UniformBufferObjChunk::setMat4x3(UInt32 handle, const Matrix4f& value, UInt32 array_idx)
2440 {
2441 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2442
2443 editMField(FloatValuesFieldMask, _mfFloatValues);
2444
2445 UInt8 columns = 4;
2446 UInt8 rows = 3;
2447
2448 for (int i = 0; i < columns; ++i) {
2449 const Vec4f& v = value[i];
2450 for (int j = 0; j < rows; ++j) {
2451 _mfFloatValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2452 }
2453 }
2454 }
2455
2456 void UniformBufferObjChunk::setDMat2x3(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2457 {
2458 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2459
2460 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2461
2462 UInt8 columns = 2;
2463 UInt8 rows = 3;
2464
2465 for (int i = 0; i < columns; ++i) {
2466 const Vec4d& v = value[i];
2467 for (int j = 0; j < rows; ++j) {
2468 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2469 }
2470 }
2471 }
2472
2473 void UniformBufferObjChunk::setDMat3x2(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2474 {
2475 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2476
2477 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2478
2479 UInt8 columns = 3;
2480 UInt8 rows = 2;
2481
2482 for (int i = 0; i < columns; ++i) {
2483 const Vec4d& v = value[i];
2484 for (int j = 0; j < rows; ++j) {
2485 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2486 }
2487 }
2488 }
2489
2490 void UniformBufferObjChunk::setDMat2x4(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2491 {
2492 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2493
2494 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2495
2496 UInt8 columns = 2;
2497 UInt8 rows = 4;
2498
2499 for (int i = 0; i < columns; ++i) {
2500 const Vec4d& v = value[i];
2501 for (int j = 0; j < rows; ++j) {
2502 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2503 }
2504 }
2505 }
2506
2507 void UniformBufferObjChunk::setDMat4x2(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2508 {
2509 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2510
2511 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2512
2513 UInt8 columns = 4;
2514 UInt8 rows = 2;
2515
2516 for (int i = 0; i < columns; ++i) {
2517 const Vec4d& v = value[i];
2518 for (int j = 0; j < rows; ++j) {
2519 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2520 }
2521 }
2522 }
2523
2524 void UniformBufferObjChunk::setDMat3x4(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2525 {
2526 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2527
2528 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2529
2530 UInt8 columns = 3;
2531 UInt8 rows = 4;
2532
2533 for (int i = 0; i < columns; ++i) {
2534 const Vec4d& v = value[i];
2535 for (int j = 0; j < rows; ++j) {
2536 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2537 }
2538 }
2539 }
2540
2541 void UniformBufferObjChunk::setDMat4x3(UInt32 handle, const Matrix4d& value, UInt32 array_idx)
2542 {
2543 OSG_ASSERT(array_idx < _mfCardinality[handle]);
2544
2545 editMField(DoubleValuesFieldMask, _mfDoubleValues);
2546
2547 UInt8 columns = 4;
2548 UInt8 rows = 3;
2549
2550 for (int i = 0; i < columns; ++i) {
2551 const Vec4d& v = value[i];
2552 for (int j = 0; j < rows; ++j) {
2553 _mfDoubleValues[_mfIndex[handle] + (array_idx * rows * columns) + (j + rows * i)] = v[j];
2554 }
2555 }
2556 }
2557
2558 /*------------------------------ set-interface II ---------------------------*/
2559
2560 void UniformBufferObjChunk::setFloat(const std::string& name, Real32 value, UInt32 array_idx)
2561 {
2562 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2563 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2564 setFloat(iter->second, value, array_idx);
2565 }
2566
2567 void UniformBufferObjChunk::setDouble(const std::string& name, Real64 value, UInt32 array_idx)
2568 {
2569 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2570 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2571 setDouble(iter->second, value, array_idx);
2572 }
2573
2574 void UniformBufferObjChunk::setInt(const std::string& name, Int32 value, UInt32 array_idx)
2575 {
2576 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2577 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2578 setInt(iter->second, value, array_idx);
2579 }
2580
2581 void UniformBufferObjChunk::setUInt(const std::string& name, UInt32 value, UInt32 array_idx)
2582 {
2583 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2584 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2585 setUInt(iter->second, value, array_idx);
2586 }
2587
2588 void UniformBufferObjChunk::setBool(const std::string& name, bool value, UInt32 array_idx)
2589 {
2590 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2591 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2592 setBool(iter->second, value, array_idx);
2593 }
2594
2595 void UniformBufferObjChunk::setVec2(const std::string& name, const Vec2f& value, UInt32 array_idx)
2596 {
2597 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2598 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2599 setVec2(iter->second, value, array_idx);
2600 }
2601
2602 void UniformBufferObjChunk::setVec2(const std::string& name, const Pnt2f& value, UInt32 array_idx)
2603 {
2604 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2605 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2606 setVec2(iter->second, value, array_idx);
2607 }
2608
2609 void UniformBufferObjChunk::setVec3(const std::string& name, const Vec3f& value, UInt32 array_idx)
2610 {
2611 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2612 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2613 setVec3(iter->second, value, array_idx);
2614 }
2615
2616 void UniformBufferObjChunk::setVec3(const std::string& name, const Pnt3f& value, UInt32 array_idx)
2617 {
2618 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2619 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2620 setVec3(iter->second, value, array_idx);
2621 }
2622
2623 void UniformBufferObjChunk::setVec3(const std::string& name, const Color3f& value, UInt32 array_idx)
2624 {
2625 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2626 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2627 setVec3(iter->second, value, array_idx);
2628 }
2629
2630 void UniformBufferObjChunk::setVec4(const std::string& name, const Vec4f& value, UInt32 array_idx)
2631 {
2632 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2633 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2634 setVec4(iter->second, value, array_idx);
2635 }
2636
2637 void UniformBufferObjChunk::setVec4(const std::string& name, const Pnt4f& value, UInt32 array_idx)
2638 {
2639 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2640 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2641 setVec4(iter->second, value, array_idx);
2642 }
2643
2644 void UniformBufferObjChunk::setVec4(const std::string& name, const Color4f& value, UInt32 array_idx)
2645 {
2646 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2647 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2648 setVec4(iter->second, value, array_idx);
2649 }
2650
2651 void UniformBufferObjChunk::setDVec2(const std::string& name, const Vec2d& value, UInt32 array_idx)
2652 {
2653 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2654 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2655 setDVec2(iter->second, value, array_idx);
2656 }
2657
2658 void UniformBufferObjChunk::setDVec2(const std::string& name, const Pnt2d& value, UInt32 array_idx)
2659 {
2660 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2661 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2662 setDVec2(iter->second, value, array_idx);
2663 }
2664
2665 void UniformBufferObjChunk::setDVec3(const std::string& name, const Vec3d& value, UInt32 array_idx)
2666 {
2667 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2668 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2669 setDVec3(iter->second, value, array_idx);
2670 }
2671
2672 void UniformBufferObjChunk::setDVec3(const std::string& name, const Pnt3d& value, UInt32 array_idx)
2673 {
2674 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2675 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2676 setDVec3(iter->second, value, array_idx);
2677 }
2678
2679 void UniformBufferObjChunk::setDVec4(const std::string& name, const Vec4d& value, UInt32 array_idx)
2680 {
2681 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2682 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2683 setDVec4(iter->second, value, array_idx);
2684 }
2685
2686 void UniformBufferObjChunk::setDVec4(const std::string& name, const Pnt4d& value, UInt32 array_idx)
2687 {
2688 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2689 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2690 setDVec4(iter->second, value, array_idx);
2691 }
2692
2693 void UniformBufferObjChunk::setIVec2(const std::string& name, const Vec2i& value, UInt32 array_idx)
2694 {
2695 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2696 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2697 setIVec2(iter->second, value, array_idx);
2698 }
2699
2700 void UniformBufferObjChunk::setIVec2(const std::string& name, const Pnt2i& value, UInt32 array_idx)
2701 {
2702 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2703 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2704 setIVec2(iter->second, value, array_idx);
2705 }
2706
2707 void UniformBufferObjChunk::setIVec3(const std::string& name, const Vec3i& value, UInt32 array_idx)
2708 {
2709 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2710 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2711 setIVec3(iter->second, value, array_idx);
2712 }
2713 /*
2714 void UniformBufferObjChunk::setIVec3(const std::string& name, const Pnt3i& value, UInt32 array_idx)
2715 {
2716 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2717 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2718 setIVec3(iter->second, value, array_idx);
2719 }
2720 */
2721 void UniformBufferObjChunk::setIVec4(const std::string& name, const Vec4i& value, UInt32 array_idx)
2722 {
2723 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2724 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2725 setIVec4(iter->second, value, array_idx);
2726 }
2727 /*
2728 void UniformBufferObjChunk::setIVec4(const std::string& name, const Pnt4i& value, UInt32 array_idx)
2729 {
2730 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2731 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2732 setIVec4(iter->second, value, array_idx);
2733 }
2734 */
2735 void UniformBufferObjChunk::setUVec2(const std::string& name, const Vec2u& value, UInt32 array_idx)
2736 {
2737 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2738 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2739 setUVec2(iter->second, value, array_idx);
2740 }
2741 /*
2742 void UniformBufferObjChunk::setUVec2(const std::string& name, const Pnt2u& value, UInt32 array_idx)
2743 {
2744 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2745 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2746 setUVec2(iter->second, value, array_idx);
2747 }
2748 */
2749 void UniformBufferObjChunk::setUVec3(const std::string& name, const Vec3u& value, UInt32 array_idx)
2750 {
2751 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2752 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2753 setUVec3(iter->second, value, array_idx);
2754 }
2755 /*
2756 void UniformBufferObjChunk::setUVec3(const std::string& name, const Pnt3u& value, UInt32 array_idx)
2757 {
2758 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2759 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2760 setUVec3(iter->second, value, array_idx);
2761 }
2762 */
2763 void UniformBufferObjChunk::setUVec4(const std::string& name, const Vec4u& value, UInt32 array_idx)
2764 {
2765 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2766 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2767 setUVec4(iter->second, value, array_idx);
2768 }
2769 /*
2770 void UniformBufferObjChunk::setUVec4(const std::string& name, const Pnt4u& value, UInt32 array_idx)
2771 {
2772 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2773 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2774 setUVec4(iter->second, value, array_idx);
2775 }
2776 */
2777 void UniformBufferObjChunk::setBVec2(const std::string& name, const Vec2b& value, UInt32 array_idx)
2778 {
2779 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2780 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2781 setBVec2(iter->second, value, array_idx);
2782 }
2783
2784 void UniformBufferObjChunk::setBVec2(const std::string& name, const Pnt2b& value, UInt32 array_idx)
2785 {
2786 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2787 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2788 setBVec2(iter->second, value, array_idx);
2789 }
2790
2791 void UniformBufferObjChunk::setBVec3(const std::string& name, const Vec3b& value, UInt32 array_idx)
2792 {
2793 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2794 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2795 setBVec3(iter->second, value, array_idx);
2796 }
2797
2798 void UniformBufferObjChunk::setBVec3(const std::string& name, const Pnt3b& value, UInt32 array_idx)
2799 {
2800 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2801 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2802 setBVec3(iter->second, value, array_idx);
2803 }
2804
2805 void UniformBufferObjChunk::setBVec4(const std::string& name, const Vec4b& value, UInt32 array_idx)
2806 {
2807 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2808 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2809 setBVec4(iter->second, value, array_idx);
2810 }
2811
2812 void UniformBufferObjChunk::setBVec4(const std::string& name, const Pnt4b& value, UInt32 array_idx)
2813 {
2814 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2815 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2816 setBVec4(iter->second, value, array_idx);
2817 }
2818
2819 void UniformBufferObjChunk::setMat2(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2820 {
2821 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2822 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2823 setMat2(iter->second, value, array_idx);
2824 }
2825
2826 void UniformBufferObjChunk::setMat3(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2827 {
2828 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2829 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2830 setMat3(iter->second, value, array_idx);
2831 }
2832
2833 void UniformBufferObjChunk::setMat4(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2834 {
2835 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2836 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2837 setMat4(iter->second, value, array_idx);
2838 }
2839
2840 void UniformBufferObjChunk::setDMat2(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2841 {
2842 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2843 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2844 setDMat2(iter->second, value, array_idx);
2845 }
2846
2847 void UniformBufferObjChunk::setDMat3(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2848 {
2849 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2850 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2851 setDMat3(iter->second, value, array_idx);
2852 }
2853
2854 void UniformBufferObjChunk::setDMat4(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2855 {
2856 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2857 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2858 setDMat4(iter->second, value, array_idx);
2859 }
2860
2861 void UniformBufferObjChunk::setMat2x3(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2862 {
2863 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2864 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2865 setMat2x3(iter->second, value, array_idx);
2866 }
2867
2868 void UniformBufferObjChunk::setMat3x2(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2869 {
2870 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2871 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2872 setMat3x2(iter->second, value, array_idx);
2873 }
2874
2875 void UniformBufferObjChunk::setMat2x4(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2876 {
2877 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2878 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2879 setMat2x4(iter->second, value, array_idx);
2880 }
2881
2882 void UniformBufferObjChunk::setMat4x2(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2883 {
2884 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2885 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2886 setMat4x2(iter->second, value, array_idx);
2887 }
2888
2889 void UniformBufferObjChunk::setMat3x4(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2890 {
2891 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2892 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2893 setMat3x4(iter->second, value, array_idx);
2894 }
2895
2896 void UniformBufferObjChunk::setMat4x3(const std::string& name, const Matrix4f& value, UInt32 array_idx)
2897 {
2898 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2899 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2900 setMat4x3(iter->second, value, array_idx);
2901 }
2902
2903 void UniformBufferObjChunk::setDMat2x3(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2904 {
2905 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2906 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2907 setDMat2x3(iter->second, value, array_idx);
2908 }
2909
2910 void UniformBufferObjChunk::setDMat3x2(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2911 {
2912 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2913 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2914 setDMat3x2(iter->second, value, array_idx);
2915 }
2916
2917 void UniformBufferObjChunk::setDMat2x4(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2918 {
2919 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2920 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2921 setDMat2x4(iter->second, value, array_idx);
2922 }
2923
2924 void UniformBufferObjChunk::setDMat4x2(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2925 {
2926 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2927 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2928 setDMat4x2(iter->second, value, array_idx);
2929 }
2930
2931 void UniformBufferObjChunk::setDMat3x4(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2932 {
2933 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2934 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2935 setDMat3x4(iter->second, value, array_idx);
2936 }
2937
2938 void UniformBufferObjChunk::setDMat4x3(const std::string& name, const Matrix4d& value, UInt32 array_idx)
2939 {
2940 StringToUInt32Map::const_iterator iter = _sfNameToIndex.getValue().find(name);
2941 OSG_ASSERT(iter != _sfNameToIndex.getValue().end());
2942 setDMat4x3(iter->second, value, array_idx);
2943 }
2944
2945 /*------------------------------ Invariants ---------------------------------*/
2946
2947 bool UniformBufferObjChunk::invariantOnStorageSize()
2948 {
2949 std::size_t sz = _mfFundamentalTypes.size();
2950 if (sz != _mfMainTypes .size() ||
2951 sz != _mfCardinality.size() ||
2952 sz != _mfIndex .size() ||
2953 sz != _mfNames .size() ||
2954 sz != _sfNameToIndex.getValue().size()
2955 ) return false;
2956 return true;
2957 }
2958
2959 OSG_END_NAMESPACE