historical/toontown-classic.git/panda/include/renderEffects.I
2024-01-16 11:20:27 -06:00

216 lines
5.9 KiB
Text

/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file renderEffects.I
* @author drose
* @date 2002-03-14
*/
/**
*
*/
INLINE RenderEffects::Effect::
Effect(const RenderEffect *effect) :
_type(effect->get_type()),
_effect(effect)
{
}
/**
* This constructor is only used when reading the RenderEffects from a bam
* file. At this point, the effect pointer is unknown.
*/
INLINE RenderEffects::Effect::
Effect() {
}
/**
* This constructor makes an invalid Effect with no RenderEffect pointer; its
* purpose is just to make an object we can use to look up a particular type
* in the Effect set.
*/
INLINE RenderEffects::Effect::
Effect(TypeHandle type) :
_type(type),
_effect(nullptr)
{
}
/**
*
*/
INLINE RenderEffects::Effect::
Effect(const Effect &copy) :
_type(copy._type),
_effect(copy._effect)
{
}
/**
*
*/
INLINE void RenderEffects::Effect::
operator = (const Effect &copy) {
_type = copy._type;
_effect = copy._effect;
}
/**
* This is used by the Effects set to uniquify RenderEffects by type. Only
* one RenderEffect of a given type is allowed in the set. This ordering must
* also match the ordering reported by compare_to().
*/
INLINE bool RenderEffects::Effect::
operator < (const Effect &other) const {
return _type < other._type;
}
/**
* Provides an indication of whether a particular effect is equivalent to
* another one, for purposes of generating unique RenderEffects. This should
* compare all properties of the Effect, but it is important that the type is
* compared first, to be consistent with the ordering defined by operator <.
*/
INLINE int RenderEffects::Effect::
compare_to(const Effect &other) const {
if (_type != other._type) {
return _type.get_index() - other._type.get_index();
}
if (_effect != other._effect) {
return _effect < other._effect ? -1 : 1;
}
return 0;
}
/**
* Returns true if the state is empty, false otherwise.
*/
INLINE bool RenderEffects::
is_empty() const {
return _effects.empty();
}
/**
* Returns the number of separate effects indicated in the state.
* @deprecated in Python, use len(effects) instead, or effects.size() in C++.
*/
INLINE size_t RenderEffects::
get_num_effects() const {
return _effects.size();
}
/**
* Returns the nth effect in the state.
*/
INLINE const RenderEffect *RenderEffects::
get_effect(size_t n) const {
nassertr(n < _effects.size(), nullptr);
return _effects[n]._effect;
}
/**
* Returns the number of separate effects indicated in the state.
*/
INLINE size_t RenderEffects::
size() const {
return _effects.size();
}
/**
* Returns the nth effect in the state.
*/
INLINE const RenderEffect *RenderEffects::
operator [](size_t n) const {
nassertr(n < _effects.size(), nullptr);
return _effects[n]._effect;
}
/**
* Returns the effect in the state with the given type.
*/
INLINE const RenderEffect *RenderEffects::
operator [](TypeHandle type) const {
return get_effect(type);
}
/**
* This function is provided as an optimization, to speed up the render-time
* checking for the existance of a DecalEffect on this state. It returns true
* if a DecalEffect exists, false otherwise. Note that since there is no
* additional information stored on the DecalEffect, there's no point in
* returning it if it exists.
*/
INLINE bool RenderEffects::
has_decal() const {
if ((_flags & F_checked_decal) == 0) {
// We pretend this function is const, even though it transparently
// modifies the internal decal cache.
((RenderEffects *)this)->determine_decal();
}
return ((_flags & F_has_decal) != 0);
}
/**
* This function is provided as an optimization, to speed up the render-time
* checking for the existance of a ShowBoundsEffect on this state. It returns
* true if a ShowBoundsEffect exists, false otherwise. Note that since there
* is no additional information stored on the ShowBoundsEffect, there's no
* point in returning it if it exists.
*/
INLINE bool RenderEffects::
has_show_bounds() const {
if ((_flags & F_checked_show_bounds) == 0) {
// We pretend this function is const, even though it transparently
// modifies the internal show_bounds cache.
((RenderEffects *)this)->determine_show_bounds();
}
return ((_flags & F_has_show_bounds) != 0);
}
/**
* If has_show_bounds() returns true, this will return true if the
* ShowBoundsEffect in question requests showing a "tight" bound.
*/
INLINE bool RenderEffects::
has_show_tight_bounds() const {
if ((_flags & F_checked_show_bounds) == 0) {
// We pretend this function is const, even though it transparently
// modifies the internal show_bounds cache.
((RenderEffects *)this)->determine_show_bounds();
}
return ((_flags & F_has_show_tight_bounds) != 0);
}
/**
* This function is provided as an optimization, to speed up the render-time
* checking for the existance of an effect with a cull_callback on this state.
*/
INLINE bool RenderEffects::
has_cull_callback() const {
if ((_flags & F_checked_cull_callback) == 0) {
// We pretend this function is const, even though it transparently
// modifies the internal cull_callback cache.
((RenderEffects *)this)->determine_cull_callback();
}
return ((_flags & F_has_cull_callback) != 0);
}
/**
* This function is provided as an optimization, to speed up the render-time
* checking for the existance of an effect with a compute_adjust_transform on
* this state.
*/
INLINE bool RenderEffects::
has_adjust_transform() const {
if ((_flags & F_checked_adjust_transform) == 0) {
// We pretend this function is const, even though it transparently
// modifies the internal adjust_transform cache.
((RenderEffects *)this)->determine_adjust_transform();
}
return ((_flags & F_has_adjust_transform) != 0);
}