Panda3D
|
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 ©) : 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 ©) { 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 ¶ms) { 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 }