From 29bf5a2ae34f9c09f1a8ccdaaa8cc8ea6722fe45 Mon Sep 17 00:00:00 2001 From: David Rose Date: Tue, 5 Mar 2002 03:02:42 +0000 Subject: [PATCH] a couple more pgraph attribs --- panda/src/egg2pg/qpeggLoader.cxx | 138 ++++---------- panda/src/egg2pg/qpeggLoader.h | 19 +- panda/src/glgsg/glGraphicsStateGuardian.cxx | 32 ++++ panda/src/glgsg/glGraphicsStateGuardian.h | 4 +- panda/src/pgraph/Sources.pp | 6 + panda/src/pgraph/config_pgraph.cxx | 9 +- panda/src/pgraph/materialAttrib.I | 52 ++++++ panda/src/pgraph/materialAttrib.cxx | 196 ++++++++++++++++++++ panda/src/pgraph/materialAttrib.h | 86 +++++++++ panda/src/pgraph/pgraph_composite1.cxx | 2 + panda/src/pgraph/pgraph_composite2.cxx | 3 +- panda/src/pgraph/textureApplyAttrib.I | 40 ++++ panda/src/pgraph/textureApplyAttrib.cxx | 183 ++++++++++++++++++ panda/src/pgraph/textureApplyAttrib.h | 89 +++++++++ 14 files changed, 735 insertions(+), 124 deletions(-) create mode 100644 panda/src/pgraph/materialAttrib.I create mode 100644 panda/src/pgraph/materialAttrib.cxx create mode 100644 panda/src/pgraph/materialAttrib.h create mode 100644 panda/src/pgraph/textureApplyAttrib.I create mode 100644 panda/src/pgraph/textureApplyAttrib.cxx create mode 100644 panda/src/pgraph/textureApplyAttrib.h diff --git a/panda/src/egg2pg/qpeggLoader.cxx b/panda/src/egg2pg/qpeggLoader.cxx index 2aac9222f3..93a2ad1cc4 100644 --- a/panda/src/egg2pg/qpeggLoader.cxx +++ b/panda/src/egg2pg/qpeggLoader.cxx @@ -23,12 +23,17 @@ #include "renderState.h" #include "transformState.h" #include "textureAttrib.h" +#include "textureApplyAttrib.h" #include "texturePool.h" #include "billboardAttrib.h" #include "cullFaceAttrib.h" #include "cullBinAttrib.h" #include "transparencyAttrib.h" #include "decalAttrib.h" +#include "depthTestAttrib.h" +#include "depthWriteAttrib.h" +#include "materialAttrib.h" +#include "materialPool.h" #include "qpgeomNode.h" #include "string_utils.h" #include "eggPrimitive.h" @@ -125,7 +130,6 @@ build_graph() { make_node(&_data, _root); _builder.qpbuild(); - // reset_directs(); reparent_decals(); // apply_deferred_arcs(_root); @@ -196,54 +200,6 @@ reparent_decals() { } } -/* -//////////////////////////////////////////////////////////////////// -// Function: qpEggLoader::reset_directs -// Access: Public -// Description: This applies to all of the nodes marked with the -// "render" flag, i.e. direct rendering of a subgraph, -// in depth-first order, as opposed to state-sorting -// within the subgraph. For each such node, it moves -// all the transitions from the first GeomNode under -// that node up to the node itself, just so we'll be -// able to state-sort at least the tops of the -// subgraphs. -//////////////////////////////////////////////////////////////////// -void qpEggLoader:: -reset_directs() { - Directs::const_iterator di; - for (di = _directs.begin(); di != _directs.end(); ++di) { - RenderRelation *arc = (*di); - nassertv(arc != (RenderRelation *)NULL); - PandaNode *node = DCAST(PandaNode, arc->get_child()); - nassertv(node != (PandaNode *)NULL); - - // First, search for the first GeomNode. - GeomNode *geom = NULL; - NodeRelation *child_arc = NULL; - - int num_children = - node->get_num_children(RenderRelation::get_class_type()); - for (int i = 0; i < num_children && geom == (GeomNode *)NULL; i++) { - child_arc = node->get_child(RenderRelation::get_class_type(), i); - nassertv(child_arc != (NodeRelation *)NULL); - Node *child = child_arc->get_child(); - nassertv(child != (Node *)NULL); - - if (child->is_of_type(GeomNode::get_class_type())) { - DCAST_INTO_V(geom, child); - } - } - - if (geom != (GeomNode *)NULL) { - // Now copy all of the GeomNode's transitions up to its parent. - nassertv(child_arc != (NodeRelation *)NULL); - arc->copy_transitions_from(child_arc); - } - } -} -*/ - //////////////////////////////////////////////////////////////////// // Function: qpEggLoader::make_nonindexed_primitive @@ -512,16 +468,11 @@ load_texture(TextureDef &def, const EggTexture *egg_tex) { } } - /* - PT(TextureApplyTransition) apply = - new TextureApplyTransition(TextureApplyProperty::M_modulate); - */ - apply_texture_attributes(tex, egg_tex); - // apply_texture_apply_attributes(apply, egg_tex); + CPT(RenderAttrib) apply = get_texture_apply_attributes(egg_tex); def._texture = TextureAttrib::make(tex); - // def._apply = *(_texture_applies.insert(apply).first); + def._apply = apply; return true; } @@ -819,26 +770,25 @@ apply_texture_attributes(Texture *tex, const EggTexture *egg_tex) { } } -/* //////////////////////////////////////////////////////////////////// // Function: qpEggLoader::apply_texture_apply_attributes // Access: Private // Description: //////////////////////////////////////////////////////////////////// -void qpEggLoader:: -apply_texture_apply_attributes(TextureApplyTransition *apply, - const EggTexture *egg_tex) { +CPT(RenderAttrib) qpEggLoader:: +get_texture_apply_attributes(const EggTexture *egg_tex) { + CPT(RenderAttrib) result = TextureApplyAttrib::make(TextureApplyAttrib::M_modulate); if (egg_always_decal_textures) { - apply->set_mode(TextureApplyProperty::M_decal); + result = TextureApplyAttrib::make(TextureApplyAttrib::M_decal); } else { switch (egg_tex->get_env_type()) { case EggTexture::ET_modulate: - apply->set_mode(TextureApplyProperty::M_modulate); + result = TextureApplyAttrib::make(TextureApplyAttrib::M_modulate); break; case EggTexture::ET_decal: - apply->set_mode(TextureApplyProperty::M_decal); + result = TextureApplyAttrib::make(TextureApplyAttrib::M_decal); break; case EggTexture::ET_unspecified: @@ -850,19 +800,19 @@ apply_texture_apply_attributes(TextureApplyTransition *apply, << (int)egg_tex->get_env_type() << "\n"; } } -} -*/ -/* + return result; +} + //////////////////////////////////////////////////////////////////// -// Function: qpEggLoader::get_material_transition +// Function: qpEggLoader::get_material_attrib // Access: Private -// Description: Returns a transition suitable for enabling the +// Description: Returns a RenderAttrib suitable for enabling the // material indicated by the given EggMaterial, and with // the indicated backface flag. //////////////////////////////////////////////////////////////////// -MaterialTransition *qpEggLoader:: -get_material_transition(const EggMaterial *egg_mat, bool bface) { +CPT(RenderAttrib) qpEggLoader:: +get_material_attrib(const EggMaterial *egg_mat, bool bface) { Materials &materials = bface ? _materials_bface : _materials; // First, check whether we've seen this material before. @@ -902,13 +852,12 @@ get_material_transition(const EggMaterial *egg_mat, bool bface) { // Now get a global Material pointer, shared with other models. const Material *shared_mat = MaterialPool::get_material(mat); - // And create a MaterialTransition for this Material. - PT(MaterialTransition) mt = new MaterialTransition(shared_mat); + // And create a MaterialAttrib for this Material. + CPT(RenderAttrib) mt = MaterialAttrib::make(shared_mat); materials.insert(Materials::value_type(egg_mat, mt)); return mt; } -*/ //////////////////////////////////////////////////////////////////// @@ -989,7 +938,7 @@ setup_bucket(BuilderBucket &bucket, PandaNode *parent, const TextureDef &def = _textures[egg_tex]; if (def._texture != (const RenderAttrib *)NULL) { bucket.add_attrib(def._texture); - // bucket.add_attrib(def._apply); + bucket.add_attrib(def._apply); // If neither the primitive nor the texture specified an alpha // mode, assume it should be alpha'ed if the texture has an @@ -1006,13 +955,12 @@ setup_bucket(BuilderBucket &bucket, PandaNode *parent, } } - /* if (egg_prim->has_material()) { - MaterialTransition *mt = get_material_transition(egg_prim->get_material(), - egg_prim->get_bface_flag()); + CPT(RenderAttrib) mt = + get_material_attrib(egg_prim->get_material(), + egg_prim->get_bface_flag()); bucket.add_attrib(mt); } - */ // Also check the color of the primitive to see if we should assume @@ -1047,7 +995,7 @@ setup_bucket(BuilderBucket &bucket, PandaNode *parent, case EggRenderMode::AM_blend_no_occlude: bucket.add_attrib(TransparencyAttrib::make(TransparencyAttrib::M_alpha)); - // bucket.add_attrib(new DepthWriteTransition(DepthWriteTransition::off())); + bucket.add_attrib(DepthWriteAttrib::make(DepthWriteAttrib::M_off)); break; case EggRenderMode::AM_ms: @@ -1063,35 +1011,31 @@ setup_bucket(BuilderBucket &bucket, PandaNode *parent, break; } - /* switch (dwm) { case EggRenderMode::DWM_on: - bucket.add_attrib(new DepthWriteTransition); + bucket.add_attrib(DepthWriteAttrib::make(DepthWriteAttrib::M_on)); break; case EggRenderMode::DWM_off: - bucket.add_attrib(new DepthWriteTransition(DepthWriteTransition::off())); + bucket.add_attrib(DepthWriteAttrib::make(DepthWriteAttrib::M_off)); break; default: break; } - */ - /* switch (dtm) { case EggRenderMode::DTM_on: - bucket.add_attrib(new DepthTestTransition(DepthTestProperty::M_less)); + bucket.add_attrib(DepthTestAttrib::make(DepthTestAttrib::M_less)); break; case EggRenderMode::DTM_off: - bucket.add_attrib(new DepthTestTransition(DepthTestProperty::M_none)); + bucket.add_attrib(DepthTestAttrib::make(DepthTestAttrib::M_none)); break; default: break; } - */ if (has_bin) { bucket.add_attrib(CullBinAttrib::make(bin, draw_order)); @@ -1477,7 +1421,7 @@ make_node(EggGroup *egg_group, PandaNode *parent) { // Function: qpEggLoader::create_group_arc // Access: Private // Description: Creates the arc parenting a new group to the scene -// graph, and applies any relevant transitions to the +// graph, and applies any relevant attribs to the // arc according to the EggGroup node that inspired the // group. //////////////////////////////////////////////////////////////////// @@ -1523,22 +1467,6 @@ create_group_arc(EggGroup *egg_group, PandaNode *parent, PandaNode *node) { _decals.insert(node); } - /* - if (egg_group->get_direct_flag()) { - // If the group has the "direct" flag set, it means that - // everything at this node and below should be rendered in direct - // mode, i.e. in depth-first tree order, without state-sorting. - - arc->set_transition(new DirectRenderTransition); - - // We'll also want to set up the transitions on this arc to - // reflect the geometry at the top of the tree below this node, so - // we get good state-sorting behavior. We'll have to do this - // later. - _directs.insert(arc); - } - */ - /* // If the group specified some property that should propagate down // to the leaves, we have to remember this arc and apply the @@ -2002,7 +1930,7 @@ void qpEggLoader:: apply_deferred_arcs(Node *root) { DeferredArcTraverser trav(_deferred_arcs); - df_traverse(root, trav, NullTransitionWrapper(), DeferredArcProperty(), + df_traverse(root, trav, NullAttribWrapper(), DeferredArcProperty(), PandaNode::get_class_type()); } */ diff --git a/panda/src/egg2pg/qpeggLoader.h b/panda/src/egg2pg/qpeggLoader.h index 9ad2cdabec..2a307e6735 100644 --- a/panda/src/egg2pg/qpeggLoader.h +++ b/panda/src/egg2pg/qpeggLoader.h @@ -64,7 +64,6 @@ public: void build_graph(); void reparent_decals(); - void reset_directs(); void make_nonindexed_primitive(EggPrimitive *egg_prim, PandaNode *parent, const LMatrix4d *transform = NULL); @@ -77,19 +76,16 @@ private: class TextureDef { public: CPT(RenderAttrib) _texture; - // PT(TextureApplyTransition) _apply; + CPT(RenderAttrib) _apply; }; void load_textures(); bool load_texture(TextureDef &def, const EggTexture *egg_tex); void apply_texture_attributes(Texture *tex, const EggTexture *egg_tex); - void apply_texture_apply_attributes(TextureApplyTransition *apply, - const EggTexture *egg_tex); + CPT(RenderAttrib) get_texture_apply_attributes(const EggTexture *egg_tex); - /* - MaterialTransition *get_material_transition(const EggMaterial *egg_mat, - bool bface); - */ + CPT(RenderAttrib) get_material_attrib(const EggMaterial *egg_mat, + bool bface); void setup_bucket(BuilderBucket &bucket, PandaNode *parent, EggPrimitive *egg_prim); @@ -133,19 +129,14 @@ private: typedef pmap Textures; Textures _textures; - /* - typedef pmap Materials; + typedef pmap Materials; Materials _materials; Materials _materials_bface; - */ typedef pset Decals; Decals _decals; /* - typedef pset Directs; - Directs _directs; - DeferredArcs _deferred_arcs; */ diff --git a/panda/src/glgsg/glGraphicsStateGuardian.cxx b/panda/src/glgsg/glGraphicsStateGuardian.cxx index fe6bc39867..0125b0cc21 100644 --- a/panda/src/glgsg/glGraphicsStateGuardian.cxx +++ b/panda/src/glgsg/glGraphicsStateGuardian.cxx @@ -3455,6 +3455,18 @@ issue_texture(const TextureAttrib *attrib) { report_errors(); } +//////////////////////////////////////////////////////////////////// +// Function: GLGraphicsStateGuardian::issue_texture_apply +// Access: Public, Virtual +// Description: +//////////////////////////////////////////////////////////////////// +void GLGraphicsStateGuardian:: +issue_texture_apply(const TextureApplyAttrib *attrib) { + GLint glmode = get_texture_apply_mode_type(attrib->get_mode()); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, glmode); + report_errors(); +} + //////////////////////////////////////////////////////////////////// // Function: GLGraphicsStateGuardian::issue_cull_face // Access: Public, Virtual @@ -4386,6 +4398,26 @@ get_texture_apply_mode_type( TextureApplyProperty::Mode am ) const return GL_MODULATE; } +//////////////////////////////////////////////////////////////////// +// Function: GLGraphicsStateGuardian::get_texture_apply_mode_type +// Access: Protected +// Description: Maps from the texture environment's mode types +// to the corresponding OpenGL ids +//////////////////////////////////////////////////////////////////// +GLint GLGraphicsStateGuardian:: +get_texture_apply_mode_type(TextureApplyAttrib::Mode am) const { + switch (am) { + case TextureApplyAttrib::M_modulate: return GL_MODULATE; + case TextureApplyAttrib::M_decal: return GL_DECAL; + case TextureApplyAttrib::M_blend: return GL_BLEND; + case TextureApplyAttrib::M_replace: return GL_REPLACE; + case TextureApplyAttrib::M_add: return GL_ADD; + } + glgsg_cat.error() + << "Invalid TextureApplyAttrib::Mode value" << endl; + return GL_MODULATE; +} + //////////////////////////////////////////////////////////////////// // Function: GLGraphicsStateGuardian::get_depth_func_type // Access: Protected diff --git a/panda/src/glgsg/glGraphicsStateGuardian.h b/panda/src/glgsg/glGraphicsStateGuardian.h index 87c55bbd23..d63ded5eb4 100644 --- a/panda/src/glgsg/glGraphicsStateGuardian.h +++ b/panda/src/glgsg/glGraphicsStateGuardian.h @@ -34,8 +34,8 @@ #include "stencilProperty.h" #include "fog.h" #include "pt_Light.h" - #include "depthTestAttrib.h" +#include "textureApplyAttrib.h" #include "pointerToArray.h" #ifdef WIN32_VC @@ -160,6 +160,7 @@ public: virtual void issue_transform(const TransformState *transform); virtual void issue_texture(const TextureAttrib *attrib); + virtual void issue_texture_apply(const TextureApplyAttrib *attrib); virtual void issue_cull_face(const CullFaceAttrib *attrib); virtual void issue_transparency(const TransparencyAttrib *attrib); virtual void issue_color_write(const ColorWriteAttrib *attrib); @@ -264,6 +265,7 @@ protected: GLenum get_external_image_format(PixelBuffer::Format format); GLenum get_internal_image_format(PixelBuffer::Format format); GLint get_texture_apply_mode_type( TextureApplyProperty::Mode am ) const; + GLint get_texture_apply_mode_type(TextureApplyAttrib::Mode am) const; GLenum get_depth_func_type(DepthTestProperty::Mode m) const; GLenum get_depth_func_type(DepthTestAttrib::Mode m) const; GLenum get_stencil_func_type(StencilProperty::Mode m) const; diff --git a/panda/src/pgraph/Sources.pp b/panda/src/pgraph/Sources.pp index cc5a56b7a6..a440652313 100644 --- a/panda/src/pgraph/Sources.pp +++ b/panda/src/pgraph/Sources.pp @@ -28,11 +28,13 @@ drawCullHandler.h drawCullHandler.I \ qpgeomNode.h qpgeomNode.I \ qplensNode.h qplensNode.I \ + materialAttrib.h materialAttrib.I \ nodeChain.h nodeChain.I \ nodeChainComponent.h nodeChainComponent.I \ pandaNode.h pandaNode.I \ renderAttrib.h renderAttrib.I \ renderState.h renderState.I \ + textureApplyAttrib.h textureApplyAttrib.I \ textureAttrib.h textureAttrib.I \ transformState.h transformState.I \ transparencyAttrib.h transparencyAttrib.I @@ -61,11 +63,13 @@ drawCullHandler.cxx \ qpgeomNode.cxx \ qplensNode.cxx \ + materialAttrib.cxx \ nodeChain.cxx \ nodeChainComponent.cxx \ pandaNode.cxx \ renderAttrib.cxx \ renderState.cxx \ + textureApplyAttrib.cxx \ textureAttrib.cxx \ transformState.cxx \ transparencyAttrib.cxx @@ -99,11 +103,13 @@ drawCullHandler.h drawCullHandler.I \ qpgeomNode.h qpgeomNode.I \ qplensNode.h qplensNode.I \ + materialAttrib.h materialAttrib.I \ nodeChain.h nodeChain.I \ nodeChainComponent.h nodeChainComponent.I \ pandaNode.h pandaNode.I \ renderAttrib.h renderAttrib.I \ renderState.h renderState.I \ + textureApplyAttrib.h textureApplyAttrib.I \ textureAttrib.h textureAttrib.I \ transformState.h transformState.I \ transparencyAttrib.h transparencyAttrib.I diff --git a/panda/src/pgraph/config_pgraph.cxx b/panda/src/pgraph/config_pgraph.cxx index d9029e0f7b..abf46e87b5 100644 --- a/panda/src/pgraph/config_pgraph.cxx +++ b/panda/src/pgraph/config_pgraph.cxx @@ -33,13 +33,14 @@ #include "depthWriteAttrib.h" #include "qpgeomNode.h" #include "qplensNode.h" +#include "materialAttrib.h" #include "nodeChain.h" #include "nodeChainComponent.h" #include "pandaNode.h" #include "renderAttrib.h" #include "renderState.h" +#include "textureApplyAttrib.h" #include "textureAttrib.h" -#include "colorAttrib.h" #include "transformState.h" #include "transparencyAttrib.h" @@ -89,13 +90,14 @@ init_libpgraph() { DepthWriteAttrib::init_type(); qpGeomNode::init_type(); qpLensNode::init_type(); + MaterialAttrib::init_type(); NodeChain::init_type(); NodeChainComponent::init_type(); PandaNode::init_type(); RenderAttrib::init_type(); RenderState::init_type(); + TextureApplyAttrib::init_type(); TextureAttrib::init_type(); - ColorAttrib::init_type(); TransformState::init_type(); TransparencyAttrib::init_type(); @@ -108,10 +110,11 @@ init_libpgraph() { DepthTestAttrib::register_with_read_factory(); DepthWriteAttrib::register_with_read_factory(); qpGeomNode::register_with_read_factory(); + MaterialAttrib::register_with_read_factory(); PandaNode::register_with_read_factory(); RenderState::register_with_read_factory(); + TextureApplyAttrib::register_with_read_factory(); TextureAttrib::register_with_read_factory(); - ColorAttrib::register_with_read_factory(); TransformState::register_with_read_factory(); TransparencyAttrib::register_with_read_factory(); } diff --git a/panda/src/pgraph/materialAttrib.I b/panda/src/pgraph/materialAttrib.I new file mode 100644 index 0000000000..4432dd7d84 --- /dev/null +++ b/panda/src/pgraph/materialAttrib.I @@ -0,0 +1,52 @@ +// Filename: materialAttrib.I +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::Constructor +// Access: Private +// Description: Use MaterialAttrib::make() to construct a new +// MaterialAttrib object. +//////////////////////////////////////////////////////////////////// +INLINE MaterialAttrib:: +MaterialAttrib() { +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::is_off +// Access: Published +// Description: Returns true if the MaterialAttrib is an 'off' +// MaterialAttrib, indicating that it should disable +// texturing. +//////////////////////////////////////////////////////////////////// +INLINE bool MaterialAttrib:: +is_off() const { + return _material == (const Material *)NULL; +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::get_material +// Access: Published +// Description: If the MaterialAttrib is not an 'off' MaterialAttrib, +// returns the material that is associated. Otherwise, +// return NULL. +//////////////////////////////////////////////////////////////////// +INLINE const Material *MaterialAttrib:: +get_material() const { + return _material; +} diff --git a/panda/src/pgraph/materialAttrib.cxx b/panda/src/pgraph/materialAttrib.cxx new file mode 100644 index 0000000000..510c992eed --- /dev/null +++ b/panda/src/pgraph/materialAttrib.cxx @@ -0,0 +1,196 @@ +// Filename: materialAttrib.cxx +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#include "materialAttrib.h" +#include "graphicsStateGuardianBase.h" +#include "bamReader.h" +#include "bamWriter.h" +#include "datagram.h" +#include "datagramIterator.h" + +TypeHandle MaterialAttrib::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::make +// Access: Published, Static +// Description: Constructs a new MaterialAttrib object suitable for +// rendering the indicated material onto geometry. +//////////////////////////////////////////////////////////////////// +CPT(RenderAttrib) MaterialAttrib:: +make(const Material *material) { + MaterialAttrib *attrib = new MaterialAttrib; + attrib->_material = material; + return return_new(attrib); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::make_off +// Access: Published, Static +// Description: Constructs a new MaterialAttrib object suitable for +// rendering unmateriald geometry. +//////////////////////////////////////////////////////////////////// +CPT(RenderAttrib) MaterialAttrib:: +make_off() { + MaterialAttrib *attrib = new MaterialAttrib; + return return_new(attrib); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::issue +// Access: Public, Virtual +// Description: Calls the appropriate method on the indicated GSG +// to issue the graphics commands appropriate to the +// given attribute. This is normally called +// (indirectly) only from +// GraphicsStateGuardian::set_state() or modify_state(). +//////////////////////////////////////////////////////////////////// +void MaterialAttrib:: +issue(GraphicsStateGuardianBase *gsg) const { + gsg->issue_material(this); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::output +// Access: Public, Virtual +// Description: +//////////////////////////////////////////////////////////////////// +void MaterialAttrib:: +output(ostream &out) const { + out << get_type() << ":"; + if (is_off()) { + out << "(off)"; + } else { + out << *_material; + } +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::compare_to_impl +// Access: Protected, Virtual +// Description: Intended to be overridden by derived MaterialAttrib +// types to return a unique number indicating whether +// this MaterialAttrib is equivalent to the other one. +// +// This should return 0 if the two MaterialAttrib objects +// are equivalent, a number less than zero if this one +// should be sorted before the other one, and a number +// greater than zero otherwise. +// +// This will only be called with two MaterialAttrib +// objects whose get_type() functions return the same. +//////////////////////////////////////////////////////////////////// +int MaterialAttrib:: +compare_to_impl(const RenderAttrib *other) const { + const MaterialAttrib *ta; + DCAST_INTO_R(ta, other, 0); + return (int)(_material - ta->_material); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::make_default_impl +// Access: Protected, Virtual +// Description: Intended to be overridden by derived MaterialAttrib +// types to specify what the default property for a +// MaterialAttrib of this type should be. +// +// This should return a newly-allocated MaterialAttrib of +// the same type that corresponds to whatever the +// standard default for this kind of MaterialAttrib is. +//////////////////////////////////////////////////////////////////// +RenderAttrib *MaterialAttrib:: +make_default_impl() const { + return new MaterialAttrib; +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::register_with_read_factory +// Access: Public, Static +// Description: Tells the BamReader how to create objects of type +// MaterialAttrib. +//////////////////////////////////////////////////////////////////// +void MaterialAttrib:: +register_with_read_factory() { + BamReader::get_factory()->register_factory(get_class_type(), make_from_bam); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::write_datagram +// Access: Public, Virtual +// Description: Writes the contents of this object to the datagram +// for shipping out to a Bam file. +//////////////////////////////////////////////////////////////////// +void MaterialAttrib:: +write_datagram(BamWriter *manager, Datagram &dg) { + RenderAttrib::write_datagram(manager, dg); + + manager->write_pointer(dg, _material); +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::complete_pointers +// Access: Public, Virtual +// Description: Receives an array of pointers, one for each time +// manager->read_pointer() was called in fillin(). +// Returns the number of pointers processed. +//////////////////////////////////////////////////////////////////// +int MaterialAttrib:: +complete_pointers(TypedWritable **p_list, BamReader *manager) { + int pi = RenderAttrib::complete_pointers(p_list, manager); + + TypedWritable *material = p_list[pi++]; + if (material != (TypedWritable *)NULL) { + _material = DCAST(Material, material); + } + + return pi; +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::make_from_bam +// Access: Protected, Static +// Description: This function is called by the BamReader's factory +// when a new object of type MaterialAttrib is encountered +// in the Bam file. It should create the MaterialAttrib +// and extract its information from the file. +//////////////////////////////////////////////////////////////////// +TypedWritable *MaterialAttrib:: +make_from_bam(const FactoryParams ¶ms) { + MaterialAttrib *attrib = new MaterialAttrib; + DatagramIterator scan; + BamReader *manager; + + parse_params(params, scan, manager); + attrib->fillin(scan, manager); + + return attrib; +} + +//////////////////////////////////////////////////////////////////// +// Function: MaterialAttrib::fillin +// Access: Protected +// Description: This internal function is called by make_from_bam to +// read in all of the relevant data from the BamFile for +// the new MaterialAttrib. +//////////////////////////////////////////////////////////////////// +void MaterialAttrib:: +fillin(DatagramIterator &scan, BamReader *manager) { + RenderAttrib::fillin(scan, manager); + + // Read the _material pointer. + manager->read_pointer(scan, this); +} diff --git a/panda/src/pgraph/materialAttrib.h b/panda/src/pgraph/materialAttrib.h new file mode 100644 index 0000000000..0b1d64e2b0 --- /dev/null +++ b/panda/src/pgraph/materialAttrib.h @@ -0,0 +1,86 @@ +// Filename: materialAttrib.h +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#ifndef MATERIALATTRIB_H +#define MATERIALATTRIB_H + +#include "pandabase.h" + +#include "renderAttrib.h" +#include "material.h" + +//////////////////////////////////////////////////////////////////// +// Class : MaterialAttrib +// Description : Indicates which, if any, material should be applied +// to geometry. The material is used primarily to +// control lighting effects, and isn't necessarily (or +// useful) in the absence of lighting. +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDA MaterialAttrib : public RenderAttrib { +private: + INLINE MaterialAttrib(); + +PUBLISHED: + static CPT(RenderAttrib) make(const Material *tex); + static CPT(RenderAttrib) make_off(); + + INLINE bool is_off() const; + INLINE const Material *get_material() const; + +public: + virtual void issue(GraphicsStateGuardianBase *gsg) const; + virtual void output(ostream &out) const; + +protected: + virtual int compare_to_impl(const RenderAttrib *other) const; + virtual RenderAttrib *make_default_impl() const; + +private: + CPT(Material) _material; + +public: + static void register_with_read_factory(); + virtual void write_datagram(BamWriter *manager, Datagram &dg); + virtual int complete_pointers(TypedWritable **plist, BamReader *manager); + +protected: + static TypedWritable *make_from_bam(const FactoryParams ¶ms); + void fillin(DatagramIterator &scan, BamReader *manager); + +public: + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + RenderAttrib::init_type(); + register_type(_type_handle, "MaterialAttrib", + RenderAttrib::get_class_type()); + } + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + +private: + static TypeHandle _type_handle; +}; + +#include "materialAttrib.I" + +#endif + diff --git a/panda/src/pgraph/pgraph_composite1.cxx b/panda/src/pgraph/pgraph_composite1.cxx index 4f08f644ac..83bc85f155 100644 --- a/panda/src/pgraph/pgraph_composite1.cxx +++ b/panda/src/pgraph/pgraph_composite1.cxx @@ -13,3 +13,5 @@ #include "cullHandler.cxx" #include "cullResult.cxx" #include "qpcullTraverser.cxx" +#include "cullableObject.cxx" + diff --git a/panda/src/pgraph/pgraph_composite2.cxx b/panda/src/pgraph/pgraph_composite2.cxx index d9a7bdf166..1538ab03eb 100644 --- a/panda/src/pgraph/pgraph_composite2.cxx +++ b/panda/src/pgraph/pgraph_composite2.cxx @@ -1,16 +1,17 @@ -#include "cullableObject.cxx" #include "decalAttrib.cxx" #include "depthTestAttrib.cxx" #include "depthWriteAttrib.cxx" #include "drawCullHandler.cxx" #include "qpgeomNode.cxx" #include "qplensNode.cxx" +#include "materialAttrib.cxx" #include "nodeChain.cxx" #include "nodeChainComponent.cxx" #include "pandaNode.cxx" #include "renderAttrib.cxx" #include "renderState.cxx" #include "test_pgraph.cxx" +#include "textureApplyAttrib.cxx" #include "textureAttrib.cxx" #include "transformState.cxx" #include "transparencyAttrib.cxx" diff --git a/panda/src/pgraph/textureApplyAttrib.I b/panda/src/pgraph/textureApplyAttrib.I new file mode 100644 index 0000000000..40605a454c --- /dev/null +++ b/panda/src/pgraph/textureApplyAttrib.I @@ -0,0 +1,40 @@ +// Filename: textureApplyAttrib.I +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::Constructor +// Access: Private +// Description: Use TextureApplyAttrib::make() to construct a new +// TextureApplyAttrib object. +//////////////////////////////////////////////////////////////////// +INLINE TextureApplyAttrib:: +TextureApplyAttrib(TextureApplyAttrib::Mode mode) : + _mode(mode) +{ +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::get_mode +// Access: Published +// Description: Returns the culling mode. +//////////////////////////////////////////////////////////////////// +INLINE TextureApplyAttrib::Mode TextureApplyAttrib:: +get_mode() const { + return _mode; +} diff --git a/panda/src/pgraph/textureApplyAttrib.cxx b/panda/src/pgraph/textureApplyAttrib.cxx new file mode 100644 index 0000000000..64897fe8b3 --- /dev/null +++ b/panda/src/pgraph/textureApplyAttrib.cxx @@ -0,0 +1,183 @@ +// Filename: textureApplyAttrib.cxx +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#include "textureApplyAttrib.h" +#include "graphicsStateGuardianBase.h" +#include "dcast.h" +#include "bamReader.h" +#include "bamWriter.h" +#include "datagram.h" +#include "datagramIterator.h" + +TypeHandle TextureApplyAttrib::_type_handle; + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::make +// Access: Published, Static +// Description: Constructs a new TextureApplyAttrib object that specifies +// how to cull geometry. By Panda convention, vertices +// are ordered counterclockwise when seen from the +// front, so the M_cull_clockwise will cull backfacing +// polygons. +//////////////////////////////////////////////////////////////////// +CPT(RenderAttrib) TextureApplyAttrib:: +make(TextureApplyAttrib::Mode mode) { + TextureApplyAttrib *attrib = new TextureApplyAttrib(mode); + return return_new(attrib); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::issue +// Access: Public, Virtual +// Description: Calls the appropriate method on the indicated GSG +// to issue the graphics commands appropriate to the +// given attribute. This is normally called +// (indirectly) only from +// GraphicsStateGuardian::set_state() or modify_state(). +//////////////////////////////////////////////////////////////////// +void TextureApplyAttrib:: +issue(GraphicsStateGuardianBase *gsg) const { + gsg->issue_texture_apply(this); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::output +// Access: Public, Virtual +// Description: +//////////////////////////////////////////////////////////////////// +void TextureApplyAttrib:: +output(ostream &out) const { + out << get_type() << ":"; + switch (get_mode()) { + case M_modulate: + out << "modulate"; + break; + + case M_decal: + out << "decal"; + break; + + case M_blend: + out << "blend"; + break; + + case M_replace: + out << "replace"; + break; + + case M_add: + out << "add"; + break; + } +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::compare_to_impl +// Access: Protected, Virtual +// Description: Intended to be overridden by derived TextureApplyAttrib +// types to return a unique number indicating whether +// this TextureApplyAttrib is equivalent to the other one. +// +// This should return 0 if the two TextureApplyAttrib objects +// are equivalent, a number less than zero if this one +// should be sorted before the other one, and a number +// greater than zero otherwise. +// +// This will only be called with two TextureApplyAttrib +// objects whose get_type() functions return the same. +//////////////////////////////////////////////////////////////////// +int TextureApplyAttrib:: +compare_to_impl(const RenderAttrib *other) const { + const TextureApplyAttrib *ta; + DCAST_INTO_R(ta, other, 0); + return (int)_mode - (int)ta->_mode; +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::make_default_impl +// Access: Protected, Virtual +// Description: Intended to be overridden by derived TextureApplyAttrib +// types to specify what the default property for a +// TextureApplyAttrib of this type should be. +// +// This should return a newly-allocated TextureApplyAttrib of +// the same type that corresponds to whatever the +// standard default for this kind of TextureApplyAttrib is. +//////////////////////////////////////////////////////////////////// +RenderAttrib *TextureApplyAttrib:: +make_default_impl() const { + return new TextureApplyAttrib; +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::register_with_read_factory +// Access: Public, Static +// Description: Tells the BamReader how to create objects of type +// TextureApplyAttrib. +//////////////////////////////////////////////////////////////////// +void TextureApplyAttrib:: +register_with_read_factory() { + BamReader::get_factory()->register_factory(get_class_type(), make_from_bam); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::write_datagram +// Access: Public, Virtual +// Description: Writes the contents of this object to the datagram +// for shipping out to a Bam file. +//////////////////////////////////////////////////////////////////// +void TextureApplyAttrib:: +write_datagram(BamWriter *manager, Datagram &dg) { + RenderAttrib::write_datagram(manager, dg); + + dg.add_int8(_mode); +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::make_from_bam +// Access: Protected, Static +// Description: This function is called by the BamReader's factory +// when a new object of type TextureApplyAttrib is encountered +// in the Bam file. It should create the TextureApplyAttrib +// and extract its information from the file. +//////////////////////////////////////////////////////////////////// +TypedWritable *TextureApplyAttrib:: +make_from_bam(const FactoryParams ¶ms) { + TextureApplyAttrib *attrib = new TextureApplyAttrib; + DatagramIterator scan; + BamReader *manager; + + parse_params(params, scan, manager); + attrib->fillin(scan, manager); + + return attrib; +} + +//////////////////////////////////////////////////////////////////// +// Function: TextureApplyAttrib::fillin +// Access: Protected +// Description: This internal function is called by make_from_bam to +// read in all of the relevant data from the BamFile for +// the new TextureApplyAttrib. +//////////////////////////////////////////////////////////////////// +void TextureApplyAttrib:: +fillin(DatagramIterator &scan, BamReader *manager) { + RenderAttrib::fillin(scan, manager); + + _mode = (Mode)scan.get_int8(); +} diff --git a/panda/src/pgraph/textureApplyAttrib.h b/panda/src/pgraph/textureApplyAttrib.h new file mode 100644 index 0000000000..91559206cd --- /dev/null +++ b/panda/src/pgraph/textureApplyAttrib.h @@ -0,0 +1,89 @@ +// Filename: textureApplyAttrib.h +// Created by: drose (04Mar02) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://www.panda3d.org/license.txt . +// +// To contact the maintainers of this program write to +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#ifndef TEXTUREAPPLYATTRIB_H +#define TEXTUREAPPLYATTRIB_H + +#include "pandabase.h" + +#include "renderAttrib.h" + +//////////////////////////////////////////////////////////////////// +// Class : TextureApplyAttrib +// Description : Specifies how textures are applied; specifically, how +// texture color modifies geometry color. +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDA TextureApplyAttrib : public RenderAttrib { +PUBLISHED: + enum Mode { + M_modulate, + M_decal, + M_blend, + M_replace, + M_add + }; + +private: + INLINE TextureApplyAttrib(Mode mode = M_modulate); + +PUBLISHED: + static CPT(RenderAttrib) make(Mode mode); + + INLINE Mode get_mode() const; + +public: + virtual void issue(GraphicsStateGuardianBase *gsg) const; + virtual void output(ostream &out) const; + +protected: + virtual int compare_to_impl(const RenderAttrib *other) const; + virtual RenderAttrib *make_default_impl() const; + +private: + Mode _mode; + +public: + static void register_with_read_factory(); + virtual void write_datagram(BamWriter *manager, Datagram &dg); + +protected: + static TypedWritable *make_from_bam(const FactoryParams ¶ms); + void fillin(DatagramIterator &scan, BamReader *manager); + +public: + static TypeHandle get_class_type() { + return _type_handle; + } + static void init_type() { + RenderAttrib::init_type(); + register_type(_type_handle, "TextureApplyAttrib", + RenderAttrib::get_class_type()); + } + virtual TypeHandle get_type() const { + return get_class_type(); + } + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + +private: + static TypeHandle _type_handle; +}; + +#include "textureApplyAttrib.I" + +#endif +