Panda3D

Loading...
Searching...
No Matches
shader.I
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file shader.I
10 * @author jyelon
11 * @date 2005-09
12 * @author fperazzi, PandaSE
13 * @date 2010-04-06
14 */
15
16/**
17 * Return the Shader's filename for the given shader type.
18 */
19INLINE Filename Shader::
20 get_filename(ShaderType type) const {
21 if (_filename._separate && type != ST_none) {
22 switch (type) {
23 case ST_vertex:
24 return _filename._vertex;
25 break;
26 case ST_fragment:
27 return _filename._fragment;
28 break;
29 case ST_geometry:
30 return _filename._geometry;
31 break;
32 case ST_tess_control:
33 return _filename._tess_control;
34 break;
35 case ST_tess_evaluation:
36 return _filename._tess_evaluation;
37 break;
38 case ST_compute:
39 return _filename._compute;
40 break;
41 default:
42 return _filename._shared;
43 }
44 } else if (!_filename._shared.empty()) {
45 return _filename._shared;
46
47 } else {
48 // Um, better than nothing?
49 return _filename._fragment;
50 }
51}
52
53/**
54 * Sets the Shader's filename for the given shader type. Useful for
55 * associating a shader created with Shader.make with a name for diagnostics.
56 */
57INLINE void Shader::
58 set_filename(ShaderType type, const Filename &filename) {
59 _filename._separate = true;
60 switch (type) {
61 case ST_vertex:
62 _filename._vertex = filename;
63 break;
64 case ST_fragment:
65 _filename._fragment = filename;
66 break;
67 case ST_geometry:
68 _filename._geometry = filename;
69 break;
70 case ST_tess_control:
71 _filename._tess_control = filename;
72 break;
73 case ST_tess_evaluation:
74 _filename._tess_evaluation = filename;
75 break;
76 case ST_compute:
77 _filename._compute = filename;
78 break;
79 default:
80 _filename._shared = filename;
81 _filename._separate = false;
82 }
83}
84
85/**
86 * Return the Shader's text for the given shader type.
87 */
88INLINE const std::string &Shader::
89 get_text(ShaderType type) const {
90 if (_text._separate) {
91 nassertr(type != ST_none || !_text._shared.empty(), _text._shared);
92 switch (type) {
93 case ST_vertex:
94 return _text._vertex;
95 break;
96 case ST_fragment:
97 return _text._fragment;
98 break;
99 case ST_geometry:
100 return _text._geometry;
101 break;
102 case ST_tess_control:
103 return _text._tess_control;
104 break;
105 case ST_tess_evaluation:
106 return _text._tess_evaluation;
107 break;
108 case ST_compute:
109 return _text._compute;
110 break;
111 default:
112 return _text._shared;
113 }
114 } else {
115 return _text._shared;
116 }
117}
118
119/**
120 * Returns true if the shader contains a compile-time error. This doesn't
121 * tell you whether or not the shader is supported on the current video card.
122 */
123INLINE bool Shader::
124 get_error_flag() const {
125 return _error_flag;
126}
127
128/**
129 * Returns the shader language in which this shader was written.
130 */
131INLINE Shader::ShaderLanguage Shader::
132 get_language() const {
133 return _language;
134}
135
136/**
137 * Returns true if the fullpath has been set and is available. See
138 * set_fullpath().
139 */
140INLINE bool Shader::
141 has_fullpath() const {
142 return !_fullpath.empty();
143}
144
145/**
146 * Returns the fullpath that has been set. This is the full path to the file
147 * as it was found along the model-path.
148 */
149INLINE const Filename &Shader::
150 get_fullpath() const {
151 return _fullpath;
152}
153
154/**
155 * Returns the setting of the cache_compiled_shader flag. See
156 * set_cache_compiled_shader().
157 */
158INLINE bool Shader::
159 get_cache_compiled_shader() const {
160 return _cache_compiled_shader;
161}
162
163/**
164 * Sets the cache_compiled_shader flag. When this is set, the next time the
165 * Shader is loaded on a GSG, it will automatically extract the compiled
166 * shader from the GSG and save it to the global BamCache.
167 *
168 * This is used to store compiled shaders in the BamCache. This flag should
169 * not be set explicitly; it is set automatically by the ShaderPool when
170 * model-cache-compiled-shaders is set true.
171 */
172INLINE void Shader::
173 set_cache_compiled_shader(bool flag) {
174 _cache_compiled_shader = flag;
175}
176
177/**
178 *
179 */
180INLINE Shader::ShaderCaps::
181ShaderCaps() {
182 clear();
183}
184
185/**
186 *
187 */
188INLINE bool Shader::ShaderCaps::
189operator == (const ShaderCaps &other) const {
190#ifdef HAVE_CG
191 if ((_active_vprofile != other._active_vprofile) ||
192 (_active_fprofile != other._active_fprofile) ||
193 (_active_gprofile != other._active_gprofile) ||
194 (_ultimate_vprofile != other._ultimate_vprofile) ||
195 (_ultimate_fprofile != other._ultimate_fprofile) ||
196 (_ultimate_gprofile != other._ultimate_gprofile)) {
197 return false;
198 }
199#endif
200 return true;
201}
202
203/**
204 *
205 */
206INLINE Shader::ShaderPtrData::
207ShaderPtrData() :
208 _ptr(nullptr),
209 _type(SPT_unknown),
210 _updated(true),
211 _size(0)
212{
213}
214
215/**
216 *
217 */
218INLINE Shader::ShaderPtrData::
219ShaderPtrData(const PTA_float &ptr):
220 _pta(ptr.v0()),
221 _ptr(ptr.p()),
222 _type(SPT_float),
223 _updated(true),
224 _size(ptr.size())
225{
226}
227
228/**
229 *
230 */
231INLINE Shader::ShaderPtrData::
232ShaderPtrData(const PTA_LMatrix4f &ptr):
233 _pta(ptr.v0()),
234 _ptr(ptr.p()),
235 _type(SPT_float),
236 _updated(true),
237 _size(ptr.size() * 16)
238{
239}
240
241/**
242 *
243 */
244INLINE Shader::ShaderPtrData::
245ShaderPtrData(const PTA_LMatrix3f &ptr):
246 _pta(ptr.v0()),
247 _ptr(ptr.p()),
248 _type(SPT_float),
249 _updated(true),
250 _size(ptr.size() * 9)
251{
252}
253
254/**
255 *
256 */
257INLINE Shader::ShaderPtrData::
258ShaderPtrData(const PTA_LVecBase4f &ptr):
259 _pta(ptr.v0()),
260 _ptr(ptr.p()),
261 _type(SPT_float),
262 _updated(true),
263 _size(ptr.size() * 4)
264{
265}
266
267/**
268 *
269 */
270INLINE Shader::ShaderPtrData::
271ShaderPtrData(const PTA_LVecBase3f &ptr):
272 _pta(ptr.v0()),
273 _ptr(ptr.p()),
274 _type(SPT_float),
275 _updated(true),
276 _size(ptr.size() * 3)
277{
278}
279
280/**
281 *
282 */
283INLINE Shader::ShaderPtrData::
284ShaderPtrData(const PTA_LVecBase2f &ptr):
285 _pta(ptr.v0()),
286 _ptr(ptr.p()),
287 _type(SPT_float),
288 _updated(true),
289 _size(ptr.size() * 2)
290{
291}
292
293/**
294 *
295 */
296INLINE Shader::ShaderPtrData::
297ShaderPtrData(const LVecBase4f &vec) :
298 _type(SPT_float),
299 _updated(true),
300 _size(4)
301{
302 PTA_float pta = PTA_float::empty_array(4);
303 _pta = pta.v0();
304 _ptr = pta.p();
305 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
306 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
307}
308
309/**
310 *
311 */
312INLINE Shader::ShaderPtrData::
313ShaderPtrData(const LVecBase3f &vec) :
314 _type(SPT_float),
315 _updated(true),
316 _size(3)
317{
318 PTA_float pta = PTA_float::empty_array(3);
319 _pta = pta.v0();
320 _ptr = pta.p();
321 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
322 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
323}
324
325/**
326 *
327 */
328INLINE Shader::ShaderPtrData::
329ShaderPtrData(const LVecBase2f &vec) :
330 _type(SPT_float),
331 _updated(true),
332 _size(2)
333{
334 PTA_float pta = PTA_float::empty_array(2);
335 _pta = pta.v0();
336 _ptr = pta.p();
337 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
338 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
339}
340
341/**
342 *
343 */
344INLINE Shader::ShaderPtrData::
345ShaderPtrData(const LMatrix4f &mat) :
346 _type(SPT_float),
347 _updated(true),
348 _size(16)
349{
350 PTA_float pta = PTA_float::empty_array(16);
351 _pta = pta.v0();
352 _ptr = pta.p();
353 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
354 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
355}
356
357/**
358 *
359 */
360INLINE Shader::ShaderPtrData::
361ShaderPtrData(const LMatrix3f &mat) :
362 _type(SPT_float),
363 _updated(true),
364 _size(9)
365{
366 PTA_float pta = PTA_float::empty_array(9);
367 _pta = pta.v0();
368 _ptr = pta.p();
369 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
370 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
371}
372
373/**
374 *
375 */
376INLINE Shader::ShaderPtrData::
377ShaderPtrData(const PTA_double &ptr):
378 _pta(ptr.v0()),
379 _ptr(ptr.p()),
380 _type(SPT_double),
381 _updated(true),
382 _size(ptr.size())
383{
384}
385
386/**
387 *
388 */
389INLINE Shader::ShaderPtrData::
390ShaderPtrData(const PTA_LMatrix4d &ptr):
391 _pta(ptr.v0()),
392 _ptr(ptr.p()),
393 _type(SPT_double),
394 _updated(true),
395 _size(ptr.size() * 16)
396{
397}
398
399/**
400 *
401 */
402INLINE Shader::ShaderPtrData::
403ShaderPtrData(const PTA_LMatrix3d &ptr):
404 _pta(ptr.v0()),
405 _ptr(ptr.p()),
406 _type(SPT_double),
407 _updated(true),
408 _size(ptr.size() * 9)
409{
410}
411
412/**
413 *
414 */
415INLINE Shader::ShaderPtrData::
416ShaderPtrData(const PTA_LVecBase4d &ptr):
417 _pta(ptr.v0()),
418 _ptr(ptr.p()),
419 _type(SPT_double),
420 _updated(true),
421 _size(ptr.size() * 4)
422{
423}
424
425/**
426 *
427 */
428INLINE Shader::ShaderPtrData::
429ShaderPtrData(const PTA_LVecBase3d &ptr):
430 _pta(ptr.v0()),
431 _ptr(ptr.p()),
432 _type(SPT_double),
433 _updated(true),
434 _size(ptr.size() * 3)
435{
436}
437
438/**
439 *
440 */
441INLINE Shader::ShaderPtrData::
442ShaderPtrData(const PTA_LVecBase2d &ptr):
443 _pta(ptr.v0()),
444 _ptr(ptr.p()),
445 _type(SPT_double),
446 _updated(true),
447 _size(ptr.size() * 2)
448{
449}
450
451/**
452 *
453 */
454INLINE Shader::ShaderPtrData::
455ShaderPtrData(const LVecBase4d &vec) :
456 _type(SPT_double),
457 _updated(true),
458 _size(4)
459{
460 PTA_double pta = PTA_double::empty_array(4);
461 _pta = pta.v0();
462 _ptr = pta.p();
463 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
464 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
465}
466
467/**
468 *
469 */
470INLINE Shader::ShaderPtrData::
471ShaderPtrData(const LVecBase3d &vec) :
472 _type(SPT_double),
473 _updated(true),
474 _size(3)
475{
476 PTA_double pta = PTA_double::empty_array(3);
477 _pta = pta.v0();
478 _ptr = pta.p();
479 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
480 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
481}
482
483/**
484 *
485 */
486INLINE Shader::ShaderPtrData::
487ShaderPtrData(const LVecBase2d &vec) :
488 _type(SPT_double),
489 _updated(true),
490 _size(2)
491{
492 PTA_double pta = PTA_double::empty_array(2);
493 _pta = pta.v0();
494 _ptr = pta.p();
495 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
496 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
497}
498
499/**
500 *
501 */
502INLINE Shader::ShaderPtrData::
503ShaderPtrData(const LMatrix4d &mat) :
504 _type(SPT_double),
505 _updated(true),
506 _size(16)
507{
508 PTA_double pta = PTA_double::empty_array(16);
509 _pta = pta.v0();
510 _ptr = pta.p();
511 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
512 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
513}
514
515/**
516 *
517 */
518INLINE Shader::ShaderPtrData::
519ShaderPtrData(const LMatrix3d &mat) :
520 _type(SPT_double),
521 _updated(true),
522 _size(9)
523{
524 PTA_double pta = PTA_double::empty_array(9);
525 _pta = pta.v0();
526 _ptr = pta.p();
527 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
528 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
529}
530
531/**
532 *
533 */
534INLINE Shader::ShaderPtrData::
535ShaderPtrData(const PTA_int &ptr):
536 _pta(ptr.v0()),
537 _ptr(ptr.p()),
538 _type(SPT_int),
539 _updated(true),
540 _size(ptr.size())
541{
542}
543
544/**
545 *
546 */
547INLINE Shader::ShaderPtrData::
548ShaderPtrData(const PTA_LVecBase4i &ptr):
549 _pta(ptr.v0()),
550 _ptr(ptr.p()),
551 _type(SPT_int),
552 _updated(true),
553 _size(ptr.size() * 4)
554{
555}
556
557/**
558 *
559 */
560INLINE Shader::ShaderPtrData::
561ShaderPtrData(const PTA_LVecBase3i &ptr):
562 _pta(ptr.v0()),
563 _ptr(ptr.p()),
564 _type(SPT_int),
565 _updated(true),
566 _size(ptr.size() * 3)
567{
568}
569
570/**
571 *
572 */
573INLINE Shader::ShaderPtrData::
574ShaderPtrData(const PTA_LVecBase2i &ptr):
575 _pta(ptr.v0()),
576 _ptr(ptr.p()),
577 _type(SPT_int),
578 _updated(true),
579 _size(ptr.size() * 2)
580{
581}
582
583/**
584 *
585 */
586INLINE Shader::ShaderPtrData::
587ShaderPtrData(const LVecBase4i &vec) :
588 _type(SPT_int),
589 _updated(true),
590 _size(4)
591{
592 PTA_int pta = PTA_int::empty_array(4);
593 _pta = pta.v0();
594 _ptr = pta.p();
595 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
596 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
597}
598
599/**
600 *
601 */
602INLINE Shader::ShaderPtrData::
603ShaderPtrData(const LVecBase3i &vec) :
604 _type(SPT_int),
605 _updated(true),
606 _size(3)
607{
608 PTA_int pta = PTA_int::empty_array(3);
609 _pta = pta.v0();
610 _ptr = pta.p();
611 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
612 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
613}
614
615/**
616 *
617 */
618INLINE Shader::ShaderPtrData::
619ShaderPtrData(const LVecBase2i &vec) :
620 _type(SPT_int),
621 _updated(true),
622 _size(2)
623{
624 PTA_int pta = PTA_int::empty_array(2);
625 _pta = pta.v0();
626 _ptr = pta.p();
627 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
628 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
629}
630
631/**
632 * Writes the contents of this object to the datagram for shipping out to a
633 * Bam file.
634 */
635INLINE void Shader::ShaderPtrData::
636 write_datagram(Datagram &dg) const {
637 dg.add_uint8(_type);
638 dg.add_uint32((uint32_t)_size);
639
640 if (_type == SPT_double) {
641 const double *data = (const double *) _ptr;
642 for (size_t i = 0; i < _size; ++i) {
643 dg.add_float64(data[i]);
644 }
645
646 } else if (_type == SPT_float) {
647 const float *data = (const float *) _ptr;
648 for (size_t i = 0; i < _size; ++i) {
649 dg.add_float32(data[i]);
650 }
651 } else if (_type == SPT_int) {
652 const int *data = (const int *) _ptr;
653 for (size_t i = 0; i < _size; ++i) {
654 dg.add_int32(data[i]);
655 }
656 }
657}
658
659/**
660 * Reads the object from a Datagram.
661 */
662INLINE void Shader::ShaderPtrData::
663 read_datagram(DatagramIterator &scan) {
664 _type = (ShaderPtrType) scan.get_uint8();
665 _size = scan.get_uint32();
666
667 if (_type == SPT_double) {
668 PTA_double pta = PTA_double::empty_array(_size);
669 for (size_t i = 0; i < _size; ++i) {
670 pta[i] = scan.get_float64();
671 }
672 _pta = pta.v0();
673 _ptr = pta.p();
674
675 } else if (_type == SPT_float) {
676 PTA_float pta = PTA_float::empty_array(_size);
677 for (size_t i = 0; i < _size; ++i) {
678 pta[i] = scan.get_float32();
679 }
680 _pta = pta.v0();
681 _ptr = pta.p();
682
683 } else if (_type == SPT_int) {
684 PTA_int pta = PTA_int::empty_array(_size);
685 for (size_t i = 0; i < _size; ++i) {
686 pta[i] = scan.get_int32();
687 }
688 _pta = pta.v0();
689 _ptr = pta.p();
690 }
691}
692
693/**
694 *
695 */
696INLINE Shader::ShaderFile::
697ShaderFile(std::string shared) :
698 _separate(false),
699 _shared(std::move(shared))
700{
701}
702
703/**
704 *
705 */
706INLINE Shader::ShaderFile::
707ShaderFile(std::string vertex, std::string fragment, std::string geometry,
708 std::string tess_control, std::string tess_evaluation) :
709 _separate(true),
710 _vertex(std::move(vertex)),
711 _fragment(std::move(fragment)),
712 _geometry(std::move(geometry)),
713 _tess_control(std::move(tess_control)),
714 _tess_evaluation(std::move(tess_evaluation))
715{
716}
717
718/**
719 * Writes the contents of this object to the datagram for shipping out to a
720 * Bam file.
721 */
722INLINE void Shader::ShaderFile::
723 write_datagram(Datagram &dg) const {
724 if (_separate) {
725 dg.add_uint8(6);
726 dg.add_string(_vertex);
727 dg.add_string(_fragment);
728 dg.add_string(_geometry);
729 dg.add_string(_tess_control);
730 dg.add_string(_tess_evaluation);
731 dg.add_string(_compute);
732 } else {
733 dg.add_uint8(0);
734 dg.add_string(_shared);
735 }
736}
737
738/**
739 * Reads the object from a Datagram.
740 */
741INLINE void Shader::ShaderFile::
742 read_datagram(DatagramIterator &scan) {
743 short count = scan.get_uint8();
744 if (count > 0) {
745 _separate = true;
746 if (count-- > 0) _vertex = scan.get_string();
747 if (count-- > 0) _fragment = scan.get_string();
748 if (count-- > 0) _geometry = scan.get_string();
749 if (count-- > 0) _tess_control = scan.get_string();
750 if (count-- > 0) _tess_evaluation = scan.get_string();
751 if (count-- > 0) _compute = scan.get_string();
752 while (count-- > 0) {
753 scan.get_string();
754 }
755 } else {
756 _separate = false;
757 _shared = scan.get_string();
758 }
759}
760
761/**
762 * Ordering operator
763 */
764INLINE bool Shader::ShaderFile::
765 operator < (const Shader::ShaderFile &other) const {
766 if (_separate != other._separate) {
767 return (!_separate && other._separate);
768 }
769 if (_shared != other._shared) {
770 return (_shared < other._shared);
771 }
772 if (_vertex != other._vertex) {
773 return (_vertex < other._vertex);
774 }
775 if (_fragment != other._fragment) {
776 return (_fragment < other._fragment);
777 }
778 if (_geometry != other._geometry) {
779 return (_geometry < other._geometry);
780 }
781 if (_tess_control != other._tess_control) {
782 return (_tess_control < other._tess_control);
783 }
784 if (_tess_evaluation != other._tess_evaluation) {
785 return (_tess_evaluation < other._tess_evaluation);
786 }
787 if (_compute != other._compute) {
788 return (_compute < other._compute);
789 }
790 return false;
791}
DatagramIterator
A class to retrieve the individual data elements previously stored in a Datagram.
Definition datagramIterator.h:30
DatagramIterator::get_uint8
uint8_t get_uint8()
Extracts an unsigned 8-bit integer.
Definition datagramIterator.I:72
DatagramIterator::get_float32
PN_float32 get_float32()
Extracts a 32-bit single-precision floating-point number.
Definition datagramIterator.I:202
DatagramIterator::get_uint32
uint32_t get_uint32()
Extracts an unsigned 32-bit integer.
Definition datagramIterator.I:164
DatagramIterator::get_float64
PN_float64 get_float64()
Extracts a 64-bit floating-point number.
Definition datagramIterator.I:221
DatagramIterator::get_string
std::string get_string()
Extracts a variable-length string.
Definition datagramIterator.cxx:26
DatagramIterator::get_int32
int32_t get_int32()
Extracts a signed 32-bit integer.
Definition datagramIterator.I:107
Datagram
An ordered list of data elements, formatted in memory for transmission over a socket or writing to a ...
Definition datagram.h:38
Datagram::add_uint32
void add_uint32(uint32_t value)
Adds an unsigned 32-bit integer to the datagram.
Definition datagram.I:94
Datagram::add_float32
void add_float32(PN_float32 value)
Adds a 32-bit single-precision floating-point number to the datagram.
Definition datagram.I:114
Datagram::add_int32
void add_int32(int32_t value)
Adds a signed 32-bit integer to the datagram.
Definition datagram.I:67
Datagram::add_uint8
void add_uint8(uint8_t value)
Adds an unsigned 8-bit integer to the datagram.
Definition datagram.I:50
Datagram::add_string
void add_string(const std::string &str)
Adds a variable-length string to the datagram.
Definition datagram.I:219
Datagram::add_float64
void add_float64(PN_float64 value)
Adds a 64-bit floating-point number to the datagram.
Definition datagram.I:123
Filename
The name of a file, such as a texture file or an Egg file.
Definition filename.h:44
Shader::ShaderCaps
Definition shader.h:459
Shader::ShaderFile
Definition shader.h:483
Shader::ShaderFile::read_datagram
void read_datagram(DatagramIterator &source)
Reads the object from a Datagram.
Definition shader.I:742
Shader::ShaderFile::write_datagram
void write_datagram(Datagram &dg) const
Writes the contents of this object to the datagram for shipping out to a Bam file.
Definition shader.I:723
Shader::ShaderFile::operator<
bool operator<(const ShaderFile &other) const
Ordering operator.
Definition shader.I:765
Shader::get_error_flag
bool get_error_flag() const
Returns true if the shader contains a compile-time error.
Definition shader.I:124
Shader::has_fullpath
bool has_fullpath() const
Returns true if the fullpath has been set and is available.
Definition shader.I:141
Shader::get_text
const std::string & get_text(ShaderType type=ST_none) const
Return the Shader's text for the given shader type.
Definition shader.I:89
Shader::set_filename
void set_filename(ShaderType type, const Filename &filename)
Sets the Shader's filename for the given shader type.
Definition shader.I:58
Shader::set_cache_compiled_shader
void set_cache_compiled_shader(bool flag)
Sets the cache_compiled_shader flag.
Definition shader.I:173
Shader::get_cache_compiled_shader
bool get_cache_compiled_shader() const
Returns the setting of the cache_compiled_shader flag.
Definition shader.I:159
Shader::get_language
ShaderLanguage get_language() const
Returns the shader language in which this shader was written.
Definition shader.I:132
Shader::get_filename
Filename get_filename(ShaderType type=ST_none) const
Return the Shader's filename for the given shader type.
Definition shader.I:20
Shader::get_fullpath
const Filename & get_fullpath() const
Returns the fullpath that has been set.
Definition shader.I:150
std
STL namespace.
Shader::ShaderPtrData::write_datagram
void write_datagram(Datagram &dg) const
Writes the contents of this object to the datagram for shipping out to a Bam file.
Definition shader.I:636
Shader::ShaderPtrData::read_datagram
void read_datagram(DatagramIterator &source)
Reads the object from a Datagram.
Definition shader.I:663