Initial commit

Torque/SDK/engine/ts/tsShapeAlloc.cc

@@ -0,0 +1,209 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+
+#include "ts/tsShapeAlloc.h"
+
+#define readOnly()  AssertFatal(mMode==TSShapeAlloc::ReadMode, "TSShapeAlloc: write-only function called when reading")
+#define writeOnly() AssertFatal(mMode==TSShapeAlloc::WriteMode,"TSShapeAlloc: read-only function called when writing")
+
+void TSShapeAlloc::setRead(S32 * memBuffer32, S16 * memBuffer16, S8 * memBuffer8, bool clear)
+{
+   mMemBuffer32 = memBuffer32;
+   mMemBuffer16 = memBuffer16;
+   mMemBuffer8  = memBuffer8 ;
+
+   mMemGuard32  = 0;
+   mMemGuard16  = 0;
+   mMemGuard8   = 0;
+
+   mSaveGuard32  = 0;
+   mSaveGuard16  = 0;
+   mSaveGuard8   = 0;
+
+   if (clear)
+   {
+      mDest = NULL;
+      mSize = 0;
+   }
+
+   setSkipMode(false);
+   mMode = TSShapeAlloc::ReadMode;
+}
+
+void TSShapeAlloc::setWrite()
+{
+   mMemBuffer32 = 0;
+   mMemBuffer16 = 0;
+   mMemBuffer8  = 0;
+
+   mSize32 = mFullSize32 = 0;
+   mSize16 = mFullSize16 = 0;
+   mSize8  = mFullSize8  = 0;
+
+   mMemGuard32  = 0;
+   mMemGuard16  = 0;
+   mMemGuard8   = 0;
+
+   setSkipMode(false); // doesn't really do anything here...
+   mMode = TSShapeAlloc::WriteMode;
+}
+
+void TSShapeAlloc::doAlloc()
+{
+   readOnly();
+
+   mDest = new S8[mSize];
+   mSize = 0;
+}
+
+void TSShapeAlloc::align32()
+{
+   readOnly();
+
+   S32 aligned = mSize+3 & (~0x3);
+   allocShape8(aligned-mSize);
+}
+
+#define IMPLEMENT_ALLOC(suffix,type)                          \
+                                                              \
+type TSShapeAlloc::get##suffix()                              \
+{                                                             \
+   readOnly();                                                \
+   return *(mMemBuffer##suffix++);                            \
+}                                                             \
+                                                              \
+void TSShapeAlloc::get##suffix(type * dest, S32 num)          \
+{                                                             \
+   readOnly();                                                \
+   dMemcpy(dest,mMemBuffer##suffix,sizeof(type)*num);         \
+   mMemBuffer##suffix += num;                                 \
+}                                                             \
+                                                              \
+type * TSShapeAlloc::allocShape##suffix(S32 num)              \
+{                                                             \
+   readOnly();                                                \
+   type * ret = (type*) mDest;                                \
+   if (mDest)                                                 \
+      mDest += mMult*num*sizeof(type);                        \
+   mSize += sizeof(type)*mMult*num;                           \
+   return ret;                                                \
+}                                                             \
+                                                              \
+type * TSShapeAlloc::getPointer##suffix(S32 num)              \
+{                                                             \
+   readOnly();                                                \
+   type * ret = (type*)mMemBuffer##suffix;                    \
+   mMemBuffer##suffix += num;                                 \
+   return ret;                                                \
+}                                                             \
+                                                              \
+type * TSShapeAlloc::copyToShape##suffix(S32 num, bool returnSomething) \
+{                                                             \
+   readOnly();                                                \
+   type * ret = (!returnSomething || mDest) ? (type*)mDest : mMemBuffer##suffix; \
+   if (mDest)                                                 \
+   {                                                          \
+      dMemcpy((S8*)mDest,(S8*)mMemBuffer##suffix,             \
+              mMult*num*sizeof(type));                        \
+      mDest += mMult*num*sizeof(type);                        \
+   }                                                          \
+   mMemBuffer##suffix += num;                                 \
+   mSize += sizeof(type)*mMult*num;                           \
+   return ret;                                                \
+}                                                             \
+                                                              \
+bool TSShapeAlloc::checkGuard##suffix()                       \
+{                                                             \
+   readOnly();                                                \
+   mSaveGuard##suffix=get##suffix();                          \
+   bool ret = (mSaveGuard##suffix==mMemGuard##suffix);        \
+   mMemGuard##suffix += 1;                                    \
+   return ret;                                                \
+}                                                             \
+                                                              \
+type TSShapeAlloc::getPrevGuard##suffix()                     \
+{                                                             \
+   readOnly();                                                \
+   return mMemGuard##suffix - 1;                              \
+}                                                             \
+                                                              \
+type TSShapeAlloc::getSaveGuard##suffix()                     \
+{                                                             \
+   readOnly();                                                \
+   return mSaveGuard##suffix;                                 \
+}                                                             \
+                                                              \
+type * TSShapeAlloc::getBuffer##suffix()                      \
+{                                                             \
+   writeOnly();                                               \
+   return mMemBuffer##suffix;                                 \
+}                                                             \
+                                                              \
+S32 TSShapeAlloc::getBufferSize##suffix()                     \
+{                                                             \
+   writeOnly();                                               \
+   return mSize##suffix;                                      \
+}                                                             \
+                                                              \
+type * TSShapeAlloc::extend##suffix(S32 add)                  \
+{                                                             \
+   writeOnly();                                               \
+   if (mSize##suffix+add>mFullSize##suffix)                   \
+   {                                                          \
+      S32 numPages = 1+(mFullSize##suffix+add)/TSShapeAlloc::PageSize; \
+      mFullSize##suffix = numPages*TSShapeAlloc::PageSize;    \
+      type * temp = new type[mFullSize##suffix];              \
+      dMemcpy(temp,mMemBuffer##suffix, mSize##suffix * sizeof(type)); \
+      delete [] mMemBuffer##suffix;                           \
+      mMemBuffer##suffix = temp;                              \
+   }                                                          \
+   type * ret = mMemBuffer##suffix + mSize##suffix;            \
+   mSize##suffix += add;                                      \
+   return ret;                                                \
+}                                                             \
+                                                              \
+type TSShapeAlloc::set##suffix(type entry)                    \
+{                                                             \
+   writeOnly();                                               \
+   *extend##suffix(1) = entry;                                \
+   return entry;                                              \
+}                                                             \
+                                                              \
+void TSShapeAlloc::copyToBuffer##suffix(type * entries, S32 count) \
+{                                                             \
+   writeOnly();                                               \
+   dMemcpy((U8*)extend##suffix(count),(U8*)entries,count*sizeof(type)); \
+}                                                             \
+                                                              \
+void TSShapeAlloc::setGuard##suffix()                         \
+{                                                             \
+   writeOnly();                                               \
+   set##suffix(mMemGuard##suffix);                            \
+   mMemGuard##suffix += 1;                                    \
+}
+
+IMPLEMENT_ALLOC(32,S32)
+IMPLEMENT_ALLOC(16,S16)
+IMPLEMENT_ALLOC(8,S8)
+
+void TSShapeAlloc::checkGuard()
+{
+   bool check32 = checkGuard32();
+   bool check16 = checkGuard16();
+   bool check8  = checkGuard8();
+
+   AssertFatal(check32,avar("TSShapeAlloc::checkGuard32: found %i, wanted %i",getSaveGuard32(),getPrevGuard32()));
+   AssertFatal(check16,avar("TSShapeAlloc::checkGuard16: found %i, wanted %i",getSaveGuard16(),getPrevGuard16()));
+   AssertFatal(check8 ,avar("TSShapeAlloc::checkGuard8:  found %i, wanted %i",getSaveGuard8() ,getPrevGuard8()));
+}
+
+void TSShapeAlloc::setGuard()
+{
+   setGuard32();
+   setGuard16();
+   setGuard8();
+}
+
+