43 PGItem *PGItem::_focus_item =
nullptr;
51 is_right(
const LVector2 &v1,
const LVector2 &v2) {
52 return (v1[0] * v2[1] - v1[1] * v2[0]) > 0;
59 PGItem(
const string &name) :
77 if (_notify !=
nullptr) {
78 _notify->remove_item(
this);
82 nassertv(_region->_item ==
this);
83 _region->_item =
nullptr;
86 if (_focus_item ==
this) {
87 _focus_item =
nullptr;
95 PGItem(
const PGItem ©) :
98 _has_frame(copy._has_frame),
104 , _sounds(copy._sounds)
110 _region->set_name(copy._region->get_name());
113 size_t num_state_defs = copy._state_defs.size();
114 _state_defs.reserve(num_state_defs);
115 for (
size_t i = 0; i < num_state_defs; ++i) {
119 StateDef &old_sd = (StateDef &)(copy._state_defs[i]);
120 old_sd._frame.remove_node();
121 old_sd._frame_stale =
true;
124 new_sd._root = old_sd._root.copy_to(
NodePath());
125 new_sd._frame_style = old_sd._frame_style;
127 _state_defs.push_back(new_sd);
129 #ifdef THREADED_PIPELINE
131 ((
PGItem &)copy).update_frame((
int)i);
132 update_frame((
int)i);
155 transform_changed() {
157 PandaNode::transform_changed();
158 if (_notify !=
nullptr) {
159 _notify->item_transform_changed(
this);
169 draw_mask_changed() {
171 PandaNode::draw_mask_changed();
172 if (_notify !=
nullptr) {
173 _notify->item_draw_mask_changed(
this);
203 has_frame = _has_frame && ((_flags & F_active) != 0);
207 if (state >= 0 && (
size_t)state < _state_defs.size()) {
208 StateDef &state_def = _state_defs[state];
209 if (!state_def._root.is_empty()) {
211 if (state_def._frame_stale) {
216 state_def_root = state_def._root.node();
227 if (trav->
is_exact_type(PGCullTraverser::get_class_type())) {
229 DCAST_INTO_R(pg_trav, trav,
true);
231 const LMatrix4 &transform = data.get_net_transform(trav)->get_mat();
236 int bin_index = data._state->get_bin_index();
240 CullBinManager::BinType bin_type = bin_manager->
get_bin_type(bin_index);
241 if (bin_type == CullBinManager::BT_fixed) {
244 sort = data._state->get_draw_order();
246 }
else if (bin_type == CullBinManager::BT_unsorted) {
249 sort = pg_trav->_sort_index;
250 pg_trav->_sort_index++;
259 int bin_sort = bin_manager->
get_bin_sort(data._state->get_bin_index());
266 sort = (bin_sort << 16) | ((sort + 0x8000) & 0xffff);
270 data._state->get_attrib(clip);
271 data._state->get_attrib(scissor);
272 if (activate_region(transform, sort, clip, scissor)) {
278 if (state_def_root !=
nullptr) {
296 is_renderable()
const {
307 int &internal_vertices,
309 Thread *current_thread)
const {
311 int num_vertices = 0;
317 if (btype == BoundingVolume::BT_default) {
321 if (btype == BoundingVolume::BT_sphere) {
334 for (
int i = 0; i < (int)_state_defs.size(); i++) {
338 child_volumes.push_back(node->get_bounds(current_thread));
339 num_vertices += node->get_nested_vertices(current_thread);
344 const BoundingVolume **child_end = child_begin + child_volumes.size();
346 bound->around(child_begin, child_end);
348 internal_bounds = bound;
349 internal_vertices = num_vertices;
360 for (StateDef &def : _state_defs) {
364 CPT(
RenderState) child_state = node_state->compose(child->get_state());
377 xform(
const LMatrix4 &mat) {
380 LPoint3 ll(_frame[0], 0.0f, _frame[2]);
381 LPoint3 ur(_frame[1], 0.0f, _frame[3]);
384 _frame.set(ll[0], ur[0], ll[2], ur[2]);
387 for (
size_t state = 0; state < _state_defs.size(); ++state) {
388 StateDef &def = _state_defs[state];
398 if (def._frame_style.xform(mat)) {
399 #ifdef THREADED_PIPELINE
401 update_frame((
int)state);
406 def._frame_stale =
true;
410 mark_internal_bounds_stale();
421 activate_region(
const LMatrix4 &transform,
int sort,
430 LPoint3 ll = LPoint3::rfu(_frame[0], 0.0f, _frame[2]) * transform;
431 LPoint3 lr = LPoint3::rfu(_frame[1], 0.0f, _frame[2]) * transform;
432 LPoint3 ul = LPoint3::rfu(_frame[0], 0.0f, _frame[3]) * transform;
433 LPoint3 ur = LPoint3::rfu(_frame[1], 0.0f, _frame[3]) * transform;
434 LVector3 up = LVector3::up();
445 LVector3 right = LVector3::right();
464 points.push_back(LPoint2(ll[right_axis], ll[up_axis]));
465 points.push_back(LPoint2(lr[right_axis], lr[up_axis]));
466 points.push_back(LPoint2(ur[right_axis], ur[up_axis]));
467 points.push_back(LPoint2(ul[right_axis], ul[up_axis]));
470 for (
int i = 0; i < num_on_planes; ++i) {
472 LPlane plane = DCAST(
PlaneNode, plane_path.
node())->get_plane();
473 plane.xform(plane_path.get_net_transform()->
get_mat());
478 clip_frame(points, plane);
481 if (points.empty()) {
486 ClipPoints::iterator pi;
488 frame.set((*pi)[0], (*pi)[0], (*pi)[1], (*pi)[1]);
490 while (pi != points.end()) {
491 frame[0] = min(frame[0], (*pi)[0]);
492 frame[1] = max(frame[1], (*pi)[0]);
493 frame[2] = min(frame[2], (*pi)[1]);
494 frame[3] = max(frame[3], (*pi)[1]);
499 frame.set(min(min(ll[right_axis], lr[right_axis]), min(ul[right_axis], ur[right_axis])),
500 max(max(ll[right_axis], lr[right_axis]), max(ul[right_axis], ur[right_axis])),
501 min(min(ll[up_axis], lr[up_axis]), min(ul[up_axis], ur[up_axis])),
502 max(max(ll[up_axis], lr[up_axis]), max(ul[up_axis], ur[up_axis])));
509 frame.set(max(frame[0], sf[0] * 2.0f - 1.0f),
510 min(frame[1], sf[1] * 2.0f - 1.0f),
511 max(frame[2], sf[2] * 2.0f - 1.0f),
512 min(frame[3], sf[3] * 2.0f - 1.0f));
513 if (frame[1] <= frame[0] || frame[3] <= frame[2]) {
519 _region->set_frame(frame);
521 _region->set_sort(sort);
522 _region->set_active(
true);
526 _frame_inv_xform.invert_from(transform);
540 if (pgui_cat.is_debug()) {
542 << *
this <<
"::enter_region(" << param <<
")\n";
550 if (_notify !=
nullptr) {
551 _notify->item_enter(
this, param);
564 if (pgui_cat.is_debug()) {
566 << *
this <<
"::exit_region(" << param <<
")\n";
574 if (_notify !=
nullptr) {
575 _notify->item_exit(
this, param);
590 if (pgui_cat.is_debug()) {
592 << *
this <<
"::within_region(" << param <<
")\n";
600 if (_notify !=
nullptr) {
601 _notify->item_within(
this, param);
612 if (pgui_cat.is_debug()) {
614 << *
this <<
"::without_region(" << param <<
")\n";
622 if (_notify !=
nullptr) {
623 _notify->item_without(
this, param);
634 if (pgui_cat.is_debug()) {
636 << *
this <<
"::focus_in()\n";
643 if (_notify !=
nullptr) {
644 _notify->item_focus_in(
this);
655 if (pgui_cat.is_debug()) {
657 << *
this <<
"::focus_out()\n";
664 if (_notify !=
nullptr) {
665 _notify->item_focus_out(
this);
676 if (pgui_cat.is_debug()) {
678 << *
this <<
"::press(" << param <<
", " << background <<
")\n";
693 if (_notify !=
nullptr) {
694 _notify->item_press(
this, param);
705 if (pgui_cat.is_debug()) {
707 << *
this <<
"::release(" << param <<
", " << background <<
")\n";
717 if (_notify !=
nullptr) {
718 _notify->item_release(
this, param);
728 if (pgui_cat.is_debug()) {
730 << *
this <<
"::keystroke(" << param <<
", " << background <<
")\n";
752 if (pgui_cat.is_debug()) {
754 << *
this <<
"::candidate(" << param <<
", " << background <<
")\n";
772 if (pgui_cat.is_debug()) {
774 << *
this <<
"::move(" << param <<
")\n";
777 if (_notify !=
nullptr) {
778 _notify->item_move(
this, param);
787 for (
PGItem *item : _background_focus) {
788 if (!item->get_focus()) {
789 item->press(param,
true);
799 for (
PGItem *item : _background_focus) {
800 if (!item->get_focus()) {
801 item->release(param,
true);
811 for (
PGItem *item : _background_focus) {
812 if (!item->get_focus()) {
813 item->keystroke(param,
true);
823 for (
PGItem *item : _background_focus) {
824 if (!item->get_focus()) {
825 item->candidate(param,
true);
869 if (_focus_item !=
this) {
870 if (_focus_item !=
nullptr) {
882 if (_focus_item ==
this) {
884 _focus_item =
nullptr;
892 _region->set_keyboard(focus);
907 _flags |= F_background_focus;
908 bool inserted = _background_focus.insert(
this).second;
913 _flags &= ~F_background_focus;
914 size_t num_erased = _background_focus.erase(
this);
915 nassertv(num_erased == 1);
931 return _state_defs.size();
942 if (state < 0 || state >= (
int)_state_defs.size()) {
945 return (!_state_defs[state]._root.is_empty());
955 if (state < 0 || state >= (
int)_state_defs.size()) {
959 _state_defs[state]._root =
NodePath();
960 _state_defs[state]._frame =
NodePath();
961 _state_defs[state]._frame_stale =
true;
963 mark_internal_bounds_stale();
965 #ifdef THREADED_PIPELINE
984 mark_internal_bounds_stale();
996 if (state < 0 || state >= (
int)_state_defs.size()) {
999 return _state_defs[state]._frame_style;
1011 NodePath &root = do_get_state_def(state);
1014 _state_defs[state]._frame_style = style;
1015 _state_defs[state]._frame_stale =
true;
1017 mark_internal_bounds_stale();
1019 #ifdef THREADED_PIPELINE
1021 update_frame(state);
1031 set_sound(
const string &event,
AudioSound *sound) {
1033 _sounds[event] = sound;
1040 clear_sound(
const string &event) {
1042 _sounds.erase(event);
1050 get_sound(
const string &event)
const {
1052 Sounds::const_iterator si = _sounds.find(event);
1053 if (si != _sounds.end()) {
1054 return (*si).second;
1064 has_sound(
const string &event)
const {
1066 return (_sounds.count(event) != 0);
1077 if (_text_node ==
nullptr) {
1078 _text_node =
new TextNode(
"pguiText");
1079 _text_node->set_text_color(0.0f, 0.0f, 0.0f, 1.0f);
1083 _text_node->set_align(TextNode::A_left);
1092 play_sound(
const string &event) {
1095 Sounds::const_iterator si = _sounds.find(event);
1096 if (si != _sounds.end()) {
1115 reduce_region(LVecBase4 &frame,
PGItem *obscurer)
const {
1120 LVecBase4 oframe = get_relative_frame(obscurer);
1124 LVecBase4 right(max(frame[0], oframe[1]), frame[1], frame[2], frame[3]);
1125 LVecBase4 left(frame[0], min(frame[1], oframe[0]), frame[2], frame[3]);
1126 LVecBase4 above(frame[0], frame[1], max(frame[2], oframe[3]), frame[3]);
1127 LVecBase4 below(frame[0], frame[1], frame[2], min(frame[3], oframe[2]));
1130 const LVecBase4 *largest = &right;
1131 PN_stdfloat largest_area = compute_area(*largest);
1132 compare_largest(largest, largest_area, &left);
1133 compare_largest(largest, largest_area, &above);
1134 compare_largest(largest, largest_area, &below);
1145 get_relative_frame(
PGItem *item)
const {
1154 const LVecBase4 &orig_frame = item->
get_frame();
1155 LMatrix4 transform = item_np.
get_mat(this_np);
1160 LPoint3 ll(orig_frame[0], 0.0f, orig_frame[2]);
1161 LPoint3 lr(orig_frame[1], 0.0f, orig_frame[2]);
1162 LPoint3 ul(orig_frame[0], 0.0f, orig_frame[3]);
1163 LPoint3 ur(orig_frame[1], 0.0f, orig_frame[3]);
1164 ll = ll * transform;
1165 lr = lr * transform;
1166 ul = ul * transform;
1167 ur = ur * transform;
1169 return LVecBase4(min(min(ll[0], lr[0]), min(ul[0], ur[0])),
1170 max(max(ll[0], lr[0]), max(ul[0], ur[0])),
1171 min(min(ll[2], lr[2]), min(ul[2], ur[2])),
1172 max(max(ll[2], lr[2]), max(ul[2], ur[2])));
1180 mouse_to_local(
const LPoint2 &mouse_point)
const {
1185 return inv_transform->
get_mat().xform_point(LVector3::rfu(mouse_point[0], 0, mouse_point[1]));
1193 mark_frames_stale();
1194 if (_notify !=
nullptr) {
1195 _notify->item_frame_changed(
this);
1207 do_get_state_def(
int state) {
1208 slot_state_def(state);
1210 if (_state_defs[state]._root.is_empty()) {
1212 _state_defs[state]._root =
NodePath(
"state_" + format_string(state));
1213 _state_defs[state]._frame_stale =
true;
1216 if (_state_defs[state]._frame_stale) {
1217 update_frame(state);
1220 return _state_defs[state]._root;
1228 slot_state_def(
int state) {
1229 while (state >= (
int)_state_defs.size()) {
1230 _state_defs.push_back(StateDef());
1239 update_frame(
int state) {
1241 if (state >= 0 && state < (
int)_state_defs.size()) {
1242 _state_defs[state]._frame.remove_node();
1247 _state_defs[state]._frame_stale =
false;
1251 NodePath &root = do_get_state_def(state);
1252 _state_defs[state]._frame =
1253 _state_defs[state]._frame_style.generate_into(root, _frame);
1262 mark_frames_stale() {
1263 #ifdef THREADED_PIPELINE
1267 for (
int state = 0; state < (int)_state_defs.size(); ++state) {
1268 update_frame(state);
1274 for (StateDef &def : _state_defs) {
1276 def._frame.remove_node();
1277 def._frame_stale =
true;
1280 mark_internal_bounds_stale();
1291 clip_frame(ClipPoints &source_points,
const LPlane &plane)
const {
1292 if (source_points.empty()) {
1298 if (!plane.intersects_plane(from3d, delta3d, LPlane(LVector3(0, 1, 0), LPoint3::zero()))) {
1301 if (plane.dist_to_plane(LPoint3::zero()) < 0.0) {
1311 LPoint2 from2d(from3d[0], from3d[2]);
1312 LVector2 delta2d(delta3d[0], delta3d[2]);
1314 PN_stdfloat a = -delta2d[1];
1315 PN_stdfloat b = delta2d[0];
1316 PN_stdfloat c = from2d[0] * delta2d[1] - from2d[1] * delta2d[0];
1324 ClipPoints new_points;
1325 new_points.reserve(source_points.size() + 1);
1327 LPoint2 last_point(source_points.back());
1328 bool last_is_in =
is_right(last_point - from2d, delta2d);
1329 bool all_in = last_is_in;
1331 for (LPoint2 this_point : source_points) {
1332 bool this_is_in =
is_right(this_point - from2d, delta2d);
1336 bool crossed_over = (this_is_in != last_is_in);
1340 LVector2 d = this_point - last_point;
1341 PN_stdfloat denom = (a * d[0] + b * d[1]);
1343 PN_stdfloat t = -(a * last_point[0] + b * last_point[1] + c) / denom;
1344 LPoint2 p = last_point + t * d;
1346 new_points.push_back(p);
1347 last_is_in = this_is_in;
1353 new_points.push_back(this_point);
1358 last_point = this_point;
1361 source_points.swap(new_points);
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
An axis-aligned bounding box; that is, a minimum and maximum coordinate triple.
This defines a bounding sphere, consisting of a center and a radius.
This is an abstract class for any volume in any sense which can be said to define the locality of ref...
This functions similarly to a LightAttrib.
get_on_plane
Returns the nth plane enabled by the attribute, sorted in render order.
get_num_on_planes
Returns the number of planes that are enabled by the attribute.
This is a global object that maintains the collection of named CullBins in the world.
BinType get_bin_type(int bin_index) const
Returns the type of the bin with the indicated bin_index (where bin_index was retrieved by get_bin() ...
static CullBinManager * get_global_ptr()
Returns the pointer to the global CullBinManager object.
int get_bin_sort(int bin_index) const
Returns the sort order of the bin with the indicated bin_index (where bin_index was retrieved by get_...
This collects together the pieces of data that are accumulated for each node while walking the scene ...
This object performs a depth-first traversal of the scene graph, with optional view-frustum culling,...
const DrawMask & get_camera_mask() const
Returns the visibility mask from the camera viewing the scene.
void traverse(const NodePath &root)
Begins the traversal from the indicated node.
An optional parameter associated with an event.
This is a base class for the GraphicsStateGuardian class, which is itself a base class for the variou...
Similar to MutexHolder, but for a light reentrant mutex.
This is sent along as a parameter to most events generated for a region to indicate the mouse and but...
ButtonHandle get_button() const
Returns the mouse or keyboard button associated with this event.
bool is_keyrepeat() const
Returns true if the button-down even was generated due to keyrepeat, or false if it was an original b...
NodePath is the fundamental system for disambiguating instances, and also provides a higher-level int...
static NodePath any_path(PandaNode *node, Thread *current_thread=Thread::get_current_thread())
Returns a new NodePath that represents any arbitrary path from the root to the indicated node.
NodePath find_path_to(PandaNode *node) const
Searches for the indicated node below this node and returns the shortest NodePath that connects them.
bool is_empty() const
Returns true if the NodePath contains no nodes.
const LMatrix4 & get_mat() const
Returns the transform matrix that has been applied to the referenced node, or the identity matrix if ...
PandaNode * node() const
Returns the referenced node of the path.
const TransformState * get_transform(Thread *current_thread=Thread::get_current_thread()) const
Returns the complete transform object set on this node.
NodePath instance_to(const NodePath &other, int sort=0, Thread *current_thread=Thread::get_current_thread()) const
Adds the referenced node of the NodePath as a child of the referenced node of the indicated other Nod...
void set_transform(const TransformState *transform, Thread *current_thread=Thread::get_current_thread())
Changes the complete transform object on this node.
This is a specialization of CullTraverser for use within the pgui system.
This is the base class for all the various kinds of gui widget objects.
static void background_release(const MouseWatcherParameter ¶m)
Calls release() on all the PGItems with background focus.
const LVecBase4 & get_frame() const
Returns the bounding rectangle of the item.
virtual void press(const MouseWatcherParameter ¶m, bool background)
This is a callback hook function, called whenever a mouse or keyboard button is depressed while the m...
bool get_active() const
Returns whether the PGItem is currently active for mouse events.
void set_frame_style(int state, const PGFrameStyle &style)
Changes the kind of frame that will be drawn behind the item when it is in the indicated state.
static void background_candidate(const MouseWatcherParameter ¶m)
Calls candidate() on all the PGItems with background focus.
std::string get_keystroke_event() const
Returns the event name that will be thrown when the item is active and any key is pressed by the user...
std::string get_without_event() const
Returns the event name that will be thrown when the item is active and the mouse moves completely out...
std::string get_focus_out_event() const
Returns the event name that will be thrown when the item loses the keyboard focus.
PGItemNotify * get_notify() const
Returns the object which will be notified when the PGItem changes, if any.
void clear_state_def(int state)
Resets the NodePath assigned to the indicated state to its initial default, with only a frame represe...
std::string get_exit_event() const
Returns the event name that will be thrown when the item is active and the mouse exits its frame,...
static TextNode * get_text_node()
Returns the TextNode object that will be used by all PGItems to generate default labels given a strin...
bool has_state_def(int state) const
Returns true if get_state_def() has ever been called for the indicated state (thus defining a render ...
bool get_focus() const
Returns whether the PGItem currently has focus for keyboard events.
bool get_background_focus() const
Returns whether background_focus is currently enabled.
get_num_state_defs
Returns one more than the highest-numbered state def that was ever assigned to the PGItem.
virtual void release(const MouseWatcherParameter ¶m, bool background)
This is a callback hook function, called whenever a mouse or keyboard button previously depressed wit...
PGFrameStyle get_frame_style(int state)
Returns the kind of frame that will be drawn behind the item when it is in the indicated state.
NodePath instance_to_state_def(int state, const NodePath &path)
Parents an instance of the bottom node of the indicated NodePath to the indicated state index.
void set_background_focus(bool focus)
Sets the background_focus flag for this item.
virtual void without_region(const MouseWatcherParameter ¶m)
This is a callback hook function, called whenever the mouse moves completely outside the boundaries o...
std::string get_press_event(const ButtonHandle &button) const
Returns the event name that will be thrown when the item is active and the indicated mouse or keyboar...
std::string get_within_event() const
Returns the event name that will be thrown when the item is active and the mouse moves within the bou...
virtual void keystroke(const MouseWatcherParameter ¶m, bool background)
This is a callback hook function, called whenever the user presses a key.
virtual void exit_region(const MouseWatcherParameter ¶m)
This is a callback hook function, called whenever the mouse exits the region.
static void background_press(const MouseWatcherParameter ¶m)
Calls press() on all the PGItems with background focus.
virtual void set_focus(bool focus)
Sets whether the PGItem currently has keyboard focus.
std::string get_repeat_event(const ButtonHandle &button) const
Returns the event name that will be thrown when the item is active and the indicated mouse or keyboar...
virtual void focus_in()
This is a callback hook function, called whenever the widget gets the keyboard focus.
bool has_notify() const
Returns true if there is an object configured to be notified when the PGItem changes,...
virtual void focus_out()
This is a callback hook function, called whenever the widget loses the keyboard focus.
virtual void move(const MouseWatcherParameter ¶m)
This is a callback hook function, called whenever a mouse is moved while within the region.
bool has_frame() const
Returns true if the item has a bounding rectangle; see set_frame().
virtual void within_region(const MouseWatcherParameter ¶m)
This is a callback hook function, called whenever the mouse moves within the boundaries of the region...
std::string get_release_event(const ButtonHandle &button) const
Returns the event name that will be thrown when the item is active and the indicated mouse or keyboar...
virtual void candidate(const MouseWatcherParameter ¶m, bool background)
This is a callback hook function, called whenever the user highlights an option in the IME window.
static void background_keystroke(const MouseWatcherParameter ¶m)
Calls keystroke() on all the PGItems with background focus.
std::string get_enter_event() const
Returns the event name that will be thrown when the item is active and the mouse enters its frame,...
std::string get_focus_in_event() const
Returns the event name that will be thrown when the item gets the keyboard focus.
virtual void enter_region(const MouseWatcherParameter ¶m)
This is a callback hook function, called whenever the mouse enters the region.
virtual void set_active(bool active)
Sets whether the PGItem is active for mouse watching.
This specialization on MouseWatcherParameter allows us to tag on additional elements to events for th...
This is a specialization on MouseWatcherRegion, to add a bit more fields that are relevant to the PG ...
void add_region(MouseWatcherRegion *region)
Adds the indicated region to the set of regions in the group.
A basic node of the scene graph or data graph.
is_overall_hidden
Returns true if the node has been hidden to all cameras by clearing its overall bit.
virtual void r_prepare_scene(GraphicsStateGuardianBase *gsg, const RenderState *node_state, GeomTransformer &transformer, Thread *current_thread)
The recursive implementation of prepare_scene().
get_bounds_type
Returns the bounding volume type set with set_bounds_type().
int get_num_stages() const
Returns the number of stages required for the pipeline.
static Pipeline * get_render_pipeline()
Returns a pointer to the global render pipeline.
A node that contains a plane.
This represents a unique collection of RenderAttrib objects that correspond to a particular renderabl...
An interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing...
void apply_attribs(PandaNode *node, int attrib_types=~(TT_clip_plane|TT_cull_face|TT_apply_texture_color))
Walks the scene graph, accumulating attribs of the indicated types, applying them to the vertices,...
This restricts rendering to within a rectangular region of the scene, without otherwise affecting the...
get_frame
Returns the left, right, bottom, top coordinates of the scissor frame.
The primary interface to this module.
A thread; that is, a lightweight process.
get_current_pipeline_stage
Returns the integer pipeline stage associated with the current thread.
TypeHandle is the identifier used to differentiate C++ class types.
bool is_exact_type(TypeHandle handle) const
Returns true if the current object is the indicated type exactly.
This is our own Panda specialization on the default STL vector.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
bool is_right(const LVector2 &v1, const LVector2 &v2)
Returns true if the 2-d v1 is to the right of v2.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.