// This file is distributed under a BSD license. See LICENSE.txt for details.

#ifndef __KDOC_HPP__
#define __KDOC_HPP__

#include "_types.hpp"
#include "_start.hpp"

/****************************************************************************/

struct KLogic;                    // game logic operation
struct KOp;                       // Operator
struct KEvent;                    // Event in timeline
struct KSpline;                   // Spline
struct KInstanceMem;              // per event and operator memory
class KEnvironment;               // glue everything together

/****************************************************************************/
                                  // program limits
#define KK_MAXLINK    16          // linked inputs
#define KK_MAXSPLINE  8           // spline inpuits
#define KK_MAXINPUT   256         // conected inputs
#define KK_MAXKEYS    128         // keys per spline, each dimension has it's own
#define KK_NAME       32          // editor-name (not stored here)
#define KK_MAXVAR     32          // variables for animation
#define KK_MAXVARSAVE 256         // space for saving variables 

#define KK_MAXJOBS    1024        // max paintjobs
#define MAX_OP_ROOT   16          // there are multiple roots nowadays

                                  // animation options
#define KAF_INT       0           // integral numbers
#define KAF_FIXED     1           // 16 bit fixed point
#define KAF_FLOAT     2           // 32 bit float
#define KAF_UBYTE     3           // ubyte, like for colors

#define KAM_MUL       0x0001      // multiply instead of adding
#define KAM_VELOCIFY  0x0002      // multiply spline with velocity
#define KAM_MODULATE  0x0004      // multiply spline with modulation
#define KAM_SELECT    0x0010      // replace time with select
#define KAM_MOUSEX    0x0020      // replace time with mousex
#define KAM_MOUSEY    0x0030      // replace time with mousex

                                  // KObject Class ID's
#define KC_NULL       0           // no input allowed
#define KC_BITMAP     1           // bitmap
#define KC_MINMESH    2           // minimal mesh
#define KC_SCENE      3           // list of meshes
#define KC_KKRIEGER   4           // the game itself
#define KC_MATERIAL   5           // material
#define KC_MESH       6           // a real mesh
#define KC_IPP        8           // image postprocessing
#define KC_EFFECT     9           // special effect, painted in scene like meshes but with own code
#define KC_SMESH      10          // simple mesh (but with bsp)
#define KC_DEMO       11          // image postprocessing
#define KC_SCENE2     12          // new scene. this is no OP!
#define KC_SPLINE     13          // some kind of spline
#define KC_IMGLIST    14          // image list
#define KC_COUNT      15          // number of distinct object classes
//#define KC_UPDATE     254         // an update object, that's no real object
#define KC_ANY        255         // any class allowed as input

/****************************************************************************/

#define KA_NOP        0x00        // no operation
#define KA_END        0x01        // end of program
#define KA_LOADVAR    0x02        // load variable
#define KA_LOADPARA1  0x03        // load original operator parameter
#define KA_LOADPARA2  0x04        // load original operator parameter
#define KA_LOADPARA3  0x05        // load original operator parameter
#define KA_LOADPARA4  0x06        // load original operator parameter
#define KA_SWIZZLEX   0x07        // x -> xyzw
#define KA_SWIZZLEY   0x08        // y -> xyzw
#define KA_SWIZZLEZ   0x09        // z -> xyzw
#define KA_SWIZZLEW   0x0a        // w -> xyzw
#define KA_ADD        0x0b        // a+b
#define KA_SUB        0x0c        // a-b
#define KA_MUL        0x0d        // a*b
#define KA_DIV        0x0e        // a/b
#define KA_MOD        0x0f        // a%1
#define KA_INVERT     0x10        // 1-a
#define KA_NEG        0x11        // -a
#define KA_SIN        0x12        // sin(t)
#define KA_COS        0x13        // cos(t)
#define KA_PULSE      0x14        // pulse(t,phase)
#define KA_RAMP       0x15        // ramp(t)
#define KA_CONSTV     0x16        // const float vector
#define KA_CONSTC     0x17        // const color
#define KA_CONSTS     0x18        // const scalar
#define KA_SPLINE     0x19        // spline(t,"name")
#define KA_EVENTSPLINE      0x1a  // eventspline(t) -> use spline from event
#define KA_MATRIX           0x1b  // apply matrix
#define KA_NOISE      0x1c        // noise
#define KA_EASE       0x1d        // ease in / out
#define KA_TIMESHIFT  0x1e        // remap time range
#define KA_POW        0x1f        // a^b
#define KA_LOG2       0x20        // log2(x)
#define KA_POW2       0x21        // 2^x (float)

