00001
00002
00003
00004
00005
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
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
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
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 }