Panda3D
|
00001 // Filename: sliderTable.cxx 00002 // Created by: drose (28Mar05) 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 "sliderTable.h" 00016 #include "bamReader.h" 00017 #include "bamWriter.h" 00018 #include "vertexTransform.h" 00019 00020 SparseArray SliderTable::_empty_array; 00021 TypeHandle SliderTable::_type_handle; 00022 00023 //////////////////////////////////////////////////////////////////// 00024 // Function: SliderTable::Constructor 00025 // Access: Published 00026 // Description: 00027 //////////////////////////////////////////////////////////////////// 00028 SliderTable:: 00029 SliderTable() : 00030 _is_registered(false) 00031 { 00032 } 00033 00034 //////////////////////////////////////////////////////////////////// 00035 // Function: SliderTable::Copy Constructor 00036 // Access: Published 00037 // Description: 00038 //////////////////////////////////////////////////////////////////// 00039 SliderTable:: 00040 SliderTable(const SliderTable ©) : 00041 _is_registered(false), 00042 _sliders(copy._sliders), 00043 _sliders_by_name(copy._sliders_by_name) 00044 { 00045 } 00046 00047 //////////////////////////////////////////////////////////////////// 00048 // Function: SliderTable::Copy Assignment Operator 00049 // Access: Published 00050 // Description: 00051 //////////////////////////////////////////////////////////////////// 00052 void SliderTable:: 00053 operator = (const SliderTable ©) { 00054 nassertv(!_is_registered); 00055 _sliders = copy._sliders; 00056 _sliders_by_name = copy._sliders_by_name; 00057 } 00058 00059 //////////////////////////////////////////////////////////////////// 00060 // Function: SliderTable::Destructor 00061 // Access: Published, Virtual 00062 // Description: 00063 //////////////////////////////////////////////////////////////////// 00064 SliderTable:: 00065 ~SliderTable() { 00066 if (_is_registered) { 00067 do_unregister(); 00068 } 00069 } 00070 00071 //////////////////////////////////////////////////////////////////// 00072 // Function: SliderTable::set_slider 00073 // Access: Published 00074 // Description: Replaces the nth slider. Only valid for 00075 // unregistered tables. 00076 //////////////////////////////////////////////////////////////////// 00077 void SliderTable:: 00078 set_slider(int n, const VertexSlider *slider) { 00079 nassertv(!_is_registered); 00080 nassertv(n >= 0 && n < (int)_sliders.size()); 00081 00082 if (_sliders[n]._slider->get_name() != slider->get_name()) { 00083 _sliders_by_name[_sliders[n]._slider->get_name()].clear_bit(n); 00084 _sliders_by_name[slider->get_name()].set_bit(n); 00085 } 00086 00087 _sliders[n]._slider = slider; 00088 } 00089 00090 //////////////////////////////////////////////////////////////////// 00091 // Function: SliderTable::set_slider_rows 00092 // Access: Published 00093 // Description: Replaces the rows affected by the nth slider. Only 00094 // valid for unregistered tables. 00095 //////////////////////////////////////////////////////////////////// 00096 void SliderTable:: 00097 set_slider_rows(int n, const SparseArray &rows) { 00098 // We don't actually enforce the registration requirement, since 00099 // gee, it doesn't actually matter here; and the GeomVertexData 00100 // needs to be able to change the SparseArrays in the bam reader. 00101 // nassertv(!_is_registered); 00102 nassertv(n >= 0 && n < (int)_sliders.size()); 00103 00104 _sliders[n]._rows = rows; 00105 } 00106 00107 //////////////////////////////////////////////////////////////////// 00108 // Function: SliderTable::remove_slider 00109 // Access: Published 00110 // Description: Removes the nth slider. Only valid for 00111 // unregistered tables. 00112 //////////////////////////////////////////////////////////////////// 00113 void SliderTable:: 00114 remove_slider(int n) { 00115 nassertv(!_is_registered); 00116 nassertv(n >= 0 && n < (int)_sliders.size()); 00117 00118 _sliders_by_name[_sliders[n]._slider->get_name()].clear_bit(n); 00119 _sliders.erase(_sliders.begin() + n); 00120 } 00121 00122 //////////////////////////////////////////////////////////////////// 00123 // Function: SliderTable::add_slider 00124 // Access: Published 00125 // Description: Adds a new slider to the table, and returns the 00126 // index number of the new slider. Only valid for 00127 // unregistered tables. 00128 //////////////////////////////////////////////////////////////////// 00129 int SliderTable:: 00130 add_slider(const VertexSlider *slider, const SparseArray &rows) { 00131 nassertr(!_is_registered, -1); 00132 00133 int new_index = (int)_sliders.size(); 00134 00135 SliderDef slider_def; 00136 slider_def._slider = slider; 00137 slider_def._rows = rows; 00138 _sliders.push_back(slider_def); 00139 _sliders_by_name[slider->get_name()].set_bit(new_index); 00140 00141 return new_index; 00142 } 00143 00144 //////////////////////////////////////////////////////////////////// 00145 // Function: SliderTable::write 00146 // Access: Published 00147 // Description: 00148 //////////////////////////////////////////////////////////////////// 00149 void SliderTable:: 00150 write(ostream &out) const { 00151 for (size_t i = 0; i < _sliders.size(); ++i) { 00152 out << i << ". " << *_sliders[i]._slider << " " 00153 << _sliders[i]._rows << "\n"; 00154 } 00155 } 00156 00157 //////////////////////////////////////////////////////////////////// 00158 // Function: SliderTable::do_register 00159 // Access: Private 00160 // Description: Called internally when the table is registered. 00161 //////////////////////////////////////////////////////////////////// 00162 void SliderTable:: 00163 do_register() { 00164 nassertv(!_is_registered); 00165 00166 Sliders::iterator si; 00167 for (si = _sliders.begin(); si != _sliders.end(); ++si) { 00168 const VertexSlider *slider = (*si)._slider; 00169 bool inserted = ((VertexSlider *)slider)->_tables.insert(this).second; 00170 nassertv(inserted); 00171 } 00172 _is_registered = true; 00173 } 00174 00175 //////////////////////////////////////////////////////////////////// 00176 // Function: SliderTable::do_unregister 00177 // Access: Private 00178 // Description: Called internally when the table is unregistered 00179 // (i.e. right before destruction). 00180 //////////////////////////////////////////////////////////////////// 00181 void SliderTable:: 00182 do_unregister() { 00183 nassertv(_is_registered); 00184 00185 Sliders::iterator si; 00186 for (si = _sliders.begin(); si != _sliders.end(); ++si) { 00187 const VertexSlider *slider = (*si)._slider; 00188 ((VertexSlider *)slider)->_tables.erase(this); 00189 } 00190 _is_registered = false; 00191 } 00192 00193 //////////////////////////////////////////////////////////////////// 00194 // Function: SliderTable::register_with_read_factory 00195 // Access: Public, Static 00196 // Description: Tells the BamReader how to create objects of type 00197 // SliderTable. 00198 //////////////////////////////////////////////////////////////////// 00199 void SliderTable:: 00200 register_with_read_factory() { 00201 BamReader::get_factory()->register_factory(get_class_type(), make_from_bam); 00202 } 00203 00204 //////////////////////////////////////////////////////////////////// 00205 // Function: SliderTable::write_datagram 00206 // Access: Public, Virtual 00207 // Description: Writes the contents of this object to the datagram 00208 // for shipping out to a Bam file. 00209 //////////////////////////////////////////////////////////////////// 00210 void SliderTable:: 00211 write_datagram(BamWriter *manager, Datagram &dg) { 00212 TypedWritable::write_datagram(manager, dg); 00213 00214 dg.add_uint16(_sliders.size()); 00215 Sliders::const_iterator si; 00216 for (si = _sliders.begin(); si != _sliders.end(); ++si) { 00217 manager->write_pointer(dg, (*si)._slider->get_name()); 00218 manager->write_pointer(dg, (*si)._slider); 00219 (*si)._rows.write_datagram(manager, dg); 00220 } 00221 00222 manager->write_cdata(dg, _cycler); 00223 } 00224 00225 //////////////////////////////////////////////////////////////////// 00226 // Function: SliderTable::complete_pointers 00227 // Access: Public, Virtual 00228 // Description: Receives an array of pointers, one for each time 00229 // manager->read_pointer() was called in fillin(). 00230 // Returns the number of pointers processed. 00231 //////////////////////////////////////////////////////////////////// 00232 int SliderTable:: 00233 complete_pointers(TypedWritable **p_list, BamReader *manager) { 00234 int pi = TypedWritableReferenceCount::complete_pointers(p_list, manager); 00235 00236 for (size_t n = 0; n < _sliders.size(); ++n) { 00237 CPT(InternalName) name = DCAST(InternalName, p_list[pi++]); 00238 PT(VertexSlider) slider = DCAST(VertexSlider, p_list[pi++]); 00239 00240 _sliders[n]._slider = slider; 00241 _sliders_by_name[name].set_bit(n); 00242 } 00243 00244 return pi; 00245 } 00246 00247 //////////////////////////////////////////////////////////////////// 00248 // Function: SliderTable::make_from_bam 00249 // Access: Protected, Static 00250 // Description: This function is called by the BamReader's factory 00251 // when a new object of type SliderTable is encountered 00252 // in the Bam file. It should create the SliderTable 00253 // and extract its information from the file. 00254 //////////////////////////////////////////////////////////////////// 00255 TypedWritable *SliderTable:: 00256 make_from_bam(const FactoryParams ¶ms) { 00257 SliderTable *object = new SliderTable; 00258 DatagramIterator scan; 00259 BamReader *manager; 00260 00261 parse_params(params, scan, manager); 00262 object->fillin(scan, manager); 00263 00264 return object; 00265 } 00266 00267 //////////////////////////////////////////////////////////////////// 00268 // Function: SliderTable::fillin 00269 // Access: Protected 00270 // Description: This internal function is called by make_from_bam to 00271 // read in all of the relevant data from the BamFile for 00272 // the new SliderTable. 00273 //////////////////////////////////////////////////////////////////// 00274 void SliderTable:: 00275 fillin(DatagramIterator &scan, BamReader *manager) { 00276 TypedWritable::fillin(scan, manager); 00277 00278 size_t num_sliders = scan.get_uint16(); 00279 _sliders.reserve(num_sliders); 00280 for (size_t i = 0; i < num_sliders; ++i) { 00281 manager->read_pointer(scan); 00282 manager->read_pointer(scan); 00283 _sliders.push_back(SliderDef()); 00284 if (manager->get_file_minor_ver() >= 7) { 00285 _sliders[i]._rows.read_datagram(scan, manager); 00286 } else { 00287 // In this case, for bam files prior to 6.7, we must define the 00288 // SparseArray with the full number of vertices. This is done 00289 // in GeomVertexData::complete_pointers(). 00290 } 00291 } 00292 00293 manager->read_cdata(scan, _cycler); 00294 } 00295 00296 //////////////////////////////////////////////////////////////////// 00297 // Function: SliderTable::CData::make_copy 00298 // Access: Public, Virtual 00299 // Description: 00300 //////////////////////////////////////////////////////////////////// 00301 CycleData *SliderTable::CData:: 00302 make_copy() const { 00303 return new CData(*this); 00304 } 00305 00306 //////////////////////////////////////////////////////////////////// 00307 // Function: SliderTable::CData::write_datagram 00308 // Access: Public, Virtual 00309 // Description: Writes the contents of this object to the datagram 00310 // for shipping out to a Bam file. 00311 //////////////////////////////////////////////////////////////////// 00312 void SliderTable::CData:: 00313 write_datagram(BamWriter *manager, Datagram &dg) const { 00314 } 00315 00316 //////////////////////////////////////////////////////////////////// 00317 // Function: SliderTable::CData::fillin 00318 // Access: Public, Virtual 00319 // Description: This internal function is called by make_from_bam to 00320 // read in all of the relevant data from the BamFile for 00321 // the new SliderTable. 00322 //////////////////////////////////////////////////////////////////// 00323 void SliderTable::CData:: 00324 fillin(DatagramIterator &scan, BamReader *manager) { 00325 Thread *current_thread = Thread::get_current_thread(); 00326 _modified = VertexTransform::get_next_modified(current_thread); 00327 }