#define KA_STOREVAR   0x80        // store variable, with writemask
#define KA_STOREPARAFLOAT   0x90  // store parameter, with writemask
#define KA_STOREPARAINT     0xa0  // store parameter, with writemask
#define KA_STOREPARABYTE    0xb0  // store parameter, with writemask
#define KA_CHANGEPARAFLOAT  0xd0  // store parameter, with writemask, changing
#define KA_CHANGEPARAINT    0xe0  // store parameter, with writemask, changing
#define KA_CHANGEPARABYTE   0xf0  // store parameter, with writemask, changing

sInt CalcCmdSize(sU8 *bytecode);         // calc size of one single bytecode command
sInt CalcCodeSize(sU8 *bytecode);        // returns size of bytecode fragment
sBool AnimCodeWritesTo(sU8 *code,sInt offset);  // find if offset is changed by code

/****************************************************************************/

#define KV_TIME       0x00        // basic event
#define KV_VELOCITY   0x01
#define KV_MODULATION 0x02
#define KV_SELECT     0x03        // count for multiply / particles
#define KV_EVENT_S    0x04        // event matrix
#define KV_EVENT_R    0x05
#define KV_EVENT_T    0x06
#define KV_EVENT_C    0x07        // event color
#define KV_CAM_S      0x08        // camera matrix
#define KV_CAM_R      0x09
#define KV_CAM_T      0x0a
#define KV_FRACTION   0x0b        // fraction for particles
#define KV_PLAYER_S   0x0c        // player matrix
#define KV_PLAYER_R   0x0d
#define KV_PLAYER_T   0x0e
#define KV_0f         0x0f        // unused
#define KV_LEG_L0     0x10        // walker-leg position
#define KV_LEG_R0     0x11
#define KV_LEG_L1     0x12
#define KV_LEG_R1     0x13
#define KV_LEG_L2     0x14
#define KV_LEG_R2     0x15
#define KV_LEG_L3     0x16
#define KV_LEG_R3     0x17
#define KV_18         0x18      // unused
#define KV_19         0x19      // unused
#define KV_1a         0x1a      
#define KV_LEG_TIMES  0x1b      // walker timing { time, 0, 0, 0 }
#define KV_MATRIX_I   0x1c      // general purpose matrix (set by Limb)
#define KV_MATRIX_J   0x1d
#define KV_MATRIX_K   0x1e
#define KV_MATRIX_L   0x1f

// variable misuse for monster

// KV_EVENT_S                   // attack timer { melee, ranged, life-percent, 0 }

/****************************************************************************/

// calling convention bitmasks, in the order of parameters

sInt inline OPC_GETDATA(sU32 x)   {return (x&0x000000ff);}
sInt inline OPC_GETINPUT(sU32 x)  {return (x&0x00000f00)>>8;}
sInt inline OPC_GETLINK(sU32 x)   {return (x&0x0000f000)>>12;}
sInt inline OPC_GETSTRING(sU32 x) {return (x&0x00070000)>>16;}
sInt inline OPC_GETSPLINE(sU32 x) {return (x&0x00700000)>>20;} // i assume that 2 bit are enough, tho

#define OPC_BLOB          0x00080000  // blob is stored in op. this does not change the actual calling convention
#define OPC_KENV          0x00800000  // push KENV in INIT
#define OPC_VARIABLEINPUT 0x01000000  // use Call(x,y,...); convention (for add)
#define OPC_SKIPEXEC      0x02000000  // nothing special happens during the exec phase
#define OPC_ALTEXEC       0x04000000  // alternative calling convention for exec (no parameter)
//#define OPC_OUTPUTCOUNT   0x08000000  // add outputcount as parameter (removed!)
#define OPC_STRIPPEDIN    0x08000000  // op accepts stripped inputs
#define OPC_DONTCALLLINK  0x10000000  // don't call link. used to pass events.
#define OPC_ALTINIT       0x20000000  // alternative calling convention for ínit (no parameter except op)
#define OPC_KOP           0x40000000  // push KOp in INIT (op is before env)
#define OPC_FLEXINPUT     0x80000000  // non-fixed number of input parameters (only in export)

