Panda3D
nodePath.h
1 // Filename: nodePath.h
2 // Created by: drose (25Feb02)
3 // Updated by: fperazzi, PandaSE (06Apr10) (added more overloads
4 // for set_shader_input)
5 // Updated by: weifengh, PandaSE(30Apr10)
6 //
7 ////////////////////////////////////////////////////////////////////
8 //
9 // PANDA 3D SOFTWARE
10 // Copyright (c) Carnegie Mellon University. All rights reserved.
11 //
12 // All use of this software is subject to the terms of the revised BSD
13 // license. You should have received a copy of this license along
14 // with this source code in a file named "LICENSE."
15 //
16 ////////////////////////////////////////////////////////////////////
17 
18 #ifndef NODEPATH_H
19 #define NODEPATH_H
20 
21 #include "pandabase.h"
22 
23 #include "pandaNode.h"
24 #include "renderState.h"
25 #include "transformState.h"
26 #include "renderModeAttrib.h"
27 #include "transparencyAttrib.h"
28 #include "nodePathComponent.h"
29 #include "pointerTo.h"
30 #include "referenceCount.h"
31 #include "pnotify.h"
32 #include "typedObject.h"
33 #include "pta_float.h"
34 #include "pta_double.h"
35 #include "pta_LMatrix4.h"
36 #include "pta_LMatrix3.h"
37 #include "pta_LVecBase4.h"
38 #include "pta_LVecBase3.h"
39 #include "pta_LVecBase2.h"
40 #include "stl_compares.h"
41 #include "shaderInput.h"
42 #include "textureCollection.h"
43 #include "textureStageCollection.h"
44 
45 class NodePathCollection;
46 class FindApproxPath;
48 class Light;
49 class PolylightNode;
51 class Texture;
52 class TextureStage;
53 class TextureCollection;
55 class Material;
56 class MaterialCollection;
57 class Fog;
58 class GlobPattern;
60 class SamplerState;
61 class Shader;
62 class ShaderInput;
63 
64 //
65 // A NodePath is the fundamental unit of high-level interaction with
66 // the scene graph. It encapsulates the complete path down to a node
67 // from some other node, usually the root of the scene graph. This is
68 // used to resolve ambiguities associated with instancing.
69 //
70 // NodePath also contains a number of handy high-level methods for
71 // common scene-graph manipulations, such as reparenting, and common
72 // state changes, such as repositioning.
73 //
74 // There are also a number of NodePath methods for finding nodes deep
75 // within the tree by name or by type. These take a path string,
76 // which at its simplest consists of a series of node names separated
77 // by slashes, like a directory pathname.
78 //
79 // Each component of the path string may optionally consist of one of
80 // the following special names, instead of a node name:
81 //
82 // * -- matches exactly one node, with any name.
83 // ** -- matches any sequence of zero or more nodes.
84 // +typename -- matches any node that is or derives from the given type.
85 // -typename -- matches any node that is the given type exactly.
86 // =tag -- matches any node that has the indicated tag.
87 // =tag=value -- matches any node whose tag matches the indicated value.
88 //
89 // Furthermore, a node name may itself contain standard filename
90 // globbing characters, like *, ?, and [a-z], that will be accepted as
91 // a partial match. (In fact, the '*' special name may be seen as
92 // just a special case of this.) The globbing characters may not be
93 // used with the typename matches or with tag matches, but they may
94 // be used to match a tag's value in the =tag=value syntax.
95 //
96 // The special characters "@@", appearing at the beginning of a node
97 // name, indicate a stashed node. Normally, stashed nodes are not
98 // returned by a find (but see the special flags, below), but a
99 // stashed node may be found if it is explicitly named with its
100 // leading @@ characters. By extension, "@@*" may be used to identify
101 // any stashed node.
102 //
103 // Examples:
104 //
105 // "room//graph" will look for a node named "graph", which is a child
106 // of an unnamed node, which is a child of a node named "room", which
107 // is a child of the starting path.
108 //
109 // "**/red*" will look for any node anywhere in the tree (below the
110 // starting path) with a name that begins with "red".
111 //
112 // "**/+PartBundleNode/**/head" will look for a node named "head",
113 // somewhere below a PartBundleNode anywhere in the tree.
114 //
115 //
116 // The search is always potentially ambiguous, even if the special
117 // wildcard operators are not used, because there may be multiple
118 // nodes in the tree with the same name. In general, in the case of
119 // an ambiguity, the shortest path is preferred; when a method (such
120 // as extend_by) must choose only only one of several possible paths,
121 // it will choose the shortest available; on the other hand, when a
122 // method (such as find_all_matches) is to return all of the matching
123 // paths, it will sort them so that the shortest paths appear first in
124 // the output.
125 //
126 //
127 // Special flags. The entire string may optionally be followed by the
128 // ";" character, followed by one or more of the following special
129 // control flags, with no intervening spaces or punctuation:
130 //
131 // -h Do not return hidden nodes.
132 // +h Do return hidden nodes.
133 // -s Do not return stashed nodes unless explicitly referenced with @@.
134 // +s Return stashed nodes even without any explicit @@ characters.
135 // -i Node name comparisons are not case insensitive: case must match
136 // exactly.
137 // +i Node name comparisons are case insensitive: case is not important.
138 // This affects matches against the node name only; node type
139 // and tag strings are always case sensitive.
140 //
141 // The default flags are +h-s-i.
142 //
143 
144 
145 ////////////////////////////////////////////////////////////////////
146 // Class : NodePath
147 // Description : NodePath is the fundamental system for disambiguating
148 // instances, and also provides a higher-level interface
149 // for manipulating the scene graph.
150 //
151 // A NodePath is a list of connected nodes from the root
152 // of the graph to any sub-node. Each NodePath
153 // therefore uniquely describes one instance of a node.
154 //
155 // NodePaths themselves are lightweight objects that may
156 // easily be copied and passed by value. Their data is
157 // stored as a series of NodePathComponents that are
158 // stored on the nodes. Holding a NodePath will keep a
159 // reference count to all the nodes in the path.
160 // However, if any node in the path is removed or
161 // reparented (perhaps through a different NodePath),
162 // the NodePath will automatically be updated to reflect
163 // the changes.
164 ////////////////////////////////////////////////////////////////////
165 class EXPCL_PANDA_PGRAPH NodePath {
166 PUBLISHED:
167  // This enumeration is returned by get_error_type() for an empty
168  // NodePath to report the reason it's empty.
169  enum ErrorType {
170  ET_ok = 0, // i.e. not empty, or never assigned to anything.
171  ET_not_found, // returned from a failed find() or similar function.
172  ET_removed, // remove_node() was previously called on this NodePath.
173  ET_fail, // general failure return from some function.
174  };
175 
176  INLINE NodePath();
177  INLINE explicit NodePath(const string &top_node_name, Thread *current_thread = Thread::get_current_thread());
178  INLINE explicit NodePath(PandaNode *node, Thread *current_thread = Thread::get_current_thread());
179  INLINE static NodePath any_path(PandaNode *node, Thread *current_thread = Thread::get_current_thread());
180  NodePath(const NodePath &parent, PandaNode *child_node,
181  Thread *current_thread = Thread::get_current_thread());
182 
183  INLINE NodePath(const NodePath &copy);
184  INLINE void operator = (const NodePath &copy);
185  INLINE void clear();
186 
187 #ifdef USE_MOVE_SEMANTICS
188  INLINE NodePath(NodePath &&from) NOEXCEPT;
189  INLINE void operator = (NodePath &&from) NOEXCEPT;
190 #endif
191 
192  EXTENSION(NodePath __copy__() const);
193  EXTENSION(PyObject *__deepcopy__(PyObject *self, PyObject *memo) const);
194  EXTENSION(PyObject *__reduce__(PyObject *self) const);
195  EXTENSION(PyObject *__reduce_persist__(PyObject *self, PyObject *pickler) const);
196 
197  INLINE static NodePath not_found();
198  INLINE static NodePath removed();
199  INLINE static NodePath fail();
200 
201  INLINE static void set_max_search_depth(int max_search_depth);
202  INLINE static int get_max_search_depth();
203 
204  // Methods to query a NodePath's contents.
205  INLINE bool is_empty() const;
206  operator bool () const;
207 
208  INLINE bool is_singleton(Thread *current_thread = Thread::get_current_thread()) const;
209  int get_num_nodes(Thread *current_thread = Thread::get_current_thread()) const;
210  PandaNode *get_node(int index, Thread *current_thread = Thread::get_current_thread()) const;
211  MAKE_SEQ(get_nodes, get_num_nodes, get_node);
212  NodePath get_ancestor(int index, Thread *current_thread = Thread::get_current_thread()) const;
213  MAKE_SEQ(get_ancestors, get_num_nodes, get_ancestor);
214 
215  INLINE ErrorType get_error_type() const;
216 
217  INLINE PandaNode *get_top_node(Thread *current_thread = Thread::get_current_thread()) const;
218  NodePath get_top(Thread *current_thread = Thread::get_current_thread()) const;
219 
220  INLINE PandaNode *node() const;
221 
222  INLINE int get_key() const;
223  INLINE size_t add_hash(size_t hash) const;
224 
225  INLINE bool is_same_graph(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
226  INLINE bool is_ancestor_of(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
227  INLINE NodePath get_common_ancestor(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
228 
229  // Methods that return collections of NodePaths derived from or
230  // related to this one.
231 
232  NodePathCollection get_children(Thread *current_thread = Thread::get_current_thread()) const;
233  INLINE int get_num_children(Thread *current_thread = Thread::get_current_thread()) const;
234  INLINE NodePath get_child(int n, Thread *current_thread = Thread::get_current_thread()) const;
235  NodePathCollection get_stashed_children(Thread *current_thread = Thread::get_current_thread()) const;
236 
237  INLINE int count_num_descendants() const;
238 
239  INLINE bool has_parent(Thread *current_thread = Thread::get_current_thread()) const;
240  INLINE NodePath get_parent(Thread *current_thread = Thread::get_current_thread()) const;
241  int get_sort(Thread *current_thread = Thread::get_current_thread()) const;
242 
243  NodePath find(const string &path) const;
244  NodePath find_path_to(PandaNode *node) const;
245  NodePathCollection find_all_matches(const string &path) const;
246  NodePathCollection find_all_paths_to(PandaNode *node) const;
247 
248  // Methods that actually move nodes around in the scene graph. The
249  // optional "sort" parameter can be used to force a particular
250  // ordering between sibling nodes, useful when dealing with LOD's
251  // and similar switch nodes. If the sort value is the same, nodes
252  // will be arranged in the order they were added.
253  void reparent_to(const NodePath &other, int sort = 0,
254  Thread *current_thread = Thread::get_current_thread());
255  void stash_to(const NodePath &other, int sort = 0,
256  Thread *current_thread = Thread::get_current_thread());
257  void wrt_reparent_to(const NodePath &other, int sort = 0,
258  Thread *current_thread = Thread::get_current_thread());
259  NodePath instance_to(const NodePath &other, int sort = 0,
260  Thread *current_thread = Thread::get_current_thread()) const;
261  NodePath instance_under_node(const NodePath &other, const string &name,
262  int sort = 0,
263  Thread *current_thread = Thread::get_current_thread()) const;
264  NodePath copy_to(const NodePath &other, int sort = 0,
265  Thread *current_thread = Thread::get_current_thread()) const;
266  NodePath attach_new_node(PandaNode *node, int sort = 0,
267  Thread *current_thread = Thread::get_current_thread()) const;
268  INLINE NodePath attach_new_node(const string &name, int sort = 0,
269  Thread *current_thread = Thread::get_current_thread()) const;
270  void remove_node(Thread *current_thread = Thread::get_current_thread());
271  void detach_node(Thread *current_thread = Thread::get_current_thread());
272 
273  // Handy ways to look at what's there, and other miscellaneous
274  // operations.
275 
276  void output(ostream &out) const;
277 
278  INLINE void ls() const;
279  INLINE void ls(ostream &out, int indent_level = 0) const;
280  INLINE void reverse_ls() const;
281  INLINE int reverse_ls(ostream &out, int indent_level = 0) const;
282 
283 
284  // Aggregate transform and state information.
285  const RenderState *get_state(Thread *current_thread = Thread::get_current_thread()) const;
286  INLINE void set_state(const RenderState *state, Thread *current_thread = Thread::get_current_thread());
287  CPT(RenderState) get_state(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
288  void set_state(const NodePath &other, const RenderState *state, Thread *current_thread = Thread::get_current_thread());
289  INLINE CPT(RenderState) get_net_state(Thread *current_thread = Thread::get_current_thread()) const;
290 
291  INLINE void set_attrib(const RenderAttrib *attrib, int priority = 0);
292  INLINE const RenderAttrib *get_attrib(TypeHandle type) const;
293  INLINE bool has_attrib(TypeHandle type) const;
294  INLINE void clear_attrib(TypeHandle type);
295 
296  INLINE void set_effect(const RenderEffect *effect);
297  INLINE const RenderEffect *get_effect(TypeHandle type) const;
298  INLINE bool has_effect(TypeHandle type) const;
299  INLINE void clear_effect(TypeHandle type);
300 
301  INLINE void set_effects(const RenderEffects *effects);
302  INLINE const RenderEffects *get_effects() const;
303  INLINE void clear_effects();
304 
305  const TransformState *get_transform(Thread *current_thread = Thread::get_current_thread()) const;
306  INLINE void clear_transform(Thread *current_thread = Thread::get_current_thread());
307  INLINE void set_transform(const TransformState *transform, Thread *current_thread = Thread::get_current_thread());
308  CPT(TransformState) get_transform(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
309  INLINE void clear_transform(const NodePath &other, Thread *current_thread = Thread::get_current_thread());
310  void set_transform(const NodePath &other, const TransformState *transform, Thread *current_thread = Thread::get_current_thread());
311  INLINE CPT(TransformState) get_net_transform(Thread *current_thread = Thread::get_current_thread()) const;
312 
313  const TransformState *get_prev_transform(Thread *current_thread = Thread::get_current_thread()) const;
314  INLINE void set_prev_transform(const TransformState *transform, Thread *current_thread = Thread::get_current_thread());
315  CPT(TransformState) get_prev_transform(const NodePath &other, Thread *current_thread = Thread::get_current_thread()) const;
316  void set_prev_transform(const NodePath &other, const TransformState *transform, Thread *current_thread = Thread::get_current_thread());
317  INLINE CPT(TransformState) get_net_prev_transform(Thread *current_thread = Thread::get_current_thread()) const;
318 
319 
320  // Methods that get and set the matrix transform: pos, hpr, scale,
321  // in the local coordinate system.
322 
323  INLINE void set_pos(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
324  void set_pos(const LVecBase3 &pos);
325  void set_x(PN_stdfloat x);
326  void set_y(PN_stdfloat y);
327  void set_z(PN_stdfloat z);
328  INLINE void set_fluid_pos(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
329  void set_fluid_pos(const LVecBase3 &pos);
330  void set_fluid_x(PN_stdfloat x);
331  void set_fluid_y(PN_stdfloat y);
332  void set_fluid_z(PN_stdfloat z);
333  LPoint3 get_pos() const;
334  INLINE PN_stdfloat get_x() const;
335  INLINE PN_stdfloat get_y() const;
336  INLINE PN_stdfloat get_z() const;
337 
338  LVector3 get_pos_delta() const;
339 
340  INLINE void set_hpr(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
341  void set_hpr(const LVecBase3 &hpr);
342  void set_h(PN_stdfloat h);
343  void set_p(PN_stdfloat p);
344  void set_r(PN_stdfloat r);
345  LVecBase3 get_hpr() const;
346  INLINE PN_stdfloat get_h() const;
347  INLINE PN_stdfloat get_p() const;
348  INLINE PN_stdfloat get_r() const;
349 
350  void set_quat(const LQuaternion &quat);
351  LQuaternion get_quat() const;
352 
353  INLINE void set_scale(PN_stdfloat scale);
354  INLINE void set_scale(PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
355  void set_scale(const LVecBase3 &scale);
356  void set_sx(PN_stdfloat sx);
357  void set_sy(PN_stdfloat sy);
358  void set_sz(PN_stdfloat sz);
359  LVecBase3 get_scale() const;
360  INLINE PN_stdfloat get_sx() const;
361  INLINE PN_stdfloat get_sy() const;
362  INLINE PN_stdfloat get_sz() const;
363 
364  INLINE void set_shear(PN_stdfloat shxy, PN_stdfloat shxz, PN_stdfloat shyz);
365  void set_shear(const LVecBase3 &shear);
366  void set_shxy(PN_stdfloat shxy);
367  void set_shxz(PN_stdfloat shxz);
368  void set_shyz(PN_stdfloat shyz);
369  LVecBase3 get_shear() const;
370  INLINE PN_stdfloat get_shxy() const;
371  INLINE PN_stdfloat get_shxz() const;
372  INLINE PN_stdfloat get_shyz() const;
373 
374  INLINE void set_pos_hpr(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z,
375  PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
376  void set_pos_hpr(const LVecBase3 &pos,
377  const LVecBase3 &hpr);
378  void set_pos_quat(const LVecBase3 &pos,
379  const LQuaternion &quat);
380 
381  INLINE void set_hpr_scale(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r,
382  PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
383  void set_hpr_scale(const LVecBase3 &hpr,
384  const LVecBase3 &scale);
385  void set_quat_scale(const LQuaternion &quat,
386  const LVecBase3 &scale);
387  INLINE void set_pos_hpr_scale(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z,
388  PN_stdfloat h, PN_stdfloat p, PN_stdfloat r,
389  PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
390  void set_pos_hpr_scale(const LVecBase3 &pos,
391  const LVecBase3 &hpr,
392  const LVecBase3 &scale);
393  void set_pos_quat_scale(const LVecBase3 &pos,
394  const LQuaternion &quat,
395  const LVecBase3 &scale);
396  void set_pos_hpr_scale_shear(const LVecBase3 &pos,
397  const LVecBase3 &hpr,
398  const LVecBase3 &scale,
399  const LVecBase3 &shear);
400  void set_pos_quat_scale_shear(const LVecBase3 &pos,
401  const LQuaternion &quat,
402  const LVecBase3 &scale,
403  const LVecBase3 &shear);
404 
405  void set_mat(const LMatrix4 &mat);
406  INLINE void clear_mat();
407  INLINE bool has_mat() const;
408  INLINE const LMatrix4 &get_mat() const;
409 
410  INLINE void look_at(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
411  void look_at(const LPoint3 &point, const LVector3 &up = LVector3::up());
412  INLINE void heads_up(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
413  void heads_up(const LPoint3 &point, const LVector3 &up = LVector3::up());
414 
415  // Methods that get and set the matrix transforms relative to some
416  // other node in the scene graph. These perform an implicit wrt().
417 
418  INLINE void set_pos(const NodePath &other, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
419  void set_pos(const NodePath &other, const LVecBase3 &pos);
420  void set_x(const NodePath &other, PN_stdfloat x);
421  void set_y(const NodePath &other, PN_stdfloat y);
422  void set_z(const NodePath &other, PN_stdfloat z);
423  INLINE void set_fluid_pos(const NodePath &other, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
424  void set_fluid_pos(const NodePath &other, const LVecBase3 &pos);
425  void set_fluid_x(const NodePath &other, PN_stdfloat x);
426  void set_fluid_y(const NodePath &other, PN_stdfloat y);
427  void set_fluid_z(const NodePath &other, PN_stdfloat z);
428  LPoint3 get_pos(const NodePath &other) const;
429  INLINE PN_stdfloat get_x(const NodePath &other) const;
430  INLINE PN_stdfloat get_y(const NodePath &other) const;
431  INLINE PN_stdfloat get_z(const NodePath &other) const;
432 
433  LVector3 get_pos_delta(const NodePath &other) const;
434 
435  INLINE void set_hpr(const NodePath &other, PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
436  void set_hpr(const NodePath &other, const LVecBase3 &hpr);
437  void set_h(const NodePath &other, PN_stdfloat h);
438  void set_p(const NodePath &other, PN_stdfloat p);
439  void set_r(const NodePath &other, PN_stdfloat r);
440  LVecBase3 get_hpr(const NodePath &other) const;
441  INLINE PN_stdfloat get_h(const NodePath &other) const;
442  INLINE PN_stdfloat get_p(const NodePath &other) const;
443  INLINE PN_stdfloat get_r(const NodePath &other) const;
444 
445  void set_quat(const NodePath &other, const LQuaternion &quat);
446  LQuaternion get_quat(const NodePath &other) const;
447 
448  INLINE void set_scale(const NodePath &other, PN_stdfloat scale);
449  INLINE void set_scale(const NodePath &other, PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
450  void set_scale(const NodePath &other, const LVecBase3 &scale);
451  void set_sx(const NodePath &other, PN_stdfloat sx);
452  void set_sy(const NodePath &other, PN_stdfloat sy);
453  void set_sz(const NodePath &other, PN_stdfloat sz);
454  LVecBase3 get_scale(const NodePath &other) const;
455  INLINE PN_stdfloat get_sx(const NodePath &other) const;
456  INLINE PN_stdfloat get_sy(const NodePath &other) const;
457  INLINE PN_stdfloat get_sz(const NodePath &other) const;
458 
459  INLINE void set_shear(const NodePath &other, PN_stdfloat shxy, PN_stdfloat shxz, PN_stdfloat shyz);
460  void set_shear(const NodePath &other, const LVecBase3 &shear);
461  void set_shxy(const NodePath &other, PN_stdfloat shxy);
462  void set_shxz(const NodePath &other, PN_stdfloat shxz);
463  void set_shyz(const NodePath &other, PN_stdfloat shyz);
464  LVecBase3 get_shear(const NodePath &other) const;
465  INLINE PN_stdfloat get_shxy(const NodePath &other) const;
466  INLINE PN_stdfloat get_shxz(const NodePath &other) const;
467  INLINE PN_stdfloat get_shyz(const NodePath &other) const;
468 
469  INLINE void set_pos_hpr(const NodePath &other,
470  PN_stdfloat x, PN_stdfloat y, PN_stdfloat z,
471  PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
472  void set_pos_hpr(const NodePath &other,
473  const LVecBase3 &pos,
474  const LVecBase3 &hpr);
475  void set_pos_quat(const NodePath &other,
476  const LVecBase3 &pos,
477  const LQuaternion &quat);
478  INLINE void set_hpr_scale(const NodePath &other,
479  PN_stdfloat h, PN_stdfloat p, PN_stdfloat r,
480  PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
481  void set_hpr_scale(const NodePath &other,
482  const LVecBase3 &hpr,
483  const LVecBase3 &scale);
484  void set_quat_scale(const NodePath &other,
485  const LQuaternion &quat,
486  const LVecBase3 &scale);
487  INLINE void set_pos_hpr_scale(const NodePath &other,
488  PN_stdfloat x, PN_stdfloat y, PN_stdfloat z,
489  PN_stdfloat h, PN_stdfloat p, PN_stdfloat r,
490  PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz);
491  void set_pos_hpr_scale(const NodePath &other,
492  const LVecBase3 &pos,
493  const LVecBase3 &hpr,
494  const LVecBase3 &scale);
495  void set_pos_quat_scale(const NodePath &other,
496  const LVecBase3 &pos,
497  const LQuaternion &quat,
498  const LVecBase3 &scale);
499  void set_pos_hpr_scale_shear(const NodePath &other,
500  const LVecBase3 &pos,
501  const LVecBase3 &hpr,
502  const LVecBase3 &scale,
503  const LVecBase3 &shear);
504  void set_pos_quat_scale_shear(const NodePath &other,
505  const LVecBase3 &pos,
506  const LQuaternion &quat,
507  const LVecBase3 &scale,
508  const LVecBase3 &shear);
509 
510  LMatrix4 get_mat(const NodePath &other) const;
511  void set_mat(const NodePath &other, const LMatrix4 &mat);
512 
513  LPoint3 get_relative_point(const NodePath &other, const LVecBase3 &point) const;
514  LVector3 get_relative_vector(const NodePath &other, const LVecBase3 &vec) const;
515 
516  INLINE void look_at(const NodePath &other,
517  PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
518  void look_at(const NodePath &other,
519  const LPoint3 &point = LPoint3(0.0, 0.0, 0.0),
520  const LVector3 &up = LVector3::up());
521  INLINE void heads_up(const NodePath &other,
522  PN_stdfloat x, PN_stdfloat y, PN_stdfloat z);
523  void heads_up(const NodePath &other,
524  const LPoint3 &point = LPoint3(0.0, 0.0, 0.0),
525  const LVector3 &up = LVector3::up());
526 
527  INLINE PN_stdfloat get_distance(const NodePath &other) const;
528 
529 
530  // Methods that affect appearance of geometry: color, texture, etc.
531  // These affect the state at the bottom level only.
532 
533  void set_color(PN_stdfloat r, PN_stdfloat g, PN_stdfloat b, PN_stdfloat a = 1.0,
534  int priority = 0);
535  void set_color(const LColor &color, int priority = 0);
536  void set_color_off(int priority = 0);
537  void clear_color();
538  bool has_color() const;
539  LColor get_color() const;
540 
541  bool has_color_scale() const;
542  void clear_color_scale();
543  void set_color_scale(const LVecBase4 &scale,
544  int priority = 0);
545  INLINE void set_color_scale(PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz, PN_stdfloat sa,
546  int priority = 0);
547  void compose_color_scale(const LVecBase4 &scale,
548  int priority = 0);
549  INLINE void compose_color_scale(PN_stdfloat sx, PN_stdfloat sy, PN_stdfloat sz, PN_stdfloat sa,
550  int priority = 0);
551  void set_color_scale_off(int priority = 0);
552 
553  void set_alpha_scale(PN_stdfloat scale, int priority = 0);
554  void set_all_color_scale(PN_stdfloat scale, int priority = 0);
555  INLINE void set_sr(PN_stdfloat sr);
556  INLINE void set_sg(PN_stdfloat sg);
557  INLINE void set_sb(PN_stdfloat sb);
558  INLINE void set_sa(PN_stdfloat sa);
559 
560  const LVecBase4 &get_color_scale() const;
561  INLINE PN_stdfloat get_sr() const;
562  INLINE PN_stdfloat get_sg() const;
563  INLINE PN_stdfloat get_sb() const;
564  INLINE PN_stdfloat get_sa() const;
565 
566  void set_light(const NodePath &light, int priority = 0);
567  void set_light_off(int priority = 0);
568  void set_light_off(const NodePath &light, int priority = 0);
569  void clear_light();
570  void clear_light(const NodePath &light);
571  bool has_light(const NodePath &light) const;
572  bool has_light_off() const;
573  bool has_light_off(const NodePath &light) const;
574 
575  void set_clip_plane(const NodePath &clip_plane, int priority = 0);
576  void set_clip_plane_off(int priority = 0);
577  void set_clip_plane_off(const NodePath &clip_plane, int priority = 0);
578  void clear_clip_plane();
579  void clear_clip_plane(const NodePath &clip_plane);
580  bool has_clip_plane(const NodePath &clip_plane) const;
581  bool has_clip_plane_off() const;
582  bool has_clip_plane_off(const NodePath &clip_plane) const;
583 
584  void set_scissor(PN_stdfloat left, PN_stdfloat right, PN_stdfloat bottom, PN_stdfloat top);
585  void set_scissor(const LPoint3 &a, const LPoint3 &b);
586  void set_scissor(const LPoint3 &a, const LPoint3 &b,
587  const LPoint3 &c, const LPoint3 &d);
588  void set_scissor(const NodePath &other,
589  const LPoint3 &a, const LPoint3 &b);
590  void set_scissor(const NodePath &other,
591  const LPoint3 &a, const LPoint3 &b,
592  const LPoint3 &c, const LPoint3 &d);
593  void clear_scissor();
594  bool has_scissor() const;
595 
596  void set_occluder(const NodePath &occluder);
597  void clear_occluder();
598  void clear_occluder(const NodePath &occluder);
599  bool has_occluder(const NodePath &occluder) const;
600 
601  void set_bin(const string &bin_name, int draw_order, int priority = 0);
602  void clear_bin();
603  bool has_bin() const;
604  string get_bin_name() const;
605  int get_bin_draw_order() const;
606 
607  void set_texture(Texture *tex, int priority = 0);
608  void set_texture(TextureStage *stage, Texture *tex, int priority = 0);
609  void set_texture(Texture *tex, const SamplerState &sampler, int priority = 0);
610  void set_texture(TextureStage *stage, Texture *tex, const SamplerState &sampler, int priority = 0);
611  void set_texture_off(int priority = 0);
612  void set_texture_off(TextureStage *stage, int priority = 0);
613  void clear_texture();
614  void clear_texture(TextureStage *stage);
615  bool has_texture() const;
616  bool has_texture(TextureStage *stage) const;
617  bool has_texture_off() const;
618  bool has_texture_off(TextureStage *stage) const;
619  Texture *get_texture() const;
620  Texture *get_texture(TextureStage *stage) const;
621  const SamplerState &get_texture_sampler() const;
622  const SamplerState &get_texture_sampler(TextureStage *stage) const;
623 
624  void set_shader(const Shader *sha, int priority = 0);
625  void set_shader_off(int priority = 0);
626  void set_shader_auto(int priority = 0);
627  void set_shader_auto(BitMask32 shader_switch, int priority=0);
628  void clear_shader();
629 
630  void set_shader_input(const ShaderInput *inp);
631  INLINE void set_shader_input(CPT_InternalName id, Texture *tex, int priority=0);
632  INLINE void set_shader_input(CPT_InternalName id, Texture *tex, const SamplerState &sampler, int priority=0);
633  INLINE void set_shader_input(CPT_InternalName id, Texture *tex, bool read, bool write, int z=-1, int n=0, int priority=0);
634  INLINE void set_shader_input(CPT_InternalName id, const NodePath &np, int priority=0);
635  INLINE void set_shader_input(CPT_InternalName id, const PTA_float &v, int priority=0);
636  INLINE void set_shader_input(CPT_InternalName id, const PTA_double &v, int priority=0);
637  INLINE void set_shader_input(CPT_InternalName id, const PTA_int &v, int priority=0);
638  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase4 &v, int priority=0);
639  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase3 &v, int priority=0);
640  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase2 &v, int priority=0);
641  INLINE void set_shader_input(CPT_InternalName id, const PTA_LMatrix4 &v, int priority=0);
642  INLINE void set_shader_input(CPT_InternalName id, const PTA_LMatrix3 &v, int priority=0);
643  INLINE void set_shader_input(CPT_InternalName id, const LVecBase4 &v, int priority=0);
644  INLINE void set_shader_input(CPT_InternalName id, const LVecBase3 &v, int priority=0);
645  INLINE void set_shader_input(CPT_InternalName id, const LVecBase2 &v, int priority=0);
646  INLINE void set_shader_input(CPT_InternalName id, const LMatrix4 &v, int priority=0);
647  INLINE void set_shader_input(CPT_InternalName id, const LMatrix3 &v, int priority=0);
648  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase4i &v, int priority=0);
649  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase3i &v, int priority=0);
650  INLINE void set_shader_input(CPT_InternalName id, const PTA_LVecBase2i &v, int priority=0);
651  INLINE void set_shader_input(CPT_InternalName id, const LVecBase4i &v, int priority=0);
652  INLINE void set_shader_input(CPT_InternalName id, const LVecBase3i &v, int priority=0);
653  INLINE void set_shader_input(CPT_InternalName id, const LVecBase2i &v, int priority=0);
654  INLINE void set_shader_input(CPT_InternalName id, int n1, int n2=0, int n3=0,
655  int n4=0, int priority=0);
656  INLINE void set_shader_input(CPT_InternalName id, PN_stdfloat n1, PN_stdfloat n2=0,
657  PN_stdfloat n3=0, PN_stdfloat n4=0, int priority=0);
658 
659  void clear_shader_input(CPT_InternalName id);
660  void set_instance_count(int instance_count);
661 
662  const Shader *get_shader() const;
663  const ShaderInput *get_shader_input(CPT_InternalName id) const;
664  int get_instance_count() const;
665 
666  void set_tex_transform(TextureStage *stage, const TransformState *transform);
667  void clear_tex_transform();
668  void clear_tex_transform(TextureStage *stage);
669  bool has_tex_transform(TextureStage *stage) const;
670  CPT(TransformState) get_tex_transform(TextureStage *stage) const;
671 
672  INLINE void set_tex_offset(TextureStage *stage, PN_stdfloat u, PN_stdfloat v);
673  INLINE void set_tex_offset(TextureStage *stage, const LVecBase2 &uv);
674  INLINE void set_tex_rotate(TextureStage *stage, PN_stdfloat r);
675  INLINE void set_tex_scale(TextureStage *stage, PN_stdfloat scale);
676  INLINE void set_tex_scale(TextureStage *stage, PN_stdfloat su, PN_stdfloat sv);
677  INLINE void set_tex_scale(TextureStage *stage, const LVecBase2 &scale);
678  INLINE LVecBase2 get_tex_offset(TextureStage *stage) const;
679  INLINE PN_stdfloat get_tex_rotate(TextureStage *stage) const;
680  INLINE LVecBase2 get_tex_scale(TextureStage *stage) const;
681 
682  INLINE void set_tex_pos(TextureStage *stage, PN_stdfloat u, PN_stdfloat v, PN_stdfloat w);
683  INLINE void set_tex_pos(TextureStage *stage, const LVecBase3 &uvw);
684  INLINE void set_tex_hpr(TextureStage *stage, PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
685  INLINE void set_tex_hpr(TextureStage *stage, const LVecBase3 &hpr);
686  INLINE void set_tex_scale(TextureStage *stage, PN_stdfloat su, PN_stdfloat sv, PN_stdfloat sw);
687  INLINE void set_tex_scale(TextureStage *stage, const LVecBase3 &scale);
688  INLINE LVecBase3 get_tex_pos(TextureStage *stage) const;
689  INLINE LVecBase3 get_tex_hpr(TextureStage *stage) const;
690  INLINE LVecBase3 get_tex_scale_3d(TextureStage *stage) const;
691 
692  void set_tex_transform(const NodePath &other, TextureStage *stage, const TransformState *transform);
693  CPT(TransformState) get_tex_transform(const NodePath &other, TextureStage *stage) const;
694 
695  INLINE void set_tex_offset(const NodePath &other, TextureStage *stage, PN_stdfloat u, PN_stdfloat v);
696  INLINE void set_tex_offset(const NodePath &other, TextureStage *stage, const LVecBase2 &uv);
697  INLINE void set_tex_rotate(const NodePath &other, TextureStage *stage, PN_stdfloat r);
698  INLINE void set_tex_scale(const NodePath &other, TextureStage *stage, PN_stdfloat scale);
699  INLINE void set_tex_scale(const NodePath &other, TextureStage *stage, PN_stdfloat su, PN_stdfloat sv);
700  INLINE void set_tex_scale(const NodePath &other, TextureStage *stage, const LVecBase2 &scale);
701  INLINE LVecBase2 get_tex_offset(const NodePath &other, TextureStage *stage) const;
702  INLINE PN_stdfloat get_tex_rotate(const NodePath &other, TextureStage *stage) const;
703  INLINE LVecBase2 get_tex_scale(const NodePath &other, TextureStage *stage) const;
704 
705  INLINE void set_tex_pos(const NodePath &other, TextureStage *stage, PN_stdfloat u, PN_stdfloat v, PN_stdfloat w);
706  INLINE void set_tex_pos(const NodePath &other, TextureStage *stage, const LVecBase3 &uvw);
707  INLINE void set_tex_hpr(const NodePath &other, TextureStage *stage, PN_stdfloat h, PN_stdfloat p, PN_stdfloat r);
708  INLINE void set_tex_hpr(const NodePath &other, TextureStage *stage, const LVecBase3 &hpr);
709  INLINE void set_tex_scale(const NodePath &other, TextureStage *stage, PN_stdfloat su, PN_stdfloat sv, PN_stdfloat sw);
710  INLINE void set_tex_scale(const NodePath &other, TextureStage *stage, const LVecBase3 &scale);
711  INLINE LVecBase3 get_tex_pos(const NodePath &other, TextureStage *stage) const;
712  INLINE LVecBase3 get_tex_hpr(const NodePath &other, TextureStage *stage) const;
713  INLINE LVecBase3 get_tex_scale_3d(const NodePath &other, TextureStage *stage) const;
714 
715  void set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode, int priority = 0);
716  void set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode,
717  const LTexCoord3 &constant_value,
718  int priority = 0);
719  void clear_tex_gen();
720  void clear_tex_gen(TextureStage *stage);
721  bool has_tex_gen(TextureStage *stage) const;
722  RenderAttrib::TexGenMode get_tex_gen(TextureStage *stage) const;
723 
724  void set_tex_projector(TextureStage *stage, const NodePath &from, const NodePath &to,
725  int lens_index = 0);
726  void clear_tex_projector(TextureStage *stage);
727  void clear_tex_projector();
728  bool has_tex_projector(TextureStage *stage) const;
729  NodePath get_tex_projector_from(TextureStage *stage) const;
730  NodePath get_tex_projector_to(TextureStage *stage) const;
731 
732  void project_texture(TextureStage *stage, Texture *tex, const NodePath &projector);
733  INLINE void clear_project_texture(TextureStage *stage);
734 
735  INLINE bool has_texcoord(const string &texcoord_name) const;
736  bool has_vertex_column(const InternalName *name) const;
737  InternalNameCollection find_all_vertex_columns() const;
738  InternalNameCollection find_all_vertex_columns(const string &name) const;
739  InternalNameCollection find_all_texcoords() const;
740  InternalNameCollection find_all_texcoords(const string &name) const;
741 
742  Texture *find_texture(const string &name) const;
743  Texture *find_texture(TextureStage *stage) const;
744  TextureCollection find_all_textures() const;
745  TextureCollection find_all_textures(const string &name) const;
746  TextureCollection find_all_textures(TextureStage *stage) const;
747 
748  TextureStage *find_texture_stage(const string &name) const;
749  TextureStageCollection find_all_texture_stages() const;
750  TextureStageCollection find_all_texture_stages(const string &name) const;
751 
752  void unify_texture_stages(TextureStage *stage);
753 
754  Material *find_material(const string &name) const;
755  MaterialCollection find_all_materials() const;
756  MaterialCollection find_all_materials(const string &name) const;
757 
758  void set_material(Material *tex, int priority = 0);
759  void set_material_off(int priority = 0);
760  void clear_material();
761  bool has_material() const;
762  PT(Material) get_material() const;
763 
764  void set_fog(Fog *fog, int priority = 0);
765  void set_fog_off(int priority = 0);
766  void clear_fog();
767  bool has_fog() const;
768  bool has_fog_off() const;
769  Fog *get_fog() const;
770 
771  void set_render_mode_wireframe(int priority = 0);
772  void set_render_mode_filled(int priority = 0);
773  void set_render_mode_filled_wireframe(const LColor &wireframe_color, int priority = 0);
774  void set_render_mode_thickness(PN_stdfloat thickness, int priority = 0);
775  void set_render_mode_perspective(bool perspective, int priority = 0);
776  void set_render_mode(RenderModeAttrib::Mode mode, PN_stdfloat thickness, int priority = 0);
777  void clear_render_mode();
778  bool has_render_mode() const;
779  RenderModeAttrib::Mode get_render_mode() const;
780  PN_stdfloat get_render_mode_thickness() const;
781  bool get_render_mode_perspective() const;
782 
783  void set_two_sided(bool two_sided, int priority = 0);
784  void clear_two_sided();
785  bool has_two_sided() const;
786  bool get_two_sided() const;
787 
788  void set_depth_test(bool depth_test, int priority = 0);
789  void clear_depth_test();
790  bool has_depth_test() const;
791  bool get_depth_test() const;
792 
793  void set_depth_write(bool depth_write, int priority = 0);
794  void clear_depth_write();
795  bool has_depth_write() const;
796  bool get_depth_write() const;
797 
798  void set_depth_offset(int bias, int priority = 0);
799  void clear_depth_offset();
800  bool has_depth_offset() const;
801  int get_depth_offset() const;
802 
803  void do_billboard_axis(const NodePath &camera, PN_stdfloat offset);
804  void do_billboard_point_eye(const NodePath &camera, PN_stdfloat offset);
805  void do_billboard_point_world(const NodePath &camera, PN_stdfloat offset);
806  INLINE void set_billboard_axis(PN_stdfloat offset = 0.0);
807  INLINE void set_billboard_point_eye(PN_stdfloat offset = 0.0);
808  INLINE void set_billboard_point_world(PN_stdfloat offset = 0.0);
809  void set_billboard_axis(const NodePath &camera, PN_stdfloat offset);
810  void set_billboard_point_eye(const NodePath &camera, PN_stdfloat offset);
811  void set_billboard_point_world(const NodePath &camera, PN_stdfloat offset);
812  void clear_billboard();
813  bool has_billboard() const;
814 
815  void set_compass(const NodePath &reference = NodePath());
816  void clear_compass();
817  bool has_compass() const;
818 
819  void set_transparency(TransparencyAttrib::Mode mode, int priority = 0);
820  void clear_transparency();
821  bool has_transparency() const;
822  TransparencyAttrib::Mode get_transparency() const;
823 
824  void set_antialias(unsigned short mode, int priority = 0);
825  void clear_antialias();
826  bool has_antialias() const;
827  unsigned short get_antialias() const;
828 
829  bool has_audio_volume() const;
830  void clear_audio_volume();
831  void set_audio_volume(PN_stdfloat volume,
832  int priority = 0);
833  void set_audio_volume_off(int priority = 0);
834  PN_stdfloat get_audio_volume() const;
835  PN_stdfloat get_net_audio_volume() const;
836 
837  INLINE void adjust_all_priorities(int adjustment);
838 
839  // Variants on show and hide
840  INLINE void show();
841  INLINE void show(DrawMask camera_mask);
842  INLINE void show_through();
843  INLINE void show_through(DrawMask camera_mask);
844  INLINE void hide();
845  INLINE void hide(DrawMask camera_mask);
846  INLINE bool is_hidden(DrawMask camera_mask = PandaNode::get_overall_bit()) const;
847  NodePath get_hidden_ancestor(DrawMask camera_mask = PandaNode::get_overall_bit(),
848  Thread *current_thread = Thread::get_current_thread()) const;
849 
850  void stash(int sort = 0, Thread *current_thread = Thread::get_current_thread());
851  void unstash(int sort = 0, Thread *current_thread = Thread::get_current_thread());
852  void unstash_all(Thread *current_thread = Thread::get_current_thread());
853  INLINE bool is_stashed() const;
854  NodePath get_stashed_ancestor(Thread *current_thread = Thread::get_current_thread()) const;
855 
856  INLINE CollideMask get_collide_mask() const;
857  INLINE void set_collide_mask(CollideMask new_mask, CollideMask bits_to_change = CollideMask::all_on(),
858  TypeHandle node_type = TypeHandle::none());
859 
860  // Comparison methods
861  INLINE bool operator == (const NodePath &other) const;
862  INLINE bool operator != (const NodePath &other) const;
863  INLINE bool operator < (const NodePath &other) const;
864  INLINE int compare_to(const NodePath &other) const;
865 
866  // Miscellaneous
867  bool verify_complete(Thread *current_thread = Thread::get_current_thread()) const;
868 
869  void premunge_scene(GraphicsStateGuardianBase *gsg = NULL);
870  void prepare_scene(GraphicsStateGuardianBase *gsg);
871 
872  void show_bounds();
873  void show_tight_bounds();
874  void hide_bounds();
875  PT(BoundingVolume) get_bounds(Thread *current_thread = Thread::get_current_thread()) const;
876  void force_recompute_bounds();
877  void write_bounds(ostream &out) const;
878  bool calc_tight_bounds(LPoint3 &min_point, LPoint3 &max_point,
879  Thread *current_thread = Thread::get_current_thread()) const;
880 
881  EXTENSION(PyObject *get_tight_bounds() const);
882 
883  // void analyze() const;
884 
885  int flatten_light();
886  int flatten_medium();
887  int flatten_strong();
888  void apply_texture_colors();
889  INLINE int clear_model_nodes();
890 
891  INLINE void set_tag(const string &key, const string &value);
892  INLINE string get_tag(const string &key) const;
893  INLINE void get_tag_keys(vector_string &keys) const;
894  INLINE bool has_tag(const string &key) const;
895  INLINE void clear_tag(const string &key);
896  INLINE string get_net_tag(const string &key) const;
897  INLINE bool has_net_tag(const string &key) const;
898  NodePath find_net_tag(const string &key) const;
899 
900  EXTENSION(INLINE PyObject *get_tag_keys() const);
901  EXTENSION(INLINE void set_python_tag(const string &key, PyObject *value));
902  EXTENSION(INLINE PyObject *get_python_tag(const string &key) const);
903  EXTENSION(INLINE void get_python_tag_keys(vector_string &keys) const);
904  EXTENSION(INLINE PyObject *get_python_tag_keys() const);
905  EXTENSION(INLINE bool has_python_tag(const string &key) const);
906  EXTENSION(INLINE void clear_python_tag(const string &key));
907  EXTENSION(INLINE PyObject *get_net_python_tag(const string &key) const);
908  EXTENSION(INLINE bool has_net_python_tag(const string &key) const);
909  EXTENSION(NodePath find_net_python_tag(const string &key) const);
910 
911  INLINE void list_tags() const;
912 
913  INLINE void set_name(const string &name);
914  INLINE string get_name() const;
915 
916  BLOCKING bool write_bam_file(const Filename &filename) const;
917  BLOCKING bool write_bam_stream(ostream &out) const;
918 
919  INLINE string encode_to_bam_stream() const;
920  bool encode_to_bam_stream(string &data, BamWriter *writer = NULL) const;
921  static NodePath decode_from_bam_stream(const string &data, BamReader *reader = NULL);
922 
923 private:
924  static NodePathComponent *
925  find_common_ancestor(const NodePath &a, const NodePath &b,
926  int &a_count, int &b_count,
927  Thread *current_thread);
928 
929  CPT(RenderState) r_get_net_state(NodePathComponent *comp,
930  Thread *current_thread) const;
931  CPT(RenderState) r_get_partial_state(NodePathComponent *comp, int n,
932  Thread *current_thread) const;
933  CPT(TransformState) r_get_net_transform(NodePathComponent *comp,
934  Thread *current_thread) const;
935  CPT(TransformState) r_get_partial_transform(NodePathComponent *comp, int n,
936  Thread *current_thread) const;
937  CPT(TransformState) r_get_net_prev_transform(NodePathComponent *comp,
938  Thread *current_thread) const;
939  CPT(TransformState) r_get_partial_prev_transform(NodePathComponent *comp,
940  int n, Thread *current_thread) const;
941 
942  void find_matches(NodePathCollection &result,
943  const string &approx_path_str,
944  int max_matches) const;
945  void find_matches(NodePathCollection &result,
946  FindApproxPath &approx_path,
947  int max_matches) const;
948  void find_matches(NodePathCollection &result,
949  FindApproxLevelEntry *level,
950  int max_matches) const;
951 
952  int r_clear_model_nodes(PandaNode *node);
953  void r_adjust_all_priorities(PandaNode *node, int adjustment);
954 
955  void r_force_recompute_bounds(PandaNode *node);
956 
957  void r_set_collide_mask(PandaNode *node,
958  CollideMask and_mask, CollideMask or_mask,
959  TypeHandle node_type);
960 
961  typedef phash_set<const InternalName *, pointer_hash> InternalNames;
962  bool r_has_vertex_column(PandaNode *node, const InternalName *name) const;
963  void r_find_all_vertex_columns(PandaNode *node,
964  InternalNames &vertex_columns) const;
965 
966  typedef phash_set<Texture *, pointer_hash> Textures;
967  Texture *r_find_texture(PandaNode *node, const RenderState *state,
968  const GlobPattern &glob) const;
969  void r_find_all_textures(PandaNode *node, const RenderState *state,
970  Textures &textures) const;
971  Texture *r_find_texture(PandaNode *node, TextureStage *stage) const;
972  void r_find_all_textures(PandaNode *node, TextureStage *stage,
973  Textures &textures) const;
974 
975  typedef phash_set<TextureStage *, pointer_hash> TextureStages;
976  TextureStage *r_find_texture_stage(PandaNode *node, const RenderState *state,
977  const GlobPattern &glob) const;
978  void r_find_all_texture_stages(PandaNode *node, const RenderState *state,
979  TextureStages &texture_stages) const;
980 
981  void r_unify_texture_stages(PandaNode *node, TextureStage *stage);
982 
983  typedef phash_set<Material *, pointer_hash> Materials;
984  Material *r_find_material(PandaNode *node, const RenderState *state,
985  const GlobPattern &glob) const;
986  void r_find_all_materials(PandaNode *node, const RenderState *state,
987  Materials &materials) const;
988 
989  PT(NodePathComponent) _head;
990  int _backup_key;
991  ErrorType _error_type;
992  static int _max_search_depth;
993 
994  static PStatCollector _get_transform_pcollector;
995  static PStatCollector _verify_complete_pcollector;
996 
997 public:
998  static TypeHandle get_class_type() {
999  return _type_handle;
1000  }
1001  static void init_type() {
1002  register_type(_type_handle, "NodePath");
1003  }
1004 
1005 private:
1006  static TypeHandle _type_handle;
1007 
1008  friend class NodePathCollection;
1009  friend class WorkingNodePath;
1010  friend class WeakNodePath;
1011 };
1012 
1013 INLINE ostream &operator << (ostream &out, const NodePath &node_path);
1014 
1015 #include "nodePath.I"
1016 
1017 #endif
A basic node of the scene graph or data graph.
Definition: pandaNode.h:72
The abstract interface to all kinds of lights.
Definition: light.h:42
This is the base class for all three-component vectors and points.
Definition: lvecBase3.h:105
This is a const pointer to an InternalName, and should be used in lieu of a CPT(InternalName) in func...
Definition: internalName.h:197
This is the base class for a number of render attributes (other than transform) that may be set on sc...
Definition: renderAttrib.h:60
static TypeHandle none()
Returns a special zero-valued TypeHandle that is used to indicate no type.
Definition: typeHandle.I:274
This is the fundamental interface for extracting binary objects from a Bam file, as generated by a Ba...
Definition: bamReader.h:122
This class is local to this package only; it doesn&#39;t get exported.
static BitMask< PN_uint32, nbits > all_on()
Returns a BitMask whose bits are all on.
Definition: bitMask.I:73
Represents a texture object, which is typically a single 2-d image but may also represent a 1-d or 3-...
Definition: texture.h:75
This class is local to this package only; it doesn&#39;t get exported.
Definition: shader.h:50
This is the base class for all two-component vectors and points.
Definition: lvecBase2.h:2360
This is a three-component vector distance (as opposed to a three-component point, which represents a ...
Definition: lvector3.h:100
This is a three-component point in space (as opposed to a three-component vector, which represents a ...
Definition: lpoint3.h:99
This is the fundamental interface for writing binary objects to a Bam file, to be extracted later by ...
Definition: bamWriter.h:73
This is a small container class that can hold any one of the value types that can be passed as input ...
Definition: shaderInput.h:41
This is the base class for a number of special render effects that may be set on scene graph nodes to...
Definition: renderEffect.h:56
A table of objects that are saved within the graphics context for reference by handle later...
This is a class designed to support low-overhead traversals of the complete scene graph...
This is the base class for all three-component vectors and points.
Definition: lvecBase4.h:3194
static Thread * get_current_thread()
Returns a pointer to the currently-executing Thread object.
Definition: thread.I:145
This is an abstract class for any volume in any sense which can be said to define the locality of ref...
A lightweight class that represents a single element that may be timed and/or counted via stats...
The name of a file, such as a texture file or an Egg file.
Definition: filename.h:44
This is a 4-by-4 transform matrix.
Definition: lmatrix.h:451
Specifies how atmospheric fog effects are applied to geometry.
Definition: fog.h:46
A PolylightNode.
Definition: polylightNode.h:31
This is the base class for all two-component vectors and points.
Definition: lvecBase2.h:105
Manages a list of Texture objects, as returned by TexturePool::find_all_textures().
This class is a wrapper around a NodePath that, unlike the actual NodePath class, doesn&#39;t hold a refe...
Definition: weakNodePath.h:37
Defines the way an object appears in the presence of lighting.
Definition: material.h:34
This represents a unique collection of RenderAttrib objects that correspond to a particular renderabl...
Definition: renderState.h:53
Represents a set of settings that indicate how a texture is sampled.
Definition: samplerState.h:39
This is the base class for all three-component vectors and points.
Definition: lvecBase4.h:111
This is the base class for all three-component vectors and points.
Definition: lvecBase3.h:2788
An STL function object class, this is intended to be used on any ordered collection of class objects ...
Definition: stl_compares.h:79
This is a base class for the GraphicsStateGuardian class, which is itself a base class for the variou...
This is the base quaternion class.
Definition: lquaternion.h:96
A thread; that is, a lightweight process.
Definition: thread.h:51
TypeHandle is the identifier used to differentiate C++ class types.
Definition: typeHandle.h:85
This is a 3-by-3 transform matrix.
Definition: lmatrix.h:110
Defines the properties of a named stage of the multitexture pipeline.
Definition: textureStage.h:38
NodePath is the fundamental system for disambiguating instances, and also provides a higher-level int...
Definition: nodePath.h:165
static LVector3f up(CoordinateSystem cs=CS_default)
Returns the up vector for the given coordinate system.
Definition: lvector3.h:541
This represents a unique collection of RenderEffect objects that correspond to a particular renderabl...
Definition: renderEffects.h:46
This class can be used to test for string matches against standard Unix-shell filename globbing conve...
Definition: globPattern.h:37
This is one component of a NodePath.
This is a set of zero or more NodePaths.