_types.cpp

// Written by Fabian "ryg" Giesen.
// I hereby place this code in the public domain.

#include "_types.hpp"
#include "_startconsole.hpp"

/****************************************************************************/
/***                                                                      ***/
/***   Compiler                                                           ***/
/***                                                                      ***/
/****************************************************************************/

/****************************************************************************/
/***                                                                      ***/
/***   Init/Exit                                                          ***/
/***                                                                      ***/
/****************************************************************************/

void sDLLSYSTEM sInitTypes();
void sDLLSYSTEM sExitTypes();
#if sINTRO
extern class ScriptRuntime *SR__;
#endif
/****************************************************************************/
/***                                                                      ***/
/***   Forwards                                                           ***/
/***                                                                      ***/
/****************************************************************************/

static sU32 sRandomSeed=0x74382381;

sU32 sGetRnd()
{
  sU32 i;

  _asm
  {
    mov eax,sRandomSeed

    imul eax,eax,343fdh
    add eax,269ec3h
    mov ebx,eax

    imul eax,eax,343fdh
    add eax,269ec3h

    mov sRandomSeed,eax

    sar eax,10
    and eax,00000ffffh
    shl ebx,6
    and ebx,0ffff0000h
    or eax,ebx
    mov i,eax
  }

  return i;
}

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

sU32 sGetRnd(sU32 max)
{
  return sGetRnd()%max;
}

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

sF32 sFGetRnd()
{
  return ((sGetRnd()&0x3fffffff)*1.0f)/0x40000000;
}

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

sF32 sFGetRnd(sF32 max)
{
  return ((sGetRnd()&0x3fffffff)*max)/0x40000000;
}

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

void sSetRndSeed(sInt seed)
{
  sRandomSeed = seed+seed*17+seed*121+(seed*121/17);
  sGetRnd();  
  sRandomSeed ^= seed+seed*17+seed*121+(seed*121/17);
  sGetRnd();  
  sRandomSeed ^= seed+seed*17+seed*121+(seed*121/17);
  sGetRnd();  
  sRandomSeed ^= seed+seed*17+seed*121+(seed*121/17);
  sGetRnd();
}

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

sInt sMakePower2(sInt val)
{
  sInt p;

  p = 1;

  while(p<val)
    p = p*2;
  return p;
}

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

sInt sGetPower2(sInt val)
{
  sInt p;

  p = 1;

  while((1<<p)<val)
    p++;
  return p;
}

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

#if !sINTRO // this is inlined in spline class! 
void sHermite(sF32 *d,sF32 *p0,sF32 *p1,sF32 *p2,sF32 *p3,sInt count,sF32 fade,sF32 t,sF32 c,sF32 b)
{
  sF32 f1,f2,f3,f4;
  sF32 t0,t1,t2,t3;
  sF32 a1,b1,a2,b2;
  sInt i;

  a1 = (1-t)*(1-c)*(1+b)/2;
  b1 = (1-t)*(1+c)*(1-b)/2;
  a2 = (1-t)*(1+c)*(1+b)/2;
  b2 = (1-t)*(1-c)*(1-b)/2;

  t1 = p1[-1];
  t2 = p2[-1];

  if(p0==0)
  {
    p0 = p2;
    a1 = -a1;
    t0 = t1+(t1-t2);
  }
  else
  {
    t0 = p0[-1];
  }
  if(p3==0)
  {
    p3 = p1;
    b2 = -b2;
    t3 = t2+(t2-t1);
  }
  else
  {
    t3 = p3[-1];
  }

  f1 =  2*fade*fade*fade - 3*fade*fade + 1;
  f2 = -2*fade*fade*fade + 3*fade*fade;
  f3 =    fade*fade*fade - 2*fade*fade + fade;
  f4 =    fade*fade*fade -   fade*fade;
 
  t0 = t1-t0;
  t1 = t2-t1;
  t2 = t3-t2;
  f3 = f3 * 2*t1/(t1+t0);
  f4 = f4 * 2*t1/(t1+t2);

  sVERIFY(count<=9);

  for(i=0;i<count;i++)
  {
    d[i] = f1 * p1[i]
         + f2 * p2[i]
         + f3 * (a1*(p1[i]-p0[i]) + b1*(p2[i]-p1[i]))
         + f4 * (a2*(p2[i]-p1[i]) + b2*(p3[i]-p2[i]));
  }
}
#endif
/*
sInt sRangeInt(sInt a,sInt b,sInt c)
{
  return sRange(a,b,c);
}
sF32 sRangeF32(sF32 a,sF32 b,sF32 c)
{
  return sRange(a,b,c);
}
*/
#if sINTRO

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

sF64 sFPow(sF64 a,sF64 b)
{
	__asm
	{
		fld		qword ptr [a];
		fld		qword ptr [b];

		fxch	st(1);
		ftst;
		fstsw	ax;
		sahf;
		jz		zero;

		fyl2x;
		fld1;
		fld		st(1);
		fprem;
		f2xm1;
		faddp	st(1), st;
		fscale;

zero:
		fstp	st(1);
		fstp	qword ptr [a];
	}
	
	return a;
}

sF64 sFExp(sF64 f)
{
	__asm
	{
		fld		qword ptr [f];
		fldl2e;
		fmulp	st(1), st;

		fld1;
		fld		st(1);
		fprem;
		f2xm1;
		faddp	st(1), st;
		fscale;

    fstp  st(1);
		fstp	qword ptr [f];
	}

	return f;
}


#endif


/****************************************************************************/
/***                                                                      ***/
/***   Memory and String                                                  ***/
/***                                                                      ***/
/****************************************************************************/

void sCopyMem4(sU32 *d,const sU32 *s,sInt c)
{
  __asm
  {
    mov esi,[s]
    mov edi,[d]
    mov ecx,[c]
    rep movsd
  }
}

#if !sINTRO
void sCopyMem8(sU64 *d,const sU64 *s,sInt c)  
{
  __asm
  {
    mov esi,[s]
    mov edi,[d]
    mov ecx,[c]
    add ecx,ecx
    rep movsd
  }
}
#endif

#if !sINTRO

sChar *sDupString(const sChar *s,sInt minsize)
{
  sInt size;
  sChar *d;

  if(s==0)
    return 0;

  size = sGetStringLen(s)+1;
  if(minsize>size)
    size = minsize;

  d = new sChar[size];
  sCopyString(d,s,size);
  return d;
}

#endif

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

#if !sINTRO || !sRELEASE
void sCopyString(sChar *d,const sChar *s,sInt size)
{
  while(size>0 && *s)
  {
    size--;
    *d++ = *s++;
  }
  *d = 0;
}
#endif


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

#if !sINTRO

void sAppendString(sChar *d,const sChar *s,sInt size)
{
  while(size>0 && *d)
  {
    size--;
    d++;
  }
  while(size>0 && *s)
  {
    size--;
    *d++ = *s++;
  }
  *d = 0;
}

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

