remove accidentally added files

panda/src/pgraph/renderAttribRegistry.I

@@ -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);
-}

panda/src/pgraph/renderAttribRegistry.cxx

@@ -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;
-}

panda/src/pgraph/renderAttribRegistry.h

@@ -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<BitMask32> 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<RegistryNode> Registry;
-  Registry _registry;
-
-  vector_int _slots_by_type;
-  vector_int _sorted_slots;
-
-  static RenderAttribRegistry *_global_ptr;
-};
-
-#include "renderAttribRegistry.I"
-
-#endif
-