Panda3D
|
00001 // Filename: cycleDataStageWriter.I 00002 // Created by: drose (06Feb06) 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 #ifndef CPPPARSER 00016 00017 #ifdef DO_PIPELINING 00018 // This is the implementation for full support of pipelining (as well 00019 // as the sanity-check only implementation). 00020 00021 //////////////////////////////////////////////////////////////////// 00022 // Function: CycleDataStageWriter::Constructor (full) 00023 // Access: Public 00024 // Description: 00025 //////////////////////////////////////////////////////////////////// 00026 template<class CycleDataType> 00027 INLINE CycleDataStageWriter<CycleDataType>:: 00028 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage, 00029 Thread *current_thread) : 00030 _cycler(&cycler), 00031 _current_thread(current_thread), 00032 _stage(stage) 00033 { 00034 _pointer = _cycler->write_stage(_stage, _current_thread); 00035 nassertv(_pointer != (CycleDataType *)NULL); 00036 } 00037 00038 //////////////////////////////////////////////////////////////////// 00039 // Function: CycleDataStageWriter::Constructor (full) 00040 // Access: Public 00041 // Description: 00042 //////////////////////////////////////////////////////////////////// 00043 template<class CycleDataType> 00044 INLINE CycleDataStageWriter<CycleDataType>:: 00045 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage, 00046 bool force_to_0, Thread *current_thread) : 00047 _cycler(&cycler), 00048 _current_thread(current_thread), 00049 _stage(stage) 00050 { 00051 _pointer = _cycler->write_stage_upstream(_stage, force_to_0, _current_thread); 00052 nassertv(_pointer != (CycleDataType *)NULL); 00053 } 00054 00055 //////////////////////////////////////////////////////////////////// 00056 // Function: CycleDataStageWriter::Copy Constructor (full) 00057 // Access: Public 00058 // Description: 00059 //////////////////////////////////////////////////////////////////// 00060 template<class CycleDataType> 00061 INLINE CycleDataStageWriter<CycleDataType>:: 00062 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> ©) : 00063 _cycler(copy._cycler), 00064 _current_thread(copy._current_thread), 00065 _pointer(copy._pointer), 00066 _stage(copy._stage) 00067 { 00068 nassertv(_pointer != (CycleDataType *)NULL); 00069 _cycler->increment_write(_pointer); 00070 } 00071 00072 //////////////////////////////////////////////////////////////////// 00073 // Function: CycleDataStageWriter::Copy Assignment (full) 00074 // Access: Public 00075 // Description: 00076 //////////////////////////////////////////////////////////////////// 00077 template<class CycleDataType> 00078 INLINE void CycleDataStageWriter<CycleDataType>:: 00079 operator = (const CycleDataStageWriter<CycleDataType> ©) { 00080 nassertv(_pointer == (CycleDataType *)NULL); 00081 nassertv(_current_thread == copy._current_thread); 00082 00083 _cycler = copy._cycler; 00084 _pointer = copy._pointer; 00085 _stage = copy._stage; 00086 00087 nassertv(_pointer != (CycleDataType *)NULL); 00088 _cycler->increment_write(_pointer); 00089 } 00090 00091 //////////////////////////////////////////////////////////////////// 00092 // Function: CycleDataStageWriter::Constructor (full) 00093 // Access: Public 00094 // Description: This flavor of the constructor elevates the pointer 00095 // from the CycleDataLockedStageReader from a read to a write 00096 // pointer (and invalidates the reader). 00097 //////////////////////////////////////////////////////////////////// 00098 template<class CycleDataType> 00099 INLINE CycleDataStageWriter<CycleDataType>:: 00100 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage, 00101 CycleDataLockedStageReader<CycleDataType> &take_from) : 00102 _cycler(&cycler), 00103 _current_thread(take_from.get_current_thread()), 00104 _stage(stage) 00105 { 00106 _pointer = _cycler->elevate_read_stage(_stage, take_from.take_pointer(), 00107 _current_thread); 00108 } 00109 00110 //////////////////////////////////////////////////////////////////// 00111 // Function: CycleDataStageWriter::Constructor (full) 00112 // Access: Public 00113 // Description: This flavor of the constructor elevates the pointer 00114 // from the CycleDataLockedStageReader from a read to a write 00115 // pointer (and invalidates the reader). 00116 //////////////////////////////////////////////////////////////////// 00117 template<class CycleDataType> 00118 INLINE CycleDataStageWriter<CycleDataType>:: 00119 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage, 00120 CycleDataLockedStageReader<CycleDataType> &take_from, 00121 bool force_to_0) : 00122 _cycler(&cycler), 00123 _current_thread(take_from.get_current_thread()), 00124 _stage(stage) 00125 { 00126 _pointer = _cycler->elevate_read_stage_upstream(_stage, take_from.take_pointer(), 00127 force_to_0, _current_thread); 00128 } 00129 00130 //////////////////////////////////////////////////////////////////// 00131 // Function: CycleDataStageWriter::Destructor (full) 00132 // Access: Public 00133 // Description: 00134 //////////////////////////////////////////////////////////////////// 00135 template<class CycleDataType> 00136 INLINE CycleDataStageWriter<CycleDataType>:: 00137 ~CycleDataStageWriter() { 00138 if (_pointer != (CycleDataType *)NULL) { 00139 _cycler->release_write_stage(_stage, _pointer); 00140 } 00141 } 00142 00143 //////////////////////////////////////////////////////////////////// 00144 // Function: CycleDataStageWriter::operator -> (full) 00145 // Access: Public 00146 // Description: This provides an indirect member access to the actual 00147 // CycleData data. 00148 //////////////////////////////////////////////////////////////////// 00149 template<class CycleDataType> 00150 INLINE CycleDataType *CycleDataStageWriter<CycleDataType>:: 00151 operator -> () { 00152 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat()); 00153 return _pointer; 00154 } 00155 00156 //////////////////////////////////////////////////////////////////// 00157 // Function: CycleDataStageWriter::operator -> (full) 00158 // Access: Public 00159 // Description: This provides an indirect member access to the actual 00160 // CycleData data. 00161 //////////////////////////////////////////////////////////////////// 00162 template<class CycleDataType> 00163 INLINE const CycleDataType *CycleDataStageWriter<CycleDataType>:: 00164 operator -> () const { 00165 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat()); 00166 return _pointer; 00167 } 00168 00169 //////////////////////////////////////////////////////////////////// 00170 // Function: CycleDataStageWriter::Typecast pointer (full) 00171 // Access: Public 00172 // Description: This allows the CycleDataStageWriter to be passed to any 00173 // function that expects a CycleDataType pointer. 00174 //////////////////////////////////////////////////////////////////// 00175 template<class CycleDataType> 00176 INLINE CycleDataStageWriter<CycleDataType>:: 00177 operator CycleDataType * () { 00178 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat()); 00179 return _pointer; 00180 } 00181 00182 //////////////////////////////////////////////////////////////////// 00183 // Function: CycleDataStageWriter::get_current_thread (full) 00184 // Access: Public 00185 // Description: Returns the Thread pointer of the currently-executing 00186 // thread, as passed to the constructor of this object. 00187 //////////////////////////////////////////////////////////////////// 00188 template<class CycleDataType> 00189 INLINE Thread *CycleDataStageWriter<CycleDataType>:: 00190 get_current_thread() const { 00191 return _current_thread; 00192 } 00193 00194 #else // !DO_PIPELINING 00195 // This is the trivial, do-nothing implementation. 00196 00197 //////////////////////////////////////////////////////////////////// 00198 // Function: CycleDataStageWriter::Constructor (trivial) 00199 // Access: Public 00200 // Description: 00201 //////////////////////////////////////////////////////////////////// 00202 template<class CycleDataType> 00203 INLINE CycleDataStageWriter<CycleDataType>:: 00204 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int, Thread *) { 00205 _pointer = cycler.cheat(); 00206 } 00207 00208 //////////////////////////////////////////////////////////////////// 00209 // Function: CycleDataStageWriter::Constructor (trivial) 00210 // Access: Public 00211 // Description: 00212 //////////////////////////////////////////////////////////////////// 00213 template<class CycleDataType> 00214 INLINE CycleDataStageWriter<CycleDataType>:: 00215 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int, bool, Thread *) { 00216 _pointer = cycler.cheat(); 00217 } 00218 00219 //////////////////////////////////////////////////////////////////// 00220 // Function: CycleDataStageWriter::Copy Constructor (trivial) 00221 // Access: Public 00222 // Description: 00223 //////////////////////////////////////////////////////////////////// 00224 template<class CycleDataType> 00225 INLINE CycleDataStageWriter<CycleDataType>:: 00226 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> ©) : 00227 _pointer(copy._pointer) 00228 { 00229 } 00230 00231 //////////////////////////////////////////////////////////////////// 00232 // Function: CycleDataStageWriter::Copy Assignment (trivial) 00233 // Access: Public 00234 // Description: 00235 //////////////////////////////////////////////////////////////////// 00236 template<class CycleDataType> 00237 INLINE void CycleDataStageWriter<CycleDataType>:: 00238 operator = (const CycleDataStageWriter<CycleDataType> ©) { 00239 _pointer = copy._pointer; 00240 } 00241 00242 //////////////////////////////////////////////////////////////////// 00243 // Function: CycleDataStageWriter::Constructor (trivial) 00244 // Access: Public 00245 // Description: This flavor of the constructor elevates the pointer 00246 // from the CycleDataLockedStageReader from a read to a write 00247 // pointer (and invalidates the reader). 00248 //////////////////////////////////////////////////////////////////// 00249 template<class CycleDataType> 00250 INLINE CycleDataStageWriter<CycleDataType>:: 00251 CycleDataStageWriter(PipelineCycler<CycleDataType> &, int, 00252 CycleDataLockedStageReader<CycleDataType> &take_from) : 00253 _pointer((CycleDataType *)take_from.take_pointer()) 00254 { 00255 } 00256 00257 //////////////////////////////////////////////////////////////////// 00258 // Function: CycleDataStageWriter::Constructor (trivial) 00259 // Access: Public 00260 // Description: This flavor of the constructor elevates the pointer 00261 // from the CycleDataLockedStageReader from a read to a write 00262 // pointer (and invalidates the reader). 00263 //////////////////////////////////////////////////////////////////// 00264 template<class CycleDataType> 00265 INLINE CycleDataStageWriter<CycleDataType>:: 00266 CycleDataStageWriter(PipelineCycler<CycleDataType> &, int, 00267 CycleDataLockedStageReader<CycleDataType> &take_from, 00268 bool) : 00269 _pointer((CycleDataType *)take_from.take_pointer()) 00270 { 00271 } 00272 00273 //////////////////////////////////////////////////////////////////// 00274 // Function: CycleDataStageWriter::Destructor (trivial) 00275 // Access: Public 00276 // Description: 00277 //////////////////////////////////////////////////////////////////// 00278 template<class CycleDataType> 00279 INLINE CycleDataStageWriter<CycleDataType>:: 00280 ~CycleDataStageWriter() { 00281 } 00282 00283 //////////////////////////////////////////////////////////////////// 00284 // Function: CycleDataStageWriter::operator -> (trivial) 00285 // Access: Public 00286 // Description: This provides an indirect member access to the actual 00287 // CycleData data. 00288 //////////////////////////////////////////////////////////////////// 00289 template<class CycleDataType> 00290 INLINE CycleDataType *CycleDataStageWriter<CycleDataType>:: 00291 operator -> () { 00292 return _pointer; 00293 } 00294 00295 //////////////////////////////////////////////////////////////////// 00296 // Function: CycleDataStageWriter::operator -> (trivial) 00297 // Access: Public 00298 // Description: This provides an indirect member access to the actual 00299 // CycleData data. 00300 //////////////////////////////////////////////////////////////////// 00301 template<class CycleDataType> 00302 INLINE const CycleDataType *CycleDataStageWriter<CycleDataType>:: 00303 operator -> () const { 00304 return _pointer; 00305 } 00306 00307 //////////////////////////////////////////////////////////////////// 00308 // Function: CycleDataStageWriter::Typecast pointer (trivial) 00309 // Access: Public 00310 // Description: This allows the CycleDataStageWriter to be passed to any 00311 // function that expects a CycleDataType pointer. 00312 //////////////////////////////////////////////////////////////////// 00313 template<class CycleDataType> 00314 INLINE CycleDataStageWriter<CycleDataType>:: 00315 operator CycleDataType * () { 00316 return _pointer; 00317 } 00318 00319 //////////////////////////////////////////////////////////////////// 00320 // Function: CycleDataStageWriter::get_current_thread (trivial) 00321 // Access: Public 00322 // Description: Returns the Thread pointer of the currently-executing 00323 // thread, as passed to the constructor of this object. 00324 //////////////////////////////////////////////////////////////////// 00325 template<class CycleDataType> 00326 INLINE Thread *CycleDataStageWriter<CycleDataType>:: 00327 get_current_thread() const { 00328 return Thread::get_current_thread(); 00329 } 00330 00331 #endif // DO_PIPELINING 00332 #endif // CPPPARSER