RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

step one of eliminating NodeAttributes for scene graph performance

This commit is contained in:
David Rose 2001-08-03 06:43:29 +00:00
parent 76a48e45b3
commit f8535f4676
3 changed files with 52 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
direct/src/showbase/ShowBase.py
View File

@ -60,13 +60,12 @@ class ShowBase:
fsmRedefine = self.config.GetBool('fsm-redefine', 0)
State.FsmRedefine = fsmRedefine
self.initialState = NodeAttributes()
# Set a default "off color" (i.e. use poly color) for color transitions
self.initialState.setAttribute(ColorTransition.getClassType(),
ColorAttribute())
self.renderTop = NodePath(NamedNode('renderTop'))
self.render = self.renderTop.attachNewNode('render')
# Set a default "off color" (i.e. use poly color) for color transitions
self.render.setColorOff()
self.hidden = NodePath(NamedNode('hidden'))
# This will be the list of cameras, one per display region
# For now, we only have one display region, so just create the
@ -77,9 +76,7 @@ class ShowBase:
self.dataRootNode = self.dataRoot.node()
self.dataUnused = NodePath(NamedNode('dataUnused'), DataRelation.getClassType())
self.pipe = makeGraphicsPipe()
chanConfig = makeGraphicsWindow(self.pipe,
self.renderTop.node(),
self.initialState)
chanConfig = makeGraphicsWindow(self.pipe, self.render.arc())
self.win = chanConfig.getWin()
# Now that we've assigned a window, assign an exitfunc.
@ -382,13 +379,13 @@ class ShowBase:
self.eventMgr.shutdown()
def toggleBackface(self):
toggleBackface(self.initialState)
toggleBackface(self.render.arc())
def toggleTexture(self):
toggleTexture(self.initialState)
toggleTexture(self.render.arc())
def toggleWireframe(self):
toggleWireframe(self.initialState)
toggleWireframe(self.render.arc())
def disableMouse(self):
"""

95
direct/src/showbase/showBase.cxx
View File

@ -23,14 +23,12 @@
#include <renderRelation.h>
#include <namedNode.h>
#include <renderModeTransition.h>
#include <renderModeAttribute.h>
#include <textureTransition.h>
#include <textureAttribute.h>
#include <textureTransition.h>
#include <interactiveGraphicsPipe.h>
#include <graphicsWindow.h>
#include <chancfg.h>
#include <cullFaceTransition.h>
#include <cullFaceAttribute.h>
#include <dftraverser.h>
#include <renderBuffer.h>
#include <clockObject.h>
@ -38,9 +36,7 @@
#include <nodeRelation.h>
#include <dataGraphTraversal.h>
#include <depthTestTransition.h>
#include <depthTestAttribute.h>
#include <depthWriteTransition.h>
#include <depthWriteAttribute.h>
#include <lightTransition.h>
#include <materialTransition.h>
#include <camera.h>
@ -48,7 +44,7 @@
#include <orthoProjection.h>
#include <appTraverser.h>
#include <get_config_path.h>
#include <allAttributesWrapper.h>
#include <allTransitionsWrapper.h>
#include <dataGraphTraversal.h>
ConfigureDef(config_showbase);
@ -65,12 +61,11 @@ get_particle_path() {
std::string chan_config = "single";
std::string window_title = "Panda3D";
void render_frame(GraphicsPipe *pipe,
NodeAttributes &initial_state) {
void render_frame(GraphicsPipe *pipe) {
int num_windows = pipe->get_num_windows();
for (int w = 0; w < num_windows; w++) {
GraphicsWindow *win = pipe->get_window(w);
win->get_gsg()->render_frame(initial_state);
win->get_gsg()->render_frame();
}
ClockObject::get_global_clock()->tick();
throw_event("NewFrame");
@ -78,25 +73,22 @@ void render_frame(GraphicsPipe *pipe,
class WindowCallback : public GraphicsWindow::Callback {
public:
WindowCallback(GraphicsPipe *pipe, Node *render,
NodeAttributes *initial_state) :
WindowCallback(GraphicsPipe *pipe, Node *render_top) :
_pipe(pipe),
_render(render),
_initial_state(initial_state),
_render_top(render_top),
_app_traverser(RenderRelation::get_class_type()) { }
virtual ~WindowCallback() { }
virtual void draw(bool) {
_app_traverser.traverse(_render);
render_frame(_pipe, *_initial_state);
_app_traverser.traverse(_render_top);
render_frame(_pipe);
}
virtual void idle(void) {
}
PT(GraphicsPipe) _pipe;
PT(Node) _render;
NodeAttributes *_initial_state;
PT(Node) _render_top;
AppTraverser _app_traverser;
};
@ -124,20 +116,20 @@ PT(GraphicsPipe) make_graphics_pipe() {
return main_pipe;
}
ChanConfig make_graphics_window(GraphicsPipe *pipe,
NamedNode *render,
NodeAttributes &initial_state) {
ChanConfig make_graphics_window(GraphicsPipe *pipe, NodeRelation *render_arc) {
PT(GraphicsWindow) main_win;
ChanCfgOverrides override;
// Turn on backface culling
CullFaceAttribute *cfa = new CullFaceAttribute;
cfa->set_mode(CullFaceProperty::M_cull_clockwise);
initial_state.set_attribute(CullFaceTransition::get_class_type(), cfa);
DepthTestAttribute *dta = new DepthTestAttribute;
initial_state.set_attribute(DepthTestTransition::get_class_type(), dta);
DepthWriteAttribute *dwa = new DepthWriteAttribute;
initial_state.set_attribute(DepthWriteTransition::get_class_type(), dwa);
// Turn on backface culling and depth buffer
CullFaceTransition *cfa = new CullFaceTransition(CullFaceProperty::M_cull_clockwise);
render_arc->set_transition(cfa);
DepthTestTransition *dta = new DepthTestTransition;
render_arc->set_transition(dta);
DepthWriteTransition *dwa = new DepthWriteTransition;
render_arc->set_transition(dwa);
// Now use ChanConfig to create the window.
Node *render_top = render_arc->get_parent();
override.setField(ChanCfgOverrides::Mask,
((unsigned int)(W_DOUBLE|W_DEPTH|W_MULTISAMPLE)));
@ -146,12 +138,11 @@ ChanConfig make_graphics_window(GraphicsPipe *pipe,
override.setField(ChanCfgOverrides::Title, title);
std::string conf = config_showbase.GetString("chan-config", chan_config);
ChanConfig chan_config(pipe, conf, render, override);
ChanConfig chan_config(pipe, conf, render_top, override);
main_win = chan_config.get_win();
assert(main_win != (GraphicsWindow*)0L);
WindowCallback *wcb =
new WindowCallback(pipe, render, &initial_state);
WindowCallback *wcb = new WindowCallback(pipe, render_top);
// Set draw callback. Currently there is no reason to use the idle callback.
main_win->set_draw_callback(wcb);
@ -217,33 +208,29 @@ add_render_layer(GraphicsWindow *win, Node *render_top, Camera *camera) {
void
toggle_wireframe(NodeAttributes &initial_state) {
toggle_wireframe(NodeRelation *render_arc) {
static bool wireframe_mode = false;
wireframe_mode = !wireframe_mode;
if (!wireframe_mode) {
// Set the normal, filled mode on the render arc.
RenderModeAttribute *rma = new RenderModeAttribute;
rma->set_mode(RenderModeProperty::M_filled);
CullFaceAttribute *cfa = new CullFaceAttribute;
cfa->set_mode(CullFaceProperty::M_cull_clockwise);
initial_state.set_attribute(RenderModeTransition::get_class_type(), rma);
initial_state.set_attribute(CullFaceTransition::get_class_type(), cfa);
RenderModeTransition *rma = new RenderModeTransition(RenderModeProperty::M_filled);
CullFaceTransition *cfa = new CullFaceTransition(CullFaceProperty::M_cull_clockwise);
render_arc->set_transition(rma);
render_arc->set_transition(cfa);
} else {
// Set the initial state up for wireframe mode.
RenderModeAttribute *rma = new RenderModeAttribute;
rma->set_mode(RenderModeProperty::M_wireframe);
CullFaceAttribute *cfa = new CullFaceAttribute;
cfa->set_mode(CullFaceProperty::M_cull_none);
initial_state.set_attribute(RenderModeTransition::get_class_type(), rma);
initial_state.set_attribute(CullFaceTransition::get_class_type(), cfa);
RenderModeTransition *rma = new RenderModeTransition(RenderModeProperty::M_wireframe);
CullFaceTransition *cfa = new CullFaceTransition(CullFaceProperty::M_cull_none);
render_arc->set_transition(rma);
render_arc->set_transition(cfa);
}
}
void
toggle_backface(NodeAttributes &initial_state) {
toggle_backface(NodeRelation *render_arc) {
static bool backface_mode = false;
// Toggle the state variable
@ -251,30 +238,28 @@ toggle_backface(NodeAttributes &initial_state) {
if (backface_mode) {
// Turn backface culling off
CullFaceAttribute *cfa = new CullFaceAttribute;
cfa->set_mode(CullFaceProperty::M_cull_none);
initial_state.set_attribute(CullFaceTransition::get_class_type(), cfa);
CullFaceTransition *cfa = new CullFaceTransition(CullFaceProperty::M_cull_none);
render_arc->set_transition(cfa);
} else {
// Turn backface culling on
CullFaceAttribute *cfa = new CullFaceAttribute;
cfa->set_mode(CullFaceProperty::M_cull_clockwise);
initial_state.set_attribute(CullFaceTransition::get_class_type(), cfa);
CullFaceTransition *cfa = new CullFaceTransition(CullFaceProperty::M_cull_clockwise);
render_arc->set_transition(cfa);
}
}
void toggle_texture(NodeAttributes &initial_state) {
void toggle_texture(NodeRelation *render_arc) {
static bool textures_enabled = true;
textures_enabled = !textures_enabled;
if (textures_enabled) {
// Remove the override from the initial state.
initial_state.clear_attribute(TextureTransition::get_class_type());
render_arc->clear_transition(TextureTransition::get_class_type());
} else {
// Set an override on the initial state to disable texturing.
TextureAttribute *ta = new TextureAttribute;
TextureTransition *ta = new TextureTransition;
ta->set_priority(100);
initial_state.set_attribute(TextureTransition::get_class_type(), ta);
render_arc->set_transition(ta);
}
}

9
direct/src/showbase/showBase.h
View File

@ -45,16 +45,15 @@ EXPCL_DIRECT DSearchPath &get_particle_path();
EXPCL_DIRECT PT(GraphicsPipe) make_graphics_pipe();
EXPCL_DIRECT ChanConfig
make_graphics_window(GraphicsPipe *pipe,
NamedNode *render,
NodeAttributes &initial_state);
NodeRelation *render_arc);
EXPCL_DIRECT NodePath setup_panda_2d(GraphicsWindow *win, const string &name);
EXPCL_DIRECT void add_render_layer(GraphicsWindow *win, Node *render_top,
Camera *camera);
EXPCL_DIRECT void toggle_wireframe(NodeAttributes &initial_state);
EXPCL_DIRECT void toggle_texture(NodeAttributes &initial_state);
EXPCL_DIRECT void toggle_backface(NodeAttributes &initial_state);
EXPCL_DIRECT void toggle_wireframe(NodeRelation *render_arc);
EXPCL_DIRECT void toggle_texture(NodeRelation *render_arc);
EXPCL_DIRECT void toggle_backface(NodeRelation *render_arc);
EXPCL_DIRECT void take_snapshot(GraphicsWindow *win, const string &name);