581 lines
16 KiB
C++
581 lines
16 KiB
C++
/**
|
|
* 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 nodePathCollection.cxx
|
|
* @author drose
|
|
* @date 2002-03-06
|
|
*/
|
|
|
|
#include "nodePathCollection.h"
|
|
#include "findApproxPath.h"
|
|
#include "findApproxLevelEntry.h"
|
|
#include "textureAttrib.h"
|
|
#include "colorScaleAttrib.h"
|
|
#include "colorAttrib.h"
|
|
#include "indent.h"
|
|
|
|
using std::max;
|
|
using std::min;
|
|
|
|
/**
|
|
* Adds a new NodePath to the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
add_path(const NodePath &node_path) {
|
|
// If the pointer to our internal array is shared by any other
|
|
// NodePathCollections, we have to copy the array now so we won't
|
|
// inadvertently modify any of our brethren NodePathCollection objects.
|
|
|
|
if (_node_paths.get_ref_count() > 1) {
|
|
NodePaths old_node_paths = _node_paths;
|
|
_node_paths = NodePaths::empty_array(0);
|
|
_node_paths.v() = old_node_paths.v();
|
|
}
|
|
|
|
_node_paths.push_back(node_path);
|
|
}
|
|
|
|
/**
|
|
* Removes the indicated NodePath from the collection. Returns true if the
|
|
* path was removed, false if it was not a member of the collection.
|
|
*/
|
|
bool NodePathCollection::
|
|
remove_path(const NodePath &node_path) {
|
|
int path_index = -1;
|
|
for (int i = 0; path_index == -1 && i < (int)_node_paths.size(); i++) {
|
|
if (_node_paths[i] == node_path) {
|
|
path_index = i;
|
|
}
|
|
}
|
|
|
|
if (path_index == -1) {
|
|
// The indicated path was not a member of the collection.
|
|
return false;
|
|
}
|
|
|
|
// If the pointer to our internal array is shared by any other
|
|
// NodePathCollections, we have to copy the array now so we won't
|
|
// inadvertently modify any of our brethren NodePathCollection objects.
|
|
|
|
if (_node_paths.get_ref_count() > 1) {
|
|
NodePaths old_node_paths = _node_paths;
|
|
_node_paths = NodePaths::empty_array(0);
|
|
_node_paths.v() = old_node_paths.v();
|
|
}
|
|
|
|
_node_paths.erase(_node_paths.begin() + path_index);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Adds all the NodePaths indicated in the other collection to this path. The
|
|
* other paths are simply appended to the end of the paths in this list;
|
|
* duplicates are not automatically removed.
|
|
*/
|
|
void NodePathCollection::
|
|
add_paths_from(const NodePathCollection &other) {
|
|
int other_num_paths = other.get_num_paths();
|
|
for (int i = 0; i < other_num_paths; i++) {
|
|
add_path(other.get_path(i));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Removes from this collection all of the NodePaths listed in the other
|
|
* collection.
|
|
*/
|
|
void NodePathCollection::
|
|
remove_paths_from(const NodePathCollection &other) {
|
|
NodePaths new_paths;
|
|
int num_paths = get_num_paths();
|
|
for (int i = 0; i < num_paths; i++) {
|
|
NodePath path = get_path(i);
|
|
if (!other.has_path(path)) {
|
|
new_paths.push_back(path);
|
|
}
|
|
}
|
|
_node_paths = new_paths;
|
|
}
|
|
|
|
/**
|
|
* Removes any duplicate entries of the same NodePaths on this collection. If
|
|
* a NodePath appears multiple times, the first appearance is retained;
|
|
* subsequent appearances are removed.
|
|
*/
|
|
void NodePathCollection::
|
|
remove_duplicate_paths() {
|
|
NodePaths new_paths;
|
|
|
|
int num_paths = get_num_paths();
|
|
for (int i = 0; i < num_paths; i++) {
|
|
NodePath path = get_path(i);
|
|
bool duplicated = false;
|
|
|
|
for (int j = 0; j < i && !duplicated; j++) {
|
|
duplicated = (path == get_path(j));
|
|
}
|
|
|
|
if (!duplicated) {
|
|
new_paths.push_back(path);
|
|
}
|
|
}
|
|
|
|
_node_paths = new_paths;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the indicated NodePath appears in this collection, false
|
|
* otherwise.
|
|
*/
|
|
bool NodePathCollection::
|
|
has_path(const NodePath &path) const {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
if (path == get_path(i)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Removes all NodePaths from the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
clear() {
|
|
_node_paths.clear();
|
|
}
|
|
|
|
/**
|
|
* This is a hint to Panda to allocate enough memory to hold the given number
|
|
* of NodePaths, if you know ahead of time how many you will be adding.
|
|
*/
|
|
void NodePathCollection::
|
|
reserve(size_t num) {
|
|
_node_paths.reserve(num);
|
|
}
|
|
|
|
/**
|
|
* Returns true if there are no NodePaths in the collection, false otherwise.
|
|
*/
|
|
bool NodePathCollection::
|
|
is_empty() const {
|
|
return _node_paths.empty();
|
|
}
|
|
|
|
/**
|
|
* Returns the number of NodePaths in the collection.
|
|
*/
|
|
int NodePathCollection::
|
|
get_num_paths() const {
|
|
return _node_paths.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the nth NodePath in the collection.
|
|
*/
|
|
NodePath NodePathCollection::
|
|
get_path(int index) const {
|
|
nassertr(index >= 0 && index < (int)_node_paths.size(), NodePath());
|
|
|
|
return _node_paths[index];
|
|
}
|
|
|
|
/**
|
|
* Returns the nth NodePath in the collection. This is the same as
|
|
* get_path(), but it may be a more convenient way to access it.
|
|
*/
|
|
NodePath NodePathCollection::
|
|
operator [] (size_t index) const {
|
|
nassertr(index < _node_paths.size(), NodePath());
|
|
|
|
return _node_paths[index];
|
|
}
|
|
|
|
/**
|
|
* Returns the number of paths in the collection. This is the same thing as
|
|
* get_num_paths().
|
|
*/
|
|
size_t NodePathCollection::
|
|
size() const {
|
|
return _node_paths.size();
|
|
}
|
|
|
|
/**
|
|
* Lists all the nodes at and below each node in the collection
|
|
* hierarchically.
|
|
*/
|
|
void NodePathCollection::
|
|
ls(std::ostream &out, int indent_level) const {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
NodePath path = get_path(i);
|
|
indent(out, indent_level) << path << "\n";
|
|
path.ls(out, indent_level + 2);
|
|
out << "\n";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the complete set of all NodePaths that begin with any NodePath in
|
|
* this collection and can be extended by path. The shortest paths will be
|
|
* listed first.
|
|
*/
|
|
NodePathCollection NodePathCollection::
|
|
find_all_matches(const std::string &path) const {
|
|
NodePathCollection result;
|
|
|
|
FindApproxPath approx_path;
|
|
if (approx_path.add_string(path)) {
|
|
if (!is_empty()) {
|
|
FindApproxLevelEntry *level = nullptr;
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
FindApproxLevelEntry *start =
|
|
new FindApproxLevelEntry(get_path(i), approx_path);
|
|
start->_next = level;
|
|
level = start;
|
|
}
|
|
get_path(0).find_matches(result, level, -1);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Reparents all the NodePaths in the collection to the indicated node.
|
|
*/
|
|
void NodePathCollection::
|
|
reparent_to(const NodePath &other) {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).reparent_to(other);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reparents all the NodePaths in the collection to the indicated node,
|
|
* adjusting each transform so as not to move in world coordinates.
|
|
*/
|
|
void NodePathCollection::
|
|
wrt_reparent_to(const NodePath &other) {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).wrt_reparent_to(other);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows all NodePaths in the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
show() {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).show();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hides all NodePaths in the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
hide() {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).hide();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stashes all NodePaths in the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
stash() {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).stash();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unstashes all NodePaths in the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
unstash() {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).unstash();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detaches all NodePaths in the collection.
|
|
*/
|
|
void NodePathCollection::
|
|
detach() {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).detach_node();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the union of all of the into_collide_masks for nodes at this level
|
|
* and below. This is the same thing as node()->get_net_collide_mask().
|
|
*
|
|
* If you want to return what the into_collide_mask of this node itself is,
|
|
* without regard to its children, use node()->get_into_collide_mask().
|
|
*/
|
|
CollideMask NodePathCollection::
|
|
get_collide_mask() const {
|
|
CollideMask collide_mask;
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
collide_mask |= get_path(i).get_collide_mask();
|
|
}
|
|
return collide_mask;
|
|
}
|
|
|
|
/**
|
|
* Recursively applies the indicated CollideMask to the into_collide_masks for
|
|
* all nodes at this level and below.
|
|
*
|
|
* The default is to change all bits, but if bits_to_change is not all bits
|
|
* on, then only the bits that are set in bits_to_change are modified,
|
|
* allowing this call to change only a subset of the bits in the subgraph.
|
|
*/
|
|
void NodePathCollection::
|
|
set_collide_mask(CollideMask new_mask, CollideMask bits_to_change,
|
|
TypeHandle node_type) {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
get_path(i).set_collide_mask(new_mask, bits_to_change, node_type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates the minimum and maximum vertices of all Geoms at these
|
|
* NodePath's bottom nodes and below This is a tight bounding box; it will
|
|
* generally be tighter than the bounding volume returned by get_bounds() (but
|
|
* it is more expensive to compute).
|
|
*
|
|
* The return value is true if any points are within the bounding volume, or
|
|
* false if none are.
|
|
*/
|
|
bool NodePathCollection::
|
|
calc_tight_bounds(LPoint3 &min_point, LPoint3 &max_point) const {
|
|
bool have_bounds = false;
|
|
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
LPoint3 tmp_min;
|
|
LPoint3 tmp_max;
|
|
|
|
if (get_path(i).is_empty()) {
|
|
continue;
|
|
}
|
|
|
|
if (get_path(i).calc_tight_bounds(tmp_min, tmp_max)) {
|
|
if (!have_bounds) {
|
|
min_point = tmp_min;
|
|
max_point = tmp_max;
|
|
have_bounds = true;
|
|
} else {
|
|
min_point.set(min(min_point._v(0), tmp_min._v(0)),
|
|
min(min_point._v(1), tmp_min._v(1)),
|
|
min(min_point._v(2), tmp_min._v(2)));
|
|
max_point.set(max(max_point._v(0), tmp_max._v(0)),
|
|
max(max_point._v(1), tmp_max._v(1)),
|
|
max(max_point._v(2), tmp_max._v(2)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return have_bounds;
|
|
}
|
|
|
|
/**
|
|
* Adds the indicated texture to the list of textures that will be rendered on
|
|
* the default texture stage.
|
|
*
|
|
* This is the deprecated single-texture variant of this method; it is now
|
|
* superceded by set_texture() that accepts a stage and texture. However,
|
|
* this method may be used in the presence of multitexture if you just want to
|
|
* adjust the default stage.
|
|
*/
|
|
void NodePathCollection::
|
|
set_texture(Texture *tex, int priority) {
|
|
PT(TextureStage) stage = TextureStage::get_default();
|
|
set_texture(stage, tex, priority);
|
|
}
|
|
|
|
/**
|
|
* Adds the indicated texture to the list of textures that will be rendered on
|
|
* the indicated multitexture stage. If there are multiple texture stages
|
|
* specified (possibly on multiple different nodes at different levels), they
|
|
* will all be applied to geometry together, according to the stage
|
|
* specification set up in the TextureStage object.
|
|
*/
|
|
void NodePathCollection::
|
|
set_texture(TextureStage *stage, Texture *tex, int priority) {
|
|
StateMap state_map;
|
|
|
|
NodePaths::iterator npi;
|
|
for (npi = _node_paths.begin(); npi != _node_paths.end(); ++npi) {
|
|
NodePath &np = (*npi);
|
|
CPT(RenderState) orig_state = np.get_state();
|
|
StateMap::iterator smi = state_map.find(orig_state);
|
|
if (smi != state_map.end()) {
|
|
// This RenderState has already been encountered; reuse it.
|
|
np.set_state((*smi).second);
|
|
} else {
|
|
// This RenderState has not yet been encountered; apply the attrib to
|
|
// it.
|
|
np.set_texture(stage, tex, priority);
|
|
state_map[orig_state] = np.get_state();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the geometry at this level and below to render using no texture, on
|
|
* any stage. This is different from not specifying a texture; rather, this
|
|
* specifically contradicts set_texture() at a higher node level (or, with a
|
|
* priority, overrides a set_texture() at a lower level).
|
|
*/
|
|
void NodePathCollection::
|
|
set_texture_off(int priority) {
|
|
nassertv_always(!is_empty());
|
|
set_attrib(TextureAttrib::make_all_off(), priority);
|
|
}
|
|
|
|
/**
|
|
* Sets the geometry at this level and below to render using no texture, on
|
|
* the indicated stage. This is different from not specifying a texture;
|
|
* rather, this specifically contradicts set_texture() at a higher node level
|
|
* (or, with a priority, overrides a set_texture() at a lower level).
|
|
*/
|
|
void NodePathCollection::
|
|
set_texture_off(TextureStage *stage, int priority) {
|
|
StateMap state_map;
|
|
|
|
NodePaths::iterator npi;
|
|
for (npi = _node_paths.begin(); npi != _node_paths.end(); ++npi) {
|
|
NodePath &np = (*npi);
|
|
CPT(RenderState) orig_state = np.get_state();
|
|
StateMap::iterator smi = state_map.find(orig_state);
|
|
if (smi != state_map.end()) {
|
|
// This RenderState has already been encountered; reuse it.
|
|
np.set_state((*smi).second);
|
|
} else {
|
|
// This RenderState has not yet been encountered; apply the attrib to
|
|
// it.
|
|
np.set_texture_off(stage, priority);
|
|
state_map[orig_state] = np.get_state();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Colors all NodePaths in the collection
|
|
*/
|
|
void NodePathCollection::
|
|
set_color(const LColor &color, int priority) {
|
|
set_attrib(ColorAttrib::make_flat(color), priority);
|
|
}
|
|
|
|
/**
|
|
* Applies color scales to all NodePaths in the collection. The existing
|
|
* color scale is replaced.
|
|
*/
|
|
void NodePathCollection::
|
|
set_color_scale(const LVecBase4 &scale, int priority) {
|
|
StateMap state_map;
|
|
|
|
NodePaths::iterator npi;
|
|
for (npi = _node_paths.begin(); npi != _node_paths.end(); ++npi) {
|
|
NodePath &np = (*npi);
|
|
CPT(RenderState) orig_state = np.get_state();
|
|
StateMap::iterator smi = state_map.find(orig_state);
|
|
if (smi != state_map.end()) {
|
|
// This RenderState has already been encountered; reuse it.
|
|
np.set_state((*smi).second);
|
|
} else {
|
|
// This RenderState has not yet been encountered; apply the attrib to
|
|
// it.
|
|
np.set_color_scale(scale, priority);
|
|
state_map[orig_state] = np.get_state();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies color scales to all NodePaths in the collection. The existing
|
|
* color scale, if any, is multiplied by the specified color scale.
|
|
*/
|
|
void NodePathCollection::
|
|
compose_color_scale(const LVecBase4 &scale, int priority) {
|
|
StateMap state_map;
|
|
|
|
NodePaths::iterator npi;
|
|
for (npi = _node_paths.begin(); npi != _node_paths.end(); ++npi) {
|
|
NodePath &np = (*npi);
|
|
CPT(RenderState) orig_state = np.get_state();
|
|
StateMap::iterator smi = state_map.find(orig_state);
|
|
if (smi != state_map.end()) {
|
|
// This RenderState has already been encountered; reuse it.
|
|
np.set_state((*smi).second);
|
|
} else {
|
|
// This RenderState has not yet been encountered; apply the attrib to
|
|
// it.
|
|
np.compose_color_scale(scale, priority);
|
|
state_map[orig_state] = np.get_state();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies the indicated RenderAttrib to all NodePaths in the collection. An
|
|
* effort is made to apply the attrib to many NodePaths as quickly as
|
|
* possible; redundant RenderState compositions are not duplicated.
|
|
*/
|
|
void NodePathCollection::
|
|
set_attrib(const RenderAttrib *attrib, int priority) {
|
|
StateMap state_map;
|
|
|
|
NodePaths::iterator npi;
|
|
for (npi = _node_paths.begin(); npi != _node_paths.end(); ++npi) {
|
|
NodePath &np = (*npi);
|
|
CPT(RenderState) orig_state = np.get_state();
|
|
StateMap::iterator smi = state_map.find(orig_state);
|
|
if (smi != state_map.end()) {
|
|
// This RenderState has already been encountered; reuse it.
|
|
np.set_state((*smi).second);
|
|
} else {
|
|
// This RenderState has not yet been encountered; apply the attrib to
|
|
// it.
|
|
np.set_attrib(attrib, priority);
|
|
state_map[orig_state] = np.get_state();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes a brief one-line description of the NodePathCollection to the
|
|
* indicated output stream.
|
|
*/
|
|
void NodePathCollection::
|
|
output(std::ostream &out) const {
|
|
if (get_num_paths() == 1) {
|
|
out << "1 NodePath";
|
|
} else {
|
|
out << get_num_paths() << " NodePaths";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes a complete multi-line description of the NodePathCollection to the
|
|
* indicated output stream.
|
|
*/
|
|
void NodePathCollection::
|
|
write(std::ostream &out, int indent_level) const {
|
|
for (int i = 0; i < get_num_paths(); i++) {
|
|
indent(out, indent_level) << get_path(i) << "\n";
|
|
}
|
|
}
|