void sParentString(sChar *path)
{
  sChar *s,*e;

  e = path;
  s = path;
  while(s[0] && s[1])
  {
    if(*s=='/' && (s!=path || s[-1]!=':'))
      e = s+1;
    s++;
  }

  *e = 0;
}

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

sInt sCmpString(const sChar *a,const sChar *b)
{
  sInt aa,bb;
  do
  {
    aa = *a++;
    bb = *b++;
  }
  while(aa!=0 && aa==bb);
  return sSign(aa-bb);
}

sInt sCmpStringI(const sChar *a,const sChar *b)
{
  sInt aa,bb;
  do
  {
    aa = *a++;
    bb = *b++;
    if(aa>='A' && aa<='Z') aa=aa-'A'+'a';
    if(bb>='A' && bb<='Z') bb=bb-'A'+'a';
  }
  while(aa!=0 && aa==bb);
  return sSign(aa-bb);
}

const sChar *sFindString(const sChar *s,const sChar *f)
{
  sInt len,i,slen;

  len = sGetStringLen(f);
  slen = sGetStringLen(s);
  for(i=0;i<=slen-len;i++)
  {
    if(sCmpMem(s+i,f,len)==0)
      return s+i;
  }
  return 0;
}
/*
sChar *sFindStringI(sChar *s,sChar *f)
{
  sInt len,i,slen;

  len = sGetStringLen(f);
  slen = sGetStringLen(s);
  for(i=0;i<=slen-len;i++)
  {
    if(sCmpMemI(s+i,f,len)==0)
      return s+i;
  }
  return 0;
}
*/
#endif
/****************************************************************************/
/****************************************************************************/

#if !sINTRO
sInt sScanInt(sChar *&scan)
{
  sInt val; 
  sInt sign;

  sign = 1;
  val = 0;

  if(*scan=='\'')
  {
    if(scan[1]!=0 && scan[2]=='\'')
    {
      val = scan[1];
      scan+=3;
      return val;
    }
    return 0;
  }

  if(*scan=='+')
    scan++;
  else if(*scan=='-')
  {
    sign = -1;
    scan++;
  }

  if(*scan=='$' || *scan=='#')
  {
    scan++;
    for(;;)
    {
      if(*scan>='0' && *scan<='9')
        val = val*16+(*scan)-'0';
      else if(*scan>='a' && *scan<='f')
        val = val*16+(*scan)-'a'+10;
      else if(*scan>='A' && *scan<='F')
        val = val*16+(*scan)-'A'+10;
      else
        break;
      scan++;
    }
  }
  else
  {
    while(*scan>='0' && *scan<='9')
      val = val*10+(*scan++)-'0';
  }

  return val*sign;
}


sInt sScanHex(sChar *&scan)
{
  sInt val; 
  sInt sign;

  sign = 1;
  val = 0;

  if(*scan=='+')
    scan++;
  else if(*scan=='-')
  {
    sign = -1;
    scan++;
  }

  for(;;)
  {
    if(*scan>='0' && *scan<='9')
      val = val*16+(*scan)-'0';
    else if(*scan>='a' && *scan<='f')
      val = val*16+(*scan)-'a'+10;
    else if(*scan>='A' && *scan<='F')
      val = val*16+(*scan)-'A'+10;
    else
      break;
    scan++;
  }

  return val*sign;
}

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

sF32 sScanFloat(sChar *&scan)
{
  sF64 val;
  sInt sign;
  sF64 dec;

  sign = 1;
  val = 0;

  if(*scan=='+')
    scan++;
  else if(*scan=='-')
  {
    sign = -1;
    scan++;
  }

  while(*scan>='0' && *scan<='9')
    val = val*10+(*scan++)-'0';
  if(*scan=='.')
  {
    scan++;
    dec = 1.0;
    while(*scan>='0' && *scan<='9')
    {
      dec = dec/10.0;
      val = val + ((*scan++)-'0')*dec;
    }
  }

  return val*sign;
}

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

sBool sScanString(sChar *&scan,sChar *buffer,sInt size)
{
  if(*scan!='"')
    return sFALSE;
  scan++;
  while(*scan!='"' && *scan!=0 && *scan!='\r' && *scan!='\n' && size>1)
  {
    *buffer++ = *scan++;
    size--;
  }
  *buffer++ = 0;
  if(*scan=='"')
  {
    scan++;
    return sTRUE;
  }
  else
    return sFALSE;
}

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

sBool sScanName(sChar *&scan,sChar *buffer,sInt size)
{
  sBool done;

  done = sFALSE;

  if(!((*scan>='a' && *scan<='z') || 
       (*scan>='A' && *scan<='Z') || *scan=='_' )) 
    return sFALSE;

  *buffer++ = *scan++;
  size--;

  while(size>1)
  {
    if(!((*scan>='a' && *scan<='z') || 
         (*scan>='A' && *scan<='Z') || 
         (*scan>='0' && *scan<='9') || *scan=='_' )) 
    {
      *buffer++=0;
      return sTRUE;
    }
    *buffer++ = *scan++;
    size--;
  }

  *buffer++=0;
  return sFALSE;
}

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

void sScanSpace(sChar *&scan)
{
  while(*scan==' ' || *scan=='\t' || *scan=='\r' || *scan=='\n')
    scan++;
}

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

sBool sScanCycle(sChar *s,sInt index,sInt &start,sInt &len)
{
  start = 0;
  len = 0;
  while(index>0)
  {
    while(s[start]!='|' && s[start]!=0)
      start++;
    if(s[start]!='|')
      return sFALSE;
    start++;
    index--;
  }
  while(s[start+len]!='|' && s[start+len]!=0)
    len++;
  return sTRUE;
}

#endif

/****************************************************************************/
/***                                                                      ***/
/***   Formatted Printing                                                 ***/
/***                                                                      ***/
/****************************************************************************/

#if !sINTRO || _DEBUG

extern "C" char * __cdecl _fcvt( double value, int count, int *dec, int *sign );