// - the inputcount will be in the specified range
// - all inputs within inputcount are valid
// - links may be failty
// - if there is is an op as input or link, it will have a cached object
// this is true for Init and Exec
// in the player, this is explicitly assumed
// in the werkkzeug, this is checked in Init / Exec
// if DONTCALLLINK is set, links are not checked in Init.

/****************************************************************************/

struct KLogic                               // effect connected to cell
{
  sU8 Code;                                 // KKEC_??? KKEE_???
  sU8 Condition;                            // additional switch condition for switch and value groups. use switch 0 which is always on
  sU8 Output;                               // output: event or switch
  sU8 pad;
  sInt Value;                               // value for value-group, switch for logic group
  KOp *Event[2];                            // (possible) event to issue
};
                                            // what to do
#define KKEC_NOP                  0x00      // nothing
                                            // switches
#define KKEC_ENABLESWITCH         0x01      // set switch on event
#define KKEC_DISABLESWITCH        0x02      // clear switch on event
#define KKEC_TOGGLESWITCH         0x03      // toggle switch on event
#define KKEC_SETSWITCH            0x04      // set event (0/1) to switch
                                            // collectables
#define KKEC_SETVALUE             0x05      // output = value
#define KKEC_MAXVALUE             0x06      // output = max(output,value)
#define KKEC_MINVALUE             0x07      // output = min(output,value)
#define KKEC_INCVALUE             0x08      // output = output + value
#define KKEC_DECVALUE             0x09      // output = output - value
                                            // game physics
#define KKEC_JUMP                 0x0a      // accelerate up by value*0.001f
#define KKEC_RESPAWN              0x0b      // set respawn zone for player, value=0..9
/*
                                            // switch logic
#define KKEC_ANDLOGIC             0x0a      // output = condition & value
#define KKEC_ORLOGIC              0x0b      // output = condition | value
#define KKEC_NOTLOGIC             0x0c      // output = !condition
*/
                                            // when to do
#define KKEE_NOP                  0x00      // never
#define KKEE_ENTER                0x10      // when entering a zone
#define KKEE_LEAVE                0x20      // when leaving a zone
#define KKEE_COLLECT              0x30      // when entering a zone, once
#define KKEE_RESPAWN0             0x40      // when entering a zone, will respawn soon
#define KKEE_RESPAWN1             0x50      // when entering a zone, will respawn 
#define KKEE_RESPAWN2             0x60      // when entering a zone, will respawn 
#define KKEE_RESPAWN3             0x70      // when entering a zone, will respawn late
#define KKEE_USE                  0x80      // when pressing the use button inside a zone
#define KKEE_HIT                  0x90      // when a shot "enters" a zone
#define KKEE_ALWAYS               0xa0      // always, with respect to the condition
#define KKEE_INSIDE               0xb0      // when inside
#define KKEE_HITORENTER           0xc0      // when hit or entered

/****************************************************************************/

class KObject                     // base cass
{
public:
  sInt ClassId;                   // KC_??
  sInt RefCount;                  // 

  KObject();
protected: virtual ~KObject();
public:
  virtual void Copy(KObject *o);  // copy from object
  virtual KObject *Copy();        // duplicate object
  void AddRef() {RefCount++;}
  void Release() {RefCount--;if(RefCount==0) delete this;}

  virtual sBool Strip();          // throw away anything that's not necessary after init. return if this object has usable data left.
  virtual sBool IsStripped();     // has this object been stripped?
};                                // =12 bytes (vtable+8)

/****************************************************************************/

struct KInstanceMem               // used for instance-storage. derive from this
{
  KOp *Operator;                  // operator requesting storage
  KInstanceMem *Next;             // next instance mem
  KInstanceMem **DeleteChild;     // recurse to this child when DeleteChain(). 
  KInstanceMem **DeleteChild2;    // recurse to this child when DeleteChain(). 
  void *DeleteArray;              // call delete[] on this when DeleteChain(). 
  sBool Reset;                    // set true on first encounter, automatically reset
  void DeleteChain();             // delete a list of KInstanceMem, beginning with *this. can be called on 0-pointers
};

