Panda3D
eggTexture.cxx
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 eggTexture.cxx
10 * @author drose
11 * @date 1999-01-18
12 */
13
14#include "eggTexture.h"
15#include "eggMiscFuncs.h"
16#include "lexerDefs.h"
17
18#include "indent.h"
19#include "string_utils.h"
20
21using std::ostream;
22using std::string;
23
24TypeHandle EggTexture::_type_handle;
25
26
27/**
28 *
29 */
30EggTexture::
31EggTexture(const string &tref_name, const Filename &filename)
32 : EggFilenameNode(tref_name, filename)
33{
34 _texture_type = TT_unspecified;
35 _format = F_unspecified;
36 _compression_mode = CM_default;
37 _wrap_mode = WM_unspecified;
38 _wrap_u = WM_unspecified;
39 _wrap_v = WM_unspecified;
40 _wrap_w = WM_unspecified;
41 _minfilter = FT_unspecified;
42 _magfilter = FT_unspecified;
43 _anisotropic_degree = 0;
44 _env_type = ET_unspecified;
45 _saved_result = false;
46 _multiview = false;
47 _num_views = 0;
48 _tex_gen = TG_unspecified;
49 _quality_level = QL_unspecified;
50 _priority = 0;
51 _color.set(0.0f, 0.0f, 0.0f, 1.0f);
52 _border_color.set(0.0f, 0.0f, 0.0f, 1.0f);
53 _flags = 0;
54 _alpha_file_channel = 0;
55 _read_mipmaps = false;
56 _multitexture_sort = 0;
57}
58
59/**
60 *
61 */
62EggTexture::
63EggTexture(const EggTexture &copy) {
64 (*this) = copy;
65}
66
67/**
68 *
69 */
70EggTexture &EggTexture::
71operator = (const EggTexture &copy) {
73
74 EggFilenameNode::operator = (copy);
75 EggRenderMode::operator = (copy);
76 EggTransform::operator = (copy);
77
78 _texture_type = copy._texture_type;
79 _format = copy._format;
80 _compression_mode = copy._compression_mode;
81 _wrap_mode = copy._wrap_mode;
82 _wrap_u = copy._wrap_u;
83 _wrap_v = copy._wrap_v;
84 _wrap_w = copy._wrap_w;
85 _minfilter = copy._minfilter;
86 _magfilter = copy._magfilter;
87 _anisotropic_degree = copy._anisotropic_degree;
88 _env_type = copy._env_type;
89 _saved_result = copy._saved_result;
90 _multiview = copy._multiview;
91 _num_views = copy._num_views;
92 _tex_gen = copy._tex_gen;
93 _quality_level = copy._quality_level;
94 _stage_name = copy._stage_name;
95 _priority = copy._priority;
96 _color = copy._color;
97 _border_color = copy._border_color;
98 _uv_name = copy._uv_name;
99 _rgb_scale = 1;
100 _alpha_scale = 1;
101 _flags = copy._flags;
102 _alpha_filename = copy._alpha_filename;
103 _alpha_fullpath = copy._alpha_fullpath;
104 _alpha_file_channel = copy._alpha_file_channel;
105 _read_mipmaps = copy._read_mipmaps;
106 _multitexture_sort = 0;
107 _combiner[0] = copy._combiner[0];
108 _combiner[1] = copy._combiner[1];
109
110 return *this;
111}
112
113/**
114 *
115 */
116EggTexture::
117~EggTexture() {
119}
120
121/**
122 * Writes the texture definition to the indicated output stream in Egg format.
123 */
125write(ostream &out, int indent_level) const {
126 write_header(out, indent_level, "<Texture>");
127 enquote_string(out, get_filename(), indent_level + 2) << "\n";
128
129 if (has_alpha_filename()) {
130 indent(out, indent_level + 2)
131 << "<Scalar> alpha-file { ";
133 out << " }\n";
134 }
135
137 indent(out, indent_level + 2)
138 << "<Scalar> alpha-file-channel { "
139 << get_alpha_file_channel() << " }\n";
140 }
141
142 if (get_read_mipmaps()) {
143 indent(out, indent_level + 2)
144 << "<Scalar> read-mipmaps { 1 }\n";
145 }
146
147 if (get_texture_type() != TT_unspecified) {
148 indent(out, indent_level + 2)
149 << "<Scalar> type { " << get_texture_type() << " }\n";
150 }
151
152 if (get_format() != F_unspecified) {
153 indent(out, indent_level + 2)
154 << "<Scalar> format { " << get_format() << " }\n";
155 }
156
157 if (get_compression_mode() != CM_default) {
158 indent(out, indent_level + 2)
159 << "<Scalar> compression { " << get_compression_mode() << " }\n";
160 }
161
162 if (get_wrap_mode() != WM_unspecified) {
163 indent(out, indent_level + 2)
164 << "<Scalar> wrap { " << get_wrap_mode() << " }\n";
165 }
166
167 if (get_wrap_u() != WM_unspecified) {
168 indent(out, indent_level + 2)
169 << "<Scalar> wrapu { " << get_wrap_u() << " }\n";
170 }
171
172 if (get_wrap_v() != WM_unspecified) {
173 indent(out, indent_level + 2)
174 << "<Scalar> wrapv { " << get_wrap_v() << " }\n";
175 }
176
177 if (get_wrap_w() != WM_unspecified) {
178 indent(out, indent_level + 2)
179 << "<Scalar> wrapw { " << get_wrap_w() << " }\n";
180 }
181
182 if (get_minfilter() != FT_unspecified) {
183 indent(out, indent_level + 2)
184 << "<Scalar> minfilter { " << get_minfilter() << " }\n";
185 }
186
187 if (get_magfilter() != FT_unspecified) {
188 indent(out, indent_level + 2)
189 << "<Scalar> magfilter { " << get_magfilter() << " }\n";
190 }
191
193 indent(out, indent_level + 2)
194 << "<Scalar> anisotropic-degree { " << get_anisotropic_degree() << " }\n";
195 }
196
197 if (get_env_type() != ET_unspecified) {
198 indent(out, indent_level + 2)
199 << "<Scalar> envtype { " << get_env_type() << " }\n";
200 }
201
202 for (int ci = 0; ci < (int)CC_num_channels; ci++) {
203 CombineChannel channel = (CombineChannel)ci;
204 if (get_combine_mode(channel) != CM_unspecified) {
205 indent(out, indent_level + 2)
206 << "<Scalar> combine-" << channel
207 << " { " << get_combine_mode(channel) << " }\n";
208 }
209 for (int i = 0; i < (int)CI_num_indices; i++) {
210 if (get_combine_source(channel, i) != CS_unspecified) {
211 indent(out, indent_level + 2)
212 << "<Scalar> combine-" << channel << "-source" << i
213 << " { " << get_combine_source(channel, i) << " }\n";
214 }
215 if (get_combine_operand(channel, i) != CO_unspecified) {
216 indent(out, indent_level + 2)
217 << "<Scalar> combine-" << channel << "-operand" << i
218 << " { " << get_combine_operand(channel, i) << " }\n";
219 }
220 }
221 }
222
223 if (get_saved_result()) {
224 indent(out, indent_level + 2)
225 << "<Scalar> saved-result { 1 }\n";
226 }
227
228 if (get_tex_gen() != TG_unspecified) {
229 indent(out, indent_level + 2)
230 << "<Scalar> tex-gen { " << get_tex_gen() << " }\n";
231 }
232
233 if (get_quality_level() != QL_unspecified) {
234 indent(out, indent_level + 2)
235 << "<Scalar> quality-level { " << get_quality_level() << " }\n";
236 }
237
238 if (has_stage_name()) {
239 indent(out, indent_level + 2)
240 << "<Scalar> stage-name { " << get_stage_name() << " }\n";
241 }
242
243 if (has_priority()) {
244 indent(out, indent_level + 2)
245 << "<Scalar> priority { " << get_priority() << " }\n";
246 }
247
248 if (has_color()) {
249 indent(out, indent_level + 2)
250 << "<Scalar> blendr { " << _color[0] << " }\n";
251 indent(out, indent_level + 2)
252 << "<Scalar> blendg { " << _color[1] << " }\n";
253 indent(out, indent_level + 2)
254 << "<Scalar> blendb { " << _color[2] << " }\n";
255 indent(out, indent_level + 2)
256 << "<Scalar> blenda { " << _color[3] << " }\n";
257 }
258
259 if (has_border_color()) {
260 indent(out, indent_level + 2)
261 << "<Scalar> borderr { " << _border_color[0] << " }\n";
262 indent(out, indent_level + 2)
263 << "<Scalar> borderg { " << _border_color[1] << " }\n";
264 indent(out, indent_level + 2)
265 << "<Scalar> borderb { " << _border_color[2] << " }\n";
266 indent(out, indent_level + 2)
267 << "<Scalar> bordera { " << _border_color[3] << " }\n";
268 }
269
270 if (has_uv_name()) {
271 indent(out, indent_level + 2)
272 << "<Scalar> uv-name { " << get_uv_name() << " }\n";
273 }
274
275 if (has_rgb_scale()) {
276 indent(out, indent_level + 2)
277 << "<Scalar> rgb-scale { " << get_rgb_scale() << " }\n";
278 }
279
280 if (has_alpha_scale()) {
281 indent(out, indent_level + 2)
282 << "<Scalar> alpha-scale { " << get_alpha_scale() << " }\n";
283 }
284
285 if (get_multiview()) {
286 indent(out, indent_level + 2)
287 << "<Scalar> multiview { 1 }\n";
288 }
289
290 if (has_num_views()) {
291 indent(out, indent_level + 2)
292 << "<Scalar> num-views { " << get_num_views() << " }\n";
293 }
294
295 EggRenderMode::write(out, indent_level + 2);
296
297 if (has_transform()) {
298 EggTransform::write(out, indent_level + 2, "<Transform>");
299 }
300
301 indent(out, indent_level) << "}\n";
302}
303
304/**
305 * Returns true if the two textures are equivalent in all relevant properties
306 * (according to eq), false otherwise.
307 *
308 * The Equivalence parameter, eq, should be set to the bitwise OR of the
309 * following properties, according to what you consider relevant:
310 *
311 * EggTexture::E_basename: The basename part of the texture filename, without
312 * the directory prefix *or* the filename extension.
313 *
314 * EggTexture::E_extension: The extension part of the texture filename.
315 *
316 * EggTexture::E_dirname: The directory prefix of the texture filename.
317 *
318 * EggTexture::E_complete_filename: The union of the above three; that is, the
319 * complete filename, with directory, basename, and extension.
320 *
321 * EggTexture::E_transform: The texture matrix.
322 *
323 * EggTexture::E_attributes: All remaining texture attributes (mode, mipmap,
324 * etc.) except TRef name.
325 *
326 * EggTexture::E_tref_name: The TRef name.
327 */
329is_equivalent_to(const EggTexture &other, int eq) const {
330 if ((eq & E_complete_filename) == E_complete_filename) {
331 // cout << "compared by filename" << endl;
332 if (get_filename() != other.get_filename()) {
333 return false;
334 }
335 } else {
336 // cout << "compared by not complete filename" << endl;
337 const Filename &a = get_filename();
338 const Filename &b = other.get_filename();
339
340 if (eq & E_basename) {
342 return false;
343 }
344 }
345 if (eq & E_extension) {
346 if (a.get_extension() != b.get_extension()) {
347 return false;
348 }
349 }
350 if (eq & E_dirname) {
351 if (a.get_dirname() != b.get_dirname()) {
352 return false;
353 }
354 }
355 }
356
357 if (eq & E_transform) {
358 // cout << "compared by transform" << endl;
360 return false;
361 }
362
363 if (has_transform() && other.has_transform()) {
364 if (!get_transform3d().almost_equal(other.get_transform3d(), 0.0001)) {
365 return false;
366 }
367 }
368 }
369
370 if (eq & E_attributes) {
371 // cout << "compared by attributes" << endl;
372 if (_texture_type != other._texture_type ||
373 _format != other._format ||
374 _compression_mode != other._compression_mode ||
375 _wrap_mode != other._wrap_mode ||
376 _wrap_u != other._wrap_u ||
377 _wrap_v != other._wrap_v ||
378 _wrap_w != other._wrap_w ||
379 _minfilter != other._minfilter ||
380 _magfilter != other._magfilter ||
381 _env_type != other._env_type) {
382 return false;
383 }
384 if (EggRenderMode::operator != (other)) {
385 return false;
386 }
387 }
388
389 if (eq & E_tref_name) {
390 // cout << "compared by tref_name" << endl;
391 if (get_name() != other.get_name()) {
392 return false;
393 }
394 }
395
396 return true;
397}
398
399/**
400 * An ordering operator to compare two textures for sorting order. This
401 * imposes an arbitrary ordering useful to identify unique textures, according
402 * to the indicated Equivalence factor. See is_equivalent_to().
403 */
405sorts_less_than(const EggTexture &other, int eq) const {
406 if ((eq & E_complete_filename) == E_complete_filename) {
407 if (get_filename() != other.get_filename()) {
408 return get_filename() < other.get_filename();
409 }
410 } else {
411 const Filename &a = get_filename();
412 const Filename &b = other.get_filename();
413
414 if (eq & E_basename) {
417 }
418 }
419 if (eq & E_extension) {
420 if (a.get_extension() != b.get_extension()) {
421 return a.get_extension() < b.get_extension();
422 }
423 }
424 if (eq & E_dirname) {
425 if (a.get_dirname() != b.get_dirname()) {
426 return a.get_dirname() < b.get_dirname();
427 }
428 }
429 }
430
431 if (eq & E_transform) {
432 bool is_identity = transform_is_identity();
433 bool other_is_identity = other.transform_is_identity();
434 if (is_identity != other_is_identity) {
435 return (int)is_identity < (int)other_is_identity;
436 }
437
438 if (has_transform() && other.has_transform()) {
439 int compare = get_transform3d().compare_to(other.get_transform3d());
440 if (compare != 0) {
441 return compare < 0;
442 }
443 }
444 }
445
446 if (eq & E_attributes) {
447 if (_texture_type != other._texture_type) {
448 return (int)_texture_type < (int)other._texture_type;
449 }
450 if (_format != other._format) {
451 return (int)_format < (int)other._format;
452 }
453 if (_compression_mode != other._compression_mode) {
454 return (int)_compression_mode < (int)other._compression_mode;
455 }
456 if (_wrap_mode != other._wrap_mode) {
457 return (int)_wrap_mode < (int)other._wrap_mode;
458 }
459 if (_wrap_u != other._wrap_u) {
460 return (int)_wrap_u < (int)other._wrap_u;
461 }
462 if (_wrap_v != other._wrap_v) {
463 return (int)_wrap_v < (int)other._wrap_v;
464 }
465 if (_wrap_w != other._wrap_w) {
466 return (int)_wrap_w < (int)other._wrap_w;
467 }
468 if (_minfilter != other._minfilter) {
469 return (int)_minfilter < (int)other._minfilter;
470 }
471 if (_magfilter != other._magfilter) {
472 return (int)_magfilter < (int)other._magfilter;
473 }
474 if (_anisotropic_degree != other._anisotropic_degree) {
475 return _anisotropic_degree < other._anisotropic_degree;
476 }
477 if (_env_type != other._env_type) {
478 return (int)_env_type < (int)other._env_type;
479 }
480 if (EggRenderMode::operator != (other)) {
481 return EggRenderMode::operator < (other);
482 }
483 }
484
485 if (eq & E_tref_name) {
486 if (get_name() != other.get_name()) {
487 return get_name() < other.get_name();
488 }
489 }
490
491 return false;
492}
493
494/**
495 * Given the number of color components (channels) in the image file as
496 * actually read from the disk, return true if this texture seems to have an
497 * alpha channel or not. This depends on the EggTexture's format as well as
498 * the number of channels.
499 */
501has_alpha_channel(int num_components) const {
502 switch (_format) {
503 case F_red:
504 case F_green:
505 case F_blue:
506 case F_luminance:
507 case F_rgb:
508 case F_rgb12:
509 case F_rgb8:
510 case F_rgb5:
511 case F_rgb332:
512 case F_srgb:
513 // These formats never use alpha, regardless of the number of components
514 // we have.
515 return false;
516
517 case F_alpha:
518 // This format always uses alpha.
519 return true;
520
521 case F_luminance_alpha:
522 case F_luminance_alphamask:
523 case F_rgba:
524 case F_rgbm:
525 case F_rgba12:
526 case F_rgba8:
527 case F_rgba4:
528 case F_rgba5:
529 case F_srgb_alpha:
530 case F_unspecified:
531 // These formats use alpha if the image had alpha.
532 return (num_components == 2 || num_components == 4);
533 }
534
535 return false;
536}
537
538/**
539 * Returns true if this texture's environment type or combine mode allows the
540 * texture to have an effect on the polygon's alpha values, false otherwise.
541 */
543affects_polygon_alpha() const {
544 switch (_env_type) {
545 case ET_modulate:
546 case ET_replace:
547 return true;
548
549 case ET_decal:
550 case ET_blend:
551 case ET_add:
552 case ET_blend_color_scale:
553 case ET_modulate_glow:
554 case ET_modulate_gloss:
555 case ET_normal:
556 case ET_normal_height:
557 case ET_glow:
558 case ET_gloss:
559 case ET_height:
560 case ET_normal_gloss:
561 case ET_emission:
562 return false;
563
564 case ET_selector:
565 return true;
566
567 case ET_unspecified:
568 break;
569 }
570
571 switch (_combiner[CC_alpha]._mode) {
572 case CM_replace:
573 case CM_modulate:
574 case CM_add_signed:
575 case CM_subtract:
576 return true;
577
578 case CM_interpolate:
579 case CM_add:
580 case CM_dot3_rgb:
581 case CM_dot3_rgba:
582 return false;
583
584 case CM_unspecified:
585 break;
586 }
587
588 // A completely unspecified texture environment implies "modulate", which
589 // does affect alpha.
590 return true;
591}
592
593
594/**
595 * Resets the multitexture flags set by multitexture_over(). After this call,
596 * get_multitexture() will return false, and get_multitexture_sort() will
597 * return 0.
598 */
601 _multitexture_sort = 0;
602
603 // Now empty out the _over_textures and _under_textures sets. This requires
604 // a bit of care so we don't end up in mutual recursion or iterating through
605 // self-modifying structures. To avoid this, we empty the sets first, and
606 // then walk through their original contents.
607 MultiTextures orig_over_textures, orig_under_textures;
608 orig_over_textures.swap(_over_textures);
609 orig_under_textures.swap(_under_textures);
610
611 MultiTextures::iterator mti;
612 for (mti = orig_over_textures.begin();
613 mti != orig_over_textures.end();
614 ++mti) {
615 EggTexture *other = (*mti);
616 other->_under_textures.erase(this);
617 }
618 for (mti = orig_under_textures.begin();
619 mti != orig_under_textures.end();
620 ++mti) {
621 EggTexture *other = (*mti);
622 other->_over_textures.erase(this);
623 }
624}
625
626/**
627 * Indicates that this texture should be layered on top of the other texture.
628 * This will guarantee that this->get_multitexture_sort() >
629 * other->get_multitexture_sort(), at least until clear_multitexture() is
630 * called on either one.
631 *
632 * The return value is true if successful, or false if there is a failure
633 * because the other texture was already layered on top of this one (or there
634 * is a three- or more-way cycle).
635 */
639 MultiTextures cycle_detector;
640 if (!r_min_multitexture_sort(other->get_multitexture_sort() + 1,
641 cycle_detector)) {
642 // Found a cycle right off the bat!
643 return false;
644 }
645 }
646
647 if (_over_textures.insert(other).second) {
648 bool inserted_under = other->_under_textures.insert(this).second;
649 nassertr(inserted_under, false);
650 }
651 nassertr(get_multitexture_sort() > other->get_multitexture_sort(), false);
652
653 return true;
654}
655
656/**
657 * Returns the Texture_ype value associated with the given string
658 * representation, or TT_unspecified if the string does not match any known
659 * TextureType value.
660 */
661EggTexture::TextureType EggTexture::
662string_texture_type(const string &string) {
663 if (cmp_nocase_uh(string, "1d") == 0 ||
664 cmp_nocase_uh(string, "1dtexture") == 0 ||
665 cmp_nocase_uh(string, "1d_texture") == 0) {
666 return TT_1d_texture;
667
668 } else if (cmp_nocase_uh(string, "2d") == 0 ||
669 cmp_nocase_uh(string, "2dtexture") == 0 ||
670 cmp_nocase_uh(string, "2d_texture") == 0) {
671 return TT_2d_texture;
672
673 } else if (cmp_nocase_uh(string, "3d") == 0 ||
674 cmp_nocase_uh(string, "3dtexture") == 0 ||
675 cmp_nocase_uh(string, "3d_texture") == 0) {
676 return TT_3d_texture;
677
678 } else if (cmp_nocase_uh(string, "cube") == 0 ||
679 cmp_nocase_uh(string, "cubemap") == 0 ||
680 cmp_nocase_uh(string, "cube_map") == 0) {
681 return TT_cube_map;
682
683 } else {
684 return TT_unspecified;
685 }
686}
687
688/**
689 * Returns the Format value associated with the given string representation,
690 * or F_unspecified if the string does not match any known Format value.
691 */
692EggTexture::Format EggTexture::
693string_format(const string &string) {
694 if (cmp_nocase_uh(string, "rgba") == 0) {
695 return F_rgba;
696 } else if (cmp_nocase_uh(string, "srgb_alpha") == 0) {
697 return F_srgb_alpha;
698 } else if (cmp_nocase_uh(string, "rgbm") == 0) {
699 return F_rgbm;
700 } else if (cmp_nocase_uh(string, "rgba12") == 0) {
701 return F_rgba12;
702 } else if (cmp_nocase_uh(string, "rgba8") == 0) {
703 return F_rgba8;
704 } else if (cmp_nocase_uh(string, "rgba4") == 0) {
705 return F_rgba4;
706
707 } else if (cmp_nocase_uh(string, "rgb") == 0) {
708 return F_rgb;
709 } else if (cmp_nocase_uh(string, "srgb") == 0) {
710 return F_srgb;
711 } else if (cmp_nocase_uh(string, "rgb12") == 0) {
712 return F_rgb12;
713 } else if (cmp_nocase_uh(string, "rgb8") == 0) {
714 return F_rgb8;
715 } else if (cmp_nocase_uh(string, "rgb5") == 0) {
716 return F_rgb5;
717 } else if (cmp_nocase_uh(string, "rgba5") == 0) {
718 return F_rgba5;
719 } else if (cmp_nocase_uh(string, "rgb332") == 0) {
720 return F_rgb332;
721 } else if (cmp_nocase_uh(string, "red") == 0) {
722 return F_red;
723 } else if (cmp_nocase_uh(string, "green") == 0) {
724 return F_green;
725 } else if (cmp_nocase_uh(string, "blue") == 0) {
726 return F_blue;
727 } else if (cmp_nocase_uh(string, "alpha") == 0) {
728 return F_alpha;
729 } else if (cmp_nocase_uh(string, "luminance") == 0) {
730 return F_luminance;
731 } else if (cmp_nocase_uh(string, "luminance_alpha") == 0) {
732 return F_luminance_alpha;
733 } else if (cmp_nocase_uh(string, "luminance_alphamask") == 0) {
734 return F_luminance_alphamask;
735 } else {
736 return F_unspecified;
737 }
738}
739
740/**
741 * Returns the CompressionMode value associated with the given string
742 * representation, or CM_default if the string does not match any known
743 * CompressionMode value.
744 */
745EggTexture::CompressionMode EggTexture::
746string_compression_mode(const string &string) {
747 if (cmp_nocase_uh(string, "off") == 0) {
748 return CM_off;
749 } else if (cmp_nocase_uh(string, "on") == 0) {
750 return CM_on;
751 } else if (cmp_nocase_uh(string, "fxt1") == 0) {
752 return CM_fxt1;
753 } else if (cmp_nocase_uh(string, "dxt1") == 0) {
754 return CM_dxt1;
755 } else if (cmp_nocase_uh(string, "dxt2") == 0) {
756 return CM_dxt2;
757 } else if (cmp_nocase_uh(string, "dxt3") == 0) {
758 return CM_dxt3;
759 } else if (cmp_nocase_uh(string, "dxt4") == 0) {
760 return CM_dxt4;
761 } else if (cmp_nocase_uh(string, "dxt5") == 0) {
762 return CM_dxt5;
763 } else {
764 return CM_default;
765 }
766}
767
768/**
769 * Returns the WrapMode value associated with the given string representation,
770 * or WM_unspecified if the string does not match any known WrapMode value.
771 */
772EggTexture::WrapMode EggTexture::
773string_wrap_mode(const string &string) {
774 if (cmp_nocase_uh(string, "repeat") == 0) {
775 return WM_repeat;
776 } else if (cmp_nocase_uh(string, "clamp") == 0) {
777 return WM_clamp;
778 } else if (cmp_nocase_uh(string, "mirror") == 0) {
779 return WM_mirror;
780 } else if (cmp_nocase_uh(string, "mirror_once") == 0) {
781 return WM_mirror_once;
782 } else if (cmp_nocase_uh(string, "border_color") == 0) {
783 return WM_border_color;
784 } else {
785 return WM_unspecified;
786 }
787}
788
789/**
790 * Returns the FilterType value associated with the given string
791 * representation, or FT_unspecified if the string does not match any known
792 * FilterType value.
793 */
794EggTexture::FilterType EggTexture::
795string_filter_type(const string &string) {
796 // Old egg filter types.
797 if (cmp_nocase_uh(string, "point") == 0) {
798 return FT_nearest;
799 } else if (cmp_nocase_uh(string, "linear") == 0) {
800 return FT_linear;
801 } else if (cmp_nocase_uh(string, "bilinear") == 0) {
802 return FT_linear;
803 } else if (cmp_nocase_uh(string, "trilinear") == 0) {
804 return FT_linear_mipmap_linear;
805 } else if (cmp_nocase_uh(string, "mipmap") == 0) {
806 return FT_linear_mipmap_linear;
807 } else if (cmp_nocase_uh(string, "mipmap_point") == 0) {
808 return FT_nearest_mipmap_nearest;
809 } else if (cmp_nocase_uh(string, "mipmap_linear") == 0) {
810 return FT_nearest_mipmap_linear;
811 } else if (cmp_nocase_uh(string, "mipmap_bilinear") == 0) {
812 return FT_linear_mipmap_nearest;
813 } else if (cmp_nocase_uh(string, "mipmap_trilinear") == 0) {
814 return FT_linear_mipmap_linear;
815
816 // Current egg filter types, that match those in Texture.
817 } else if (cmp_nocase_uh(string, "nearest") == 0) {
818 return FT_nearest;
819 } else if (cmp_nocase_uh(string, "linear") == 0) {
820 return FT_linear;
821 } else if (cmp_nocase_uh(string, "nearest_mipmap_nearest") == 0) {
822 return FT_nearest_mipmap_nearest;
823 } else if (cmp_nocase_uh(string, "linear_mipmap_nearest") == 0) {
824 return FT_linear_mipmap_nearest;
825 } else if (cmp_nocase_uh(string, "nearest_mipmap_linear") == 0) {
826 return FT_nearest_mipmap_linear;
827 } else if (cmp_nocase_uh(string, "linear_mipmap_linear") == 0) {
828 return FT_linear_mipmap_linear;
829
830 } else {
831 return FT_unspecified;
832 }
833}
834
835/**
836 * Returns the EnvType value associated with the given string representation,
837 * or ET_unspecified if the string does not match any known EnvType value.
838 */
839EggTexture::EnvType EggTexture::
840string_env_type(const string &string) {
841 if (cmp_nocase_uh(string, "modulate") == 0) {
842 return ET_modulate;
843
844 } else if (cmp_nocase_uh(string, "decal") == 0) {
845 return ET_decal;
846
847 } else if (cmp_nocase_uh(string, "blend") == 0) {
848 return ET_blend;
849
850 } else if (cmp_nocase_uh(string, "replace") == 0) {
851 return ET_replace;
852
853 } else if (cmp_nocase_uh(string, "add") == 0) {
854 return ET_add;
855
856 } else if (cmp_nocase_uh(string, "blend_color_scale") == 0) {
857 return ET_blend_color_scale;
858
859 } else if (cmp_nocase_uh(string, "modulate_glow") == 0) {
860 return ET_modulate_glow;
861
862 } else if (cmp_nocase_uh(string, "modulate_gloss") == 0) {
863 return ET_modulate_gloss;
864
865 } else if (cmp_nocase_uh(string, "normal") == 0) {
866 return ET_normal;
867
868 } else if (cmp_nocase_uh(string, "normal_height") == 0) {
869 return ET_normal_height;
870
871 } else if (cmp_nocase_uh(string, "glow") == 0) {
872 return ET_glow;
873
874 } else if (cmp_nocase_uh(string, "gloss") == 0) {
875 return ET_gloss;
876
877 } else if (cmp_nocase_uh(string, "height") == 0) {
878 return ET_height;
879
880 } else if (cmp_nocase_uh(string, "selector") == 0) {
881 return ET_selector;
882
883 } else if (cmp_nocase_uh(string, "normal_gloss") == 0) {
884 return ET_normal_gloss;
885
886 } else if (cmp_nocase_uh(string, "emission") == 0) {
887 return ET_emission;
888
889 } else {
890 return ET_unspecified;
891 }
892}
893
894/**
895 * Returns the CombineMode value associated with the given string
896 * representation, or CM_unspecified if the string does not match any known
897 * CombineMode value.
898 */
899EggTexture::CombineMode EggTexture::
900string_combine_mode(const string &string) {
901 if (cmp_nocase_uh(string, "replace") == 0) {
902 return CM_replace;
903
904 } else if (cmp_nocase_uh(string, "modulate") == 0) {
905 return CM_modulate;
906
907 } else if (cmp_nocase_uh(string, "add") == 0) {
908 return CM_add;
909
910 } else if (cmp_nocase_uh(string, "add_signed") == 0) {
911 return CM_add_signed;
912
913 } else if (cmp_nocase_uh(string, "interpolate") == 0) {
914 return CM_interpolate;
915
916 } else if (cmp_nocase_uh(string, "subtract") == 0) {
917 return CM_subtract;
918
919 } else if (cmp_nocase_uh(string, "dot3_rgb") == 0) {
920 return CM_dot3_rgb;
921
922 } else if (cmp_nocase_uh(string, "dot3_rgba") == 0) {
923 return CM_dot3_rgba;
924
925 } else {
926 return CM_unspecified;
927 }
928}
929
930/**
931 * Returns the CombineSource value associated with the given string
932 * representation, or CS_unspecified if the string does not match any known
933 * CombineSource value.
934 */
935EggTexture::CombineSource EggTexture::
936string_combine_source(const string &string) {
937 if (cmp_nocase_uh(string, "texture") == 0) {
938 return CS_texture;
939
940 } else if (cmp_nocase_uh(string, "constant") == 0) {
941 return CS_constant;
942
943 } else if (cmp_nocase_uh(string, "primary_color") == 0) {
944 return CS_primary_color;
945
946 } else if (cmp_nocase_uh(string, "previous") == 0) {
947 return CS_previous;
948
949 } else if (cmp_nocase_uh(string, "constant_color_scale") == 0) {
950 return CS_constant_color_scale;
951
952 } else if (cmp_nocase_uh(string, "last_saved_result") == 0) {
953 return CS_last_saved_result;
954
955 } else {
956 return CS_unspecified;
957 }
958}
959
960/**
961 * Returns the CombineOperand value associated with the given string
962 * representation, or CO_unspecified if the string does not match any known
963 * CombineOperand value.
964 */
965EggTexture::CombineOperand EggTexture::
966string_combine_operand(const string &string) {
967 if (cmp_nocase_uh(string, "src_color") == 0) {
968 return CO_src_color;
969
970 } else if (cmp_nocase_uh(string, "one_minus_src_color") == 0) {
971 return CO_one_minus_src_color;
972
973 } else if (cmp_nocase_uh(string, "src_alpha") == 0) {
974 return CO_src_alpha;
975
976 } else if (cmp_nocase_uh(string, "one_minus_src_alpha") == 0) {
977 return CO_one_minus_src_alpha;
978
979 } else {
980 return CO_unspecified;
981 }
982}
983
984/**
985 * Returns the TexGen value associated with the given string representation,
986 * or ET_unspecified if the string does not match any known TexGen value.
987 */
988EggTexture::TexGen EggTexture::
989string_tex_gen(const string &string) {
990 if (cmp_nocase_uh(string, "unspecified") == 0) {
991 return TG_unspecified;
992
993 } else if (cmp_nocase_uh(string, "sphere_map") == 0 ||
994 cmp_nocase_uh(string, "eye_sphere_map") == 0) {
995 return TG_eye_sphere_map;
996
997 } else if (cmp_nocase_uh(string, "world_cube_map") == 0) {
998 return TG_world_cube_map;
999
1000 } else if (cmp_nocase_uh(string, "cube_map") == 0 ||
1001 cmp_nocase_uh(string, "eye_cube_map") == 0) {
1002 return TG_eye_cube_map;
1003
1004 } else if (cmp_nocase_uh(string, "world_normal") == 0) {
1005 return TG_world_normal;
1006
1007 } else if (cmp_nocase_uh(string, "eye_normal") == 0) {
1008 return TG_eye_normal;
1009
1010 } else if (cmp_nocase_uh(string, "world_position") == 0) {
1011 return TG_world_position;
1012
1013 } else if (cmp_nocase_uh(string, "eye_position") == 0) {
1014 return TG_eye_position;
1015
1016 } else if (cmp_nocase_uh(string, "point_sprite") == 0) {
1017 return TG_point_sprite;
1018
1019 } else {
1020 return TG_unspecified;
1021 }
1022}
1023
1024/**
1025 * Returns the TexGen value associated with the given string representation,
1026 * or ET_unspecified if the string does not match any known TexGen value.
1027 */
1028EggTexture::QualityLevel EggTexture::
1029string_quality_level(const string &string) {
1030 if (cmp_nocase_uh(string, "unspecified") == 0) {
1031 return QL_unspecified;
1032
1033 } else if (cmp_nocase_uh(string, "default") == 0) {
1034 return QL_default;
1035
1036 } else if (cmp_nocase_uh(string, "fastest") == 0) {
1037 return QL_fastest;
1038
1039 } else if (cmp_nocase_uh(string, "normal") == 0) {
1040 return QL_normal;
1041
1042 } else if (cmp_nocase_uh(string, "best") == 0) {
1043 return QL_best;
1044
1045 } else {
1046 return QL_unspecified;
1047 }
1048}
1049
1050/**
1051 * Returns this object cross-cast to an EggTransform pointer, if it inherits
1052 * from EggTransform, or NULL if it does not.
1053 */
1055as_transform() {
1056 return this;
1057}
1058
1059/**
1060 * This function is called within parse_egg(). It should call the appropriate
1061 * function on the lexer to initialize the parser into the state associated
1062 * with this object. If the object cannot be parsed into directly, it should
1063 * return false.
1064 */
1065bool EggTexture::
1066egg_start_parse_body() {
1067 egg_start_texture_body();
1068 return true;
1069}
1070
1071/**
1072 * Ensures that our multitexture_sort is at least the indicated value.
1073 */
1074bool EggTexture::
1075r_min_multitexture_sort(int sort, EggTexture::MultiTextures &cycle_detector) {
1076 if (_multitexture_sort >= sort) {
1077 // No problem.
1078 return true;
1079 }
1080
1081 if (!cycle_detector.insert(this).second) {
1082 // Oops, we just hit a cycle!
1083 return false;
1084 }
1085
1086 _multitexture_sort = sort;
1087
1088 // Now we also have to increment all of the textures that we are under.
1089 bool no_cycles = true;
1090
1091 MultiTextures::iterator mti;
1092 for (mti = _under_textures.begin();
1093 mti != _under_textures.end();
1094 ++mti) {
1095 EggTexture *other = (*mti);
1096 if (!other->r_min_multitexture_sort(sort + 1, cycle_detector)) {
1097 // Oops, found a cycle!
1098 no_cycles = false;
1099 }
1100 }
1101
1102 return no_cycles;
1103}
1104
1105
1106/**
1107 *
1108 */
1109ostream &operator << (ostream &out, EggTexture::TextureType texture_type) {
1110 switch (texture_type) {
1111 case EggTexture::TT_unspecified:
1112 return out << "unspecified";
1113
1114 case EggTexture::TT_1d_texture:
1115 return out << "1d";
1116
1117 case EggTexture::TT_2d_texture:
1118 return out << "2d";
1119
1120 case EggTexture::TT_3d_texture:
1121 return out << "3d";
1122
1123 case EggTexture::TT_cube_map:
1124 return out << "cube-map";
1125 }
1126
1127 nassertr(false, out);
1128 return out << "(**invalid**)";
1129}
1130
1131
1132/**
1133 *
1134 */
1135ostream &operator << (ostream &out, EggTexture::Format format) {
1136 switch (format) {
1137 case EggTexture::F_unspecified:
1138 return out << "unspecified";
1139
1140 case EggTexture::F_rgba:
1141 return out << "rgba";
1142 case EggTexture::F_rgbm:
1143 return out << "rgbm";
1144 case EggTexture::F_rgba12:
1145 return out << "rgba12";
1146 case EggTexture::F_rgba8:
1147 return out << "rgba8";
1148 case EggTexture::F_rgba4:
1149 return out << "rgba4";
1150 case EggTexture::F_srgb_alpha:
1151 return out << "srgb_alpha";
1152
1153 case EggTexture::F_rgb:
1154 return out << "rgb";
1155 case EggTexture::F_rgb12:
1156 return out << "rgb12";
1157 case EggTexture::F_rgb8:
1158 return out << "rgb8";
1159 case EggTexture::F_rgb5:
1160 return out << "rgb5";
1161 case EggTexture::F_rgba5:
1162 return out << "rgba5";
1163 case EggTexture::F_rgb332:
1164 return out << "rgb332";
1165 case EggTexture::F_srgb:
1166 return out << "srgb";
1167
1168 case EggTexture::F_red:
1169 return out << "red";
1170 case EggTexture::F_green:
1171 return out << "green";
1172 case EggTexture::F_blue:
1173 return out << "blue";
1174 case EggTexture::F_alpha:
1175 return out << "alpha";
1176 case EggTexture::F_luminance:
1177 return out << "luminance";
1178 case EggTexture::F_luminance_alpha:
1179 return out << "luminance_alpha";
1180 case EggTexture::F_luminance_alphamask:
1181 return out << "luminance_alphamask";
1182 }
1183
1184 nassertr(false, out);
1185 return out << "(**invalid**)";
1186}
1187
1188/**
1189 *
1190 */
1191ostream &operator << (ostream &out, EggTexture::CompressionMode mode) {
1192 switch (mode) {
1193 case EggTexture::CM_default:
1194 return out << "default";
1195 case EggTexture::CM_off:
1196 return out << "off";
1197 case EggTexture::CM_on:
1198 return out << "on";
1199 case EggTexture::CM_fxt1:
1200 return out << "fxt1";
1201 case EggTexture::CM_dxt1:
1202 return out << "dxt1";
1203 case EggTexture::CM_dxt2:
1204 return out << "dxt2";
1205 case EggTexture::CM_dxt3:
1206 return out << "dxt3";
1207 case EggTexture::CM_dxt4:
1208 return out << "dxt4";
1209 case EggTexture::CM_dxt5:
1210 return out << "dxt5";
1211 }
1212
1213 nassertr(false, out);
1214 return out << "(**invalid**)";
1215}
1216
1217/**
1218 *
1219 */
1220ostream &operator << (ostream &out, EggTexture::WrapMode mode) {
1221 switch (mode) {
1222 case EggTexture::WM_unspecified:
1223 return out << "unspecified";
1224 case EggTexture::WM_repeat:
1225 return out << "repeat";
1226 case EggTexture::WM_clamp:
1227 return out << "clamp";
1228 case EggTexture::WM_mirror:
1229 return out << "mirror";
1230 case EggTexture::WM_mirror_once:
1231 return out << "mirror_once";
1232 case EggTexture::WM_border_color:
1233 return out << "border_color";
1234 }
1235
1236 nassertr(false, out);
1237 return out << "(**invalid**)";
1238}
1239
1240/**
1241 *
1242 */
1243ostream &operator << (ostream &out, EggTexture::FilterType type) {
1244 switch (type) {
1245 case EggTexture::FT_unspecified:
1246 return out << "unspecified";
1247
1248 case EggTexture::FT_nearest:
1249 return out << "nearest";
1250 case EggTexture::FT_linear:
1251 return out << "linear";
1252
1253 case EggTexture::FT_nearest_mipmap_nearest:
1254 return out << "nearest_mipmap_nearest";
1255 case EggTexture::FT_linear_mipmap_nearest:
1256 return out << "linear_mipmap_nearest";
1257 case EggTexture::FT_nearest_mipmap_linear:
1258 return out << "nearest_mipmap_linear";
1259 case EggTexture::FT_linear_mipmap_linear:
1260 return out << "linear_mipmap_linear";
1261 }
1262
1263 nassertr(false, out);
1264 return out << "(**invalid**)";
1265}
1266
1267/**
1268 *
1269 */
1270ostream &operator << (ostream &out, EggTexture::EnvType type) {
1271 switch (type) {
1272 case EggTexture::ET_unspecified:
1273 return out << "unspecified";
1274
1275 case EggTexture::ET_modulate:
1276 return out << "modulate";
1277
1278 case EggTexture::ET_decal:
1279 return out << "decal";
1280
1281 case EggTexture::ET_blend:
1282 return out << "blend";
1283
1284 case EggTexture::ET_replace:
1285 return out << "replace";
1286
1287 case EggTexture::ET_add:
1288 return out << "add";
1289
1290 case EggTexture::ET_blend_color_scale:
1291 return out << "blend_color_scale";
1292
1293 case EggTexture::ET_modulate_glow:
1294 return out << "modulate_glow";
1295
1296 case EggTexture::ET_modulate_gloss:
1297 return out << "modulate_gloss";
1298
1299 case EggTexture::ET_normal:
1300 return out << "normal";
1301
1302 case EggTexture::ET_normal_height:
1303 return out << "normal_height";
1304
1305 case EggTexture::ET_glow:
1306 return out << "glow";
1307
1308 case EggTexture::ET_gloss:
1309 return out << "gloss";
1310
1311 case EggTexture::ET_height:
1312 return out << "height";
1313
1314 case EggTexture::ET_selector:
1315 return out << "selector";
1316
1317 case EggTexture::ET_normal_gloss:
1318 return out << "normal_gloss";
1319
1320 case EggTexture::ET_emission:
1321 return out << "emission";
1322 }
1323
1324 nassertr(false, out);
1325 return out << "(**invalid**)";
1326}
1327
1328ostream &
1329operator << (ostream &out, EggTexture::CombineMode cm) {
1330 switch (cm) {
1331 case EggTexture::CM_unspecified:
1332 return out << "unspecified";
1333
1334 case EggTexture::CM_replace:
1335 return out << "replace";
1336
1337 case EggTexture::CM_modulate:
1338 return out << "modulate";
1339
1340 case EggTexture::CM_add:
1341 return out << "add";
1342
1343 case EggTexture::CM_add_signed:
1344 return out << "add_signed";
1345
1346 case EggTexture::CM_interpolate:
1347 return out << "interpolate";
1348
1349 case EggTexture::CM_subtract:
1350 return out << "subtract";
1351
1352 case EggTexture::CM_dot3_rgb:
1353 return out << "dot3_rgb";
1354
1355 case EggTexture::CM_dot3_rgba:
1356 return out << "dot3_rgba";
1357 }
1358
1359 return out << "**invalid CombineMode(" << (int)cm << ")**";
1360}
1361
1362ostream &
1363operator << (ostream &out, EggTexture::CombineChannel cm) {
1364 switch (cm) {
1365 case EggTexture::CC_rgb:
1366 return out << "rgb";
1367
1368 case EggTexture::CC_alpha:
1369 return out << "alpha";
1370
1371 case EggTexture::CC_num_channels:
1372 // This case is here just to prevent a compiler warning. Fall out of the
1373 // switch and return the error message.
1374 break;
1375 }
1376
1377 return out << "**invalid CombineChannel(" << (int)cm << ")**";
1378}
1379
1380ostream &
1381operator << (ostream &out, EggTexture::CombineSource cs) {
1382 switch (cs) {
1383 case EggTexture::CS_unspecified:
1384 return out << "unspecified";
1385
1386 case EggTexture::CS_texture:
1387 return out << "texture";
1388
1389 case EggTexture::CS_constant:
1390 return out << "constant";
1391
1392 case EggTexture::CS_primary_color:
1393 return out << "primary_color";
1394
1395 case EggTexture::CS_previous:
1396 return out << "previous";
1397
1398 case EggTexture::CS_constant_color_scale:
1399 return out << "constant_color_scale";
1400
1401 case EggTexture::CS_last_saved_result:
1402 return out << "last_saved_result";
1403 }
1404
1405 return out << "**invalid CombineSource(" << (int)cs << ")**";
1406}
1407
1408ostream &
1409operator << (ostream &out, EggTexture::CombineOperand co) {
1410 switch (co) {
1411 case EggTexture::CO_unspecified:
1412 return out << "unspecified";
1413
1414 case EggTexture::CO_src_color:
1415 return out << "src_color";
1416
1417 case EggTexture::CO_one_minus_src_color:
1418 return out << "one_minus_src_color";
1419
1420 case EggTexture::CO_src_alpha:
1421 return out << "src_alpha";
1422
1423 case EggTexture::CO_one_minus_src_alpha:
1424 return out << "one_minus_src_alpha";
1425 }
1426
1427 return out << "**invalid CombineOperand(" << (int)co << ")**";
1428}
1429
1430ostream &
1431operator << (ostream &out, EggTexture::TexGen tex_gen) {
1432 switch (tex_gen) {
1433 case EggTexture::TG_unspecified:
1434 return out << "unspecified";
1435
1436 case EggTexture::TG_eye_sphere_map:
1437 return out << "eye_sphere_map";
1438
1439 case EggTexture::TG_world_cube_map:
1440 return out << "world_cube_map";
1441
1442 case EggTexture::TG_eye_cube_map:
1443 return out << "eye_cube_map";
1444
1445 case EggTexture::TG_world_normal:
1446 return out << "world_normal";
1447
1448 case EggTexture::TG_eye_normal:
1449 return out << "eye_normal";
1450
1451 case EggTexture::TG_world_position:
1452 return out << "world_position";
1453
1454 case EggTexture::TG_eye_position:
1455 return out << "eye_position";
1456
1457 case EggTexture::TG_point_sprite:
1458 return out << "point_sprite";
1459 }
1460
1461 return out << "**invalid TexGen(" << (int)tex_gen << ")**";
1462}
1463
1464ostream &
1465operator << (ostream &out, EggTexture::QualityLevel quality_level) {
1466 switch (quality_level) {
1467 case EggTexture::QL_unspecified:
1468 return out << "unspecified";
1469 case EggTexture::QL_default:
1470 return out << "default";
1471 case EggTexture::QL_fastest:
1472 return out << "fastest";
1473 case EggTexture::QL_normal:
1474 return out << "normal";
1475 case EggTexture::QL_best:
1476 return out << "best";
1477 }
1478
1479 return out << "**invalid QualityLevel(" << (int)quality_level << ")**";
1480}
This is an egg node that contains a filename.
const Filename & get_filename() const
Returns a nonmodifiable reference to the filename.
void write_header(std::ostream &out, int indent_level, const char *egg_keyword) const
Writes the first line of the egg object, e.g.
void write(std::ostream &out, int indent_level) const
Writes the attributes to the indicated output stream in Egg format.
Defines a texture map that may be applied to geometry.
Definition: eggTexture.h:30
static CombineOperand string_combine_operand(const std::string &string)
Returns the CombineOperand value associated with the given string representation, or CO_unspecified i...
Definition: eggTexture.cxx:966
get_stage_name
Returns the stage name that has been specified for this texture, or the tref name if no texture stage...
Definition: eggTexture.h:333
get_read_mipmaps
Returns the current setting of the read_mipmaps flag.
Definition: eggTexture.h:354
has_uv_name
Returns true if a texcoord name has been explicitly specified for this texture, false otherwise.
Definition: eggTexture.h:341
get_alpha_scale
Returns the alpha_scale value that has been specified for the texture, or 1 if no alpha_scale value h...
Definition: eggTexture.h:345
get_wrap_w
Returns the amount specified for W wrap.
Definition: eggTexture.h:323
get_uv_name
Returns the texcoord name that has been specified for this texture, or the empty string if no texcoor...
Definition: eggTexture.h:341
static EnvType string_env_type(const std::string &string)
Returns the EnvType value associated with the given string representation, or ET_unspecified if the s...
Definition: eggTexture.cxx:840
static CombineSource string_combine_source(const std::string &string)
Returns the CombineSource value associated with the given string representation, or CS_unspecified if...
Definition: eggTexture.cxx:936
get_multiview
Returns the current setting of the multiview flag.
Definition: eggTexture.h:351
get_multitexture_sort
Returns an integer that represents the depth to which this texture is layered on all other textures i...
Definition: eggTexture.h:362
has_num_views
Returns true if the number of views has been specified for the 3-D multiview texture,...
Definition: eggTexture.h:353
virtual EggTransform * as_transform()
Returns this object cross-cast to an EggTransform pointer, if it inherits from EggTransform,...
get_alpha_file_channel
Returns the particular channel that has been specified for the alpha-file image, or 0 if no channel h...
Definition: eggTexture.h:350
static TextureType string_texture_type(const std::string &string)
Returns the Texture_ype value associated with the given string representation, or TT_unspecified if t...
Definition: eggTexture.cxx:662
has_anisotropic_degree
Returns true if a value for the anisotropic filtering degree has been specified for this texture,...
Definition: eggTexture.h:327
static Format string_format(const std::string &string)
Returns the Format value associated with the given string representation, or F_unspecified if the str...
Definition: eggTexture.cxx:693
get_wrap_u
Returns the amount specified for U wrap.
Definition: eggTexture.h:321
static QualityLevel string_quality_level(const std::string &string)
Returns the TexGen value associated with the given string representation, or ET_unspecified if the st...
bool has_alpha_channel(int num_components) const
Given the number of color components (channels) in the image file as actually read from the disk,...
Definition: eggTexture.cxx:501
bool is_equivalent_to(const EggTexture &other, int eq) const
Returns true if the two textures are equivalent in all relevant properties (according to eq),...
Definition: eggTexture.cxx:329
static FilterType string_filter_type(const std::string &string)
Returns the FilterType value associated with the given string representation, or FT_unspecified if th...
Definition: eggTexture.cxx:795
static CombineMode string_combine_mode(const std::string &string)
Returns the CombineMode value associated with the given string representation, or CM_unspecified if t...
Definition: eggTexture.cxx:900
bool multitexture_over(EggTexture *other)
Indicates that this texture should be layered on top of the other texture.
Definition: eggTexture.cxx:637
get_anisotropic_degree
Returns the anisotropic filtering degree that has been specified for this texture,...
Definition: eggTexture.h:327
has_color
Returns true if a blend color has been specified for the texture.
Definition: eggTexture.h:337
get_alpha_filename
Returns the separate file assigned for the alpha channel.
Definition: eggTexture.h:347
has_alpha_file_channel
Returns true if a particular channel has been specified for the alpha-file image, false otherwise.
Definition: eggTexture.h:350
virtual void write(std::ostream &out, int indent_level) const
Writes the texture definition to the indicated output stream in Egg format.
Definition: eggTexture.cxx:125
has_priority
Returns true if a priority value for multitexture importance has been specified for the texture,...
Definition: eggTexture.h:335
bool affects_polygon_alpha() const
Returns true if this texture's environment type or combine mode allows the texture to have an effect ...
Definition: eggTexture.cxx:543
has_rgb_scale
Returns true if an rgb_scale has been specified for the texture, false otherwise.
Definition: eggTexture.h:343
void clear_multitexture()
Resets the multitexture flags set by multitexture_over().
Definition: eggTexture.cxx:600
bool sorts_less_than(const EggTexture &other, int eq) const
An ordering operator to compare two textures for sorting order.
Definition: eggTexture.cxx:405
has_alpha_scale
Returns true if an alpha_scale has been specified for the texture, false otherwise.
Definition: eggTexture.h:345
static TexGen string_tex_gen(const std::string &string)
Returns the TexGen value associated with the given string representation, or ET_unspecified if the st...
Definition: eggTexture.cxx:989
static CompressionMode string_compression_mode(const std::string &string)
Returns the CompressionMode value associated with the given string representation,...
Definition: eggTexture.cxx:746
get_wrap_v
Returns the amount specified for V wrap.
Definition: eggTexture.h:322
get_rgb_scale
Returns the rgb_scale value that has been specified for the texture, or 1 if no rgb_scale value has b...
Definition: eggTexture.h:343
static WrapMode string_wrap_mode(const std::string &string)
Returns the WrapMode value associated with the given string representation, or WM_unspecified if the ...
Definition: eggTexture.cxx:773
has_border_color
Returns true if a border color has been specified for the texture.
Definition: eggTexture.h:339
get_priority
Returns the multitexture importance value that has been specified for the texture,...
Definition: eggTexture.h:335
has_stage_name
Returns true if a stage name has been explicitly specified for this texture, false otherwise.
Definition: eggTexture.h:333
has_alpha_filename
Returns true if a separate file for the alpha component has been applied, false otherwise.
Definition: eggTexture.h:347
get_num_views
Returns the specified number of views specified for the 3-D multiview texture.
Definition: eggTexture.h:353
get_saved_result
Returns the current setting of the saved_result flag.
Definition: eggTexture.h:329
This represents the <Transform> entry of a group or texture node: a list of component transform opera...
Definition: eggTransform.h:29
const LMatrix4d & get_transform3d() const
Returns the overall transform as a 4x4 matrix.
Definition: eggTransform.I:212
bool has_transform() const
Returns true if the transform is nonempty, false if it is empty (no transform components have been ad...
Definition: eggTransform.I:143
void write(std::ostream &out, int indent_level, const std::string &label) const
Writes the transform to the indicated stream in Egg format.
bool transform_is_identity() const
Returns true if the described transform is identity, false otherwise.
Definition: eggTransform.I:220
The name of a file, such as a texture file or an Egg file.
Definition: filename.h:39
std::string get_extension() const
Returns the file extension.
Definition: filename.I:400
std::string get_basename_wo_extension() const
Returns the basename part of the filename, without the file extension.
Definition: filename.I:386
std::string get_dirname() const
Returns the directory part of the filename.
Definition: filename.I:358
TypeHandle is the identifier used to differentiate C++ class types.
Definition: typeHandle.h:81
std::ostream & indent(std::ostream &out, int indent_level)
A handy function for doing text formatting.
Definition: dcindent.cxx:22
ostream & enquote_string(ostream &out, const string &str, int indent_level, bool always_quote)
Writes the string to the indicated output stream.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.