void sFormatString(sChar *d,sInt left,const sChar *s,sChar **fp)
{
  sInt c;
  sInt field0;
  sInt field1;
  sInt minus;
  sInt null;
  sInt len;
  sChar buffer[64];
  sChar *string;
  sInt val;
  sInt arg;
  sInt sign;
  sInt i;
  sF64 fval;
  static sChar hex[17] = "0123456789abcdef";
  static sChar HEX[17] = "0123456789ABCDEF";

  arg = 0;
  left--;

  c = *s++;
  while(c)
  {
    if(c=='%')
    {
      c = *s++;

      minus = 0;
      null = 0;
      field0 = 0;
      field1 = 4;

      if(c=='-')
      {
        minus = 1;
        c = *s++;
      }
      if(c=='0')
      {
        null = 1;
      }
      while(c>='0' && c<='9')
      {
        field0 = field0*10 + c - '0';
        c = *s++;
      }
      if(c=='.')
      {
        field1=0;
        c = *s++;
        while(c>='0' && c<='9')
        {
          field1 = field1*10 + c - '0';
          c = *s++;
        }
      }

      if(c=='%')
      {
        c = *s++;
        if(left>0)
        {
          *d++ = '%';
          left--;
        }
      }
      else if(c=='d' || c=='x' || c=='X' || c=='i' || c=='f')
      {
        len = 0;
        sign = 0;
        if(c=='f')
        {
          fval = sVARARGF(fp,arg);arg+=2;
        }
        else
        {
          val = sVARARG(fp,arg);arg++;
        }
        if(c=='f')        // this is preliminary!!!!!!!
        {
#if sINTRO
          string = "???";
#else
          if(fval<0)
            field1++;
          string = _fcvt(fval,field1,&i,&sign);
#endif
          if(i<0)
          {
            buffer[len++]='.';
            while(i<=-1)
            {
              i++;
              buffer[len++]='0';
            }
            i=-1;
          }
          while(*string)
          {
            if(i==0)
              buffer[len++]='.';
            i--;
            buffer[len++]=*string++;
          }
        }
        else if(c=='d' || c=='i')
        {          
          if(val==0x80000000)
          {
            val = val/10;
            buffer[len++] = '8';
          }
          if(val<0)
          {
            sign = 1;
            val = -val;
          }
          do
          {
            buffer[len++] = val%10+'0';
            val = val/10;
          }
          while(val!=0);
          if(sign)
            len++;

        }
        else if(c=='x' || c=='X')
        {
          do
          {
            if(c=='x')
              buffer[len] = hex[val&15];
            else
              buffer[len] = HEX[val&15];
            val = (val>>4)&0x0fffffff;
            len++;
          }
          while(val!=0);
        }

        if(!minus && !null)
        {
          while(field0>len && left>0)
          {
            *d++ = ' ';
            left--;
            field0--;
          }
        }
        if(sign && left>0)
        {
          *d++ = '-';
          left--;
          field0--;
          len--;
        }
        if(!minus && null)
        {
          while(field0>len && left>0)
          {
            *d++ = '0';
            left--;
            field0--;
          }
        }
        i = 0;
        while(len>0 && left>0)
        {
          len--;
          if(c=='f')
            *d++ = buffer[i++];
          else
            *d++ = buffer[len];
          left--;
          field0--;
        }
        if(!minus)
        {
          while(field0>len && left>0)
          {
            *d++ = ' ';
            left--;
            field0--;
          }
        }
        c = *s++;
      }
      else if(c=='c')
      {
        val = (sInt)sVARARG(fp,arg);arg++;
        if(left>0)
        {
          *d++ = val;
          left--;
        }
        c = *s++;
      }
      else if(c=='s')
      {
        string = (sChar *)sVARARG(fp,arg);arg++;
        len = sGetStringLen(string);
        if(field0<=len)
          field0=len;
        if(!minus)
        {
          while(field0>len && left>0)
          {
            *d++ = ' ';
            left--;
            field0--;
          }
        }
        while(*string && left>0)
        {
          *d++=*string++;
          left--;
        }
        if(minus)
        {
          while(field0>len && left>0)
          {
            *d++ = ' ';
            left--;
            field0--;
          }
        }
        c = *s++;
      }
      else if(c=='h' || c=='H') 
      {
        val = sVARARG(fp,arg);arg++;
        if(c=='H')
        {
          if(sAbs(val)>=0x00010000)
          {
            if(val>0x80000000)             
              val |= 0x000000ff;
            else
              val &= 0xffffff00;
          }
        }
        *d++ = '0';
        *d++ = 'x';
        *d++ = hex[(val>>28)&15];
        *d++ = hex[(val>>24)&15];
        *d++ = hex[(val>>20)&15];
        *d++ = hex[(val>>16)&15];
        *d++ = '.';
        *d++ = hex[(val>>12)&15];
        *d++ = hex[(val>> 8)&15];
        *d++ = hex[(val>> 4)&15];
        *d++ = hex[(val    )&15];
        c = *s++;
      }
      else if(c!=0)
      {
        c = *s++;
      }
    }
    else
    {
      if(left>0)
      {
        *d++ = c;
        left--;
      }
      c = *s++;
    }
  }
  *d=0;
}


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

void __cdecl sSPrintF(sChar *buffer,sInt size,const sChar *format,...)
{
  sFormatString(buffer,size,format,(sChar **) &format);
}

#endif


/****************************************************************************/
/***                                                                      ***/
/***   File Reading and Writing                                           ***/
/***                                                                      ***/
/****************************************************************************/

#if !sINTRO
void sWriteString(sU32 *&data,sChar *str)
{
  sInt size;

  size = sGetStringLen(str);
  *data++ = size;
  data[size/4] = 0;

  sCopyMem(data,str,size);
  data+=(size+3)/4;
}

sBool sReadString(sU32 *&data,sChar *str,sInt max)
{
  sInt size;

  size = *data++;
  if(size+1>max)
  {
    str[0] = 0;
    return sFALSE;
  }
  sCopyMem(str,data,size);
  str[size] = 0;
  data+=(size+3)/4;

  return sTRUE;
}

sU32 *sWriteBegin(sU32 *&data,sU32 cid,sInt version)
{
  *data++ = sMAGIC_BEGIN;
  *data++ = cid;
  *data++ = version;
  *data++ = 0;
  return data-1;
}

void sWriteEnd(sU32 *&data,sU32 *header)
{
  if(header)
    *header = data-(header+1);
  *data++ = sMAGIC_END;
}

sInt sReadBegin(sU32 *&data,sU32 cid)
{
  sInt version;
  sInt size;

  if(*data++!=sMAGIC_BEGIN) return 0;
  if(*data++!=cid) return 0;
  version = *data++;
  size = *data++;
  if(data[size]!=sMAGIC_END) return 0;
  return version;
}

sBool sReadEnd(sU32 *&data)
{
  if(*data++!=sMAGIC_END) return 0;
  return sTRUE;
}
#endif

/****************************************************************************/
/***                                                                      ***/
/***   Debugging                                                          ***/
/***                                                                      ***/
/****************************************************************************/

void sVerifyFalse(sChar *file,sInt line)
{
#if !sINTRO
  sFatal("%s(%d) : assertion",file,line);
#else
  sFatal("assertion");
#endif
}

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

#if !sINTRO || _DEBUG 
void __cdecl sFatal(sChar *format,...)
{
  static sChar buffer[1024];

  sFormatString(buffer,sizeof(buffer),format,&format);
  sSystem->Log(buffer);
  sSystem->Log("\n");
  sSystem->Abort(buffer);
}
#endif

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

#if !sINTRO || !sRELEASE
void sDPrint(sChar *text)
{
  sSystem->Log(text);
}
#endif

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

#if !sINTRO || !sRELEASE
void __cdecl sDPrintF(sChar *format,...)
{
  sChar buffer[1024];

  sFormatString(buffer,sizeof(buffer),format,&format);
  sSystem->Log(buffer);
}  
#endif

/****************************************************************************/
/***                                                                       ***/
/***   Simple Structs                                                     ***/
/***                                                                      ***/
/****************************************************************************/

#if !sINTRO

