diff --git a/panda/src/pgraph/renderAttribRegistry.I b/panda/src/pgraph/renderAttribRegistry.I deleted file mode 100644 index 6e119d7d6b..0000000000 --- a/panda/src/pgraph/renderAttribRegistry.I +++ /dev/null @@ -1,150 +0,0 @@ -// Filename: renderAttribRegistry.I -// Created by: drose (13Nov08) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_slot -// Access: Published -// Description: Returns the slot number assigned to the indicated -// TypeHandle, or 0 if no slot number has been assigned. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_slot(TypeHandle type_handle) const { - int type_index = type_handle.get_index(); - if (type_index >= (int)_slots_by_type.size()) { - return 0; - } - return _slots_by_type[type_index]; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_max_slots -// Access: Published -// Description: Returns the maximum number that any slot number is -// allowed to grow. Actually, this number will be one -// higher than the highest possible slot number. This -// puts an upper bound on the number of RenderAttrib -// slots that may be allocated, and allows other code to -// define an array of slots. -// -// This number will not change during the lifetime of -// the application. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_max_slots() const { - return _max_slots; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_num_slots -// Access: Published -// Description: Returns the number of RenderAttrib slots that have -// been allocated. This is one more than the highest -// slot number in use. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_num_slots() const { - return _registry.size(); -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_slot_type -// Access: Published -// Description: Returns the TypeHandle associated with slot n. -//////////////////////////////////////////////////////////////////// -INLINE TypeHandle RenderAttribRegistry:: -get_slot_type(int slot) const { - nassertr(slot >= 0 && slot < (int)_registry.size(), TypeHandle::none()); - return _registry[slot]._type; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_slot_sort -// Access: Published -// Description: Returns the sort number associated with slot n. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_slot_sort(int slot) const { - nassertr(slot >= 0 && slot < (int)_registry.size(), 0); - return _registry[slot]._sort; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_num_sorted_slots -// Access: Published -// Description: Returns the number of entries in the sorted_slots -// list. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_num_sorted_slots() const { - return _sorted_slots.size(); -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_sorted_slot -// Access: Published -// Description: Returns the nth slot in sorted order. By traversing -// this list, you will retrieve all the slot numbers in -// order according to their registered sort value. -//////////////////////////////////////////////////////////////////// -INLINE int RenderAttribRegistry:: -get_sorted_slot(int n) const { - nassertr(n >= 0 && n < (int)_sorted_slots.size(), 0); - return _sorted_slots[n]; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_global_ptr -// Access: Published, Static -// Description: -//////////////////////////////////////////////////////////////////// -INLINE RenderAttribRegistry *RenderAttribRegistry:: -get_global_ptr() { - if (_global_ptr == (RenderAttribRegistry *)NULL) { - init_global_ptr(); - } - return _global_ptr; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::quick_get_global_ptr -// Access: Public, Static -// Description: Returns the global_ptr without first ensuring it has -// been initialized. Only safe for code that knows it -// has already been initialized. -//////////////////////////////////////////////////////////////////// -INLINE RenderAttribRegistry *RenderAttribRegistry:: -quick_get_global_ptr() { - return _global_ptr; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::SortSlots::Constructor -// Access: Public -// Description: This is an STL function object for sorting the -// _sorted_slots list into order by slot sort number. -//////////////////////////////////////////////////////////////////// -INLINE RenderAttribRegistry::SortSlots:: -SortSlots(RenderAttribRegistry *reg) : _reg(reg) { -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::SortSlots::operator () -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -INLINE bool RenderAttribRegistry::SortSlots:: -operator () (int a, int b) const { - return _reg->get_slot_sort(a) < _reg->get_slot_sort(b); -} diff --git a/panda/src/pgraph/renderAttribRegistry.cxx b/panda/src/pgraph/renderAttribRegistry.cxx deleted file mode 100644 index 054817e029..0000000000 --- a/panda/src/pgraph/renderAttribRegistry.cxx +++ /dev/null @@ -1,168 +0,0 @@ -// Filename: renderAttribRegistry.cxx -// Created by: drose (13Nov08) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -#include "renderAttribRegistry.h" -#include "renderAttrib.h" - -RenderAttribRegistry *RenderAttribRegistry::_global_ptr; - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::Constructor -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -RenderAttribRegistry:: -RenderAttribRegistry() { - ConfigVariableInt max_attribs - ("max-attribs", SlotMask::get_max_num_bits(), - PRC_DESC("This specifies the maximum number of different RenderAttrib " - "types that may be defined at runtime. Normally you should " - "never need to change this, but if the default value is too " - "low for the number of attribs that Panda actually defines, " - "you may need to raise this number.")); - - // Assign this number once, at startup, and never change it again. - _max_slots = max((int)max_attribs, 1); - if (_max_slots > SlotMask::get_max_num_bits()) { - pgraph_cat->warning() - << "Value for max-attribs too large: cannot exceed " - << SlotMask::get_max_num_bits() - << " in this build. To raise this limit, change the typedef " - << "for SlotMask in renderAttribRegistry.h and recompile.\n"; - - _max_slots = SlotMask::get_max_num_bits(); - } - - // Reserve slot 0 for TypeHandle::none(), and for types that exceed - // max_slots. - RegistryNode node; - node._sort = 0; - node._make_default_func = NULL; - _registry.push_back(node); -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::Destructor -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -RenderAttribRegistry:: -~RenderAttribRegistry() { -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::register_slot -// Access: Public -// Description: Adds the indicated TypeHandle to the registry, if it -// is not there already, and returns a unique slot -// number in the range 0 < slot < get_max_slots(). -// -// The sort value is an arbitrary integer. In general, -// the RenderAttribs will be sorted in order from lowest -// sort value to highest sort value, when they are -// traversed via the get_num_sorted_slots() / -// get_sorted_slot() methods. This will be used to sort -// render states, so that heavier RenderAttribs are -// changed less frequently. In general, you should -// choose sort values such that the heavier -// RenderAttribs (that is, those which are more -// expensive to change) have lower sort values. -// -// The make_default_func pointer is a function that may -// be called to generate a default RenderAttrib to apply -// in the absence of any other attrib of this type. -// -// register_slot() is intended to be called at -// application start for each different RenderAttrib -// type in the system, to assign a different integer -// slot number to each one. -//////////////////////////////////////////////////////////////////// -int RenderAttribRegistry:: -register_slot(TypeHandle type_handle, int sort, - RenderAttribRegistry::MakeDefaultFunc *make_default_func) { - int type_index = type_handle.get_index(); - while (type_index >= (int)_slots_by_type.size()) { - _slots_by_type.push_back(0); - } - - if (_slots_by_type[type_index] != 0) { - // This type has already been registered. - return _slots_by_type[type_index]; - } - - int slot = (int)_registry.size(); - if (slot >= _max_slots) { - pgraph_cat->error() - << "Too many registered RenderAttribs; not registering " - << type_handle << "\n"; - nassertr(false, 0); - return 0; - } - - _slots_by_type[type_index] = slot; - - RegistryNode node; - node._type = type_handle; - node._sort = sort; - node._make_default_func = make_default_func; - _registry.push_back(node); - - _sorted_slots.push_back(slot); - ::sort(_sorted_slots.begin(), _sorted_slots.end(), SortSlots(this)); - - return slot; -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::set_slot_sort -// Access: Published -// Description: Changes the sort number associated with slot n. -//////////////////////////////////////////////////////////////////// -void RenderAttribRegistry:: -set_slot_sort(int slot, int sort) { - nassertv(slot >= 0 && slot < (int)_registry.size()); - _registry[slot]._sort = sort; - - // Re-sort the slot list. - _sorted_slots.clear(); - _sorted_slots.reserve(_registry.size() - 1); - for (int i = 1; i < (int)_registry.size(); ++i) { - _sorted_slots.push_back(i); - } - ::sort(_sorted_slots.begin(), _sorted_slots.end(), SortSlots(this)); -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::get_slot_default -// Access: Published -// Description: Returns the default RenderAttrib object associated -// with slot n. This is the attrib that should be -// applied in the absence of any other attrib of this -// type. -//////////////////////////////////////////////////////////////////// -CPT(RenderAttrib) RenderAttribRegistry:: -get_slot_default(int slot) const { - nassertr(slot >= 0 && slot < (int)_registry.size(), 0); - return (*_registry[slot]._make_default_func)(); -} - -//////////////////////////////////////////////////////////////////// -// Function: RenderAttribRegistry::init_global_ptr -// Access: Private, Static -// Description: -//////////////////////////////////////////////////////////////////// -void RenderAttribRegistry:: -init_global_ptr() { - _global_ptr = new RenderAttribRegistry; -} diff --git a/panda/src/pgraph/renderAttribRegistry.h b/panda/src/pgraph/renderAttribRegistry.h deleted file mode 100644 index ed13b4be61..0000000000 --- a/panda/src/pgraph/renderAttribRegistry.h +++ /dev/null @@ -1,102 +0,0 @@ -// Filename: renderAttribRegistry.h -// Created by: drose (13Nov08) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -#ifndef RENDERATTRIBREGISTRY_H -#define RENDERATTRIBREGISTRY_H - -#include "pandabase.h" -#include "typeHandle.h" -#include "vector_int.h" -#include "pointerTo.h" -#include "bitMask.h" - -class RenderAttrib; - -//////////////////////////////////////////////////////////////////// -// Class : RenderAttribRegistry -// Description : This class is used to associate each RenderAttrib -// with a different slot index at runtime, so we can -// store a list of RenderAttribs in the RenderState -// object, and very quickly look them up by type. -//////////////////////////////////////////////////////////////////// -class EXPCL_PANDA_PGRAPH RenderAttribRegistry { -private: - RenderAttribRegistry(); - ~RenderAttribRegistry(); - -public: - typedef CPT(RenderAttrib) MakeDefaultFunc(); - - // This typedef defines the native bitmask type for indicating which - // slots are present in a RenderState. It must be wide enough to - // allow room for all of the possible RenderAttribs that might - // register themselves. Presently, 32 bits is wide enough, but only - // barely; when we exceed this limit, we will need to go to a 64-bit - // type instead. It will be interesting to see whether a BitMask64 - // or a DoubleBitMask will be faster on a 32-bit machine. - typedef BitMask32 SlotMask; - - int register_slot(TypeHandle type_handle, int sort, - MakeDefaultFunc *make_default_func); - -PUBLISHED: - INLINE int get_slot(TypeHandle type_handle) const; - INLINE int get_max_slots() const; - - INLINE int get_num_slots() const; - INLINE TypeHandle get_slot_type(int slot) const; - INLINE int get_slot_sort(int slot) const; - void set_slot_sort(int slot, int sort); - CPT(RenderAttrib) get_slot_default(int slot) const; - - INLINE int get_num_sorted_slots() const; - INLINE int get_sorted_slot(int n) const; - - INLINE static RenderAttribRegistry *get_global_ptr(); - -public: - INLINE static RenderAttribRegistry *quick_get_global_ptr(); - -private: - static void init_global_ptr(); - -private: - int _max_slots; - - class SortSlots { - public: - INLINE SortSlots(RenderAttribRegistry *reg); - INLINE bool operator () (int a, int b) const; - RenderAttribRegistry *_reg; - }; - - class RegistryNode { - public: - TypeHandle _type; - int _sort; - MakeDefaultFunc *_make_default_func; - }; - typedef pvector Registry; - Registry _registry; - - vector_int _slots_by_type; - vector_int _sorted_slots; - - static RenderAttribRegistry *_global_ptr; -}; - -#include "renderAttribRegistry.I" - -#endif -