Panda3D
 All Classes Functions Variables Enumerations
sliderTable.cxx
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 &copy) :
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 &copy) {
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 &params) {
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 }
 All Classes Functions Variables Enumerations