void sRect::Init(struct sFRect &r) 
{
  x0=sFtol(r.x0); 
  y0=sFtol(r.y0);
  x1=sFtol(r.x1); 
  y1=sFtol(r.y1);
}

sBool sRect::Hit(sInt x,sInt y)
{
  return x>=x0 && x<x1 && y>=y0 && y<y1;
}

sBool sRect::Hit(sRect &rin)
{
  sRect r;
  r = *this;
  r.And(rin);
  return r.x0<r.x1 && r.y0<r.y1;
}

sBool sRect::Inside(sRect &r)
{
  if(x0  < r.x0) return sFALSE;
  if(y0  < r.y0) return sFALSE;
  if(x1 >= r.x1) return sFALSE;
  if(y1 >= r.y1) return sFALSE;
  return sTRUE;
}

void sRect::And(sRect &r)
{
  if(r.x0 > x0) x0 = r.x0;
  if(r.y0 > y0) y0 = r.y0;
  if(r.x1 < x1) x1 = r.x1;
  if(r.y1 < y1) y1 = r.y1;
}

void sRect::Or(sRect &r)
{
  if(r.x0 < x0) x0 = r.x0;
  if(r.y0 < y0) y0 = r.y0;
  if(r.x1 > x1) x1 = r.x1;
  if(r.y1 > y1) y1 = r.y1;
}

void sRect::Sort()
{
  if(x0>x1) sSwap(x0,x1);
  if(y0>y1) sSwap(y0,y1);
}

void sRect::Extend(sInt i)
{
  x0-=i;
  y0-=i;
  x1+=i;
  y1+=i;
}

#endif

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

#if !sINTRO

void sFRect::Init(struct sRect &r) 
{
  x0=r.x0; 
  y0=r.y0; 
  x1=r.x1;
  y1=r.y1;
}

sBool sFRect::Hit(sF32 x,sF32 y)
{
  return x>=x0 && x<x1 && y>=y0 && y<y1;
}

sBool sFRect::Hit(sFRect &rin)
{
  sFRect r;
  r = *this;
  r.And(rin);
  return r.x0<r.x1 && r.y0<r.y1;
}

void sFRect::And(sFRect &r)
{
  if(r.x0 > x0) x0 = r.x0;
  if(r.y0 > y0) y0 = r.y0;
  if(r.x1 < x1) x1 = r.x1;
  if(r.y1 < y1) y1 = r.y1;
}

void sFRect::Or(sFRect &r)
{
  if(r.x0 < x0) x0 = r.x0;
  if(r.y0 < y0) y0 = r.y0;
  if(r.x1 > x1) x1 = r.x1;
  if(r.y1 > y1) y1 = r.y1;
}

void sFRect::Sort()
{
  if(x0>x1) sSwap(x0,x1);
  if(y0>y1) sSwap(y0,y1);
}

void sFRect::Extend(sF32 i)
{
  x0-=i;
  y0-=i;
  x1+=i;
  y1+=i;
}

#endif

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

#if !sINTRO

static sInt sClamp256x(sInt a)
{
  if(a<0)
    return 0;
  if(a>255)
    return 255;
  return a;
}

void sColor::Fade(sF32 fade,sColor c0,sColor c1)
{
  sInt ff;

  ff = sFtol(fade*256);
  r = sClamp256x(c0.r + (((c1.r-c0.r)*ff)>>8));
  g = sClamp256x(c0.g + (((c1.g-c0.g)*ff)>>8));
  b = sClamp256x(c0.b + (((c1.b-c0.b)*ff)>>8));
  a = sClamp256x(c0.a + (((c1.a-c0.a)*ff)>>8));
}

void sColor::Fade(sInt fade,sColor c0,sColor c1)
{
  r = sClamp256x(c0.r + (((c1.r-c0.r)*fade)>>8));
  g = sClamp256x(c0.g + (((c1.g-c0.g)*fade)>>8));
  b = sClamp256x(c0.b + (((c1.b-c0.b)*fade)>>8));
  a = sClamp256x(c0.a + (((c1.a-c0.a)*fade)>>8));
}

#endif

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

#if !sINTRO

void sPlacer::Init(sRect &r,sInt xdiv,sInt ydiv)
{
  XPos = r.x0;
  YPos = r.y0;
  XSize = r.XSize();
  YSize = r.YSize();
  XDiv = xdiv;
  YDiv = ydiv;
}

void sPlacer::Div(sRect &r,sInt x,sInt y,sInt xs,sInt ys)
{
  xs+=x;
  ys+=y;
  r.x0 = XPos + x  * XSize / XDiv;
  r.y0 = YPos + y  * YSize / YDiv;
  r.x1 = XPos + xs * XSize / XDiv;
  r.y1 = YPos + ys * YSize / YDiv;
}

#endif

/****************************************************************************/
/***                                                                      ***/
/***   Vector and Matrix                                                  ***/
/***                                                                      ***/
/****************************************************************************/

//void sVector::Init(sInt3 &v)                                 {x=v.x/65536.0f; y=v.y/65536.0f; z=v.z/65536.0f; w=0.0f;}
//void sVector::Init(sInt4 &v)																	{x=v.x/65536.0f; y=v.y/65536.0f; z=v.z/65536.0f; w=v.w/65536.0f;}
//void sVector::InitColor(sU32 col)                            {x=((col>>0)&0xff)/255.0f;y=((col>>8)&0xff)/255.0f;z=((col>>16)&0xff)/255.0f;w=((col>>24)&0xff)/255.0f;}
//sU32 sVector::GetColor()                                     {return sRange<sInt>(x*255,255,0)|(sRange<sInt>(y*255,255,0)<<8)|(sRange<sInt>(z*255,255,0)<<16)|(sRange<sInt>(w*255,255,0)<<24);}

void sVector::InitRnd()
{
  do
  {
    x = sFGetRnd()*2.0f-1.0f;
    y = sFGetRnd()*2.0f-1.0f;
    z = sFGetRnd()*2.0f-1.0f;
  }
  while(Dot3(*this)>1.0f);
}

void sVector::Lin3(const sVector &a,const sVector &b,sF32 t) {x=a.x+(b.x-a.x)*t; y=a.y+(b.y-a.y)*t; z=a.z+(b.z-a.z)*t;}
void sVector::Rotate3(const sMatrix &m,const sVector &v)     {Scale3(m.i,v.x); AddScale3(m.j,v.y); AddScale3(m.k,v.z);}
void sVector::Rotate3(const sMatrix &m)                      {sVector v; v=*this; Rotate3(m,v);}
void sVector::RotateT3(const sMatrix &m,const sVector &v)    {x=m.i.Dot3(v); y=m.j.Dot3(v); z=m.k.Dot3(v);}
void sVector::RotateT3(const sMatrix &m)                     {sVector v; v=*this; RotateT3(m,v);}
void sVector::Cross3(const sVector &a,const sVector &b)      {x=a.y*b.z-a.z*b.y; y=a.z*b.x-a.x*b.z; z=a.x*b.y-a.y*b.x;}
sF32 sVector::Abs3() const                                   {return sFSqrt(Dot3(*this));}
void sVector::Unit3()                                        {Scale3(sFInvSqrt(Dot3(*this)));}
void sVector::UnitSafe3()                                    {sF32 e=Dot3(*this); if(e>0.00001) Scale3(sFInvSqrt(e)); else Init3(1,0,0);}