struct KEvent                     // timeline event
{
  void Init();                    // clear all
  void Exit();
  void Stop();                    // stop event by changing time. do this only to dynamic events!

  sMatrix Matrix;                 // event base matrix
  KOp *Op;                        // execute this operator
  KEvent *NextOp;                 // linked list of active events per op
  sInt Start;                     // time start
  sInt End;                       // time end
  sInt Mark;                      // connect KEvent and KSpline
  sInt ShotTime;                  // only used for reflect shots
  sInt Active;                    // obsolete
  KInstanceMem *FirstInstance;    // first instance in chain
  sInt Dynamic;                   // dynamic events must be deleted when removed
  sInt RemoveMe;                  // terminate this event
  sInt Flags;                     // various flags

  sF32 Velocity;                  // event variable velocity
  sF32 Modulation;                // event variable modulation
  sInt Select;                    // event variable selection, 0..16 maps to time 0..1
  sVector Scale;                  // event variable
  sVector Rotate;                 // event variable
  sVector Translate;              // event variable
  sU32 Color;                     // event variable
  KSpline *Spline;                // spline for event
  sF32 StartInterval;             // start interval time (default: 0)
  sF32 EndInterval;               // end interval time (default 1)

  // obscure special hardcoded shit...
//  sMatrix ReturnMatrix;           // pass back a matrix to system, used by WALK
  struct KKriegerMonster *Monster;// connect collision to monster, used by PHYSIC
  sInt CullDist;                  // set if you want distance-culling
};

#define KEF_NOTIME 0x0001         // don't manipulate time

/****************************************************************************/
/****************************************************************************/

struct KLetterMetric
{
  sFRect UV;
  sF32 PreSpace;
  sF32 Width;
};

/****************************************************************************/
 
                                  // calc-flags
#define KCF_NEED          0x0001  // result is really needed. this flag is cleared during recursion when no changes are found.
#define KCF_ROOT          0x0002  // tool-memory-management: do not flush root
#define KCF_PRECALC       0x0004  // progress bar and memory management
#define KCF_STRIPPEDOK    0x0008  // accept stripped ops as valid

class KEnvironment                // variables for 
{
public:
  KEnvironment();
  ~KEnvironment();

  void InitView();                                // prepare for viewing. Set after Init and before Exec, or whenever the viewed op was changed in the editor
  void InitFrame(sInt beattime,sInt timems);      // prepare for frame and time
  void ExitFrame();                                // clean up afterwards
//  void Calc(KOp *op);                             // call Init_???()
  void AddDynamicEvent(KEvent *event);            // call this to register event. event gets deleted by KEnv. this is used by TRIGGER
  void AddStaticEvent(KEvent *event);             // add static events. memory is managed by caller. call this directly after InitFrame(). Events come from Document and Game

  sInt ExecuteAnim(KOp *,sU8 *bytecode);          // calculate animation
  void Pop(sInt count);                           // always call this with the result of Calc to rollback changed variables
  void *GetInstImpl(KOp *me,sInt size);           // get next instance-mem (implementation)
  template <class t> t *GetInst(KOp *me);         // get next instance-mem (or alloc new)
  void SetMatrix(sMatrix &mat,sMatrix &save);     // set matrix in variable,
  void RestoreMatrix(sMatrix &save);              // clean it up;

  // internal state
  sMemStack Mem;                  // memory for all kinds of structures
  sVector Stack[KK_MAXVARSAVE];   // save modified variables here for rollback
  sU8 StackAdr[KK_MAXVARSAVE];    // save it here. 
  sInt Index;                     // for stack
  sArray<KEvent *> DynamicEvents; // use AddDynamicEvent() to add here
  sArray<KOp *> EventOpsCleanup;  // reset event-chain in these ops

  // current event environment

  sVector Var[KK_MAXVAR];         // current set of variables
  KSpline *EventSpline;           // spline attached to current event (or 0)
  struct KKriegerMonster *EventMonster;// monster from event
  KEvent *CurrentEvent;
 
  // instance memory
  KInstanceMem *NextInstance;     // if there is instance storage, this is the next chunk
  KInstanceMem **LinkInstance;    // if there isn't, allocate new and store here
  KInstanceMem *DefaultInstance;  // instance-list for "no event" state
  sInt ClearInstanceMem;          // clear instance-mem for all static events added. this is set by InitView

