//-----------------------------------------------------------------------------
// V12 Engine
// 
// Copyright (c) 2001 GarageGames.Com
// Portions Copyright (c) 2001 by Sierra Online, Inc.
//-----------------------------------------------------------------------------

#ifndef _TSSHAPEALLOC_H_
#define _TSSHAPEALLOC_H_

#ifndef _PLATFORM_H_
#include "Platform/platform.h"
#endif
#ifndef _MMATH_H_
#include "Math/mMath.h"
#endif

// alloc structure used in the reading/writing of shapes
// in read mode we assemble contents of 32-bit, 16-bit, and 8-bit buffers
// into a single destination buffer
// in write mode we dissemble a stream of memory (which may be scattered in physical memory)
// into 32-bit, 16-bit, 8-bit, Point3F, and Point2F buffers using function calls similar
// to the read calls

// read usage:  
// 1. call "setRead" with each incoming memory buffers and clear=true
// 2. run through set of operations for allocating and transfering memory to target buffer
//    these are the operations under "DECLARE_ALLOC" that call readOnly in the .cc file
// 3. call "doAlloc" to create buffer exactly as large as needed
// 4. repeat step 1 & 2 to do the actual transfer of memory, except with clear=false
//    (note: first time through nothing was copied to the shape, we only kept track
//    of the size of the transfer).
// 5. call getBuffer to get the target (destination buffer)

// write usage:  
// 1. call "setWrite" (no parameters)
// 2. run through set of operations for allocating and transfering memory to internal buffers
//    these are the operations under "DECLARE_ALLOC" that call writeOnly in the .cc file
// 3. call getBuffer32 and getBufferSize32 to get 32-bit buffer and size.  Similarly for
//    16-bit, 8-bit (getBuffer16, getBuffer8)

// TSShape::assesmbleShape and TSShape::dissembleShape can be used as examples

class TSShapeAlloc
{
   S32 mMode; // read or write

   // reading and writing (when reading these are the input; when writing these are the output)
   S32     * mMemBuffer32;
   S16     * mMemBuffer16;
   S8      * mMemBuffer8;

   // for writing only...
   S32 mSize32;
   S32 mSize16;
   S32 mSize8;
   S32 mFullSize32;
   S32 mFullSize16;
   S32 mFullSize8;

   // reading and writing...
   S32 mMemGuard32;
   S16 mMemGuard16;
   S8 mMemGuard8;

   // reading
   S32 mSaveGuard32;
   S16 mSaveGuard16;
   S8 mSaveGuard8;

   // reading only...this is the output
   S8 * mDest;
   S32 mSize;
   S32 mMult; // mult incoming sizes by this (when 0, then mDest doesn't grow --> skip mode)

   public:

   enum { ReadMode = 0, WriteMode = 1, PageSize = 1024 }; // PageSize must be multiple of 4 so that we can always
                                                          // "over-read" up to next dword

   void setRead(S32 * buff32, S16 * buff16, S8 * buff8, bool clear);
   void setWrite();

   // reading only...
   void doAlloc();
   void align32(); // align on dword boundary
   S8 * getBuffer() { return mDest; }
   S32 getSize() { return mSize; }
   void setSkipMode(bool skip) { mMult = skip ? 0 : 1; }

   // reading operations:
   // get: reads one or more entries of type from input buffer (doesn't affect output buffer)
   // copyToShape: copies entries of type from input buffer to output buffer
   // allocShape: creates room for entries of type in output buffer (no effect on input buffer)
   // getPointer: gets pointer to next entries of type in input buffer (no effect on input buffer)
   // Note: all operations advance current "position" of input and output buffers
   // writing operations:
   // set: adds one entry to appropriate buffer
   // copyToBuffer: adds count entries to approrpiate buffer
   // getBuffer: returns associated buffer (i.e., getBuffer32 gets 32bit buffer)
   // getBufferSize: returns size of associated buffer
   #define DECLARE_ALLOC(suffix,type) \
   type get##suffix();                \
   void get##suffix(type*,S32);       \
   type * copyToShape##suffix(S32,bool returnSomething=false); \
   type * getPointer##suffix(S32);    \
   type * allocShape##suffix(S32);    \
   bool checkGuard##suffix();         \
   type getPrevGuard##suffix();       \
   type getSaveGuard##suffix();       \
   type * getBuffer##suffix();        \
   S32 getBufferSize##suffix();       \
   void setGuard##suffix();           \
   type * extend##suffix(S32);        \
   type set##suffix(type);            \
   void copyToBuffer##suffix(type*,S32);

   DECLARE_ALLOC(32,S32)
   DECLARE_ALLOC(16,S16)
   DECLARE_ALLOC(8,S8)

   void checkGuard();
   void setGuard();
};

#endif // _H_TS_SHAPE_ALLOC_