void sVector::Lin4(const sVector &a,const sVector &b,sF32 t) {x=a.x+(b.x-a.x)*t; y=a.y+(b.y-a.y)*t; z=a.z+(b.z-a.z)*t; w=a.w+(b.w-a.w)*t;}
void sVector::Rotate4(const sMatrix &m,const sVector &v)     {Scale4(m.i,v.x); AddScale4(m.j,v.y); AddScale4(m.k,v.z); AddScale4(m.l,v.w);}
void sVector::Rotate4(const sMatrix &m)                      {sVector v; v=*this; Rotate4(m,v);}
void sVector::Rotate34(const sMatrix &m,const sVector &v)    {Scale4(m.i,v.x); AddScale4(m.j,v.y); AddScale4(m.k,v.z); Add4(m.l);}
void sVector::Rotate34(const sMatrix &m)                     {sVector v; v=*this; Rotate34(m,v);}
void sVector::RotateT4(const sMatrix &m,const sVector &v)    {x=m.i.Dot4(v); y=m.j.Dot4(v); z=m.k.Dot4(v); w=m.l.Dot4(v);}
void sVector::RotateT4(const sMatrix &m)                     {sVector v; v=*this; RotateT4(m,v);}
sF32 sVector::Abs4() const                                   {return Dot4(*this);}
void sVector::Unit4()                                        {Scale4(sFInvSqrt(Dot4(*this)));}
void sVector::UnitSafe4()                                    {sF32 e=Dot4(*this); if(e>0.00001) Scale4(sFInvSqrt(e)); else Init4(1,0,0,0);}

#if !sINTRO

void sVector::Write(sU32 *&p)
{
  ((sF32 *)p)[0] = x;
  ((sF32 *)p)[1] = y;
  ((sF32 *)p)[2] = z;
  ((sF32 *)p)[3] = w;
  p+=4;
}


void sVector::Write3(sU32 *&p)
{
  ((sF32 *)p)[0] = x;
  ((sF32 *)p)[1] = y;
  ((sF32 *)p)[2] = z;
  p+=3;
}


void sVector::Write3U(sU32 *&p)
{
  ((sF32 *)p)[0] = x;
  ((sF32 *)p)[1] = y;
  p+=2;
}


void sVector::Read(sU32 *&p)
{
  x = ((sF32 *)p)[0];
  y = ((sF32 *)p)[1];
  z = ((sF32 *)p)[2];
  w = ((sF32 *)p)[3];
  p+=4;
}


void sVector::Read3(sU32 *&p)
{
  x = ((sF32 *)p)[0];
  y = ((sF32 *)p)[1];
  z = ((sF32 *)p)[2];
  w = 1.0f;
  p+=3;
}


void sVector::Read3U(sU32 *&p)
{
  x = ((sF32 *)p)[0];
  y = ((sF32 *)p)[1];
  z = sFSqrt(1.0f-x*x-y*y);
  w = 1.0f;
  p+=2;
}

#endif

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

#if !sINTRO

void sMatrix::Write(sU32 *&f)
{
  i.Write(f);
  j.Write(f);
  k.Write(f);
  l.Write(f);
}

void sMatrix::WriteR(sU32 *&f)
{
  i.Write3U(f);
  j.Write3U(f);
  l.Write3(f);
}

void sMatrix::Write33(sU32 *&f)
{
  i.Write3(f);
  j.Write3(f);
  k.Write3(f);
}

void sMatrix::Write34(sU32 *&f)
{
  i.Write3(f);
  j.Write3(f);
  k.Write3(f);
  l.Write3(f);
}

void sMatrix::Write33R(sU32 *&f)
{
  i.Write3U(f);
  j.Write3U(f);
}

void sMatrix::Read(sU32 *&f)
{
  i.Read(f);
  j.Read(f);
  k.Read(f);
  l.Read(f);
}

void sMatrix::ReadR(sU32 *&f)
{
  i.Read3U(f); i.w=0.0f;
  j.Read3U(f); j.w=0.0f;
  k.Cross3(i,j); k.w=0.0f;
  l.Read3(f); l.w=1.0f;
}

void sMatrix::Read33(sU32 *&f)
{
  i.Read3(f); i.w = 0.0f;
  j.Read3(f); j.w = 0.0f;
  k.Read3(f); k.w = 0.0f;
  l.Init(0.0f,0.0f,0.0f,1.0f);
}

void sMatrix::Read34(sU32 *&f)
{
  i.Read3(f); i.w = 0.0f;
  j.Read3(f); j.w = 0.0f;
  k.Read3(f); k.w = 0.0f;
  l.Read3(f); k.w = 1.0f;
}

void sMatrix::Read33R(sU32 *&f)
{
  i.Read3U(f); i.w=0.0f;
  j.Read3U(f); j.w=0.0f;
  k.Cross3(i,j); k.w=0.0f;
  l.Init(0.0f,0.0f,0.0f,1.0f);
}

#endif

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

void sMatrix::Init()
{
  i.Init(1,0,0,0);
  j.Init(0,1,0,0);
  k.Init(0,0,1,0);
  l.Init(0,0,0,1);
}

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

void sMatrix::InitRot(const sVector &v)
{
  sF32 abs;
  sMatrix c,s;
  sVector u;
  sF32 cc,ss;

  abs = v.Abs3();
  if(abs>0.00000001)
  {
    Init();
  }
  else
  {
    cc = sFCos(abs);
    ss = sFSin(abs);
    u = v;
    u.Unit3();

    s.i.x = ss *  0;
    s.i.y = ss *  u.z; 
    s.i.z = ss * -u.y;
    s.j.x = ss * -u.z;
    s.j.y = ss *  0;
    s.j.z = ss *  u.x;
    s.k.x = ss *  u.y;
    s.k.y = ss * -u.x;
    s.k.z = ss *  0;

    c.i.x = cc * (1.0f-u.x*u.x);
    c.i.y = cc *       u.x*u.y ;
    c.i.z = cc *       u.x*u.z ;
    c.j.x = cc *       u.y*u.x ;
    c.j.y = cc * (1.0f-u.y*u.y);
    c.j.z = cc *       u.y*u.z ;
    c.k.x = cc *       u.z*u.x ;
    c.k.y = cc *       u.z*u.y ; 
    c.k.z = cc * (1.0f-u.z*u.z);

    i.x = u.x*u.x + c.i.x + s.i.x;
    i.y = u.x*u.y + c.i.y + s.i.y;
    i.z = u.x*u.z + c.i.z + s.i.z;
    i.w = 0.0f;
    j.x = u.y*u.x + c.j.x + s.j.x;
    j.y = u.y*u.y + c.j.y + s.j.y;
    j.z = u.y*u.z + c.j.z + s.j.z;
    j.w = 0.0f;
    k.x = u.z*u.x + c.k.x + s.k.x;
    k.y = u.z*u.y + c.k.y + s.k.y;
    k.z = u.z*u.z + c.k.z + s.k.z;
    k.w = 0.0f;
    l.Init4(0,0,0,1);
  }
}

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