  // set by caller
  KSpline **Splines;              // link to splines
  sInt SplineCount;
  struct KKriegerGame *Game;      // link to game
#if sLINK_KKRIEGER
  sInt NextMonsterOverride;       // use the following values to override next monster created
  sInt NextMonsterKillSwitch;
  sInt NextMonsterSpawnSwitch;
  sInt NextMonsterFlags;
#endif

  sMaterialEnv GameCam;           // camera from game or user-interface.
  sMaterialEnv CurrentCam;        // camera from viewport op.
#if !sPLAYER
  sVector CameraDataRot;          // for cam -> freecamera 'Z' option
  sVector CameraDataPos;
  sF32 CameraDataZoom;
#endif
  sF32 Aspect;
  sInt BeatTime;                  // current time in 16:16 beats
  sInt CurrentTime;               // current time in ms
  sInt LastTime;                  // last frames time
  sInt TimeDelta;                 // current-last
  sInt TimeSlices;                // timeslices since last frame (10ms)
  sInt TimeJitter;                // fraction of time since last frame
  sInt TimeReset;                 // noticed backwards movement in time

  sMatrix Markers[32];            // use Scene_Marker to set. useful hack for Effect_ChainLine

  struct BlobCameraInfo
  {
    sMatrix Matrix;
    sF32 ZoomX;
    sF32 ZoomY;
  } Camera;


  // fonts
  KLetterMetric Letters[8][256];  // set by TEXT, used by PRINT

  sMatrixStack ExecStack;         // Matrix stack for scene transforms

#if !PLAYER
  sU8 *DebugOpByte;               // bytecode address of op for debugging
  sVector DebugOpOutput;          // store output of specifired bytecode op here
  sInt CalcAbort;
#endif
};

/****************************************************************************/

struct KClass                     // Operator class
{
  sU32 Convention;                // calling convention +flag 0x10000000 (varinputs)
  sChar *Packing;                 // packing string
  void *InitHandler;              // initialize operator
  void *ExecHandler;              // execute operator
}; // =16 bytes

struct KHandler                   // Operator handler
{
  sInt Id;                        // operator id
  void *InitHandler;              // initialize operator
  void *ExecHandler;              // execute operator
};

extern KHandler KHandlers[];

/****************************************************************************/

struct KOp                        // Operator
{
  friend class KEnvironment;
  sInt Command;                   // class of operator
  sInt Result;                    // class of result
  KObject *Cache;                 // result pointers, depending on class
#if sPLAYER
  sBool CacheFreed;               // cache is freed
#endif
  sInt Changed;                   // cache is dirty
  sInt DataInvalid;               // this operator has been animated, please copy DataCopy to Data
  sInt CacheCount;                // on creation set to output-count, then reduced with each link
  sInt WheelSpeed;                // used only for spinning wheels in the gui...
  KEvent *FirstEvent;             // list of active events for this operator
  void *InitHandler;              // the actual code
  void *ExecHandler;              // the actual code
  sInt CalcError;                 // could not calculate cache
  sU32 Convention;                // calling conventions for code
  sU32 ChangeMask;                // which inputs don't update the "change" bit?
  sInt OpId;                      // operator id (used to locate blobs+shaders)
  sInt SkipExec;                  // dont' call exec phase when (a) all ops are not animated and (b) all ops don't need exec
  sInt SkipCalc;                  // if the op is not changed, you may stop recursion here...
  sInt Tag;                       // for counting
#if !sPLAYER
  sInt Highlight;                 // this operator is above the edit operator in the op-tree
  sInt CycleFlag;                 // for cyclic check
  sInt CycleChangeFlag;           // for cyclic check
  sInt CacheSize;                 // for memory management
  sBool Blocked;                  // for memory management
#endif
  sBool AnimFlag;                 // op is (somehow) animated
  sInt VarStart;                  // animated variable range of this op
  sInt VarCount;                  // (generated during Init_, used during Exec_)
  KInstanceMem *SceneMemLink;     // linked list of instance memory used for scenejobs

private:
  sInt InputMax;                  // allocated per configuration                 
  sInt LinkMax;
  sInt OutputMax;
  sInt DataMax;
  sInt StringMax;                 // number of strings, size of strings not included
  sInt SplineMax;                 // number of splines
  sInt AnimMax;                   // size of command-string, 4-byte aligned

