• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/physic/src/Stream.cpp

Go to the documentation of this file.
00001 // ===============================================================================
00002 //                                                NVIDIA PHYSX SDK TRAINING PROGRAMS
00003 //                                                               USER STREAM
00004 //
00005 //                                                  Written by Bob Schade, 5-1-06
00006 // ===============================================================================
00007 
00008 #include "../pch.h"
00009 
00010 UserStream::UserStream(const char* filename, bool load) : fp(NULL)
00011 {
00012 #ifdef WIN32
00013         fopen_s(&fp, filename, load ? "rb" : "wb");
00014 #else
00015         fp = fopen(filename, load ? "rb" : "wb");
00016 #endif
00017 }
00018 
00019 UserStream::~UserStream()
00020 {
00021         if(fp)  fclose(fp);
00022 }
00023 
00024 // Loading API
00025 NxU8 UserStream::readByte() const
00026 {
00027         NxU8 b;
00028         size_t r = fread(&b, sizeof(NxU8), 1, fp);
00029         NX_ASSERT(r);
00030         return b;
00031 }
00032 
00033 NxU16 UserStream::readWord() const
00034 {
00035         NxU16 w;
00036         size_t r = fread(&w, sizeof(NxU16), 1, fp);
00037         NX_ASSERT(r);
00038         return w;
00039 }
00040 
00041 NxU32 UserStream::readDword() const
00042 {
00043         NxU32 d;
00044         size_t r = fread(&d, sizeof(NxU32), 1, fp);
00045         NX_ASSERT(r);
00046         return d;
00047 }
00048 
00049 float UserStream::readFloat() const
00050 {
00051         NxReal f;
00052         size_t r = fread(&f, sizeof(NxReal), 1, fp);
00053         NX_ASSERT(r);
00054         return f;
00055 }
00056 
00057 double UserStream::readDouble() const
00058 {
00059         NxF64 f;
00060         size_t r = fread(&f, sizeof(NxF64), 1, fp);
00061         NX_ASSERT(r);
00062         return f;
00063 }
00064 
00065 void UserStream::readBuffer(void* buffer, NxU32 size)   const
00066 {
00067         size_t w = fread(buffer, size, 1, fp);
00068         NX_ASSERT(w);
00069 }
00070 
00071 // Saving API
00072 NxStream& UserStream::storeByte(NxU8 b)
00073 {
00074         size_t w = fwrite(&b, sizeof(NxU8), 1, fp);
00075         NX_ASSERT(w);
00076         return *this;
00077 }
00078 
00079 NxStream& UserStream::storeWord(NxU16 w)
00080 {
00081         size_t ww = fwrite(&w, sizeof(NxU16), 1, fp);
00082         NX_ASSERT(ww);
00083         return *this;
00084 }
00085 
00086 NxStream& UserStream::storeDword(NxU32 d)
00087 {
00088         size_t w = fwrite(&d, sizeof(NxU32), 1, fp);
00089         NX_ASSERT(w);
00090         return *this;
00091 }
00092 
00093 NxStream& UserStream::storeFloat(NxReal f)
00094 {
00095         size_t w = fwrite(&f, sizeof(NxReal), 1, fp);
00096         NX_ASSERT(w);
00097         return *this;
00098 }
00099 
00100 NxStream& UserStream::storeDouble(NxF64 f)
00101 {
00102         size_t w = fwrite(&f, sizeof(NxF64), 1, fp);
00103         NX_ASSERT(w);
00104         return *this;
00105 }
00106 
00107 NxStream& UserStream::storeBuffer(const void* buffer, NxU32 size)
00108 {
00109         size_t w = fwrite(buffer, size, 1, fp);
00110         NX_ASSERT(w);
00111         return *this;
00112 }
00113 
00114 
00115 
00116 MemoryWriteBuffer::MemoryWriteBuffer() : currentSize(0), maxSize(0), data(NULL)
00117 {
00118 }
00119 
00120 MemoryWriteBuffer::~MemoryWriteBuffer()
00121 {
00122         NxGetPhysicsSDKAllocator()->free(data);
00123 }
00124 
00125 NxStream& MemoryWriteBuffer::storeByte(NxU8 b)
00126 {
00127         storeBuffer(&b, sizeof(NxU8));
00128         return *this;
00129 }
00130 
00131 NxStream& MemoryWriteBuffer::storeWord(NxU16 w)
00132 {
00133         storeBuffer(&w, sizeof(NxU16));
00134         return *this;
00135 }
00136 
00137 NxStream& MemoryWriteBuffer::storeDword(NxU32 d)
00138 {
00139         storeBuffer(&d, sizeof(NxU32));
00140         return *this;
00141 }
00142 
00143 NxStream& MemoryWriteBuffer::storeFloat(NxReal f)
00144 {
00145         storeBuffer(&f, sizeof(NxReal));
00146         return *this;
00147 }
00148 
00149 NxStream& MemoryWriteBuffer::storeDouble(NxF64 f)
00150 {
00151         storeBuffer(&f, sizeof(NxF64));
00152         return *this;
00153 }
00154 
00155 NxStream& MemoryWriteBuffer::storeBuffer(const void* buffer, NxU32 size)
00156 {
00157         NxU32 expectedSize = currentSize + size;
00158         if(expectedSize > maxSize)
00159         {
00160                 maxSize = expectedSize + 4096;
00161 
00162                 NxU8* newData = (NxU8*)NxGetPhysicsSDKAllocator()->malloc(maxSize, NX_MEMORY_PERSISTENT);
00163                 if(data)
00164                 {
00165                         memcpy(newData, data, currentSize);
00166                         NxGetPhysicsSDKAllocator()->free(data);
00167                 }
00168                 data = newData;
00169         }
00170         memcpy(data+currentSize, buffer, size);
00171         currentSize += size;
00172         return *this;
00173 }
00174 
00175 MemoryReadBuffer::MemoryReadBuffer(const NxU8* data) : buffer(data)
00176 {
00177 }
00178 
00179 MemoryReadBuffer::~MemoryReadBuffer()
00180 {
00181         // We don't own the data => no delete
00182 }
00183 
00184 NxU8 MemoryReadBuffer::readByte() const
00185 {
00186         NxU8 b;
00187         memcpy(&b, buffer, sizeof(NxU8));
00188         buffer += sizeof(NxU8);
00189         return b;
00190 }
00191 
00192 NxU16 MemoryReadBuffer::readWord() const
00193 {
00194         NxU16 w;
00195         memcpy(&w, buffer, sizeof(NxU16));
00196         buffer += sizeof(NxU16);
00197         return w;
00198 }
00199 
00200 NxU32 MemoryReadBuffer::readDword() const
00201 {
00202         NxU32 d;
00203         memcpy(&d, buffer, sizeof(NxU32));
00204         buffer += sizeof(NxU32);
00205         return d;
00206 }
00207 
00208 float MemoryReadBuffer::readFloat() const
00209 {
00210         float f;
00211         memcpy(&f, buffer, sizeof(float));
00212         buffer += sizeof(float);
00213         return f;
00214 }
00215 
00216 double MemoryReadBuffer::readDouble() const
00217 {
00218         double f;
00219         memcpy(&f, buffer, sizeof(double));
00220         buffer += sizeof(double);
00221         return f;
00222 }
00223 
00224 void MemoryReadBuffer::readBuffer(void* dest, NxU32 size) const
00225 {
00226         memcpy(dest, buffer, size);
00227         buffer += size;
00228 }

Generated on Fri Jun 18 2010 17:48:39 for Cannonball by  doxygen 1.7.0