void sMatrix::InitDir(const sVector &v)
{
  j.Init3(0,1,0);
  k = v;
  k.UnitSafe3();
  i.Cross3(j,k);
  i.UnitSafe3();
  j.Cross3(k,i);
  j.UnitSafe3();
  i.w = 0.0f;
  j.w = 0.0f;
  k.w = 0.0f;
  l.Init4(0,0,0,1);
}

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

#if !sINTRO
void sMatrix::InitEuler(sF32 a,sF32 b,sF32 c)
{
  sF32 sx,sy,sz;
  sF32 cx,cy,cz;

  sx = sFSin(a);
  cx = sFCos(a);
  sy = sFSin(b);
  cy = sFCos(b);
  sz = sFSin(c);
  cz = sFCos(c);

  i.x =  cy*cz;
  i.y =  cy*sz;
  i.z = -sy;
  i.w = 0.0f;
  j.x = -cx*sz + sx*sy*cz;
  j.y =  cx*cz + sx*sy*sz;
  j.z =  sx*cy;
  j.w = 0.0f;
  k.x =  sx*sz + cx*sy*cz;
  k.y = -sx*cz + cx*sy*sz;
  k.z =  cx*cy;
  k.w = 0.0f;
  l.Init4(0,0,0,1);
}
#endif

void sMatrix::InitEulerPI2(sF32 *a)
{
  sF32 sx,sy,sz;
  sF32 cx,cy,cz;
  sF32 v;
  v=a[0]*sPI2F;
  sx = sFSin(v);
  cx = sFCos(v);
  v=a[1]*sPI2F;
  sy = sFSin(v);
  cy = sFCos(v);
  v=a[2]*sPI2F;
  sz = sFSin(v);
  cz = sFCos(v);

  i.x =  cy*cz;
  i.y =  cy*sz;
  i.z = -sy;
  i.w = 0.0f;
  j.x = -cx*sz + sx*sy*cz;
  j.y =  cx*cz + sx*sy*sz;
  j.z =  sx*cy;
  j.w = 0.0f;
  k.x =  sx*sz + cx*sy*cz;
  k.y = -sx*cz + cx*sy*sz;
  k.z =  cx*cy;
  k.w = 0.0f;
  l.Init4(0,0,0,1);
}


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

void sMatrix::InitSRT(sF32 *srt)
{
  InitEulerPI2(srt+3);
  i.Scale3(srt[0]);
  j.Scale3(srt[1]);
  k.Scale3(srt[2]);
  l.Init3(srt[6],srt[7],srt[8]);
}

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

void sMatrix::InitSRTInv(sF32 *srt)
{
  sVector v;
  InitEulerPI2(srt+3);
  Trans3();
  i.Scale3(1.0f/srt[0]);
  j.Scale3(1.0f/srt[1]);
  k.Scale3(1.0f/srt[2]);
  v.Init3(-srt[6],-srt[7],-srt[8]);
  l.Rotate3(*this,v);
}

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

#if !sINTRO

void sMatrix::FindEuler(sF32 &a,sF32 &b,sF32 &c)
{
	sF32 cy;

	cy = sFSqrt(i.x*i.x+i.y*i.y);
	b = sFATan2(-i.z,cy);

	if(cy>1e-4f)
	{
		a = sFATan2(j.z,k.z);
		c = sFATan2(i.y,i.x);
	}
	else
	{
		a = sFATan2(-k.y,j.y);
		c = 0.0f;
	}
}

#endif

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

void sMatrix::Trans3()
{
  sSwap(i.y,j.x);
  sSwap(i.z,k.x);
  sSwap(j.z,k.y);
}

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

void sMatrix::Trans4()
{
  sSwap(i.y,j.x);
  sSwap(i.z,k.x);
  sSwap(i.w,l.x);
  sSwap(j.z,k.y);
  sSwap(j.w,l.y);
  sSwap(k.w,l.z);
}

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

void sMatrix::TransR()
{
  Trans3();
  l.Neg3();
  l.Rotate3(*this);
}

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

void sMatrix::InvCheap3()
{
  sVERIFYFALSE;
}

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

void sMatrix::Scale3(sF32 s)
{
  i.Scale3(s);
  j.Scale3(s);
  k.Scale3(s);
}

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

void sMatrix::InvCheap4()
{
  sVERIFYFALSE;
}

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

void sMatrix::Scale4(sF32 s)
{
  i.Scale4(s);
  j.Scale4(s);
  k.Scale4(s);
  l.Scale4(s);
}

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

void sMatrix::Mul3(const sMatrix &a,const sMatrix &b)
{
  i.Scale3(b.i,a.i.x); i.AddScale3(b.j,a.i.y); i.AddScale3(b.k,a.i.z);
  j.Scale3(b.i,a.j.x); j.AddScale3(b.j,a.j.y); j.AddScale3(b.k,a.j.z);
  k.Scale3(b.i,a.k.x); k.AddScale3(b.j,a.k.y); k.AddScale3(b.k,a.k.z);
/*
  i.x = a.i.x*b.i.x + a.i.y*b.j.x + a.i.z*b.k.x;
  i.y = a.i.x*b.i.y + a.i.y*b.j.y + a.i.z*b.k.y;
  i.z = a.i.x*b.i.z + a.i.y*b.j.z + a.i.z*b.k.z;
  j.x = a.j.x*b.i.x + a.j.y*b.j.x + a.j.z*b.k.x;
  j.y = a.j.x*b.i.y + a.j.y*b.j.y + a.j.z*b.k.y;
  j.z = a.j.x*b.i.z + a.j.y*b.j.z + a.j.z*b.k.z;
  k.x = a.k.x*b.i.x + a.k.y*b.j.x + a.k.z*b.k.x;
  k.y = a.k.x*b.i.y + a.k.y*b.j.y + a.k.z*b.k.y;
  k.z = a.k.x*b.i.z + a.k.y*b.j.z + a.k.z*b.k.z;
*/
}

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

void sMatrix::Mul4(const sMatrix &a,const sMatrix &b)
{
#if sINTRO
  sInt i;
  sF32 *tt;
  const sF32 *aa,*bb;
  tt = &this->i.x;
  aa = &a.i.x;
  bb = &b.i.x;
  for(i=0;i<16;i++)
    tt[i] = aa[(i&12)+0]*bb[ 0+(i&3)]
          + aa[(i&12)+1]*bb[ 4+(i&3)]
          + aa[(i&12)+2]*bb[ 8+(i&3)]
          + aa[(i&12)+3]*bb[12+(i&3)];

#else
  i.Scale4(b.i,a.i.x); i.AddScale4(b.j,a.i.y); i.AddScale4(b.k,a.i.z); i.AddScale4(b.l,a.i.w);
  j.Scale4(b.i,a.j.x); j.AddScale4(b.j,a.j.y); j.AddScale4(b.k,a.j.z); j.AddScale4(b.l,a.j.w);
  k.Scale4(b.i,a.k.x); k.AddScale4(b.j,a.k.y); k.AddScale4(b.k,a.k.z); k.AddScale4(b.l,a.k.w);
  l.Scale4(b.i,a.l.x); l.AddScale4(b.j,a.l.y); l.AddScale4(b.k,a.l.z); l.AddScale4(b.l,a.l.w);
#endif
}

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