  sInt InputCount;                // inputs used
  sInt OutputCount;               // outputs used

  sU32 *Memory;                   // a block of memory, for everything to do

  KOp **Input;                    // inputs
  KOp **Link;                     // links
  KOp **Output;                   // outputs (not set in player!)
  sChar **String;                 // dynamic strings
  KSpline **Spline;               // array of spline-pointers
  sU8 *AnimCode;                  // animation code
  sU32 *DataEdit;                 // dynamic parameter array 
  sU32 *DataAnim;                 // dynamic parameter array 

  sInt BlobSize;                  // binary large object. Set OPC_BLOB to use!
  const sU8 *BlobData;                  // in Player, this points directly into export data. in Werkkzeug, this gets deleted[] on Exit().

public:

// interface

  sInt Calc(KEnvironment *,sInt flags);   // recursivly calculate, returns sTRUE when changed
  KObject *Call(KEnvironment *);  // InitHandler Recursion just call this op

  void ExecWithNewMem(KEnvironment *,KInstanceMem **link);
  void ExecEvent(KEnvironment *,KEvent *,sBool newmem);// ExecHandler Recursion, set and reset variables for event
  void Exec(KEnvironment *);      // (*ExecHandler)(op,kenv,...)

  void ExecInputs(KEnvironment *);// ExecHandler Recursion
  void ExecInput(KEnvironment *,sInt i);// ExecHandler Recursion
  void Change(sInt input=-1);     // do all stuff needed to update change status
  sBool CheckOutput(sInt kc);     // check that this op outputs a valid object of the specified type. this also checks the THIS pointer for 0, so you may call it on zero pointers
  void UpdateVar(sInt start,sInt count);
  sBool IsWrittenTo(sInt offset); // checks if offset is written to in bytecode
/*
  sU32 GetU(sInt i) {return DataU[i];}            // getter for ops
  sS32 GetS(sInt i) {return DataS[i];}
  sF32 GetF(sInt i) {return DataF[i];}
  */
  KOp *GetInput(sInt i) {return i<InputCount?Input[i]:0;}
  KOp *GetLink(sInt i) {return i<LinkMax?Link[i]:0;}
  KObject *GetLinkCache(sInt i) {return i<LinkMax?(Link[i]?Link[i]->Cache:0):0;}
  KOp *GetOutput(sInt i) {return Output[i];}
  sChar *GetString(sInt i) {return String[i];}
  KSpline *GetSpline(sInt i) {return i<SplineMax?Spline[i]:0;}
  sInt GetInputCount() {return InputCount;}
  sInt GetOutputCount() {return OutputCount;}
  sInt GetLinkMax() {return LinkMax;}
  sInt GetDataWords() {return DataMax;}
  sInt GetStringMax() {return StringMax;}
  sInt GetSplineMax() {return SplineMax;}
  sU8 *GetAnimCode() {return AnimCode;}

  const sU8 *GetBlob(sInt &size) {size=BlobSize; return BlobData;}  // get blob (if there)
  sInt GetBlobSize() {return BlobSize;}
  const sU8 *GetBlobData() {return BlobData;}
  void SetBlob(const sU8 *data,sInt size); // set blob, no copy is made, so please do not delete memory.

  void Init(sU32 convention);     // allocate buffers to fit this convention
  void Exit();                    // free buffers
#if !sPLAYER                      // interface for player to manage dynamic array
  void ReAlloc(sInt newin,sInt newout); // realloc, eventually changing a string
  void SetString(sInt i,sChar *c);
  void SetSpline(sInt i,KSpline *s);
  void ClearInput() {InputCount=0;}
  void ClearOutput() {OutputCount=0;}
  void AddInput(KOp *op);
  void AddOutput(KOp *op);
  void SetLink(sInt i,KOp *op) {if(i<LinkMax) Link[i]=op; else sVERIFY(op==0);}
  void SetAnimCode(sU8 *AnimCode,sInt size);
  void CopyEditToAnim();
  void Uncache();
  sBool HasAnim()              {return GetAnimCode()[0] != KA_END;}

