TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-04 02:42:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix billboards, lod's, etc.

Browse Source
This commit is contained in:
David Rose 2005-05-27 22:03:23 +00:00
parent 0d5cfa8e1b
commit aa29e67c84
24 changed files with 109 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
panda/src/collide/collisionNode.cxx
View File

@ -224,7 +224,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
Solids::iterator si;
for (si = _solids.begin(); si != _solids.end(); ++si) {
CollisionSolid *solid = (*si);
PT(PandaNode) node = solid->get_viz(data, false);
PT(PandaNode) node = solid->get_viz(trav, data, false);
if (node != (PandaNode *)NULL) {
CullTraverserData next_data(data, node);
@ -246,12 +246,12 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
for (si = _solids.begin(); si != _solids.end(); ++si) {
CollisionSolid *solid = (*si);
PT(PandaNode) node = solid->get_viz(data, false);
PT(PandaNode) node = solid->get_viz(trav, data, false);
if (node != (PandaNode *)NULL) {
CullTraverserData next_data(data, node);
next_data._net_transform =
next_data._net_transform->compose(transform);
next_data._modelview_transform =
next_data._modelview_transform->compose(transform);
next_data._state = get_last_pos_state();
trav->traverse(next_data);
}

17
panda/src/collide/collisionPolygon.cxx
View File

@ -278,13 +278,14 @@ get_collision_origin() const {
// made visible.
////////////////////////////////////////////////////////////////////
PT(PandaNode) CollisionPolygon::
get_viz(const CullTraverserData &data, bool bounds_only) const {
get_viz(const CullTraverser *trav, const CullTraverserData &data,
bool bounds_only) const {
const RenderAttrib *cpa_attrib =
data._state->get_attrib(ClipPlaneAttrib::get_class_type());
if (cpa_attrib == (const RenderAttrib *)NULL) {
// Fortunately, the polygon is not clipped. This is the normal,
// easy case.
return CollisionSolid::get_viz(data, bounds_only);
return CollisionSolid::get_viz(trav, data, bounds_only);
}
if (collide_cat.is_debug()) {
@ -300,10 +301,10 @@ get_viz(const CullTraverserData &data, bool bounds_only) const {
// work.
const ClipPlaneAttrib *cpa = DCAST(ClipPlaneAttrib, cpa_attrib);
Points new_points;
if (apply_clip_plane(new_points, cpa, data._net_transform)) {
if (apply_clip_plane(new_points, cpa, data.get_net_transform(trav))) {
// All points are behind the clip plane; just draw the original
// polygon.
return CollisionSolid::get_viz(data, bounds_only);
return CollisionSolid::get_viz(trav, data, bounds_only);
}
if (new_points.empty()) {
@ -845,11 +846,11 @@ draw_polygon(GeomNode *viz_geom_node, GeomNode *bounds_viz_geom_node,
geom2->set_vertex_data(vdata);
geom2->add_primitive(border);
_viz_geom->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_viz_state());
_viz_geom->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_viz_state());
viz_geom_node->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_viz_state());
viz_geom_node->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_viz_state());
_bounds_viz_geom->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_bounds_viz_state());
_bounds_viz_geom->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_bounds_viz_state());
bounds_viz_geom_node->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_bounds_viz_state());
bounds_viz_geom_node->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_bounds_viz_state());
} else {
PTA_Vertexf verts;

3
panda/src/collide/collisionPolygon.h
View File

@ -61,7 +61,8 @@ public:
virtual void xform(const LMatrix4f &mat);
virtual LPoint3f get_collision_origin() const;
virtual PT(PandaNode) get_viz(const CullTraverserData &data,
virtual PT(PandaNode) get_viz(const CullTraverser *trav,
const CullTraverserData &data,
bool bounds_only) const;
virtual void output(ostream &out) const;

2
panda/src/collide/collisionSolid.cxx
View File

@ -108,7 +108,7 @@ xform(const LMatrix4f &mat) {
// made visible.
////////////////////////////////////////////////////////////////////
PT(PandaNode) CollisionSolid::
get_viz(const CullTraverserData &, bool bounds_only) const {
get_viz(const CullTraverser *, const CullTraverserData &, bool bounds_only) const {
if ((_flags & F_viz_geom_stale) != 0) {
if (_viz_geom == (GeomNode *)NULL) {
((CollisionSolid *)this)->_viz_geom = new GeomNode("viz");

3
panda/src/collide/collisionSolid.h
View File

@ -77,7 +77,8 @@ public:
virtual void xform(const LMatrix4f &mat);
virtual PT(PandaNode) get_viz(const CullTraverserData &data,
virtual PT(PandaNode) get_viz(const CullTraverser *trav,
const CullTraverserData &data,
bool bounds_only) const;
PUBLISHED:

8
panda/src/collide/collisionVisualizer.cxx
View File

@ -129,7 +129,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
// whatever transforms were above the CollisionVisualizer node; it
// always renders its objects according to their appropriate net
// transform.
xform_data._net_transform = TransformState::make_identity();
xform_data._modelview_transform = trav->get_world_transform();
xform_data.apply_transform_and_state(trav, net_transform,
RenderState::make_empty(),
RenderEffects::make_empty());
@ -145,7 +145,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
const CollisionSolid *solid = (*si).first;
const SolidInfo &solid_info = (*si).second;
bool was_detected = (solid_info._detected_count > 0);
PT(PandaNode) node = solid->get_viz(xform_data, !was_detected);
PT(PandaNode) node = solid->get_viz(trav, xform_data, !was_detected);
if (node != (PandaNode *)NULL) {
CullTraverserData next_data(xform_data, node);
@ -188,7 +188,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
}
CullableObject *object =
new CullableObject(sphere, empty_state, xform_data._net_transform);
new CullableObject(sphere, empty_state, xform_data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
@ -206,7 +206,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
line->set_num_prims(1);
CullableObject *object =
new CullableObject(line, empty_state, xform_data._net_transform);
new CullableObject(line, empty_state, xform_data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}

18
panda/src/parametrics/ropeNode.cxx
View File

@ -361,7 +361,7 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
CPT(RenderState) state = data._state->add_attrib(thick);
CullableObject *object = new CullableObject(geom, state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
} else {
@ -406,7 +406,7 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
CPT(RenderState) state = data._state->add_attrib(thick);
CullableObject *object = new CullableObject(geom, state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
}
@ -451,7 +451,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
} else {
@ -497,7 +497,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
geom->set_lengths(lengths);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
}
@ -515,7 +515,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
void RopeNode::
render_billboard(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
const TransformState *net_transform = data._net_transform;
const TransformState *net_transform = data._modelview_transform;
const TransformState *camera_transform = trav->get_camera_transform();
CPT(TransformState) rel_transform =
@ -549,7 +549,7 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
} else {
@ -595,7 +595,7 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
geom->set_lengths(lengths);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
}
@ -654,7 +654,7 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
} else {
@ -713,7 +713,7 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
geom->set_lengths(lengths);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
}

4
panda/src/parametrics/sheetNode.cxx
View File

@ -333,7 +333,7 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
} else {
@ -403,7 +403,7 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
geom->set_lengths(lengths);
CullableObject *object = new CullableObject(geom, data._state,
data._net_transform);
data._modelview_transform);
trav->get_cull_handler()->record_object(object, trav);
}
}

13
panda/src/pgraph/billboardEffect.cxx
View File

@ -147,18 +147,21 @@ void BillboardEffect::
cull_callback(CullTraverser *trav, CullTraverserData &data,
CPT(TransformState) &node_transform,
CPT(RenderState) &) const {
CPT(TransformState) net_transform = data._net_transform;
CPT(TransformState) net_transform = data._modelview_transform;
if (net_transform->is_singular()) {
// If we're under a singular transform, never mind.
return;
}
CPT(TransformState) camera_transform = trav->get_camera_transform();
// Since the "net" transform from the cull traverser already
// includes the inverse camera transform, the camera transform is
// identity.
CPT(TransformState) camera_transform = TransformState::make_identity();
// Determine the relative transform to our camera (or other look_at
// coordinate space).
// But if we're rotating to face something other than the camera, we
// have to compute the "camera" transform to compensate for that.
if (!_look_at.is_empty()) {
camera_transform = _look_at.get_net_transform();
camera_transform = trav->get_camera_transform()->invert_compose(_look_at.get_net_transform());
}
compute_billboard(node_transform, net_transform, camera_transform);

6
panda/src/pgraph/compassEffect.cxx
View File

@ -135,7 +135,7 @@ has_cull_callback() const {
// level.
////////////////////////////////////////////////////////////////////
void CompassEffect::
cull_callback(CullTraverser *, CullTraverserData &data,
cull_callback(CullTraverser *trav, CullTraverserData &data,
CPT(TransformState) &node_transform,
CPT(RenderState) &) const {
if (_properties == 0) {
@ -143,8 +143,8 @@ cull_callback(CullTraverser *, CullTraverserData &data,
return;
}
CPT(TransformState) true_net_transform = data._net_transform;
CPT(TransformState) want_net_transform = data._net_transform;
CPT(TransformState) true_net_transform = data.get_net_transform(trav);
CPT(TransformState) want_net_transform = true_net_transform;
adjust_transform(want_net_transform, node_transform);
// Now compute the transform that will convert true_net_transform to

4
panda/src/pgraph/cullBinBackToFront.cxx
View File

@ -59,8 +59,8 @@ add_object(CullableObject *object) {
DCAST_INTO_V(gbv, &volume);
LPoint3f center = gbv->get_approx_center();
nassertv(object->_transform != (const TransformState *)NULL);
center = center * object->_transform->get_mat();
nassertv(object->_modelview_transform != (const TransformState *)NULL);
center = center * object->_modelview_transform->get_mat();
float distance = _gsg->compute_distance_to(center);
_objects.push_back(ObjectData(object, distance));

4
panda/src/pgraph/cullBinFrontToBack.cxx
View File

@ -59,8 +59,8 @@ add_object(CullableObject *object) {
DCAST_INTO_V(gbv, &volume);
LPoint3f center = gbv->get_approx_center();
nassertv(object->_transform != (const TransformState *)NULL);
center = center * object->_transform->get_mat();
nassertv(object->_modelview_transform != (const TransformState *)NULL);
center = center * object->_modelview_transform->get_mat();
float distance = _gsg->compute_distance_to(center);
_objects.push_back(ObjectData(object, distance));

4
panda/src/pgraph/cullBinStateSorted.I
View File

@ -52,8 +52,8 @@ operator < (const ObjectData &other) const {
// Then group objects by transform, since these are supposed to be
// expensive too.
if (_object->_transform != other._object->_transform) {
return _object->_transform < other._object->_transform;
if (_object->_modelview_transform != other._object->_modelview_transform) {
return _object->_modelview_transform < other._object->_modelview_transform;
}
// Then, sort by all the other states, in no particular order,

2
panda/src/pgraph/cullHandler.I
View File

@ -29,7 +29,7 @@ draw(CullableObject *object, GraphicsStateGuardianBase *gsg) {
if (object->_next != (CullableObject *)NULL) {
draw_with_decals(object, gsg);
} else {
gsg->set_state_and_transform(object->_state, object->_transform);
gsg->set_state_and_transform(object->_state, object->_modelview_transform);
object->draw(gsg);
}
}

8
panda/src/pgraph/cullHandler.cxx
View File

@ -45,7 +45,7 @@ CullHandler::
////////////////////////////////////////////////////////////////////
void CullHandler::
record_object(CullableObject *object, const CullTraverser *traverser) {
nout << *object->_geom << " " << *object->_transform << " "
nout << *object->_geom << " " << *object->_modelview_transform << " "
<< *object->_state << "\n";
delete object;
}
@ -65,7 +65,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
CullableObject *base = object;
while (base != (CullableObject *)NULL && base->_geom != (Geom *)NULL) {
gsg->set_state_and_transform(base->_state->compose(state), base->_transform);
gsg->set_state_and_transform(base->_state->compose(state), base->_modelview_transform);
base->draw(gsg);
base = base->_next;
@ -77,7 +77,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
CullableObject *decal = base->_next;
while (decal != (CullableObject *)NULL) {
gsg->set_state_and_transform(decal->_state->compose(state), decal->_transform);
gsg->set_state_and_transform(decal->_state->compose(state), decal->_modelview_transform);
decal->draw(gsg);
decal = decal->_next;
}
@ -88,7 +88,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
if (state != (const RenderState *)NULL) {
base = object;
while (base != (CullableObject *)NULL && base->_geom != (Geom *)NULL) {
gsg->set_state_and_transform(base->_state->compose(state), base->_transform);
gsg->set_state_and_transform(base->_state->compose(state), base->_modelview_transform);
base->draw(gsg);
base = base->_next;

8
panda/src/pgraph/cullTraverser.cxx
View File

@ -125,7 +125,7 @@ traverse(const NodePath &root, bool python_cull_control) {
CPT(TransformState) transform = cull_center.get_transform(root);
CullTraverserData my_data(data, portal_viewer._previous);
my_data._net_transform = my_data._net_transform->compose(transform);
my_data._modelview_transform = my_data._modelview_transform->compose(transform);
traverse(my_data);
} else {
@ -273,7 +273,7 @@ show_bounds(CullTraverserData &data, bool tight) {
_geoms_pcollector.add_level(1);
CullableObject *outer_viz =
new CullableObject(bounds_viz, get_bounds_outer_viz_state(),
data._net_transform);
data._modelview_transform);
_cull_handler->record_object(outer_viz, this);
}
@ -284,12 +284,12 @@ show_bounds(CullTraverserData &data, bool tight) {
_geoms_pcollector.add_level(2);
CullableObject *outer_viz =
new CullableObject(bounds_viz, get_bounds_outer_viz_state(),
data._net_transform);
data._modelview_transform);
_cull_handler->record_object(outer_viz, this);
CullableObject *inner_viz =
new CullableObject(bounds_viz, get_bounds_inner_viz_state(),
data._net_transform);
data._modelview_transform);
_cull_handler->record_object(inner_viz, this);
}
}

21
panda/src/pgraph/cullTraverserData.I
View File

@ -23,12 +23,12 @@
////////////////////////////////////////////////////////////////////
INLINE CullTraverserData::
CullTraverserData(const NodePath &start,
const TransformState *net_transform,
const TransformState *modelview_transform,
const RenderState *state,
GeometricBoundingVolume *view_frustum,
GeometricBoundingVolume *guard_band) :
_node_path(start),
_net_transform(net_transform),
_modelview_transform(modelview_transform),
_state(state),
_view_frustum(view_frustum),
_guard_band(guard_band)
@ -43,7 +43,7 @@ CullTraverserData(const NodePath &start,
INLINE CullTraverserData::
CullTraverserData(const CullTraverserData &copy) :
_node_path(copy._node_path),
_net_transform(copy._net_transform),
_modelview_transform(copy._modelview_transform),
_state(copy._state),
_view_frustum(copy._view_frustum),
_guard_band(copy._guard_band)
@ -58,7 +58,7 @@ CullTraverserData(const CullTraverserData &copy) :
INLINE void CullTraverserData::
operator = (const CullTraverserData &copy) {
_node_path = copy._node_path;
_net_transform = copy._net_transform;
_modelview_transform = copy._modelview_transform;
_state = copy._state;
_view_frustum = copy._view_frustum;
_guard_band = copy._guard_band;
@ -73,7 +73,7 @@ operator = (const CullTraverserData &copy) {
INLINE CullTraverserData::
CullTraverserData(const CullTraverserData &parent, PandaNode *child) :
_node_path(parent._node_path, child),
_net_transform(parent._net_transform),
_modelview_transform(parent._modelview_transform),
_state(parent._state),
_view_frustum(parent._view_frustum),
_guard_band(parent._guard_band)
@ -99,6 +99,17 @@ node() const {
return _node_path.node();
}
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::get_modelview_transform
// Access: Public
// Description: Returns the modelview transform: the relative
// transform from the camera to the model.
////////////////////////////////////////////////////////////////////
INLINE const TransformState *CullTraverserData::
get_modelview_transform() const {
return _modelview_transform;
}
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::is_in_view
// Access: Public

13
panda/src/pgraph/cullTraverserData.cxx
View File

@ -29,6 +29,17 @@
#include "renderState.h"
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::get_net_transform
// Access: Public
// Description: Returns the net transform: the relative
// transform from the root of the scene to the model.
////////////////////////////////////////////////////////////////////
CPT(TransformState) CullTraverserData::
get_net_transform(const CullTraverser *trav) const {
return trav->get_camera_transform()->compose(_modelview_transform);
}
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::apply_transform_and_state
// Access: Public
@ -71,7 +82,7 @@ apply_transform_and_state(CullTraverser *trav,
}
if (!node_transform->is_identity()) {
_net_transform = _net_transform->compose(node_transform);
_modelview_transform = _modelview_transform->compose(node_transform);
if ((_view_frustum != (GeometricBoundingVolume *)NULL) ||
(_guard_band != (GeometricBoundingVolume *)NULL)) {

7
panda/src/pgraph/cullTraverserData.h
View File

@ -48,7 +48,7 @@ class CullTraverser;
class EXPCL_PANDA CullTraverserData {
public:
INLINE CullTraverserData(const NodePath &start,
const TransformState *net_transform,
const TransformState *modelview_transform,
const RenderState *state,
GeometricBoundingVolume *view_frustum,
GeometricBoundingVolume *guard_band);
@ -60,6 +60,9 @@ public:
INLINE PandaNode *node() const;
INLINE const TransformState *get_modelview_transform() const;
CPT(TransformState) get_net_transform(const CullTraverser *trav) const;
INLINE bool is_in_view(const DrawMask &camera_mask);
void apply_transform_and_state(CullTraverser *trav);
void apply_transform_and_state(CullTraverser *trav,
@ -68,7 +71,7 @@ public:
CPT(RenderEffects) node_effects);
WorkingNodePath _node_path;
CPT(TransformState) _net_transform;
CPT(TransformState) _modelview_transform;
CPT(RenderState) _state;
PT(GeometricBoundingVolume) _view_frustum;
PT(GeometricBoundingVolume) _guard_band;

10
panda/src/pgraph/cullableObject.I
View File

@ -41,7 +41,7 @@ CullableObject(const CullTraverserData &data,
CullableObject *next) :
_geom(geom_node->get_geom(i)),
_state(data._state->compose(geom_node->get_geom_state(i))),
_transform(data._net_transform),
_modelview_transform(data._modelview_transform),
_next(next)
{
}
@ -54,11 +54,11 @@ CullableObject(const CullTraverserData &data,
////////////////////////////////////////////////////////////////////
INLINE CullableObject::
CullableObject(const Geom *geom, const RenderState *state,
const TransformState *transform,
const TransformState *modelview_transform,
CullableObject *next) :
_geom(geom),
_state(state),
_transform(transform),
_modelview_transform(modelview_transform),
_next(next)
{
}
@ -74,7 +74,7 @@ INLINE CullableObject::
CullableObject(const CullableObject &copy) :
_geom(copy._geom),
_state(copy._state),
_transform(copy._transform),
_modelview_transform(copy._modelview_transform),
_next((CullableObject *)NULL)
{
}
@ -89,7 +89,7 @@ INLINE void CullableObject::
operator = (const CullableObject &copy) {
_geom = copy._geom;
_state = copy._state;
_transform = copy._transform;
_modelview_transform = copy._modelview_transform;
}
////////////////////////////////////////////////////////////////////

6
panda/src/pgraph/cullableObject.cxx
View File

@ -54,7 +54,7 @@ munge_geom(GraphicsStateGuardianBase *gsg,
int geom_rendering = qpgeom->get_geom_rendering();
geom_rendering = _state->get_geom_rendering(geom_rendering);
geom_rendering = _transform->get_geom_rendering(geom_rendering);
geom_rendering = _modelview_transform->get_geom_rendering(geom_rendering);
GraphicsStateGuardianBase *gsg = traverser->get_gsg();
int gsg_bits = gsg->get_supported_geom_rendering();
@ -235,7 +235,7 @@ munge_points_to_quads(const CullTraverser *traverser) {
PT(qpGeom) new_geom = new qpGeom();
new_geom->set_vertex_data(new_data);
const LMatrix4f &modelview = _transform->get_mat();
const LMatrix4f &modelview = _modelview_transform->get_mat();
SceneSetup *scene = traverser->get_scene();
const Lens *lens = scene->get_lens();
@ -350,7 +350,7 @@ munge_points_to_quads(const CullTraverser *traverser) {
// height in 3-d units. To arrange that, we need to figure
// out the appropriate scaling factor based on the current
// viewport and projection matrix.
float scale = _transform->get_scale()[1];
float scale = _modelview_transform->get_scale()[1];
LVector3f height(0.0f, point_size * scale, scale);
height = height * height_projection;
scale_y = height[1] * viewport_height;

4
panda/src/pgraph/cullableObject.h
View File

@ -49,7 +49,7 @@ public:
GeomNode *geom_node, int i,
CullableObject *next = NULL);
INLINE CullableObject(const Geom *geom, const RenderState *state,
const TransformState *transform,
const TransformState *modelview_transform,
CullableObject *next = NULL);
INLINE CullableObject(const CullableObject &copy);
@ -80,7 +80,7 @@ public:
PT(qpGeomMunger) _munger;
CPT(qpGeomVertexData) _munged_data;
CPT(RenderState) _state;
CPT(TransformState) _transform;
CPT(TransformState) _modelview_transform;
CullableObject *_next;
private:

9
panda/src/pgraph/lodNode.cxx
View File

@ -250,7 +250,7 @@ is_lod_node() const {
////////////////////////////////////////////////////////////////////
int LODNode::
compute_child(CullTraverser *trav, CullTraverserData &data) {
if (data._net_transform->is_singular()) {
if (data._modelview_transform->is_singular()) {
// If we're under a singular transform, we can't compute the LOD;
// select none of them instead.
return -1;
@ -266,10 +266,11 @@ compute_child(CullTraverser *trav, CullTraverserData &data) {
// CPT(TransformState) rel_transform =
// trav->get_camera_transform()->invert_compose(data._net_transform);
CPT(TransformState) rel_transform =
trav->get_scene()->get_cull_center().get_net_transform()->
invert_compose(data._net_transform);
// CPT(TransformState) rel_transform =
// trav->get_scene()->get_cull_center().get_net_transform()->
// invert_compose(data._net_transform);
CPT(TransformState) rel_transform = data._modelview_transform;
LPoint3f center = cdata->_center * rel_transform->get_mat();
// Determine which child to traverse

3
panda/src/pgui/pgItem.cxx
View File

@ -182,7 +182,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
PGCullTraverser *pg_trav;
DCAST_INTO_R(pg_trav, trav, true);
const LMatrix4f &transform = data._net_transform->get_mat();
CPT(TransformState) net_transform = data.get_net_transform(trav);
const LMatrix4f &transform = net_transform->get_mat();
// Consider the cull bin this object is in. Since the binning
// affects the render order, we want bins that render later to