Panda3D
Loading...
Searching...
No Matches
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...
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...
static CombineSource string_combine_source(const std::string &string)
Returns the CombineSource value associated with the given string representation, or CS_unspecified if...
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...
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...
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,...
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),...
static FilterType string_filter_type(const std::string &string)
Returns the FilterType value associated with the given string representation, or FT_unspecified if th...
static CombineMode string_combine_mode(const std::string &string)
Returns the CombineMode value associated with the given string representation, or CM_unspecified if t...
bool multitexture_over(EggTexture *other)
Indicates that this texture should be layered on top of the other texture.
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.
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 ...
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().
bool sorts_less_than(const EggTexture &other, int eq) const
An ordering operator to compare two textures for sorting order.
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...
static CompressionMode string_compression_mode(const std::string &string)
Returns the CompressionMode value associated with the given string representation,...
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 ...
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...
const LMatrix4d & get_transform3d() const
Returns the overall transform as a 4x4 matrix.
bool has_transform() const
Returns true if the transform is nonempty, false if it is empty (no transform components have been ad...
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.
The name of a file, such as a texture file or an Egg file.
Definition filename.h:44
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
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.
std::ostream & indent(std::ostream &out, int indent_level)
A handy function for doing text formatting.
Definition indent.cxx:20
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.