  sU8  *GetEditPtr (sInt i) {return ((sU8 *)DataEdit)+i;}
  sU32 *GetEditPtrU(sInt i) {return ((sU32*)DataEdit)+i;}
  sS32 *GetEditPtrS(sInt i) {return ((sS32*)DataEdit)+i;}
  sF32 *GetEditPtrF(sInt i) {return ((sF32*)DataEdit)+i;}
  sU8  *GetAnimPtr (sInt i) {return ((sU8 *)DataAnim)+i;}
  sU32 *GetAnimPtrU(sInt i) {return ((sU32*)DataAnim)+i;}
  sS32 *GetAnimPtrS(sInt i) {return ((sS32*)DataAnim)+i;}
  sF32 *GetAnimPtrF(sInt i) {return ((sF32*)DataAnim)+i;}

  class WerkOp *Werk;             // backlink to werkop. no refcount, no nothing. just do it right
#else
  void AddInput(KOp *op)                {Input[InputCount++] = op;}
  void AddOutput(KOp *op)               {OutputCount++;}
  void SetLink(sInt i,KOp *op)          {Link[i]=op;}
  void SetString(sInt i,sChar *s)       {String[i]=s;}
  void SetSpline(sInt i,KSpline *s)     {Spline[i]=s;}
  void SetAnimCode(sU8 *code,sInt size) {AnimCode=code; AnimMax=size;}
  void SetBlobData(const sU8 *data)     {BlobData = data;}
  void CalcUsed();

  sU8  *GetEditPtr (sInt i) {return ((sU8 *)DataEdit)+i;}
  sU32 *GetEditPtrU(sInt i) {return ((sU32*)DataEdit)+i;}
  sS32 *GetEditPtrS(sInt i) {return ((sS32*)DataEdit)+i;}
  sF32 *GetEditPtrF(sInt i) {return ((sF32*)DataEdit)+i;}
  sU8  *GetAnimPtr (sInt i) {return ((sU8 *)DataAnim)+i;}
  sU32 *GetAnimPtrU(sInt i) {return ((sU32*)DataAnim)+i;}
  sS32 *GetAnimPtrS(sInt i) {return ((sS32*)DataAnim)+i;}
  sF32 *GetAnimPtrF(sInt i) {return ((sF32*)DataAnim)+i;}
#endif
};

/****************************************************************************/

struct KSplineKey                 // spline key !! don't change order for sHermite
{
  sF32 Time;                      // time   
  sF32 Value;                     // value
#if sLINK_GUI
  sF32 OldTime;                   // used for dragging
  sInt Select;                    // (only gui)
#endif
};

#define KSI_CUBIC     0
#define KSI_LINEAR    1
#define KSI_STEP      2

struct KSplineChannel             // spline
{
  sInt KeyCount;                  // number of keys (may be 0)
  KSplineKey *Keys;               // sorted array of spline keys
  sF32 Eval(sF32 time,sInt inter);// calculate spline pos
};

struct KSpline
{
  KSplineChannel Channel[4];      // spline channels
  sInt Count;                     // number of channels
  sInt Interpolation;             // KSI_??? kind of interpolation
  void Eval(sF32 time,sVector &v);// eval vector. fill with zero
#if !sPLAYER
  sInt SaveId;                    // number in export
#endif
};

struct KDoc
{
  void Init(const sU8 *&data);
  void Exit();

  sU8 *SongData;                  // only set in player
  sInt SongSize;
  sU8 *SampleData;
  sInt SampleSize;
  sInt BuzzTiming;
  sInt SongBPM;                   // not used in editor, only for player
  sInt SongLength;

  sArray<KOp> Ops;
  sArray<KEvent> Events;
  sArray<KSpline> Splines;
  KOp *RootOps[MAX_OP_ROOT];
  sInt CurrentRoot;

  void Reset();
  void Precalc(KEnvironment *kenv);
  void AddEvents(KEnvironment *kenv);

  sInt CountOps(KOp *start);
};

/****************************************************************************/

#if !sPLAYER

struct KObjectList                // object list for KMemoryManager
{
  sInt Size;                      // memory size currently spent in that class
  sInt Budget;                    // memory budget available
  sArray<KOp *> Ops;              // op pointers (LRU order)
};

class KMemoryManager_
{
  KObjectList Objects[KC_COUNT];  // one for each class

public:
  KMemoryManager_();
  ~KMemoryManager_();

