Panda3D

transformTable.cxx

00001 // Filename: transformTable.cxx
00002 // Created by:  drose (23Mar05)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) Carnegie Mellon University.  All rights reserved.
00008 //
00009 // All use of this software is subject to the terms of the revised BSD
00010 // license.  You should have received a copy of this license along
00011 // with this source code in a file named "LICENSE."
00012 //
00013 ////////////////////////////////////////////////////////////////////
00014 
00015 #include "transformTable.h"
00016 #include "bamReader.h"
00017 #include "bamWriter.h"
00018 
00019 TypeHandle TransformTable::_type_handle;
00020 
00021 ////////////////////////////////////////////////////////////////////
00022 //     Function: TransformTable::Constructor
00023 //       Access: Published
00024 //  Description: 
00025 ////////////////////////////////////////////////////////////////////
00026 TransformTable::
00027 TransformTable() :
00028   _is_registered(false)
00029 {
00030 }
00031 
00032 ////////////////////////////////////////////////////////////////////
00033 //     Function: TransformTable::Copy Constructor
00034 //       Access: Published
00035 //  Description: 
00036 ////////////////////////////////////////////////////////////////////
00037 TransformTable::
00038 TransformTable(const TransformTable &copy) :
00039   _is_registered(false),
00040   _transforms(copy._transforms)
00041 {
00042 }
00043 
00044 ////////////////////////////////////////////////////////////////////
00045 //     Function: TransformTable::Copy Assignment Operator
00046 //       Access: Published
00047 //  Description: 
00048 ////////////////////////////////////////////////////////////////////
00049 void TransformTable::
00050 operator = (const TransformTable &copy) {
00051   nassertv(!_is_registered);
00052   _transforms = copy._transforms;
00053 }
00054 
00055 ////////////////////////////////////////////////////////////////////
00056 //     Function: TransformTable::Destructor
00057 //       Access: Published, Virtual
00058 //  Description: 
00059 ////////////////////////////////////////////////////////////////////
00060 TransformTable::
00061 ~TransformTable() {
00062   if (_is_registered) {
00063     do_unregister();
00064   }
00065 }
00066 
00067 ////////////////////////////////////////////////////////////////////
00068 //     Function: TransformTable::set_transform
00069 //       Access: Published
00070 //  Description: Replaces the nth transform.  Only valid for
00071 //               unregistered tables.
00072 ////////////////////////////////////////////////////////////////////
00073 void TransformTable::
00074 set_transform(int n, const VertexTransform *transform) {
00075   nassertv(!_is_registered);
00076   nassertv(n >= 0 && n < (int)_transforms.size());
00077   _transforms[n] = transform;
00078 }
00079 
00080 ////////////////////////////////////////////////////////////////////
00081 //     Function: TransformTable::remove_transform
00082 //       Access: Published
00083 //  Description: Removes the nth transform.  Only valid for
00084 //               unregistered tables.
00085 ////////////////////////////////////////////////////////////////////
00086 void TransformTable::
00087 remove_transform(int n) {
00088   nassertv(!_is_registered);
00089   nassertv(n >= 0 && n < (int)_transforms.size());
00090   _transforms.erase(_transforms.begin() + n);
00091 }
00092 
00093 ////////////////////////////////////////////////////////////////////
00094 //     Function: TransformTable::add_transform
00095 //       Access: Published
00096 //  Description: Adds a new transform to the table and returns the
00097 //               index number of the new transform.  Only valid for
00098 //               unregistered tables.
00099 //
00100 //               This does not automatically uniquify the pointer; if
00101 //               the transform is already present in the table, it
00102 //               will be added twice.
00103 ////////////////////////////////////////////////////////////////////
00104 int TransformTable::
00105 add_transform(const VertexTransform *transform) {
00106   nassertr(!_is_registered, -1);
00107   int new_index = (int)_transforms.size();
00108   _transforms.push_back(transform);
00109   return new_index;
00110 }
00111 
00112 ////////////////////////////////////////////////////////////////////
00113 //     Function: TransformTable::write
00114 //       Access: Published
00115 //  Description: 
00116 ////////////////////////////////////////////////////////////////////
00117 void TransformTable::
00118 write(ostream &out) const {
00119   for (size_t i = 0; i < _transforms.size(); ++i) {
00120     out << i << ". " << *_transforms[i] << "\n";
00121   }
00122 }
00123 
00124 ////////////////////////////////////////////////////////////////////
00125 //     Function: TransformTable::do_register
00126 //       Access: Private
00127 //  Description: Called internally when the table is registered.
00128 ////////////////////////////////////////////////////////////////////
00129 void TransformTable::
00130 do_register() {
00131   nassertv(!_is_registered);
00132 
00133   Transforms::iterator ti;
00134   for (ti = _transforms.begin(); ti != _transforms.end(); ++ti) {
00135     VertexTransform *transform = (VertexTransform *)(*ti).p();
00136     bool inserted = transform->_tables.insert(this).second;
00137     nassertv(inserted);
00138   }
00139   _is_registered = true;
00140 }
00141 
00142 ////////////////////////////////////////////////////////////////////
00143 //     Function: TransformTable::do_unregister
00144 //       Access: Private
00145 //  Description: Called internally when the table is unregistered
00146 //               (i.e. right before destruction).
00147 ////////////////////////////////////////////////////////////////////
00148 void TransformTable::
00149 do_unregister() {
00150   nassertv(_is_registered);
00151 
00152   Transforms::iterator ti;
00153   for (ti = _transforms.begin(); ti != _transforms.end(); ++ti) {
00154     VertexTransform *transform = (VertexTransform *)(*ti).p();
00155     transform->_tables.erase(this);
00156   }
00157   _is_registered = false;
00158 }
00159 
00160 ////////////////////////////////////////////////////////////////////
00161 //     Function: TransformTable::register_with_read_factory
00162 //       Access: Public, Static
00163 //  Description: Tells the BamReader how to create objects of type
00164 //               TransformTable.
00165 ////////////////////////////////////////////////////////////////////
00166 void TransformTable::
00167 register_with_read_factory() {
00168   BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
00169 }
00170 
00171 ////////////////////////////////////////////////////////////////////
00172 //     Function: TransformTable::write_datagram
00173 //       Access: Public, Virtual
00174 //  Description: Writes the contents of this object to the datagram
00175 //               for shipping out to a Bam file.
00176 ////////////////////////////////////////////////////////////////////
00177 void TransformTable::
00178 write_datagram(BamWriter *manager, Datagram &dg) {
00179   TypedWritableReferenceCount::write_datagram(manager, dg);
00180 
00181   dg.add_uint16(_transforms.size());
00182   for (Transforms::const_iterator ti = _transforms.begin();
00183        ti != _transforms.end();
00184        ++ti) {
00185     manager->write_pointer(dg, *ti);
00186   }
00187 
00188   manager->write_cdata(dg, _cycler);
00189 }
00190 
00191 ////////////////////////////////////////////////////////////////////
00192 //     Function: TransformTable::complete_pointers
00193 //       Access: Public, Virtual
00194 //  Description: Receives an array of pointers, one for each time
00195 //               manager->read_pointer() was called in fillin().
00196 //               Returns the number of pointers processed.
00197 ////////////////////////////////////////////////////////////////////
00198 int TransformTable::
00199 complete_pointers(TypedWritable **p_list, BamReader *manager) {
00200   int pi = TypedWritableReferenceCount::complete_pointers(p_list, manager);
00201 
00202   for (Transforms::iterator ti = _transforms.begin();
00203        ti != _transforms.end();
00204        ++ti) {
00205     (*ti) = DCAST(VertexTransform, p_list[pi++]);
00206   }
00207 
00208   return pi;
00209 }
00210 
00211 ////////////////////////////////////////////////////////////////////
00212 //     Function: TransformTable::make_from_bam
00213 //       Access: Protected, Static
00214 //  Description: This function is called by the BamReader's factory
00215 //               when a new object of type TransformTable is encountered
00216 //               in the Bam file.  It should create the TransformTable
00217 //               and extract its information from the file.
00218 ////////////////////////////////////////////////////////////////////
00219 TypedWritable *TransformTable::
00220 make_from_bam(const FactoryParams &params) {
00221   TransformTable *object = new TransformTable;
00222   DatagramIterator scan;
00223   BamReader *manager;
00224 
00225   parse_params(params, scan, manager);
00226   object->fillin(scan, manager);
00227 
00228   return object;
00229 }
00230 
00231 ////////////////////////////////////////////////////////////////////
00232 //     Function: TransformTable::fillin
00233 //       Access: Protected
00234 //  Description: This internal function is called by make_from_bam to
00235 //               read in all of the relevant data from the BamFile for
00236 //               the new TransformTable.
00237 ////////////////////////////////////////////////////////////////////
00238 void TransformTable::
00239 fillin(DatagramIterator &scan, BamReader *manager) {
00240   TypedWritableReferenceCount::fillin(scan, manager);
00241 
00242   size_t num_transforms = scan.get_uint16();
00243   _transforms.reserve(num_transforms);
00244   for (size_t i = 0; i < num_transforms; ++i) {
00245     manager->read_pointer(scan);
00246     _transforms.push_back(NULL);
00247   }
00248 
00249   manager->read_cdata(scan, _cycler);
00250 }
00251 
00252 ////////////////////////////////////////////////////////////////////
00253 //     Function: TransformTable::CData::make_copy
00254 //       Access: Public, Virtual
00255 //  Description:
00256 ////////////////////////////////////////////////////////////////////
00257 CycleData *TransformTable::CData::
00258 make_copy() const {
00259   return new CData(*this);
00260 }
00261 
00262 ////////////////////////////////////////////////////////////////////
00263 //     Function: TransformTable::CData::write_datagram
00264 //       Access: Public, Virtual
00265 //  Description: Writes the contents of this object to the datagram
00266 //               for shipping out to a Bam file.
00267 ////////////////////////////////////////////////////////////////////
00268 void TransformTable::CData::
00269 write_datagram(BamWriter *manager, Datagram &dg) const {
00270 }
00271 
00272 ////////////////////////////////////////////////////////////////////
00273 //     Function: TransformTable::CData::fillin
00274 //       Access: Public, Virtual
00275 //  Description: This internal function is called by make_from_bam to
00276 //               read in all of the relevant data from the BamFile for
00277 //               the new TransformTable.
00278 ////////////////////////////////////////////////////////////////////
00279 void TransformTable::CData::
00280 fillin(DatagramIterator &scan, BamReader *manager) {
00281   Thread *current_thread = Thread::get_current_thread();
00282   _modified = VertexTransform::get_next_modified(current_thread);
00283 }
 All Classes Functions Variables Enumerations