#if !sINTRO
void sMatrix::MulR(const sMatrix &a,const sMatrix &b)
{
  i.Scale3(b.i,a.i.x); i.AddScale3(b.j,a.i.y); i.AddScale3(b.k,a.i.z); i.w=0.0f;
  j.Scale3(b.i,a.j.x); j.AddScale3(b.j,a.j.y); j.AddScale3(b.k,a.j.z); j.w=0.0f;
  k.Scale3(b.i,a.k.x); k.AddScale3(b.j,a.k.y); k.AddScale3(b.k,a.k.z); k.w=0.0f;
  l.Rotate3(*this,b.l);
  l.Add3(a.l); l.w=1.0f;
}
#endif

/****************************************************************************/
/***                                                                      ***/
/***   Object Broker                                                      ***/
/***                                                                      ***/
/****************************************************************************/

sBroker_::sBroker_()
{
  ObjectCount = 0;
  ObjectAlloc = 16*1024;
  Objects = new sObject*[ObjectAlloc];
#if !sINTRO
  RootCount = 0;
  RootAlloc = 4*1024;
  Roots = new sObject*[RootAlloc];
#endif
}

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

sBroker_::~sBroker_()
{
  delete[] Objects;
#if !sINTRO
  delete[] Roots;
#endif
}

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

void sBroker_::NewObject(sObject *obj)
{
  sVERIFY(ObjectCount<ObjectAlloc);
  Objects[ObjectCount] = obj;
  obj->TagVal = ObjectCount++;
  obj->_Label = 0;
}

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

void sBroker_::DeleteObject(sObject *obj)
{
  sInt i;

  if(obj)
  {
#if !sINTRO
    if(obj->TagVal&sTAGVAL_ROOT)
      RemRoot(obj);
#endif

    i = obj->TagVal&sTAGVAL_INDEX;
    sVERIFY(Objects[i] = obj);
    obj = Objects[--ObjectCount];
    Objects[i] = obj;
    obj->TagVal = (obj->TagVal & (~sTAGVAL_INDEX)) | i;
  }
}

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

#if !sINTRO

void sBroker_::AddRoot(sObject *root)
{
  sVERIFY(!(root->TagVal & sTAGVAL_ROOT));
  sVERIFY(RootCount<RootAlloc);
  Roots[RootCount++] = root;
  root->TagVal |= sTAGVAL_ROOT;
}

void sBroker_::RemRoot(sObject *root)
{
  sInt i;

  sVERIFY(root->TagVal & sTAGVAL_ROOT);
  root->TagVal &= ~sTAGVAL_ROOT;

  for(i=0;i<RootCount;i++)
  {
    if(Roots[i]==root)
    {
      Roots[i] = Roots[--RootCount];
      return;
    }
  }
  sFatal("root table mismatch");
}

#endif

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

void sBroker_::Need(sObject *obj)
{
  if(obj && !(obj->TagVal & sTAGVAL_USED))
  {
    obj->TagVal |= sTAGVAL_USED;
    obj->Tag();
  }
}

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

void sBroker_::Free()
{
  sInt i;

  for(i=0;i<ObjectCount;i++)
    Objects[i]->TagVal &= ~sTAGVAL_USED;

#if !sINTRO
  for(i=0;i<RootCount;i++)
    Need(Roots[i]);
  sSystem->Tag();
#else
  Need((sObject *)SR__);
#endif

  for(i=0;i<ObjectCount;)
  {
    if(!(Objects[i]->TagVal & sTAGVAL_USED))
      delete Objects[i];
    else
      i++;
  }
}

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

#if !sINTRO
void sBroker_::Dump()
{
  sInt i;
  if(RootCount>0 || ObjectCount>0)
  {
    sDPrintF("Broker Memory Leak!\n");
    sDPrintF("Roots:\n");
    for(i=0;i<RootCount;i++)
      sDPrintF("  %5d: %08x %08x\n",i,Roots[i],Roots[i]->GetClass());
    sDPrintF("All Objects:\n");
    for(i=0;i<ObjectCount;i++)
    {
      sDPrintF("  %5d: %08x %08x %c\n"
        ,i
        ,Objects[i]
        ,Objects[i]->GetClass()
        ,(Objects[i]->TagVal & sTAGVAL_ROOT) ? 'r':' ');
    }
  }
}
#endif

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

void sObject::Tag()
{
}

#if !sINTRO

sBool sObject::Write(sU32 *&)
{
  return sFALSE;
}

sBool sObject::Read(sU32 *&)
{
  return sFALSE;
}
#endif

#if !sINTRO
void sObject::Clear()
{
}

void sObject::Copy(sObject *)
{
#if !sINTRO
  sFatal("unimplemented copy called");
#endif
}
#endif

/****************************************************************************/
/***                                                                      ***/
/***   Arrays                                                             ***/
/***                                                                      ***/
/****************************************************************************/

void sArrayInit(sArrayBase *base,sInt s,sInt c)
{
  if(c)
    base->Array = new sU8[s*c];
  else
    base->Array = 0;
  base->Count = 0;
  base->Alloc = c;
  base->TypeSize = s;
}

void sArraySetMax(sArrayBase *base,sInt c)
{
  sU8 *n; 
  sVERIFY(c > base->Alloc);
  n=new sU8[c*base->TypeSize]; 
  if(base->Array)
  {
    sCopyMem(n,base->Array,base->TypeSize*base->Count); 
    delete[] base->Array; 
  }
  base->Count=sMin(base->Count,c); 
  base->Array=n; 
  base->Alloc=c; 
}

void sArrayAtLeast(sArrayBase *base,sInt c)
{
  if(c>base->Alloc) 
    sArraySetMax(base,sMax(c,base->Alloc*2));
}

void sArrayCopy(sArrayBase *dest,sArrayBase *src)
{
  if(src->Count > dest->Alloc)
    sArraySetMax(dest,src->Count);
  sCopyMem(dest->Array,src->Array,src->TypeSize*src->Count);
  dest->Count = src->Count;
}

sU8 *sArrayAdd(sArrayBase *base)
{
  sU8 *data;
  sArrayAtLeast(base,base->Count+1); 
  data = base->Array+base->Count*base->TypeSize;
  base->Count++;
  return data;
}

/****************************************************************************/
/***                                                                      ***/
/***   Bitmap                                                             ***/
/***                                                                      ***/
/****************************************************************************/

sBitmap::sBitmap()
{
  Data = 0;
  XSize = 0;
  YSize = 0;
}

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