  sInt GetBudget(sInt type);
  void SetBudget(sInt type,sInt size);  // set budget for that object type
  sInt GetSize(sInt type);        // size currently spent for that type
  sInt GetCount(sInt type);       // # of cached ops in that type
  void Use(KOp *op);              // mark op as used
  void Remove(KOp *op);           // remove op from list (and from memory)
  void Manage();                  // make room if necessary

  void Validate();                // consistency check
};

extern KMemoryManager_ *KMemoryManager;

void MemManagerInit();
void MemManagerExit();

#endif

/****************************************************************************/
/****************************************************************************/

class GenScene;

KObject * __stdcall Init_Misc_Nop(KOp *op);
KObject * __stdcall Init_Misc_If(KOp *op);
KObject * __stdcall Init_Misc_Load(KObject *o);
KObject * __stdcall Init_Misc_Event(KObject *o,sF32 duration);
KObject * __stdcall Init_Misc_EventTime(KObject *o);
KObject * __stdcall Init_Misc_Trigger(KObject *o,KOp *event,
  sF32 trigger,sF32 tresh,sF32 delay,sF32 duration,sInt flags,
  sF32 mod,sF32 vel,sInt sel,sF323 s,sF323 r,sF323 t,sU32 col,KSpline *spline);
GenScene * __stdcall Init_Misc_PlaySample(GenScene *scene,sInt sw,sInt val,sF32 tresh,sInt sample,sF32 volume,sF32 retrigger,sF32 halfrange);
KObject * __stdcall Init_Misc_Demo(KOp *op);
KObject * __stdcall Init_Misc_MasterCam(sF323 rot,sF323 pos,sF32 farclip,sF32 nearclip,sF32 centerx,sF32 centery,sF32 zoomx,sF32 zoomy);
void __stdcall Exec_Misc_Nop(KOp *op,KEnvironment *kenv);
void __stdcall Exec_Misc_Load(KOp *op,KEnvironment *kenv);
void __stdcall Exec_Misc_Time(KOp *op,KEnvironment *kenv);
void __stdcall Exec_Misc_Event(KOp *op,KEnvironment *kenv,sF32 duration);
void __stdcall Exec_Misc_EventTime(KOp *op,KEnvironment *kenv);
void __stdcall Exec_Misc_Trigger(KOp *op,KEnvironment *kenv,
  sF32 trigger,sF32 tresh,sF32 delay,sF32 duration,sInt flags,
  sF32 mod,sF32 vel,sInt sel,sF323 s,sF323 r,sF323 t,sU32 col,KSpline *spline);
void __stdcall Exec_Misc_Delay(KOp *op,KEnvironment *kenv,sInt flags,sInt sw,sF32 tresh,sF32 hyst,sF32 time0,sF32 time1,sF32 time2);
void __stdcall Exec_Misc_State(KOp *op,KEnvironment *kenv,sInt sw,sInt val,sInt cond,sInt condsw,sInt condval);
void __stdcall Exec_Misc_SetIf(KOp *op,KEnvironment *kenv,sInt sw,sInt val,sInt var,sInt osw);
void __stdcall Exec_Misc_Menu(KOp *op,KEnvironment *kenv,sInt sw,sInt max,sInt flags);
void __stdcall Exec_Misc_If(KOp *op,KEnvironment *kenv,sInt sw,sInt val);
void __stdcall Exec_Misc_PlaySample(KOp *op,KEnvironment *kenv,sInt sw,sInt val,sF32 tresh,sInt sample,sF32 volume,sF32 retrigger,sF32 halfrange);
void __stdcall Exec_Misc_Demo(KOp *op,KEnvironment *kenv);
void __stdcall Exec_Misc_Menu(KOp *op,KEnvironment *kenv,sInt sw,sInt max,sInt flags);
void __stdcall Exec_Misc_MasterCam(KOp *op,KEnvironment *kenv,sF323 rot,sF323 pos,sF32 farclip,sF32 nearclip,sF32 centerx,sF32 centery,sF32 zoomx,sF32 zoomy);

class GenDemo : public KObject
{
public:
  GenDemo();
  ~GenDemo();
};

/****************************************************************************/
/****************************************************************************/

template <class t> __forceinline t * KEnvironment::GetInst(KOp *me)
{
  return (t *)GetInstImpl(me,sizeof(t));
}

/****************************************************************************/
/****************************************************************************/

#endif