mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-04 10:54:24 -04:00
remove accidentally added files
This commit is contained in:
David Rose
parent
c8d3b8dac8
commit
15b1f49c12
@ -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);
|
|
||||||
}
|
|
||||||
@ -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;
|
|
||||||
}
|
|
||||||
@ -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
|
|
||||||
|
|
||||||
Loading…
x
Reference in New Issue
Block a user