sBitmap::~sBitmap()
{
#if sINTRO
  if(Data)
    delete[] Data;
#else
  Clear();
#endif
}

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

void sBitmap::Init(sInt xs,sInt ys)
{
  if(xs!=XSize || ys!=YSize)
  {
    if(Data)
      delete[] Data;
    XSize = xs;
    YSize = ys;
    Data = new sU32[XSize*YSize];
  }
}

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

#if !sINTRO
void sBitmap::Clear()
{
  if(Data)
    delete[] Data;
  Data = 0;
  XSize = 0;
  YSize = 0;
}

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

void sBitmap::Copy(sObject *o)
{
  sBitmap *bm;

  sVERIFY(o->GetClass()==sCID_BITMAP);

  bm = (sBitmap *) o;
  Init(bm->XSize,bm->YSize);
  sCopyMem4(Data,bm->Data,XSize*YSize);
}
#endif

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

#if !sINTRO

sBool sBitmap::Write(sU32 *&p)
{
  *p++ = 1;
  *p++ = XSize;
  *p++ = YSize;
  sCopyMem4(p,Data,XSize*YSize);
  p+=XSize*YSize;
  return sTRUE;
}

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

sBool sBitmap::Read(sU32 *&p)
{
  sInt version;
  version = *p++;
  if(version<1 || version>1) return sFALSE;
  if(p[0]>0x2000 || p[1]>0x2000) return sFALSE;
  Init(p[0],p[1]);
  p+=2;
  sCopyMem4(Data,p,XSize*YSize);
  p+=XSize*YSize;
  return sTRUE;
}

#endif

/****************************************************************************/
/***                                                                      ***/
/***   StringSet                                                         ***/
/***                                                                      ***/
/******************** ********************************************************/

#if !sINTRO

sInt sStringSet::FindNr(sChar *string)
{
  sInt i;

  for(i=0;i<Set.Count;i++)
    if(sCmpString(Set[i].String,string)==0)
      return i;
  return -1;
}

void sStringSet::Init()
{
  Set.Init(16);
  Set.Count = 0;
}

void sStringSet::Exit()
{
  Set.Exit();
}

void sStringSet::Clear()
{
  Set.Count = 0;
}

sObject *sStringSet::Find(sChar *string)
{
  sInt i;

  i = FindNr(string);
  if(i!=-1)
    return Set[i].Object;
  else
    return 0;
}

sBool sStringSet::Add(sChar *string,sObject *obj)
{
  sInt i;

  i = FindNr(string);
  if(i!=-1)
  {
    Set[i].Object = obj;
    return sTRUE;
  }
  else
  {
    i = Set.Count++;
    Set.AtLeast(i+1);
    Set[i].String = string;
    Set[i].Object = obj;
    return sFALSE;
  }
}

#endif

/****************************************************************************/
/***                                                                      ***/
/***   Text                                                               ***/
/***                                                                      ***/
/****************************************************************************/

#if !sINTRO
sChar *sText::DummyString = "";

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

sText::sText()
{
  Text = DummyString;
  Alloc = 0;
}

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

sText::~sText()
{
  if(Text!=DummyString)
    delete[] Text;
}

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

void sText::Init(sChar *text,sInt len)
{
  sInt size;
  if(len!=-1)
    size = len+1;
  else
    size = sGetStringLen(text)+1;

  if(size>Alloc)
  {
    Alloc = size;
    if(Text!=DummyString)
      delete[] Text;
    Text = new sChar[size];
  }
  sCopyMem(Text,text,size-1);
  Text[size-1] = 0;
}

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

void sText::Clear()
{
  if(Text[0]!=0)
    Text[0] = 0;
}

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

void sText::Copy(sObject *o)
{
  sVERIFY(o->GetClass()==sCID_TEXT);
  Init(((sText *)o)->Text);
}

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

sBool sText::Write(sU32 *&p)
{
  sInt size;
  size = sGetStringLen(Text)+1;
  p[size/4]=0;
  sCopyMem(p,Text,size);
  p+=sAlign(size,4);
  return sTRUE;
}

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

sBool sText::Read(sU32 *&p)
{
  Init((sChar *)p);
  while((*p++)&0xff000000) ;
  return sTRUE;
}

#endif

/****************************************************************************/
/***                                                                      ***/
/***   MusicPlayers                                                       ***/
/***                                                                      ***/
/****************************************************************************/

#if !sINTRO

sMusicPlayer::sMusicPlayer()
{
  Stream = 0;
  StreamSize = 0;
  StreamDelete = 0;
  Status = 0;
  RewindBuffer = 0;
  RewindSize = 0;
  RewindPos = 0;
  PlayPos = 0;
}

sMusicPlayer::~sMusicPlayer()
{
  if(StreamDelete)
    delete[] Stream;
  if(RewindBuffer)
    delete[] RewindBuffer;
}


sBool sMusicPlayer::Load(sChar *name)
{
  sInt size;

  if(StreamDelete)
    delete[] Stream;
  Stream = sSystem->LoadFile(name,size);
  StreamSize = size;
  StreamDelete = sFALSE;
  if(Stream)
  {
    StreamDelete = sTRUE;
    Status = 1;
    return sTRUE;
  }
  return sFALSE;
}

sBool sMusicPlayer::Load(sU8 *data,sInt size)
{
  if(StreamDelete)
    delete[] Stream;
  Stream = data;
  StreamSize = size;
  StreamDelete = sFALSE;
  Status = 1;
  return sTRUE;
}

void sMusicPlayer::AllocRewind(sInt bytes)
{
  RewindSize = bytes/4;
  RewindBuffer = new sS16[bytes/2];
  RewindPos = 0;
}

sBool sMusicPlayer::Start(sInt songnr)
{
  if(Status==1)
  {
    if(Init(songnr))
      Status = 3;
    else
      Status = 0;
  }
  return Status==3;
}

sBool sMusicPlayer::Handler(sS16 *buffer,sInt samples)
{
  sInt diff,size;
  sInt result;

  result = 1;
  if(Status==3)
  {
    if(RewindBuffer)
    {
      if(PlayPos+samples < RewindSize)
      {
        while(RewindPos<PlayPos+samples && result)
        {
          diff = PlayPos+samples-RewindPos;
          size = Render(RewindBuffer+RewindPos*2,diff);
          if(size==0) 
            result = 0;
          RewindPos+=size;
        }
        size = samples;
        if(RewindPos+size>RewindSize)
          size = RewindSize-RewindPos;
        if(size>0)
        {
          sCopyMem(buffer,RewindBuffer+PlayPos*2,size*4);
          buffer+=size*2;
          PlayPos += size;
          samples -= size;
        }
      }
      if(samples>0)
      {
        sSetMem(buffer,0,samples*4);
      }
    }
    else
    {
      while(samples>0 && result)
      {
        size = Render(buffer,samples);
        if(size==0)
          result = 0;
        buffer+=size*2;
        PlayPos += size;
        samples-=size;
      }
    }
  }
  else
  {
    sSetMem(buffer,0,samples*4);
  }
  return result;
}

#endif

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