voxlap5.cpp

// This file has been modified from Ken Silverman's original release

//#include "StdAfx.h"
#include "msvc.h"
#include <math.h>
#include <stdio.h>
#define VOXLAP5
#include "voxlap5.h"

//VOXLAP engine by Ken Silverman (http://advsys.net/ken)

#define USEZBUFFER 1

#define PREC (256*4096)
#define CMPPREC (256*4096)
#define FPREC (256*4096)
#define USEV5ASM 1
#define SCISDIST 1.0
#define GOLDRAT 0.3819660112501052 //Golden Ratio: 1 - 1/((sqrt(5)+1)/2)
#define ESTNORMRAD 2 //Specially optimized for 2: DON'T CHANGE unless testing!

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#else
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <dos.h>
#define MAX_PATH 260
#endif
#include <stdlib.h>

extern char keystatus[256];
extern long startdirectdraw (long *, long *, long *, long *);
extern void stopdirectdraw ();
extern void nextpage ();
extern void evilquit (const char *);

#define VOXSIZ VSID*VSID*128
#ifdef __cplusplus
extern "C" {
#endif
char *sptr[(VSID*VSID*4)/3];
#ifdef __cplusplus
}
#endif
static long *vbuf = 0, *vbit = 0, vbiti;
	//WARNING: loaddta uses last 2MB of vbuf; vbuf:[VOXSIZ>>2], vbit:[VOXSIZ>>7]
	//WARNING: loadpng uses last 4MB of vbuf; vbuf:[VOXSIZ>>2], vbit:[VOXSIZ>>7]

//                     ÚÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄ¿
//        vbuf format: ³   0:   ³   1:   ³   2:   ³   3:   ³
//ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄ´
//³      First header: ³ nextptr³   z1   ³   z1c  ³  dummy ³
//³           Color 1: ³    b   ³    g   ³    r   ³ intens ³
//³           Color 2: ³    b   ³    g   ³    r   ³ intens ³
//³             ...    ³    b   ³    g   ³    r   ³ intens ³
//³           Color n: ³    b   ³    g   ³    r   ³ intens ³
//³ Additional header: ³ nextptr³   z1   ³   z1c  ³   z0   ³
//ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÙ
//  nextptr: add this # <<2 to index to get to next header (0 if none)
//       z1: z floor (top of floor color list)
//      z1c: z bottom of floor color list MINUS 1! - needed to calculate
//             slab size with slng() and used as a separator for fcol/ccol
//       z0: z ceiling (bottom of ceiling color list)

	//Memory management variables:
#define MAXCSIZ 1028
char tbuf[MAXCSIZ];
long tbuf2[MAXZDIM*3];
long templongbuf[MAXZDIM];

long cputype = 0; //bit25=1: SSE, bits30&31=1,1:3DNow!+

static char nullst = 0; //nullst always NULL string

#define SETSPHMAXRAD 256
static double logint[SETSPHMAXRAD];
static float tempfloatbuf[SETSPHMAXRAD];
static long factr[SETSPHMAXRAD][2];

#pragma pack(push,1)
	//Rendering variables:
#if (USEZBUFFER == 0)
typedef struct { long col; } castdat;
#else
typedef struct { long col, dist; } castdat;
#endif
typedef struct { castdat *i0, *i1; long z0, z1, cx0, cy0, cx1, cy1; } cftype;
typedef struct { unsigned short x, y; } uspoint2d;
typedef struct { long x, y; } lpoint2d;
typedef struct { float x, y; } point2d;
#pragma pack(pop)

#if USEV5ASM
#ifndef __cplusplus
	extern void *cfasm;
	extern castdat skycast;
#else
	extern "C" void *cfasm;
	extern "C" castdat skycast;
#endif
	#define cf ((cftype *)&cfasm)
#else
	cftype cf[256];
#endif

	//Screen related variables:
static long xres, yres, bytesperline, frameplace, xres4;
long ylookup[MAXYDIM+1];

static lpoint3d glipos;
static point3d gipos, gistr, gihei, gifor;
static point3d gixs, giys, gizs, giadd;
static float gihx, gihy, gihz, gposxfrac[2], gposyfrac[2], grd;
static long gposz, giforzsgn, gstartz0, gstartz1, gixyi[2];
static char *gstartv;

long backtag, backedup = -1, bacx0, bacy0, bacx1, bacy1;
char *bacsptr[262144];

	//Flash variables
#define LOGFLASHVANG 9
static lpoint2d gfc[(1<<LOGFLASHVANG)*8];
static long gfclookup[8] = {4,7,2,5,0,3,6,1}, flashcnt = 0;
__int64 flashbrival;

	//Norm flash variables
#define GSIZ 512  //NOTE: GSIZ should be 1<<x, and must be <= 65536
static long bbuf[GSIZ][GSIZ>>5], p2c[32], p2m[32];      //bbuf: 2.0K
static uspoint2d ffx[((GSIZ>>1)+2)*(GSIZ>>1)], *ffxptr; // ffx:16.5K
static long xbsox = -17, xbsoy, xbsof;
static __int64 xbsbuf[25*5+1]; //need few bits before&after for protection

	//Look tables for expandbitstack256:
static long xbsceil[32], xbsflor[32];

	//float detection & falling code variables...
	//WARNING: VLSTSIZ,FSTKSIZ,FLCHKSIZ can all have bounds errors! :(
#define VLSTSIZ 65536 //Theoretically should be at least: VOXSIZ\8
#define LOGHASHEAD 12
#define FSTKSIZ 8192
typedef struct { long v, b; } vlstyp;
vlstyp vlst[VLSTSIZ];
long hhead[1<<LOGHASHEAD], vlstcnt = 0x7fffffff;
lpoint3d fstk[FSTKSIZ]; //Note .z is actually used as a pointer, not z!
#define FLCHKSIZ 4096
lpoint3d flchk[FLCHKSIZ]; long flchkcnt = 0;

	//Opticast global variables:
	//radar: 320x200 requires  419560*2 bytes (area * 6.56*2)
	//radar: 400x300 requires  751836*2 bytes (area * 6.27*2)
	//radar: 640x480 requires 1917568*2 bytes (area * 6.24*2)
#define SCPITCH 256
long *radar = 0, *radarmem = 0;
#if (USEZBUFFER == 1)
static long *zbuffermem = 0, zbuffersiz = 0;
#endif
static castdat *angstart[MAXXDIM*4], *gscanptr;
#define CMPRECIPSIZ MAXXDIM+32
static float cmprecip[CMPRECIPSIZ], wx0, wy0, wx1, wy1;
static long iwx0, iwy0, iwx1, iwy1;
static point3d gcorn[4];
		 point3d ginor[4]; //Should be static, but... necessary for stupid pingball hack :/
static long lastx[max(MAXYDIM,VSID)], uurendmem[MAXXDIM*2+8], *uurend;

void mat0(point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *);
void mat1(point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *);
void mat2(point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *, point3d *);

	//Parallaxing sky variables:
static long skypic = 0, nskypic = 0, skybpl, skyysiz, skycurlng, skycurdir;
static float skylngmul;
static point2d *skylng = 0;

#ifdef __cplusplus
extern "C" {
#endif

	//Parallaxing sky variables (accessed by assembly code)
long skyoff = 0, skyxsiz, *skylat = 0;

__int64 gi, gcsub[8] =
{
	0xff00ff00ff00ff,0xff00ff00ff00ff,0xff00ff00ff00ff,0xff00ff00ff00ff,
	0xff00ff00ff00ff,0xff00ff00ff00ff,0xff00ff00ff00ff,0xff00ff00ff00ff
};
long gylookup[512+36], gmipnum = 0; //256+4+128+4+64+4+...
long gpz[2], gdz[2], gxmip, gxmax, gixy[2], gpixy;
static long gmaxscandist;

//long reax, rebx, recx, redx, resi, redi, rebp, resp, remm[16];
void v5_asm_dep_unlock();
void grouscanasm (long);
#if (USEZBUFFER == 1)
long zbufoff;
#endif
#ifdef __cplusplus
}
#endif
#define gi0 (((long *)&gi)[0])
#define gi1 (((long *)&gi)[1])

#ifdef _MSC_VER

#pragma warning(disable:4799) //I know how to use EMMS

static _inline void fcossin (float a, float *c, float *s)
{
	_asm
	{
		fld a
		fsincos
		mov eax, c
		fstp dword ptr [eax]
		mov eax, s
		fstp dword ptr [eax]
	}
}

static _inline void dcossin (double a, double *c, double *s)
{
	_asm
	{
		fld a
		fsincos
		mov eax, c
		fstp qword ptr [eax]
		mov eax, s
		fstp qword ptr [eax]
	}
}

static _inline void ftol (float f, long *a)
{
	_asm
	{
		mov eax, a
		fld f
		fistp dword ptr [eax]
	}
}

static _inline void dtol (double d, long *a)
{
	_asm
	{
		mov eax, a
		fld qword ptr d
		fistp dword ptr [eax]
	}
}

	//WARNING: This ASM code requires >= PPRO
static _inline double dbound (double d, double dmin, double dmax)
{
	_asm
	{
		fld dmin
		fld d
		fucomi st, st(1)   ;if (d < dmin)
		fcmovb st, st(1)   ;    d = dmin;
		fld dmax
		fxch st(1)
		fucomi st, st(1)   ;if (d > dmax)
		fcmovnb st, st(1)  ;    d = dmax;
		fstp d
		fucompp
	}
	return(d);
}

static _inline long mulshr16 (long a, long d)
{
	_asm
	{
		mov eax, a
		mov edx, d
		imul edx
		shrd eax, edx, 16
	}
}

static _inline __int64 mul64 (long a, long d)
{
	_asm
	{
		mov eax, a
		imul d
	}
}

static _inline long shldiv16 (long a, long b)
{
	_asm
	{
		mov eax, a
		mov edx, eax
		shl eax, 16
		sar edx, 16
		idiv b
	}
}

static _inline long isshldiv16safe (long a, long b)
{
	_asm
	{
		mov edx, a
		test edx, edx
		js short skipneg0
		neg edx
skipneg0:
		sar edx, 14

		mov eax, b
		test eax, eax
		js short skipneg1
		neg eax
skipneg1:
			;abs((a<<16)/b) < (1<<30) ;1 extra for good luck!
			;-abs(a)>>14 > -abs(b)    ;use -abs because safe for 0x80000000
			;eax-edx < 0
		sub eax, edx
		shr eax, 31
	}
}

static _inline long umulshr32 (long a, long d)
{
	_asm
	{
		mov eax, a
		mul d
		mov eax, edx
	}
}

static _inline long scale (long a, long d, long c)
{
	_asm
	{
		mov eax, a
		imul d
		idiv c
	}
}

static _inline long dmulrethigh (long b, long c, long a, long d)
{
	_asm
	{
		mov eax, a
		imul d
		mov ecx, eax
		push edx
		mov eax, b
		imul c
		sub eax, ecx
		pop ecx
		sbb edx, ecx
		mov eax, edx
	}
}

static _inline void copybuf (void *s, void *d, long c)
{
	_asm
	{
		push esi
		push edi
		mov esi, s
		mov edi, d
		mov ecx, c
		rep movsd
		pop edi
		pop esi
	}
}

static _inline void clearbuf (void *d, long c, long a)
{
	_asm
	{
		push edi
		mov edi, d
		mov ecx, c
		mov eax, a
		rep stosd
		pop edi
	}
}

#else
#pragma message ("Compiler says it isn't Visual C.")
#endif

	//if (a < 0) return(0); else if (a > b) return(b); else return(a);
static _inline long lbound0 (long a, long b) //b MUST be >= 0
{
	if ((unsigned long)a <= b) return(a);
	return((~(a>>31))&b);
}

	//if (a < b) return(b); else if (a > c) return(c); else return(a);
static _inline long lbound (long a, long b, long c) //c MUST be >= b
{
	c -= b;
	if ((unsigned long)(a-b) <= c) return(a);
	return((((b-a)>>31)&c) + b);
}

#define LSINSIZ 8 //Must be >= 2!
static point2d usintab[(1<<LSINSIZ)+(1<<(LSINSIZ-2))];
static void ucossininit ()
{
	long i, j;
	double a, ai, s, si, m;

	j = 0; usintab[0].y = 0.0;
	i = (1<<LSINSIZ)-1;
	ai = PI*(-2)/((float)(1<<LSINSIZ)); a = ((float)(-i))*ai;
	ai *= .5; m = sin(ai)*2; s = sin(a); si = cos(a+ai)*m; m = -m*m;
	for(;i>=0;i--)
	{
		usintab[i].y = s; s += si; si += s*m; //MUCH faster than next line :)
		//usintab[i].y = sin(i*PI*2/((float)(1<<LSINSIZ)));
		usintab[i].x = (usintab[j].y-usintab[i].y)/((float)(1<<(32-LSINSIZ)));
		j = i;
	}
	for(i=(1<<(LSINSIZ-2))-1;i>=0;i--) usintab[i+(1<<LSINSIZ)] = usintab[i];
}

	//Calculates cos & sin of 32-bit unsigned long angle in ~15 clock cycles
	//  Accuracy is approximately +/-.0001
static _inline void ucossin (unsigned long a, float *cosin)
{
	float f = ((float)(a&((1<<(32-LSINSIZ))-1))); a >>= (32-LSINSIZ);
	cosin[0] = usintab[a+(1<<(LSINSIZ-2))].x*f+usintab[a+(1<<(LSINSIZ-2))].y;
	cosin[1] = usintab[a                 ].x*f+usintab[a                 ].y;
}

static const long font4x6[] = //256 DOS chars, from Ken's Build SMALLFNT
{
	0x000000,0x6f9f60,0x69f960,0xaffe40,0x4efe40,0x6ff6f0,0x66f6f0,0x000000,
	0xeeaee0,0x000000,0x000000,0x000000,0x000000,0x000000,0x7755c0,0x96f690,
	0x8cec80,0x26e620,0x4e4e40,0xaaa0a0,0x7dd550,0x7ca6c0,0x000ee0,0x4e4ee0,
	0x4e4440,0x444e40,0x02f200,0x04f400,0x000000,0x000000,0x000000,0x000000,
	0x000000,0x444040,0xaa0000,0xafafa0,0x6c46c0,0xa248a0,0x4a4ce0,0x240000,
	0x488840,0x422240,0x0a4a00,0x04e400,0x000224,0x00e000,0x000040,0x224480,
	0xeaaae0,0x444440,0xe2e8e0,0xe2e2e0,0xaae220,0xe8e2e0,0xe8eae0,0xe22220,
	0xeaeae0,0xeae220,0x040400,0x040480,0x248420,0x0e0e00,0x842480,0xc24040,
	0xeaece0,0x4aeaa0,0xcacac0,0x688860,0xcaaac0,0xe8c8e0,0xe8c880,0xe8aae0,
	0xaaeaa0,0xe444e0,0xe22a60,0xaacaa0,0x8888e0,0xaeeaa0,0xaeeea0,0xeaaae0,
	0xeae880,0xeaae60,0xeacaa0,0xe8e2e0,0xe44440,0xaaaae0,0xaaa440,0xaaeea0,
	0xaa4aa0,0xaae440,0xe248e0,0xc888c0,0x844220,0x622260,0x4a0000,0x0000e0,
	0x420000,0x006a60,0x88eae0,0x00e8e0,0x22eae0,0x006e60,0x24e440,0x06a62c,
	0x88eaa0,0x040440,0x040448,0x88aca0,0x444440,0x08eee0,0x00caa0,0x00eae0,
	0x00eae8,0x00eae2,0x00e880,0x0064c0,0x04e440,0x00aa60,0x00aa40,0x00eee0,
	0x00a4a0,0x00aa6c,0x00c460,0x648460,0x440440,0xc424c0,0x6c0000,0x04ae00,
	0x68886c,0xa0aa60,0x606e60,0xe06a60,0xa06a60,0xc06a60,0x046a60,0x00e8e4,
	0xe06e60,0xa06e60,0xc06e60,0x0a0440,0x0e0440,0x0c0440,0xa4aea0,0x404ea0,
	0x60ece0,0x007a70,0x7afab0,0xe0eae0,0xa0eae0,0xc0eae0,0xe0aa60,0xc0aa60,
	0xa0aa6c,0xa0eae0,0xa0aae0,0x4e8e40,0x65c4f0,0xa4ee40,0xcafab0,0x64e4c0,
	0x606a60,0x060440,0x60eae0,0x60aa60,0xc0caa0,0xe0aea0,0x6a60e0,0xeae0e0,
	0x404860,0x007400,0x00c400,0x8a4e60,0x8a6e20,0x404440,0x05a500,0x0a5a00,
	0x282828,0x5a5a5a,0xd7d7d7,0x444444,0x44c444,0x44cc44,0x66e666,0x00e666,
	0x00cc44,0x66ee66,0x666666,0x00ee66,0x66ee00,0x66e000,0x44cc00,0x00c444,
	0x447000,0x44f000,0x00f444,0x447444,0x00f000,0x44f444,0x447744,0x667666,
	0x667700,0x007766,0x66ff00,0x00ff66,0x667766,0x00ff00,0x66ff66,0x44ff00,
	0x66f000,0x00ff44,0x00f666,0x667000,0x447700,0x007744,0x007666,0x66f666,
	0x44ff44,0x44c000,0x007444,0xffffff,0x000fff,0xcccccc,0x333333,0xfff000,
	0x00dad0,0xcacac8,0xea8880,0x00f660,0xe848e0,0x007a40,0x0aac80,0x05a220,
	0xe4a4e0,0x4aea40,0x6996f0,0x646ae0,0x06f600,0x16f680,0x68c860,0x4aaaa0,
	0xe0e0e0,0x4e40e0,0x4240e0,0x4840e0,0x4a8880,0x222a40,0x40e040,0x06ec00,
	0xeae000,0x0cc000,0x00c000,0x644c40,0xcaa000,0xc4e000,0x0eee00,0x000000,
};

void print4x6 (long x, long y, long fcol, long bcol, const char *fmt, ...)
{
	va_list arglist;
	char st[280], *c;
	long i, j;

	if (!fmt) return;
	va_start(arglist,fmt);
	vsprintf(st,fmt,arglist);
	va_end(arglist);

	y = y*bytesperline+(x<<2)+frameplace;
	if (bcol < 0)
	{
		for(j=20;j>=0;y+=bytesperline,j-=4)
			for(c=st,x=y;*c;c++,x+=16)
			{
				i = (font4x6[*c]>>j);
				if (i&8) *(long *)(x   ) = fcol;
				if (i&4) *(long *)(x+ 4) = fcol;
				if (i&2) *(long *)(x+ 8) = fcol;
				if (i&1) *(long *)(x+12) = fcol;
				if ((*c) == 9) x += 32;
			}
		return;
	}
	fcol -= bcol;
	for(j=20;j>=0;y+=bytesperline,j-=4)
		for(c=st,x=y;*c;c++,x+=16)
		{
			i = (font4x6[*c]>>j);
			*(long *)(x   ) = (((i<<28)>>31)&fcol)+bcol;
			*(long *)(x+ 4) = (((i<<29)>>31)&fcol)+bcol;
			*(long *)(x+ 8) = (((i<<30)>>31)&fcol)+bcol;
			*(long *)(x+12) = (((i<<31)>>31)&fcol)+bcol;
			if ((*c) == 9) { for(i=16;i<48;i+=4) *(long *)(x+i) = bcol; x += 32; }
		}
}

	//NOTE: font is stored vertically first! (like .ART files)
static const __int64 font6x8[] = //256 DOS chars, from: DOSAPP.FON (tab blank)
{
	0x3E00000000000000,0x6F6B3E003E455145,0x1C3E7C3E1C003E6B,0x3000183C7E3C1800,
	0x7E5C180030367F36,0x000018180000185C,0x0000FFFFE7E7FFFF,0xDBDBC3FF00000000,
	0x0E364A483000FFC3,0x6000062979290600,0x0A7E600004023F70,0x2A1C361C2A003F35,
	0x0800081C3E7F0000,0x7F361400007F3E1C,0x005F005F00001436,0x22007F017F090600,
	0x606060002259554D,0x14B6FFB614000060,0x100004067F060400,0x3E08080010307F30,
	0x08083E1C0800081C,0x0800404040407800,0x3F3C3000083E083E,0x030F3F0F0300303C,
	0x0000000000000000,0x0003070000065F06,0x247E247E24000307,0x630000126A2B2400,
	0x5649360063640813,0x0000030700005020,0x00000000413E0000,0x1C3E080000003E41,
	0x08083E080800083E,0x0800000060E00000,0x6060000008080808,0x0204081020000000,
	0x00003E4549513E00,0x4951620000407F42,0x3649494922004649,0x2F00107F12141800,
	0x494A3C0031494949,0x0305097101003049,0x0600364949493600,0x6C6C00001E294949,
	0x00006CEC00000000,0x2400004122140800,0x2241000024242424,0x0609590102000814,
	0x7E001E555D413E00,0x49497F007E111111,0x224141413E003649,0x7F003E4141417F00,
	0x09097F0041494949,0x7A4949413E000109,0x00007F0808087F00,0x4040300000417F41,
	0x412214087F003F40,0x7F00404040407F00,0x04027F007F020402,0x3E4141413E007F08,
	0x3E00060909097F00,0x09097F005E215141,0x3249494926006619,0x3F0001017F010100,
	0x40201F003F404040,0x3F403C403F001F20,0x0700631408146300,0x4549710007087008,
	0x0041417F00000043,0x0000201008040200,0x01020400007F4141,0x8080808080800402,
	0x2000000007030000,0x44447F0078545454,0x2844444438003844,0x38007F4444443800,
	0x097E080008545454,0x7CA4A4A418000009,0x0000007804047F00,0x8480400000407D00,
	0x004428107F00007D,0x7C0000407F000000,0x04047C0078041804,0x3844444438000078,
	0x380038444444FC00,0x44784400FC444444,0x2054545408000804,0x3C000024443E0400,
	0x40201C00007C2040,0x3C6030603C001C20,0x9C00006C10106C00,0x54546400003C60A0,
	0x0041413E0800004C,0x0000000077000000,0x02010200083E4141,0x3C2623263C000001,
	0x3D001221E1A11E00,0x54543800007D2040,0x7855555520000955,0x2000785554552000,
	0x5557200078545555,0x1422E2A21C007857,0x3800085555553800,0x5555380008555455,
	0x00417C0100000854,0x0000004279020000,0x2429700000407C01,0x782F252F78007029,
	0x3400455554547C00,0x7F097E0058547C54,0x0039454538004949,0x3900003944453800,
	0x21413C0000384445,0x007C20413D00007D,0x3D00003D60A19C00,0x40413C00003D4242,
	0x002466241800003D,0x29006249493E4800,0x16097F00292A7C2A,0x02097E8840001078,
	0x0000785555542000,0x4544380000417D00,0x007D21403C000039,0x7A0000710A097A00,
	0x5555080000792211,0x004E51514E005E55,0x3C0020404D483000,0x0404040404040404,
	0x506A4C0817001C04,0x0000782A34081700,0x0014080000307D30,0x0814000814001408,
	0x55AA114411441144,0xEEBBEEBB55AA55AA,0x0000FF000000EEBB,0x0A0A0000FF080808,
	0xFF00FF080000FF0A,0x0000F808F8080000,0xFB0A0000FE0A0A0A,0xFF00FF000000FF00,
	0x0000FE02FA0A0000,0x0F0800000F080B0A,0x0F0A0A0A00000F08,0x0000F80808080000,
	0x080808080F000000,0xF808080808080F08,0x0808FF0000000808,0x0808080808080808,
	0xFF0000000808FF08,0x0808FF00FF000A0A,0xFE000A0A0B080F00,0x0B080B0A0A0AFA02,
	0x0A0AFA02FA0A0A0A,0x0A0A0A0AFB00FF00,0xFB00FB0A0A0A0A0A,0x0A0A0B0A0A0A0A0A,
	0x0A0A08080F080F08,0xF808F8080A0AFA0A,0x08080F080F000808,0x00000A0A0F000000,
	0xF808F8000A0AFE00,0x0808FF00FF080808,0x08080A0AFB0A0A0A,0xF800000000000F08,
	0xFFFFFFFFFFFF0808,0xFFFFF0F0F0F0F0F0,0xFF000000000000FF,0x0F0F0F0F0F0FFFFF,
	0xFE00241824241800,0x01017F0000344A4A,0x027E027E02000003,0x1800006349556300,
	0x2020FC00041C2424,0x000478040800001C,0x3E00085577550800,0x02724C00003E4949,
	0x0030595522004C72,0x1800182418241800,0x2A2A1C0018247E24,0x003C02023C00002A,
	0x0000002A2A2A2A00,0x4A4A510000242E24,0x00514A4A44000044,0x20000402FC000000,
	0x2A08080000003F40,0x0012241224000808,0x0000000609090600,0x0008000000001818,
	0x02023E4030000000,0x0900000E010E0100,0x3C3C3C0000000A0D,0x000000000000003C,
};

void print6x8 (long x, long y, long fcol, long bcol, const char *fmt, ...)
{
	va_list arglist;
	char st[280], *c, *v;
	long i, j;

	if (!fmt) return;
	va_start(arglist,fmt);
	vsprintf(st,fmt,arglist);
	va_end(arglist);

	y = y*bytesperline+(x<<2)+frameplace;
	if (bcol < 0)
	{
		for(j=1;j<256;y+=bytesperline,j<<=1)
			for(c=st,x=y;*c;c++,x+=24)
			{
				v = (char *)(((long)font6x8) + ((long)c[0])*6);
				if (v[0]&j) *(long *)(x   ) = fcol;
				if (v[1]&j) *(long *)(x+ 4) = fcol;
				if (v[2]&j) *(long *)(x+ 8) = fcol;
				if (v[3]&j) *(long *)(x+12) = fcol;
				if (v[4]&j) *(long *)(x+16) = fcol;
				if (v[5]&j) *(long *)(x+20) = fcol;
				if ((*c) == 9) x += ((2*6)<<2);
			}
		return;
	}
	fcol -= bcol;
	for(j=1;j<256;y+=bytesperline,j<<=1)
		for(c=st,x=y;*c;c++,x+=24)
		{
			v = (char *)(((long)font6x8) + ((long)c[0])*6);
			*(long *)(x   ) = (((-(v[0]&j))>>31)&fcol)+bcol;
			*(long *)(x+ 4) = (((-(v[1]&j))>>31)&fcol)+bcol;
			*(long *)(x+ 8) = (((-(v[2]&j))>>31)&fcol)+bcol;
			*(long *)(x+12) = (((-(v[3]&j))>>31)&fcol)+bcol;
			*(long *)(x+16) = (((-(v[4]&j))>>31)&fcol)+bcol;
			*(long *)(x+20) = (((-(v[5]&j))>>31)&fcol)+bcol;
			if ((*c) == 9) { for(i=24;i<72;i+=4) *(long *)(x+i) = bcol; x += ((2*6)<<2); }
		}
}

static long gkrand = 0;
long colorjit (long i, long jitamount)
{
	gkrand = (gkrand*27584621)+1;
	return((gkrand&jitamount)^i);
}

long lightvox (long i)
{
	long r, g, b;

	b = ((unsigned long)i>>24);
	r = min((((i>>16)&255)*b)>>7,255);
	g = min((((i>>8 )&255)*b)>>7,255);
	b = min((((i    )&255)*b)>>7,255);
	return((r<<16)+(g<<8)+b);
}

	//Note: ebx = 512 is no change
	//If PENTIUM III:1.Replace punpcklwd&punpckldq with: pshufw mm1, mm1, 0
	//               2.Use pmulhuw, shift by 8 & mul by 256
	//  :(  Can't mix with floating point
//#pragma aux colormul =
//   "movd mm0, eax"
//   "pxor mm1, mm1"
//   "punpcklbw mm0, mm1"
//   "psllw mm0, 7"
//   "movd mm1, ebx"
//   "punpcklwd mm1, mm1"
//   "punpckldq mm1, mm1"
//   "pmulhw mm0, mm1"
//   "packsswb mm0, mm0"
//   "movd eax, mm0"
//   parm [eax][ebx]
//   modify exact [eax]
//   value [eax]

long colormul (long i, long mulup8)
{
	long r, g, b;

	r = ((((i>>16)&255)*mulup8)>>8); if (r > 255) r = 255;
	g = ((((i>>8 )&255)*mulup8)>>8); if (g > 255) g = 255;
	b = ((((i    )&255)*mulup8)>>8); if (b > 255) b = 255;
	return((i&0xff000000)+(r<<16)+(g<<8)+b);
}

long curcolfunc (lpoint3d *p) { return(vx5.curcol); }

long floorcolfunc (lpoint3d *p)
{
	char *v;
	for(v=sptr[p->y*VSID+p->x];(p->z>v[2]) && (v[0]);v+=v[0]*4);
	return(*(long *)&v[4]);
}

long jitcolfunc (lpoint3d *p) { return(colorjit(vx5.curcol,vx5.amount)); }

static long manycolukup[64] =
{
	  0,  1,  2,  5, 10, 15, 21, 29, 37, 47, 57, 67, 79, 90,103,115,
	127,140,152,165,176,188,198,208,218,226,234,240,245,250,253,254,
	255,254,253,250,245,240,234,226,218,208,198,188,176,165,152,140,
	128,115,103, 90, 79, 67, 57, 47, 37, 29, 21, 15, 10,  5,  2,  1
};
long manycolfunc (lpoint3d *p)
{
	return((manycolukup[p->x&63]<<16)+(manycolukup[p->y&63]<<8)+manycolukup[p->z&63]+0x80000000);
}

long sphcolfunc (lpoint3d *p)
{
	long i;
	ftol(sin((p->x+p->y+p->z-vx5.cen)*vx5.daf)*-96,&i);
	return(((i+128)<<24)|(vx5.curcol&0xffffff));
}

#define WOODXSIZ 46
#define WOODYSIZ 24
#define WOODZSIZ 24
static float wx[256], wy[256], wz[256], vx[256], vy[256], vz[256];
long woodcolfunc (lpoint3d *p)
{
	float col, u, a, f, dx, dy, dz;
	long i, c, xof, yof, tx, ty, xoff;

	if (*(long *)&wx[0] == 0)
	{
		for(i=0;i<256;i++)
		{
			wx[i] = WOODXSIZ * ((float)rand()/32768.0f-.5f) * .5f;
			wy[i] = WOODXSIZ * ((float)rand()/32768.0f-.5f) * .5f;
			wz[i] = WOODXSIZ * ((float)rand()/32768.0f-.5f) * .5f;

				//UNIFORM spherical randomization (see spherand.c)
			dz = 1.0f-(float)rand()/32768.0f*.04f;
			a = (float)rand()/32768.0f*PI*2.0f; fcossin(a,&dx,&dy);
			f = sqrt(1.0f-dz*dz); dx *= f; dy *= f;
				//??z: rings,  ?z?: vertical,  z??: horizontal (nice)
			vx[i] = dz; vy[i] = fabs(dy); vz[i] = dx;
		}
	}

		//(tx&,ty&) = top-left corner of current panel
	ty = p->y - (p->y%WOODYSIZ);
	xoff = ((ty/WOODYSIZ)*(ty/WOODYSIZ)*51721 + (p->z/WOODZSIZ)*357) % WOODXSIZ;
	tx = ((p->x+xoff) - (p->x+xoff)%WOODXSIZ) - xoff;

	xof = p->x - (tx + (WOODXSIZ>>1));
	yof = p->y - (ty + (WOODYSIZ>>1));

	c = ((((tx*429 + 4695) ^ (ty*341 + 4355) ^ 13643) * 2797) & 255);
	dx = xof - wx[c];
	dy = yof - wy[c];
	dz = (p->z%WOODZSIZ) - wz[c];

		//u = distance to center of randomly oriented cylinder
	u = vx[c]*dx + vy[c]*dy + vz[c]*dz;
	u = sqrt(dx*dx + dy*dy + dz*dz - u*u);

		//ring randomness
	u += sin((float)xof*.12 + (float)yof*.15) * .5;
	u *= (sin(u)*.05 + 1);

		//Ring function: smooth saw-tooth wave
	col = sin(u*2)*24;
	col *= pow(1.f-vx[c],.3f);

		//Thin shaded borders
	if ((p->x-tx == 0) || (p->y-ty == 0)) col -= 5;
	if ((p->x-tx == WOODXSIZ-1) || (p->y-ty == WOODYSIZ-1)) col -= 3;

	//f = col+c*.12+72; i = ftolp3(&f);
	  ftol(col+c*.12f+72.0f,&i);

	return(colormul(vx5.curcol,i<<1));
}

long gxsizcache = 0, gysizcache = 0;
long pngcolfunc (lpoint3d *p)
{
	long x, y, z, u, v;
	float fx, fy, fz, rx, ry, rz;

	if (!vx5.pic) return(vx5.curcol);
	switch(vx5.picmode)
	{
		case 0:
			x = p->x-vx5.pico.x; y = p->y-vx5.pico.y; z = p->z-vx5.pico.z;
			u = (((x&vx5.picu.x) + (y&vx5.picu.y) + (z&vx5.picu.z))^vx5.xoru);
			v = (((x&vx5.picv.x) + (y&vx5.picv.y) + (z&vx5.picv.z))^vx5.xorv);
			break;
		case 1: case 2:
			fx = (float)p->x-vx5.fpico.x;
			fy = (float)p->y-vx5.fpico.y;
			fz = (float)p->z-vx5.fpico.z;
			rx = vx5.fpicu.x*fx + vx5.fpicu.y*fy + vx5.fpicu.z*fz;
			ry = vx5.fpicv.x*fx + vx5.fpicv.y*fy + vx5.fpicv.z*fz;
			rz = vx5.fpicw.x*fx + vx5.fpicw.y*fy + vx5.fpicw.z*fz;
			ftol(atan2(ry,rx)*vx5.xoru/(PI*2),&u);
			if (vx5.picmode == 1) ftol(rz,&v);
			else ftol((atan2(rz,sqrt(rx*rx+ry*ry))/PI+.5)*vx5.ysiz,&v);
			break;
		default: //case 3:
			fx = (float)p->x-vx5.fpico.x;
			fy = (float)p->y-vx5.fpico.y;
			fz = (float)p->z-vx5.fpico.z;
			ftol(vx5.fpicu.x*fx + vx5.fpicu.y*fy + vx5.fpicu.z*fz,&u);
			ftol(vx5.fpicv.x*fx + vx5.fpicv.y*fy + vx5.fpicv.z*fz,&v);
			break;
	}
	if ((unsigned long)(u-gxsizcache) >= (unsigned long)vx5.xsiz)
		if (u < 0) gxsizcache = u-(u+1)%vx5.xsiz-vx5.xsiz+1; else gxsizcache = u-(u%vx5.xsiz);
	if ((unsigned long)(v-gysizcache) >= (unsigned long)vx5.ysiz)
		if (v < 0) gysizcache = v-(v+1)%vx5.ysiz-vx5.ysiz+1; else gysizcache = v-(v%vx5.ysiz);
	return((vx5.pic[(v-gysizcache)*(vx5.bpl>>2)+(u-gxsizcache)]&0xffffff)|0x80000000);
}

	//Special case for SETSEC & SETCEI bumpmapping (vx5.picmode == 3)
	//no safety checks, returns alpha as signed char in range: (-128 to 127)
long hpngcolfunc (point3d *p)
{
	long u, v;
	float fx, fy, fz;

	fx = p->x-vx5.fpico.x;
	fy = p->y-vx5.fpico.y;
	fz = p->z-vx5.fpico.z;
	ftol(vx5.fpicu.x*fx + vx5.fpicu.y*fy + vx5.fpicu.z*fz,&u);
	ftol(vx5.fpicv.x*fx + vx5.fpicv.y*fy + vx5.fpicv.z*fz,&v);

	if ((unsigned long)(u-gxsizcache) >= (unsigned long)vx5.xsiz)
		if (u < 0) gxsizcache = u-(u+1)%vx5.xsiz-vx5.xsiz+1; else gxsizcache = u-(u%vx5.xsiz);
	if ((unsigned long)(v-gysizcache) >= (unsigned long)vx5.ysiz)
		if (v < 0) gysizcache = v-(v+1)%vx5.ysiz-vx5.ysiz+1; else gysizcache = v-(v%vx5.ysiz);
	return(vx5.pic[(v-gysizcache)*(vx5.bpl>>2)+(u-gxsizcache)]>>24);
}

static long slng (const char *s)
{
	const char *v;

	for(v=s;v[0];v+=v[0]*4);
	return((long)v-(long)s+(v[2]-v[1]+1)*4+4);
}

void voxdealloc (const char *v)
{
	long i, j;
	i = (((long)v-(long)vbuf)>>2); j = (slng(v)>>2)+i;
#if 0
	while (i < j) { vbit[i>>5] &= ~(1<<i); i++; }
#else
	if (!((j^i)&~31))
		vbit[i>>5] &= ~(p2m[j&31]^p2m[i&31]);
	else
	{
		vbit[i>>5] &=   p2m[i&31];  i >>= 5;
		vbit[j>>5] &= (~p2m[j&31]); j >>= 5;
		for(j--;j>i;j--) vbit[j] = 0;
	}
#endif
}

	//Note: danum MUST be a multiple of 4!
char *voxalloc (long danum)
{
	long i, badcnt, p0, p1, vend;

	badcnt = 0; danum >>= 2; vend = (VOXSIZ>>2)-danum;
	do
	{
		for(;vbiti<vend;vbiti+=danum)
		{
			if (vbit[vbiti>>5]&(1<<vbiti)) continue;
			for(p0=vbiti;(!(vbit[(p0-1)>>5]&(1<<(p0-1))));p0--);
			for(p1=p0+danum-1;p1>vbiti;p1--)
				if (vbit[p1>>5]&(1<<p1)) goto allocnothere;

			vbiti = p0+danum;
			for(i=p0;i<vbiti;i++) vbit[i>>5] |= (1<<i);
			return((char *)(&vbuf[p0]));
allocnothere:;
		}
		vbiti = 0; badcnt++;
	} while (badcnt < 2);
	evilquit("voxalloc: vbuf full"); return(0);
}

long isvoxelsolid (long x, long y, long z)
{
	char *v;

	if ((unsigned long)(x|y) >= VSID) return(0);
	v = sptr[y*VSID+x];
	while (1)
	{
		if (z < v[1]) return(0);
		if (!v[0]) return(1);
		v += v[0]*4;
		if (z < v[3]) return(1);
	}
}

	//Returns 1 if any voxels in range (x,y,z0) to (x,y,z1-1) are solid, else 0
long anyvoxelsolid (long x, long y, long z0, long z1)
{
	char *v;

		//         v1.....v3   v1.....v3    v1.......................>
		//                z0.........z1
	if ((unsigned long)(x|y) >= VSID) return(0);
	v = sptr[y*VSID+x];
	while (1)
	{
		if (z1 <= v[1]) return(0);
		if (!v[0]) return(1);
		v += v[0]*4;
		if (z0 < v[3]) return(1);
	}
}

	//Returns 1 if any voxels in range (x,y,z0) to (x,y,z1-1) are empty, else 0
long anyvoxelempty (long x, long y, long z0, long z1)
{
	char *v;

		//         v1.....v3   v1.....v3    v1.......................>
		//                z0.........z1
	if ((unsigned long)(x|y) >= VSID) return(1);
	v = sptr[y*VSID+x];
	while (1)
	{
		if (z0 < v[1]) return(1);
		if (!v[0]) return(0);
		v += v[0]*4;
		if (z1 <= v[3]) return(0);
	}
}

	//Returns z of first solid voxel under (x,y,z). Returns z if in solid.
long getfloorz (long x, long y, long z)
{
	char *v;

	if ((unsigned long)(x|y) >= VSID) return(z);
	v = sptr[y*VSID+x];
	while (1)
	{
		if (z <= v[1]) return(v[1]);
		if (!v[0]) break;
		v += v[0]*4;
		if (z < v[3]) break;
	}
	return(z);
}

	//Returns:
	//   0: air
	//   1: unexposed solid
	//else: address to color in vbuf (this can never be 0 or 1)
long getcube (long x, long y, long z)
{
	long ceilnum;
	char *v;

	if ((unsigned long)(x|y) >= VSID) return(0);
	v = sptr[y*VSID+x];
	while (1)
	{
		if (z <= v[2])
		{
			if (z < v[1]) return(0);
			return((long)&v[(z-v[1])*4+4]);
		}
		ceilnum = v[2]-v[1]-v[0]+2;

		if (!v[0]) return(1);
		v += v[0]*4;

		if (z < v[3])
		{
			if (z-v[3] < ceilnum) return(1);
			return((long)&v[(z-v[3])*4]);
		}
	}
}

	// Inputs: uind[MAXZDIM]: uncompressed 32-bit color buffer (-1: air)
	//         nind?[MAXZDIM]: neighbor buf:
	//            -2: unexposed solid
	//            -1: air
	//    0-16777215: exposed solid (color)
	//         px,py: parameters for setting unexposed voxel colors
	//Outputs: cbuf[MAXCSIZ]: compressed output buffer
	//Returns: n: length of compressed buffer (in bytes)
long compilestack (long *uind, long *n0, long *n1, long *n2, long *n3, char *cbuf, long px, long py)
{
	long oz, onext, n, cp2, cp1, cp0, rp1, rp0;
	lpoint3d p;

	p.x = px; p.y = py;

		//Do top slab (sky)
	oz = -1;
	p.z = -1; while (uind[p.z+1] == -1) p.z++;
	onext = 0;
	cbuf[1] = p.z+1;
	cbuf[2] = p.z+1;
	cbuf[3] = 0;  //Top z0 (filler, not used yet)
	n = 4;
	cp1 = 1; cp0 = 0;
	rp1 = -1; rp0 = -1;

	do
	{
			//cp2 = state at p.z-1 (0 = air, 1 = next2air, 2 = solid)
			//cp1 = state at p.z   (0 = air, 1 = next2air, 2 = solid)
			//cp0 = state at p.z+1 (0 = air, 1 = next2air, 2 = solid)
		cp2 = cp1; cp1 = cp0; cp0 = 2;
		if (p.z < MAXZDIM-2)  //Bottom must be solid!
		{
			if (uind[p.z+1] == -1)
				cp0 = 0;
			else if ((n0[p.z+1] == -1) || (n1[p.z+1] == -1) ||
						(n2[p.z+1] == -1) || (n3[p.z+1] == -1))
				cp0 = 1;
		}

			//Add slab
		if (cp1 != rp0)
		{
			if ((!cp1) && (rp0 > 0)) { oz = p.z; }
			else if ((rp0 < cp1) && (rp0 < rp1))
			{
				if (oz < 0) oz = p.z;
				cbuf[onext] = ((n-onext)>>2); onext = n;
				cbuf[n+1] = p.z;
				cbuf[n+2] = p.z-1;
				cbuf[n+3] = oz;
				n += 4; oz = -1;
			}
			rp1 = rp0; rp0 = cp1;
		}

			//Add color
		if ((cp1 == 1) || ((cp1 == 2) && ((!cp0) || (!cp2))))
		{
			if (cbuf[onext+2] == p.z-1) cbuf[onext+2] = p.z;
			if (uind[p.z] == -2) *(long *)&cbuf[n] = vx5.colfunc(&p);
								 else *(long *)&cbuf[n] = uind[p.z];
			n += 4;
		}

		p.z++;
	} while (p.z < MAXZDIM);
	cbuf[onext] = 0;
	return(n);
}

#ifdef _MSC_VER

static _inline void expandbit256 (void *s, void *d)
{
	_asm
	{
		push esi
		push edi
		mov esi, s
		mov edi, d
		mov ecx, 32   ;current bit index
		xor edx, edx  ;value of current 32-bit bits
		jmp short in2it
begit:lea esi, [esi+eax*4]
		movzx eax, byte ptr [esi+3]
		sub eax, ecx              ;xor mask [eax] for ceiling begins
		jl short xskpc
xdoc: mov [edi], edx
		add edi, 4
		mov edx, -1
		add ecx, 32
		sub eax, 32
		jge short xdoc
xskpc:and edx, xbsceil[eax*4+128] ;~(-1<<eax); xor mask [eax] for ceiling ends
in2it:movzx eax, byte ptr [esi+1]
		sub eax, ecx              ;xor mask [eax] for floor begins
		jl short xskpf
xdof: mov [edi], edx
		add edi, 4
		xor edx, edx
		add ecx, 32
		sub eax, 32
		jge short xdof
xskpf:or edx, xbsflor[eax*4+128] ;(-1<<eax); xor mask [eax] for floor ends
		movzx eax, byte ptr [esi]
		test eax, eax
		jnz short begit
		sub ecx, 256              ;finish writing buffer to [edi]
		jg short xskpe
xdoe: mov [edi], edx
		add edi, 4
		mov edx, -1
		add ecx, 32
		jle short xdoe
xskpe:pop edi
		pop esi
	}
}

#endif

void expandbitstack (long x, long y, __int64 *bind)
{
	if ((x|y)&(~(VSID-1))) { clearbuf((void *)bind,8,0L); return; }
	expandbit256(sptr[y*VSID+x],(void *)bind);
}

void expandstack (long x, long y, long *uind)
{
	long z, topz;
	char *v, *v2;

	if ((x|y)&(~(VSID-1))) { clearbuf((void *)uind,MAXZDIM,0); return; }

		//Expands compiled voxel info to 32-bit uind[?]
	v = sptr[y*VSID+x]; z = 0;
	while (1)
	{
		while (z < v[1]) { uind[z] = -1; z++; }
		while (z <= v[2]) { uind[z] = (*(long *)&v[(z-v[1])*4+4]); z++; }
		v2 = &v[(v[2]-v[1]+1)*4+4];

		if (!v[0]) break;
		v += v[0]*4;

		topz = v[3]+(((long)v2-(long)v)>>2);
		while (z < topz) { uind[z] = -2; z++; }
		while (z < v[3]) { uind[z] = *(long *)v2; z++; v2 += 4; }
	}
	while (z < MAXZDIM) { uind[z] = -2; z++; }
}

void gline (long leng, float x0, float y0, float x1, float y1)
{
	unsigned __int64 q;
	float f, f1, f2, vd0, vd1, vz0, vx1, vy1, vz1;
	long j;
	cftype *c;
#if (USEV5ASM == 0)
	long gx, ogx, gy, ixy, col, dax, day;
	cftype *c2, *ce;
	char *v;
#endif

	vd0 = x0*gistr.x + y0*gihei.x + gcorn[0].x;
	vd1 = x0*gistr.y + y0*gihei.y + gcorn[0].y;
	vz0 = x0*gistr.z + y0*gihei.z + gcorn[0].z;
	vx1 = x1*gistr.x + y1*gihei.x + gcorn[0].x;
	vy1 = x1*gistr.y + y1*gihei.y + gcorn[0].y;
	vz1 = x1*gistr.z + y1*gihei.z + gcorn[0].z;

	f = sqrt(vx1*vx1 + vy1*vy1);
	f1 = f / vx1;
	f2 = f / vy1;
	if (fabs(vx1) > fabs(vy1)) vd0 = vd0*f1; else vd0 = vd1*f2;
	if (*(long *)&vd0 < 0) vd0 = 0; //vd0 MUST NOT be negative: bad for asm
	vd1 = f;
	ftol(fabs(f1)*PREC,&gdz[0]);
	ftol(fabs(f2)*PREC,&gdz[1]);

	gixy[0] = (((*(signed long *)&vx1)>>31)<<3)+4; //=sgn(vx1)*4
	gixy[1] = gixyi[(*(unsigned long *)&vy1)>>31]; //=sgn(vy1)*4*VSID
	if (gdz[0] <= 0) { gpz[0] = 0x7fffffff; gdz[0] = 0; } //Hack for divide overflow
	else ftol(gposxfrac[(*(unsigned long *)&vx1)>>31]*(float)gdz[0],&gpz[0]);
	if (gdz[1] <= 0) { gpz[1] = 0x7fffffff; gdz[1] = 0; } //Hack for divide overflow
	else ftol(gposyfrac[(*(unsigned long *)&vy1)>>31]*(float)gdz[1],&gpz[1]);

	c = &cf[128];
	c->i0 = gscanptr; c->i1 = &gscanptr[leng];
	c->z0 = gstartz0; c->z1 = gstartz1;
	if (giforzsgn < 0)
	{
		ftol((vd1-vd0)*cmprecip[leng],&gi0); ftol(vd0*CMPPREC,&c->cx0);
		ftol((vz1-vz0)*cmprecip[leng],&gi1); ftol(vz0*CMPPREC,&c->cy0);
	}
	else
	{
		ftol((vd0-vd1)*cmprecip[leng],&gi0); ftol(vd1*CMPPREC,&c->cx0);
		ftol((vz0-vz1)*cmprecip[leng],&gi1); ftol(vz1*CMPPREC,&c->cy0);
	}
	c->cx1 = leng*gi0 + c->cx0;
	c->cy1 = leng*gi1 + c->cy0;

	gxmax = gmaxscandist;

		//Hack for early-out case when looking up towards sky
#if 0  //DOESN'T WORK WITH LOWER MIPS!
	if (c->cy1 < 0)
		if (gposz > 0)
		{
			if (dmulrethigh(-gposz,c->cx1,c->cy1,gxmax) >= 0)
			{
				j = scale(-gposz,c->cx1,c->cy1)+PREC; //+PREC for good luck
				if ((unsigned long)j < (unsigned long)gxmax) gxmax = j;
			}
		} else gxmax = 0;
#endif

		//Clip borders safely (MUST use integers!) - don't wrap around
#if ((USEZBUFFER == 1) && (USEV5ASM != 0))
	skycast.dist = gxmax;
#endif
	if (gixy[0] < 0) j = glipos.x; else j = VSID-1-glipos.x;
	q = mul64(gdz[0],j); q += (unsigned __int64)gpz[0];
	if (q < (unsigned __int64)gxmax)
	{
		gxmax = (long)q;
#if ((USEZBUFFER == 1) && (USEV5ASM != 0))
		skycast.dist = 0x7fffffff;
#endif
	}
	if (gixy[1] < 0) j = glipos.y; else j = VSID-1-glipos.y;
	q = mul64(gdz[1],j); q += (unsigned __int64)gpz[1];
	if (q < (unsigned __int64)gxmax)
	{
		gxmax = (long)q;
#if ((USEZBUFFER == 1) && (USEV5ASM != 0))
		skycast.dist = 0x7fffffff;
#endif
	}

	if (vx5.sideshademode)
	{
		gcsub[0] = gcsub[(((unsigned long)gixy[0])>>31)+4];
		gcsub[1] = gcsub[(((unsigned long)gixy[1])>>31)+6];
	}

#if USEV5ASM
	if (nskypic)
	{
		if (skycurlng < 0)
		{
			ftol((atan2(vy1,vx1)+PI)*skylngmul-.5,&skycurlng);
			if ((unsigned long)skycurlng >= skyysiz)
				skycurlng = ((skyysiz-1)&(j>>31));
		}
		else if (skycurdir < 0)
		{
			j = skycurlng+1; if (j >= skyysiz) j = 0;
			while (skylng[j].x*vy1 > skylng[j].y*vx1)
				{ skycurlng = j++; if (j >= skyysiz) j = 0; }
		}
		else
		{
			while (skylng[skycurlng].x*vy1 < skylng[skycurlng].y*vx1)
				{ skycurlng--; if (skycurlng < 0) skycurlng = skyysiz-1; }
		}
		skyoff = skycurlng*skybpl + nskypic;
	}

	//resp = 0;
	grouscanasm((long)gstartv);
	//if (resp)
	//{
	//   static char tempbuf[2048], tempbuf2[256];
	//   sprintf(tempbuf,"eax:%08x\tmm0:%08x%08x\nebx:%08x\tmm1:%08x%08x\necx:%08x\tmm2:%08x%08x\nedx:%08x\tmm3:%08x%08x\nesi:%08x\tmm4:%08x%08x\nedi:%08x\tmm5:%08x%08x\nebp:%08x\tmm6:%08x%08x\nesp:%08x\tmm7:%08x%08x\n",
	//      reax,remm[ 1],remm[ 0], rebx,remm[ 3],remm[ 2],
	//      recx,remm[ 5],remm[ 4], redx,remm[ 7],remm[ 6],
	//      resi,remm[ 9],remm[ 8], redi,remm[11],remm[10],
	//      rebp,remm[13],remm[12], resp,remm[15],remm[14]);
	//
	//   for(j=0;j<3;j++)
	//   {
	//      sprintf(tempbuf2,"%d i0:%d i1:%d z0:%ld z1:%ld cx0:%08x cy0:%08x cx1:%08x cy1:%08x\n",
	//         j,(long)cf[j].i0-(long)gscanptr,(long)cf[j].i1-(long)gscanptr,cf[j].z0,cf[j].z1,cf[j].cx0,cf[j].cy0,cf[j].cx1,cf[j].cy1);
	//      strcat(tempbuf,tempbuf2);
	//   }
	//   evilquit(tempbuf);
	//}
#else
//------------------------------------------------------------------------
	ce = c; v = gstartv;
	j = (((unsigned long)(gpz[1]-gpz[0]))>>31);
	gx = gpz[j];
	ixy = gpixy;
	if (v == (char *)*(long *)gpixy) goto drawflor; goto drawceil;

	while (1)
	{

drawfwall:;
		if (v[1] != c->z1)
		{
			if (v[1] > c->z1) c->z1 = v[1];
			else { do
			{
				c->z1--; col = *(long *)&v[(c->z1-v[1])*4+4];
				while (dmulrethigh(gylookup[c->z1],c->cx1,c->cy1,ogx) < 0)
				{
					c->i1->col = col; c->i1--; if (c->i0 > c->i1) goto deletez;
					c->cx1 -= gi0; c->cy1 -= gi1;
				}
			} while (v[1] != c->z1); }
		}

		if (v == (char *)*(long *)ixy) goto drawflor;

//drawcwall:;
		if (v[3] != c->z0)
		{
			if (v[3] < c->z0) c->z0 = v[3];
			else { do
			{
				c->z0++; col = *(long *)&v[(c->z0-v[3])*4-4];
				while (dmulrethigh(gylookup[c->z0],c->cx0,c->cy0,ogx) >= 0)
				{
					c->i0->col = col; c->i0++; if (c->i0 > c->i1) goto deletez;
					c->cx0 += gi0; c->cy0 += gi1;
				}
			} while (v[3] != c->z0); }
		}

drawceil:;
		while (dmulrethigh(gylookup[c->z0],c->cx0,c->cy0,gx) >= 0)
		{
			c->i0->col = (*(long *)&v[-4]); c->i0++; if (c->i0 > c->i1) goto deletez;
			c->cx0 += gi0; c->cy0 += gi1;
		}

drawflor:;
		while (dmulrethigh(gylookup[c->z1],c->cx1,c->cy1,gx) < 0)
		{
			c->i1->col = *(long *)&v[4]; c->i1--; if (c->i0 > c->i1) goto deletez;
			c->cx1 -= gi0; c->cy1 -= gi1;
		}

afterdelete:;
		c--;
		if (c < &cf[128])
		{
			ixy += gixy[j];
			gpz[j] += gdz[j];
			j = (((unsigned long)(gpz[1]-gpz[0]))>>31);
			ogx = gx; gx = gpz[j];

			if (gx > gxmax) break;
			v = (char *)*(long *)ixy; c = ce;
		}
			//Find highest intersecting vbuf slab
		while (1)
		{
			if (!v[0]) goto drawfwall;
			if (dmulrethigh(gylookup[v[2]+1],c->cx0,c->cy0,ogx) >= 0) break;
			v += v[0]*4;
		}
			//If next slab ALSO intersects, split cf!
		gy = gylookup[v[v[0]*4+3]];
		if (dmulrethigh(gy,c->cx1,c->cy1,ogx) < 0)
		{
			col = (long)c->i1; dax = c->cx1; day = c->cy1;
			while (dmulrethigh(gylookup[v[2]+1],dax,day,ogx) < 0)
				{ col -= sizeof(castdat); dax -= gi0; day -= gi1; }
			ce++; if (ce >= &cf[192]) return; //Give it max=64 entries like ASM
			for(c2=ce;c2>c;c2--) c2[0] = c2[-1];
			c[1].i1 = (castdat *)col; c->i0 = ((castdat *)col)+1;
			c[1].cx1 = dax; c->cx0 = dax+gi0;
			c[1].cy1 = day; c->cy0 = day+gi1;
			c[1].z1 = c->z0 = v[v[0]*4+3];
			c++;
		}
	}
//------------------------------------------------------------------------

	for(c=ce;c>=&cf[128];c--)
		while (c->i0 <= c->i1) { c->i0->col = 0; c->i0++; }
	return;

deletez:;
	ce--; if (ce < &cf[128]) return;
	for(c2=c;c2<=ce;c2++) c2[0] = c2[1];
	goto afterdelete;
#endif
}

#ifdef _MSC_VER

static _inline void mmxcoloradd (long *a)
{
	_asm
	{
		mov eax, a
		movd mm0, [eax]
		paddusb mm0, flashbrival
		movd [eax], mm0
	}
}

static _inline void mmxcolorsub (long *a)
{
	_asm
	{
		mov eax, a
		movd mm0, [eax]
		psubusb mm0, flashbrival
		movd [eax], mm0
	}
}

#endif

static _inline void addusb (char *a, long b)
{
  if( b + (long)(*a) < 0 )
    (*a) = 0;
  else
  {
	  (*a) += b;
    if ((*a) < b)
      (*a) = 255;
  }
}

	// (cone diameter vs. % 3D angular area) or: (a vs. 2/(1-cos(a*.5*PI/180)))
	// ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄ¿
	// ³  0: inf     ³ 25: 84.37 ³ 50: 21.35 ³ 75: 9.68 ³ 100: 5.60 ³ 180: 2  ³
	// ³  5: 2101.33 ³ 30: 58.70 ³ 55: 17.70 ³ 80: 8.55 ³ 105: 5.11 ³ 360: 1  ³
	// ³ 10:  525.58 ³ 35: 43.21 ³ 60: 14.93 ³ 85: 7.61 ³ 110: 4.69 ÃÄÄÄÄÄÄÄÄÄÙ
	// ³ 15:  233.78 ³ 40: 33.16 ³ 65: 12.77 ³ 90: 6.83 ³ 115: 4.32 ³
	// ³ 20:  131.65 ³ 45: 26.27 ³ 70: 11.06 ³ 95: 6.17 ³ 120: 4    ³
	// ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÙ
void setflash (float px, float py, float pz, long flashradius, long numang, long intens)
{
	unsigned __int64 q;
	float vx, vy;
	long i, j, gx, ogx, ixy, col, angoff;
	long ipx, ipy, ipz, sz0, sz1;
	cftype *c, *c2, *ce;
	char *v, *vs;

	ipx = (long)px; ipy = (long)py; ipz = (long)pz;
	vx5.minx = ipx-flashradius; vx5.maxx = ipx+flashradius+1;
	vx5.miny = ipy-flashradius; vx5.maxy = ipy+flashradius+1;
	vx5.minz = ipz-flashradius; vx5.maxz = ipz+flashradius+1;

	if (flashradius > 2047) flashradius = 2047;
	flashradius *= FPREC;

	flashbrival = (intens<<24);
	angoff = ((0x52741630>>(flashcnt<<2))&15); flashcnt++;

	gposxfrac[1] = px - (float)(ipx); gposxfrac[0] = 1 - gposxfrac[1];
	gposyfrac[1] = py - (float)(ipy); gposyfrac[0] = 1 - gposyfrac[1];
	gpixy = (long)&sptr[ipy*VSID + ipx];
	ftol(pz*FPREC-.5f,&gposz);
	for(gylookup[0]=-gposz,i=1;i<260;i++) gylookup[i] = gylookup[i-1]+FPREC;

	vs = (char *)*(long *)gpixy;
	if (ipz >= vs[1])
	{
		do
		{
			if (!vs[0]) return;
			vs += vs[0]*4;
		} while (ipz >= vs[1]);
		if (ipz < vs[3]) return;
		sz0 = vs[3];
	} else sz0 = 0;
	sz1 = vs[1];

	for(i=0;i<numang;i++)
	{
		_asm emms

		fcossin(((float)i+(float)angoff*.125f)*PI*2.0f/(float)numang,&vx,&vy);

		ftol(FPREC/fabs(vx),&gdz[0]);
		ftol(FPREC/fabs(vy),&gdz[1]);

		gixy[0] = (((*(signed long *)&vx)>>31) & (     -8)) +      4;
		gixy[1] = (((*(signed long *)&vy)>>31) & (VSID*-8)) + VSID*4;
		if (gdz[0] < 0) { gpz[0] = 0x7fffffff; gdz[0] = 0; } //Hack for divide overflow
		else ftol(gposxfrac[(*(unsigned long *)&vx)>>31]*(float)gdz[0],&gpz[0]);
		if (gdz[1] < 0) { gpz[1] = 0x7fffffff; gdz[1] = 0; } //Hack for divide overflow
		else ftol(gposyfrac[(*(unsigned long *)&vy)>>31]*(float)gdz[1],&gpz[1]);

		c = ce = &cf[128];
		v = vs; c->z0 = sz0; c->z1 = sz1;
			//Note!  These substitions are used in flashscan:
			//   c->i0 in flashscan is now: c->cx0
			//   c->i1 in flashscan is now: c->cx1
		c->cx0 = (((i+flashcnt+rand())&7)<<LOGFLASHVANG);
		c->cx1 = c->cx0+(1<<LOGFLASHVANG)-1;

		gxmax = flashradius;

			//Clip borders safely (MUST use integers!) - don't wrap around
		if (gixy[0] < 0) j = ipx; else j = VSID-1-ipx;
		q = mul64(gdz[0],j); q += (unsigned __int64)gpz[0];
		if (q < (unsigned __int64)gxmax) gxmax = (long)q;
		if (gixy[1] < 0) j = ipy; else j = VSID-1-ipy;
		q = mul64(gdz[1],j); q += (unsigned __int64)gpz[1];
		if (q < (unsigned __int64)gxmax) gxmax = (long)q;

	//------------------------------------------------------------------------
		j = (((unsigned long)(gpz[1]-gpz[0]))>>31);
		gx = gpz[j];
		ixy = gpixy;
		if (v == (char *)*(long *)gpixy) goto fdrawflor; goto fdrawceil;

		while (1)
		{

fdrawfwall:;
			if (v[1] != c->z1)
			{
				if (v[1] > c->z1) c->z1 = v[1];
				else { do
				{
					c->z1--; col = (long)&v[(c->z1-v[1])*4+4];
					while (dmulrethigh(gylookup[c->z1],gfc[c->cx1].x,gfc[c->cx1].y,ogx) < 0)
					{
						mmxcoloradd((long *)col); c->cx1--;
						if (c->cx0 > c->cx1) goto fdeletez;
					}
				} while (v[1] != c->z1); }
			}

			if (v == (char *)*(long *)ixy) goto fdrawflor;

//fdrawcwall:;
			if (v[3] != c->z0)
			{
				if (v[3] < c->z0) c->z0 = v[3];
				else { do
				{
					c->z0++; col = (long)&v[(c->z0-v[3])*4-4];
					while (dmulrethigh(gylookup[c->z0],gfc[c->cx0].x,gfc[c->cx0].y,ogx) >= 0)
					{
						mmxcoloradd((long *)col); c->cx0++;
						if (c->cx0 > c->cx1) goto fdeletez;
					}
				} while (v[3] != c->z0); }
			}

fdrawceil:;
			while (dmulrethigh(gylookup[c->z0],gfc[c->cx0].x,gfc[c->cx0].y,gx) >= 0)
			{
				mmxcoloradd((long *)&v[-4]); c->cx0++;
				if (c->cx0 > c->cx1) goto fdeletez;
			}

fdrawflor:;
			while (dmulrethigh(gylookup[c->z1],gfc[c->cx1].x,gfc[c->cx1].y,gx) < 0)
			{
				mmxcoloradd((long *)&v[4]); c->cx1--;
				if (c->cx0 > c->cx1) goto fdeletez;
			}

fafterdelete:;
			c--;
			if (c < &cf[128])
			{
				ixy += gixy[j];
				gpz[j] += gdz[j];
				j = (((unsigned long)(gpz[1]-gpz[0]))>>31);
				ogx = gx; gx = gpz[j];

				if (gx > gxmax) break;
				v = (char *)*(long *)ixy; c = ce;
			}
				//Find highest intersecting vbuf slab
			while (1)
			{
				if (!v[0]) goto fdrawfwall;
				if (dmulrethigh(gylookup[v[2]+1],gfc[c->cx0].x,gfc[c->cx0].y,ogx) >= 0) break;
				v += v[0]*4;
			}
				//If next slab ALSO intersects, split cf!
			if (dmulrethigh(gylookup[v[v[0]*4+3]],gfc[c->cx1].x,gfc[c->cx1].y,ogx) < 0)
			{
				col = c->cx1;
				while (dmulrethigh(gylookup[v[2]+1],gfc[col].x,gfc[col].y,ogx) < 0)
					col--;
				ce++; if (ce >= &cf[192]) break; //Give it max=64 entries like ASM
				for(c2=ce;c2>c;c2--) c2[0] = c2[-1];
				c[1].cx1 = col; c->cx0 = col+1;
				c[1].z1 = c->z0 = v[v[0]*4+3];
				c++;
			}
		}
fcontinue:;
	}

	_asm emms
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
	return;

fdeletez:;
	ce--; if (ce < &cf[128]) goto fcontinue;
	for(c2=c;c2<=ce;c2++) c2[0] = c2[1];
	goto fafterdelete;
}

#if (ESTNORMRAD == 2)
static signed char bitnum[32] =
{
	0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5
};
//static long bitsum[32] =
//{
//   0,-2,-1,-3, 0,-2,-1,-3, 1,-1, 0,-2, 1,-1, 0,-2,
//   2, 0, 1,-1, 2, 0, 1,-1, 3, 1, 2, 0, 3, 1, 2, 0
//};
static long bitsnum[32] =
{
	0        ,1-(2<<16),1-(1<<16),2-(3<<16),
	1        ,2-(2<<16),2-(1<<16),3-(3<<16),
	1+(1<<16),2-(1<<16),2        ,3-(2<<16),
	2+(1<<16),3-(1<<16),3        ,4-(2<<16),
	1+(2<<16),2        ,2+(1<<16),3-(1<<16),
	2+(2<<16),3        ,3+(1<<16),4-(1<<16),
	2+(3<<16),3+(1<<16),3+(2<<16),4,
	3+(3<<16),4+(1<<16),4+(2<<16),5
};
static float fsqrecip[5860]; //75*75 + 15*15 + 3*3 = 5859 is max value (5*5*5 box)
#endif

void estnorm (long x, long y, long z, point3d *fp)
{
	lpoint3d n;
	long *lptr, xx, yy, zz, b[5], i, j, k;
	float f;

	n.x = 0; n.y = 0; n.z = 0;

#if (ESTNORMRAD == 2)
	if (labs(x-xbsox) + labs(y-xbsoy) > 1)
	{
			//x,y not close enough to cache: calls expandbitstack 25 times :(
		xbsox = x; xbsoy = y; xbsof = 24*5;
		lptr = (long *)(&xbsbuf[24*5+1]);
		for(yy=-2;yy<=2;yy++)
			for(xx=-2;xx<=2;xx++,lptr-=10)
				expandbitstack(x+xx,y+yy,(__int64 *)lptr);
	}
	else if (x != xbsox)
	{
			//shift xbsbuf cache left/right: calls expandbitstack 5 times :)
		if (x < xbsox) { xx = -2; xbsof -= 24*5; lptr = (long *)(&xbsbuf[xbsof+1]); }
					 else { xx = 2; lptr = (long *)(&xbsbuf[xbsof-5*5+1]); xbsof -= 1*5; }
		xbsox = x; if (xbsof < 0) xbsof += 25*5;
		for(yy=-2;yy<=2;yy++)
		{
			if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			expandbitstack(x+xx,y+yy,(__int64 *)lptr);
			lptr -= 5*10;
		}
	}
	else if (y != xbsoy)
	{
			//shift xbsbuf cache up/down: calls expandbitstack 5 times :)
		if (y < xbsoy) { yy = -2; xbsof -= 20*5; lptr = (long *)(&xbsbuf[xbsof+1]); }
					 else { yy = 2; lptr = (long *)(&xbsbuf[xbsof+1]); xbsof -= 5*5; }
		xbsoy = y; if (xbsof < 0) xbsof += 25*5;
		for(xx=-2;xx<=2;xx++)
		{
			if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			expandbitstack(x+xx,y+yy,(__int64 *)lptr);
			lptr -= 1*10;
		}
	}

	z -= 2;
	if ((z&31) <= 27) //2 <= (z&31) <= 29
		{ lptr = (long *)((long)(&xbsbuf[xbsof+1]) + ((z&~31)>>3)); z &= 31; }
	else
		{ lptr = (long *)((long)(&xbsbuf[xbsof+1]) + (z>>3)); z &= 7; }

	for(yy=-2;yy<=2;yy++)
	{
		if (lptr >= (long *)&xbsbuf[1+10*5])
		{
			b[0] = ((lptr[  0]>>z)&31); b[1] = ((lptr[-10]>>z)&31);
			b[2] = ((lptr[-20]>>z)&31); b[3] = ((lptr[-30]>>z)&31);
			b[4] = ((lptr[-40]>>z)&31); lptr -= 50;
		}
		else
		{
			b[0] = ((lptr[0]>>z)&31); lptr -= 10; if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			b[1] = ((lptr[0]>>z)&31); lptr -= 10; if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			b[2] = ((lptr[0]>>z)&31); lptr -= 10; if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			b[3] = ((lptr[0]>>z)&31); lptr -= 10; if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
			b[4] = ((lptr[0]>>z)&31); lptr -= 10; if (lptr < (long *)&xbsbuf[1]) lptr += 25*10;
		}

			//Make filter spherical
		//if (yy&1) { b[0] &= 0xe; b[4] &= 0xe; }
		//else if (yy) { b[0] &= 0x4; b[1] &= 0xe; b[3] &= 0xe; b[4] &= 0x4; }

		n.x += ((bitnum[b[4]]-bitnum[b[0]])<<1)+bitnum[b[3]]-bitnum[b[1]];
		j = bitsnum[b[0]]+bitsnum[b[1]]+bitsnum[b[2]]+bitsnum[b[3]]+bitsnum[b[4]];
		n.z += j; n.y += (*(signed short *)&j)*yy;
	}
	n.z >>= 16;
#else
	for(yy=-ESTNORMRAD;yy<=ESTNORMRAD;yy++)
		for(xx=-ESTNORMRAD;xx<=ESTNORMRAD;xx++)
			for(zz=-ESTNORMRAD;zz<=ESTNORMRAD;zz++)
				if (isvoxelsolid(x+xx,y+yy,z+zz))
					{ n.x += xx; n.y += yy; n.z += zz; }
#endif

#if 1
	f = fsqrecip[n.x*n.x + n.y*n.y + n.z*n.z];
	fp->x = ((float)n.x)*f; fp->y = ((float)n.y)*f; fp->z = ((float)n.z)*f;
#else

		//f = 1.0 / sqrt((double)(n.x*n.x + n.y*n.y + n.z*n.z));
		//fp->x = f*(float)n.x; fp->y = f*(float)n.y; fp->z = f*(float)n.z;
	zz = n.x*n.x + n.y*n.y + n.z*n.z;
	if (cputype&(1<<25))
	{
		_asm
		{
			cvtsi2ss xmm0, zz
			rsqrtss xmm0, xmm0
			;movss f, xmm0

				;fp->x = f*(float)n.x; fp->y = f*(float)n.y; fp->z = f*(float)n.z;
			cvtsi2ss xmm1, n.z
			shufps xmm0, xmm0, 0
			mov eax, fp
			movlhps xmm1, xmm1
			cvtpi2ps xmm1, n
			mulps xmm0, xmm1
			movlps [eax], xmm0
			movhlps xmm0, xmm0
			movss [eax+8], xmm0
		}
	}
	else
	{
		_asm
		{
			pi2fd mm0, zz       ;mm0:     0          zz
			pfrsqrt mm0, mm0    ;mm0: 1/sqrt(zz) 1/sqrt(zz)
			pi2fd mm1, n.x      ;mm1:     0         n.x
			pi2fd mm2, n.y      ;mm2:     0         n.y
			punpckldq mm1, mm2  ;mm1:    n.y        n.x
			pi2fd mm2, n.z      ;mm2:     0         n.z
			pfmul mm1, mm0      ;mm1:n.y/sqrt(zz) n.x/sqrt(zz)
			pfmul mm2, mm0      ;mm2:     0       n.z/sqrt(zz)
			mov eax, fp
			movq [eax], mm1
			movd [eax+8], mm2
			femms
		}
	}
#endif
}

static long vspan (long x, long y0, long y1)
{
	long y, yy, *bbufx;

	y = (y0>>5); bbufx = &bbuf[x][0];
	if ((y1>>5) == y)
	{
		yy = bbufx[y]; bbufx[y] &= ~(p2m[y1&31]^p2m[y0&31]);
		return(bbufx[y] ^ yy);
	}

	if (!(bbufx[y]&(~p2m[y0&31])))
		if (!(bbufx[y1>>5]&p2m[y1&31]))
		{
			for(yy=(y1>>5)-1;yy>y;yy--)
				if (bbufx[yy]) goto vspan_skip;
			return(0);
		}
vspan_skip:;
	bbufx[y] &= p2m[y0&31];
	bbufx[y1>>5] &= (~p2m[y1&31]);
	for(yy=(y1>>5)-1;yy>y;yy--) bbufx[yy] = 0;
	return(1);
}

static long docube (long x, long y, long z)
{
	long x0, y0, x1, y1, g;

	ffxptr = &ffx[(z+1)*z-1];
	x0 = (long)ffxptr[x].x; x1 = (long)ffxptr[x].y;
	y0 = (long)ffxptr[y].x; y1 = (long)ffxptr[y].y;
	for(g=0;x0<x1;x0++) g |= vspan(x0,y0,y1);
	return(g);
}

void setnormflash (float px, float py, float pz, long flashradius, long intens)
{
	point3d fp;
	float f, fintens;
	long i, j, k, l, m, x, y, z, xx, yy, xi, yi, xe, ye, ipx, ipy, ipz;
	long ceilnum, sq;
	char *v;

	ipx = (long)px; ipy = (long)py; ipz = (long)pz;
	vx5.minx = ipx-flashradius+1; vx5.maxx = ipx+flashradius;
	vx5.miny = ipy-flashradius+1; vx5.maxy = ipy+flashradius;
	vx5.minz = ipz-flashradius+1; vx5.maxz = ipz+flashradius;

	if (isvoxelsolid(ipx,ipy,ipz)) return;

	fintens = intens;
	if (flashradius > (GSIZ>>1)) flashradius = (GSIZ>>1);

	xbsox = -17;

		//       ÚÄ 7Ä¿
		//      11  . 8
		//  ÚÄ11ÄÅÄ 4ÄÅÄ 8ÄÂÄ 7Ä¿
		//  3 |  0  + 1  | 2  + 3
		//  ÀÄ10ÄÅÄ 5ÄÅÄ 9ÄÁÄ 6ÄÙ
		//      10  . 9
		//       ÀÄ 6ÄÙ

		//Do left&right faces of the cube
	for(j=1;j>=0;j--)
	{
		clearbuf((void *)bbuf,GSIZ*(GSIZ>>5),0xffffffff);
		for(y=1;y<flashradius;y++)
		{
			if (j) yy = ipy-y; else yy = ipy+y;
			for(xi=1,xe=y+1;xi>=-1;xi-=2,xe=-xe)
				for(x=(xi>>1);x!=xe;x+=xi)
				{
					xx = ipx+x;
					if ((unsigned long)(xx|yy) >= VSID) continue;
					v = sptr[yy*VSID+xx]; i = 0; sq = x*x+y*y;
					while (1)
					{
						for(z=v[1];z<=v[2];z++)
						{
							if (z-ipz < 0) { tbuf2[i] = z-ipz; tbuf2[i+1] = (long)&v[(z-v[1])*4+4]; i += 2; }
							else
							{
								//if (z-ipz < -y) continue; //TEMP HACK!!!
								if (z-ipz > y) goto normflash_exwhile1;
								if (!docube(x,z-ipz,y)) continue;
								estnorm(xx,yy,z,&fp); if (j) fp.y = -fp.y;
								f = fp.x*x + fp.y*y + fp.z*(z-ipz);
								if (*(long *)&f > 0) addusb(&v[(z-v[1])*4+7],f*fintens/((z-ipz)*(z-ipz)+sq));
							}
						}
						if (!v[0]) break;
						ceilnum = v[2]-v[1]-v[0]+2; v += v[0]*4;
						for(z=v[3]+ceilnum;z<v[3];z++)
						{
							if (z < ipz) { tbuf2[i] = z-ipz; tbuf2[i+1] = (long)&v[(z-v[3])*4]; i += 2; }
							else
							{
								//if (z-ipz < -y) continue; //TEMP HACK!!!
								if (z-ipz > y) goto normflash_exwhile1;
								if (!docube(x,z-ipz,y)) continue;
								estnorm(xx,yy,z,&fp); if (j) fp.y = -fp.y;
								f = fp.x*x + fp.y*y + fp.z*(z-ipz);
								if (*(long *)&f > 0) addusb(&v[(z-v[3])*4+3],f*fintens/((z-ipz)*(z-ipz)+sq));
							}
						}
					}
normflash_exwhile1:;
					while (i > 0)
					{
						i -= 2; if (tbuf2[i] < -y) break;
						if (!docube(x,tbuf2[i],y)) continue;
						estnorm(xx,yy,tbuf2[i]+ipz,&fp); if (j) fp.y = -fp.y;
						f = fp.x*x + fp.y*y + fp.z*tbuf2[i];
						if (*(long *)&f > 0) addusb(&((char *)tbuf2[i+1])[3],f*fintens/(tbuf2[i]*tbuf2[i]+sq));
					}
				}
		}
	}

		//Do up&down faces of the cube
	for(j=1;j>=0;j--)
	{
		clearbuf((void *)bbuf,GSIZ*(GSIZ>>5),0xffffffff);
		for(y=1;y<flashradius;y++)
		{
			if (j) xx = ipx-y; else xx = ipx+y;
			for(xi=1,xe=y+1;xi>=-1;xi-=2,xe=-xe)
				for(x=(xi>>1);x!=xe;x+=xi)
				{
					yy = ipy+x;
					if ((unsigned long)(xx|yy) >= VSID) continue;
					v = sptr[yy*VSID+xx]; i = 0; sq = x*x+y*y; m = x+xi-xe;
					while (1)
					{
						for(z=v[1];z<=v[2];z++)
						{
							if (z-ipz < 0) { tbuf2[i] = z-ipz; tbuf2[i+1] = (long)&v[(z-v[1])*4+4]; i += 2; }
							else
							{
								//if (z-ipz < -y) continue; //TEMP HACK!!!
								if (z-ipz > y) goto normflash_exwhile2;
								if ((!docube(x,z-ipz,y)) || (!m)) continue;
								estnorm(xx,yy,z,&fp); if (j) fp.x = -fp.x;
								f = fp.x*y + fp.y*x + fp.z*(z-ipz);
								if (*(long *)&f > 0) addusb(&v[(z-v[1])*4+7],f*fintens/((z-ipz)*(z-ipz)+sq));
							}
						}
						if (!v[0]) break;
						ceilnum = v[2]-v[1]-v[0]+2; v += v[0]*4;
						for(z=v[3]+ceilnum;z<v[3];z++)
						{
							if (z < ipz) { tbuf2[i] = z-ipz; tbuf2[i+1] = (long)&v[(z-v[3])*4]; i += 2; }
							else
							{
								//if (z-ipz < -y) continue; //TEMP HACK!!!
								if (z-ipz > y) goto normflash_exwhile2;
								if ((!docube(x,z-ipz,y)) || (!m)) continue;
								estnorm(xx,yy,z,&fp); if (j) fp.x = -fp.x;
								f = fp.x*y + fp.y*x + fp.z*(z-ipz);
								if (*(long *)&f > 0) addusb(&v[(z-v[3])*4+3],f*fintens/((z-ipz)*(z-ipz)+sq));
							}
						}
					}
normflash_exwhile2:;
					while (i > 0)
					{
						i -= 2; if (tbuf2[i] < -y) break;
						if ((!docube(x,tbuf2[i],y)) || (!m)) continue;
						estnorm(xx,yy,tbuf2[i]+ipz,&fp); if (j) fp.x = -fp.x;
						f = fp.x*y + fp.y*x + fp.z*tbuf2[i];
						if (*(long *)&f > 0) addusb(&((char *)tbuf2[i+1])[3],f*fintens/(tbuf2[i]*tbuf2[i]+sq));
					}
				}
		}
	}

		//Do the bottom face of the cube
	clearbuf((void *)bbuf,GSIZ*(GSIZ>>5),0xffffffff);
	for(yi=1,ye=flashradius+1;yi>=-1;yi-=2,ye=-ye)
		for(y=(yi>>1);y!=ye;y+=yi)
			for(xi=1,xe=flashradius+1;xi>=-1;xi-=2,xe=-xe)
				for(x=(xi>>1);x!=xe;x+=xi)
				{
					xx = ipx+x; yy = ipy+y;
					if ((unsigned long)(xx|yy) >= VSID) goto normflash_exwhile3;
					k = max(labs(x),labs(y));

					v = sptr[yy*VSID+xx]; sq = x*x+y*y;
					while (1)
					{
						for(z=v[1];z<=v[2];z++)
						{
							if (z-ipz < k) continue;
							if (z-ipz >= flashradius) goto normflash_exwhile3;
							if ((!docube(x,y,z-ipz)) || (z-ipz == k)) continue;
							estnorm(xx,yy,z,&fp);
							f = fp.x*x + fp.y*y + fp.z*(z-ipz);
							if (*(long *)&f > 0) addusb(&v[(z-v[1])*4+7],f*fintens/((z-ipz)*(z-ipz)+sq));
						}
						if (!v[0]) break;
						ceilnum = v[2]-v[1]-v[0]+2; v += v[0]*4;
						for(z=v[3]+ceilnum;z<v[3];z++)
						{
							if (z-ipz < k) continue;
							if (z-ipz >= flashradius) goto normflash_exwhile3;
							if ((!docube(x,y,z-ipz)) || (z-ipz <= k)) continue;
							estnorm(xx,yy,z,&fp);
							f = fp.x*x + fp.y*y + fp.z*(z-ipz);
							if (*(long *)&f > 0) addusb(&v[(z-v[3])*4+3],f*fintens/((z-ipz)*(z-ipz)+sq));
						}
					}
normflash_exwhile3:;
				}


		//Do the top face of the cube
	clearbuf((void *)bbuf,GSIZ*(GSIZ>>5),0xffffffff);
	for(yi=1,ye=flashradius+1;yi>=-1;yi-=2,ye=-ye)
		for(y=(yi>>1);y!=ye;y+=yi)
			for(xi=1,xe=flashradius+1;xi>=-1;xi-=2,xe=-xe)
				for(x=(xi>>1);x!=xe;x+=xi)
				{
					xx = ipx+x; yy = ipy+y;
					if ((unsigned long)(xx|yy) >= VSID) goto normflash_exwhile4;
					k = max(labs(x),labs(y)); m = ((x+xi != xe) && (y+yi != ye));

					v = sptr[yy*VSID+xx]; i = 0; sq = x*x+y*y;
					while (1)
					{
						for(z=v[1];z<=v[2];z++)
						{
							if (ipz-z >= flashradius) continue;
							if (ipz-z < k) goto normflash_exwhile4;
							tbuf2[i] = ipz-z; tbuf2[i+1] = (long)&v[(z-v[1])*4+4]; i += 2;
						}
						if (!v[0]) break;
						ceilnum = v[2]-v[1]-v[0]+2; v += v[0]*4;
						for(z=v[3]+ceilnum;z<v[3];z++)
						{
							if (ipz-z >= flashradius) continue;
							if (ipz-z < k) goto normflash_exwhile4;
							tbuf2[i] = ipz-z; tbuf2[i+1] = (long)&v[(z-v[3])*4]; i += 2;
						}
					}
normflash_exwhile4:;
					while (i >= 2) // potential bug fix
					{
						i -= 2;
						if ((!docube(x,y,tbuf2[i])) || (tbuf2[i] <= k)) continue;
						estnorm(xx,yy,ipz-tbuf2[i],&fp);
						f = fp.x*x + fp.y*y - fp.z*tbuf2[i];
						if (*(long *)&f > 0) addusb(&((char *)tbuf2[i+1])[3],f*fintens/(tbuf2[i]*tbuf2[i]+sq));
					}
				}
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

void hline (float x0, float y0, float x1, float y1, long *ix0, long *ix1)
{
	float dyx;

	dyx = (y1-y0) * grd; //grd = 1/(x1-x0)

		  if (y0 < wy0) ftol((wy0-y0)/dyx+x0,ix0);
	else if (y0 > wy1) ftol((wy1-y0)/dyx+x0,ix0);
	else ftol(x0,ix0);
		  if (y1 < wy0) ftol((wy0-y0)/dyx+x0,ix1);
	else if (y1 > wy1) ftol((wy1-y0)/dyx+x0,ix1);
	else ftol(x1,ix1);
	if ((*ix0) < iwx0) (*ix0) = iwx0;
	if ((*ix0) > iwx1) (*ix0) = iwx1; //(*ix1) = min(max(*ix1,wx0),wx1);
	gline(labs((*ix1)-(*ix0)),(float)(*ix0),((*ix0)-x1)*dyx + y1,
									  (float)(*ix1),((*ix1)-x1)*dyx + y1);
}

void vline (float x0, float y0, float x1, float y1, long *iy0, long *iy1)
{
	float dxy;

	dxy = (x1-x0) * grd; //grd = 1/(y1-y0)

		  if (x0 < wx0) ftol((wx0-x0)/dxy+y0,iy0);
	else if (x0 > wx1) ftol((wx1-x0)/dxy+y0,iy0);
	else ftol(y0,iy0);
		  if (x1 < wx0) ftol((wx0-x0)/dxy+y0,iy1);
	else if (x1 > wx1) ftol((wx1-x0)/dxy+y0,iy1);
	else ftol(y1,iy1);
	if ((*iy0) < iwy0) (*iy0) = iwy0;
	if ((*iy0) > iwy1) (*iy0) = iwy1;
	gline(labs((*iy1)-(*iy0)),((*iy0)-y1)*dxy + x1,(float)(*iy0),
									  ((*iy1)-y1)*dxy + x1,(float)(*iy1));
}

static float optistrx, optistry, optiheix, optiheiy, optiaddx, optiaddy;

static __int64 foglut[2048], fogcol;
static long ofogdist = -1;

#ifdef _MSC_VER

#ifdef __cplusplus
extern "C" {
#endif
extern void *opti4asm;
#define opti4 ((point4d *)&opti4asm)
#ifdef __cplusplus
}
#endif

void (*hrend)(long,long,long,long,long,long);
void (*vrend)(long,long,long,long,long);

#if (USEZBUFFER != 1)
void hrendnoz (long sx, long sy, long p1, long plc, long incr, long j)
{
	sy = ylookup[sy]+frameplace; p1 = sy+(p1<<2); sy += (sx<<2);
	do
	{
		*(long *)sy = angstart[plc>>16][j].col;
		plc += incr; sy += 4;
	} while (sy != p1);
}

void vrendnoz (long sx, long sy, long p1, long iplc, long iinc)
{
	sy = ylookup[sy]+(sx<<2)+frameplace;
	for(;sx<p1;sx++)
	{
		*(long *)sy = angstart[uurend[sx]>>16][iplc].col;
		uurend[sx] += uurend[sx+MAXXDIM]; sy += 4; iplc += iinc;
	}
}

#else

#if 0
	//Example C code
void hrendz (long sx, long sy, long p1, long plc, long incr, long j)
{
	long p0, i; float dirx, diry;
	p0 = ylookup[sy]+(sx<<2)+frameplace;
	p1 = ylookup[sy]+(p1<<2)+frameplace;
	dirx = optistrx*(float)sx + optiheix*(float)sy + optiaddx;
	diry = optistry*(float)sx + optiheiy*(float)sy + optiaddy;
	i = zbufoff;
	do
	{
		*(long *)p0 = angstart[plc>>16][j].col;
		*(float *)(p0+i) = (float)angstart[plc>>16][j].dist/sqrt(dirx*dirx+diry*diry);
		dirx += optistrx; diry += optistry; plc += incr; p0 += 4;
	} while (p0 != p1);
}

	//Example C code
void vrendz (long sx, long sy, long p1, long iplc, long iinc)
{
	float dirx, diry; long i, p0;
	p0 = ylookup[sy]+(sx<<2)+frameplace;
	p1 = ylookup[sy]+(p1<<2)+frameplace;
	dirx = optistrx*(float)sx + optiheix*(float)sy + optiaddx;
	diry = optistry*(float)sx + optiheiy*(float)sy + optiaddy;
	i = zbufoff;
	while (p0 < p1)
	{
		*(long *)p0 = angstart[uurend[sx]>>16][iplc].col;
		*(float *)(p0+i) = (float)angstart[uurend[sx]>>16][iplc].dist/sqrt(dirx*dirx+diry*diry);
		dirx += optistrx; diry += optistry; uurend[sx] += uurend[sx+MAXXDIM]; p0 += 4; iplc += iinc; sx++;
	}
}

	//Example C code
void hrendzfog (long sx, long sy, long p1, long plc, long incr, long j)
{
	long p0, i, k, l; float dirx, diry;
	p0 = ylookup[sy]+(sx<<2)+frameplace;
	p1 = ylookup[sy]+(p1<<2)+frameplace;
	dirx = optistrx*(float)sx + optiheix*(float)sy + optiaddx;
	diry = optistry*(float)sx + optiheiy*(float)sy + optiaddy;
	i = zbufoff;
	do
	{
		k = angstart[plc>>16][j].col;
		l = angstart[plc>>16][j].dist;
		l = (foglut[l>>20]&32767);
		*(long *)p0 = ((((( vx5.fogcol     &255)-( k     &255))*l)>>15)    ) +
						  ((((((vx5.fogcol>> 8)&255)-((k>> 8)&255))*l)>>15)<< 8) +
						  ((((((vx5.fogcol>>16)&255)-((k>>16)&255))*l)>>15)<<16)+k;
		*(float *)(p0+i) = (float)angstart[plc>>16][j].dist/sqrt(dirx*dirx+diry*diry);
		dirx += optistrx; diry += optistry; plc += incr; p0 += 4;
	} while (p0 != p1);
}

	//Example C code
void vrendzfog (long sx, long sy, long p1, long iplc, long iinc)
{
	float dirx, diry; long i, k, l, p0;
	p0 = ylookup[sy]+(sx<<2)+frameplace;
	p1 = ylookup[sy]+(p1<<2)+frameplace;
	dirx = optistrx*(float)sx + optiheix*(float)sy + optiaddx;
	diry = optistry*(float)sx + optiheiy*(float)sy + optiaddy;
	i = zbufoff;
	while (p0 < p1)
	{
		k = angstart[uurend[sx]>>16][iplc].col;
		l = angstart[uurend[sx]>>16][iplc].dist;
		l = (foglut[l>>20]&32767);
		*(long *)p0 = ((((( vx5.fogcol     &255)-( k     &255))*l)>>15)    ) +
						  ((((((vx5.fogcol>> 8)&255)-((k>> 8)&255))*l)>>15)<< 8) +
						  ((((((vx5.fogcol>>16)&255)-((k>>16)&255))*l)>>15)<<16)+k;
		*(float *)(p0+i) = (float)angstart[uurend[sx]>>16][iplc].dist/sqrt(dirx*dirx+diry*diry);
		dirx += optistrx; diry += optistry; uurend[sx] += uurend[sx+MAXXDIM]; p0 += 4; iplc += iinc; sx++;
	}
}

#endif

void hrendzsse (long sx, long sy, long p1, long plc, long incr, long j)
{
	_asm
	{
		push esi
		push edi
//beghasm_p3:
		mov eax, sx
		mov ecx, sy
		mov esi, p1
		mov edx, ylookup[ecx*4]
		add edx, frameplace
		lea edi, [edx+eax*4]
		lea esi, [edx+esi*4]

		and eax, 0xfffffffc
		cvtsi2ss xmm0, eax
		cvtsi2ss xmm4, ecx
		movss xmm1, xmm0
		movss xmm5, xmm4
		mulss xmm0, optistrx
		mulss xmm1, optistry
		mulss xmm4, optiheix
		mulss xmm5, optiheiy
		addss xmm0, optiaddx
		addss xmm1, optiaddy
		addss xmm0, xmm4
		addss xmm1, xmm5

		mov ecx, zbufoff
		mov edx, j
		movd mm6, plc
		movd mm7, incr

		shufps xmm0, xmm0, 0
		shufps xmm1, xmm1, 0
		movaps xmm2, opti4asm[2*16]
		movaps xmm3, opti4asm[3*16]
		addps xmm0, opti4asm[0*16]
		addps xmm1, opti4asm[1*16]
			;xmm0 =  xmm0      ^2 +  xmm1      ^2        (p)
			;xmm2 = (xmm0+xmm2)^2 + (xmm1+xmm3)^2 - xmm0 (v)
			;xmm1 = ...                                  (a)
		addps xmm2, xmm0  ;This block converts inner loop...
		addps xmm3, xmm1  ;from: 1 / sqrt(x*x + y*y), x += xi, y += yi;
		mulps xmm0, xmm0  ;  to: 1 / sqrt(p), p += v, v += a;
		mulps xmm1, xmm1
		mulps xmm2, xmm2
		mulps xmm3, xmm3
		addps xmm0, xmm1
		movaps xmm1, opti4asm[4*16]
		addps xmm2, xmm3
		subps xmm2, xmm0

			;Do first 0-3 pixels to align unrolled loop of 4
		test edi, 15
		jz short skip1ha

		test edi, 8
		jz short skipshufa
		shufps xmm0, xmm0, 0x4e ;rotate right by 2
skipshufa:
		test edi, 4
		jz short skipshufb
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
skipshufb:

beg1ha:
		pextrw eax, mm6, 1
		paddd mm6, mm7
		mov eax, angstart[eax*4]
		movd mm0, [eax+edx*8]
		movd [edi], mm0
		cvtsi2ss xmm7, [eax+edx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7
		add edi, 4
		cmp edi, esi
		jz short endh
		test edi, 15
		jnz short beg1ha

		addps xmm0, xmm2
		addps xmm2, xmm1
skip1ha:
		lea eax, [edi+16]      ;these 3 lines re-ordered
		cmp eax, esi
		ja short skip4h

		movq mm0, mm6          ;mm0: 0,plc
		paddd mm0, mm7         ;mm0: 0,plc+inc
		punpckldq mm7, mm7     ;mm7: inc,inc
		punpckldq mm6, mm0     ;mm6: plc+inc,plc
		paddd mm7, mm7         ;mm7: inc+inc,inc+inc

		sub esi, 16

		 ;eax: temp   ³ mm0:  z0 argb0   argb1 argb0 ³ xmm0: plc3 plc2 plc1 plc0
		 ;ebx:  -     ³ mm1:  z1 argb1               ³ xmm1: acc3 acc2 acc1 acc0
		 ;ecx:zbufoff ³ mm2:  z2 argb2   argb3 argb2 ³ xmm2: inc3 inc2 inc1 inc0
		 ;edx:  j     ³ mm3:  z3 argb3               ³ xmm3:  r3   r2   r1   r0
		 ;esi:  -     ³ mm4:              z1    z0   ³ xmm4:            z3   z2
		 ;edi:scroff  ³ mm5:              z3    z2   ³ xmm5:
		 ;ebp:  -     ³ mm6: plc1 plc0               ³ xmm6:
beg4h: ;esp:  -     ³ mm7: inc1 inc0               ³ xmm7:  z3   z2   z1   z0
		pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm0, [eax+edx*8]
		pextrw eax, mm6, 3
		mov eax, angstart[eax*4]
		movq mm1, [eax+edx*8]
		paddd mm6, mm7
		pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm2, [eax+edx*8]
		pextrw eax, mm6, 3
		mov eax, angstart[eax*4]
		movq mm3, [eax+edx*8]
		paddd mm6, mm7

		movq mm4, mm0
		movq mm5, mm2
		punpckldq mm0, mm1
		punpckldq mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

		add edi, 16
		cmp edi, esi
		jbe short beg4h
		add esi, 16
		cmp edi, esi
		jae endh

		psrad mm7, 1    ;Restore mm7 from incr*2 to just incr for single loop
skip4h:
beg1h:
		pextrw eax, mm6, 1
		paddd mm6, mm7
		mov eax, angstart[eax*4]
		movd mm0, [eax+edx*8]
		movd [edi], mm0
		cvtsi2ss xmm7, [eax+edx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7
		add edi, 4
		cmp edi, esi
		jb short beg1h
endh: pop edi
		pop esi
	}
}

void hrendzfogsse (long sx, long sy, long p1, long plc, long incr, long j)
{
	static __int64 mm7bak;
	_asm
	{
		push esi
		push edi
//beghasm_p3:
		mov eax, sx
		mov ecx, sy
		mov esi, p1
		mov edx, ylookup[ecx*4]
		add edx, frameplace
		lea edi, [edx+eax*4]
		lea esi, [edx+esi*4]

		and eax, 0xfffffffc
		cvtsi2ss xmm0, eax
		cvtsi2ss xmm4, ecx
		movss xmm1, xmm0
		movss xmm5, xmm4
		mulss xmm0, optistrx
		mulss xmm1, optistry
		mulss xmm4, optiheix
		mulss xmm5, optiheiy
		addss xmm0, optiaddx
		addss xmm1, optiaddy
		addss xmm0, xmm4
		addss xmm1, xmm5

		mov ecx, zbufoff
		mov edx, j
		movd mm6, plc
		movd mm7, incr

		shufps xmm0, xmm0, 0
		shufps xmm1, xmm1, 0
		movaps xmm2, opti4asm[2*16]
		movaps xmm3, opti4asm[3*16]
		addps xmm0, opti4asm[0*16]
		addps xmm1, opti4asm[1*16]
			;xmm0 =  xmm0      ^2 +  xmm1      ^2        (p)
			;xmm2 = (xmm0+xmm2)^2 + (xmm1+xmm3)^2 - xmm0 (v)
			;xmm1 = ...                                  (a)
		addps xmm2, xmm0  ;This block converts inner loop...
		addps xmm3, xmm1  ;from: 1 / sqrt(x*x + y*y), x += xi, y += yi;
		mulps xmm0, xmm0  ;  to: 1 / sqrt(p), p += v, v += a;
		mulps xmm1, xmm1
		mulps xmm2, xmm2
		mulps xmm3, xmm3
		addps xmm0, xmm1
		movaps xmm1, opti4asm[4*16]
		addps xmm2, xmm3
		subps xmm2, xmm0

			;Do first 0-3 pixels to align unrolled loop of 4
		test edi, 15
		jz short skip1ha

		test edi, 8
		jz short skipshufa
		shufps xmm0, xmm0, 0x4e ;rotate right by 2
skipshufa:
		test edi, 4
		jz short skipshufb
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
skipshufb:

beg1ha:
		pextrw eax, mm6, 1
		paddd mm6, mm7
		mov eax, angstart[eax*4]

			;Z
		cvtsi2ss xmm7, [eax+edx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7

			;Col
		punpcklbw mm0, [eax+edx*8]
		psrlw mm0, 8
		movq mm1, fogcol
		psubw mm1, mm0
		paddw mm1, mm1
		mov eax, [eax+edx*8+4]
		shr eax, 16+4
		pmulhw mm1, foglut[eax*8]
		paddw mm0, mm1
		packuswb mm0, mm1
		movd [edi], mm0

		add edi, 4
		cmp edi, esi
		jz short endh
		test edi, 15
		jnz short beg1ha

		addps xmm0, xmm2
		addps xmm2, xmm1
skip1ha:
		lea eax, [edi+16]      ;these 3 lines re-ordered
		cmp eax, esi
		ja short skip4h

		movq mm0, mm6          ;mm0: 0,plc
		paddd mm0, mm7         ;mm0: 0,plc+inc
		punpckldq mm7, mm7     ;mm7: inc,inc
		punpckldq mm6, mm0     ;mm6: plc+inc,plc
		paddd mm7, mm7         ;mm7: inc+inc,inc+inc

		sub esi, 16

		 ;eax: temp   ³ mm0:  z0 argb0   argb1 argb0 ³ xmm0: plc3 plc2 plc1 plc0
		 ;ebx:  -     ³ mm1:  z1 argb1               ³ xmm1: acc3 acc2 acc1 acc0
		 ;ecx:zbufoff ³ mm2:  z2 argb2   argb3 argb2 ³ xmm2: inc3 inc2 inc1 inc0
		 ;edx:  j     ³ mm3:  z3 argb3               ³ xmm3:  r3   r2   r1   r0
		 ;esi:  -     ³ mm4:              z1    z0   ³ xmm4:            z3   z2
		 ;edi:scroff  ³ mm5:              z3    z2   ³ xmm5:
		 ;ebp:  -     ³ mm6: plc1 plc0               ³ xmm6:
		 ;esp:  -     ³ mm7: inc1 inc0               ³ xmm7:  z3   z2   z1   z0

		movq mm7bak, mm7
beg4h:pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm4, [eax+edx*8]
		pextrw eax, mm6, 3
		mov eax, angstart[eax*4]
		movq mm1, [eax+edx*8]
		paddd mm6, mm7bak
		pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm5, [eax+edx*8]
		pextrw eax, mm6, 3
		mov eax, angstart[eax*4]
		movq mm3, [eax+edx*8]
		paddd mm6, mm7bak

		movq mm0, mm4
		movq mm2, mm5

			;Do Z
		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

			;Do colors
			;mm4:dist1 dist0
			;mm5:dist3 dist2
		pxor mm7, mm7
		punpcklbw mm0, mm7
		punpcklbw mm1, mm7
		punpcklbw mm2, mm7
		punpcklbw mm3, mm7

		movq mm7, fogcol
		psubw mm7, mm0
		paddw mm7, mm7
		pextrw eax, mm4, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm0, mm7

		movq mm7, fogcol
		psubw mm7, mm1
		paddw mm7, mm7
		pextrw eax, mm4, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm1, mm7

		movq mm7, fogcol
		psubw mm7, mm2
		paddw mm7, mm7
		pextrw eax, mm5, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm2, mm7

		movq mm7, fogcol
		psubw mm7, mm3
		paddw mm7, mm7
		pextrw eax, mm5, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm3, mm7

		packuswb mm0, mm1
		packuswb mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		add edi, 16
		cmp edi, esi
		jbe short beg4h
		add esi, 16
		cmp edi, esi
		jae endh

		movq mm7, mm7bak
		psrad mm7, 1    ;Restore mm7 from incr*2 to just incr for single loop
skip4h:
beg1h:
		pextrw eax, mm6, 1
		paddd mm6, mm7
		mov eax, angstart[eax*4]

			;Z
		cvtsi2ss xmm7, [eax+edx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7

			;Col
		punpcklbw mm0, [eax+edx*8]
		psrlw mm0, 8
		movq mm1, fogcol
		psubw mm1, mm0
		paddw mm1, mm1
		mov eax, [eax+edx*8+4]
		shr eax, 16+4
		pmulhw mm1, foglut[eax*8]
		paddw mm0, mm1
		packuswb mm0, mm1
		movd [edi], mm0

		add edi, 4
		cmp edi, esi
		jb short beg1h
endh: pop edi
		pop esi
	}
}

void hrendz3dn (long sx, long sy, long p1, long plc, long incr, long j)
{
	_asm
	{
		push esi
		push edi
		mov eax, sy
		mov eax, ylookup[eax*4]
		add eax, frameplace
		mov esi, p1
		lea esi, [eax+esi*4]    ;esi = p1
		mov edi, sx
		lea edi, [eax+edi*4]    ;edi = p0

		movd mm0, sx
		punpckldq mm0, sy
		pi2fd mm0, mm0          ;mm0: (float)sy (float)sx
		pshufw mm2, mm0, 0xee   ;mm2: (float)sy (float)sy
		punpckldq mm0, mm0      ;mm0: (float)sx (float)sx
		movd mm1, optistrx
		punpckldq mm1, optistry
		pfmul mm0, mm1          ;mm0: (float)sx*optistry (float)sx*optistrx
		movd mm3, optiheix
		punpckldq mm3, optiheiy
		pfmul mm2, mm3          ;mm2: (float)sy*optiheiy (float)sy*optiheix
		pfadd mm0, mm2
		movd mm3, optiaddx
		punpckldq mm3, optiaddy ;mm3: optiaddy optiaddx
		pfadd mm0, mm3          ;mm0: diry diry

		movd mm6, plc
		movd mm7, incr
		mov ecx, zbufoff
		mov edx, j

beg:  pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm2, [eax+edx*8]   ;mm2:      dist       col
		pshufw mm3, mm2, 0xee   ;mm3:         ?      dist
		pi2fd mm3, mm3          ;mm3:         ?   (f)dist
		movq mm4, mm0           ;mm4:      diry      dirx
		pfmul mm4, mm4          ;mm4:    diry^2    dirx^2
		pfadd mm0, mm1          ;mm0: dirx+optx diry+opty (unrelated)
		pfacc mm4, mm4          ;mm4: (x^2+y^2)   x^2+y^2
		pfrsqrt mm4, mm4        ;mm4: 1/sqrt(*) 1/sqrt(*)
		pfmul mm3, mm4          ;mm3:         0    zvalue
		paddd mm6, mm7          ;mm6:            plc+incr (unrelated)
		movd [edi], mm2
		movd [edi+ecx], mm3
		add edi, 4
		cmp edi, esi
		jb short beg
		pop edi
		pop esi
	}
}

void hrendzfog3dn (long sx, long sy, long p1, long plc, long incr, long j)
{
	_asm
	{
		push esi
		push edi
		mov eax, sy
		mov eax, ylookup[eax*4]
		add eax, frameplace
		mov esi, p1
		lea esi, [eax+esi*4]    ;esi = p1
		mov edi, sx
		lea edi, [eax+edi*4]    ;edi = p0

		movd mm0, sx
		punpckldq mm0, sy
		pi2fd mm0, mm0          ;mm0: (float)sy (float)sx
		pshufw mm2, mm0, 0xee   ;mm2: (float)sy (float)sy
		punpckldq mm0, mm0      ;mm0: (float)sx (float)sx
		movd mm1, optistrx
		punpckldq mm1, optistry
		pfmul mm0, mm1          ;mm0: (float)sx*optistry (float)sx*optistrx
		movd mm3, optiheix
		punpckldq mm3, optiheiy
		pfmul mm2, mm3          ;mm2: (float)sy*optiheiy (float)sy*optiheix
		pfadd mm0, mm2
		movd mm3, optiaddx
		punpckldq mm3, optiaddy ;mm3: optiaddy optiaddx
		pfadd mm0, mm3          ;mm0: diry diry

		pxor mm5, mm5

		movd mm6, plc
		movd mm7, incr
		mov ecx, zbufoff
		mov edx, j

beg:  pextrw eax, mm6, 1
		mov eax, angstart[eax*4]
		movq mm2, [eax+edx*8]   ;mm2:      dist       col
		pshufw mm3, mm2, 0xee   ;mm3:         ?      dist
		pi2fd mm3, mm3          ;mm3:         ?   (f)dist
		movq mm4, mm0           ;mm4:      diry      dirx
		pfmul mm4, mm4          ;mm4:    diry^2    dirx^2
		pfadd mm0, mm1          ;mm0: dirx+optx diry+opty (unrelated)
		pfacc mm4, mm4          ;mm4: (x^2+y^2)   x^2+y^2
		pfrsqrt mm4, mm4        ;mm4: 1/sqrt(*) 1/sqrt(*)
		pfmul mm3, mm4          ;mm3:         0    zvalue
		paddd mm6, mm7          ;mm6:            plc+incr (unrelated)

			;Extra calculations for fog
		pextrw eax, mm2, 3
		punpcklbw mm2, mm5
		movq mm4, fogcol
		psubw mm4, mm2
		paddw mm4, mm4
		shr eax, 4
		pmulhw mm4, foglut[eax*8]
		paddw mm2, mm4
		packuswb mm2, mm4

		movd [edi], mm2
		movd [edi+ecx], mm3
		add edi, 4
		cmp edi, esi
		jb short beg
		pop edi
		pop esi
	}
}

void vrendzsse (long sx, long sy, long p1, long iplc, long iinc)
{
	_asm
	{
		push ebx
		push esi
		push edi
//begvasm_p3:
		mov esi, sx
		mov eax, sy
		mov edx, p1
		mov ecx, ylookup[eax*4]
		add ecx, frameplace
		lea edx, [ecx+edx*4]
		lea edi, [ecx+esi*4]

		mov ecx, esi
		and ecx, 0xfffffffc
		cvtsi2ss xmm0, ecx
		cvtsi2ss xmm4, eax
		movss xmm1, xmm0
		movss xmm5, xmm4
		mulss xmm0, optistrx
		mulss xmm1, optistry
		mulss xmm4, optiheix
		mulss xmm5, optiheiy
		addss xmm0, optiaddx
		addss xmm1, optiaddy
		addss xmm0, xmm4
		addss xmm1, xmm5

		shufps xmm0, xmm0, 0
		shufps xmm1, xmm1, 0
		movaps xmm2, opti4asm[2*16]
		movaps xmm3, opti4asm[3*16]
		addps xmm0, opti4asm[0*16]
		addps xmm1, opti4asm[1*16]
			;xmm0 =  xmm0      ^2 +  xmm1      ^2        (p)
			;xmm2 = (xmm0+xmm2)^2 + (xmm1+xmm3)^2 - xmm0 (v)
			;xmm1 = ...                                  (a)
		addps xmm2, xmm0  ;This block converts inner loop...
		addps xmm3, xmm1  ;from: 1 / sqrt(x*x + y*y), x += xi, y += yi;
		mulps xmm0, xmm0  ;  to: 1 / sqrt(p), p += v, v += a;
		mulps xmm1, xmm1
		mulps xmm2, xmm2
		mulps xmm3, xmm3
		addps xmm0, xmm1
		movaps xmm1, opti4asm[4*16]
		addps xmm2, xmm3
		subps xmm2, xmm0

		mov p1, edx
		mov ecx, zbufoff
		shl esi, 2
		add esi, uurend
		mov ebx, iplc

		cmp edi, edx
		jae short endv

			;Do first 0-3 pixels to align unrolled loop of 4
		test edi, 15
		jz short skip1va

		test edi, 8
		jz short skipshufc
		shufps xmm0, xmm0, 0x4e ;rotate right by 2
skipshufc:
		test edi, 4
		jz short skipshufd
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
skipshufd:

beg1va:
		mov edx, [esi]
		mov eax, [esi+MAXXDIM*4]
		add eax, edx
		sar edx, 16
		mov edx, angstart[edx*4]
		mov [esi], eax
		mov eax, [edx+ebx*8]
		mov [edi], eax
		cvtsi2ss xmm7, [edx+ebx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7
		add ebx, iinc
		add esi, 4
		add edi, 4
		cmp edi, p1
		jz short endv
		test edi, 15
		jnz short beg1va

		addps xmm0, xmm2
		addps xmm2, xmm1
skip1va:
		lea edx, [edi+16]
		cmp edx, p1
		ja short prebeg1v

		cmp iinc, 0
		jl short beg4vn

beg4vp:
		movq mm6, [esi]
		movq mm7, [esi+8]
		pextrw eax, mm6, 1
		pextrw edx, mm6, 3
		paddd mm6, [esi+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm0, [eax+ebx*8]
		movq mm1, [edx+ebx*8+8]
		pextrw eax, mm7, 1
		pextrw edx, mm7, 3
		paddd mm7, [esi+8+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm2, [eax+ebx*8+16]
		movq mm3, [edx+ebx*8+24]
		add ebx, 4

		movq mm4, mm0
		movq mm5, mm2
		punpckldq mm0, mm1
		punpckldq mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

		movq [esi], mm6
		movq [esi+8], mm7

		add esi, 16
		add edi, 16
		lea edx, [edi+16]
		cmp edx, p1
		jbe short beg4vp
		cmp edi, p1
		jae short endv
		jmp short prebeg1v

beg4vn:
		movq mm6, [esi]
		movq mm7, [esi+8]
		pextrw eax, mm6, 1
		pextrw edx, mm6, 3
		paddd mm6, [esi+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm0, [eax+ebx*8]
		movq mm1, [edx+ebx*8-8]
		pextrw eax, mm7, 1
		pextrw edx, mm7, 3
		paddd mm7, [esi+8+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm2, [eax+ebx*8-16]
		movq mm3, [edx+ebx*8-24]
		sub ebx, 4

		movq mm4, mm0
		movq mm5, mm2
		punpckldq mm0, mm1
		punpckldq mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

		movq [esi], mm6
		movq [esi+8], mm7

		add esi, 16
		add edi, 16
		lea edx, [edi+16]
		cmp edx, p1
		jbe short beg4vn
		cmp edi, p1
		jae short endv

prebeg1v:
beg1v:
		mov edx, [esi]
		mov eax, [esi+MAXXDIM*4]
		add eax, edx
		sar edx, 16
		mov edx, angstart[edx*4]
		mov [esi], eax
		mov eax, [edx+ebx*8]
		mov [edi], eax
		cvtsi2ss xmm7, [edx+ebx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7
		add ebx, iinc
		add esi, 4
		add edi, 4
		cmp edi, p1
		jne short beg1v
endv: pop edi
		pop esi
		pop ebx
	}
}

void vrendzfogsse (long sx, long sy, long p1, long iplc, long iinc)
{
	_asm
	{
		push ebx
		push esi
		push edi
//begvasm_p3:
		mov esi, sx
		mov eax, sy
		mov edx, p1
		mov ecx, ylookup[eax*4]
		add ecx, frameplace
		lea edx, [ecx+edx*4]
		lea edi, [ecx+esi*4]

		mov ecx, esi
		and ecx, 0xfffffffc
		cvtsi2ss xmm0, ecx
		cvtsi2ss xmm4, eax
		movss xmm1, xmm0
		movss xmm5, xmm4
		mulss xmm0, optistrx
		mulss xmm1, optistry
		mulss xmm4, optiheix
		mulss xmm5, optiheiy
		addss xmm0, optiaddx
		addss xmm1, optiaddy
		addss xmm0, xmm4
		addss xmm1, xmm5

		shufps xmm0, xmm0, 0
		shufps xmm1, xmm1, 0
		movaps xmm2, opti4asm[2*16]
		movaps xmm3, opti4asm[3*16]
		addps xmm0, opti4asm[0*16]
		addps xmm1, opti4asm[1*16]
			;xmm0 =  xmm0      ^2 +  xmm1      ^2        (p)
			;xmm2 = (xmm0+xmm2)^2 + (xmm1+xmm3)^2 - xmm0 (v)
			;xmm1 = ...                                  (a)
		addps xmm2, xmm0  ;This block converts inner loop...
		addps xmm3, xmm1  ;from: 1 / sqrt(x*x + y*y), x += xi, y += yi;
		mulps xmm0, xmm0  ;  to: 1 / sqrt(p), p += v, v += a;
		mulps xmm1, xmm1
		mulps xmm2, xmm2
		mulps xmm3, xmm3
		addps xmm0, xmm1
		movaps xmm1, opti4asm[4*16]
		addps xmm2, xmm3
		subps xmm2, xmm0

		mov p1, edx
		mov ecx, zbufoff
		shl esi, 2
		add esi, uurend
		mov ebx, iplc

		cmp edi, edx
		jae short endv

			;Do first 0-3 pixels to align unrolled loop of 4
		test edi, 15
		jz short skip1va

		test edi, 8
		jz short skipshufc
		shufps xmm0, xmm0, 0x4e ;rotate right by 2
skipshufc:
		test edi, 4
		jz short skipshufd
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
skipshufd:

beg1va:
		mov edx, [esi]
		mov eax, [esi+MAXXDIM*4]
		add eax, edx
		sar edx, 16
		mov edx, angstart[edx*4]
		mov [esi], eax

			;Z
		cvtsi2ss xmm7, [edx+ebx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7

			;Col
		punpcklbw mm0, [edx+ebx*8]
		psrlw mm0, 8
		movq mm1, fogcol
		psubw mm1, mm0
		paddw mm1, mm1
		mov eax, [edx+ebx*8+4]
		shr eax, 16+4
		pmulhw mm1, foglut[eax*8]
		paddw mm0, mm1
		packuswb mm0, mm1
		movd [edi], mm0

		add ebx, iinc
		add esi, 4
		add edi, 4
		cmp edi, p1
		jz short endv
		test edi, 15
		jnz short beg1va

		addps xmm0, xmm2
		addps xmm2, xmm1
skip1va:
		lea edx, [edi+16]
		cmp edx, p1
		ja short prebeg1v

		cmp iinc, 0
		jl short beg4vn

beg4vp:
		movq mm6, [esi]
		movq mm7, [esi+8]
		pextrw eax, mm6, 1
		pextrw edx, mm6, 3
		paddd mm6, [esi+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm4, [eax+ebx*8]
		movq mm1, [edx+ebx*8+8]
		pextrw eax, mm7, 1
		pextrw edx, mm7, 3
		paddd mm7, [esi+8+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm5, [eax+ebx*8+16]
		movq mm3, [edx+ebx*8+24]
		add ebx, 4

			;Do Z
		movq mm0, mm4
		movq mm2, mm5
		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

		movq [esi], mm6
		movq [esi+8], mm7

			;Do color
		pxor mm7, mm7
		punpcklbw mm0, mm7
		punpcklbw mm1, mm7
		punpcklbw mm2, mm7
		punpcklbw mm3, mm7

		movq mm7, fogcol
		psubw mm7, mm0
		paddw mm7, mm7
		pextrw eax, mm4, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm0, mm7

		movq mm7, fogcol
		psubw mm7, mm1
		paddw mm7, mm7
		pextrw eax, mm4, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm1, mm7

		movq mm7, fogcol
		psubw mm7, mm2
		paddw mm7, mm7
		pextrw eax, mm5, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm2, mm7

		movq mm7, fogcol
		psubw mm7, mm3
		paddw mm7, mm7
		pextrw eax, mm5, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm3, mm7

		packuswb mm0, mm1
		packuswb mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		add esi, 16
		add edi, 16
		lea edx, [edi+16]
		cmp edx, p1
		jbe short beg4vp
		cmp edi, p1
		jae short endv
		jmp short prebeg1v

beg4vn:
		movq mm6, [esi]
		movq mm7, [esi+8]
		pextrw eax, mm6, 1
		pextrw edx, mm6, 3
		paddd mm6, [esi+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm4, [eax+ebx*8]
		movq mm1, [edx+ebx*8-8]
		pextrw eax, mm7, 1
		pextrw edx, mm7, 3
		paddd mm7, [esi+8+MAXXDIM*4]
		mov eax, angstart[eax*4]
		mov edx, angstart[edx*4]
		movq mm5, [eax+ebx*8-16]
		movq mm3, [edx+ebx*8-24]
		sub ebx, 4

			;Do Z
		movq mm0, mm4
		movq mm2, mm5
		punpckhdq mm4, mm1
		punpckhdq mm5, mm3
		cvtpi2ps xmm7, mm4
		cvtpi2ps xmm4, mm5
		rsqrtps xmm3, xmm0
		movlhps xmm7, xmm4
		mulps xmm7, xmm3
		movntps [edi+ecx], xmm7
		addps xmm0, xmm2
		addps xmm2, xmm1

		movq [esi], mm6
		movq [esi+8], mm7

			;Do color
		pxor mm7, mm7
		punpcklbw mm0, mm7
		punpcklbw mm1, mm7
		punpcklbw mm2, mm7
		punpcklbw mm3, mm7

		movq mm7, fogcol
		psubw mm7, mm0
		paddw mm7, mm7
		pextrw eax, mm4, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm0, mm7

		movq mm7, fogcol
		psubw mm7, mm1
		paddw mm7, mm7
		pextrw eax, mm4, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm1, mm7

		movq mm7, fogcol
		psubw mm7, mm2
		paddw mm7, mm7
		pextrw eax, mm5, 1
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm2, mm7

		movq mm7, fogcol
		psubw mm7, mm3
		paddw mm7, mm7
		pextrw eax, mm5, 3
		shr eax, 4
		pmulhw mm7, foglut[eax*8]
		paddw mm3, mm7

		packuswb mm0, mm1
		packuswb mm2, mm3
		movntq [edi], mm0
		movntq [edi+8], mm2

		add esi, 16
		add edi, 16
		lea edx, [edi+16]
		cmp edx, p1
		jbe short beg4vn
		cmp edi, p1
		jae short endv

prebeg1v:
beg1v:
		mov edx, [esi]
		mov eax, [esi+MAXXDIM*4]
		add eax, edx
		sar edx, 16
		mov edx, angstart[edx*4]
		mov [esi], eax

			;Z
		cvtsi2ss xmm7, [edx+ebx*8+4]
		rsqrtss xmm3, xmm0
		mulss xmm7, xmm3
		shufps xmm0, xmm0, 0x39 ;rotate right by 1
		movss [edi+ecx], xmm7

			;Col
		punpcklbw mm0, [edx+ebx*8]
		psrlw mm0, 8
		movq mm1, fogcol
		psubw mm1, mm0
		paddw mm1, mm1
		mov eax, [edx+ebx*8+4]
		shr eax, 16+4
		pmulhw mm1, foglut[eax*8]
		paddw mm0, mm1
		packuswb mm0, mm1
		movd [edi], mm0

		add ebx, iinc
		add esi, 4
		add edi, 4
		cmp edi, p1
		jne short beg1v
endv: pop edi
		pop esi
		pop ebx
	}
}

void vrendz3dn (long sx, long sy, long p1, long iplc, long iinc)
{
	_asm
	{
		push ebx
		push esi
		push edi
		mov esi, p1
		mov edi, sx
		cmp edi, esi
		jae short endv
		mov eax, sy
		mov eax, ylookup[eax*4]
		add eax, frameplace
		lea esi, [eax+esi*4]    ;esi = p1
		lea edi, [eax+edi*4]    ;edi = p0

		movd mm0, sx
		punpckldq mm0, sy
		pi2fd mm0, mm0          ;mm0: (float)sy (float)sx
		pshufw mm2, mm0, 0xee   ;mm2: (float)sy (float)sy
		punpckldq mm0, mm0      ;mm0: (float)sx (float)sx
		movd mm1, optistrx
		punpckldq mm1, optistry
		pfmul mm0, mm1          ;mm0: (float)sx*optistry (float)sx*optistrx
		movd mm3, optiheix
		punpckldq mm3, optiheiy
		pfmul mm2, mm3          ;mm2: (float)sy*optiheiy (float)sy*optiheix
		pfadd mm0, mm2
		movd mm3, optiaddx
		punpckldq mm3, optiaddy ;mm3: optiaddy optiaddx
		pfadd mm0, mm3          ;mm0: diry diry

		mov ecx, zbufoff
		mov edx, iplc
		mov ebx, sx
		mov eax, uurend
		lea ebx, [eax+ebx*4]

begv_3dn:
		movd mm5, [ebx]
		pextrw eax, mm5, 1
		paddd mm5, [ebx+MAXXDIM*4]
		movd [ebx], mm5
		mov eax, angstart[eax*4]
		movq mm2, [eax+edx*8]   ;mm2:      dist       col
		pshufw mm3, mm2, 0xee   ;mm3:         ?      dist
		pi2fd mm3, mm3          ;mm3:         ?   (f)dist
		movq mm4, mm0           ;mm4:      diry      dirx
		pfmul mm4, mm4          ;mm4:    diry^2    dirx^2
		pfadd mm0, mm1          ;mm0: dirx+optx diry+opty (unrelated)
		pfacc mm4, mm4          ;mm4: (x^2+y^2)   x^2+y^2
		pfrsqrt mm4, mm4        ;mm4: 1/sqrt(*) 1/sqrt(*)
		pfmul mm3, mm4          ;mm3:         0    zvalue
		movd [edi], mm2
		movd [edi+ecx], mm3
		add edx, iinc
		add ebx, 4
		add edi, 4
		cmp edi, esi
		jb short begv_3dn
endv: pop edi
		pop esi
		pop ebx
	}
}

void vrendzfog3dn (long sx, long sy, long p1, long iplc, long iinc)
{
	_asm
	{
		push ebx
		push esi
		push edi
		mov esi, p1
		mov edi, sx
		cmp edi, esi
		jae short endv
		mov eax, sy
		mov eax, ylookup[eax*4]
		add eax, frameplace
		lea esi, [eax+esi*4]    ;esi = p1
		lea edi, [eax+edi*4]    ;edi = p0

		movd mm0, sx
		punpckldq mm0, sy
		pi2fd mm0, mm0          ;mm0: (float)sy (float)sx
		pshufw mm2, mm0, 0xee   ;mm2: (float)sy (float)sy
		punpckldq mm0, mm0      ;mm0: (float)sx (float)sx
		movd mm1, optistrx
		punpckldq mm1, optistry
		pfmul mm0, mm1          ;mm0: (float)sx*optistry (float)sx*optistrx
		movd mm3, optiheix
		punpckldq mm3, optiheiy
		pfmul mm2, mm3          ;mm2: (float)sy*optiheiy (float)sy*optiheix
		pfadd mm0, mm2
		movd mm3, optiaddx
		punpckldq mm3, optiaddy ;mm3: optiaddy optiaddx
		pfadd mm0, mm3          ;mm0: diry diry

		pxor mm6, mm6

		mov ecx, zbufoff
		mov edx, iplc
		mov ebx, sx
		mov eax, uurend
		lea ebx, [eax+ebx*4]

begv_3dn:
		movd mm5, [ebx]
		pextrw eax, mm5, 1
		paddd mm5, [ebx+MAXXDIM*4]
		movd [ebx], mm5
		mov eax, angstart[eax*4]
		movq mm2, [eax+edx*8]   ;mm2:      dist       col
		pshufw mm3, mm2, 0xee   ;mm3:         ?      dist
		pi2fd mm3, mm3          ;mm3:         ?   (f)dist
		movq mm4, mm0           ;mm4:      diry      dirx
		pfmul mm4, mm4          ;mm4:    diry^2    dirx^2
		pfadd mm0, mm1          ;mm0: dirx+optx diry+opty (unrelated)
		pfacc mm4, mm4          ;mm4: (x^2+y^2)   x^2+y^2
		pfrsqrt mm4, mm4        ;mm4: 1/sqrt(*) 1/sqrt(*)
		pfmul mm3, mm4          ;mm3:         0    zvalue

			;Extra calculations for fog
		pextrw eax, mm2, 3
		punpcklbw mm2, mm6
		movq mm4, fogcol
		psubw mm4, mm2
		paddw mm4, mm4
		shr eax, 4
		pmulhw mm4, foglut[eax*8]
		paddw mm2, mm4
		packuswb mm2, mm4

		movd [edi], mm2
		movd [edi+ecx], mm3
		add edx, iinc
		add ebx, 4
		add edi, 4
		cmp edi, esi
		jb short begv_3dn
endv: pop edi
		pop esi
		pop ebx
	}
}

#endif

void setcamera (dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo,
					 float dahx, float dahy, float dahz)
{
	long i, j;

	gipos.x = ipo->x; gipos.y = ipo->y; gipos.z = ipo->z;
	gistr.x = ist->x; gistr.y = ist->y; gistr.z = ist->z;
	gihei.x = ihe->x; gihei.y = ihe->y; gihei.z = ihe->z;
	gifor.x = ifo->x; gifor.y = ifo->y; gifor.z = ifo->z;
	gihx = dahx; gihy = dahy; gihz = dahz;

	gixs.x = gistr.x; gixs.y = gihei.x; gixs.z = gifor.x;
	giys.x = gistr.y; giys.y = gihei.y; giys.z = gifor.y;
	gizs.x = gistr.z; gizs.y = gihei.z; gizs.z = gifor.z;
	giadd.x = -(gipos.x*gistr.x + gipos.y*gistr.y + gipos.z*gistr.z);
	giadd.y = -(gipos.x*gihei.x + gipos.y*gihei.y + gipos.z*gihei.z);
	giadd.z = -(gipos.x*gifor.x + gipos.y*gifor.y + gipos.z*gifor.z);

	gcorn[0].x = -gihx*gistr.x - gihy*gihei.x + gihz*gifor.x;
	gcorn[0].y = -gihx*gistr.y - gihy*gihei.y + gihz*gifor.y;
	gcorn[0].z = -gihx*gistr.z - gihy*gihei.z + gihz*gifor.z;
	gcorn[1].x = xres*gistr.x+gcorn[0].x;
	gcorn[1].y = xres*gistr.y+gcorn[0].y;
	gcorn[1].z = xres*gistr.z+gcorn[0].z;
	gcorn[2].x = yres*gihei.x+gcorn[1].x;
	gcorn[2].y = yres*gihei.y+gcorn[1].y;
	gcorn[2].z = yres*gihei.z+gcorn[1].z;
	gcorn[3].x = yres*gihei.x+gcorn[0].x;
	gcorn[3].y = yres*gihei.y+gcorn[0].y;
	gcorn[3].z = yres*gihei.z+gcorn[0].z;
	for(j=0,i=3;j<4;i=j++)
	{
		ginor[i].x = gcorn[i].y*gcorn[j].z - gcorn[i].z*gcorn[j].y;
		ginor[i].y = gcorn[i].z*gcorn[j].x - gcorn[i].x*gcorn[j].z;
		ginor[i].z = gcorn[i].x*gcorn[j].y - gcorn[i].y*gcorn[j].x;
	}
}

void opticast ()
{
	float f, ff, cx, cy, fx, fy, gx, gy, x0, y0, x1, y1, x2, y2, x3, y3;
	long i, j, sx, sy, p0, p1, cx16, cy16, kadd, kmul, u, u1, ui;

	if (gifor.z < 0) giforzsgn = -1; else giforzsgn = 1; //giforzsgn = (gifor.z < 0);

	gixyi[0] = (VSID<<2); gixyi[1] = -gixyi[0];
	glipos.x = ((long)gipos.x);
	glipos.y = ((long)gipos.y);
	glipos.z = ((long)gipos.z);
	gpixy = (long)&sptr[glipos.y*VSID + glipos.x];
	ftol(gipos.z*PREC-.5f,&gposz);
	gposxfrac[1] = gipos.x - (float)glipos.x; gposxfrac[0] = 1-gposxfrac[1];
	gposyfrac[1] = gipos.y - (float)glipos.y; gposyfrac[0] = 1-gposyfrac[1];
#if USEV5ASM
	for(j=u=0;j<gmipnum;j++,u+=i)
		for(i=0;i<(256>>j)+4;i++)
			gylookup[i+u] = ((((gposz>>j)-i*PREC)>>(16-j))&0x0000ffff);
	gxmip = max(vx5.mipscandist,4)*PREC;
#else
	for(i=0;i<256+4;i++) gylookup[i] = (i*PREC-gposz);
#endif
	gmaxscandist = min(max(vx5.maxscandist,1),2047)*PREC;

#if (USEZBUFFER != 1)
	hrend = hrendnoz; vrend = vrendnoz;
#else
	if (ofogdist < 0)
	{
		if (cputype&(1<<25)) { hrend = hrendzsse; vrend = vrendzsse; }
							 else { hrend = hrendz3dn; vrend = vrendz3dn; }
	}
	else
	{
		if (cputype&(1<<25)) { hrend = hrendzfogsse; vrend = vrendzfogsse; }
							 else { hrend = hrendzfog3dn; vrend = vrendzfog3dn; }

	}
#endif
	if (ofogdist < 0) nskypic = skypic;
				  else { nskypic = skyoff = 0; } //Optimization hack: draw sky as pure black when using fog

	gstartv = (char *)*(long *)gpixy;
	if (glipos.z >= gstartv[1])
	{
		do
		{
			if (!gstartv[0]) return;
			gstartv += gstartv[0]*4;
		} while (glipos.z >= gstartv[1]);
		if (glipos.z < gstartv[3]) return;
		gstartz0 = gstartv[3];
	} else gstartz0 = 0;
	gstartz1 = gstartv[1];

	if (gifor.z == 0) f = 32000; else f = gihz/gifor.z;
	f = min(max(f,-32000),32000);
	cx = gistr.z*f + gihx;
	cy = gihei.z*f + gihy;

	wx0 = (float)(-(vx5.anginc)); wx1 = (float)(xres-1+(vx5.anginc));
	wy0 = (float)(-(vx5.anginc)); wy1 = (float)(yres-1+(vx5.anginc));
	ftol(wx0,&iwx0); ftol(wx1,&iwx1);
	ftol(wy0,&iwy0); ftol(wy1,&iwy1);

	fx = wx0-cx; fy = wy0-cy; gx = wx1-cx; gy = wy1-cy;
	x0 = x3 = wx0; y0 = y1 = wy0; x1 = x2 = wx1; y2 = y3 = wy1;
	if (fy < 0)
	{
		if (fx < 0) { f = sqrt(fx*fy); x0 = cx-f; y0 = cy-f; }
		if (gx > 0) { f = sqrt(-gx*fy); x1 = cx+f; y1 = cy-f; }
	}
	if (gy > 0)
	{
		if (gx > 0) { f = sqrt(gx*gy); x2 = cx+f; y2 = cy+f; }
		if (fx < 0) { f = sqrt(-fx*gy); x3 = cx-f; y3 = cy+f; }
	}
	if (x0 > x1) { if (fx < 0) y0 = fx/gx*fy + cy; else y1 = gx/fx*fy + cy; }
	if (y1 > y2) { if (fy < 0) x1 = fy/gy*gx + cx; else x2 = gy/fy*gx + cx; }
	if (x2 < x3) { if (fx < 0) y3 = fx/gx*gy + cy; else y2 = gx/fx*gy + cy; }
	if (y3 < y0) { if (fy < 0) x0 = fy/gy*fx + cx; else x3 = gy/fy*fx + cx; }
		//This makes precision errors cause pixels to overwrite rather than omit
	x0 -= .01; x1 += .01;
	y1 -= .01; y2 += .01;
	x3 -= .01; x2 += .01;
	y0 -= .01; y3 += .01;

	f = 1048576.0 / gihz;
	optistrx = gistr.x*f; optiheix = gihei.x*f; optiaddx = gcorn[0].x*f;
	optistry = gistr.y*f; optiheiy = gihei.y*f; optiaddy = gcorn[0].y*f;
#ifdef _MSC_VER
	opti4[0].y = optistrx; opti4[0].z = optistrx*2; opti4[0].z2 = optistrx*3;
	opti4[1].y = optistry; opti4[1].z = optistry*2; opti4[1].z2 = optistry*3;
	opti4[2].x = opti4[2].y = opti4[2].z = opti4[2].z2 = optistrx*4.0f;
	opti4[3].x = opti4[3].y = opti4[3].z = opti4[3].z2 = optistry*4.0f;
	opti4[4].x = opti4[4].y = opti4[4].z = opti4[4].z2 = (optistrx*optistrx + optistry*optistry)*32.0f; //NEW ALGO!
#endif

	ftol(cx*65536,&cx16);
	ftol(cy*65536,&cy16);

	ftol((x1-x0)/vx5.anginc,&j);
	if ((fy < 0) && (j > 0)) //(cx,cy),(x0,wy0),(x1,wy0)
	{
		ff = (x1-x0) / (float)j; grd = 1.0f / (wy0-cy);
		gscanptr = (castdat *)radar; skycurlng = -1; skycurdir = -giforzsgn;
		for(i=0,f=x0+ff*.5f;i<j;f+=ff,i++)
		{
			vline(cx,cy,f,wy0,&p0,&p1);
			if (giforzsgn < 0) angstart[i] = gscanptr+p0; else angstart[i] = gscanptr-p1;
			gscanptr += labs(p1-p0)+1;
		}

		j <<= 16; f = (float)j / ((x1-x0)*grd); ftol((cx-x0)*grd*f,&kadd);
		ftol(cx-.5f,&p1); p0 = lbound0(p1+1,xres); p1 = lbound0(p1,xres);
		ftol(cy-0.50005f,&sy); if (sy >= yres) sy = yres-1;
		ff = (fabs((float)p1-cx)+1)*f/2147483647.0 + cy; //Anti-crash hack
		while ((ff < sy) && (sy >= 0)) sy--;
		if (sy >= 0)
		{
			ftol(f,&kmul);
			for(;sy>=0;sy--) if (isshldiv16safe(kmul,(sy<<16)-cy16)) break; //Anti-crash hack
			if (giforzsgn < 0) i = -sy; else i = sy;
			for(;sy>=0;sy--,i-=giforzsgn)
			{
				ui = shldiv16(kmul,(sy<<16)-cy16);
				u = mulshr16((p0<<16)-cx16,ui)+kadd;
				while ((p0 > 0) && (u >= ui)) { u -= ui; p0--; }
				u1 = (p1-p0)*ui + u;
				while ((p1 < xres) && (u1 < j)) { u1 += ui; p1++; }
				if (p0 < p1) hrend(p0,sy,p1,u,ui,i);
			}
			_asm emms
		}
	}

	ftol((y2-y1)/vx5.anginc,&j);
	if ((gx > 0) && (j > 0)) //(cx,cy),(wx1,y1),(wx1,y2)
	{
		ff = (y2-y1) / (float)j; grd = 1.0f / (wx1-cx);
		gscanptr = (castdat *)radar; skycurlng = -1; skycurdir = -giforzsgn;
		for(i=0,f=y1+ff*.5f;i<j;f+=ff,i++)
		{
			hline(cx,cy,wx1,f,&p0,&p1);
			if (giforzsgn < 0) angstart[i] = gscanptr-p0; else angstart[i] = gscanptr+p1;
			gscanptr += labs(p1-p0)+1;
		}

		j <<= 16; f = (float)j / ((y2-y1)*grd); ftol((cy-y1)*grd*f,&kadd);
		ftol(cy-.5f,&p1); p0 = lbound0(p1+1,yres); p1 = lbound0(p1,yres);
		ftol(cx+0.50005f,&sx); if (sx < 0) sx = 0;
		ff = (fabs((float)p1-cy)+1)*f/2147483647.0 + cx; //Anti-crash hack
		while ((ff > sx) && (sx < xres)) sx++;
		if (sx < xres)
		{
			ftol(f,&kmul);
			for(;sx<xres;sx++) if (isshldiv16safe(kmul,(sx<<16)-cx16)) break; //Anti-crash hack
			for(;sx<xres;sx++)
			{
				ui = shldiv16(kmul,(sx<<16)-cx16);
				u = mulshr16((p0<<16)-cy16,ui)+kadd;
				while ((p0 > 0) && (u >= ui)) { u -= ui; lastx[--p0] = sx; }
				uurend[sx] = u; uurend[sx+MAXXDIM] = ui; u += (p1-p0)*ui;
				while ((p1 < yres) && (u < j)) { u += ui; lastx[p1++] = sx; }
			}
			if (giforzsgn < 0)
				  { for(sy=p0;sy<p1;sy++) vrend(lastx[sy],sy,xres,lastx[sy],1); }
			else { for(sy=p0;sy<p1;sy++) vrend(lastx[sy],sy,xres,-lastx[sy],-1); }
			_asm emms
		}
	}

	ftol((x2-x3)/vx5.anginc,&j);
	if ((gy > 0) && (j > 0)) //(cx,cy),(x2,wy1),(x3,wy1)
	{
		ff = (x2-x3) / (float)j; grd = 1.0f / (wy1-cy);
		gscanptr = (castdat *)radar; skycurlng = -1; skycurdir = giforzsgn;
		for(i=0,f=x3+ff*.5f;i<j;f+=ff,i++)
		{
			vline(cx,cy,f,wy1,&p0,&p1);
			if (giforzsgn < 0) angstart[i] = gscanptr-p0; else angstart[i] = gscanptr+p1;
			gscanptr += labs(p1-p0)+1;
		}

		j <<= 16; f = (float)j / ((x2-x3)*grd); ftol((cx-x3)*grd*f,&kadd);
		ftol(cx-.5f,&p1); p0 = lbound0(p1+1,xres); p1 = lbound0(p1,xres);
		ftol(cy+0.50005f,&sy); if (sy < 0) sy = 0;
		ff = (fabs((float)p1-cx)+1)*f/2147483647.0 + cy; //Anti-crash hack
		while ((ff > sy) && (sy < yres)) sy++;
		if (sy < yres)
		{
			ftol(f,&kmul);
			for(;sy<yres;sy++) if (isshldiv16safe(kmul,(sy<<16)-cy16)) break; //Anti-crash hack
			if (giforzsgn < 0) i = sy; else i = -sy;
			for(;sy<yres;sy++,i-=giforzsgn)
			{
				ui = shldiv16(kmul,(sy<<16)-cy16);
				u = mulshr16((p0<<16)-cx16,ui)+kadd;
				while ((p0 > 0) && (u >= ui)) { u -= ui; p0--; }
				u1 = (p1-p0)*ui + u;
				while ((p1 < xres) && (u1 < j)) { u1 += ui; p1++; }
				if (p0 < p1) hrend(p0,sy,p1,u,ui,i);
			}
			_asm emms
		}
	}

	ftol((y3-y0)/vx5.anginc,&j);
	if ((fx < 0) && (j > 0)) //(cx,cy),(wx0,y3),(wx0,y0)
	{
		ff = (y3-y0) / (float)j; grd = 1.0f / (wx0-cx);
		gscanptr = (castdat *)radar; skycurlng = -1; skycurdir = giforzsgn;
		for(i=0,f=y0+ff*.5f;i<j;f+=ff,i++)
		{
			hline(cx,cy,wx0,f,&p0,&p1);
			if (giforzsgn < 0) angstart[i] = gscanptr+p0; else angstart[i] = gscanptr-p1;
			gscanptr += labs(p1-p0)+1;
		}

		j <<= 16; f = (float)j / ((y3-y0)*grd); ftol((cy-y0)*grd*f,&kadd);
		ftol(cy-.5f,&p1); p0 = lbound0(p1+1,yres); p1 = lbound0(p1,yres);
		ftol(cx-0.50005f,&sx); if (sx >= xres) sx = xres-1;
		ff = (fabs((float)p1-cy)+1)*f/2147483647.0 + cx; //Anti-crash hack
		while ((ff < sx) && (sx >= 0)) sx--;
		if (sx >= 0)
		{
			ftol(f,&kmul);
			for(;sx>=0;sx--) if (isshldiv16safe(kmul,(sx<<16)-cx16)) break; //Anti-crash hack
			for(;sx>=0;sx--)
			{
				ui = shldiv16(kmul,(sx<<16)-cx16);
				u = mulshr16((p0<<16)-cy16,ui)+kadd;
				while ((p0 > 0) && (u >= ui)) { u -= ui; lastx[--p0] = sx; }
				uurend[sx] = u; uurend[sx+MAXXDIM] = ui; u += (p1-p0)*ui;
				while ((p1 < yres) && (u < j)) { u += ui; lastx[p1++] = sx; }
			}
			for(sy=p0;sy<p1;sy++) vrend(0,sy,lastx[sy]+1,0,giforzsgn);
			_asm emms
		}
	}
}

	//0: asm temp for current x
	//1: asm temp for current y
	//2: bottom (28)
	//3: top    ( 0)
	//4: left   ( 8)
	//5: right  (24)
	//6: up     (12)
	//7: down   (12)
	//setsideshades(0,0,0,0,0,0);
	//setsideshades(0,28,8,24,12,12);
void setsideshades (char sto, char sbo, char sle, char sri, char sup, char sdo)
{
	((char *)&gcsub[2])[7] = sbo; ((char *)&gcsub[3])[7] = sto;
	((char *)&gcsub[4])[7] = sle; ((char *)&gcsub[5])[7] = sri;
	((char *)&gcsub[6])[7] = sup; ((char *)&gcsub[7])[7] = sdo;
	if (!(sto|sbo|sle|sri|sup|sdo))
	{
		vx5.sideshademode = 0;
		((char *)&gcsub[0])[7] = ((char *)&gcsub[1])[7] = 0x00;
	}
	else vx5.sideshademode = 1;
}

	//MUST have more than: CEILING(max possible CLIPRADIUS) * 4 entries!
#define MAXCLIPIT (VSID*4) //VSID*2+4 is not a power of 2!
static lpoint2d clipit[MAXCLIPIT];

double findmaxcr (double px, double py, double pz, double cr)
{
	double f, g, maxcr, thresh2;
	long x, y, z, i0, i1, ix, y0, y1, z0, z1;
	char *v;

	thresh2 = cr+1.7321+1; thresh2 *= thresh2;
	maxcr = cr*cr;

		//Find closest point of all nearby cubes to (px,py,pz)
	x = (long)px; y = (long)py; z = (long)pz; i0 = i1 = 0; ix = x; y0 = y1 = y;
	while (1)
	{
		f = max(fabs((double)x+.5-px)-.5,0);
		g = max(fabs((double)y+.5-py)-.5,0);
		f = f*f + g*g;
		if (f < maxcr)
		{
			if (((unsigned long)x >= VSID) || ((unsigned long)y >= VSID))
				{ z0 = z1 = 0; }
			else
			{
				v = sptr[y*VSID+x];
				if (z >= v[1])
				{
					while (1)
					{
						if (!v[0]) { z0 = z1 = 0; break; }
						v += v[0]*4;
						if (z < v[1]) { z0 = v[3]; z1 = v[1]; break; }
					}
				}
				else { z0 = MAXZDIM-2048; z1 = v[1]; }
			}

			if ((pz <= z0) || (pz >= z1))
				maxcr = f;
			else
			{
				g = min(pz-(double)z0,(double)z1-pz);
				f += g*g; if (f < maxcr) maxcr = f;
			}
		}

		if ((x-px)*(x-px)+(y-py)*(y-py) < thresh2)
		{
			if ((x <= ix) && (x > 0))
				{ clipit[i1].x = x-1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
			if ((x >= ix) && (x < VSID-1))
				{ clipit[i1].x = x+1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
			if ((y <= y0) && (y > 0))
				{ clipit[i1].x = x; clipit[i1].y = y-1; i1 = ((i1+1)&(MAXCLIPIT-1)); y0--; }
			if ((y >= y1) && (y < VSID-1))
				{ clipit[i1].x = x; clipit[i1].y = y+1; i1 = ((i1+1)&(MAXCLIPIT-1)); y1++; }
		}
		if (i0 == i1) break;
		x = clipit[i0].x; y = clipit[i0].y; i0 = ((i0+1)&(MAXCLIPIT-1));
	}
	return(sqrt(maxcr));
}

#if 0

	//Point: (x,y), line segment: (px,py)-(px+vx,py+vy)
	//Returns 1 if point is closer than sqrt(cr2) to line
long dist2linept2d (double x, double y, double px, double py, double vx, double vy, double cr2)
{
	double f, g;
	x -= px; y -= py; f = x*vx + y*vy; if (f <= 0) return(x*x + y*y <= cr2);
	g = vx*vx + vy*vy; if (f >= g) { x -= vx; y -= vy; return(x*x + y*y <= cr2); }
	x = x*g-vx*f; y = y*g-vy*f; return(x*x + y*y <= cr2*g*g);
}

static char clipbuf[MAXZDIM+16]; //(8 extra on each side)
long sphtraceo (double px, double py, double pz,    //start pt
					double vx, double vy, double vz,    //move vector
					double *nx, double *ny, double *nz, //new pt after collision
					double *fx, double *fy, double *fz, //pt that caused collision
					double cr, double acr)
{
	double t, u, ex, ey, ez, Za, Zb, Zc, thresh2;
	double vxyz, vyz, vxz, vxy, rvxyz, rvyz, rvxz, rvxy, rvx, rvy, rvz, cr2;
	long i, i0, i1, x, y, z, xx, yy, zz, v, vv, ix, y0, y1, z0, z1;
	char *vp;

	t = 1;
	(*nx) = px + vx;
	(*ny) = py + vy;
	(*nz) = pz + vz;

	z0 = max((long)(min(pz,*nz)-cr)-2,-1);
	z1 = min((long)(max(pz,*nz)+cr)+2,MAXZDIM);

	thresh2 = cr+1.7321+1; thresh2 *= thresh2;

	vyz = vz*vz; vxz = vx*vx; vxy = vy*vy; cr2 = cr*cr;
	vyz += vxy; vxy += vxz; vxyz = vyz + vxz; vxz += vz*vz;
	rvx = 1.0 / vx; rvy = 1.0 / vy; rvz = 1.0 / vz;
	rvyz = 1.0 / vyz; rvxz = 1.0 / vxz; rvxy = 1.0 / vxy;
	rvxyz = 1.0 / vxyz;

		//Algorithm fails (stops short) if cr < 2 :(
	i0 = i1 = 0; ix = x = (long)px; y = y0 = y1 = (long)py;
	while (1)
	{
		for(z=z0;z<=z1;z++) clipbuf[z+8] = 0;
		i = 16;
		for(yy=y;yy<y+2;yy++)
			for(xx=x;xx<x+2;xx++,i<<=1)
			{
				z = z0;
				if ((unsigned long)(xx|yy) < VSID)
				{
					vp = sptr[yy*VSID+xx];
					while (1)
					{
						if (vp[1] > z) z = vp[1];
						if (!vp[0]) break;
						vp += vp[0]*4;
						zz = vp[3]; if (zz > z1) zz = z1;
						while (z < zz) clipbuf[(z++)+8] |= i;
					}
				}
				while (z <= z1) clipbuf[(z++)+8] |= i;
			}

		xx = x+1; yy = y+1; v = clipbuf[z0+8];
		for(z=z0;z<z1;z++)
		{
			zz = z+1; v = (v>>4)|clipbuf[zz+8];
			if ((!v) || (v == 255)) continue;

//---------------Check 1(8) corners of cube (sphere intersection)-------------

			//if (((v-1)^v) >= v)  //True if v is: {1,2,4,8,16,32,64,128}
			if (!(v&(v-1)))      //Same as above, but {0,1,2,4,...} (v's never 0)
			{
				ex = xx-px; ey = yy-py; ez = zz-pz;
				Zb = ex*vx + ey*vy + ez*vz;
				Zc = ex*ex + ey*ey + ez*ez - cr2;
				u = Zb*Zb - vxyz*Zc;
				if ((((long *)&u)[1] | ((long *)&Zb)[1]) >= 0)
				//if ((u >= 0) && (Zb >= 0))
				{
						//   //Proposed compare optimization:
						//f = Zb*Zb-u; g = vxyz*t; h = (Zb*2-g)*g;
						//if ((unsigned __int64 *)&f < (unsigned __int64 *)&h)
					u = (Zb - sqrt(u)) * rvxyz;
					if ((u >= 0) && (u < t))
					{
						*fx = xx; *fy = yy; *fz = zz; t = u;
						*nx = vx*u + px; *ny = vy*u + py; *nz = vz*u + pz;
					}
				}
			}

//---------------Check 3(12) edges of cube (cylinder intersection)-----------

			vv = v&0x55; if (((vv-1)^vv) >= vv)  //True if (v&0x55)={1,4,16,64}
			{
				ey = yy-py; ez = zz-pz;
				Zb = ey*vy + ez*vz;
				Zc = ey*ey + ez*ez - cr2;
				u = Zb*Zb - vyz*Zc;
				if ((((long *)&u)[1] | ((long *)&Zb)[1]) >= 0)
				//if ((u >= 0) && (Zb >= 0))
				{
					u = (Zb - sqrt(u)) * rvyz;
					if ((u >= 0) && (u < t))
					{
						ex = vx*u + px;
						if ((ex >= x) && (ex <= xx))
						{
							*fx = ex; *fy = yy; *fz = zz; t = u;
							*nx = ex; *ny = vy*u + py; *nz = vz*u + pz;
						}
					}
				}
			}
			vv = v&0x33; if (((vv-1)^vv) >= vv) //True if (v&0x33)={1,2,16,32}
			{
				ex = xx-px; ez = zz-pz;
				Zb = ex*vx + ez*vz;
				Zc = ex*ex + ez*ez - cr2;
				u = Zb*Zb - vxz*Zc;
				if ((((long *)&u)[1] | ((long *)&Zb)[1]) >= 0)
				//if ((u >= 0) && (Zb >= 0))
				{
					u = (Zb - sqrt(u)) * rvxz;
					if ((u >= 0) && (u < t))
					{
						ey = vy*u + py;
						if ((ey >= y) && (ey <= yy))
						{
							*fx = xx; *fy = ey; *fz = zz; t = u;
							*nx = vx*u + px; *ny = ey; *nz = vz*u + pz;
						}
					}
				}
			}
			vv = v&0x0f; if (((vv-1)^vv) >= vv) //True if (v&0x0f)={1,2,4,8}
			{
				ex = xx-px; ey = yy-py;
				Zb = ex*vx + ey*vy;
				Zc = ex*ex + ey*ey - cr2;
				u = Zb*Zb - vxy*Zc;
				if ((((long *)&u)[1] | ((long *)&Zb)[1]) >= 0)
				//if ((u >= 0) && (Zb >= 0))
				{
					u = (Zb - sqrt(u)) * rvxy;
					if ((u >= 0) && (u < t))
					{
						ez = vz*u + pz;
						if ((ez >= z) && (ez <= zz))
						{
							*fx = xx; *fy = yy; *fz = ez; t = u;
							*nx = vx*u + px; *ny = vy*u + py; *nz = ez;
						}
					}
				}
			}

//---------------Check 3(6) faces of cube (plane intersection)---------------

			if (vx)
			{
				switch(v&0x03)
				{
					case 0x01: ex = xx+cr; if ((vx > 0) || (px < ex)) goto skipfacex; break;
					case 0x02: ex = xx-cr; if ((vx < 0) || (px > ex)) goto skipfacex; break;
					default: goto skipfacex;
				}
				u = (ex - px) * rvx;
				if ((u >= 0) && (u < t))
				{
					ey = vy*u + py;
					ez = vz*u + pz;
					if ((ey >= y) && (ey <= yy) && (ez >= z) && (ez <= zz))
					{
						*fx = xx; *fy = ey; *fz = ez; t = u;
						*nx = ex; *ny = ey; *nz = ez;
					}
				}
			}
skipfacex:;
			if (vy)
			{
				switch(v&0x05)
				{
					case 0x01: ey = yy+cr; if ((vy > 0) || (py < ey)) goto skipfacey; break;
					case 0x04: ey = yy-cr; if ((vy < 0) || (py > ey)) goto skipfacey; break;
					default: goto skipfacey;
				}
				u = (ey - py) * rvy;
				if ((u >= 0) && (u < t))
				{
					ex = vx*u + px;
					ez = vz*u + pz;
					if ((ex >= x) && (ex <= xx) && (ez >= z) && (ez <= zz))
					{
						*fx = ex; *fy = yy; *fz = ez; t = u;
						*nx = ex; *ny = ey; *nz = ez;
					}
				}
			}
skipfacey:;
			if (vz)
			{
				switch(v&0x11)
				{
					case 0x01: ez = zz+cr; if ((vz > 0) || (pz < ez)) goto skipfacez; break;
					case 0x10: ez = zz-cr; if ((vz < 0) || (pz > ez)) goto skipfacez; break;
					default: goto skipfacez;
				}
				u = (ez - pz) * rvz;
				if ((u >= 0) && (u < t))
				{
					ex = vx*u + px;
					ey = vy*u + py;
					if ((ex >= x) && (ex <= xx) && (ey >= y) && (ey <= yy))
					{
						*fx = ex; *fy = ey; *fz = zz; t = u;
						*nx = ex; *ny = ey; *nz = ez;
					}
				}
			}
skipfacez:;
		}

		if ((x <= ix) && (x > 0) && (dist2linept2d(x-1,y,px,py,vx,vy,thresh2)))
			{ clipit[i1].x = x-1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
		if ((x >= ix) && (x < VSID-1) && (dist2linept2d(x+1,y,px,py,vx,vy,thresh2)))
			{ clipit[i1].x = x+1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
		if ((y <= y0) && (y > 0) && (dist2linept2d(x,y-1,px,py,vx,vy,thresh2)))
			{ clipit[i1].x = x; clipit[i1].y = y-1; i1 = ((i1+1)&(MAXCLIPIT-1)); y0--; }
		if ((y >= y1) && (y < VSID-1) && (dist2linept2d(x,y+1,px,py,vx,vy,thresh2)))
			{ clipit[i1].x = x; clipit[i1].y = y+1; i1 = ((i1+1)&(MAXCLIPIT-1)); y1++; }
		if (i0 == i1) break;
		x = clipit[i0].x; y = clipit[i0].y; i0 = ((i0+1)&(MAXCLIPIT-1));
	}

	if ((*nx) < acr) (*nx) = acr;
	if ((*ny) < acr) (*ny) = acr;
	if ((*nx) > VSID-acr) (*nx) = VSID-acr;
	if ((*ny) > VSID-acr) (*ny) = VSID-acr;
	if ((*nz) > MAXZDIM-1-acr) (*nz) = MAXZDIM-1-acr;
	if ((*nz) < MAXZDIM-2048) (*nz) = MAXZDIM-2048;

	return (t == 1);
}

#endif

static double gx0, gy0, gcrf2, grdst, gendt, gux, guy;
static long gdist2square (double x, double y)
{
	double t;
	x -= gx0; y -= gy0; t = x*gux + y*guy; if (t <= 0) t = gcrf2;
	else if (t*grdst >= gendt) { x -= gux*gendt; y -= guy*gendt; t = gcrf2; }
	else t = t*t*grdst + gcrf2;
	return(x*x + y*y <= t);
}

long sphtrace (double x0, double y0, double z0,          //start pt
					double vx, double vy, double vz,          //move vector
					double *hitx, double *hity, double *hitz, //new pt after collision
					double *clpx, double *clpy, double *clpz, //pt causing collision
					double cr, double acr)
{
	double f, t, dax, day, daz, vyx, vxy, vxz, vyz, rvz, cr2, fz, fc;
	double dx, dy, dx1, dy1;
	double nx, ny, intx, inty, intz, dxy, dxz, dyz, dxyz, rxy, rxz, ryz, rxyz;
	long i, j, x, y, ix, iy0, iy1, i0, i1, iz[2], cz0, cz1;
	char *v;

		 //Precalculate global constants for ins & getval functions
	if ((vx == 0) && (vy == 0) && (vz == 0))
		{ (*hitx) = x0; (*hity) = y0; (*hitz) = z0; return(1); }
	gux = vx; guy = vy; gx0 = x0; gy0 = y0; dxy = vx*vx + vy*vy;
	if (dxy != 0) rxy = 1.0 / dxy; else rxy = 0;
	grdst = rxy; gendt = 1; cr2 = cr*cr; t = cr + 0.7072; gcrf2 = t*t;

	if (((long *)&vz)[1] >= 0) { dtol(   z0-cr-.5,&cz0); dtol(vz+z0+cr-.5,&cz1); }
								 else { dtol(vz+z0-cr-.5,&cz0); dtol(   z0+cr-.5,&cz1); }

		//Precalculate stuff for closest point on cube finder
	dax = 0; day = 0; vyx = 0; vxy = 0; rvz = 0; vxz = 0; vyz = 0;
	if (vx != 0) { vyx = vy/vx; if (((long *)&vx)[1] >= 0) dax = x0+cr; else dax = x0-cr-1; }
	if (vy != 0) { vxy = vx/vy; if (((long *)&vy)[1] >= 0) day = y0+cr; else day = y0-cr-1; }
	if (vz != 0)
	{
		rvz = 1.0/vz; vxz = vx*rvz; vyz = vy*rvz;
		if (((long *)&vz)[1] >= 0) daz = z0+cr; else daz = z0-cr;
	}

	dxyz = vz*vz;
	dxz = vx*vx+dxyz; if (dxz != 0) rxz = 1.0 / dxz;
	dyz = vy*vy+dxyz; if (dyz != 0) ryz = 1.0 / dyz;
	dxyz += dxy; rxyz = 1.0 / dxyz;

	dtol(x0-.5,&x); dtol(y0-.5,&y);
	ix = x; iy0 = iy1 = y;
	i0 = 0; clipit[0].x = x; clipit[0].y = y; i1 = 1;
	do
	{
		x = clipit[i0].x; y = clipit[i0].y; i0 = ((i0+1)&(MAXCLIPIT-1));

		dx = (double)x; dx1 = (double)(x+1);
		dy = (double)y; dy1 = (double)(y+1);

			//closest point on cube finder
			//Plane intersection (both vertical planes)
#if 0
		intx = dbound((dy-day)*vxy + x0,dx,dx1);
		inty = dbound((dx-dax)*vyx + y0,dy,dy1);
#else
		intx = (dy-day)*vxy + x0;
		inty = (dx-dax)*vyx + y0;
		if (((long *)&intx)[1] < ((long *)&dx)[1]) intx = dx;
		if (((long *)&inty)[1] < ((long *)&dy)[1]) inty = dy;
		if (((long *)&intx)[1] >= ((long *)&dx1)[1]) intx = dx1;
		if (((long *)&inty)[1] >= ((long *)&dy1)[1]) inty = dy1;
		//if (intx < (double)x) intx = (double)x;
		//if (inty < (double)y) inty = (double)y;
		//if (intx > (double)(x+1)) intx = (double)(x+1);
		//if (inty > (double)(y+1)) inty = (double)(y+1);
#endif

		do
		{
			if (((long *)&dxy)[1] == 0) { t = -1.0; continue; }
			nx = intx-x0; ny = inty-y0; t = vx*nx + vy*ny; if (((long *)&t)[1] < 0) continue;
			f = cr2 - nx*nx - ny*ny; if (((long *)&f)[1] >= 0) { t = -1.0; continue; }
			f = f*dxy + t*t; if (((long *)&f)[1] < 0) { t = -1.0; continue; }
			t = (t-sqrt(f))*rxy;
		} while (0);
		if (t >= gendt) goto sphtracecont;
		if (((long *)&t)[1] < 0) intz = z0; else intz = vz*t + z0;

			//Find closest ceil(iz[0]) & flor(iz[1]) in (x,y) column
		dtol(intz-.5,&i);
		if ((unsigned long)(x|y) < VSID)
		{
			v = sptr[y*VSID+x]; iz[0] = MAXZDIM-2048; iz[1] = v[1];
			while (i >= iz[1])
			{
				if (!v[0]) { iz[1] = -1; break; }
				v += v[0]*4;
				iz[0] = v[3]; if (i < iz[0]) { iz[1] = -1; break; }
				iz[1] = v[1];
			}
		}
		else iz[1] = -1;

			//hit xz plane, yz plane or z-axis edge?
		if (iz[1] < 0) //Treat whole column as solid
		{
			if (((long *)&t)[1] >= 0) { gendt = t; (*clpx) = intx; (*clpy) = inty; (*clpz) = intz; goto sphtracecont; }
		}

			//Must check tops & bottoms of slab
		for(i=1;i>=0;i--)
		{
				//Ceil/flor outside of quick&dirty bounding box
			if ((iz[i] < cz0) || (iz[i] > cz1)) continue;

				//Plane intersection (parallel to ground)
			intz = (double)iz[i]; t = intz-daz;
			intx = t*vxz + x0;
			inty = t*vyz + y0;

			j = 0;                         // A ³ 8 ³ 9
			//     if (intx < dx)  j |= 2; //ÄÄÄÅÄÄÄÅÄÄÄ
			//else if (intx > dx1) j |= 1; // 2 ³ 0 ³ 1
			//     if (inty < dy)  j |= 8; //ÄÄÄÅÄÄÄÅÄÄÄ
			//else if (inty > dy1) j |= 4; // 6 ³ 4 ³ 5
				  if (((long *)&intx)[1] <  ((long *)&dx)[1])  j |= 2;
			else if (((long *)&intx)[1] >= ((long *)&dx1)[1]) j |= 1;
				  if (((long *)&inty)[1] <  ((long *)&dy)[1])  j |= 8;
			else if (((long *)&inty)[1] >= ((long *)&dy1)[1]) j |= 4;

				//NOTE: only need to check once per "for"!
			if ((!j) && (vz != 0)) //hit xy plane?
			{
				t *= rvz;
				if ((((long *)&t)[1] >= 0) && (t < gendt)) { gendt = t; (*clpx) = intx; (*clpy) = inty; (*clpz) = intz; }
				continue;
			}

				//common calculations used for rest of checks...
			fz = intz-z0; fc = cr2-fz*fz; fz *= vz;

			if (j&3)
			{
				nx = (double)((j&1)+x);
				if (((long *)&dxz)[1] != 0) //hit y-axis edge?
				{
					f = nx-x0; t = vx*f + fz; f = (fc - f*f)*dxz + t*t;
					if (((long *)&f)[1] >= 0) t = (t-sqrt(f))*rxz; else t = -1.0;
				} else t = -1.0;
				ny = vy*t + y0;
					  if (((long *)&ny)[1] > ((long *)&dy1)[1]) j |= 0x10;
				else if (((long *)&ny)[1] >= ((long *)&dy)[1])
				{
					if ((((long *)&t)[1] >= 0) && (t < gendt)) { gendt = t; (*clpx) = nx; (*clpy) = ny; (*clpz) = intz; }
					continue;
				}
				inty = (double)(((j>>4)&1)+y);
			}
			else inty = (double)(((j>>2)&1)+y);

			if (j&12)
			{
				ny = (double)(((j>>2)&1)+y);
				if (((long *)&dyz)[1] != 0) //hit x-axis edge?
				{
					f = ny-y0; t = vy*f + fz; f = (fc - f*f)*dyz + t*t;
					if (((long *)&f)[1] >= 0) t = (t-sqrt(f))*ryz; else t = -1.0;
				} else t = -1.0;
				nx = vx*t + x0;
					  if (((long *)&nx)[1] > ((long *)&dx1)[1]) j |= 0x20;
				else if (((long *)&nx)[1] >= ((long *)&dx)[1])
				{
					if ((((long *)&t)[1] >= 0) && (t < gendt)) { gendt = t; (*clpx) = nx; (*clpy) = ny; (*clpz) = intz; }
					continue;
				}
				intx = (double)(((j>>5)&1)+x);
			}
			else intx = (double)((j&1)+x);

				//hit corner?
			nx = intx-x0; ny = inty-y0;
			t = vx*nx + vy*ny + fz; if (((long *)&t)[1] < 0) continue;
			f = fc - nx*nx - ny*ny; if (((long *)&f)[1] >= 0) continue;
			f = f*dxyz + t*t; if (((long *)&f)[1] < 0) continue;
			t = (t-sqrt(f))*rxyz;
			if (t < gendt) { gendt = t; (*clpx) = intx; (*clpy) = inty; (*clpz) = intz; }
		}
sphtracecont:;
		if ((x <= ix)  && (x >      0) && (gdist2square(dx- .5,dy+ .5))) { clipit[i1].x = x-1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
		if ((x >= ix)  && (x < VSID-1) && (gdist2square(dx+1.5,dy+ .5))) { clipit[i1].x = x+1; clipit[i1].y = y; i1 = ((i1+1)&(MAXCLIPIT-1)); }
		if ((y <= iy0) && (y >      0) && (gdist2square(dx+ .5,dy- .5))) { clipit[i1].x = x; clipit[i1].y = y-1; i1 = ((i1+1)&(MAXCLIPIT-1)); iy0 = y-1; }
		if ((y >= iy1) && (y < VSID-1) && (gdist2square(dx+ .5,dy+1.5))) { clipit[i1].x = x; clipit[i1].y = y+1; i1 = ((i1+1)&(MAXCLIPIT-1)); iy1 = y+1; }
	} while (i0 != i1);
#if 1
	(*hitx) = dbound(vx*gendt + x0,acr,VSID-acr);
	(*hity) = dbound(vy*gendt + y0,acr,VSID-acr);
	(*hitz) = dbound(vz*gendt + z0,MAXZDIM-2048+acr,MAXZDIM-1-acr);
#else
	(*hitx) = min(max(vx*gendt + x0,acr),VSID-acr);
	(*hity) = min(max(vy*gendt + y0,acr),VSID-acr);
	(*hitz) = min(max(vz*gendt + z0,MAXZDIM-2048+acr),MAXZDIM-1-acr);
#endif
	return(gendt == 1);
}

bool clipmove_slide = true; // hax!

void clipmove (dpoint3d *p, dpoint3d *v, double acr)
{
	double f, gx, gy, gz, nx, ny, nz, ex, ey, ez, hitx, hity, hitz, cr;
	//double nx2, ny2, nz2, ex2, ey2, ez2; //double ox, oy, oz;
	long i, j, k;

	//ox = p->x; oy = p->y; oz = p->z;
	gx = p->x+v->x; gy = p->y+v->y; gz = p->z+v->z;

	cr = findmaxcr(p->x,p->y,p->z,acr);
	vx5.clipmaxcr = cr;

	vx5.cliphitnum = 0;
	for(i=0;i<3;i++)
	{
		if ((v->x == 0) && (v->y == 0) && (v->z == 0)) break;

		cr -= 1e-7;  //Shrinking radius error control hack

		//j = sphtraceo(p->x,p->y,p->z,v->x,v->y,v->z,&nx,&ny,&nz,&ex,&ey,&ez,cr,acr);
		//k = sphtraceo(p->x,p->y,p->z,v->x,v->y,v->z,&nx2,&ny2,&nz2,&ex2,&ey2,&ez2,cr,acr);

		j = sphtrace(p->x,p->y,p->z,v->x,v->y,v->z,&nx,&ny,&nz,&ex,&ey,&ez,cr,acr);

		//if ((j != k) || (fabs(nx-nx2) > .000001) || (fabs(ny-ny2) > .000001) || (fabs(nz-nz2) > .000001) ||
		//   ((j == 0) && ((fabs(ex-ex2) > .000001) || (fabs(ey-ey2) > .000001) || (fabs(ez-ez2) > .000001))))
		//{
		//   printf("%d %f %f %f %f %f %f\n",i,p->x,p->y,p->z,v->x,v->y,v->z);
		//   printf("%f %f %f ",nx,ny,nz); if (!j) printf("%f %f %f\n",ex,ey,ez); else printf("\n");
		//   printf("%f %f %f ",nx2,ny2,nz2); if (!k) printf("%f %f %f\n",ex2,ey2,ez2); else printf("\n");
		//   printf("\n");
		//}
		if (j) { p->x = nx; p->y = ny; p->z = nz; break; }

		vx5.cliphit[i].x = ex; vx5.cliphit[i].y = ey; vx5.cliphit[i].z = ez;
		vx5.cliphitnum = i+1;
		p->x = nx; p->y = ny; p->z = nz;

			//Calculate slide vector
		v->x = gx-nx; v->y = gy-ny; v->z = gz-nz;
    if(!clipmove_slide) return;
		switch(i)
		{
			case 0:
				hitx = ex-nx; hity = ey-ny; hitz = ez-nz;
				f = (v->x*hitx + v->y*hity + v->z*hitz) / (cr * cr);
				v->x -= hitx*f; v->y -= hity*f; v->z -= hitz*f;
				break;
			case 1:
				nx -= ex; ny -= ey; nz -= ez;
				ex = hitz*ny - hity*nz;
				ey = hitx*nz - hitz*nx;
				ez = hity*nx - hitx*ny;
				f = ex*ex + ey*ey + ez*ez; if (f <= 0) break;
				f = (v->x*ex + v->y*ey + v->z*ez) / f;
				v->x = ex*f; v->y = ey*f; v->z = ez*f;
				break;
			default: break;
		}
	}

		//If you didn't move much, then don't move at all. This helps prevents
		//cliprad from shrinking, but you get stuck too much :(
	//if ((p->x-ox)*(p->x-ox) + (p->y-oy)*(p->y-oy) + (p->z-oz)*(p->z-oz) < 1e-12)
	//   { p->x = ox; p->y = oy; p->z = oz; }
}

long cansee (point3d *p0, point3d *p1, lpoint3d *hit)
{
	lpoint3d a, c, d, p, i;
	point3d f, g;
	long cnt;

	ftol(p0->x-.5,&a.x); ftol(p0->y-.5,&a.y); ftol(p0->z-.5,&a.z);
	if (isvoxelsolid(a.x,a.y,a.z)) { hit->x = a.x; hit->y = a.y; hit->z = a.z; return(0); }
	ftol(p1->x-.5,&c.x); ftol(p1->y-.5,&c.y); ftol(p1->z-.5,&c.z);
	cnt = 0;

		  if (c.x <  a.x) { d.x = -1; f.x = p0->x-a.x;   g.x = (p0->x-p1->x)*1024; cnt += a.x-c.x; }
	else if (c.x != a.x) { d.x =  1; f.x = a.x+1-p0->x; g.x = (p1->x-p0->x)*1024; cnt += c.x-a.x; }
	else f.x = g.x = 0;
		  if (c.y <  a.y) { d.y = -1; f.y = p0->y-a.y;   g.y = (p0->y-p1->y)*1024; cnt += a.y-c.y; }
	else if (c.y != a.y) { d.y =  1; f.y = a.y+1-p0->y; g.y = (p1->y-p0->y)*1024; cnt += c.y-a.y; }
	else f.y = g.y = 0;
		  if (c.z <  a.z) { d.z = -1; f.z = p0->z-a.z;   g.z = (p0->z-p1->z)*1024; cnt += a.z-c.z; }
	else if (c.z != a.z) { d.z =  1; f.z = a.z+1-p0->z; g.z = (p1->z-p0->z)*1024; cnt += c.z-a.z; }
	else f.z = g.z = 0;

	ftol(f.x*g.z - f.z*g.x,&p.x); ftol(g.x,&i.x);
	ftol(f.y*g.z - f.z*g.y,&p.y); ftol(g.y,&i.y);
	ftol(f.y*g.x - f.x*g.y,&p.z); ftol(g.z,&i.z);

		//NOTE: GIGO! This can happen if p0,p1 (cansee input) is NaN, Inf, etc...
	if ((unsigned long)cnt > (VSID+VSID+2048)*2) cnt = (VSID+VSID+2048)*2;
	while (cnt > 0)
	{
		if (((p.x|p.y) >= 0) && (a.z != c.z)) { a.z += d.z; p.x -= i.x; p.y -= i.y; }
		else if ((p.z >= 0) && (a.x != c.x))  { a.x += d.x; p.x += i.z; p.z -= i.y; }
		else                                  { a.y += d.y; p.y += i.z; p.z += i.x; }
		if (isvoxelsolid(a.x,a.y,a.z)) break;
		cnt--;
	}
	hit->x = a.x; hit->y = a.y; hit->z = a.z; return(!cnt);
}

	//  p: start position
	//  d: direction
	//  h: coordinate of voxel hit (if any)
	//ind: pointer to surface voxel's 32-bit color (0 if none hit)
	//dir: 0-5: last direction moved upon hit (-1 if inside solid)
void hitscan (dpoint3d *p, dpoint3d *d, lpoint3d *h, long **ind, long *dir)
{
	long ixi, iyi, izi, dx, dy, dz, dxi, dyi, dzi, z0, z1, minz;
	float f, kx, ky, kz;
	char *v;

		//Note: (h->x,h->y,h->z) MUST be rounded towards -inf
	(h->x) = (long)p->x;
	(h->y) = (long)p->y;
	(h->z) = (long)p->z;
	if ((unsigned long)(h->x|h->y) >= VSID) { (*ind) = 0; (*dir) = -1; return; }
	ixi = (((((signed long *)&d->x)[1])>>31)|1);
	iyi = (((((signed long *)&d->y)[1])>>31)|1);
	izi = (((((signed long *)&d->z)[1])>>31)|1);

	minz = min(h->z,0);

	f = 0x3fffffff/VSID; //Maximum delta value
	if ((fabs(d->x) >= fabs(d->y)) && (fabs(d->x) >= fabs(d->z)))
	{
		kx = 1024.0;
		if (d->y == 0) ky = f; else ky = min(fabs(d->x/d->y)*1024.0,f);
		if (d->z == 0) kz = f; else kz = min(fabs(d->x/d->z)*1024.0,f);
	}
	else if (fabs(d->y) >= fabs(d->z))
	{
		ky = 1024.0;
		if (d->x == 0) kx = f; else kx = min(fabs(d->y/d->x)*1024.0,f);
		if (d->z == 0) kz = f; else kz = min(fabs(d->y/d->z)*1024.0,f);
	}
	else
	{
		kz = 1024.0;
		if (d->x == 0) kx = f; else kx = min(fabs(d->z/d->x)*1024.0,f);
		if (d->y == 0) ky = f; else ky = min(fabs(d->z/d->y)*1024.0,f);
	}
	ftol(kx,&dxi); ftol((p->x-(float)h->x)*kx,&dx); if (ixi >= 0) dx = dxi-dx;
	ftol(ky,&dyi); ftol((p->y-(float)h->y)*ky,&dy); if (iyi >= 0) dy = dyi-dy;
	ftol(kz,&dzi); ftol((p->z-(float)h->z)*kz,&dz); if (izi >= 0) dz = dzi-dz;

	v = sptr[h->y*VSID+h->x];
	if (h->z >= v[1])
	{
		do
		{
			if (!v[0]) { (*ind) = 0; (*dir) = -1; return; }
			v += v[0]*4;
		} while (h->z >= v[1]);
		z0 = v[3];
	} else z0 = minz;
	z1 = v[1];

	while (1)
	{
		//Check cube at: h->x,h->y,h->z

		if ((dz <= dx) && (dz <= dy))
		{
			h->z += izi; dz += dzi; (*dir) = 5-(izi>0);

				//Check if h->z ran into anything solid
			if (h->z < z0)
			{
				if (h->z < minz) (*ind) = 0; else (*ind) = (long *)&v[-4];
				return;
			}
			if (h->z >= z1) { (*ind) = (long *)&v[4]; return; }
		}
		else
		{
			if (dx < dy)
			{
				h->x += ixi; dx += dxi; (*dir) = 1-(ixi>0);
				if ((unsigned long)h->x >= VSID) { (*ind) = 0; return; }
			}
			else
			{
				h->y += iyi; dy += dyi; (*dir) = 3-(iyi>0);
				if ((unsigned long)h->y >= VSID) { (*ind) = 0; return; }
			}

				//Check if (h->x, h->y) ran into anything solid
			v = sptr[h->y*VSID+h->x];
			while (1)
			{
				if (h->z < v[1])
				{
					if (v == sptr[h->y*VSID+h->x]) { z0 = minz; z1 = v[1]; break; }
					if (h->z < v[3]) { (*ind) = (long *)&v[(h->z-v[3])*4]; return; }
					z0 = v[3]; z1 = v[1]; break;
				}
				else if ((h->z <= v[2]) || (!v[0]))
					{ (*ind) = (long *)&v[(h->z-v[1])*4+4]; return; }

				v += v[0]*4;
			}
		}
	}
}


long getvdir(vx5sprite *spr, long x, long y, long z)
{
  kv6data *kv = spr->voxnum;
  if (!kv) return (255);

	float f; //, maxf, fx, fy, fz;
	long i, j, k, xx, yy, zz, ox, oy, oz;

		//Find number of solid cubes in local sphere
  static const int NORMBOXSIZ = 3;
  //static const int MAXXSIZ = 256; //Default values
  //static const int MAXYSIZ = 256;
  //static const int BUFZSIZ = 256;
  static long zheight[49] =
  {
    -1,1,2,2,2,1,-1,
	  1,2,3,3,3,2, 1,
	  2,3,3,3,3,3, 2,
	  2,3,3,3,3,3, 2,
	  2,3,3,3,3,3, 2,
	  1,2,3,3,3,2, 1,
    -1,1,2,2,2,1,-1
  };
  static long bitsum[128] =
  {
	  0,-3,-2,-5,-1,-4,-3,-6, 0,-3,-2,-5,-1,-4,-3,-6,
	  1,-2,-1,-4, 0,-3,-2,-5, 1,-2,-1,-4, 0,-3,-2,-5,
	  2,-1, 0,-3, 1,-2,-1,-4, 2,-1, 0,-3, 1,-2,-1,-4,
	  3, 0, 1,-2, 2,-1, 0,-3, 3, 0, 1,-2, 2,-1, 0,-3,
	  3, 0, 1,-2, 2,-1, 0,-3, 3, 0, 1,-2, 2,-1, 0,-3,
	  4, 1, 2,-1, 3, 0, 1,-2, 4, 1, 2,-1, 3, 0, 1,-2,
	  5, 2, 3, 0, 4, 1, 2,-1, 5, 2, 3, 0, 4, 1, 2,-1,
	  6, 3, 4, 1, 5, 2, 3, 0, 6, 3, 4, 1, 5, 2, 3, 0
  };
  static long zmask[49] =
  {
	   0, 28, 62, 62, 62, 28,  0,
	  28, 62,127,127,127, 62, 28,
	  62,127,127,127,127,127, 62,
	  62,127,127,127,127,127, 62,
	  62,127,127,127,127,127, 62,
	  28, 62,127,127,127, 62, 28,
	   0, 28, 62, 62, 62, 28,  0
  };

	long *zh = &zheight[3];
	ox = oy = oz = 0;
	//if (((unsigned long)(y-3) >= kv->ysiz-6) || ((unsigned long)(z-3) >= kv->zsiz-6))
	{
		for(xx=-3;xx<=3;xx++,zh+=7)
		{
			if ((unsigned long)(x+xx) >= (unsigned long)kv->xsiz) continue;
			for(yy=-3;yy<=3;yy++)
			{
				if ((unsigned long)(y+yy) >= (unsigned long)kv->ysiz) continue;
				j = zh[yy];
				for(zz=-j;zz<=j;zz++)
				{
					if ((unsigned long)(z+zz) >= (unsigned long)kv->zsiz) continue;
					//i = ((x+xx)*MAXYSIZ+(y+yy))*BUFZSIZ+(z+zz);
          if(sprgetcube(spr, x+xx, y+yy, z+zz) != NULL) //(!(vbit[i>>5]&(1<<i)))
          {
            ox += xx; oy += yy; oz += zz;
          }
				}
			}
		}
	}
  // i guess this is a quicker path, but i sure as hell don't understand it
	/*else
	{
		long tx, *zm = &zmask[3];
		char *cbit = (char *)vbit;
		i = ((x-3)*MAXYSIZ+(y-3))*BUFZSIZ+(z-3);
		for(xx=-3;xx<=3;xx++,i+=MAXYSIZ*BUFZSIZ,zm+=7)
		{
			if ((unsigned long)(x+xx) >= (unsigned long)kv->xsiz) continue;
			tx = 0;
			for(yy=-3,j=i;yy<=3;yy++,j+=BUFZSIZ)
			{
				k = (~((*(long *)&cbit[j>>3])>>(j&7)))&zm[yy];
				tx += bitnum[k];
				oy += bitnum[k]*yy;
				oz += bitsum[k];
			}
			ox += tx*xx;
		}
	}*/

		//If voxels aren't directional (thin), return the 0 vector (no direction)
	f = ox*ox+oy*oy+oz*oz; if (f < 32*32) return(255);
	f = 1 / sqrt(f); //NOTE: don't use rsqrtss: sqrt must be accurate here
  extern long equivec2indmem (float x, float y, float z);
	return(equivec2indmem(ox*f,oy*f,oz*f));
}

void sprdrawbullethole(vx5sprite *spr, long point_x, long point_y, long point_z)
{
  sprclearcube(spr, point_x, point_y, point_z, 0x000000);

  static const lpoint3d offsets[6] = {{1,0,0}, {-1,0,0}, {0,1,0}, {0,-1,0}, {0,0,1}, {0,0,-1}};
  for(int i = 0; i < 6; i++)
  {
    kv6voxtype *vox = sprgetcube(spr, point_x + offsets[i].x, point_y + offsets[i].y, point_z + offsets[i].z);
    if(!vox)
      continue;

    long newcolor = vox->col;
    int r = (newcolor>>16) & 0xFF;
    int g = (newcolor>>8) & 0xFF;
    int b = (newcolor) & 0xFF;
    // mul by 0.8
    r *= 8; r /= 10;
    g *= 8; g /= 10;
    b *= 8; b /= 10;
    vox->col = 0x80000000 | (r<<16) | (g<<8) | (b);
  }
}

void sprdrawwound(vx5sprite *spr, long point_x, long point_y, long point_z, int hole_radius, int blood_radius)
{
  if(!spr->voxnum)
    return;

  // this is gonna hurt (performance wise at least)
  if(hole_radius > 1)
  {
    hole_radius--;

    int xmin = max(point_x - hole_radius, 0);
    int xmax = min(point_x + hole_radius, spr->voxnum->xsiz-1);
    int ymin = max(point_y - hole_radius, 0);
    int ymax = min(point_y + hole_radius, spr->voxnum->ysiz-1);
    int zmin = max(point_z - hole_radius, 0);
    int zmax = min(point_z + hole_radius, spr->voxnum->zsiz-1);

    for(int x = xmin; x <= xmax; x++)
    {
      for(int y = ymin; y <= ymax; y++)
      {
        for(int z = zmin; z <= zmax; z++)
        {
          int r = 40 + rand()%50;
          sprclearcube(spr, x, y, z, 0xFF000000|(r<<16));
        }
      }
    }

  }
  else if(hole_radius == 1)
  {
    int r = 40 + rand()%50;
    sprclearcube(spr, point_x, point_y, point_z, 0xFF000000|(r<<16));
  }

  kv6data *kv = spr->voxnum;
  if (!kv) return;

  int xmin = max(point_x - blood_radius, 0);
  int xmax = min(point_x + blood_radius, spr->voxnum->xsiz-1);
  int ymin = max(point_y - blood_radius, 0);
  int ymax = min(point_y + blood_radius, spr->voxnum->ysiz-1);
  int zmin = max(point_z - blood_radius, 0);
  int zmax = min(point_z + blood_radius, spr->voxnum->zsiz-1);

  for(int pnt_x = xmin; pnt_x <= xmax; pnt_x++)
  {
    for(int pnt_y = ymin; pnt_y <= ymax; pnt_y++)
    {
      int offset_x = pnt_x - point_x;
      int offset_y = pnt_y - point_y;

      kv6voxtype *vs = kv->vox;
      int x;
	    for(x=0;x<pnt_x;x++) vs += kv->xlen[x];
      int y;
	    for(y=0;y<pnt_y;y++) vs += kv->ylen[x*kv->ysiz + y];

      float fMaxDist = blood_radius*blood_radius*3;
      kv6voxtype *ve = vs + kv->ylen[x*kv->ysiz + y];
	    for(;vs<ve;vs++)
      {
        if (vs->z >= zmin && vs->z <= zmax)
        {
          int offset_z = vs->z - point_z;
          float fIntensity = powf((offset_x * offset_x + offset_y * offset_y + offset_z * offset_z) / fMaxDist, 0.25f);

          float fExtraMultiplier = 1.0f/(1.0f + (1.0f - fIntensity) * rand()/(float)RAND_MAX);

          int iR = (vs->col >> 16) & 0xFF;
          int iG = (vs->col >> 8) & 0xFF;
          int iB = (vs->col) & 0xFF;

          iR = (iR * fExtraMultiplier);
          iG = (iG * fIntensity * fExtraMultiplier);
          iB = (iB * fIntensity * fExtraMultiplier);

          vs->col = 0x80000000 | iR<<16 | iG<<8 | iB;
        }
      }
    }
  }
}

void sprcolorizecube(vx5sprite *spr, long point_x, long point_y, long point_z, long color)
{
	//Check if voxel at: (a.x,a.y,a.z) is solid
  kv6data *kv = spr->voxnum;
  if (!kv) return;

  if((unsigned int)point_x >= kv->xsiz)
    return;
  if((unsigned int)point_y >= kv->ysiz)
    return;
  if((unsigned int)point_z >= kv->zsiz)
    return;

	kv6voxtype *vs = kv->vox;
  int x;
	for(x=0;x<point_x;x++) vs += kv->xlen[x];
  int y;
	for(y=0;y<point_y;y++) vs += kv->ylen[x*kv->ysiz + y];

  kv6voxtype *ve = vs + kv->ylen[point_x*kv->ysiz + point_y];
	for(;vs<ve;vs++)
  {
    if (vs->z == point_z)
    {
      vs->col = color;
      return;
    }
  }
}

void sprinsertcube(vx5sprite *spr, long point_x, long point_y, long point_z, long color, long vis)
{
  kv6data *kv = spr->voxnum;
  if (!kv) return;

  if((unsigned int)point_x >= kv->xsiz)
    return;
  if((unsigned int)point_y >= kv->ysiz)
    return;
  if((unsigned int)point_z >= kv->zsiz)
    return;

	kv6voxtype *vs = kv->vox;
  int x;
	for(x=0;x<point_x;x++) vs += kv->xlen[x];
  int y;
	for(y=0;y<point_y;y++) vs += kv->ylen[x*kv->ysiz + y];

  kv6voxtype *ve = vs + kv->ylen[x*kv->ysiz + y];
	for(;vs<ve;vs++)
  {
    if(vs->z > point_z)
    {
      int voxel_number = vs - kv->vox;
      vs = NULL; // do not use VS anymore due to realloc!!

      // calculate how much free space left
      long usedbytes = kv->numvoxs*sizeof(kv6voxtype) + kv->xsiz*4 + kv->xsiz*kv->ysiz*2 + sizeof(kv6data);
      long freebytes = usedbytes - kv->leng;

      // not enough free space
      if(freebytes < sizeof(kv6voxtype))
      {
        // realloc space for 32 new voxels (256 bytes)
        long extraspace = sizeof(kv6voxtype) * 32;
        kv = (kv6data *)realloc(kv, kv->leng + extraspace);
        spr->voxnum = kv;
        kv->leng += extraspace;

        // reset pointers
        kv->vox = (kv6voxtype *)(((long)kv)+sizeof(kv6data));
	      kv->xlen = (unsigned long *)(((long)kv->vox)+kv->numvoxs*sizeof(kv6voxtype));
	      kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);
      }

      // move memory to make room for new voxel
      memmove(kv->vox + voxel_number + 1, kv->vox + voxel_number, sizeof(kv6voxtype) * (kv->numvoxs - voxel_number) + kv->xsiz*4 + kv->xsiz*kv->ysiz*2);

      // reset pointers
      kv->numvoxs++;
      kv->xlen = (unsigned long *)(((long)kv->vox)+kv->numvoxs*sizeof(kv6voxtype));
      kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);

      // set new voxel
      kv->vox[voxel_number].col = color;
      kv->vox[voxel_number].dir = 255;//getvdir(spr, point_x, point_y, point_z);
      kv->vox[voxel_number].vis = vis;
      kv->vox[voxel_number].z = point_z;

      // increase count
      kv->xlen[point_x]++;
      kv->ylen[point_x*kv->ysiz + point_y]++;

      return;     
    }
  }
}

// returns pointer to voxel at given coordinates
kv6voxtype *sprgetcube(vx5sprite *spr, long point_x, long point_y, long point_z)
{
  kv6data *kv = spr->voxnum;
  if (!kv) return NULL;

  if((unsigned int)point_x >= kv->xsiz)
    return NULL;
  if((unsigned int)point_y >= kv->ysiz)
    return NULL;
  if((unsigned int)point_z >= kv->zsiz)
    return NULL;

	kv6voxtype *vs = kv->vox;
  int x;
	for(x=0;x<point_x;x++) vs += kv->xlen[x];
  int y;
	for(y=0;y<point_y;y++) vs += kv->ylen[x*kv->ysiz + y];

  kv6voxtype *ve = vs + kv->ylen[x*kv->ysiz + y];
	for(;vs<ve;vs++)
  {
    // found match
    if(vs->z == point_z)
      return vs;
    // already passed, not going to be found
    if(vs->z > point_z)
      return NULL;
  }
  return NULL;
}

void sprclearcube(vx5sprite *spr, long point_x, long point_y, long point_z, long remcolor)
{
  int voxel_number;
  char visbits;

  // do not use pointers in case voxels are realloced..
  {
    kv6voxtype *vox = sprgetcube(spr, point_x, point_y, point_z);
    if(vox == NULL)
      return;

    if(remcolor == -1)
      remcolor = vox->col;
    visbits = vox->vis;
    voxel_number = (vox - spr->voxnum->vox);
  }

  // scan neighbours
  // Bit 0: x- (left)
  // Bit 1: x+ (right)
  // Bit 2: y- (forward)
  // Bit 3: y+ (back)
  // Bit 4: z- (up)
  // Bit 5: z+ (down)
  for(int i = 0; i < 6; i++)
  {
    // empty air in this direction
    if(visbits & (1<<i))
    {
      // do nothing
      continue;
    }

    // get position
    long new_point_x = point_x;
    long new_point_y = point_y;
    long new_point_z = point_z;
    int my_vis_bit = 0; // visibility bit of this voxel for the neighbour
    switch(i)
    {
      case 0: new_point_x--; my_vis_bit = 1; break;
      case 1: new_point_x++; my_vis_bit = 0; break;
      case 2: new_point_y--; my_vis_bit = 3; break;
      case 3: new_point_y++; my_vis_bit = 2; break;
      case 4: new_point_z--; my_vis_bit = 5; break;
      case 5: new_point_z++; my_vis_bit = 4; break;
    }

    // a voxel already exists
    kv6voxtype *vox2 = sprgetcube(spr, new_point_x, new_point_y, new_point_z);
    if(vox2 != NULL)
    {
      // add face for the removed voxel
      vox2->vis |= (1<<my_vis_bit);
      continue;
    }
    else
    {
      // otherwise add new voxel
      sprinsertcube(spr, new_point_x, new_point_y, new_point_z, remcolor, (1<<my_vis_bit));
    }
  }

  // get voxel pointer again because new voxels have been added
  kv6voxtype *vox = sprgetcube(spr, point_x, point_y, point_z);
  if(vox == NULL)
    return;
  voxel_number = (vox - spr->voxnum->vox);
  kv6data *kv = spr->voxnum;

  // move other voxels on top of this
  memmove(kv->vox + voxel_number, kv->vox + voxel_number + 1, sizeof(kv6voxtype) * (kv->numvoxs - voxel_number) + kv->xsiz*4 + kv->xsiz*kv->ysiz*2);

  // reset pointers
  kv->numvoxs--;
  kv->xlen = (unsigned long *)(((long)kv->vox)+kv->numvoxs*sizeof(kv6voxtype));
  kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);

  // decrease voxel count
  kv->xlen[point_x]--;
  kv->ylen[point_x*spr->voxnum->ysiz + point_y]--;
}


	// p0: start position
	// v0: direction
	//spr: pointer of sprite to test collision with
	//  h: coordinate of voxel hit in sprite coordinates (if any)
	//ind: pointer to voxel hit (kv6voxtype) (0 if none hit)
	//vsc:  input: max multiple/fraction of v0's length to scan (1.0 for |v0|)
	//     output: multiple/fraction of v0's length of hit point
void sprhitscan (dpoint3d *p0, dpoint3d *v0, vx5sprite *spr, lpoint3d *h, kv6voxtype **ind, long *hitdir, float *vsc)
{
	kv6voxtype *vx[4];
	kv6data *kv;
	point3d t, u, v;
	lpoint3d a, d, p, q;
	float f, g;
	long i, x, y, xup, ix0, ix1;

	(*ind) = 0;
	if (spr->flags&2)
	{
		kfatype *kf = spr->kfaptr;
			//This sets the sprite pointer to be the parent sprite (voxnum
			//   of the main sprite is invalid for KFA sprites!)
		spr = &kf->spr[kf->hingesort[(kf->numhin)-1]];
	}
	kv = spr->voxnum; if (!kv) return;

		//d transformed to spr space (0,0,0,kv->xsiz,kv->ysiz,kv->zsiz)
	v.x = v0->x*spr->s.x + v0->y*spr->s.y + v0->z*spr->s.z;
	v.y = v0->x*spr->h.x + v0->y*spr->h.y + v0->z*spr->h.z;
	v.z = v0->x*spr->f.x + v0->y*spr->f.y + v0->z*spr->f.z;
	v.x /= (spr->s.x*spr->s.x + spr->s.y*spr->s.y + spr->s.z*spr->s.z);
	v.y /= (spr->h.x*spr->h.x + spr->h.y*spr->h.y + spr->h.z*spr->h.z);
	v.z /= (spr->f.x*spr->f.x + spr->f.y*spr->f.y + spr->f.z*spr->f.z);

		//p transformed to spr space (0,0,0,kv->xsiz,kv->ysiz,kv->zsiz)
	t.x = p0->x-spr->p.x;
	t.y = p0->y-spr->p.y;
	t.z = p0->z-spr->p.z;
	u.x = t.x*spr->s.x + t.y*spr->s.y + t.z*spr->s.z;
	u.y = t.x*spr->h.x + t.y*spr->h.y + t.z*spr->h.z;
	u.z = t.x*spr->f.x + t.y*spr->f.y + t.z*spr->f.z;
	u.x /= (spr->s.x*spr->s.x + spr->s.y*spr->s.y + spr->s.z*spr->s.z);
	u.y /= (spr->h.x*spr->h.x + spr->h.y*spr->h.y + spr->h.z*spr->h.z);
	u.z /= (spr->f.x*spr->f.x + spr->f.y*spr->f.y + spr->f.z*spr->f.z);
	u.x += kv->xpiv; u.y += kv->ypiv; u.z += kv->zpiv;

	ix0 = max(vx5.xplanemin,0);
	ix1 = min(vx5.xplanemax,kv->xsiz);

		//Increment ray until it hits bounding box
		// (ix0,0,0,ix1-1ulp,kv->ysiz-1ulp,kv->zsiz-1ulp)
	g = (float)ix0;
	t.x = (float)ix1;      (*(long *)&t.x)--;
	t.y = (float)kv->ysiz; (*(long *)&t.y)--;
	t.z = (float)kv->zsiz; (*(long *)&t.z)--;
		  if (u.x <   g) { if (v.x <= 0) return; f = (  g-u.x)/v.x; u.x =   g; u.y += v.y*f; u.z += v.z*f; }
	else if (u.x > t.x) { if (v.x >= 0) return; f = (t.x-u.x)/v.x; u.x = t.x; u.y += v.y*f; u.z += v.z*f; }
		  if (u.y <   0) { if (v.y <= 0) return; f = (  0-u.y)/v.y; u.y =   0; u.x += v.x*f; u.z += v.z*f; }
	else if (u.y > t.y) { if (v.y >= 0) return; f = (t.y-u.y)/v.y; u.y = t.y; u.x += v.x*f; u.z += v.z*f; }
		  if (u.z <   0) { if (v.z <= 0) return; f = (  0-u.z)/v.z; u.z =   0; u.x += v.x*f; u.y += v.y*f; }
	else if (u.z > t.z) { if (v.z >= 0) return; f = (t.z-u.z)/v.z; u.z = t.z; u.x += v.x*f; u.y += v.y*f; }

	ix1 -= ix0;

	g = 262144.0 / sqrt(v.x*v.x + v.y*v.y + v.z*v.z);

		//Note: (a.x,a.y,a.z) MUST be rounded towards -inf
	ftol(u.x-.5,&a.x); if ((unsigned long)(a.x-ix0) >= ix1) return;
	ftol(u.y-.5,&a.y); if ((unsigned long)a.y >= kv->ysiz) return;
	ftol(u.z-.5,&a.z); if ((unsigned long)a.z >= kv->zsiz) return;
	if (*(long *)&v.x < 0) { d.x = -1; u.x -= a.x;      v.x *= -g; }
							else { d.x =  1; u.x = a.x+1-u.x; v.x *=  g; }
	if (*(long *)&v.y < 0) { d.y = -1; u.y -= a.y;      v.y *= -g; }
							else { d.y =  1; u.y = a.y+1-u.y; v.y *=  g; }
	if (*(long *)&v.z < 0) { d.z = -1; u.z -= a.z;      v.z *= -g; }
							else { d.z =  1; u.z = a.z+1-u.z; v.z *=  g; }
	ftol(u.x*v.z - u.z*v.x,&p.x); ftol(v.x,&q.x);
	ftol(u.y*v.z - u.z*v.y,&p.y); ftol(v.y,&q.y);
	ftol(u.y*v.x - u.x*v.y,&p.z); ftol(v.z,&q.z);

  if ((p.x|p.y) >= 0)
    (*hitdir) = d.z < 0 ? 2 : 3;
  else if (p.z < 0)
    (*hitdir) = d.y > 0 ? 4 : 5;
  else
    (*hitdir) = d.x > 0 ? 0 : 1;

		//Check if voxel at: (a.x,a.y,a.z) is solid
	vx[0] = kv->vox;
	for(x=0;x<a.x;x++) vx[0] += kv->xlen[x];
	vx[1] = vx[0]; xup = x*kv->ysiz;
	for(y=0;y<a.y;y++) vx[1] += kv->ylen[xup+y];
	vx[2] = vx[1]; vx[3] = &vx[1][kv->ylen[xup+y]];

	while (1)
	{
		//vs = kv->vox; //Brute force: remove all vx[?] code to enable this
		//for(x=0;x<a.x;x++) vs += kv->xlen[x];
		//for(y=0;y<a.y;y++) vs += kv->ylen[x*kv->ysiz+y];
		//for(ve=&vs[kv->ylen[x+y]];vs<ve;vs++) if (vs->z == a.z) break;

			//Check if voxel at: (a.x,a.y,a.z) is solid
		if (vx[1] < vx[3])
		{
			while ((a.z < vx[2]->z) && (vx[2] > vx[1]  )) vx[2]--;
			while ((a.z > vx[2]->z) && (vx[2] < vx[3]-1)) vx[2]++;
			if (a.z == vx[2]->z) break;
		}

		if ((p.x|p.y) >= 0)
		{
      (*hitdir) = d.z < 0 ? 2 : 3;
			a.z += d.z; if ((unsigned long)a.z >= kv->zsiz) return;
			p.x -= q.x; p.y -= q.y;
		}
		else if (p.z < 0)
		{
      (*hitdir) = d.y > 0 ? 4 : 5;
			a.y += d.y; if ((unsigned long)a.y >= kv->ysiz) return;
			p.y += q.z; p.z += q.x;

			if (a.y < y) { y--; vx[1] -= kv->ylen[xup+y];      }
			if (a.y > y) {      vx[1] += kv->ylen[xup+y]; y++; }
			vx[2] = vx[1]; vx[3] = &vx[1][kv->ylen[xup+y]];
		}
		else
		{
      (*hitdir) = d.x > 0 ? 0 : 1;
			a.x += d.x; if ((unsigned long)(a.x-ix0) >= ix1) return;
			p.x += q.z; p.z -= q.y;

			if (a.x < x) { x--; vx[0] -= kv->xlen[x];      xup -= kv->ysiz; }
			if (a.x > x) {      vx[0] += kv->xlen[x]; x++; xup += kv->ysiz; }
			if ((a.y<<1) < kv->ysiz) //Start y-slice search from closer side
			{
				vx[1] = vx[0];
				for(y=0;y<a.y;y++) vx[1] += kv->ylen[xup+y];
			}
			else
			{
				vx[1] = &vx[0][kv->xlen[x]];
				for(y=kv->ysiz;y>a.y;y--) vx[1] -= kv->ylen[xup+y-1];
			}
			vx[2] = vx[1]; vx[3] = &vx[1][kv->ylen[xup+y]];
		}
	}

		//given: a = kv6 coordinate, find: v = vxl coordinate
	u.x = (float)a.x-kv->xpiv;
	u.y = (float)a.y-kv->ypiv;
	u.z = (float)a.z-kv->zpiv;
	v.x = u.x*spr->s.x + u.y*spr->h.x + u.z*spr->f.x + spr->p.x;
	v.y = u.x*spr->s.y + u.y*spr->h.y + u.z*spr->f.y + spr->p.y;
	v.z = u.x*spr->s.z + u.y*spr->h.z + u.z*spr->f.z + spr->p.z;

		//Stupid dot product stuff...
	f = ((v.x-p0->x)*v0->x + (v.y-p0->y)*v0->y + (v.z-p0->z)*v0->z) /
		  (v0->x*v0->x + v0->y*v0->y + v0->z*v0->z);
	if (f >= (*vsc)) return;
	{ (*vsc) = f; (*h) = a; (*ind) = vx[2]; (*vsc) = f; }
}

unsigned long calcglobalmass ()
{
	unsigned long i, j;
	char *v;

	j = VSID*VSID*256;
	for(i=0;i<VSID*VSID;i++)
	{
		v = sptr[i]; j -= v[1];
		while (v[0]) { v += v[0]*4; j += v[3]-v[1]; }
	}
	return(j);
}

void loadnul (dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	lpoint3d lp0, lp1;
	long i, x, y;
	char *v;
	float f;

	if (!vbuf) { vbuf = (long *)malloc((VOXSIZ>>2)<<2); if (!vbuf) evilquit("vbuf malloc failed"); }
	if (!vbit) { vbit = (long *)malloc((VOXSIZ>>7)<<2); if (!vbit) evilquit("vbuf malloc failed"); }

	v = (char *)(&vbuf[1]); //1st dword for voxalloc compare logic optimization

		//Completely re-compile vbuf
	for(x=0;x<VSID;x++)
		for(y=0;y<VSID;y++)
		{
			sptr[y*VSID+x] = v;
			i = 0; // + (rand()&1);  //i = default height of plain
			v[0] = 0;
			v[1] = i;
			v[2] = i;
			v[3] = 0;  //z0 (Dummy filler)
			//i = ((((x+y)>>3) + ((x^y)>>4)) % 231) + 16;
			//i = (i<<16)+(i<<8)+i;
			v += 4;
			(*(long *)v) = ((x^y)&15)*0x10101+0x807c7c7c; //colorjit(i,0x70707)|0x80000000;
			v += 4;
		}

	memset(&sptr[VSID*VSID],0,sizeof(sptr)-VSID*VSID*4);
	vbiti = (((long)v-(long)vbuf)>>2); //# vbuf longs/vbit bits allocated
	clearbuf((void *)vbit,vbiti>>5,-1);
	clearbuf((void *)&vbit[vbiti>>5],(VOXSIZ>>7)-(vbiti>>5),0);
	vbit[vbiti>>5] = (1<<vbiti)-1;

		//Blow out sphere and stick you inside map
	vx5.colfunc = jitcolfunc; vx5.curcol = 0x50205020;

	lp0.x = VSID*.5-90; lp0.y = VSID*.5-90; lp0.z = MAXZDIM*.5-45;
	lp1.x = VSID*.5+90; lp1.y = VSID*.5+90; lp1.z = MAXZDIM*.5+45;
	setrect(&lp0,&lp1,-1);
	//lp.x = VSID*.5; lp.y = VSID*.5; lp.z = MAXZDIM*.5; setsphere(&lp,64,-1);

	vx5.globalmass = calcglobalmass();

	ipo->x = VSID*.5; ipo->y = VSID*.5; ipo->z = MAXZDIM*.5; //ipo->z = -16;
	f = 0.0*PI/180.0;
	ist->x = cos(f); ist->y = sin(f); ist->z = 0;
	ihe->x = 0; ihe->y = 0; ihe->z = 1;
	ifo->x = sin(f); ifo->y = -cos(f); ifo->z = 0;

	gmipnum = 1; vx5.flstnum = 0;
	updatebbox(0,0,0,VSID,VSID,MAXZDIM,0);
}

long loaddta (const char *filename, dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	long i, j, p, leng, minz = 255, maxz = 0, h[5], longpal[256];
	char dat, *dtahei, *dtacol, *v, dafilename[MAX_PATH];
	float f;
	FILE *fp;

	if (!vbuf) { vbuf = (long *)malloc((VOXSIZ>>2)<<2); if (!vbuf) evilquit("vbuf malloc failed"); }
	if (!vbit) { vbit = (long *)malloc((VOXSIZ>>7)<<2); if (!vbit) evilquit("vbuf malloc failed"); }

	if (VSID != 1024) return(0);
	v = (char *)(&vbuf[1]); //1st dword for voxalloc compare logic optimization

	strcpy(dafilename,filename);

	dtahei = (char *)(&vbuf[(VOXSIZ-2097152)>>2]);
	dtacol = (char *)(&vbuf[(VOXSIZ-1048576)>>2]);

	dafilename[0] = 'd';
	if (!kzopen(dafilename)) return(0);
	kzseek(128,SEEK_SET); p = 0;
	while (p < 1024*1024)
	{
		dat = kzgetc();
		if (dat >= 192) { leng = dat-192; dat = kzgetc(); }
					  else { leng = 1; }
		dat = 255-dat;
		if (dat < minz) minz = dat;
		if (dat > maxz) maxz = dat;
		while (leng-- > 0) dtahei[p++] = dat;
	}
	kzclose();

	dafilename[0] = 'c';
	if (!kzopen(dafilename)) return(0);
	kzseek(128,SEEK_SET);
	p = 0;
	while (p < 1024*1024)
	{
		dat = kzgetc();
		if (dat >= 192) { leng = dat-192; dat = kzgetc(); }
					  else { leng = 1; }
		while (leng-- > 0) dtacol[p++] = dat;
	}

	dat = kzgetc();
	if (dat == 0xc)
		for(i=0;i<256;i++)
		{
			longpal[i] = kzgetc();
			longpal[i] = (longpal[i]<<8)+kzgetc();
			longpal[i] = (longpal[i]<<8)+kzgetc() + 0x80000000;
		}

	kzclose();

		//Fill board data
	minz = lbound(128-((minz+maxz)>>1),-minz,255-maxz);
	for(p=0;p<1024*1024;p++)
	{
		h[0] = (long)dtahei[p];
		h[1] = (long)dtahei[((p-1)&0x3ff)+((p     )&0xffc00)];
		h[2] = (long)dtahei[((p+1)&0x3ff)+((p     )&0xffc00)];
		h[3] = (long)dtahei[((p  )&0x3ff)+((p-1024)&0xffc00)];
		h[4] = (long)dtahei[((p  )&0x3ff)+((p+1024)&0xffc00)];

		j = 1;
		for(i=4;i>0;i--) if (h[i]-h[0] > j) j = h[i]-h[0];

		sptr[p] = v;
		v[0] = 0;
		v[1] = dtahei[p]+minz;
		v[2] = dtahei[p]+minz+j-1;
		v[3] = 0; //dummy (z top)
		v += 4;
		for(;j;j--) { *(long *)v = colorjit(longpal[dtacol[p]],0x70707); v += 4; }
	}

	memset(&sptr[VSID*VSID],0,sizeof(sptr)-VSID*VSID*4);
	vbiti = (((long)v-(long)vbuf)>>2); //# vbuf longs/vbit bits allocated
	clearbuf((void *)vbit,vbiti>>5,-1);
	clearbuf((void *)&vbit[vbiti>>5],(VOXSIZ>>7)-(vbiti>>5),0);
	vbit[vbiti>>5] = (1<<vbiti)-1;

	vx5.globalmass = calcglobalmass();

	ipo->x = VSID*.5; ipo->y = VSID*.5; ipo->z = 128;
	f = 0.0*PI/180.0;
	ist->x = cos(f); ist->y = sin(f); ist->z = 0;
	ihe->x = 0; ihe->y = 0; ihe->z = 1;
	ifo->x = sin(f); ifo->y = -cos(f); ifo->z = 0;

	gmipnum = 1; vx5.flstnum = 0;
	updatebbox(0,0,0,VSID,VSID,MAXZDIM,0);
	return(1);
}

long loadpng (const char *filename, dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	unsigned long *pngdat, dat[5];
	long i, j, k, l, p, leng, minz = 255, maxz = 0;
	char *v, *buf;
	float f;
	FILE *fp;

	if (!vbuf) { vbuf = (long *)malloc((VOXSIZ>>2)<<2); if (!vbuf) evilquit("vbuf malloc failed"); }
	if (!vbit) { vbit = (long *)malloc((VOXSIZ>>7)<<2); if (!vbit) evilquit("vbuf malloc failed"); }

	if (VSID != 1024) return(0);
	v = (char *)(&vbuf[1]); //1st dword for voxalloc compare logic optimization

	if (!kzopen(filename)) return(0);
	leng = kzfilelength();
	buf = (char *)malloc(leng); if (!buf) { kzclose(); return(0); }
	kzread(buf,leng);
	kzclose();

	kpgetdim(buf,leng,&i,&j); if ((i != VSID) && (j != VSID)) { free(buf); return(0); }
	pngdat = (unsigned long *)(&vbuf[(VOXSIZ-VSID*VSID*4)>>2]);
	if (kprender(buf,leng,(long)pngdat,VSID<<2,VSID,VSID,0,0) < 0) return(0);
	free(buf);

	for(i=0;i<VSID*VSID;i++)
	{
		if ((pngdat[i]>>24) < minz) minz = (pngdat[i]>>24);
		if ((pngdat[i]>>24) > maxz) maxz = (pngdat[i]>>24);
	}

		//Fill board data
	minz = lbound(128-((minz+maxz)>>1),-minz,255-maxz);
	for(p=0;p<VSID*VSID;p++)
	{
		dat[0] = pngdat[p];
		dat[1] = pngdat[((p-1)&(VSID-1))+((p     )&((VSID-1)*VSID))];
		dat[2] = pngdat[((p+1)&(VSID-1))+((p     )&((VSID-1)*VSID))];
		dat[3] = pngdat[((p  )&(VSID-1))+((p-VSID)&((VSID-1)*VSID))];
		dat[4] = pngdat[((p  )&(VSID-1))+((p+VSID)&((VSID-1)*VSID))];

		j = 1; l = dat[0];
		for(i=4;i>0;i--)
			if (((signed long)((dat[i]>>24)-(dat[0]>>24))) > j)
				{ j = (dat[i]>>24)-(dat[0]>>24); l = dat[i]; }

		sptr[p] = v;
		v[0] = 0;
		v[1] = (pngdat[p]>>24)+minz;
		v[2] = (pngdat[p]>>24)+minz+j-1;
		v[3] = 0; //dummy (z top)
		v += 4;
		k = (pngdat[p]&0xffffff)|0x80000000;
		if (j == 2)
		{
			l = (((  l     &255)-( k     &255))>>1)      +
				 (((((l>> 8)&255)-((k>> 8)&255))>>1)<< 8) +
				 (((((l>>16)&255)-((k>>16)&255))>>1)<<16);
		}
		else if (j > 2)
		{
			l = (((  l     &255)-( k     &255))/j)      +
				 (((((l>> 8)&255)-((k>> 8)&255))/j)<< 8) +
				 (((((l>>16)&255)-((k>>16)&255))/j)<<16);
		}
		*(long *)v = k; v += 4; j--;
		while (j) { k += l; *(long *)v = colorjit(k,0x30303); v += 4; j--; }
	}

	memset(&sptr[VSID*VSID],0,sizeof(sptr)-VSID*VSID*4);
	vbiti = (((long)v-(long)vbuf)>>2); //# vbuf longs/vbit bits allocated
	clearbuf((void *)vbit,vbiti>>5,-1);
	clearbuf((void *)&vbit[vbiti>>5],(VOXSIZ>>7)-(vbiti>>5),0);
	vbit[vbiti>>5] = (1<<vbiti)-1;

	vx5.globalmass = calcglobalmass();

	ipo->x = VSID*.5; ipo->y = VSID*.5; ipo->z = 128;
	f = 0.0*PI/180.0;
	ist->x = cos(f); ist->y = sin(f); ist->z = 0;
	ihe->x = 0; ihe->y = 0; ihe->z = 1;
	ifo->x = sin(f); ifo->y = -cos(f); ifo->z = 0;

	gmipnum = 1; vx5.flstnum = 0;
	updatebbox(0,0,0,VSID,VSID,MAXZDIM,0);
	return(1);
}


//Quake3 .BSP loading code begins --------------------------------------------
typedef struct { long c, i; float z, z1; } vlinerectyp;
static point3d q3pln[5250];
static float q3pld[5250], q3vz[256];
static long q3nod[4850][3], q3lf[4850];
long vlinebsp (float x, float y, float z0, float z1, float *dvz)
{
	vlinerectyp vlrec[64];
	float z, t;
	long i, j, vcnt, vlcnt;
	char vt[256];

	vcnt = 1; i = 0; vlcnt = 0; vt[0] = 17;
	while (1)
	{
		if (i < 0)
		{
			if (vt[vcnt-1] != (q3lf[~i]&255))
				{ dvz[vcnt] = z0; vt[vcnt] = (q3lf[~i]&255); vcnt++; }
		}
		else
		{
			j = q3nod[i][0]; z = q3pld[j] - q3pln[j].x*x - q3pln[j].y*y;
			t = q3pln[j].z*z0-z;
			if ((t < 0) == (q3pln[j].z*z1 < z))
				{ vlrec[vlcnt].c = 0; i = q3nod[i][(t<0)+1]; }
			else
			{
				z /= q3pln[j].z; j = (q3pln[j].z<0)+1;
				vlrec[vlcnt].c = 1; vlrec[vlcnt].i = q3nod[i][j];
				vlrec[vlcnt].z = z; vlrec[vlcnt].z1 = z1;
				i = q3nod[i][3-j]; z1 = z;
			}
			vlcnt++; continue;
		}
		do { vlcnt--; if (vlcnt < 0) return(vcnt); } while (!vlrec[vlcnt].c);
		vlrec[vlcnt].c = 0; i = vlrec[vlcnt].i;
		z0 = vlrec[vlcnt].z; z1 = vlrec[vlcnt].z1;
		vlcnt++;
	}
	return(0);
}

	//Stupidly useless declarations:
void delslab(long *b2, long y0, long y1);
long *scum2(long x, long y);
void scum2finish();

void loadbsp (const char *filnam, dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	FILE *fp;
	dpoint3d dp;
	float f, xof, yof, zof, sc, rsc;
	long numplanes, numnodes, numleafs, fpos[17], flng[17];
	long i, x, y, z, z0, z1, vcnt, *lptr, minx, miny, minz, maxx, maxy, maxz;
	char *v;

	if (!vbuf) { vbuf = (long *)malloc((VOXSIZ>>2)<<2); if (!vbuf) evilquit("vbuf malloc failed"); }
	if (!vbit) { vbit = (long *)malloc((VOXSIZ>>7)<<2); if (!vbit) evilquit("vbuf malloc failed"); }

		//Completely re-compile vbuf
	v = (char *)(&vbuf[1]); //1st dword for voxalloc compare logic optimization
	for(x=0;x<VSID;x++)
		for(y=0;y<VSID;y++)
		{
			sptr[y*VSID+x] = v; v[0] = 0; v[1] = 0; v[2] = 0; v[3] = 0; v += 4;
			(*(long *)v) = ((x^y)&15)*0x10101+0x807c7c7c; v += 4;
		}

	memset(&sptr[VSID*VSID],0,sizeof(sptr)-VSID*VSID*4);
	vbiti = (((long)v-(long)vbuf)>>2); //# vbuf longs/vbit bits allocated
	clearbuf((void *)vbit,vbiti>>5,-1);
	clearbuf((void *)&vbit[vbiti>>5],(VOXSIZ>>7)-(vbiti>>5),0);
	vbit[vbiti>>5] = (1<<vbiti)-1;

	if (!kzopen(filnam)) return;
	kzread(&i,4); if (i != 0x50534249) { kzclose(); return; }
	kzread(&i,4); if (i != 0x2e) { kzclose(); return; }
	for(i=0;i<17;i++) { kzread(&fpos[i],4); kzread(&flng[i],4); }
	kzseek(fpos[2],SEEK_SET); numplanes = flng[2]/16;
	for(i=0;i<numplanes;i++) { kzread(&q3pln[i].x,12); kzread(&q3pld[i],4); }
	kzseek(fpos[3],SEEK_SET); numnodes = flng[3]/36;
	minx = 0x7fffffff; miny = 0x7fffffff; minz = 0x7fffffff;
	maxx = 0x80000000; maxy = 0x80000000; maxz = 0x80000000;
	for(i=0;i<numnodes;i++)
	{
		kzread(&q3nod[i][0],12);
		kzread(&x,4); if (x < minx) minx = x;
		kzread(&x,4); if (x < miny) miny = x;
		kzread(&x,4); if (x < minz) minz = x;
		kzread(&x,4); if (x > maxx) maxx = x;
		kzread(&x,4); if (x > maxy) maxy = x;
		kzread(&x,4); if (x > maxz) maxz = x;
	}
	kzseek(fpos[4]+4,SEEK_SET); numleafs = flng[4]/48;
	for(i=0;i<numleafs;i++) { kzread(&q3lf[i],4); kzseek(44,SEEK_CUR); }
	kzclose();

	sc = (float)(VSID-2)/(float)(maxx-minx);
	rsc = (float)(VSID-2)/(float)(maxy-miny); if (rsc < sc) sc = rsc;
	rsc = (float)(MAXZDIM-2)/(float)(maxz-minz); if (rsc < sc) sc = rsc;
	//i = *(long *)sc; i &= 0xff800000; sc = *(float *)i;
	xof = (-(float)(minx+maxx)*sc + VSID   )*.5;
	yof = (+(float)(miny+maxy)*sc + VSID   )*.5;
	zof = (+(float)(minz+maxz)*sc + MAXZDIM)*.5;

	rsc = 1.0 / sc;
	vx5.colfunc = curcolfunc; //0<x0<x1<VSID, 0<y0<y1<VSID, 0<z0<z1<256,
	for(y=0;y<VSID;y++)
		for(x=0;x<VSID;x++)
		{
			lptr = scum2(x,y);

				//voxx = q3x*+sc + xof;
				//voxy = q3y*-sc + yof;
				//voxz = q3z*-sc + zof;
			vcnt = vlinebsp(((float)x-xof)*rsc,((float)y-yof)*-rsc,-65536.0,65536.0,q3vz);
			for(i=vcnt-2;i>0;i-=2)
			{
				ftol(-q3vz[i+1]*sc+zof,&z0); if (z0 < 0) z0 = 0;
				ftol(-q3vz[i  ]*sc+zof,&z1); if (z1 > MAXZDIM) z1 = MAXZDIM;
				delslab(lptr,z0,z1);
			}
		}
	scum2finish();

	vx5.globalmass = calcglobalmass();

		//Find a spot that isn't too close to a wall
	sc = -1; ipo->x = VSID*.5; ipo->y = VSID*.5; ipo->z = -16;
	for(i=4096;i>=0;i--)
	{
		x = (rand()%VSID); y = (rand()%VSID); z = (rand()%MAXZDIM);
		if (!isvoxelsolid(x,y,z))
		{
			rsc = findmaxcr((double)x+.5,(double)y+.5,(double)z+.5,5.0);
			if (rsc <= sc) continue;
			ipo->x = (double)x+.5; ipo->y = (double)x+.5; ipo->z = (double)x+.5;
			sc = rsc; if (sc >= 5.0) break;
		}
	}
	f = 0.0*PI/180.0;
	ist->x = cos(f); ist->y = sin(f); ist->z = 0;
	ihe->x = 0; ihe->y = 0; ihe->z = 1;
	ifo->x = sin(f); ifo->y = -cos(f); ifo->z = 0;

	gmipnum = 1; vx5.flstnum = 0;
	updatebbox(0,0,0,VSID,VSID,MAXZDIM,0);
}

//Quake3 .BSP loading code ends ----------------------------------------------

long loadvxl (const char *lodfilnam, dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	FILE *fil;
	long i, j, fsiz;
	char *v, *v2;

	if (!vbuf) { vbuf = (long *)malloc((VOXSIZ>>2)<<2); if (!vbuf) evilquit("vbuf malloc failed"); }
	if (!vbit) { vbit = (long *)malloc((VOXSIZ>>7)<<2); if (!vbit) evilquit("vbuf malloc failed"); }

	if (!kzopen(lodfilnam)) return(0);
	fsiz = kzfilelength();

	kzread(&i,4); if (i != 0x09072000) return(0);
	kzread(&i,4); if (i != VSID) return(0);
	kzread(&i,4); if (i != VSID) return(0);
	kzread(ipo,24);
	kzread(ist,24);
	kzread(ihe,24);
	kzread(ifo,24);

	v = (char *)(&vbuf[1]); //1st dword for voxalloc compare logic optimization
	kzread((void *)v,fsiz-kztell());

	for(i=0;i<VSID*VSID;i++)
	{
		sptr[i] = v;
		while (v[0]) v += (((long)v[0])<<2);
		v += ((((long)v[2])-((long)v[1])+2)<<2);
	}
	kzclose();

	memset(&sptr[VSID*VSID],0,sizeof(sptr)-VSID*VSID*4);
	vbiti = (((long)v-(long)vbuf)>>2); //# vbuf longs/vbit bits allocated
	clearbuf((void *)vbit,vbiti>>5,-1);
	clearbuf((void *)&vbit[vbiti>>5],(VOXSIZ>>7)-(vbiti>>5),0);
	vbit[vbiti>>5] = (1<<vbiti)-1;

	vx5.globalmass = calcglobalmass();
	backedup = -1;

	gmipnum = 1; vx5.flstnum = 0;
	updatebbox(0,0,0,VSID,VSID,MAXZDIM,0);
	return(1);
}

long savevxl (const char *savfilnam, dpoint3d *ipo, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	FILE *fil;
	long i;

	if (!(fil = fopen(savfilnam,"wb"))) return(0);
	i = 0x09072000; fwrite(&i,4,1,fil);  //Version
	i = VSID; fwrite(&i,4,1,fil);
	i = VSID; fwrite(&i,4,1,fil);
	fwrite(ipo,24,1,fil);
	fwrite(ist,24,1,fil);
	fwrite(ihe,24,1,fil);
	fwrite(ifo,24,1,fil);
	for(i=0;i<VSID*VSID;i++) fwrite((void *)sptr[i],slng(sptr[i]),1,fil);
	fclose(fil);
	return(1);
}

long loadsky (const char *skyfilnam)
{
	long x, y, xoff, yoff;
	float ang, f;

	if (skypic) { free((void *)skypic); skypic = skyoff = 0; }
	xoff = yoff = 0;

	if (!stricmp(skyfilnam,"BLACK")) return(0);
	if (!stricmp(skyfilnam,"BLUE")) goto loadbluesky;

	kpzload(skyfilnam,&skypic,&skybpl,&skyxsiz,&skyysiz);
	if (!skypic)
	{
		long r, g, b, *p;
loadbluesky:;
			//Load default sky
		skyxsiz = 512; skyysiz = 1; skybpl = skyxsiz*4;
		if (!(skypic = (long)malloc(skyysiz*skybpl))) return(-1);

		p = (long *)skypic; y = skyxsiz*skyxsiz;
		for(x=0;x<=(skyxsiz>>1);x++)
		{
			p[x] = ((((x*1081 - skyxsiz*252)*x)/y + 35)<<16)+
					 ((((x* 950 - skyxsiz*198)*x)/y + 53)<<8)+
					  (((x* 439 - skyxsiz* 21)*x)/y + 98);
		}
		p[skyxsiz-1] = 0x50903c;
		r = ((p[skyxsiz>>1]>>16)&255);
		g = ((p[skyxsiz>>1]>>8)&255);
		b = ((p[skyxsiz>>1])&255);
		for(x=(skyxsiz>>1)+1;x<skyxsiz;x++)
		{
			p[x] = ((((0x50-r)*(x-(skyxsiz>>1)))/(skyxsiz-1-(skyxsiz>>1))+r)<<16)+
					 ((((0x90-g)*(x-(skyxsiz>>1)))/(skyxsiz-1-(skyxsiz>>1))+g)<<8)+
					 ((((0x3c-b)*(x-(skyxsiz>>1)))/(skyxsiz-1-(skyxsiz>>1))+b));
		}
		y = skyxsiz*skyysiz;
		for(x=skyxsiz;x<y;x++) p[x] = p[x-skyxsiz];
	}

		//Initialize look-up table for longitudes
	if (skylng) free((void *)skylng);
	if (!(skylng = (point2d *)malloc(skyysiz*8))) return(-1);
	f = PI*2.0 / ((float)skyysiz);
	for(y=skyysiz-1;y>=0;y--)
		fcossin((float)y*f+PI,&skylng[y].x,&skylng[y].y);
	skylngmul = (float)skyysiz/(PI*2);
		//This makes those while loops in gline() not lockup when skyysiz==1
	if (skyysiz == 1) { skylng[0].x = 0; skylng[0].y = 0; }

		//Initialize look-up table for latitudes
	if (skylat) free((void *)skylat);
	if (!(skylat = (long *)malloc(skyxsiz*4))) return(-1);
	f = PI*.5 / ((float)skyxsiz);
	for(x=skyxsiz-1;x;x--)
	{
		ang = (float)((x<<1)-skyxsiz)*f;
		ftol(cos(ang)*32767.0,&xoff);
		ftol(sin(ang)*32767.0,&yoff);
		skylat[x] = (xoff<<16)+((-yoff)&65535);
	}
	skylat[0] = 0; //Hack to make sure assembly index never goes < 0
	skyxsiz--; //Hack for assembly code

	return(0);
}

void orthonormalize (point3d *v0, point3d *v1, point3d *v2)
{
	float t;

	t = 1.0 / sqrt((v0->x)*(v0->x) + (v0->y)*(v0->y) + (v0->z)*(v0->z));
	(v0->x) *= t; (v0->y) *= t; (v0->z) *= t;
	t = (v1->x)*(v0->x) + (v1->y)*(v0->y) + (v1->z)*(v0->z);
	(v1->x) -= t*(v0->x); (v1->y) -= t*(v0->y); (v1->z) -= t*(v0->z);
	t = 1.0 / sqrt((v1->x)*(v1->x) + (v1->y)*(v1->y) + (v1->z)*(v1->z));
	(v1->x) *= t; (v1->y) *= t; (v1->z) *= t;
	(v2->x) = (v0->y)*(v1->z) - (v0->z)*(v1->y);
	(v2->y) = (v0->z)*(v1->x) - (v0->x)*(v1->z);
	(v2->z) = (v0->x)*(v1->y) - (v0->y)*(v1->x);
}

void dorthonormalize (dpoint3d *v0, dpoint3d *v1, dpoint3d *v2)
{
	double t;

	t = 1.0 / sqrt((v0->x)*(v0->x) + (v0->y)*(v0->y) + (v0->z)*(v0->z));
	(v0->x) *= t; (v0->y) *= t; (v0->z) *= t;
	t = (v1->x)*(v0->x) + (v1->y)*(v0->y) + (v1->z)*(v0->z);
	(v1->x) -= t*(v0->x); (v1->y) -= t*(v0->y); (v1->z) -= t*(v0->z);
	t = 1.0 / sqrt((v1->x)*(v1->x) + (v1->y)*(v1->y) + (v1->z)*(v1->z));
	(v1->x) *= t; (v1->y) *= t; (v1->z) *= t;
	(v2->x) = (v0->y)*(v1->z) - (v0->z)*(v1->y);
	(v2->y) = (v0->z)*(v1->x) - (v0->x)*(v1->z);
	(v2->z) = (v0->x)*(v1->y) - (v0->y)*(v1->x);
}

void orthorotate (float ox, float oy, float oz, point3d *ist, point3d *ihe, point3d *ifo)
{
	float f, t, dx, dy, dz, rr[9];

	fcossin(ox,&ox,&dx);
	fcossin(oy,&oy,&dy);
	fcossin(oz,&oz,&dz);
	f = ox*oz; t = dx*dz; rr[0] =  t*dy + f; rr[7] = -f*dy - t;
	f = ox*dz; t = dx*oz; rr[1] = -f*dy + t; rr[6] =  t*dy - f;
	rr[2] = dz*oy; rr[3] = -dx*oy; rr[4] = ox*oy; rr[8] = oz*oy; rr[5] = dy;
	ox = ist->x; oy = ihe->x; oz = ifo->x;
	ist->x = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->x = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->x = ox*rr[2] + oy*rr[5] + oz*rr[8];
	ox = ist->y; oy = ihe->y; oz = ifo->y;
	ist->y = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->y = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->y = ox*rr[2] + oy*rr[5] + oz*rr[8];
	ox = ist->z; oy = ihe->z; oz = ifo->z;
	ist->z = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->z = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->z = ox*rr[2] + oy*rr[5] + oz*rr[8];
	//orthonormalize(ist,ihe,ifo);
}

void dorthorotate (double ox, double oy, double oz, dpoint3d *ist, dpoint3d *ihe, dpoint3d *ifo)
{
	double f, t, dx, dy, dz, rr[9];

	dcossin(ox,&ox,&dx);
	dcossin(oy,&oy,&dy);
	dcossin(oz,&oz,&dz);
	f = ox*oz; t = dx*dz; rr[0] =  t*dy + f; rr[7] = -f*dy - t;
	f = ox*dz; t = dx*oz; rr[1] = -f*dy + t; rr[6] =  t*dy - f;
	rr[2] = dz*oy; rr[3] = -dx*oy; rr[4] = ox*oy; rr[8] = oz*oy; rr[5] = dy;
	ox = ist->x; oy = ihe->x; oz = ifo->x;
	ist->x = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->x = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->x = ox*rr[2] + oy*rr[5] + oz*rr[8];
	ox = ist->y; oy = ihe->y; oz = ifo->y;
	ist->y = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->y = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->y = ox*rr[2] + oy*rr[5] + oz*rr[8];
	ox = ist->z; oy = ihe->z; oz = ifo->z;
	ist->z = ox*rr[0] + oy*rr[3] + oz*rr[6];
	ihe->z = ox*rr[1] + oy*rr[4] + oz*rr[7];
	ifo->z = ox*rr[2] + oy*rr[5] + oz*rr[8];
	//dorthonormalize(ist,ihe,ifo);
}

void axisrotate (point3d *p, point3d *axis, float w)
{
	point3d ax;
	float t, c, s, ox, oy, oz, k[9];

	fcossin(w,&c,&s);
	t = axis->x*axis->x + axis->y*axis->y + axis->z*axis->z; if (t == 0) return;
	t = 1.0 / sqrt(t); ax.x = axis->x*t; ax.y = axis->y*t; ax.z = axis->z*t;

	t = 1.0-c;
	k[0] = ax.x*t; k[7] = ax.x*s; oz = ax.y*k[0];
	k[4] = ax.y*t; k[2] = ax.y*s; oy = ax.z*k[0];
	k[8] = ax.z*t; k[3] = ax.z*s; ox = ax.z*k[4];
	k[0] = ax.x*k[0] + c; k[5] = ox - k[7]; k[7] += ox;
	k[4] = ax.y*k[4] + c; k[6] = oy - k[2]; k[2] += oy;
	k[8] = ax.z*k[8] + c; k[1] = oz - k[3]; k[3] += oz;

	ox = p->x; oy = p->y; oz = p->z;
	p->x = ox*k[0] + oy*k[1] + oz*k[2];
	p->y = ox*k[3] + oy*k[4] + oz*k[5];
	p->z = ox*k[6] + oy*k[7] + oz*k[8];
}

void slerp (point3d *istr, point3d *ihei, point3d *ifor,
				point3d *istr2, point3d *ihei2, point3d *ifor2,
				point3d *ist, point3d *ihe, point3d *ifo, float rat)
{
	point3d ax;
	float c, s, t, ox, oy, oz, k[9];

	ist->x = istr->x; ist->y = istr->y; ist->z = istr->z;
	ihe->x = ihei->x; ihe->y = ihei->y; ihe->z = ihei->z;
	ifo->x = ifor->x; ifo->y = ifor->y; ifo->z = ifor->z;

	ax.x = istr->y*istr2->z - istr->z*istr2->y + ihei->y*ihei2->z - ihei->z*ihei2->y + ifor->y*ifor2->z - ifor->z*ifor2->y;
	ax.y = istr->z*istr2->x - istr->x*istr2->z + ihei->z*ihei2->x - ihei->x*ihei2->z + ifor->z*ifor2->x - ifor->x*ifor2->z;
	ax.z = istr->x*istr2->y - istr->y*istr2->x + ihei->x*ihei2->y - ihei->y*ihei2->x + ifor->x*ifor2->y - ifor->y*ifor2->x;
	t = ax.x*ax.x + ax.y*ax.y + ax.z*ax.z; if (t == 0) return;

		//Based on the vector suck-out method (see ROTATE2.BAS)
	ox = istr->x*ax.x + istr->y*ax.y + istr->z*ax.z;
	oy = ihei->x*ax.x + ihei->y*ax.y + ihei->z*ax.z;
	if (fabs(ox) < fabs(oy))
		{ c = istr->x*istr2->x + istr->y*istr2->y + istr->z*istr2->z; s = ox*ox; }
	else
		{ c = ihei->x*ihei2->x + ihei->y*ihei2->y + ihei->z*ihei2->z; s = oy*oy; }
	if (t == s) return;
	c = (c*t - s) / (t-s);
	if (c < -1) c = -1;
	if (c > 1) c = 1;
	fcossin(acos(c)*rat,&c,&s);

	t = 1.0 / sqrt(t); ax.x *= t; ax.y *= t; ax.z *= t;

	t = 1.0f-c;
	k[0] = ax.x*t; k[7] = ax.x*s; oz = ax.y*k[0];
	k[4] = ax.y*t; k[2] = ax.y*s; oy = ax.z*k[0];
	k[8] = ax.z*t; k[3] = ax.z*s; ox = ax.z*k[4];
	k[0] = ax.x*k[0] + c; k[5] = ox - k[7]; k[7] += ox;
	k[4] = ax.y*k[4] + c; k[6] = oy - k[2]; k[2] += oy;
	k[8] = ax.z*k[8] + c; k[1] = oz - k[3]; k[3] += oz;

	ox = ist->x; oy = ist->y; oz = ist->z;
	ist->x = ox*k[0] + oy*k[1] + oz*k[2];
	ist->y = ox*k[3] + oy*k[4] + oz*k[5];
	ist->z = ox*k[6] + oy*k[7] + oz*k[8];

	ox = ihe->x; oy = ihe->y; oz = ihe->z;
	ihe->x = ox*k[0] + oy*k[1] + oz*k[2];
	ihe->y = ox*k[3] + oy*k[4] + oz*k[5];
	ihe->z = ox*k[6] + oy*k[7] + oz*k[8];

	ox = ifo->x; oy = ifo->y; oz = ifo->z;
	ifo->x = ox*k[0] + oy*k[1] + oz*k[2];
	ifo->y = ox*k[3] + oy*k[4] + oz*k[5];
	ifo->z = ox*k[6] + oy*k[7] + oz*k[8];
}

void expandrle (long x, long y, long *uind)
{
	long i;
	char *v;

	if ((x|y)&(~(VSID-1))) { uind[0] = 0; uind[1] = MAXZDIM; return; }

	v = sptr[y*VSID+x]; uind[0] = v[1]; i = 2;
	while (v[0])
	{
		v += v[0]*4; if (v[3] >= v[1]) continue;
		uind[i-1] = v[3]; uind[i] = v[1]; i += 2;
	}
	uind[i-1] = MAXZDIM;
}

	//Inputs:  n0[<=MAXZDIM]: rle buffer of column to compress
	//         n1-4[<=MAXZDIM]: neighboring rle buffers
	//         top,bot,top,bot,... (ends when bot == MAXZDIM)
	//         px,py: takes color from original column (before modification)
	//            If originally unexposed, calls vx5.colfunc(.)
	//Outputs: cbuf[MAXCSIZ]: compressed output buffer
	//Returns: n: length of compressed buffer (in bytes)
long compilerle (long *n0, long *n1, long *n2, long *n3, long *n4, char *cbuf, long px, long py)
{
	long i, ia, ze, zend, onext, dacnt, n, *ic;
	lpoint3d p;
	char *v;

	p.x = px; p.y = py;

		//Generate pointers to color slabs in this format:
		//   0:z0,  1:z1,  2:(pointer to z0's color)-z0
	v = sptr[py*VSID+px]; ic = tbuf2;
	while (1)
	{
		ia = v[1]; p.z = v[2];
		ic[0] = ia; ic[1] = p.z+1; ic[2] = ((long)v)-(ia<<2)+4; ic += 3;
		i = v[0]; if (!i) break;
		v += i*4; ze = v[3];
		ic[0] = ze+p.z-ia-i+2; ic[1] = ze; ic[2] = ((long)v)-(ze<<2); ic += 3;
	}
	ic[0] = MAXZDIM; ic[1] = MAXZDIM;

	p.z = n0[0]; cbuf[1] = n0[0];
	ze = n0[1]; cbuf[2] = ze-1;
	cbuf[3] = 0;
	i = onext = 0; ic = tbuf2; ia = 15; n = 4;
	if (ze != MAXZDIM) zend = ze-1; else zend = -1;
	while (1)
	{
		dacnt = 0;
		while (1)
		{
			do
			{
				while (p.z >= ic[1]) ic += 3;
				if (p.z >= ic[0]) *(long *)&cbuf[n] = *(long *)(ic[2]+(p.z<<2));
								 else *(long *)&cbuf[n] = vx5.colfunc(&p);
				n += 4; p.z++; if (p.z >= ze) goto rlendit2;
				while (p.z >= n1[0]) { n1++; ia ^= 1; }
				while (p.z >= n2[0]) { n2++; ia ^= 2; }
				while (p.z >= n3[0]) { n3++; ia ^= 4; }
				while (p.z >= n4[0]) { n4++; ia ^= 8; }
			} while ((ia) || (p.z == zend));

			if (!dacnt) { cbuf[onext+2] = p.z-1; dacnt = 1; }
			else
			{
				cbuf[onext] = ((n-onext)>>2); onext = n;
				cbuf[n+1] = p.z; cbuf[n+2] = p.z-1; cbuf[n+3] = p.z; n += 4;
			}

			if ((n1[0] < n2[0]) && (n1[0] < n3[0]) && (n1[0] < n4[0]))
				{ if (n1[0] >= ze) { p.z = ze-1; } else { p.z = *n1++; ia ^= 1; } }
			else if ((n2[0] < n3[0]) && (n2[0] < n4[0]))
				{ if (n2[0] >= ze) { p.z = ze-1; } else { p.z = *n2++; ia ^= 2; } }
			else if (n3[0] < n4[0])
				{ if (n3[0] >= ze) { p.z = ze-1; } else { p.z = *n3++; ia ^= 4; } }
			else
				{ if (n4[0] >= ze) { p.z = ze-1; } else { p.z = *n4++; ia ^= 8; } }

			if (p.z == MAXZDIM-1) goto rlenditall;
		}
rlendit2:;
		if (ze >= MAXZDIM) break;

		i += 2;
		cbuf[onext] = ((n-onext)>>2); onext = n;
		p.z = n0[i]; cbuf[n+1] = n0[i]; cbuf[n+3] = ze;
		ze = n0[i+1]; cbuf[n+2] = ze-1;
		n += 4;
	}
rlenditall:;
	cbuf[onext] = 0;
	return(n);
}

	//Delete everything on b2() in y0<=y<y1
void delslab (long *b2, long y0, long y1)
{
	long i, j, z;

	if (y1 >= MAXZDIM) y1 = MAXZDIM-1;
	if ((y0 >= y1) || (!b2)) return;
	for(z=0;y0>=b2[z+1];z+=2);
	if (y0 > b2[z])
	{
		if (y1 < b2[z+1])
		{
			for(i=z;b2[i+1]<MAXZDIM;i+=2);
			while (i > z) { b2[i+3] = b2[i+1]; b2[i+2] = b2[i]; i -= 2; }
			b2[z+3] = b2[z+1]; b2[z+1] = y0; b2[z+2] = y1; return;
		}
		b2[z+1] = y0; z += 2;
	}
	if (y1 >= b2[z+1])
	{
		for(i=z+2;y1>=b2[i+1];i+=2);
		j = z-i; b2[z] = b2[i]; b2[z+1] = b2[i+1];
		while (b2[i+1] < MAXZDIM)
			{ i += 2; b2[i+j] = b2[i]; b2[i+j+1] = b2[i+1]; }
	}
	if (y1 > b2[z]) b2[z] = y1;
}

	//Insert everything on b2() in y0<=y<y1
void insslab (long *b2, long y0, long y1)
{
	long i, j, z;

	if ((y0 >= y1) || (!b2)) return;
	for(z=0;y0>b2[z+1];z+=2);
	if (y1 < b2[z])
	{
		for(i=z;b2[i+1]<MAXZDIM;i+=2);
		do { b2[i+3] = b2[i+1]; b2[i+2] = b2[i]; i -= 2; } while (i >= z);
		b2[z+1] = y1; b2[z] = y0; return;
	}
	if (y0 < b2[z]) b2[z] = y0;
	if ((y1 >= b2[z+2]) && (b2[z+1] < MAXZDIM))
	{
		for(i=z+2;(y1 >= b2[i+2]) && (b2[i+1] < MAXZDIM);i+=2);
		j = z-i; b2[z+1] = b2[i+1];
		while (b2[i+1] < MAXZDIM)
			{ i += 2; b2[i+j] = b2[i]; b2[i+j+1] = b2[i+1]; }
	}
	if (y1 > b2[z+1]) b2[z+1] = y1;
}

//------------------------ SETCOLUMN CODE BEGINS ----------------------------

static long scx0, scx1, scox0, scox1, scoox0, scoox1;
static long scex0, scex1, sceox0, sceox1, scoy = 0x80000000, *scoym3;

void scumline ()
{
	long i, j, k, x, y, x0, x1, *mptr, *uptr;
	char *v;

	x0 = min(scox0-1,min(scx0,scoox0)); scoox0 = scox0; scox0 = scx0;
	x1 = max(scox1+1,max(scx1,scoox1)); scoox1 = scox1; scox1 = scx1;

	uptr = &scoym3[SCPITCH]; if (uptr == &radar[SCPITCH*9]) uptr = &radar[SCPITCH*6];
	mptr = &uptr[SCPITCH];   if (mptr == &radar[SCPITCH*9]) mptr = &radar[SCPITCH*6];

	if ((x1 < sceox0) || (x0 > sceox1))
	{
		for(x=x0;x<=x1;x++) expandstack(x,scoy-2,&uptr[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0;x<sceox0;x++) expandstack(x,scoy-2,&uptr[x*SCPITCH*3]);
		for(x=x1;x>sceox1;x--) expandstack(x,scoy-2,&uptr[x*SCPITCH*3]);
	}

	if ((scex1|x1) >= 0)
	{
		for(x=x1+2;x<scex0;x++) expandstack(x,scoy-1,&mptr[x*SCPITCH*3]);
		for(x=x0-2;x>scex1;x--) expandstack(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	if ((x1+1 < scex0) || (x0-1 > scex1))
	{
		for(x=x0-1;x<=x1+1;x++) expandstack(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0-1;x<scex0;x++) expandstack(x,scoy-1,&mptr[x*SCPITCH*3]);
		for(x=x1+1;x>scex1;x--) expandstack(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	sceox0 = min(x0-1,scex0);
	sceox1 = max(x1+1,scex1);

	if ((x1 < scx0) || (x0 > scx1))
	{
		for(x=x0;x<=x1;x++) expandstack(x,scoy,&scoym3[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0;x<scx0;x++) expandstack(x,scoy,&scoym3[x*SCPITCH*3]);
		for(x=x1;x>scx1;x--) expandstack(x,scoy,&scoym3[x*SCPITCH*3]);
	}
	scex0 = x0;
	scex1 = x1;

	y = scoy-1; if (y&(~(VSID-1))) return;
	if (x0 < 0) x0 = 0;
	if (x1 >= VSID) x1 = VSID-1;
	i = y*VSID+x0; k = x0*SCPITCH*3;
	for(x=x0;x<=x1;x++,i++,k+=SCPITCH*3)
	{
		v = sptr[i]; vx5.globalmass += v[1];
		while (v[0]) { v += v[0]*4; vx5.globalmass += v[1]-v[3]; }

			//De-allocate column (x,y)
		voxdealloc(sptr[i]);

		j = compilestack(&mptr[k],&mptr[k-SCPITCH*3],&mptr[k+SCPITCH*3],&uptr[k],&scoym3[k],
							  tbuf,x,y);

			//Allocate & copy to new column (x,y)
		sptr[i] = v = voxalloc(j); copybuf((void *)tbuf,(void *)v,j>>2);

		vx5.globalmass -= v[1];
		while (v[0]) { v += v[0]*4; vx5.globalmass += v[3]-v[1]; }
	}
}

	//x: x on voxel map
	//y: y on voxel map
	//z0: highest z on column
	//z1: lowest z(+1) on column
	//nbuf: buffer of color data from nbuf[z0] to nbuf[z1-1];
	//           -3: don't modify voxel
	//           -2: solid voxel (unexposed): to be calculated in compilestack
	//           -1: write air voxel
	//   0-16777215: write solid voxel (exposed)
void scum (long x, long y, long z0, long z1, long *nbuf)
{
	long z, *mptr;

	if ((x|y)&(~(VSID-1))) return;

	if (y != scoy)
	{
		if (scoy >= 0)
		{
			scumline();
			while (scoy < y-1)
			{
				scx0 = 0x7fffffff; scx1 = 0x80000000;
				scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
				scumline();
			}
			scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
		}
		else
		{
			scoox0 = scox0 = 0x7fffffff;
			sceox0 = scex0 = x+1;
			sceox1 = scex1 = x;
			scoy = y; scoym3 = &radar[SCPITCH*6];
		}
		scx0 = x;
	}
	else
	{
		while (scx1 < x-1) { scx1++; expandstack(scx1,y,&scoym3[scx1*SCPITCH*3]); }
	}

	mptr = &scoym3[x*SCPITCH*3]; scx1 = x; expandstack(x,y,mptr);

		//Modify column (x,y):
	if (nbuf[MAXZDIM-1] == -1) nbuf[MAXZDIM-1] = -2; //Bottom voxel must be solid
	for(z=z0;z<z1;z++)
		if (nbuf[z] != -3) mptr[z] = nbuf[z];
}

void scumfinish ()
{
	long i;

	if (scoy == 0x80000000) return;
	for(i=2;i;i--)
	{
		scumline(); scx0 = 0x7fffffff; scx1 = 0x80000000;
		scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
	}
	scumline(); scoy = 0x80000000;
}

	//Example of how to use this code:
	//vx5.colfunc = curcolfunc; //0<x0<x1<VSID, 0<y0<y1<VSID, 0<z0<z1<256,
	//clearbuf((void *)&templongbuf[z0],z1-z0,-1); //Ex: set all voxels to air
	//for(y=y0;y<y1;y++) //MUST iterate x&y in this order, but can skip around
	//   for(x=x0;x<x1;x++)
	//      if (rand()&8) scum(x,y,z0,z1,templongbuf));
	//scumfinish(); //MUST call this when done!

void scum2line ()
{
	long i, j, k, x, y, x0, x1, *mptr, *uptr;
	char *v;

	x0 = min(scox0-1,min(scx0,scoox0)); scoox0 = scox0; scox0 = scx0;
	x1 = max(scox1+1,max(scx1,scoox1)); scoox1 = scox1; scox1 = scx1;

	uptr = &scoym3[SCPITCH]; if (uptr == &radar[SCPITCH*9]) uptr = &radar[SCPITCH*6];
	mptr = &uptr[SCPITCH];   if (mptr == &radar[SCPITCH*9]) mptr = &radar[SCPITCH*6];

	if ((x1 < sceox0) || (x0 > sceox1))
	{
		for(x=x0;x<=x1;x++) expandrle(x,scoy-2,&uptr[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0;x<sceox0;x++) expandrle(x,scoy-2,&uptr[x*SCPITCH*3]);
		for(x=x1;x>sceox1;x--) expandrle(x,scoy-2,&uptr[x*SCPITCH*3]);
	}

	if ((scex1|x1) >= 0)
	{
		for(x=x1+2;x<scex0;x++) expandrle(x,scoy-1,&mptr[x*SCPITCH*3]);
		for(x=x0-2;x>scex1;x--) expandrle(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	if ((x1+1 < scex0) || (x0-1 > scex1))
	{
		for(x=x0-1;x<=x1+1;x++) expandrle(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0-1;x<scex0;x++) expandrle(x,scoy-1,&mptr[x*SCPITCH*3]);
		for(x=x1+1;x>scex1;x--) expandrle(x,scoy-1,&mptr[x*SCPITCH*3]);
	}
	sceox0 = min(x0-1,scex0);
	sceox1 = max(x1+1,scex1);

	if ((x1 < scx0) || (x0 > scx1))
	{
		for(x=x0;x<=x1;x++) expandrle(x,scoy,&scoym3[x*SCPITCH*3]);
	}
	else
	{
		for(x=x0;x<scx0;x++) expandrle(x,scoy,&scoym3[x*SCPITCH*3]);
		for(x=x1;x>scx1;x--) expandrle(x,scoy,&scoym3[x*SCPITCH*3]);
	}
	scex0 = x0;
	scex1 = x1;

	y = scoy-1; if (y&(~(VSID-1))) return;
	if (x0 < 0) x0 = 0;
	if (x1 >= VSID) x1 = VSID-1;
	i = y*VSID+x0; k = x0*SCPITCH*3;
	for(x=x0;x<=x1;x++,i++,k+=SCPITCH*3)
	{
		j = compilerle(&mptr[k],&mptr[k-SCPITCH*3],&mptr[k+SCPITCH*3],&uptr[k],&scoym3[k],
							tbuf,x,y);

		v = sptr[i]; vx5.globalmass += v[1];
		while (v[0]) { v += v[0]*4; vx5.globalmass += v[1]-v[3]; }

			//De-allocate column (x,y)  Note: Must be AFTER compilerle!
		voxdealloc(sptr[i]);

			//Allocate & copy to new column (x,y)
		sptr[i] = v = voxalloc(j); copybuf((void *)tbuf,(void *)v,j>>2);

		vx5.globalmass -= v[1];
		while (v[0]) { v += v[0]*4; vx5.globalmass += v[3]-v[1]; }
	}
}

	//x: x on voxel map
	//y: y on voxel map
	//Returns pointer to rle column (x,y)
long *scum2 (long x, long y)
{
	long *mptr;

	if ((x|y)&(~(VSID-1))) return(0);

	if (y != scoy)
	{
		if (scoy >= 0)
		{
			scum2line();
			while (scoy < y-1)
			{
				scx0 = 0x7fffffff; scx1 = 0x80000000;
				scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
				scum2line();
			}
			scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
		}
		else
		{
			scoox0 = scox0 = 0x7fffffff;
			sceox0 = scex0 = x+1;
			sceox1 = scex1 = x;
			scoy = y; scoym3 = &radar[SCPITCH*6];
		}
		scx0 = x;
	}
	else
	{
		while (scx1 < x-1) { scx1++; expandrle(scx1,y,&scoym3[scx1*SCPITCH*3]); }
	}

	mptr = &scoym3[x*SCPITCH*3]; scx1 = x; expandrle(x,y,mptr);
	return(mptr);
}

void scum2finish ()
{
	long i;

	if (scoy == 0x80000000) return;
	for(i=2;i;i--)
	{
		scum2line(); scx0 = 0x7fffffff; scx1 = 0x80000000;
		scoy++; scoym3 += SCPITCH; if (scoym3 == &radar[SCPITCH*9]) scoym3 = &radar[SCPITCH*6];
	}
	scum2line(); scoy = 0x80000000;
}

//------------------- editing backup / restore begins ------------------------

void voxdontrestore ()
{
	long i;

	if (backedup == 1)
	{
		for(i=(bacx1-bacx0)*(bacy1-bacy0)-1;i>=0;i--) voxdealloc(bacsptr[i]);
	}
	backedup = -1;
}

void voxrestore ()
{
	long i, j, x, y;
	char *v, *daptr;

	if (backedup == 1)
	{
		i = 0;
		for(y=bacy0;y<bacy1;y++)
		{
			j = y*VSID;
			for(x=bacx0;x<bacx1;x++)
			{
				v = sptr[j+x]; vx5.globalmass += v[1];
				while (v[0]) { v += v[0]*4; vx5.globalmass += v[1]-v[3]; }

				voxdealloc(sptr[j+x]);
				sptr[j+x] = bacsptr[i]; i++;

				v = sptr[j+x]; vx5.globalmass -= v[1];
				while (v[0]) { v += v[0]*4; vx5.globalmass += v[3]-v[1]; }
			}
		}
		if (vx5.vxlmipuse > 1) genmipvxl(bacx0,bacy0,bacx1,bacy1);
	}
	else if (backedup == 2)
	{
		daptr = (char *)bacsptr;
		for(y=bacy0;y<bacy1;y++)
		{
			j = y*VSID;
			for(x=bacx0;x<bacx1;x++)
			{
				for(v=sptr[j+x];v[0];v+=v[0]*4)
					for(i=1;i<v[0];i++) v[(i<<2)+3] = *daptr++;
				for(i=1;i<=v[2]-v[1]+1;i++) v[(i<<2)+3] = *daptr++;
			}
		}
		if (vx5.vxlmipuse > 1) genmipvxl(bacx0,bacy0,bacx1,bacy1);
	}
	backedup = -1;
}

void voxbackup (long x0, long y0, long x1, long y1, long tag)
{
	long i, j, n, x, y;
	char *v, *daptr;

	voxdontrestore();

	x0 = max(x0-2,0); y0 = max(y0-2,0);
	x1 = min(x1+2,VSID); y1 = min(y1+2,VSID);
	if ((x1-x0)*(y1-y0) > 262144) return;

	bacx0 = x0; bacy0 = y0; bacx1 = x1; bacy1 = y1; backtag = tag;

	if (tag&0x10000)
	{
		backedup = 1;
		i = 0;
		for(y=bacy0;y<bacy1;y++)
		{
			j = y*VSID;
			for(x=bacx0;x<bacx1;x++)
			{
				bacsptr[i] = v = sptr[j+x]; i++;
				n = slng(v); sptr[j+x] = voxalloc(n);

				copybuf((void *)v,(void *)sptr[j+x],n>>2);
			}
		}
	}
	else if (tag&0x20000)
	{
		backedup = 2;
			//WARNING!!! Right now, function will crash if saving more than
			//   1<<20 colors :( This needs to be addressed!!!
		daptr = (char *)bacsptr;
		for(y=bacy0;y<bacy1;y++)
		{
			j = y*VSID;
			for(x=bacx0;x<bacx1;x++)
			{
				for(v=sptr[j+x];v[0];v+=v[0]*4)
					for(i=1;i<v[0];i++) *daptr++ = v[(i<<2)+3];
				for(i=1;i<=v[2]-v[1]+1;i++) *daptr++ = v[(i<<2)+3];
			}
		}
	}
	else backedup = 0;
}

//-------------------- editing backup / restore ends -------------------------

	//WARNING! Make sure to set vx5.colfunc before calling this function!
	//This function is here for simplicity only - it is NOT optimal.
	//
	//   -1: set air
	//   -2: use vx5.colfunc
void setcube (long px, long py, long pz, long col)
{
	long bakcol, (*bakcolfunc)(lpoint3d *), *lptr;

	vx5.minx = px; vx5.maxx = px+1;
	vx5.miny = py; vx5.maxy = py+1;
	vx5.minz = pz; vx5.maxz = pz+1;
	if ((unsigned long)pz >= MAXZDIM) return;
	if ((unsigned long)col >= (unsigned long)0xfffffffe) //-1 or -2
	{
		lptr = scum2(px,py);
		if (col == -1) delslab(lptr,pz,pz+1); else insslab(lptr,pz,pz+1);
		scum2finish();
		updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,col);
		return;
	}

	bakcol = getcube(px,py,pz);
	if (bakcol == 1) return; //Unexposed solid
	if (bakcol != 0) //Not 0 (air)
		*(long *)bakcol = col;
	else
	{
		bakcolfunc = vx5.colfunc; bakcol = vx5.curcol;
		vx5.colfunc = curcolfunc; vx5.curcol = col;
		insslab(scum2(px,py),pz,pz+1); scum2finish();
		vx5.colfunc = bakcolfunc; vx5.curcol = bakcol;
	}
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

void clearcolumn (long px, long py, long pz, long height)
{
	long bakcol, (*bakcolfunc)(lpoint3d *), *lptr;

  if( pz < 0)
    pz = 0;
  if( pz + height >= MAXZDIM)
    height = MAXZDIM - pz;

	vx5.minx = px; vx5.maxx = px+1;
	vx5.miny = py; vx5.maxy = py+1;
	vx5.minz = pz; vx5.maxz = pz+height;
	if ((unsigned long)pz >= MAXZDIM) return;
	lptr = scum2(px,py);
	delslab(lptr,pz,pz+height);
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,-1);
	return;
}

//-------------------------- SETCOLUMN CODE ENDS ----------------------------

static __int64 qmulmip[8] =
{
	0x7fff7fff7fff7fff,0x4000400040004000,0x2aaa2aaa2aaa2aaa,0x2000200020002000,
	0x1999199919991999,0x1555155515551555,0x1249124912491249,0x1000100010001000
};
static long mixc[MAXZDIM>>1][8]; //4K
static long mixn[MAXZDIM>>1];    //0.5K
void genmipvxl (long x0, long y0, long x1, long y1)
{
	long i, n, oldn, x, y, z, xsiz, ysiz, zsiz, oxsiz, oysiz;
	long cz, oz, nz, zz, besti, cstat, curz[4], curzn[4][4], mipnum, mipmax;
	char *v[4], *tv, **sr, **sw, **ssr, **ssw;

	if ((!(x0|y0)) && (x1 == VSID) && (y1 == VSID)) mipmax = vx5.vxlmipuse;
															 else mipmax = gmipnum;
	if (mipmax <= 0) return;
	mipnum = 1;

	vx5.colfunc = curcolfunc;
	xsiz = VSID; ysiz = VSID; zsiz = MAXZDIM;
	ssr = sptr; ssw = sptr+xsiz*ysiz;
	while ((xsiz > 1) && (ysiz > 1) && (zsiz > 1) && (mipnum < mipmax))
	{
		oxsiz = xsiz; xsiz >>= 1;
		oysiz = ysiz; ysiz >>= 1;
						  zsiz >>= 1;

		x0--; if (x0 < 0) x0 = 0;
		y0--; if (y0 < 0) y0 = 0;
		x1++; if (x1 > VSID) x1 = VSID;
		y1++; if (y1 > VSID) y1 = VSID;

		x0 >>= 1; x1 = ((x1+1)>>1);
		y0 >>= 1; y1 = ((y1+1)>>1);
		for(y=y0;y<y1;y++)
		{
			sr = ssr+oxsiz*(y<<1)+(x0<<1);
			sw = ssw+xsiz*y+x0;
			for(x=x0;x<x1;x++)
			{
					//ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
					//³npt³z1 ³z1c³dum³
					//³ b ³ g ³ r ³ i ³
					//³ b ³ g ³ r ³ i ³
					//³npt³z1 ³z1c³z0 ³
					//³ b ³ g ³ r ³ i ³
					//ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
				v[0] = sr[      0];
				v[1] = sr[      1];
				v[2] = sr[oysiz  ];
				v[3] = sr[oysiz+1];
				for(i=3;i>=0;i--)
				{
					curz[i] = curzn[i][0] = (long)v[i][1];
					curzn[i][1] = ((long)v[i][2])+1;

					tv = v[i];
					while (1)
					{
						oz = (long)tv[1];
						for(z=oz;z<=((long)tv[2]);z++)
						{
							nz = (z>>1);
							mixc[nz][mixn[nz]++] = *(long *)(&tv[((z-oz)<<2)+4]);
						}
						z = (z-oz) - (((long)tv[0])-1);
						if (!tv[0]) break;
						tv += (((long)tv[0])<<2);
						oz = (long)tv[3];
						for(;z<0;z++)
						{
							nz = ((z+oz)>>1);
							mixc[nz][mixn[nz]++] = *(long *)(&tv[z<<2]);
						}
					}
				}
				cstat = 0; oldn = 0; n = 4; tbuf[3] = 0; z = 0x80000000;
				while (1)
				{
					oz = z;

						//z,besti = min,argmin(curz[0],curz[1],curz[2],curz[3])
					besti = (((unsigned long)(curz[1]-curz[    0]))>>31);
						 i = (((unsigned long)(curz[3]-curz[    2]))>>31)+2;
					besti +=(((( signed long)(curz[i]-curz[besti]))>>31)&(i-besti));
					z = curz[besti]; if (z >= MAXZDIM) break;

					if ((!cstat) && ((z>>1) >= ((oz+1)>>1)))
					{
						if (oz >= 0)
						{
							tbuf[oldn] = ((n-oldn)>>2);
							tbuf[oldn+2]--;
							tbuf[n+3] = ((oz+1)>>1);
							oldn = n; n += 4;
						}
						tbuf[oldn] = 0;
						tbuf[oldn+1] = tbuf[oldn+2] = (z>>1); cz = -1;
					}
					if (cstat&0x1111)
					{
						if (((((long)tbuf[oldn+2])<<1)+1 >= oz) && (cz < 0))
						{
							while ((((long)tbuf[oldn+2])<<1) < z)
							{
								zz = (long)tbuf[oldn+2];

								_asm //*(long *)&tbuf[n] = mixc[zz][rand()%mixn[zz]];
								{    //mixn[zz] = 0;
									mov eax, zz
									mov ecx, mixn[eax*4]
									mov mixn[eax*4], 0
									shl eax, 5
									pxor mm0, mm0
									movq mm2, qmulmip[ecx*8-8]
									pcmpeqb mm6, mm6
									movq mm7, mm0
					 vxlmipbeg0:movd mm1, mixc[eax+ecx*4-4]
									punpcklbw mm1, mm7
									paddw mm0, mm1
									dec ecx
									jnz short vxlmipbeg0
									paddw mm0, mm0
									psubw mm0, mm6 ;rounding bias
									pmulhw mm0, mm2
									packuswb mm0, mm0
									mov eax, n
									movd tbuf[eax], mm0
								}

								tbuf[oldn+2]++; n += 4;
							}
						}
						else
						{
							if (cz < 0) cz = (oz>>1);
							else if ((cz<<1)+1 < oz)
							{
									//Insert fake slab
								tbuf[oldn] = ((n-oldn)>>2);
								tbuf[oldn+2]--;
								tbuf[n] = 0;
								tbuf[n+1] = tbuf[n+2] = tbuf[n+3] = cz;
								oldn = n; n += 4;
								cz = (oz>>1);
							}
							while ((cz<<1) < z)
							{
								_asm //*(long *)&tbuf[n] = mixc[cz][rand()%mixn[cz]];
								{    //mixn[cz] = 0;
									mov eax, cz
									mov ecx, mixn[eax*4]
									mov mixn[eax*4], 0
									shl eax, 5
									pxor mm0, mm0
									movq mm2, qmulmip[ecx*8-8]
									pcmpeqb mm6, mm6
									movq mm7, mm0
					 vxlmipbeg1:movd mm1, mixc[eax+ecx*4-4]
									punpcklbw mm1, mm7
									paddw mm0, mm1
									dec ecx
									jnz short vxlmipbeg1
									paddw mm0, mm0
									psubw mm0, mm6 ;rounding bias
									pmulhw mm0, mm2
									packuswb mm0, mm0
									mov eax, n
									movd tbuf[eax], mm0
								}

								cz++; n += 4;
							}
						}
					}

					i = (besti<<2);
					cstat = (((1<<i)+cstat)&0x3333); //--33--22--11--00
					switch ((cstat>>i)&3)
					{
						case 0: curz[besti] = curzn[besti][0]; break;
						case 1: curz[besti] = curzn[besti][1]; break;
						case 2:
							if (!(v[besti][0])) { curz[besti] = MAXZDIM; }
							else
							{
								tv = v[besti]; i = (((long)tv[2])-((long)tv[1])+1)-(((long)tv[0])-1);
								tv += (((long)tv[0])<<2);
								curz[besti] = ((long)(tv[3])) + i;
								curzn[besti][3] = (long)(tv[3]);
								curzn[besti][0] = (long)(tv[1]);
								curzn[besti][1] = ((long)tv[2])+1;
								v[besti] = tv;
							}
							break;
						case 3: curz[besti] = curzn[besti][3]; break;
						//default: __assume(0); //tells MSVC default can't be reached
					}
				}
				tbuf[oldn+2]--;
				if (cz >= 0)
				{
					tbuf[oldn] = ((n-oldn)>>2);
					tbuf[n] = 0;
					tbuf[n+1] = tbuf[n+3] = cz;
					tbuf[n+2] = cz-1;
					n += 4;
				}

					//De-allocate column (x,y) if it exists
				if (sw[0]) voxdealloc(sw[0]);

					//Allocate & copy to new column (x,y)
				sw[0] = voxalloc(n);
				copybuf((void *)tbuf,(void *)sw[0],n>>2);
				sw++; sr += 2;
			}
			sr += ysiz*2;
		}
		ssr = ssw; ssw += xsiz*ysiz;
		mipnum++; if (mipnum > gmipnum) gmipnum = mipnum;
	}

		//Remove extra mips (bbox must be 0,0,VSID,VSID to get inside this)
	while ((xsiz > 1) && (ysiz > 1) && (zsiz > 1) && (mipnum < gmipnum))
	{
		xsiz >>= 1; ysiz >>= 1; zsiz >>= 1;
		for(i=xsiz*ysiz;i>0;i--)
		{
			if (ssw[0]) voxdealloc(ssw[0]); //De-allocate column if it exists
			ssw++;
		}
		gmipnum--;
	}

	_asm emms

#if 0 //TEMP HACK!!!
	{
	FILE *fil;
	dpoint3d dp;
	if (!(fil = fopen("temp512.vxl","wb"))) return;
	i = 0x09072000; fwrite(&i,4,1,fil);  //Version
	i = (VSID>>1); fwrite(&i,4,1,fil);
	i = (VSID>>1); fwrite(&i,4,1,fil);
	dp.x = (double)i*.5; dp.y = (double)i*.5; dp.z = (double)i*.5;
	fwrite(&dp,24,1,fil);
	dp.x = 1.0; dp.y = 0.0; dp.z = 0.0; fwrite(&dp,24,1,fil);
	dp.x = 0.0; dp.y = 0.0; dp.z = 1.0; fwrite(&dp,24,1,fil);
	dp.x = 0.0; dp.y =-1.0; dp.z = 0.0; fwrite(&dp,24,1,fil);
	for(i=0;i<(VSID>>1)*(VSID>>1);i++)
		fwrite((void *)sptr[i+VSID*VSID],slng(sptr[i+VSID*VSID]),1,fil);
	fclose(fil);
	}
	gmipnum = 1;
#endif

}

void setsphere (lpoint3d *hit, long hitrad, long dacol)
{
	void (*modslab)(long *, long, long);
	long i, x, y, xs, ys, zs, xe, ye, ze, sq;
	float f, ff;

	xs = max(hit->x-hitrad,0); xe = min(hit->x+hitrad,VSID-1);
	ys = max(hit->y-hitrad,0); ye = min(hit->y+hitrad,VSID-1);
	zs = max(hit->z-hitrad,0); ze = min(hit->z+hitrad,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;

	if (vx5.colfunc == sphcolfunc)
	{
		vx5.cen = hit->x+hit->y+hit->z;
		vx5.daf = 1.f/(hitrad*sqrt(3.f));
	}

	if (hitrad >= SETSPHMAXRAD-1) hitrad = SETSPHMAXRAD-2;
	if (dacol == -1) modslab = delslab; else modslab = insslab;

	tempfloatbuf[0] = 0.0f;
#if 0
		//Totally unoptimized
	for(i=1;i<=hitrad;i++) tempfloatbuf[i] = pow((float)i,vx5.curpow);
#else
	tempfloatbuf[1] = 1.0f;
	for(i=2;i<=hitrad;i++)
	{
		if (!factr[i][0]) tempfloatbuf[i] = exp(logint[i]*vx5.curpow);
		else tempfloatbuf[i] = tempfloatbuf[factr[i][0]]*tempfloatbuf[factr[i][1]];
	}
#endif
	*(long *)&tempfloatbuf[hitrad+1] = 0x7f7fffff; //3.4028235e38f; //Highest float

	sq = 0; //pow(fabs(x-hit->x),vx5.curpow) + "y + "z < pow(vx5.currad,vx5.curpow)
	for(y=ys;y<=ye;y++)
	{
		ff = tempfloatbuf[hitrad]-tempfloatbuf[labs(y-hit->y)];
		if (*(long *)&ff <= 0) continue;
		for(x=xs;x<=xe;x++)
		{
			f = ff-tempfloatbuf[labs(x-hit->x)]; if (*(long *)&f <= 0) continue;
			while (*(long *)&tempfloatbuf[sq] <  *(long *)&f) sq++;
			while (*(long *)&tempfloatbuf[sq] >= *(long *)&f) sq--;
			modslab(scum2(x,y),max(hit->z-sq,zs),min(hit->z+sq+1,ze));
		}
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

void setellipsoid (lpoint3d *hit, lpoint3d *hit2, long hitrad, long dacol, long bakit)
{
	void (*modslab)(long *, long, long);
	long x, y, xs, ys, zs, xe, ye, ze;
	float a, b, c, d, e, f, g, h, r, t, u, Za, Zb, fx0, fy0, fz0, fx1, fy1, fz1;

	xs = min(hit->x,hit2->x)-hitrad; xs = max(xs,0);
	ys = min(hit->y,hit2->y)-hitrad; ys = max(ys,0);
	zs = min(hit->z,hit2->z)-hitrad; zs = max(zs,0);
	xe = max(hit->x,hit2->x)+hitrad; xe = min(xe,VSID-1);
	ye = max(hit->y,hit2->y)+hitrad; ye = min(ye,VSID-1);
	ze = max(hit->z,hit2->z)+hitrad; ze = min(ze,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze))
		{ if (bakit) voxbackup(xs,ys,xs,ys,bakit); return; }

	fx0 = (float)hit->x; fy0 = (float)hit->y; fz0 = (float)hit->z;
	fx1 = (float)hit2->x; fy1 = (float)hit2->y; fz1 = (float)hit2->z;

	r = (fx1-fx0)*(fx1-fx0) + (fy1-fy0)*(fy1-fy0) + (fz1-fz0)*(fz1-fz0);
	r = sqrt((float)hitrad*(float)hitrad + r*.25);
	c = fz0*fz0 - fz1*fz1; d = r*r*-4; e = d*4;
	f = c*c + fz1*fz1 * e; g = c + c; h = (fz1-fz0)*2; c = c*h - fz1*e;
	Za = -h*h - e; if (Za <= 0) { if (bakit) voxbackup(xs,ys,xs,ys,bakit); return; }
	u = 1 / Za;

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	if (bakit) voxbackup(xs,ys,xe+1,ye+1,bakit);

	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
		{
			a = (x-fx0)*(x-fx0) + (y-fy0)*(y-fy0);
			b = (x-fx1)*(x-fx1) + (y-fy1)*(y-fy1);
			t = a-b+d; Zb = t*h + c;
			t = ((t+g)*t + b*e + f)*Za + Zb*Zb; if (t <= 0) continue;
			t = sqrt(t);
			ftol((Zb - t)*u,&zs); if (zs < 0) zs = 0;
			ftol((Zb + t)*u,&ze); if (ze > MAXZDIM) ze = MAXZDIM;
			modslab(scum2(x,y),zs,ze);
		}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

void setcone (lpoint3d *hit, lpoint3d *hit2, long hitrad, long rad2, long dacol, long bakit)
{
	void (*modslab)(long *, long, long);
	long x, y, xs, ys, zs, xe, ye, ze;
	float a, b, c, d, e, f, g, h, r, t, u, Za, Zb, fx0, fy0, fz0, fx1, fy1, fz1;

	xs = min(hit->x,hit2->x)-hitrad; xs = max(xs,0);
	ys = min(hit->y,hit2->y)-hitrad; ys = max(ys,0);
	zs = min(hit->z,hit2->z)-hitrad; zs = max(zs,0);
	xe = max(hit->x,hit2->x)+hitrad; xe = min(xe,VSID-1);
	ye = max(hit->y,hit2->y)+hitrad; ye = min(ye,VSID-1);
	ze = max(hit->z,hit2->z)+hitrad; ze = min(ze,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze))
		{ if (bakit) voxbackup(xs,ys,xs,ys,bakit); return; }

	fx0 = (float)hit->x; fy0 = (float)hit->y; fz0 = (float)hit->z;
	fx1 = (float)hit2->x; fy1 = (float)hit2->y; fz1 = (float)hit2->z;

	r = (fx1-fx0)*(fx1-fx0) + (fy1-fy0)*(fy1-fy0) + (fz1-fz0)*(fz1-fz0);
	r = sqrt((float)hitrad*(float)hitrad + r*.25);
	c = fz0*fz0 - fz1*fz1; d = r*r*-4; e = d*4;
	f = c*c + fz1*fz1 * e; g = c + c; h = (fz1-fz0)*2; c = c*h - fz1*e;
	Za = -h*h - e; if (Za <= 0) { if (bakit) voxbackup(xs,ys,xs,ys,bakit); return; }
	u = 1 / Za;

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	if (bakit) voxbackup(xs,ys,xe+1,ye+1,bakit);

	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
		{
			a = (x-fx0)*(x-fx0) + (y-fy0)*(y-fy0);
			b = (x-fx1)*(x-fx1) + (y-fy1)*(y-fy1);
			t = a-b+d; Zb = t*h + c;
			t = ((t+g)*t + b*e + f)*Za + Zb*Zb; if (t <= 0) continue;
			t = sqrt(t);
			ftol((Zb - t)*u,&zs); if (zs < 0) zs = 0;
			ftol((Zb + t)*u,&ze); if (ze > MAXZDIM) ze = MAXZDIM;
			modslab(scum2(x,y),zs,ze);
		}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//Draws a cylinder, given: 2 points, a radius, and a color
	//Code mostly optimized - original code from CYLINDER.BAS:drawcylinder
void setcylinder (lpoint3d *p0, lpoint3d *p1, long cr, long dacol, long bakit)
{
	void (*modslab)(long *, long, long);

	float t, ax, ay, az, bx, by, bz, cx, cy, cz, ux, uy, uz, vx, vy, vz;
	float Za, Zb, Zc, tcr, xxyy, rcz, rZa;
	float fx, fxi, xof, vx0, vy0, vz0, vz0i, vxo, vyo, vzo;
	long i, j, ix, iy, ix0, ix1, iz0, iz1, minx, maxx, miny, maxy;
	long x0, y0, z0, x1, y1, z1;

		//Map generic cylinder into unit space:  (0,0,0), (0,0,1), cr = 1
		//   x*x + y*y < 1, z >= 0, z < 1
	if (p0->z > p1->z)
	{
		x0 = p1->x; y0 = p1->y; z0 = p1->z;
		x1 = p0->x; y1 = p0->y; z1 = p0->z;
	}
	else
	{
		x0 = p0->x; y0 = p0->y; z0 = p0->z;
		x1 = p1->x; y1 = p1->y; z1 = p1->z;
	}

	xxyy = (float)((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0));
	t = xxyy + (float)(z1-z0)*(z1-z0);
	if ((t == 0) || (cr == 0))
	{
		vx5.minx = x0; vx5.maxx = x0+1;
		vx5.miny = y0; vx5.maxy = y0+1;
		vx5.minz = z0; vx5.maxz = z0+1;
		if (bakit) voxbackup(x0,y0,x0,y0,bakit);
		return;
	}
	t = 1 / t; cx = ((float)(x1-x0))*t; cy = ((float)(y1-y0))*t; cz = ((float)(z1-z0))*t;
	t = sqrt(t); ux = ((float)(x1-x0))*t; uy = ((float)(y1-y0))*t; uz = ((float)(z1-z0))*t;

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	if (xxyy == 0)
	{
		iz0 = max(z0,0); iz1 = min(z1,MAXZDIM);
		minx = max(x0-cr,0); maxx = min(x0+cr,VSID-1);
		miny = max(y0-cr,0); maxy = min(y0+cr,VSID-1);

		vx5.minx = minx; vx5.maxx = maxx+1;
		vx5.miny = miny; vx5.maxy = maxy+1;
		vx5.minz = iz0; vx5.maxz = iz1;
		if (bakit) voxbackup(minx,miny,maxx+1,maxy+1,bakit);

		j = cr*cr;
		for(iy=miny;iy<=maxy;iy++)
		{
			i = j-(iy-y0)*(iy-y0);
			for(ix=minx;ix<=maxx;ix++)
				if ((ix-x0)*(ix-x0) < i) modslab(scum2(ix,iy),iz0,iz1);
		}
		scum2finish();
		updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
		return;
	}

	if (x0 < x1) { minx = x0; maxx = x1; } else { minx = x1; maxx = x0; }
	if (y0 < y1) { miny = y0; maxy = y1; } else { miny = y1; maxy = y0; }
	tcr = cr / sqrt(xxyy); vx = fabs((float)(x1-x0))*tcr; vy = fabs((float)(y1-y0))*tcr;
	t = vx*uz + vy;
	ftol((float)minx-t,&minx); if (minx < 0) minx = 0;
	ftol((float)maxx+t,&maxx); if (maxx >= VSID) maxx = VSID-1;
	t = vy*uz + vx;
	ftol((float)miny-t,&miny); if (miny < 0) miny = 0;
	ftol((float)maxy+t,&maxy); if (maxy >= VSID) maxy = VSID-1;

	vx5.minx = minx; vx5.maxx = maxx+1;
	vx5.miny = miny; vx5.maxy = maxy+1;
	vx5.minz = z0-cr; vx5.maxz = z1+cr+1;
	if (bakit) voxbackup(minx,miny,maxx+1,maxy+1,bakit);

	vx = (fabs(ux) < fabs(uy)); vy = 1.0f-vx; vz = 0;
	ax = uy*vz - uz*vy; ay = uz*vx - ux*vz; az = ux*vy - uy*vx;
	t = 1.0 / (sqrt(ax*ax + ay*ay + az*az)*cr);
	ax *= t; ay *= t; az *= t;
	bx = ay*uz - az*uy; by = az*ux - ax*uz; bz = ax*uy - ay*ux;

	Za = az*az + bz*bz; rZa = 1.0f / Za;
	if (cz != 0) { rcz = 1.0f / cz; vz0i = -rcz*cx; }
	if (y0 != y1)
	{
		t = 1.0f / ((float)(y1-y0)); fxi = ((float)(x1-x0))*t;
		fx = ((float)miny-y0)*fxi + x0; xof = fabs(tcr*xxyy*t);
	}
	else { fx = (float)minx; fxi = 0.0; xof = (float)(maxx-minx); }

	vy = (float)(miny-y0);
	vxo = vy*ay - z0*az;
	vyo = vy*by - z0*bz;
	vzo = vy*cy - z0*cz;
	for(iy=miny;iy<=maxy;iy++)
	{
		ftol(fx-xof,&ix0); if (ix0 < minx) ix0 = minx;
		ftol(fx+xof,&ix1); if (ix1 > maxx) ix1 = maxx;
		fx += fxi;

		vx = (float)(ix0-x0);
		vx0 = vx*ax + vxo; vxo += ay;
		vy0 = vx*bx + vyo; vyo += by;
		vz0 = vx*cx + vzo; vzo += cy;

		if (cz != 0)   //(vx0 + vx1*t)ý + (vy0 + vy1*t)ý = 1
		{
			vz0 *= -rcz;
			for(ix=ix0;ix<=ix1;ix++,vx0+=ax,vy0+=bx,vz0+=vz0i)
			{
				Zb = vx0*az + vy0*bz; Zc = vx0*vx0 + vy0*vy0 - 1;
				t = Zb*Zb - Za*Zc; if (*(long *)&t <= 0) continue; t = sqrt(t);
				ftol(max((-Zb-t)*rZa,vz0    ),&iz0); if (iz0 < 0) iz0 = 0;
				ftol(min((-Zb+t)*rZa,vz0+rcz),&iz1); if (iz1 > MAXZDIM) iz1 = MAXZDIM;
				modslab(scum2(ix,iy),iz0,iz1);
			}
		}
		else
		{
			for(ix=ix0;ix<=ix1;ix++,vx0+=ax,vy0+=bx,vz0+=cx)
			{
				if (*(unsigned long *)&vz0 >= 0x3f800000) continue; //vz0<0||vz0>=1
				Zb = vx0*az + vy0*bz; Zc = vx0*vx0 + vy0*vy0 - 1;
				t = Zb*Zb - Za*Zc; if (*(long *)&t <= 0) continue; t = sqrt(t);
				ftol((-Zb-t)*rZa,&iz0); if (iz0 < 0) iz0 = 0;
				ftol((-Zb+t)*rZa,&iz1); if (iz1 > MAXZDIM) iz1 = MAXZDIM;
				modslab(scum2(ix,iy),iz0,iz1);
			}
		}
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//Draws a rectangle, given: 2 points as opposite corners, and a color
void setrect (lpoint3d *hit, lpoint3d *hit2, long dacol)
{
	long x, y, xs, ys, zs, xe, ye, ze;

		//WARNING: do NOT use lbound because 'c' not guaranteed to be >= 'b'
	xs = max(min(hit->x,hit2->x),0); xe = min(max(hit->x,hit2->x),VSID-1);
	ys = max(min(hit->y,hit2->y),0); ye = min(max(hit->y,hit2->y),VSID-1);
	zs = max(min(hit->z,hit2->z),0); ze = min(max(hit->z,hit2->z),MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	ze++;
	if (dacol == -1)
	{
		for(y=ys;y<=ye;y++)
			for(x=xs;x<=xe;x++)
				delslab(scum2(x,y),zs,ze);
	}
	else
	{
		for(y=ys;y<=ye;y++)
			for(x=xs;x<=xe;x++)
				insslab(scum2(x,y),zs,ze);
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//Does CSG using pre-sorted spanlist
void setspans (vspans *lst, long lstnum, lpoint3d *offs, long dacol)
{
	void (*modslab)(long *, long, long);
	long i, j, x, y, z0, z1, *lptr;
	char ox, oy;

	if (lstnum <= 0) return;
	if (dacol == -1) modslab = delslab; else modslab = insslab;
	vx5.minx = vx5.maxx = ((long)lst[0].x)+offs->x;
	vx5.miny = ((long)lst[       0].y)+offs->y;
	vx5.maxy = ((long)lst[lstnum-1].y)+offs->y+1;
	vx5.minz = vx5.maxz = ((long)lst[0].z0)+offs->z;

	i = 0; goto in2setlist;
	do
	{
		if ((ox != lst[i].x) || (oy != lst[i].y))
		{
in2setlist:;
			ox = lst[i].x; oy = lst[i].y;
			x = ((long)lst[i].x)+offs->x;
			y = ((long)lst[i].y)+offs->y;
				  if (x < vx5.minx) vx5.minx = x;
			else if (x > vx5.maxx) vx5.maxx = x;
			lptr = scum2(x,y);
		}
		if ((x|y)&(~(VSID-1))) { i++; continue; }
		z0 = ((long)lst[i].z0)+offs->z;   if (z0 < 0) z0 = 0;
		z1 = ((long)lst[i].z1)+offs->z+1; if (z1 > MAXZDIM) z1 = MAXZDIM;
		if (z0 < vx5.minz) vx5.minz = z0;
		if (z1 > vx5.maxz) vx5.maxz = z1;
		modslab(lptr,z0,z1);
		i++;
	} while (i < lstnum);
	vx5.maxx++; vx5.maxz++;
	if (vx5.minx < 0) vx5.minx = 0;
	if (vx5.miny < 0) vx5.miny = 0;
	if (vx5.maxx > VSID) vx5.maxx = VSID;
	if (vx5.maxy > VSID) vx5.maxy = VSID;

	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

void setheightmap (const unsigned char *hptr, long hpitch, long hxdim, long hydim,
						 long x0, long y0, long x1, long y1)
{
	long x, y, su, sv, u, v;

	if (x0 < 0) x0 = 0;
	if (y0 < 0) y0 = 0;
	if (x1 > VSID) x1 = VSID;
	if (y1 > VSID) y1 = VSID;
	vx5.minx = x0; vx5.maxx = x1;
	vx5.miny = y0; vx5.maxy = y1;
	vx5.minz = 0; vx5.maxz = MAXZDIM;
	if ((x0 >= x1) || (y0 >= y1)) return;

	su = x0%hxdim; sv = y0%hydim;
	for(y=y0,v=sv;y<y1;y++)
	{
		for(x=x0,u=su;x<x1;x++)
		{
			insslab(scum2(x,y),hptr[v*hpitch+u],MAXZDIM);
			u++; if (u >= hxdim) u = 0;
		}
		v++; if (v >= hydim) v = 0;
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

static long min0[VSID], max0[VSID]; //MAXY
static long min1[VSID], max1[VSID]; //MAXX
static long min2[VSID], max2[VSID]; //MAXY

static void canseerange (point3d *p0, point3d *p1)
{
	lpoint3d a, c, d, p, i;
	point3d f, g;
	long cnt, j;

	ftol(p0->x-.5,&a.x); ftol(p0->y-.5,&a.y); ftol(p0->z-.5,&a.z);
	ftol(p1->x-.5,&c.x); ftol(p1->y-.5,&c.y); ftol(p1->z-.5,&c.z);
	cnt = 0;

		  if (c.x <  a.x) { d.x = -1; f.x = p0->x-a.x;   g.x = (p0->x-p1->x)*1024; cnt += a.x-c.x; }
	else if (c.x != a.x) { d.x =  1; f.x = a.x+1-p0->x; g.x = (p1->x-p0->x)*1024; cnt += c.x-a.x; }
	else f.x = g.x = 0;
		  if (c.y <  a.y) { d.y = -1; f.y = p0->y-a.y;   g.y = (p0->y-p1->y)*1024; cnt += a.y-c.y; }
	else if (c.y != a.y) { d.y =  1; f.y = a.y+1-p0->y; g.y = (p1->y-p0->y)*1024; cnt += c.y-a.y; }
	else f.y = g.y = 0;
		  if (c.z <  a.z) { d.z = -1; f.z = p0->z-a.z;   g.z = (p0->z-p1->z)*1024; cnt += a.z-c.z; }
	else if (c.z != a.z) { d.z =  1; f.z = a.z+1-p0->z; g.z = (p1->z-p0->z)*1024; cnt += c.z-a.z; }
	else f.z = g.z = 0;

	ftol(f.x*g.z - f.z*g.x,&p.x); ftol(g.x,&i.x);
	ftol(f.y*g.z - f.z*g.y,&p.y); ftol(g.y,&i.y);
	ftol(f.y*g.x - f.x*g.y,&p.z); ftol(g.z,&i.z);
	for(;cnt;cnt--)
	{
			//use a.x, a.y, a.z
		if (a.x < min0[a.y]) min0[a.y] = a.x;
		if (a.x > max0[a.y]) max0[a.y] = a.x;
		if (a.z < min1[a.x]) min1[a.x] = a.z;
		if (a.z > max1[a.x]) max1[a.x] = a.z;
		if (a.z < min2[a.y]) min2[a.y] = a.z;
		if (a.z > max2[a.y]) max2[a.y] = a.z;

		if (((p.x|p.y) >= 0) && (a.z != c.z)) { a.z += d.z; p.x -= i.x; p.y -= i.y; }
		else if ((p.z >= 0) && (a.x != c.x))  { a.x += d.x; p.x += i.z; p.z -= i.y; }
		else                                  { a.y += d.y; p.y += i.z; p.z += i.x; }
	}
}

void settri (point3d *p0, point3d *p1, point3d *p2, long bakit)
{
	point3d n;
	float f, x0, y0, z0, x1, y1, z1, rx, ry, k0, k1;
	long i, x, y, z, iz0, iz1, minx, maxx, miny, maxy;

	if (p0->x < p1->x) { x0 = p0->x; x1 = p1->x; } else { x0 = p1->x; x1 = p0->x; }
	if (p2->x < x0) x0 = p2->x;
	if (p2->x > x1) x1 = p2->x;
	if (p0->y < p1->y) { y0 = p0->y; y1 = p1->y; } else { y0 = p1->y; y1 = p0->y; }
	if (p2->y < y0) y0 = p2->y;
	if (p2->y > y1) y1 = p2->y;
	if (p0->z < p1->z) { z0 = p0->z; z1 = p1->z; } else { z0 = p1->z; z1 = p0->z; }
	if (p2->z < z0) z0 = p2->z;
	if (p2->z > z1) z1 = p2->z;

	ftol(x0-.5,&minx); ftol(y0-.5,&miny);
	ftol(x1-.5,&maxx); ftol(y1-.5,&maxy);
	vx5.minx = minx; vx5.maxx = maxx+1;
	vx5.miny = miny; vx5.maxy = maxy+1;
	ftol(z0-.5,&vx5.minz); ftol(z1+.5,&vx5.maxz);
	if (bakit) voxbackup(minx,miny,maxx+1,maxy+1,bakit);

	for(i=miny;i<=maxy;i++) { min0[i] = 0x7fffffff; max0[i] = 0x80000000; }
	for(i=minx;i<=maxx;i++) { min1[i] = 0x7fffffff; max1[i] = 0x80000000; }
	for(i=miny;i<=maxy;i++) { min2[i] = 0x7fffffff; max2[i] = 0x80000000; }

	canseerange(p0,p1);
	canseerange(p1,p2);
	canseerange(p2,p0);

	n.x = (p1->z-p0->z)*(p2->y-p1->y) - (p1->y-p0->y) * (p2->z-p1->z);
	n.y = (p1->x-p0->x)*(p2->z-p1->z) - (p1->z-p0->z) * (p2->x-p1->x);
	n.z = (p1->y-p0->y)*(p2->x-p1->x) - (p1->x-p0->x) * (p2->y-p1->y);
	f = 1.0 / sqrt(n.x*n.x + n.y*n.y + n.z*n.z); if (n.z < 0) f = -f;
	n.x *= f; n.y *= f; n.z *= f;

	if (n.z > .01)
	{
		f = -1.0 / n.z; rx = n.x*f; ry = n.y*f;
		k0 = ((n.x>=0)-p0->x)*rx + ((n.y>=0)-p0->y)*ry - ((n.z>=0)-p0->z) + .5;
		k1 = ((n.x< 0)-p0->x)*rx + ((n.y< 0)-p0->y)*ry - ((n.z< 0)-p0->z) - .5;
	}
	else { rx = 0; ry = 0; k0 = -2147000000.0; k1 = 2147000000.0; }

	for(y=miny;y<=maxy;y++)
		for(x=min0[y];x<=max0[y];x++)
		{
			f = (float)x*rx + (float)y*ry; ftol(f+k0,&iz0); ftol(f+k1,&iz1);
			if (iz0 < min1[x]) iz0 = min1[x];
			if (iz1 > max1[x]) iz1 = max1[x];
			if (iz0 < min2[y]) iz0 = min2[y];
			if (iz1 > max2[y]) iz1 = max2[y];

				//set: (x,y,iz0) to (x,y,iz1) (inclusive)
			insslab(scum2(x,y),iz0,iz1+1);
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

	//Known problems:
	//1. Need to test faces for intersections on p1<->p2 line (not just edges)
	//2. Doesn't guarantee that hit point/line is purely air (but very close)
	//3. Piescan is more useful for parts of rope code :/
static long tripind[24] = {0,4,1,5,2,6,3,7,0,2,1,3,4,6,5,7,0,1,2,3,4,5,6,7};
long triscan (point3d *p0, point3d *p1, point3d *p2, point3d *hit, lpoint3d *lhit)
{
	point3d n, d[8], cp2;
	float f, g, x0, x1, y0, y1, rx, ry, k0, k1, fx, fy, fz, pval[8];
	long i, j, k, x, y, z, iz0, iz1, minx, maxx, miny, maxy, didhit;

	didhit = 0;

	if (p0->x < p1->x) { x0 = p0->x; x1 = p1->x; } else { x0 = p1->x; x1 = p0->x; }
	if (p2->x < x0) x0 = p2->x;
	if (p2->x > x1) x1 = p2->x;
	if (p0->y < p1->y) { y0 = p0->y; y1 = p1->y; } else { y0 = p1->y; y1 = p0->y; }
	if (p2->y < y0) y0 = p2->y;
	if (p2->y > y1) y1 = p2->y;
	ftol(x0-.5,&minx); ftol(y0-.5,&miny);
	ftol(x1-.5,&maxx); ftol(y1-.5,&maxy);
	for(i=miny;i<=maxy;i++) { min0[i] = 0x7fffffff; max0[i] = 0x80000000; }
	for(i=minx;i<=maxx;i++) { min1[i] = 0x7fffffff; max1[i] = 0x80000000; }
	for(i=miny;i<=maxy;i++) { min2[i] = 0x7fffffff; max2[i] = 0x80000000; }

	canseerange(p0,p1);
	canseerange(p1,p2);
	canseerange(p2,p0);

	n.x = (p1->z-p0->z)*(p2->y-p1->y) - (p1->y-p0->y) * (p2->z-p1->z);
	n.y = (p1->x-p0->x)*(p2->z-p1->z) - (p1->z-p0->z) * (p2->x-p1->x);
	n.z = (p1->y-p0->y)*(p2->x-p1->x) - (p1->x-p0->x) * (p2->y-p1->y);
	f = 1.0 / sqrt(n.x*n.x + n.y*n.y + n.z*n.z); if (n.z < 0) f = -f;
	n.x *= f; n.y *= f; n.z *= f;

	if (n.z > .01)
	{
		f = -1.0 / n.z; rx = n.x*f; ry = n.y*f;
		k0 = ((n.x>=0)-p0->x)*rx + ((n.y>=0)-p0->y)*ry - ((n.z>=0)-p0->z) + .5;
		k1 = ((n.x< 0)-p0->x)*rx + ((n.y< 0)-p0->y)*ry - ((n.z< 0)-p0->z) - .5;
	}
	else { rx = 0; ry = 0; k0 = -2147000000.0; k1 = 2147000000.0; }

	cp2.x = p2->x; cp2.y = p2->y; cp2.z = p2->z;

	for(y=miny;y<=maxy;y++)
		for(x=min0[y];x<=max0[y];x++)
		{
			f = (float)x*rx + (float)y*ry; ftol(f+k0,&iz0); ftol(f+k1,&iz1);
			if (iz0 < min1[x]) iz0 = min1[x];
			if (iz1 > max1[x]) iz1 = max1[x];
			if (iz0 < min2[y]) iz0 = min2[y];
			if (iz1 > max2[y]) iz1 = max2[y];
			for(z=iz0;z<=iz1;z++)
			{
				if (!isvoxelsolid(x,y,z)) continue;

				for(i=0;i<8;i++)
				{
					d[i].x = (float)(( i    &1)+x);
					d[i].y = (float)(((i>>1)&1)+y);
					d[i].z = (float)(((i>>2)&1)+z);
					pval[i] = (d[i].x-p0->x)*n.x + (d[i].y-p0->y)*n.y + (d[i].z-p0->z)*n.z;
				}
				for(i=0;i<24;i+=2)
				{
					j = tripind[i+0];
					k = tripind[i+1];
					if (((*(long *)&pval[j])^(*(long *)&pval[k])) < 0)
					{
						f = pval[j]/(pval[j]-pval[k]);
						fx = (d[k].x-d[j].x)*f + d[j].x;
						fy = (d[k].y-d[j].y)*f + d[j].y;
						fz = (d[k].z-d[j].z)*f + d[j].z;

							//         (p0->x,p0->y,p0->z)
							//             _|     |_
							//           _|     .   |_
							//         _|  (fx,fy,fz) |_
							//       _|                 |_
							//(p1->x,p1->y,p1->z)-.----(cp2.x,cp2.y,cp2.z)
	
						if ((fabs(n.z) > fabs(n.x)) && (fabs(n.z) > fabs(n.y)))
						{ //x,y
						  // ix = p1->x + (cp2.x-p1->x)*t;
						  // iy = p1->y + (cp2.y-p1->y)*t;
						  //(iz = p1->z + (cp2.z-p1->z)*t;)
						  // ix = p0->x + (fx-p0->x)*u;
						  // iy = p0->y + (fy-p0->y)*u;
						  // (p1->x-cp2.x)*t + (fx-p0->x)*u = p1->x-p0->x;
						  // (p1->y-cp2.y)*t + (fy-p0->y)*u = p1->y-p0->y;
	
							f = (p1->x-cp2.x)*(fy-p0->y) - (p1->y-cp2.y)*(fx-p0->x);
							if ((*(long *)&f) == 0) continue;
							f = 1.0 / f;
							g = ((p1->x-cp2.x)*(p1->y-p0->y) - (p1->y-cp2.y)*(p1->x-p0->x))*f;
							//NOTE: The following trick assumes g not * or / by f!
							//if (((*(long *)&g)-(*(long *)&f))^(*(long *)&f)) >= 0) continue;
							if ((*(long *)&g) < 0x3f800000) continue;
							g = ((p1->x-p0->x)*(fy-p0->y) - (p1->y-p0->y)*(fx-p0->x))*f;
						}
						else if (fabs(n.y) > fabs(n.x))
						{ //x,z
							f = (p1->x-cp2.x)*(fz-p0->z) - (p1->z-cp2.z)*(fx-p0->x);
							if ((*(long *)&f) == 0) continue;
							f = 1.0 / f;
							g = ((p1->x-cp2.x)*(p1->z-p0->z) - (p1->z-cp2.z)*(p1->x-p0->x))*f;
							if ((*(long *)&g) < 0x3f800000) continue;
							g = ((p1->x-p0->x)*(fz-p0->z) - (p1->z-p0->z)*(fx-p0->x))*f;
						}
						else
						{ //y,z
							f = (p1->y-cp2.y)*(fz-p0->z) - (p1->z-cp2.z)*(fy-p0->y);
							if ((*(long *)&f) == 0) continue;
							f = 1.0 / f;
							g = ((p1->y-cp2.y)*(p1->z-p0->z) - (p1->z-cp2.z)*(p1->y-p0->y))*f;
							if ((*(long *)&g) < 0x3f800000) continue;
							g = ((p1->y-p0->y)*(fz-p0->z) - (p1->z-p0->z)*(fy-p0->y))*f;
						}
						if ((*(unsigned long *)&g) >= 0x3f800000) continue;
						(hit->x) = fx; (hit->y) = fy; (hit->z) = fz;
						(lhit->x) = x; (lhit->y) = y; (lhit->z) = z; didhit = 1;
						(cp2.x) = (cp2.x-p1->x)*g + p1->x;
						(cp2.y) = (cp2.y-p1->y)*g + p1->y;
						(cp2.z) = (cp2.z-p1->z)*g + p1->z;
					}
				}
			}
		}
	return(didhit);
}

// ------------------------ CONVEX 3D HULL CODE BEGINS ------------------------

#define MAXPOINTS (256 *2) //Leave the *2 here for safety!
point3d nm[MAXPOINTS*2+2];
float nmc[MAXPOINTS*2+2];
long tri[MAXPOINTS*8+8], lnk[MAXPOINTS*8+8], tricnt;
char umost[VSID*VSID], dmost[VSID*VSID];

void initetrasid (point3d *pt, long z)
{
	long i, j, k;
	float x0, y0, z0, x1, y1, z1;

	i = tri[z*4]; j = tri[z*4+1]; k = tri[z*4+2];
	x0 = pt[i].x-pt[k].x; y0 = pt[i].y-pt[k].y; z0 = pt[i].z-pt[k].z;
	x1 = pt[j].x-pt[k].x; y1 = pt[j].y-pt[k].y; z1 = pt[j].z-pt[k].z;
	nm[z].x = y0*z1 - z0*y1;
	nm[z].y = z0*x1 - x0*z1;
	nm[z].z = x0*y1 - y0*x1;
	nmc[z] = nm[z].x*pt[k].x + nm[z].y*pt[k].y + nm[z].z*pt[k].z;
}

void inithull3d (point3d *pt, long nump)
{
	float px, py, pz;
	long i, k, s, z, szz, zz, zx, snzz, nzz, zzz, otricnt;

	tri[0] = 0; tri[4] = 0; tri[8] = 0; tri[12] = 1;
	tri[1] = 1; tri[2] = 2; initetrasid(pt,0);
	if (nm[0].x*pt[3].x + nm[0].y*pt[3].y + nm[0].z*pt[3].z >= nmc[0])
	{
		tri[1] = 1; tri[2] = 2; lnk[0] = 10; lnk[1] = 14; lnk[2] = 4;
		tri[5] = 2; tri[6] = 3; lnk[4] = 2; lnk[5] = 13; lnk[6] = 8;
		tri[9] = 3; tri[10] = 1; lnk[8] = 6; lnk[9] = 12; lnk[10] = 0;
		tri[13] = 3; tri[14] = 2; lnk[12] = 9; lnk[13] = 5; lnk[14] = 1;
	}
	else
	{
		tri[1] = 2; tri[2] = 1; lnk[0] = 6; lnk[1] = 12; lnk[2] = 8;
		tri[5] = 3; tri[6] = 2; lnk[4] = 10; lnk[5] = 13; lnk[6] = 0;
		tri[9] = 1; tri[10] = 3; lnk[8] = 2; lnk[9] = 14; lnk[10] = 4;
		tri[13] = 2; tri[14] = 3; lnk[12] = 1; lnk[13] = 5; lnk[14] = 9;
	}
	tricnt = 4*4;

	for(z=0;z<4;z++) initetrasid(pt,z);

	for(z=4;z<nump;z++)
	{
		px = pt[z].x; py = pt[z].y; pz = pt[z].z;
		for(zz=tricnt-4;zz>=0;zz-=4)
		{
			i = (zz>>2);
			if (nm[i].x*px + nm[i].y*py + nm[i].z*pz >= nmc[i]) continue;

			s = 0;
			for(zx=2;zx>=0;zx--)
			{
				i = (lnk[zz+zx]>>2);
				s += (nm[i].x*px + nm[i].y*py + nm[i].z*pz < nmc[i]) + s;
			}
			if (s == 7) continue;

			nzz = ((0x4a4>>(s+s))&3); szz = zz; otricnt = tricnt;
			do
			{
				snzz = nzz;
				do
				{
					zzz = nzz+1; if (zzz >= 3) zzz = 0;

						//Insert triangle tricnt: (p0,p1,z)
					tri[tricnt+0] = tri[zz+nzz];
					tri[tricnt+1] = tri[zz+zzz];
					tri[tricnt+2] = z;
					initetrasid(pt,tricnt>>2);
					k = lnk[zz+nzz]; lnk[tricnt] = k; lnk[k] = tricnt;
					lnk[tricnt+1] = tricnt+6;
					lnk[tricnt+2] = tricnt-3;
					tricnt += 4;

						//watch out for loop inside single triangle
					if (zzz == snzz) goto endit;
					nzz = zzz;
				} while (!(s&(1<<zzz)));
				do
				{
					i = zz+nzz;
					zz = (lnk[i]&~3);
					nzz = (lnk[i]&3)+1; if (nzz == 3) nzz = 0;
					s = 0;
					for(zx=2;zx>=0;zx--)
					{
						i = (lnk[zz+zx]>>2);
						s += (nm[i].x*px + nm[i].y*py + nm[i].z*pz < nmc[i]) + s;
					}
				} while (s&(1<<nzz));
			} while (zz != szz);
endit:;  lnk[tricnt-3] = otricnt+2; lnk[otricnt+2] = tricnt-3;

			for(zz=otricnt-4;zz>=0;zz-=4)
			{
				i = (zz>>2);
				if (nm[i].x*px + nm[i].y*py + nm[i].z*pz < nmc[i])
				{
					tricnt -= 4; //Delete triangle zz%
					nm[i] = nm[tricnt>>2]; nmc[i] = nmc[tricnt>>2];
					for(i=0;i<3;i++)
					{
						tri[zz+i] = tri[tricnt+i];
						lnk[zz+i] = lnk[tricnt+i];
						lnk[lnk[zz+i]] = zz+i;
					}
				}
			}
			break;
		}
	}
	tricnt >>= 2;
}

static long incmod3[3];
void tmaphulltrisortho (point3d *pt)
{
	point3d *i0, *i1;
	float r, knmx, knmy, knmc, xinc;
	long i, k, op, p, pe, y, yi, z, zi, sy, sy1, itop, ibot, damost;

	for(k=0;k<tricnt;k++)
	{
		if (nm[k].z >= 0)
			{ damost = (long)umost; incmod3[0] = 1; incmod3[1] = 2; incmod3[2] = 0; }
		else
			{ damost = (long)dmost; incmod3[0] = 2; incmod3[1] = 0; incmod3[2] = 1; }

		itop = (pt[tri[(k<<2)+1]].y < pt[tri[k<<2]].y); ibot = 1-itop;
			  if (pt[tri[(k<<2)+2]].y < pt[tri[(k<<2)+itop]].y) itop = 2;
		else if (pt[tri[(k<<2)+2]].y > pt[tri[(k<<2)+ibot]].y) ibot = 2;

			//Pre-calculations
		if (fabs(nm[k].z) < .000001) r = 0; else r = -65536.0 / nm[k].z;
		knmx = nm[k].x*r; knmy = nm[k].y*r;
		//knmc = 65536.0-nmc[k]*r-knmx-knmy;
		//knmc = -nmc[k]*r-(knmx+knmy)*.5f;
		knmc = /*65536.0*/  -nmc[k]*r+knmx;
		ftol(knmx,&zi);

		i = ibot;
		do
		{
			i1 = &pt[tri[(k<<2)+i]]; ftol(i1->y,&sy1); i = incmod3[i];
			i0 = &pt[tri[(k<<2)+i]]; ftol(i0->y,&sy); if (sy == sy1) continue;
			xinc = (i1->x-i0->x)/(i1->y-i0->y);
			ftol((((float)sy-i0->y)*xinc+i0->x)*65536,&y); ftol(xinc*65536,&yi);
			for(;sy<sy1;sy++,y+=yi) lastx[sy] = (y>>16);
		} while (i != itop);
		do
		{
			i0 = &pt[tri[(k<<2)+i]]; ftol(i0->y,&sy); i = incmod3[i];
			i1 = &pt[tri[(k<<2)+i]]; ftol(i1->y,&sy1); if (sy == sy1) continue;
			xinc = (i1->x-i0->x)/(i1->y-i0->y);
			ftol((((float)sy-i0->y)*xinc+i0->x)*65536,&y); ftol(xinc*65536,&yi);
			op = sy*VSID+damost;
			for(;sy<sy1;sy++,y+=yi,op+=VSID)
			{
				ftol(knmx*(float)lastx[sy] + knmy*(float)sy + knmc,&z);
				pe = (y>>16)+op; p = lastx[sy]+op;
				for(;p<pe;p++,z+=zi) *(char *)p = (z>>16);
			}
		} while (i != ibot);
	}
}

void sethull3d (point3d *pt, long nump, long dacol, long bakit)
{
	void (*modslab)(long *, long, long);
	float fminx, fminy, fminz, fmaxx, fmaxy, fmaxz;
	long i, x, y, xs, ys, xe, ye, z0, z1;

	if (nump > (MAXPOINTS>>1)) nump = (MAXPOINTS>>1); //DANGER!!!

	fminx = fminy = VSID; fminz = MAXZDIM; fmaxx = fmaxy = fmaxz = 0;
	for(i=0;i<nump;i++)
	{
		pt[i].x = min(max(pt[i].x,0),VSID-1);
		pt[i].y = min(max(pt[i].y,0),VSID-1);
		pt[i].z = min(max(pt[i].z,0),MAXZDIM-1);

		if (pt[i].x < fminx) fminx = pt[i].x;
		if (pt[i].y < fminy) fminy = pt[i].y;
		if (pt[i].z < fminz) fminz = pt[i].z;
		if (pt[i].x > fmaxx) fmaxx = pt[i].x;
		if (pt[i].y > fmaxy) fmaxy = pt[i].y;
		if (pt[i].z > fmaxz) fmaxz = pt[i].z;
	}

	ftol(fminx,&xs); if (xs < 0) xs = 0;
	ftol(fminy,&ys); if (ys < 0) ys = 0;
	ftol(fmaxx,&xe); if (xe >= VSID) xe = VSID-1;
	ftol(fmaxy,&ye); if (ye >= VSID) ye = VSID-1;
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	ftol(fminz-.5,&vx5.minz); ftol(fmaxz+.5,&vx5.maxz);
	if ((xs > xe) || (ys > ye))
		{ if (bakit) voxbackup(xs,ys,xs,ys,bakit); return; }
	if (bakit) voxbackup(xs,ys,xe,ye,bakit);

	i = ys*VSID+(xs&~3); x = ((((xe+3)&~3)-(xs&~3))>>2)+1;
	for(y=ys;y<=ye;y++,i+=VSID)
		{ clearbuf((void *)&umost[i],x,-1); clearbuf((void *)&dmost[i],x,0); }

	inithull3d(pt,nump);
	tmaphulltrisortho(pt);

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
			modslab(scum2(x,y),(long)umost[y*VSID+x],(long)dmost[y*VSID+x]);
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

// ------------------------- CONVEX 3D HULL CODE ENDS -------------------------

	//Old&Slow sector code, but only this one supports the 3D bumpmapping :(
static void setsectorb (point3d *p, long *point2, long n, float thick, long dacol, long bakit, long bumpmap)
{
	point3d norm, p2;
	float d, f, x0, y0, x1, y1;
	long i, j, k, got, x, y, z, xs, ys, zs, xe, ye, ze, maxis, ndacol;

	norm.x = 0; norm.y = 0; norm.z = 0;
	for(i=0;i<n;i++)
	{
		j = point2[i]; k = point2[j];
		norm.x += (p[i].y-p[j].y)*(p[k].z-p[j].z) - (p[i].z-p[j].z)*(p[k].y-p[j].y);
		norm.y += (p[i].z-p[j].z)*(p[k].x-p[j].x) - (p[i].x-p[j].x)*(p[k].z-p[j].z);
		norm.z += (p[i].x-p[j].x)*(p[k].y-p[j].y) - (p[i].y-p[j].y)*(p[k].x-p[j].x);
	}
	f = 1.0 / sqrt(norm.x*norm.x + norm.y*norm.y + norm.z*norm.z);
	norm.x *= f; norm.y *= f; norm.z *= f;

	if ((fabs(norm.z) >= fabs(norm.x)) && (fabs(norm.z) >= fabs(norm.y)))
		maxis = 2;
	else if (fabs(norm.y) > fabs(norm.x))
		maxis = 1;
	else
		maxis = 0;

	xs = xe = p[0].x;
	ys = ye = p[0].y;
	zs = ze = p[0].z;
	for(i=n-1;i;i--)
	{
		if (p[i].x < xs) xs = p[i].x;
		if (p[i].y < ys) ys = p[i].y;
		if (p[i].z < zs) zs = p[i].z;
		if (p[i].x > xe) xe = p[i].x;
		if (p[i].y > ye) ye = p[i].y;
		if (p[i].z > ze) ze = p[i].z;
	}
	xs = max(xs-thick-bumpmap,0); xe = min(xe+thick+bumpmap,VSID-1);
	ys = max(ys-thick-bumpmap,0); ye = min(ye+thick+bumpmap,VSID-1);
	zs = max(zs-thick-bumpmap,0); ze = min(ze+thick+bumpmap,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;
	if (bakit) voxbackup(xs,ys,xe+1,ye+1,bakit);

	clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);

	ndacol = (dacol==-1)-2;

	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
		{
			got = 0;
			d = ((float)x-p[0].x)*norm.x + ((float)y-p[0].y)*norm.y + ((float)zs-p[0].z)*norm.z;
			for(z=zs;z<=ze;z++,d+=norm.z)
			{
				if (bumpmap)
				{
					if (d < -thick) continue;
					p2.x = (float)x - d*norm.x;
					p2.y = (float)y - d*norm.y;
					p2.z = (float)z - d*norm.z;
					if (d > (float)hpngcolfunc(&p2)+thick) continue;
				}
				else
				{
					if (fabs(d) > thick) continue;
					p2.x = (float)x - d*norm.x;
					p2.y = (float)y - d*norm.y;
					p2.z = (float)z - d*norm.z;
				}

				k = 0;
				for(i=n-1;i>=0;i--)
				{
					j = point2[i];
					switch(maxis)
					{
						case 0: x0 = p[i].z-p2.z; x1 = p[j].z-p2.z;
								  y0 = p[i].y-p2.y; y1 = p[j].y-p2.y; break;
						case 1: x0 = p[i].x-p2.x; x1 = p[j].x-p2.x;
								  y0 = p[i].z-p2.z; y1 = p[j].z-p2.z; break;
						case 2: x0 = p[i].x-p2.x; x1 = p[j].x-p2.x;
								  y0 = p[i].y-p2.y; y1 = p[j].y-p2.y; break;
						default: __assume(0); //tells MSVC default can't be reached
					}
					if (((*(long *)&y0)^(*(long *)&y1)) < 0)
					{
						if (((*(long *)&x0)^(*(long *)&x1)) >= 0) k ^= (*(long *)&x0);
						else { f = (x0*y1-x1*y0); k ^= (*(long *)&f)^(*(long *)&y1); }
					}
				}
				if (k >= 0) continue;

				templongbuf[z] = ndacol; got = 1;
			}
			if (got)
			{
				scum(x,y,zs,ze+1,templongbuf);
				clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);
			}
		}
	scumfinish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//This is for ordfillpolygon&splitpoly
typedef struct { long p, i, t; } raster;
#define MAXCURS 100 //THIS IS VERY EVIL... FIX IT!!!
static raster rst[MAXCURS];
static long slist[MAXCURS];

	//Code taken from POLYOLD\POLYSPLI.BAS:splitpoly (06/09/2001)
void splitpoly (float *px, float *py, long *point2, long *bakn,
					 float x0, float y0, float dx, float dy)
{
	long i, j, s2, n, sn, splcnt, z0, z1, z2, z3;
	float t, t1;

	n = (*bakn); if (n < 3) return;
	i = 0; s2 = sn = n; splcnt = 0;
	do
	{
		t1 = (px[i]-x0)*dy - (py[i]-y0)*dx;
		do
		{
			j = point2[i]; point2[i] |= 0x80000000;
			t = t1; t1 = (px[j]-x0)*dy - (py[j]-y0)*dx;
			if ((*(long *)&t) < 0)
				{ px[n] = px[i]; py[n] = py[i]; point2[n] = n+1; n++; }
			if (((*(long *)&t) ^ (*(long *)&t1)) < 0)
			{
				if ((*(long *)&t) < 0) slist[splcnt++] = n;
				t /= (t-t1);
				px[n] = (px[j]-px[i])*t + px[i];
				py[n] = (py[j]-py[i])*t + py[i];
				point2[n] = n+1; n++;
			}
			i = j;
		} while (point2[i] >= 0);
		if (n > s2) { point2[n-1] = s2; s2 = n; }
		for(i=sn-1;(i) && (point2[i] < 0);i--);
	} while (i > 0);

	if (fabs(dx) > fabs(dy))
	{
		for(i=1;i<splcnt;i++)
		{
			z0 = slist[i];
			for(j=0;j<i;j++)
			{
				z1 = point2[z0]; z2 = slist[j]; z3 = point2[z2];
				if (fabs(px[z0]-px[z3])+fabs(px[z2]-px[z1]) < fabs(px[z0]-px[z1])+fabs(px[z2]-px[z3]))
					{ point2[z0] = z3; point2[z2] = z1; }
			}
		}
	}
	else
	{
		for(i=1;i<splcnt;i++)
		{
			z0 = slist[i];
			for(j=0;j<i;j++)
			{
				z1 = point2[z0]; z2 = slist[j]; z3 = point2[z2];
				if (fabs(py[z0]-py[z3])+fabs(py[z2]-py[z1]) < fabs(py[z0]-py[z1])+fabs(py[z2]-py[z3]))
					{ point2[z0] = z3; point2[z2] = z1; }
			}
		}
	}

	for(i=sn;i<n;i++)
		{ px[i-sn] = px[i]; py[i-sn] = py[i]; point2[i-sn] = point2[i]-sn; }
	(*bakn) = n-sn;
}

void ordfillpolygon (float *px, float *py, long *point2, long n, long day, long xs, long xe, void (*modslab)(long *, long, long))
{
	float f;
	long k, i, z, zz, z0, z1, zx, sx0, sy0, sx1, sy1, sy, nsy, gap, numrst;
	long np, ni;

	if (n < 3) return;

	for(z=0;z<n;z++) slist[z] = z;

		//Sort points by y's
	for(gap=(n>>1);gap;gap>>=1)
		for(z=0;z<n-gap;z++)
			for(zz=z;zz>=0;zz-=gap)
			{
				if (py[point2[slist[zz]]] <= py[point2[slist[zz+gap]]]) break;
				z0 = slist[zz]; slist[zz] = slist[zz+gap]; slist[zz+gap] = z0;
			}

	ftol(py[point2[slist[0]]]+.5,&sy); if (sy < xs) sy = xs;

	numrst = 0; z = 0; n--; //Note: n is local variable!
	while (z < n)
	{
		z1 = slist[z]; z0 = point2[z1];
		for(zx=0;zx<2;zx++)
		{
			ftol(py[z0]+.5,&sy0); ftol(py[z1]+.5,&sy1);
			if (sy1 > sy0) //Insert raster (z0,z1)
			{
				f = (px[z1]-px[z0]) / (py[z1]-py[z0]);
				ftol(((sy-py[z0])*f + px[z0])*65536.0 + 65535.0,&np);
				if (sy1-sy0 >= 2) ftol(f*65536.0,&ni); else ni = 0;
				k = (np<<1)+ni;
				for(i=numrst;i>0;i--)
				{
					if ((rst[i-1].p<<1)+rst[i-1].i < k) break;
					rst[i] = rst[i-1];
				}
				rst[i].i = ni; rst[i].p = np; rst[i].t = (z0<<16)+z1;
				numrst++;
			}
			else if (sy1 < sy0) //Delete raster (z1,z0)
			{
				numrst--;
				k = (z1<<16)+z0; i = 0;
				while ((i < numrst) && (rst[i].t != k)) i++;
				while (i < numrst) { rst[i] = rst[i+1]; i++; }
			}
			z1 = point2[z0];
		}

		z++;
		ftol(py[point2[slist[z]]]+.5,&nsy); if (nsy > xe) nsy = xe;
		for(;sy<nsy;sy++)
			for(i=0;i<numrst;i+=2)
			{
				modslab(scum2(sy,day),max(rst[i].p>>16,0),min(rst[i+1].p>>16,MAXZDIM));
				rst[i].p += rst[i].i; rst[i+1].p += rst[i+1].i;
			}
	}
}

	//Draws a flat polygon
	//given: p&point2: 3D points, n: # points, thick: thickness, dacol: color
static float ppx[MAXCURS*4], ppy[MAXCURS*4];
static long npoint2[MAXCURS*4];
void setsector (point3d *p, long *point2, long n, float thick, long dacol, long bakit)
{
	void (*modslab)(long *, long, long);
	point3d norm;
	float f, rnormy, xth, zth, dax, daz, t, t1;
	long i, j, k, x, y, z, sn, s2, nn, xs, ys, zs, xe, ye, ze;

	norm.x = 0; norm.y = 0; norm.z = 0;
	for(i=0;i<n;i++)
	{
		j = point2[i]; k = point2[j];
		norm.x += (p[i].y-p[j].y)*(p[k].z-p[j].z) - (p[i].z-p[j].z)*(p[k].y-p[j].y);
		norm.y += (p[i].z-p[j].z)*(p[k].x-p[j].x) - (p[i].x-p[j].x)*(p[k].z-p[j].z);
		norm.z += (p[i].x-p[j].x)*(p[k].y-p[j].y) - (p[i].y-p[j].y)*(p[k].x-p[j].x);
	}
	f = 1.0 / sqrt(norm.x*norm.x + norm.y*norm.y + norm.z*norm.z);
	norm.x *= f; norm.y *= f; norm.z *= f;

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;
	else if ((vx5.colfunc == pngcolfunc) && (vx5.pic) && (vx5.xsiz > 0) && (vx5.ysiz > 0) && (vx5.picmode == 3))
	{
			//Find biggest height offset to minimize bounding box size
		j = k = vx5.pic[0];
		for(y=vx5.ysiz-1;y>=0;y--)
		{
			i = y*(vx5.bpl>>2);
			for(x=vx5.xsiz-1;x>=0;x--)
			{
				if (vx5.pic[i+x] < j) j = vx5.pic[i+x];
				if (vx5.pic[i+x] > k) k = vx5.pic[i+x];
			}
		}
		if ((j^k)&0xff000000) //If high bytes are !=, then use bumpmapping
		{
			setsectorb(p,point2,n,thick,dacol,bakit,max(labs(j>>24),labs(k>>24)));
			return;
		}
	}

	xs = xe = p[0].x;
	ys = ye = p[0].y;
	zs = ze = p[0].z;
	for(i=n-1;i;i--)
	{
		if (p[i].x < xs) xs = p[i].x;
		if (p[i].y < ys) ys = p[i].y;
		if (p[i].z < zs) zs = p[i].z;
		if (p[i].x > xe) xe = p[i].x;
		if (p[i].y > ye) ye = p[i].y;
		if (p[i].z > ze) ze = p[i].z;
	}
	xs = max(xs-thick,0); xe = min(xe+thick,VSID-1);
	ys = max(ys-thick,0); ye = min(ye+thick,VSID-1);
	zs = max(zs-thick,0); ze = min(ze+thick,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;
	if (bakit) voxbackup(xs,ys,xe+1,ye+1,bakit);

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	if (fabs(norm.y) >= .001)
	{
		rnormy = 1.0 / norm.y;
		for(y=ys;y<=ye;y++)
		{
			nn = n;
			for(i=0;i<n;i++)
			{
				f = ((float)y-p[i].y) * rnormy;
				ppx[i] = norm.z*f + p[i].z;
				ppy[i] = norm.x*f + p[i].x;
				npoint2[i] = point2[i];
			}
			if (fabs(norm.x) > fabs(norm.z))
			{
				splitpoly(ppx,ppy,npoint2,&nn,p[0].z,((p[0].y-(float)y)*norm.y-thick)/norm.x+p[0].x,norm.x,-norm.z);
				splitpoly(ppx,ppy,npoint2,&nn,p[0].z,((p[0].y-(float)y)*norm.y+thick)/norm.x+p[0].x,-norm.x,norm.z);
			}
			else
			{
				splitpoly(ppx,ppy,npoint2,&nn,((p[0].y-(float)y)*norm.y-thick)/norm.z+p[0].z,p[0].x,norm.x,-norm.z);
				splitpoly(ppx,ppy,npoint2,&nn,((p[0].y-(float)y)*norm.y+thick)/norm.z+p[0].z,p[0].x,-norm.x,norm.z);
			}
			ordfillpolygon(ppx,ppy,npoint2,nn,y,xs,xe,modslab);
		}
	}
	else
	{
		xth = norm.x*thick; zth = norm.z*thick;
		for(y=ys;y<=ye;y++)
		{
			for(z=0;z<n;z++) slist[z] = 0;
			nn = 0; i = 0; sn = n;
			do
			{
				s2 = nn; t1 = p[i].y-(float)y;
				do
				{
					j = point2[i]; slist[i] = 1; t = t1; t1 = p[j].y-(float)y;
					if (((*(long *)&t) ^ (*(long *)&t1)) < 0)
					{
						k = ((*(unsigned long *)&t)>>31); t /= (t-t1);
						daz = (p[j].z-p[i].z)*t + p[i].z;
						dax = (p[j].x-p[i].x)*t + p[i].x;
						ppx[nn+k] = daz+zth; ppx[nn+1-k] = daz-zth;
						ppy[nn+k] = dax+xth; ppy[nn+1-k] = dax-xth;
						npoint2[nn] = nn+1; npoint2[nn+1] = nn+2; nn += 2;
					}
					i = j;
				} while (!slist[i]);
				if (nn > s2) { npoint2[nn-1] = s2; s2 = nn; }
				for(i=sn-1;(i) && (slist[i]);i--);
			} while (i);
			ordfillpolygon(ppx,ppy,npoint2,nn,y,xs,xe,modslab);
		}
	}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//Given: p[>=3]: points 0,1 are the axis of rotation, others make up shape
	//      numcurs: number of points
	//        dacol: color
void setlathe (point3d *p, long numcurs, long dacol, long bakit)
{
	point3d norm, ax0, ax1, tp0, tp1;
	float d, f, x0, y0, x1, y1, px, py, pz;
	long i, j, cnt, got, x, y, z, xs, ys, zs, xe, ye, ze, maxis, ndacol;

	norm.x = (p[0].y-p[1].y)*(p[2].z-p[1].z) - (p[0].z-p[1].z)*(p[2].y-p[1].y);
	norm.y = (p[0].z-p[1].z)*(p[2].x-p[1].x) - (p[0].x-p[1].x)*(p[2].z-p[1].z);
	norm.z = (p[0].x-p[1].x)*(p[2].y-p[1].y) - (p[0].y-p[1].y)*(p[2].x-p[1].x);
	f = 1.0 / sqrt(norm.x*norm.x + norm.y*norm.y + norm.z*norm.z);
	norm.x *= f; norm.y *= f; norm.z *= f;

	ax0.x = p[1].x-p[0].x; ax0.y = p[1].y-p[0].y; ax0.z = p[1].z-p[0].z;
	f = 1.0 / sqrt(ax0.x*ax0.x + ax0.y*ax0.y + ax0.z*ax0.z);
	ax0.x *= f; ax0.y *= f; ax0.z *= f;

	ax1.x = ax0.y*norm.z - ax0.z*norm.y;
	ax1.y = ax0.z*norm.x - ax0.x*norm.z;
	ax1.z = ax0.x*norm.y - ax0.y*norm.x;

	x0 = 0; //Cylindrical thickness: Perp-dist from line (p[0],p[1])
	y0 = 0; //Cylindrical min dot product from line (p[0],p[1])
	y1 = 0; //Cylindrical max dot product from line (p[0],p[1])
	for(i=numcurs-1;i;i--)
	{
		d = (p[i].x-p[0].x)*ax0.x + (p[i].y-p[0].y)*ax0.y + (p[i].z-p[0].z)*ax0.z;
		if (d < y0) y0 = d;
		if (d > y1) y1 = d;
		px = (p[i].x-p[0].x) - d*ax0.x;
		py = (p[i].y-p[0].y) - d*ax0.y;
		pz = (p[i].z-p[0].z) - d*ax0.z;
		f = px*px + py*py + pz*pz;     //Note: f is thickness SQUARED
		if (f > x0) x0 = f;
	}
	x0 = sqrt(x0)+1.0;
	tp0.x = ax0.x*y0 + p[0].x; tp1.x = ax0.x*y1 + p[0].x;
	tp0.y = ax0.y*y0 + p[0].y; tp1.y = ax0.y*y1 + p[0].y;
	tp0.z = ax0.z*y0 + p[0].z; tp1.z = ax0.z*y1 + p[0].z;
	xs = max(min(tp0.x,tp1.x)-x0,0); xe = min(max(tp0.x,tp1.x)+x0,VSID-1);
	ys = max(min(tp0.y,tp1.y)-x0,0); ye = min(max(tp0.y,tp1.y)+x0,VSID-1);
	zs = max(min(tp0.z,tp1.z)-x0,0); ze = min(max(tp0.z,tp1.z)+x0,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;
	if (bakit) voxbackup(xs,ys,xe,ye,bakit);

	if ((fabs(norm.z) >= fabs(norm.x)) && (fabs(norm.z) >= fabs(norm.y)))
		maxis = 2;
	else if (fabs(norm.y) > fabs(norm.x))
		maxis = 1;
	else
		maxis = 0;

	clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	ndacol = (dacol==-1)-2;

	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
		{
			got = 0;
			d = ((float)x-p[0].x)*ax0.x + ((float)y-p[0].y)*ax0.y + ((float)zs-p[0].z)*ax0.z;
			for(z=zs;z<=ze;z++,d+=ax0.z)
			{
					//Another way: p = sqrt((xyz dot ax1)^2 + (xyz dot norm)^2)
				px = ((float)x-p[0].x) - d*ax0.x;
				py = ((float)y-p[0].y) - d*ax0.y;
				pz = ((float)z-p[0].z) - d*ax0.z;
				f = sqrt(px*px + py*py + pz*pz);

				px = ax0.x*d + ax1.x*f + p[0].x;
				py = ax0.y*d + ax1.y*f + p[0].y;
				pz = ax0.z*d + ax1.z*f + p[0].z;

				cnt = j = 0;
				for(i=numcurs-1;i>=0;i--)
				{
					switch(maxis)
					{
						case 0: x0 = p[i].z-pz; x1 = p[j].z-pz;
								  y0 = p[i].y-py; y1 = p[j].y-py; break;
						case 1: x0 = p[i].x-px; x1 = p[j].x-px;
								  y0 = p[i].z-pz; y1 = p[j].z-pz; break;
						case 2: x0 = p[i].x-px; x1 = p[j].x-px;
								  y0 = p[i].y-py; y1 = p[j].y-py; break;
						default: __assume(0); //tells MSVC default can't be reached
					}
					if (((*(long *)&y0)^(*(long *)&y1)) < 0)
					{
						if (((*(long *)&x0)^(*(long *)&x1)) >= 0) cnt ^= (*(long *)&x0);
						else { f = (x0*y1-x1*y0); cnt ^= (*(long *)&f)^(*(long *)&y1); }
					}
					j = i;
				}
				if (cnt >= 0) continue;

				templongbuf[z] = ndacol; got = 1;
			}
			if (got)
			{
				scum(x,y,zs,ze+1,templongbuf);
				clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);
			}
		}
	scumfinish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

	//Given: p[>=1]: centers
	//   vx5.currad: cutoff value
	//      numcurs: number of points
	//        dacol: color
void setblobs (point3d *p, long numcurs, long dacol, long bakit)
{
	float dx, dy, dz, v, nrad;
	long i, got, x, y, z, xs, ys, zs, xe, ye, ze, ndacol;

	if (numcurs <= 0) return;

		//Boundaries are quick hacks - rewrite this code!!!
	xs = max(p[0].x-64,0); xe = min(p[0].x+64,VSID-1);
	ys = max(p[0].y-64,0); ye = min(p[0].y+64,VSID-1);
	zs = max(p[0].z-64,0); ze = min(p[0].z+64,MAXZDIM-1);
	vx5.minx = xs; vx5.maxx = xe+1;
	vx5.miny = ys; vx5.maxy = ye+1;
	vx5.minz = zs; vx5.maxz = ze+1;
	if ((xs > xe) || (ys > ye) || (zs > ze)) return;
	if (bakit) voxbackup(xs,ys,xe,ye,bakit);

	clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);

	if (vx5.colfunc == jitcolfunc) vx5.amount = 0x70707;

	ndacol = (dacol==-1)-2;

	if (cputype&(1<<25))
	{
		_asm
		{
			mov eax, 256
			xorps xmm7, xmm7    ;xmm7: 0,0,0,0
			cvtsi2ss xmm6, eax  ;xmm6: ?,?,?,256
			movlhps xmm6, xmm6  ;xmm6: ?,256,?,256
		}
	}

	nrad = (float)numcurs / ((float)vx5.currad*(float)vx5.currad + 256.0);
	for(y=ys;y<=ye;y++)
		for(x=xs;x<=xe;x++)
		{
			if (cputype&(1<<25))
			{
				_asm
				{
					cvtsi2ss xmm0, x        ;xmm0:?,?,?,x
					cvtsi2ss xmm7, y        ;xmm7:0,0,0,y
					movlhps xmm0, xmm7      ;xmm0:0,y,?,x
					shufps xmm0, xmm0, 0x08 ;xmm0:x,x,y,x
				}
			}

			got = 0;
			for(z=zs;z<=ze;z++)
			{
				if (cputype&(1<<25))
				{
					_asm
					{
						movhlps xmm3, xmm7       ;xmm3:?,?,0,0
						cvtsi2ss xmm7, z         ;xmm7:0,0,0,z
						movlhps xmm0, xmm7       ;xmm0:0,z,y,x
						mov eax, numcurs
						mov edx, p
						lea eax, [eax+eax*2-3]
				 beg: movups xmm1, [edx+eax*4] ;xmm1: ?,pz,py,pz
						subps xmm1, xmm0         ;xmm1: ?,dz,dy,dx
						mulps xmm1, xmm1         ;xmm1: ?,dzý,dyý,dxý
						movhlps xmm6, xmm1       ;xmm6: ?,256,?,dzý
						shufps xmm1, xmm6, 0x84  ;xmm1: 256,dzý,dyý,dxý
						movhlps xmm2, xmm1       ;xmm2: ?,?,256,dzý
						addps xmm1, xmm2         ;xmm1: ?,?,dyý+256,dxý+dzý
						movss xmm2, xmm1         ;xmm2: ?,?,256,dxý+dzý
						shufps xmm1, xmm1, 0x1   ;xmm1: dxý+dzý,dxý+dzý,dxý+dzý,dyý+256
						addss xmm1, xmm2         ;xmm1: ?,?,?,dxý+dyý+dzý+256
						rcpss xmm1, xmm1         ;xmm1: ?,?,?,1/(dxý+dyý+dzý+256)
						addss xmm3, xmm1
						sub eax, 3
						jnc short beg
						movss v, xmm3
					}
				}
				else
				{
					v = 0;
					for(i=numcurs-1;i>=0;i--)
					{
						dx = p[i].x-(float)x;
						dy = p[i].y-(float)y;
						dz = p[i].z-(float)z;
						v += 1.0f / (dx*dx + dy*dy + dz*dz + 256.0f);
					}
				}
				if (*(long *)&v > *(long *)&nrad) { templongbuf[z] = ndacol; got = 1; }
			}
			if (got)
			{
				scum(x,y,zs,ze+1,templongbuf);
				clearbuf((void *)&templongbuf[zs],ze-zs+1,-3);
			}
		}
	scumfinish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

//FLOODFILL3D begins --------------------------------------------------------

#define FILLBUFSIZ 16384 //Use realloc instead!
typedef struct { unsigned short x, y, z0, z1; } spoint4d; //128K
static spoint4d fbuf[FILLBUFSIZ];

long dntil0 (long x, long y, long z)
{
	char *v = sptr[y*VSID+x];
	while (1)
	{
		if (z < v[1]) break;
		if (!v[0]) return(MAXZDIM);
		v += v[0]*4;
		if (z < v[3]) return(v[3]);
	}
	return(z);
}

long dntil1 (long x, long y, long z)
{
	char *v = sptr[y*VSID+x];
	while (1)
	{
		if (z <= v[1]) return(v[1]);
		if (!v[0]) break;
		v += v[0]*4;
		if (z < v[3]) break;
	}
	return(z);
}

long uptil1 (long x, long y, long z)
{
	char *v = sptr[y*VSID+x];
	if (z < v[1]) return(0);
	while (v[0])
	{
		v += v[0]*4;
		if (z < v[3]) break;
		if (z < v[1]) return(v[3]);
	}
	return(z);
}

	//Conducts on air and writes solid
void setfloodfill3d (long x, long y, long z, long minx, long miny, long minz,
															long maxx, long maxy, long maxz)
{
	long wholemap, j, z0, z1, nz1, i0, i1, (*bakcolfunc)(lpoint3d *);
	spoint4d a;

	if (minx < 0) minx = 0;
	if (miny < 0) miny = 0;
	if (minz < 0) minz = 0;
	maxx++; maxy++; maxz++;
	if (maxx > VSID) maxx = VSID;
	if (maxy > VSID) maxy = VSID;
	if (maxz > MAXZDIM) maxz = MAXZDIM;
	vx5.minx = minx; vx5.maxx = maxx;
	vx5.miny = miny; vx5.maxy = maxy;
	vx5.minz = minz; vx5.maxz = maxz;
	if ((minx >= maxx) || (miny >= maxy) || (minz >= maxz)) return;

	if ((x < minx) || (x >= maxx) ||
		 (y < miny) || (y >= maxy) ||
		 (z < minz) || (z >= maxz)) return;

	if ((minx != 0) || (miny != 0) || (minz != 0) || (maxx != VSID) || (maxy != VSID) || (maxz != VSID))
		wholemap = 0;
	else wholemap = 1;

	if (isvoxelsolid(x,y,z)) return;

	bakcolfunc = vx5.colfunc; vx5.colfunc = curcolfunc;

	a.x = x; a.z0 = uptil1(x,y,z); if (a.z0 < minz) a.z0 = minz;
	a.y = y; a.z1 = dntil1(x,y,z+1); if (a.z1 > maxz) a.z1 = maxz;
	if (((!a.z0) && (wholemap)) || (a.z0 >= a.z1)) { vx5.colfunc = bakcolfunc; return; } //oops! broke free :/
	insslab(scum2(x,y),a.z0,a.z1); scum2finish();
	i0 = i1 = 0; goto floodfill3dskip;
	do
	{
		a = fbuf[i0]; i0 = ((i0+1)&(FILLBUFSIZ-1));
floodfill3dskip:;
		for(j=3;j>=0;j--)
		{
			if (j&1) { x = a.x+(j&2)-1; if ((x < minx) || (x >= maxx)) continue; y = a.y; }
				 else { y = a.y+(j&2)-1; if ((y < miny) || (y >= maxy)) continue; x = a.x; }

			if (isvoxelsolid(x,y,a.z0)) { z0 = dntil0(x,y,a.z0); z1 = z0; }
										  else { z0 = uptil1(x,y,a.z0); z1 = a.z0; }
			if ((!z0) && (wholemap)) { vx5.colfunc = bakcolfunc; return; } //oops! broke free :/
			while (z1 < a.z1)
			{
				z1 = dntil1(x,y,z1);

				if (z0 < minz) z0 = minz;
				nz1 = z1; if (nz1 > maxz) nz1 = maxz;
				if (z0 < nz1)
				{
					fbuf[i1].x = x; fbuf[i1].y = y;
					fbuf[i1].z0 = z0; fbuf[i1].z1 = nz1;
					i1 = ((i1+1)&(FILLBUFSIZ-1));
					//if (i0 == i1) floodfill stack overflow!
					insslab(scum2(x,y),z0,nz1); scum2finish();
				}
				z0 = dntil0(x,y,z1); z1 = z0;
			}
		}
	} while (i0 != i1);

	vx5.colfunc = bakcolfunc;

	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

void hollowfillstart (long x, long y, long z)
{
	spoint4d a;
	char *v;
	long i, j, z0, z1, i0, i1;

	a.x = x; a.y = y;

	v = sptr[y*VSID+x]; j = ((((long)v)-(long)vbuf)>>2); a.z0 = 0;
	while (1)
	{
		a.z1 = (long)(v[1]);
		if ((a.z0 <= z) && (z < a.z1) && (!(vbit[j>>5]&(1<<j)))) break;
		if (!v[0]) return;
		v += v[0]*4; j += 2;
		a.z0 = (long)(v[3]);
	}
	vbit[j>>5] |= (1<<j); //fill a.x,a.y,a.z0<=?<a.z1

	i0 = i1 = 0; goto floodfill3dskip2;
	do
	{
		a = fbuf[i0]; i0 = ((i0+1)&(FILLBUFSIZ-1));
floodfill3dskip2:;
		for(i=3;i>=0;i--)
		{
			if (i&1) { x = a.x+(i&2)-1; if ((unsigned long)x >= VSID) continue; y = a.y; }
				 else { y = a.y+(i&2)-1; if ((unsigned long)y >= VSID) continue; x = a.x; }

			v = sptr[y*VSID+x]; j = ((((long)v)-(long)vbuf)>>2); z0 = 0;
			while (1)
			{
				z1 = (long)(v[1]);
				if ((z0 < a.z1) && (a.z0 < z1) && (!(vbit[j>>5]&(1<<j))))
				{
					fbuf[i1].x = x; fbuf[i1].y = y;
					fbuf[i1].z0 = z0; fbuf[i1].z1 = z1;
					i1 = ((i1+1)&(FILLBUFSIZ-1));
					if (i0 == i1) return; //floodfill stack overflow!
					vbit[j>>5] |= (1<<j); //fill x,y,z0<=?<z1
				}
				if (!v[0]) break;
				v += v[0]*4; j += 2;
				z0 = (long)(v[3]);
			}
		}
	} while (i0 != i1);
}

	//hollowfill
void sethollowfill ()
{
	long i, j, l, x, y, z0, z1, *lptr, (*bakcolfunc)(lpoint3d *);
	char *v;

	vx5.minx = 0; vx5.maxx = VSID;
	vx5.miny = 0; vx5.maxy = VSID;
	vx5.minz = 0; vx5.maxz = MAXZDIM;

	for(i=0;i<VSID*VSID;i++)
	{
		j = ((((long)sptr[i])-(long)vbuf)>>2);
		for(v=sptr[i];v[0];v+=v[0]*4) { vbit[j>>5] &= ~(1<<j); j += 2; }
		vbit[j>>5] &= ~(1<<j);
	}

	for(y=0;y<VSID;y++)
		for(x=0;x<VSID;x++)
			hollowfillstart(x,y,0);

	bakcolfunc = vx5.colfunc; vx5.colfunc = curcolfunc;
	i = 0;
	for(y=0;y<VSID;y++)
		for(x=0;x<VSID;x++,i++)
		{
			j = ((((long)sptr[i])-(long)vbuf)>>2);
			v = sptr[i]; z0 = MAXZDIM;
			while (1)
			{
				z1 = (long)(v[1]);
				if ((z0 < z1) && (!(vbit[j>>5]&(1<<j))))
				{
					vbit[j>>5] |= (1<<j);
					insslab(scum2(x,y),z0,z1);
				}
				if (!v[0]) break;
				v += v[0]*4; j += 2;
				z0 = (long)(v[3]);
			}
		}
	scum2finish();
	vx5.colfunc = bakcolfunc;
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);
}

//FLOODFILL3D ends ----------------------------------------------------------

#define LPATBUFSIZ 14
static lpoint2d *patbuf;
#define LPATHASHSIZ 12
static lpoint3d *pathashdat;
static long *pathashead, pathashcnt, pathashmax;

static void initpathash ()
{
	patbuf = (lpoint2d *)radar;
	pathashead = (long *)(((long)patbuf)+(1<<LPATBUFSIZ)*sizeof(lpoint2d));
	pathashdat = (lpoint3d *)(((long)pathashead)+((1<<LPATHASHSIZ)*4));
	pathashmax = ((max((MAXXDIM*MAXYDIM*27)>>1,(VSID+4)*3*256*4)-((1<<LPATBUFSIZ)*sizeof(lpoint2d))-(1<<LPATHASHSIZ)*4)/12);
	memset(pathashead,-1,(1<<LPATHASHSIZ)*4);
	pathashcnt = 0;
}

static long readpathash (long i)
{
	long j = (((i>>LPATHASHSIZ)-i) & ((1<<LPATHASHSIZ)-1));
	for(j=pathashead[j];j>=0;j=pathashdat[j].x)
		if (pathashdat[j].y == i) return(pathashdat[j].z);
	return(-1);
}

static void writepathash (long i, long v)
{
	long k, j = (((i>>LPATHASHSIZ)-i) & ((1<<LPATHASHSIZ)-1));
	for(k=pathashead[j];k>=0;k=pathashdat[k].x)
		if (pathashdat[k].y == i) { pathashdat[k].z = v; return; }
	pathashdat[pathashcnt].x = pathashead[j]; pathashead[j] = pathashcnt;
	pathashdat[pathashcnt].y = i;
	pathashdat[pathashcnt].z = v;
	pathashcnt++;
}

static signed char cdir[26*4] = //sqrt(2) =~ 58/41, sqrt(3) =~ 71/41;
{
	-1, 0, 0,41,  1, 0, 0,41,  0,-1, 0,41,  0, 1, 0,41,  0, 0,-1,41,  0, 0, 1,41,
	-1,-1, 0,58, -1, 1, 0,58, -1, 0,-1,58, -1, 0, 1,58,  0,-1,-1,58,  0,-1, 1,58,
	 1,-1, 0,58,  1, 1, 0,58,  1, 0,-1,58,  1, 0, 1,58,  0, 1,-1,58,  0, 1, 1,58,
	-1,-1,-1,71, -1,-1, 1,71, -1, 1,-1,71, -1, 1, 1,71,
	 1,-1,-1,71,  1,-1, 1,71,  1, 1,-1,71,  1, 1, 1,71,
};

long findpath (long *pathpos, long pathmax, lpoint3d *p1, lpoint3d *p0)
{
	long i, j, k, x, y, z, c, nc, xx, yy, zz, bufr, bufw, pcnt;

	if (!(getcube(p0->x,p0->y,p0->z)&~1))
	{
		for(i=5;i>=0;i--)
		{
			x = p0->x+(long)cdir[i*4]; y = p0->y+(long)cdir[i*4+1]; z = p0->z+(long)cdir[i*4+2];
			if (getcube(x,y,z)&~1) { p0->x = x; p0->y = y; p0->z = z; break; }
		}
		if (i < 0) return(0);
	}
	if (!(getcube(p1->x,p1->y,p1->z)&~1))
	{
		for(i=5;i>=0;i--)
		{
			x = p1->x+(long)cdir[i*4]; y = p1->y+(long)cdir[i*4+1]; z = p1->z+(long)cdir[i*4+2];
			if (getcube(x,y,z)&~1) { p1->x = x; p1->y = y; p1->z = z; break; }
		}
		if (i < 0) return(0);
	}

	initpathash();
	j = (p0->x*VSID + p0->y)*MAXZDIM+p0->z;
	patbuf[0].x = j; patbuf[0].y = 0; bufr = 0; bufw = 1;
	writepathash(j,0);
	do
	{
		j = patbuf[bufr&((1<<LPATBUFSIZ)-1)].x;
		x = j/(VSID*MAXZDIM); y = ((j/MAXZDIM)&(VSID-1)); z = (j&(MAXZDIM-1));
		c = patbuf[bufr&((1<<LPATBUFSIZ)-1)].y; bufr++;
		for(i=0;i<26;i++)
		{
			xx = x+(long)cdir[i*4]; yy = y+(long)cdir[i*4+1]; zz = z+(long)cdir[i*4+2];
			j = (xx*VSID + yy)*MAXZDIM+zz;

			//nc = c+(long)cdir[i*4+3]; //More accurate but lowers max distance a lot!
			//if (((k = getcube(xx,yy,zz))&~1) && ((unsigned long)nc < (unsigned long)readpathash(j)))

			if (((k = getcube(xx,yy,zz))&~1) && (readpathash(j) < 0))
			{
				nc = c+(long)cdir[i*4+3];
				if ((xx == p1->x) && (yy == p1->y) && (zz == p1->z)) { c = nc; goto pathfound; }
				writepathash(j,nc);
				if (pathashcnt >= pathashmax) return(0);
				patbuf[bufw&((1<<LPATBUFSIZ)-1)].x = (xx*VSID + yy)*MAXZDIM+zz;
				patbuf[bufw&((1<<LPATBUFSIZ)-1)].y = nc; bufw++;
			}
		}
	} while (bufr != bufw);

pathfound:
	if (pathmax <= 0) return(0);
	pathpos[0] = (p1->x*VSID + p1->y)*MAXZDIM+p1->z; pcnt = 1;
	x = p1->x; y = p1->y; z = p1->z;
	do
	{
		for(i=0;i<26;i++)
		{
			xx = x+(long)cdir[i*4]; yy = y+(long)cdir[i*4+1]; zz = z+(long)cdir[i*4+2];
			nc = c-(long)cdir[i*4+3];
			if (readpathash((xx*VSID + yy)*MAXZDIM+zz) == nc)
			{
				if (pcnt >= pathmax) return(0);
				pathpos[pcnt] = (xx*VSID + yy)*MAXZDIM+zz; pcnt++;
				x = xx; y = yy; z = zz; c = nc; break;
			}
		}
	} while (i < 26);
	if (pcnt >= pathmax) return(0);
	pathpos[pcnt] = (p0->x*VSID + p0->y)*MAXZDIM+p0->z;
	return(pcnt+1);
}

//---------------------------------------------------------------------

static unsigned short xyoffs[256][256+1];
void setkvx (const char *filename, long ox, long oy, long oz, long rot, long bakit)
{
	long i, j, x, y, z, xsiz, ysiz, zsiz, longpal[256], zleng, oldz, vis;
	long d[3], k[9], x0, y0, z0, x1, y1, z1;
	char ch, typ;
	FILE *fp;

	typ = filename[strlen(filename)-3]; if (typ == 'k') typ = 'K';

	if (!(fp = fopen(filename,"rb"))) return;

	fseek(fp,-768,SEEK_END);
	for(i=0;i<255;i++)
	{
		longpal[i]  = (((long)fgetc(fp))<<18);
		longpal[i] += (((long)fgetc(fp))<<10);
		longpal[i] += (((long)fgetc(fp))<< 2) + 0x80000000;
	}
	longpal[255] = 0x7ffffffd;

	if (typ == 'K') //Load .KVX file
	{
		fseek(fp,4,SEEK_SET);
		fread(&xsiz,4,1,fp);
		fread(&ysiz,4,1,fp);
		fread(&zsiz,4,1,fp);
		fseek(fp,((xsiz+1)<<2)+28,SEEK_SET);
		for(i=0;i<xsiz;i++) fread(&xyoffs[i][0],(ysiz+1)<<1,1,fp);
	}
	else           //Load .VOX file
	{
		fseek(fp,0,SEEK_SET);
		fread(&xsiz,4,1,fp);
		fread(&ysiz,4,1,fp);
		fread(&zsiz,4,1,fp);
	}

		//rot: low 3 bits for axis negating, high 6 states for axis swapping
		//k[0], k[3], k[6] are indeces
		//k[1], k[4], k[7] are xors
		//k[2], k[5], k[8] are adds
	switch (rot&~7)
	{
		case  0: k[0] = 0; k[3] = 1; k[6] = 2; break; //can use scum!
		case  8: k[0] = 1; k[3] = 0; k[6] = 2; break; //can use scum!
		case 16: k[0] = 0; k[3] = 2; k[6] = 1; break;
		case 24: k[0] = 2; k[3] = 0; k[6] = 1; break;
		case 32: k[0] = 1; k[3] = 2; k[6] = 0; break;
		case 40: k[0] = 2; k[3] = 1; k[6] = 0; break;
		default: __assume(0); //tells MSVC default can't be reached
	}
	k[1] = ((rot<<31)>>31);
	k[4] = ((rot<<30)>>31);
	k[7] = ((rot<<29)>>31);

	d[0] = xsiz; d[1] = ysiz; d[2] = zsiz;
	k[2] = ox-((d[k[0]]>>1)^k[1]);
	k[5] = oy-((d[k[3]]>>1)^k[4]);
	k[8] = oz-((d[k[6]]>>1)^k[7]); k[8] -= (d[k[6]]>>1);

	d[0] = d[1] = d[2] = 0;
	x0 = x1 = (d[k[0]]^k[1])+k[2];
	y0 = y1 = (d[k[3]]^k[4])+k[5];
	z0 = z1 = (d[k[6]]^k[7])+k[8];
	d[0] = xsiz; d[1] = ysiz; d[2] = zsiz;
	x0 = min(x0,(d[k[0]]^k[1])+k[2]); x1 = max(x1,(d[k[0]]^k[1])+k[2]);
	y0 = min(y0,(d[k[3]]^k[4])+k[5]); y1 = max(y1,(d[k[3]]^k[4])+k[5]);
	z0 = min(z0,(d[k[6]]^k[7])+k[8]); z1 = max(z1,(d[k[6]]^k[7])+k[8]);
	if (x0 < 1) { i = 1-x0; x0 += i; x1 += i; k[2] += i; }
	if (y0 < 1) { i = 1-y0; y0 += i; y1 += i; k[5] += i; }
	if (z0 < 0) { i = 0-z0; z0 += i; z1 += i; k[8] += i; }
	if (x1 > VSID-2)    { i = VSID-2-x1; x0 += i; x1 += i; k[2] += i; }
	if (y1 > VSID-2)    { i = VSID-2-y1; y0 += i; y1 += i; k[5] += i; }
	if (z1 > MAXZDIM-1) { i = MAXZDIM-1-z1; z0 += i; z1 += i; k[8] += i; }

	vx5.minx = x0; vx5.maxx = x1+1;
	vx5.miny = y0; vx5.maxy = y1+1;
	vx5.minz = z0; vx5.maxz = z1+1;
	if (bakit) voxbackup(x0,y0,x1+1,y1+1,bakit);

	j = (!(k[3]|(rot&3))); //if (j) { can use scum/scumfinish! }

	for(x=0;x<xsiz;x++)
	{
		d[0] = x;
		for(y=0;y<ysiz;y++)
		{
			d[1] = y;
			if (k[6] == 2) //can use scum!
			{
				clearbuf((void *)&templongbuf[z0],z1-z0+1,-3);
				if (typ == 'K')
				{
					oldz = -1;
					i = xyoffs[d[0]][d[1]+1] - xyoffs[d[0]][d[1]]; if (!i) continue;
					while (i > 0)
					{
						z = fgetc(fp); zleng = fgetc(fp); i -= (zleng+3);
						vis = fgetc(fp);

						if ((oldz >= 0) && (!(vis&16)))
							for(;oldz<z;oldz++)
								templongbuf[(oldz^k[7])+k[8]] = vx5.curcol;

						for(;zleng>0;zleng--,z++)
							templongbuf[(z^k[7])+k[8]] = longpal[fgetc(fp)];
						oldz = z;
					}
				}
				else
				{
					for(z=0;z<zsiz;z++)
						templongbuf[(z^k[7])+k[8]] = longpal[fgetc(fp)];
				}

				scum((d[k[0]]^k[1])+k[2],(d[k[3]]^k[4])+k[5],z0,z1+1,templongbuf);
				if (!j) scumfinish();
			}
			else
			{
				if (typ == 'K')
				{
					oldz = -1;
					i = xyoffs[d[0]][d[1]+1] - xyoffs[d[0]][d[1]]; if (!i) continue;
					while (i > 0)
					{
						z = fgetc(fp); zleng = fgetc(fp); i -= (zleng+3);
						vis = fgetc(fp);

						if ((oldz >= 0) && (!(vis&16)))
							for(;oldz<z;oldz++)
							{
								d[2] = oldz;
								setcube((d[k[0]]^k[1])+k[2],(d[k[3]]^k[4])+k[5],(d[k[6]]^k[7])+k[8],vx5.curcol);
							}

						for(;zleng>0;zleng--,z++)
						{
							ch = fgetc(fp);
							d[2] = z;
							setcube((d[k[0]]^k[1])+k[2],(d[k[3]]^k[4])+k[5],(d[k[6]]^k[7])+k[8],longpal[ch]);
						}
						oldz = z;
					}
				}
				else
				{
					for(z=0;z<zsiz;z++)
					{
						ch = fgetc(fp);
						if (ch != 255)
						{
							d[2] = z;
							setcube((d[k[0]]^k[1])+k[2],(d[k[3]]^k[4])+k[5],(d[k[6]]^k[7])+k[8],longpal[ch]);
						}
					}
				}
			}
		}
	}
	if (j) scumfinish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,0);

	fclose(fp);
}

void applycolorfilter(long filterR, long filterB, long filterG)
{
  for(int y = 0; y < yres; y++)
  {
    for(int x = 0; x < xres; x++)
    {
      long color = *(long *)(ylookup[y]+(x<<2)+frameplace);
      int iR = (((color>>16) & 0xFF) * filterR) / 256;
      int iG = (((color>>8) & 0xFF) * filterB) / 256;
      int iB = ((color & 0xFF) * filterG) / 256;

      *(long *)(ylookup[y]+(x<<2)+frameplace) = (color&0xFF000000) | (iR<<16) | (iG<<8) | (iB);
    }
  }
}

void clearscreen(bool clearcolor, bool clearZ, char color, char z)
{
  if(clearcolor)
  {
    for(int y = 0; y < yres; y++)
      memset((void *)(ylookup[y] + frameplace), color, 4*xres);
  }
  if(clearZ)
  {
    memset(zbuffermem, z, zbuffersiz);
  }
}

void getscreensize(int &x, int &y)
{
  x = xres;
  y = yres;
}
	//This here for game programmer only. I would never use it!
void drawpoint2d (long sx, long sy, long col)
{
	if ((unsigned long)sx >= (unsigned long)xres) return;
	if ((unsigned long)sy >= (unsigned long)yres) return;
	*(long *)(ylookup[sy]+(sx<<2)+frameplace) = col;
}

	//This here for game programmer only. I would never use it!
void drawpoint3d (float x0, float y0, float z0, long col)
{
	float ox, oy, oz, r;
	long x, y;

	ox = x0-gipos.x; oy = y0-gipos.y; oz = z0-gipos.z;
	z0 = ox*gifor.x + oy*gifor.y + oz*gifor.z; if (z0 < SCISDIST) return;
	r = 1.0f / z0;
	x0 = (ox*gistr.x + oy*gistr.y + oz*gistr.z)*gihz;
	y0 = (ox*gihei.x + oy*gihei.y + oz*gihei.z)*gihz;

	ftol(x0*r + gihx-.5f,&x); if ((unsigned long)x >= (unsigned long)xres) return;
	ftol(y0*r + gihy-.5f,&y); if ((unsigned long)y >= (unsigned long)yres) return;
	*(long *)(ylookup[y]+(x<<2)+frameplace) = col;
}

	//returns 1 if visible
long project2d (float x, float y, float z, float *px, float *py, float *sx)
{
	float ox, oy, oz;

	ox = x-gipos.x; oy = y-gipos.y; oz = z-gipos.z;
	z = ox*gifor.x + oy*gifor.y + oz*gifor.z; if (z < SCISDIST) return(0);
	
	z = gihz / z;
	*px = (ox*gistr.x + oy*gistr.y + oz*gistr.z)*z + gihx;
	*py = (ox*gihei.x + oy*gihei.y + oz*gihei.z)*z + gihy;
	*sx = z;   
	return(1);
}

static __int64 mskp255 = 0x00ff00ff00ff00ff;
static __int64 mskn255 = 0xff01ff01ff01ff01;
static __int64 rgbmask64 = 0xffffff00ffffff;

	//(tf,tp,tx,ty,tcx,tcy): Tile source, (tcx&tcy) is texel (<<16) at (sx,sy)
	//(sx,sy,xz,yz) screen coordinates and x&y zoom, all (<<16)
	//(black,white): black & white shade scale (ARGB format)
	//   Note: if alphas of black&white are same, then alpha channel ignored
void drawtile (long tf, long tp, long tx, long ty, long tcx, long tcy,
					long sx, long sy, long xz, long yz, long black, long white)
{
	long sx0, sy0, sx1, sy1, x0, y0, x1, y1, x, y, u, v, ui, vi, uu, vv;
	long p, i, j, a;

	if (!tf) return;
	sx0 = sx - mulshr16(tcx,xz); sx1 = sx0 + xz*tx;
	sy0 = sy - mulshr16(tcy,yz); sy1 = sy0 + yz*ty;
	x0 = max((sx0+65535)>>16,0); x1 = min((sx1+65535)>>16,xres);
	y0 = max((sy0+65535)>>16,0); y1 = min((sy1+65535)>>16,yres);
	ui = shldiv16(65536,xz); u = mulshr16(-sx0,ui);
	vi = shldiv16(65536,yz); v = mulshr16(-sy0,vi);
	if (!((black^white)&0xff000000)) //Ignore alpha
	{
			//for(y=y0,vv=y*vi+v;y<y1;y++,vv+=vi)
			//{
			//   p = ylookup[y] + frameplace; j = (vv>>16)*tp + tf;
			//   for(x=x0,uu=x*ui+u;x<x1;x++,uu+=ui)
			//      *(long *)((x<<2)+p) = *(long *)(((uu>>16)<<2) + j);
			//}
		if ((xz == 32768) && (yz == 32768))
		{
			long plc;
			for(y=y0,vv=y*vi+v;y<y1;y++,vv+=vi)
			{
				p = ylookup[y] + frameplace;
				plc = (((x0*ui+u)>>16)<<2) + (vv>>16)*tp + tf;
				_asm
				{
					push ebx
					mov eax, x1
					mov ebx, p
					lea ebx, [ebx+eax*4]
					sub eax, x0
					mov ecx, plc
					lea ecx, [ecx+eax*8]
					mov edx, tp
					add edx, ecx
					neg eax
						;eax: x0-x1
						;ebx: p + x1*4
						;ecx: plc + (x1-x0)*8
						;edx: plc + (x1-x0)*8 + tp
	  begdthalf:movq mm0, [eax*8+ecx]   ;mm0: A1R1G1B1 A0R0G0B0
					pavgb mm0, [eax*8+edx]  ;mm0: A1R1G1B1 A0R0G0B0
					pshufw mm1, mm0, 0xe    ;mm1: ???????? A1R1G1B1
					pavgb mm0, mm1          ;mm1: ???????? AaRrGgBb
					movd [eax*4+ebx], mm0
					inc eax
					jnz short begdthalf
					pop ebx
				}
			}
			_asm emms
		}
		else
		{
			long plc = x0*ui+u;
			for(y=y0,vv=y*vi+v;y<y1;y++,vv+=vi)
			{
				p = ylookup[y] + frameplace; j = (vv>>16)*tp + tf;

					//for(x=x0,uu=plc;x<x1;x++,uu+=ui)
					//   *(long *)((x<<2)+p) = *(long *)(((uu>>16)<<2) + j);
				_asm
				{
					push ebx
					push esi
					push edi
					mov edi, x1
					mov edx, x0
					cmp edx, edi
					jge short enddtnhalf
					mov eax, p
					mov esi, ui
					mov ecx, plc
					mov ebx, j
					sub edx, edi
					lea edi, [edi*4+eax]
begdtnhalf:
#if 0
					mov eax, ecx          ;simple loop
					shr eax, 16
					mov eax, [eax*4+ebx]
					add ecx, esi
					mov [edx*4+edi], eax
					add edx, 1
					jnz short begdtnhalf
#else
					lea eax, [ecx+esi]    ;unrolled once loop; uses movntq
					shr ecx, 16
					add edx, 1
					movd mm0, [ecx*4+ebx]
					lea ecx, [eax+esi]
					jz short preenddtnhalf
					shr eax, 16
					punpckldq mm0, [eax*4+ebx]
					movntq [edx*4+edi-4], mm0
					add edx, 1
					jnz short begdtnhalf
					jmp short enddtnhalf
preenddtnhalf: movd [edx*4+edi-4], mm0
#endif
enddtnhalf:    pop edi
					pop esi
					pop ebx
				}
			}
			_asm emms
		}
	}
	else //Use alpha for masking
	{
			//Init for black/white code
		_asm
		{
			pxor mm7, mm7
			movd mm5, white
			movd mm4, black
			punpcklbw mm5, mm7   ;mm5: [00Wa00Wr00Wg00Wb]
			punpcklbw mm4, mm7   ;mm4: [00Ba00Br00Bg00Bb]
			psubw mm5, mm4       ;mm5: each word range: -255 to 255
			movq mm0, mm5        ;if (? == -255) ? = -256;
			movq mm1, mm5        ;if (? ==  255) ? =  256;
			pcmpeqw mm0, mskp255 ;if (mm0.w[#] == 0x00ff) mm0.w[#] = 0xffff
			pcmpeqw mm1, mskn255 ;if (mm1.w[#] == 0xff01) mm1.w[#] = 0xffff
			psubw mm5, mm0
			paddw mm5, mm1
			psllw mm5, 4         ;mm5: [-WBa-WBr-WBg-WBb]
			movq mm6, rgbmask64
		}
		for(y=y0,vv=y*vi+v;y<y1;y++,vv+=vi)
		{
			p = ylookup[y] + frameplace; j = (vv>>16)*tp + tf;
			for(x=x0,uu=x*ui+u;x<x1;x++,uu+=ui)
			{
				i = *(long *)(((uu>>16)<<2) + j);

				_asm
				{
						;                (mm5)              (mm4)
						;i.a = i.a*(white.a-black.a)/256 + black.a
						;i.r = i.r*(white.r-black.r)/256 + black.r
						;i.g = i.g*(white.g-black.g)/256 + black.g
						;i.b = i.b*(white.b-black.b)/256 + black.b
					movd mm0, i           ;mm1: [00000000AaRrGgBb]
					punpcklbw mm0, mm7    ;mm1: [00Aa00Rr00Gg00Bb]
					psllw mm0, 4          ;mm1: [0Aa00Rr00Gg00Bb0]
					pmulhw mm0, mm5       ;mm1: [--Aa--Rr--Gg--Bb]
					paddw mm0, mm4        ;mm1: [00Aa00Rr00Gg00Bb]
					movq mm1, mm0
					packuswb mm0, mm0     ;mm1: [AaRrGgBbAaRrGgBb]
					movd i, mm0
				}

					//a = (((unsigned long)i)>>24);
					//if (!a) continue;
					//if (a == 255) { *(long *)((x<<2)+p) = i; continue; }
				if ((unsigned long)(i+0x1000000) < 0x2000000)
				{
					if (i < 0) *(long *)((x<<2)+p) = i;
					continue;
				}
				_asm
				{
					mov eax, x            ;mm0 = (mm1-mm0)*a + mm0
					mov edx, p
					lea eax, [eax*4+edx]
					movd mm0, [eax]       ;mm0: [00000000AaRrGgBb]
					;movd mm1, i           ;mm1: [00000000AaRrGgBb]
					pand mm0, mm6         ;zero alpha from screen pixel
					punpcklbw mm0, mm7    ;mm0: [00Aa00Rr00Gg00Bb]
					;punpcklbw mm1, mm7    ;mm1: [00Aa00Rr00Gg00Bb]
					psubw mm1, mm0        ;mm1: [--Aa--Rr--Gg--Bb] range:+-255
					psllw mm1, 4          ;mm1: [-Aa0-Rr0-Gg0-Bb0]
					pshufw mm2, mm1, 0xff ;mm2: [-Aa0-Aa0-Aa0-Aa0]
					pmulhw mm1, mm2
					;mov edx, a            ;alphalookup[i] = i*0x001000100010;
					;pmulhw mm1, alphalookup[edx*8]
					paddw mm0, mm1
					packuswb mm0, mm0
					movd [eax], mm0
				}
			}
		}
		_asm emms
	}
}

void drawline2d (float x1, float y1, float x2, float y2, long col)
{
	float dx, dy, fxresm1, fyresm1;
	long i, j, incr, ie;

	dx = x2-x1; dy = y2-y1; if ((dx == 0) && (dy == 0)) return;
	fxresm1 = (float)xres-.5; fyresm1 = (float)yres-.5;
	if (x1 >= fxresm1) { if (x2 >= fxresm1) return; y1 += (fxresm1-x1)*dy/dx; x1 = fxresm1; }
	else if (x1 < 0) { if (x2 < 0) return; y1 += (0-x1)*dy/dx; x1 = 0; }
	if (x2 >= fxresm1) { y2 += (fxresm1-x2)*dy/dx; x2 = fxresm1; }
	else if (x2 < 0) { y2 += (0-x2)*dy/dx; x2 = 0; }
	if (y1 >= fyresm1) { if (y2 >= fyresm1) return; x1 += (fyresm1-y1)*dx/dy; y1 = fyresm1; }
	else if (y1 < 0) { if (y2 < 0) return; x1 += (0-y1)*dx/dy; y1 = 0; }
	if (y2 >= fyresm1) { x2 += (fyresm1-y2)*dx/dy; y2 = fyresm1; }
	else if (y2 < 0) { x2 += (0-y2)*dx/dy; y2 = 0; }

	if (fabs(dx) >= fabs(dy))
	{
		if (x2 > x1) { ftol(x1,&i); ftol(x2,&ie); } else { ftol(x2,&i); ftol(x1,&ie); }
		if (i < 0) i = 0; if (ie >= xres) ie = xres-1;
		ftol(1048576.0*dy/dx,&incr); ftol(y1*1048576.0+((float)i+.5f-x1)*incr,&j);
		for(;i<=ie;i++,j+=incr)
			if ((unsigned long)(j>>20) < (unsigned long)yres)
				*(long *)(ylookup[j>>20]+(i<<2)+frameplace) = col;
	}
	else
	{
		if (y2 > y1) { ftol(y1,&i); ftol(y2,&ie); } else { ftol(y2,&i); ftol(y1,&ie); }
		if (i < 0) i = 0; if (ie >= yres) ie = yres-1;
		ftol(1048576.0*dx/dy,&incr); ftol(x1*1048576.0+((float)i+.5f-y1)*incr,&j);
		for(;i<=ie;i++,j+=incr)
			if ((unsigned long)(j>>20) < (unsigned long)xres)
				*(long *)(ylookup[i]+((j>>18)&~3)+frameplace) = col;
	}
}

#if (USEZBUFFER == 1)
void drawline2dclip (float x1, float y1, float x2, float y2, float rx0, float ry0, float rz0, float rx1, float ry1, float rz1, long col)
{
	float dx, dy, fxresm1, fyresm1, Za, Zb, Zc, z;
	long i, j, incr, ie, p;

	dx = x2-x1; dy = y2-y1; if ((dx == 0) && (dy == 0)) return;
	fxresm1 = (float)xres-.5; fyresm1 = (float)yres-.5;
	if (x1 >= fxresm1) { if (x2 >= fxresm1) return; y1 += (fxresm1-x1)*dy/dx; x1 = fxresm1; }
	else if (x1 < 0) { if (x2 < 0) return; y1 += (0-x1)*dy/dx; x1 = 0; }
	if (x2 >= fxresm1) { y2 += (fxresm1-x2)*dy/dx; x2 = fxresm1; }
	else if (x2 < 0) { y2 += (0-x2)*dy/dx; x2 = 0; }
	if (y1 >= fyresm1) { if (y2 >= fyresm1) return; x1 += (fyresm1-y1)*dx/dy; y1 = fyresm1; }
	else if (y1 < 0) { if (y2 < 0) return; x1 += (0-y1)*dx/dy; y1 = 0; }
	if (y2 >= fyresm1) { x2 += (fyresm1-y2)*dx/dy; y2 = fyresm1; }
	else if (y2 < 0) { x2 += (0-y2)*dx/dy; y2 = 0; }

	if (fabs(dx) >= fabs(dy))
	{
			//Original equation: (rz1*t+rz0) / (rx1*t+rx0) = gihz/(sx-gihx)
		Za = gihz*(rx0*rz1 - rx1*rz0); Zb = rz1; Zc = -gihx*rz1 - gihz*rx1;

		if (x2 > x1) { ftol(x1,&i); ftol(x2,&ie); } else { ftol(x2,&i); ftol(x1,&ie); }
		if (i < 0) i = 0; if (ie >= xres) ie = xres-1;
		ftol(1048576.0*dy/dx,&incr); ftol(y1*1048576.0+((float)i+.5f-x1)*incr,&j);
		for(;i<=ie;i++,j+=incr)
			if ((unsigned long)(j>>20) < (unsigned long)yres)
			{
				p = ylookup[j>>20]+(i<<2)+frameplace;
				z = Za / ((float)i*Zb + Zc);
				if (*(unsigned long *)&z >= *(unsigned long *)(p+zbufoff)) continue;
				*(long *)(p+zbufoff) = *(long *)&z;
				*(long *)p = col;
			}
	}
	else
	{
		Za = gihz*(ry0*rz1 - ry1*rz0); Zb = rz1; Zc = -gihy*rz1 - gihz*ry1;

		if (y2 > y1) { ftol(y1,&i); ftol(y2,&ie); } else { ftol(y2,&i); ftol(y1,&ie); }
		if (i < 0) i = 0; if (ie >= yres) ie = yres-1;
		ftol(1048576.0*dx/dy,&incr); ftol(x1*1048576.0+((float)i+.5f-y1)*incr,&j);
		for(;i<=ie;i++,j+=incr)
			if ((unsigned long)(j>>20) < (unsigned long)xres)
			{
				p = ylookup[i]+((j>>18)&~3)+frameplace;
				z = Za / ((float)i*Zb + Zc);
				if (*(unsigned long *)&z >= *(unsigned long *)(p+zbufoff)) continue;
				*(long *)(p+zbufoff) = *(long *)&z;
				*(long *)p = col;
			}
	}
}
#endif

void drawline3d (float x0, float y0, float z0, float x1, float y1, float z1, long col)
{
	float ox, oy, oz, r;

	ox = x0-gipos.x; oy = y0-gipos.y; oz = z0-gipos.z;
	x0 = ox*gistr.x + oy*gistr.y + oz*gistr.z;
	y0 = ox*gihei.x + oy*gihei.y + oz*gihei.z;
	z0 = ox*gifor.x + oy*gifor.y + oz*gifor.z;

	ox = x1-gipos.x; oy = y1-gipos.y; oz = z1-gipos.z;
	x1 = ox*gistr.x + oy*gistr.y + oz*gistr.z;
	y1 = ox*gihei.x + oy*gihei.y + oz*gihei.z;
	z1 = ox*gifor.x + oy*gifor.y + oz*gifor.z;

	if (z0 < SCISDIST)
	{
		if (z1 < SCISDIST) return;
		r = (SCISDIST-z0)/(z1-z0); z0 = SCISDIST;
		x0 += (x1-x0)*r; y0 += (y1-y0)*r;
	}
	else if (z1 < SCISDIST)
	{
		r = (SCISDIST-z1)/(z1-z0); z1 = SCISDIST;
		x1 += (x1-x0)*r; y1 += (y1-y0)*r;
	}

	ox = gihz/z0;
	oy = gihz/z1;

#if (USEZBUFFER == 1)
	if (!(col&0xff000000))
		drawline2dclip(x0*ox+gihx,y0*ox+gihy,x1*oy+gihx,y1*oy+gihy,x0,y0,z0,x1-x0,y1-y0,z1-z0,col);
	else
		drawline2d(x0*ox+gihx,y0*ox+gihy,x1*oy+gihx,y1*oy+gihy,col&0xffffff);
#else
	drawline2d(x0*ox+gihx,y0*ox+gihy,x1*oy+gihx,y1*oy+gihy,col);
#endif
}

	//If radius is negative, then it uses Z-buffering
void drawspherefill (float ox, float oy, float oz, float bakrad, long col)
{
	float a, b, c, d, e, f, g, h, t, cxcx, cycy, Za, Zb, Zc, ysq;
	float r2a, rr2a, nb, nbi, isq, isqi, isqii, cx, cy, cz, rad;
	long sx1, sy1, sx2, sy2, p, sx;

	rad = fabs(bakrad);
#if (USEZBUFFER == 0)
	bakrad = rad;
#endif

	ox -= gipos.x; oy -= gipos.y; oz -= gipos.z;
	cz = ox*gifor.x + oy*gifor.y + oz*gifor.z; if (cz < SCISDIST) return;
	cx = ox*gistr.x + oy*gistr.y + oz*gistr.z;
	cy = ox*gihei.x + oy*gihei.y + oz*gihei.z;

		//3D Sphere projection (see spherast.txt for derivation) (13 multiplies)
	cxcx = cx*cx; cycy = cy*cy; g = rad*rad - cxcx - cycy - cz*cz;
	a = g + cxcx; if (!a) return;
	b = cx*cy; b += b;
	c = g + cycy;
	f = gihx*cx + gihy*cy - gihz*cz;
	d = -cx*f - gihx*g; d += d;
	e = -cy*f - gihy*g; e += e;
	f = f*f + g*(gihx*gihx+gihy*gihy+gihz*gihz);

		//isq = (b*b-4*a*c)yý + (2*b*d-4*a*e)y + (d*d-4*a*f) = 0
	Za = b*b - a*c*4; if (!Za) return;
	Zb = b*d*2 - a*e*4;
	Zc = d*d - a*f*4;
	ysq = Zb*Zb - Za*Zc*4; if (ysq <= 0) return;
	t = sqrt(ysq); //fsqrtasm(&ysq,&t);
	h = .5f / Za;
	ftol((-Zb+t)*h,&sy1); if (sy1 < 0) sy1 = 0;
	ftol((-Zb-t)*h,&sy2); if (sy2 > yres) sy2 = yres;
	if (sy1 >= sy2) return;
	r2a = .5f / a; rr2a = r2a*r2a;
	nbi = -b*r2a; nb = nbi*(float)sy1-d*r2a;
	h = Za*(float)sy1; isq = ((float)sy1*(h+Zb)+Zc)*rr2a;
	isqi = (h+h+Za+Zb)*rr2a; isqii = Za*rr2a*2;

	p = ylookup[sy1]+frameplace;
	sy2 = ylookup[sy2]+frameplace;
#if (USEZBUFFER == 1)
	if ((*(long *)&bakrad) >= 0)
	{
#endif
		while (1)  //(a)xý + (b*y+d)x + (c*y*y+e*y+f) = 0
		{
			t = sqrt(isq); //fsqrtasm(&isq,&t);
			ftol(nb-t,&sx1); if (sx1 < 0) sx1 = 0;
			ftol(nb+t,&sx2);
			sx2 = min(sx2,xres)-sx1;
			if (sx2 > 0) clearbuf((void *)((sx1<<2)+p),sx2,col);
			p += bytesperline; if (p >= sy2) return;
			isq += isqi; isqi += isqii; nb += nbi;
		}
#if (USEZBUFFER == 1)
	}
	else
	{     //Use Z-buffering

		if (ofogdist >= 0) //If fog enabled...
		{
			ftol(sqrt(ox*ox + oy*oy),&sx); //Use cylindrical x-y distance for fog
			if (sx > 2047) sx = 2047;
			sx = (long)(*(short *)&foglut[sx]);
			col = ((((( vx5.fogcol     &255)-( col     &255))*sx)>>15)    ) +
					((((((vx5.fogcol>> 8)&255)-((col>> 8)&255))*sx)>>15)<< 8) +
					((((((vx5.fogcol>>16)&255)-((col>>16)&255))*sx)>>15)<<16) + col;
		}

		while (1)  //(a)xý + (b*y+d)x + (c*y*y+e*y+f) = 0
		{
			t = sqrt(isq); //fsqrtasm(&isq,&t);
			ftol(nb-t,&sx1); if (sx1 < 0) sx1 = 0;
			ftol(nb+t,&sx2);
			if (sx2 > xres) sx2 = xres;
			for(sx=sx1;sx<sx2;sx++)
				if (*(unsigned long *)&cz < *(unsigned long *)(p+(sx<<2)+zbufoff))
				{
					*(long *)(p+(sx<<2)+zbufoff) = *(long *)&cz;
					*(long *)(p+(sx<<2)) = col;
				}
			sy1++;
			p += bytesperline; if (p >= sy2) return;
			isq += isqi; isqi += isqii; nb += nbi;
		}
	}
#endif
}

void drawpicinquad (long rpic, long rbpl, long rxsiz, long rysiz,
						  long wpic, long wbpl, long wxsiz, long wysiz,
						  float x0, float y0, float x1, float y1,
						  float x2, float y2, float x3, float y3)
{
	float px[4], py[4], k0, k1, k2, k3, k4, k5, k6, k7, k8;
	float t, u, v, dx, dy, l0, l1, m0, m1, m2, n0, n1, n2, r;
	long i, j, k, l, imin, imax, sx, sxe, sy, sy1, dd, uu, vv, ddi, uui, vvi;
	long x, xi, *p, *pe, uvmax, iu, iv;

	px[0] = x0; px[1] = x1; px[2] = x2; px[3] = x3;
	py[0] = y0; py[1] = y1; py[2] = y2; py[3] = y3;

		//This code projects 4 point2D's into a t,u,v screen-projection matrix
		//
		//Derivation: (given 4 known (sx,sy,kt,ku,kv) pairs, solve for k0-k8)
		//   kt = k0*sx + k1*sy + k2
		//   ku = k3*sx + k4*sy + k5
		//   kv = k6*sx + k7*sy + k8
		//0 = (k3*x0 + k4*y0 + k5) / (k0*x0 + k1*y0 + k2) / rxsiz
		//0 = (k6*x0 + k7*y0 + k8) / (k0*x0 + k1*y0 + k2) / rysiz
		//1 = (k3*x1 + k4*y1 + k5) / (k0*x1 + k1*y1 + k2) / rxsiz
		//0 = (k6*x1 + k7*y1 + k8) / (k0*x1 + k1*y1 + k2) / rysiz
		//1 = (k3*x2 + k4*y2 + k5) / (k0*x2 + k1*y2 + k2) / rxsiz
		//1 = (k6*x2 + k7*y2 + k8) / (k0*x2 + k1*y2 + k2) / rysiz
		//0 = (k3*x3 + k4*y3 + k5) / (k0*x3 + k1*y3 + k2) / rxsiz
		//1 = (k6*x3 + k7*y3 + k8) / (k0*x3 + k1*y3 + k2) / rysiz
		//   40*, 28+, 1~, 30W
	k3 = y3 - y0; k4 = x0 - x3; k5 = x3*y0 - x0*y3;
	k6 = y0 - y1; k7 = x1 - x0; k8 = x0*y1 - x1*y0;
	n0 = x2*y3 - x3*y2; n1 = x3*y1 - x1*y3; n2 = x1*y2 - x2*y1;
	l0 = k6*x2 + k7*y2 + k8;
	l1 = k3*x2 + k4*y2 + k5;
	t = n0 + n1 + n2; dx = (float)rxsiz*t*l0; dy = (float)rysiz*t*l1;
	t = l0*l1;
	l0 *= (k3*x1 + k4*y1 + k5);
	l1 *= (k6*x3 + k7*y3 + k8);
	m0 = l1 - t; m1 = l0 - l1; m2 = t - l0;
	k0 = m0*y1 + m1*y2 + m2*y3;
	k1 = -(m0*x1 + m1*x2 + m2*x3);
	k2 = n0*l0 + n1*t + n2*l1;
	k3 *= dx; k4 *= dx; k5 *= dx;
	k6 *= dy; k7 *= dy; k8 *= dy;

		//Make sure k's are in good range for conversion to integers...
	t = fabs(k0);
	if (fabs(k1) > t) t = fabs(k1);
	if (fabs(k2) > t) t = fabs(k2);
	if (fabs(k3) > t) t = fabs(k3);
	if (fabs(k4) > t) t = fabs(k4);
	if (fabs(k5) > t) t = fabs(k5);
	if (fabs(k6) > t) t = fabs(k6);
	if (fabs(k7) > t) t = fabs(k7);
	if (fabs(k8) > t) t = fabs(k8);
	t = -268435456.0 / t;
	k0 *= t; k1 *= t; k2 *= t;
	k3 *= t; k4 *= t; k5 *= t;
	k6 *= t; k7 *= t; k8 *= t;
	ftol(k0,&ddi);

	imin = 0; imax = 0;
	for(i=1;i<4;i++)
	{
		if (py[i] < py[imin]) imin = i;
		if (py[i] > py[imax]) imax = i;
	}

	uvmax = (rysiz-1)*rbpl + (rxsiz<<2);

	i = imax;
	do
	{
		j = ((i+1)&3);
			//offset would normally be -.5, but need to bias by +1.0
		ftol(py[j]+.5,&sy); if (sy < 0) sy = 0;
		ftol(py[i]+.5,&sy1); if (sy1 > wysiz) sy1 = wysiz;
		if (sy1 > sy)
		{
			ftol((px[i]-px[j])*4096.0/(py[i]-py[j]),&xi);
			ftol(((float)sy-py[j])*(float)xi + px[j]*4096.0 + 4096.0,&x);
			for(;sy<sy1;sy++,x+=xi) lastx[sy] = (x>>12);
		}
		i = j;
	} while (i != imin);
	do
	{
		j = ((i+1)&3);
			//offset would normally be -.5, but need to bias by +1.0
		ftol(py[i]+.5,&sy); if (sy < 0) sy = 0;
		ftol(py[j]+.5,&sy1); if (sy1 > wysiz) sy1 = wysiz;
		if (sy1 > sy)
		{
			ftol((px[j]-px[i])*4096.0/(py[j]-py[i]),&xi);
			ftol(((float)sy-py[i])*(float)xi + px[i]*4096.0 + 4096.0,&x);
			for(;sy<sy1;sy++,x+=xi)
			{
				sx = lastx[sy]; if (sx < 0) sx = 0;
				sxe = (x>>12); if (sxe > wxsiz) sxe = wxsiz;
				if (sx >= sxe) continue;
				t = k0*(float)sx + k1*(float)sy + k2; r = 1.0 / t;
				u = k3*(float)sx + k4*(float)sy + k5; ftol(u*r-.5,&iu);
				v = k6*(float)sx + k7*(float)sy + k8; ftol(v*r-.5,&iv);
				ftol(t,&dd);
				ftol((float)iu*k0 - k3,&uui); ftol((float)iu*t - u,&uu);
				ftol((float)iv*k0 - k6,&vvi); ftol((float)iv*t - v,&vv);
				if (k3*t < u*k0) k =    -4; else { uui = -(uui+ddi); uu = -(uu+dd); k =    4; }
				if (k6*t < v*k0) l = -rbpl; else { vvi = -(vvi+ddi); vv = -(vv+dd); l = rbpl; }
				iu = iv*rbpl + (iu<<2);
				p  = (long *)(sy*wbpl+(sx<<2)+wpic);
				pe = (long *)(sy*wbpl+(sxe<<2)+wpic);
				do
				{
					if ((unsigned long)iu < uvmax) p[0] = *(long *)(rpic+iu);
					dd += ddi;
					uu += uui; while (uu < 0) { iu += k; uui -= ddi; uu -= dd; }
					vv += vvi; while (vv < 0) { iu += l; vvi -= ddi; vv -= dd; }
					p++;
				} while (p < pe);
			}
		}
		i = j;
	} while (i != imax);
}

__declspec(align(16)) static float dpqdistlut[MAXXDIM];
__declspec(align(16)) static float dpqmulval[4] = {0,1,2,3}, dpqfour[4] = {4,4,4,4};
__declspec(align(8)) static float dpq3dn[4];
void drawpolyquad (long rpic, long rbpl, long rxsiz, long rysiz,
						 float x0, float y0, float z0, float u0, float v0,
						 float x1, float y1, float z1, float u1, float v1,
						 float x2, float y2, float z2, float u2, float v2,
						 float x3, float y3, float z3)
{
	point3d fp, fp2;
	float px[6], py[6], pz[6], pu[6], pv[6], px2[4], py2[4], pz2[4], pu2[4], pv2[4];
	float f, t, u, v, r, nx, ny, nz, ox, oy, oz, scaler;
	float dx, dy, db, ux, uy, ub, vx, vy, vb;
	long i, j, k, l, imin, imax, sx, sxe, sy, sy1;
	long x, xi, *p, *pe, uvmax, iu, iv, n;
	long dd, uu, vv, ddi, uui, vvi, distlutoffs;

	px2[0] = x0; py2[0] = y0; pz2[0] = z0; pu2[0] = u0; pv2[0] = v0;
	px2[1] = x1; py2[1] = y1; pz2[1] = z1; pu2[1] = u1; pv2[1] = v1;
	px2[2] = x2; py2[2] = y2; pz2[2] = z2; pu2[2] = u2; pv2[2] = v2;
	px2[3] = x3; py2[3] = y3; pz2[3] = z3;

		//Calculate U-V coordinate of 4th point on quad (based on 1st 3)
	nx = (y1-y0)*(z2-z0) - (z1-z0)*(y2-y0);
	ny = (z1-z0)*(x2-x0) - (x1-x0)*(z2-z0);
	nz = (x1-x0)*(y2-y0) - (y1-y0)*(x2-x0);
	if ((fabs(nx) > fabs(ny)) && (fabs(nx) > fabs(nz)))
	{     //(y1-y0)*u + (y2-y0)*v = (y3-y0)
			//(z1-z0)*u + (z2-z0)*v = (z3-z0)
		f = 1/nx;
		u = ((y3-y0)*(z2-z0) - (z3-z0)*(y2-y0))*f;
		v = ((y1-y0)*(z3-z0) - (z1-z0)*(y3-y0))*f;
	}
	else if (fabs(ny) > fabs(nz))
	{     //(x1-x0)*u + (x2-x0)*v = (x3-x0)
			//(z1-z0)*u + (z2-z0)*v = (z3-z0)
		f = -1/ny;
		u = ((x3-x0)*(z2-z0) - (z3-z0)*(x2-x0))*f;
		v = ((x1-x0)*(z3-z0) - (z1-z0)*(x3-x0))*f;
	}
	else
	{     //(x1-x0)*u + (x2-x0)*v = (x3-x0)
			//(y1-y0)*u + (y2-y0)*v = (y3-y0)
		f = 1/nz;
		u = ((x3-x0)*(y2-y0) - (y3-y0)*(x2-x0))*f;
		v = ((x1-x0)*(y3-y0) - (y1-y0)*(x3-x0))*f;
	}
	pu2[3] = (u1-u0)*u + (u2-u0)*v + u0;
	pv2[3] = (v1-v0)*u + (v2-v0)*v + v0;


	for(i=4-1;i>=0;i--) //rotation
	{
		fp.x = px2[i]-gipos.x; fp.y = py2[i]-gipos.y; fp.z = pz2[i]-gipos.z;
		px2[i] = fp.x*gistr.x + fp.y*gistr.y + fp.z*gistr.z;
		py2[i] = fp.x*gihei.x + fp.y*gihei.y + fp.z*gihei.z;
		pz2[i] = fp.x*gifor.x + fp.y*gifor.y + fp.z*gifor.z;
	}

		//Clip to SCISDIST plane
	n = 0;
	for(i=0;i<4;i++)
	{
		j = ((i+1)&3);
		if (pz2[i] >= SCISDIST) { px[n] = px2[i]; py[n] = py2[i]; pz[n] = pz2[i]; pu[n] = pu2[i]; pv[n] = pv2[i]; n++; }
		if ((pz2[i] >= SCISDIST) != (pz2[j] >= SCISDIST))
		{
			f = (SCISDIST-pz2[i])/(pz2[j]-pz2[i]);
			px[n] = (px2[j]-px2[i])*f + px2[i];
			py[n] = (py2[j]-py2[i])*f + py2[i];
			pz[n] = SCISDIST;
			pu[n] = (pu2[j]-pu2[i])*f + pu2[i];
			pv[n] = (pv2[j]-pv2[i])*f + pv2[i]; n++;
		}
	}
	if (n < 3) return;

	for(i=n-1;i>=0;i--) //projection
	{
		pz[i] = 1/pz[i]; f = pz[i]*gihz;
		px[i] = px[i]*f + gihx;
		py[i] = py[i]*f + gihy;
	}

		//General equations:
		//pz[i] = (px[i]*gdx + py[i]*gdy + gdo)
		//pu[i] = (px[i]*gux + py[i]*guy + guo)/pz[i]
		//pv[i] = (px[i]*gvx + py[i]*gvy + gvo)/pz[i]
		//
		//px[0]*gdx + py[0]*gdy + 1*gdo = pz[0]
		//px[1]*gdx + py[1]*gdy + 1*gdo = pz[1]
		//px[2]*gdx + py[2]*gdy + 1*gdo = pz[2]
		//
		//px[0]*gux + py[0]*guy + 1*guo = pu[0]*pz[0] (pu[i] premultiplied by pz[i] above)
		//px[1]*gux + py[1]*guy + 1*guo = pu[1]*pz[1]
		//px[2]*gux + py[2]*guy + 1*guo = pu[2]*pz[2]
		//
		//px[0]*gvx + py[0]*gvy + 1*gvo = pv[0]*pz[0] (pv[i] premultiplied by pz[i] above)
		//px[1]*gvx + py[1]*gvy + 1*gvo = pv[1]*pz[1]
		//px[2]*gvx + py[2]*gvy + 1*gvo = pv[2]*pz[2]
	pu[0] *= pz[0]; pu[1] *= pz[1]; pu[2] *= pz[2];
	pv[0] *= pz[0]; pv[1] *= pz[1]; pv[2] *= pz[2];
	ox = py[1]-py[2]; oy = py[2]-py[0]; oz = py[0]-py[1];
	r = 1.0 / (ox*px[0] + oy*px[1] + oz*px[2]);
	dx = (ox*pz[0] + oy*pz[1] + oz*pz[2])*r;
	ux = (ox*pu[0] + oy*pu[1] + oz*pu[2])*r;
	vx = (ox*pv[0] + oy*pv[1] + oz*pv[2])*r;
	ox = px[2]-px[1]; oy = px[0]-px[2]; oz = px[1]-px[0];
	dy = (ox*pz[0] + oy*pz[1] + oz*pz[2])*r;
	uy = (ox*pu[0] + oy*pu[1] + oz*pu[2])*r;
	vy = (ox*pv[0] + oy*pv[1] + oz*pv[2])*r;
	db = pz[0] - px[0]*dx - py[0]*dy;
	ub = pu[0] - px[0]*ux - py[0]*uy;
	vb = pv[0] - px[0]*vx - py[0]*vy;

#if 1
		//Make sure k's are in good range for conversion to integers...
	t = fabs(ux);
	if (fabs(uy) > t) t = fabs(uy);
	if (fabs(ub) > t) t = fabs(ub);
	if (fabs(vx) > t) t = fabs(vx);
	if (fabs(vy) > t) t = fabs(vy);
	if (fabs(vb) > t) t = fabs(vb);
	if (fabs(dx) > t) t = fabs(dx);
	if (fabs(dy) > t) t = fabs(dy);
	if (fabs(db) > t) t = fabs(db);
	scaler = -268435456.0 / t;
	ux *= scaler; uy *= scaler; ub *= scaler;
	vx *= scaler; vy *= scaler; vb *= scaler;
	dx *= scaler; dy *= scaler; db *= scaler;
	ftol(dx,&ddi);
	uvmax = (rysiz-1)*rbpl + (rxsiz<<2);

	scaler = 1.f/scaler; t = dx*scaler;
	if (cputype&(1<<25))
	{
		_asm //SSE
		{
			movss xmm6, t         ;xmm6: -,-,-,dx*scaler
			shufps xmm6, xmm6, 0  ;xmm6: dx*scaler,dx*scaler,dx*scaler,dx*scaler
			movaps xmm7, xmm6     ;xmm7: dx*scaler,dx*scaler,dx*scaler,dx*scaler
			mulps xmm6, dpqmulval ;xmm6: dx*scaler*3,dx*scaler*2,dx*scaler*1,0
			mulps xmm7, dpqfour   ;xmm7: dx*scaler*4,dx*scaler*4,dx*scaler*4,dx*scaler*4
		}
	}
	else { dpq3dn[0] = 0; dpq3dn[1] = t; dpq3dn[2] = dpq3dn[3] = t+t; } //3DNow!
#endif

	imin = (py[1]<py[0]); imax = 1-imin;
	for(i=n-1;i>1;i--)
	{
		if (py[i] < py[imin]) imin = i;
		if (py[i] > py[imax]) imax = i;
	}

	i = imax;
	do
	{
		j = i+1; if (j >= n) j = 0;
			//offset would normally be -.5, but need to bias by +1.0
		ftol(py[j]+.5,&sy); if (sy < 0) sy = 0;
		ftol(py[i]+.5,&sy1); if (sy1 > yres) sy1 = yres;
		if (sy1 > sy)
		{
			ftol((px[i]-px[j])*4096.0/(py[i]-py[j]),&xi);
			ftol(((float)sy-py[j])*(float)xi + px[j]*4096.0 + 4096.0,&x);
			for(;sy<sy1;sy++,x+=xi) lastx[sy] = (x>>12);
		}
		i = j;
	} while (i != imin);
	do
	{
		j = i+1; if (j >= n) j = 0;
			//offset would normally be -.5, but need to bias by +1.0
		ftol(py[i]+.5,&sy); if (sy < 0) sy = 0;
		ftol(py[j]+.5,&sy1); if (sy1 > yres) sy1 = yres;
		if (sy1 > sy)
		{
			ftol((px[j]-px[i])*4096.0/(py[j]-py[i]),&xi);
			ftol(((float)sy-py[i])*(float)xi + px[i]*4096.0 + 4096.0,&x);
			for(;sy<sy1;sy++,x+=xi)
			{
				sx = lastx[sy]; if (sx < 0) sx = 0;
				sxe = (x>>12); if (sxe > xres) sxe = xres;
				if (sx >= sxe) continue;
				p  = (long *)(sy*bytesperline+(sx<<2)+frameplace);
				pe = (long *)(sy*bytesperline+(sxe<<2)+frameplace);
#if 0
					//Brute force
				do
				{
					f = 1.f/(dx*(float)sx + dy*(float)sy + db);
					if (f < *(float *)(((long)p)+zbufoff))
					{
						*(float *)(((long)p)+zbufoff) = f;
						ftol((ux*(float)sx + uy*(float)sy + ub)*f-.5,&iu);
						ftol((vx*(float)sx + vy*(float)sy + vb)*f-.5,&iv);
						if ((unsigned long)iu >= rxsiz) iu = 0;
						if ((unsigned long)iv >= rysiz) iv = 0;
						p[0] = *(long *)(iv*rbpl+(iu<<2)+rpic);
					}
					p++; sx++;
				} while (p < pe);
#else
					//Optimized (in C) hyperbolic texture-mapping (Added Z-buffer using SSE/3DNow! for recip's)
				t = dx*(float)sx + dy*(float)sy + db; r = 1.0 / t;
				u = ux*(float)sx + uy*(float)sy + ub; ftol(u*r-.5,&iu);
				v = vx*(float)sx + vy*(float)sy + vb; ftol(v*r-.5,&iv);
				ftol(t,&dd);
				ftol((float)iu*dx - ux,&uui); ftol((float)iu*t - u,&uu);
				ftol((float)iv*dx - vx,&vvi); ftol((float)iv*t - v,&vv);
				if (ux*t < u*dx) k =    -4; else { uui = -(uui+ddi); uu = -(uu+dd); k =    4; }
				if (vx*t < v*dx) l = -rbpl; else { vvi = -(vvi+ddi); vv = -(vv+dd); l = rbpl; }
				iu = iv*rbpl + (iu<<2);

				t *= scaler;
				_asm
				{
					mov ecx, sxe
					sub ecx, sx
					xor eax, eax
					lea ecx, [ecx*4]
					sub eax, ecx
					add ecx, offset dpqdistlut

					test cputype, 1 shl 25
					jz short dpqpre3dn

					movss xmm0, t ;dd+ddi*3 dd+ddi*2 dd+ddi*1 dd+ddi*0
					shufps xmm0, xmm0, 0
					addps xmm0, xmm6
	 dpqbegsse: rcpps xmm1, xmm0
					addps xmm0, xmm7
					movaps [eax+ecx], xmm1
					add eax, 16
					jl short dpqbegsse
					jmp short dpqendit

	 dpqpre3dn: movd mm0, t ;dd+ddi*1 dd+ddi*0
					punpckldq mm0, mm0
					pfadd mm0, dpq3dn[0]
					movq mm7, dpq3dn[8]
	 dpqbeg3dn: pswapd mm2, mm0
					pfrcp mm1, mm0     ;mm1: 1/mm0l 1/mm0l
					pfrcp mm2, mm2     ;mm2: 1/mm0h 1/mm0h
					punpckldq mm1, mm2 ;mm1: 1/mm0h 1/mm0l
					pfadd mm0, mm7
					movq [eax+ecx], mm1
					add eax, 8
					jl short dpqbeg3dn
					femms
	  dpqendit:
				}
				distlutoffs = ((long)dpqdistlut)-((long)p);
				do
				{
#if (USEZBUFFER != 0)
					if (*(unsigned long *)(((long)p)+zbufoff) > *(unsigned long *)(((long)p)+distlutoffs))
					{
						*(long *)(((long)p)+zbufoff) = *(long *)(((long)p)+distlutoffs);
#endif
						if ((unsigned long)iu < uvmax) p[0] = *(long *)(rpic+iu);
#if (USEZBUFFER != 0)
					}
#endif
					dd += ddi;
					uu += uui; while (uu < 0) { iu += k; uui -= ddi; uu -= dd; }
					vv += vvi; while (vv < 0) { iu += l; vvi -= ddi; vv -= dd; }
					p++;
				} while (p < pe);
#endif
			}
		}
		i = j;
	} while (i != imax);
}

//------------------------- SXL parsing code begins --------------------------

static char *sxlbuf = 0;
static long sxlparspos, sxlparslen;

long loadsxl (const char *sxlnam, char **vxlnam, char **skynam, char **globst)
{
	long j, k, m, n;

		//NOTE: MUST buffer file because insertsprite uses kz file code :/
	if (!kzopen(sxlnam)) return(0);
	sxlparslen = kzfilelength();
	if (sxlbuf) { free(sxlbuf); sxlbuf = 0; }
	if (!(sxlbuf = (char *)malloc(sxlparslen))) return(0);
	kzread(sxlbuf,sxlparslen);
	kzclose();

	j = n = 0;

		//parse vxlnam
	(*vxlnam) = &sxlbuf[j];
	while ((sxlbuf[j]!=13)&&(sxlbuf[j]!=10) && (j < sxlparslen)) j++; sxlbuf[j++] = 0;
	while (((sxlbuf[j]==13)||(sxlbuf[j]==10)) && (j < sxlparslen)) j++;

		//parse skynam
	(*skynam) = &sxlbuf[j];
	while ((sxlbuf[j]!=13)&&(sxlbuf[j]!=10) && (j < sxlparslen)) j++; sxlbuf[j++] = 0;
	while (((sxlbuf[j]==13)||(sxlbuf[j]==10)) && (j < sxlparslen)) j++;

		//parse globst
	m = n = j; (*globst) = &sxlbuf[n];
	while (((sxlbuf[j] == ' ') || (sxlbuf[j] == 9)) && (j < sxlparslen))
	{
		j++;
		while ((sxlbuf[j]!=13) && (sxlbuf[j]!=10) && (j < sxlparslen)) sxlbuf[n++] = sxlbuf[j++];
		sxlbuf[n++] = 13; j++;
		while (((sxlbuf[j]==13) || (sxlbuf[j]==10)) && (j < sxlparslen)) j++;
	}
	if (n > m) sxlbuf[n-1] = 0; else (*globst) = &nullst;

		//Count number of sprites in .SXL file (helpful for GAME)
	sxlparspos = j;
	return(1);
}

char *parspr (vx5sprite *spr, char **userst)
{
	float f;
	long j, k, m, n;
	char *namptr;

	j = sxlparspos; //unnecessary temp variable (to shorten code)

		//Automatically free temp sxlbuf when done reading sprites
	if (((j+2 < sxlparslen) && (sxlbuf[j] == 'e') && (sxlbuf[j+1] == 'n') && (sxlbuf[j+2] == 'd') &&
		((j+3 == sxlparslen) || (sxlbuf[j+3] == 13) || (sxlbuf[j+3] == 10))) || (j > sxlparslen))
		return(0);

		//parse kv6name
	for(k=j;(sxlbuf[k]!=',') && (k < sxlparslen);k++); sxlbuf[k] = 0;
	namptr = &sxlbuf[j]; j = k+1;

		//parse 12 floats
	for(m=0;m<12;m++)
	{
		if (m < 11) { for(k=j;(sxlbuf[k]!=',') && (k < sxlparslen);k++); }
		else { for(k=j;(sxlbuf[k]!=13) && (sxlbuf[k]!=10) && (k < sxlparslen);k++); }

		sxlbuf[k] = 0; f = atof(&sxlbuf[j]); j = k+1;
		switch(m)
		{
			case  0: spr->p.x = f; break;
			case  1: spr->p.y = f; break;
			case  2: spr->p.z = f; break;
			case  3: spr->s.x = f; break;
			case  4: spr->s.y = f; break;
			case  5: spr->s.z = f; break;
			case  6: spr->h.x = f; break;
			case  7: spr->h.y = f; break;
			case  8: spr->h.z = f; break;
			case  9: spr->f.x = f; break;
			case 10: spr->f.y = f; break;
			case 11: spr->f.z = f; break;
			default: __assume(0); //tells MSVC default can't be reached
		}
	}
	while (((sxlbuf[j]==13) || (sxlbuf[j]==10)) && (j < sxlparslen)) j++;

	spr->flags = 0;

		//parse userst
	m = n = j; (*userst) = &sxlbuf[n];
	while (((sxlbuf[j] == ' ') || (sxlbuf[j] == 9)) && (j < sxlparslen))
	{
		j++;
		while ((sxlbuf[j]!=13) && (sxlbuf[j]!=10) && (j < sxlparslen)) sxlbuf[n++] = sxlbuf[j++];
		sxlbuf[n++] = 13; j++;
		while (((sxlbuf[j]==13) || (sxlbuf[j]==10)) && (j < sxlparslen)) j++;
	}
	if (n > m) sxlbuf[n-1] = 0; else (*userst) = &nullst;

	sxlparspos = j; //unnecessary temp variable (for short code)
	return(namptr);
}

//--------------------------  Name hash code begins --------------------------

	//khashbuf format: (used by getkv6/getkfa to avoid duplicate loads)
	//[long index to next hash or -1][pointer to struct][char type]string[\0]
	//[long index to next hash or -1][pointer to struct][chat type]string[\0]
	//...
	//type:0 = kv6data
	//type:1 = kfatype
#define KHASHINITSIZE 8192
static char *khashbuf = 0;
static long khashead[256], khashpos = 0, khashsiz = 0;

char *getkfilname (long namoff) { return(&khashbuf[namoff]); }

	//Returns: 0,retptr=-1: Error! (bad filename or out of memory)
	//         0,retptr>=0: Not in hash; new name allocated, valid index
	//         1,retptr>=0: Already in hash, valid index
	//   Uses a 256-entry hash to compare names very quickly.
static long inkhash (const char *filnam, long *retind)
{
	long i, j, hashind;

	(*retind) = -1;

	if (!filnam) return(0);
	j = strlen(filnam); if (!j) return(0);
	j += 10;
	if (khashpos+j > khashsiz) //Make sure string fits in khashbuf
	{
		i = khashsiz; do { i <<= 1; } while (khashpos+j > i);
		if (!(khashbuf = (char *)realloc(khashbuf,i))) return(0);
		khashsiz = i;
	}

		//Copy filename to avoid destroying original string
		//Also, calculate hash index (which hopefully is uniformly random :)
	strcpy(&khashbuf[khashpos+9],filnam);
	for(i=khashpos+9,hashind=0;khashbuf[i];i++)
	{
		if ((khashbuf[i] >= 'a') && (khashbuf[i] <= 'z')) khashbuf[i] -= 32;
		if (khashbuf[i] == '/') khashbuf[i] = '\\';
		hashind = (khashbuf[i] - hashind*3);
	}
	hashind %= (sizeof(khashead)/sizeof(khashead[0]));

		//Find if string is already in hash...
	for(i=khashead[hashind];i>=0;i=(*(long *)&khashbuf[i]))
		if (!strcmp(&khashbuf[i+9],&khashbuf[khashpos+9]))
			{ (*retind) = i; return(1); } //Early out: already in hash

	(*retind) = khashpos;
	*(long *)&khashbuf[khashpos] = khashead[hashind];
	*(long *)&khashbuf[khashpos+4] = 0; //Set to 0 just in case load fails
	khashead[hashind] = khashpos; khashpos += j;
	return(0);
}

//-------------------------- KV6 sprite code begins --------------------------

//EQUIVEC code begins -----------------------------------------------------
point3d univec[256];
__declspec(align(8)) short iunivec[256][4];

typedef struct
{
	float fibx[45], fiby[45];
	float azval[20], zmulk, zaddk;
	long fib[47], aztop, npoints;
} equivectyp;
static equivectyp equivec;

#ifdef _MSC_VER

static _inline long dmulshr0 (long a, long d, long s, long t)
{
	_asm
	{
		mov eax, a
		imul d
		mov ecx, eax
		mov eax, s
		imul t
		add eax, ecx
	}
}

#endif

void equiind2vec (long i, float *x, float *y, float *z)
{
	float r;
	(*z) = (float)i*equivec.zmulk + equivec.zaddk; r = sqrt(1.f - (*z)*(*z));
	fcossin((float)i*(GOLDRAT*PI*2),x,y); (*x) *= r; (*y) *= r;
}

	//Very fast; good quality
long equivec2indmem (float x, float y, float z)
{
	long b, i, j, k, bestc;
	float xy, zz, md, d;

	xy = atan2(y,x); //atan2 is 150 clock cycles!
	j = ((*(long *)&z)&0x7fffffff);
	bestc = equivec.aztop;
	do
	{
		if (j < *(long *)&equivec.azval[bestc]) break;
		bestc--;
	} while (bestc);

	zz = z + 1.f;
	ftol(equivec.fibx[bestc]*xy + equivec.fiby[bestc]*zz - .5,&i);
	bestc++;
	ftol(equivec.fibx[bestc]*xy + equivec.fiby[bestc]*zz - .5,&j);

	k = dmulshr0(equivec.fib[bestc+2],i,equivec.fib[bestc+1],j);
	if ((unsigned long)k < equivec.npoints)
	{
		md = univec[k].x*x + univec[k].y*y + univec[k].z*z;
		j = k;
	} else md = -2.f;
	b = bestc+3;
	do
	{
		i = equivec.fib[b] + k;
		if ((unsigned long)i < equivec.npoints)
		{
			d = univec[i].x*x + univec[i].y*y + univec[i].z*z;
			if (*(long *)&d > *(long *)&md) { md = d; j = i; }
		}
		b--;
	} while (b != bestc);
	return(j);
}

void equivecinit (long n)
{
	float t0, t1;
	long z;

		//Init constants for ind2vec
	equivec.npoints = n;
	equivec.zmulk = 2 / (float)n; equivec.zaddk = equivec.zmulk*.5 - 1.0;

		//equimemset
	for(z=n-1;z>=0;z--)
		equiind2vec(z,&univec[z].x,&univec[z].y,&univec[z].z);
	if (n&1) //Hack for when n=255 and want a <0,0,0> vector
		{ univec[n].x = univec[n].y = univec[n].z = 0; }

		//Init Fibonacci table
	equivec.fib[0] = 0; equivec.fib[1] = 1;
	for(z=2;z<47;z++) equivec.fib[z] = equivec.fib[z-2]+equivec.fib[z-1];

		//Init fibx/y LUT
	t0 = .5 / PI; t1 = (float)n * -.5;
	for(z=0;z<45;z++)
	{
		t0 = -t0; equivec.fibx[z] = (float)equivec.fib[z+2]*t0;
		t1 = -t1; equivec.fiby[z] = ((float)equivec.fib[z+2]*GOLDRAT - (float)equivec.fib[z])*t1;
	}

	t0 = 1 / ((float)n * PI);
	for(equivec.aztop=0;equivec.aztop<20;equivec.aztop++)
	{
		t1 = 1 - (float)equivec.fib[(equivec.aztop<<1)+6]*t0; if (t1 < 0) break;
		equivec.azval[equivec.aztop+1] = sqrt(t1);
	}
}

//EQUIVEC code ends -------------------------------------------------------

static long umulmip[9] = {0,4294967295,2147483648,1431655765,1073741824,
								  858993459,715827882,613566756,536870912};
kv6data *genmipkv6 (kv6data *kv6)
{
	kv6data *nkv6;
	kv6voxtype *v0[2], *vs[4], *ve[4], *voxptr;
	unsigned short *xyptr, *xyi2, *sxyi2;
	long i, j, x, y, z, xs, ys, zs, xysiz, n, oxn, oxyn, *xptr;
	long xx, yy, zz, r, g, b, vis, npix, sxyi2i, darand = 0;
	char vecbuf[8];

	if ((!kv6) || (kv6->lowermip)) return(0);

	xs = ((kv6->xsiz+1)>>1); ys = ((kv6->ysiz+1)>>1); zs = ((kv6->zsiz+1)>>1);
	if ((xs < 2) || (ys < 2) || (zs < 2)) return(0);
	xysiz = ((((xs*ys)<<1)+3)&~3);
	i = sizeof(kv6data) + (xs<<2) + xysiz + kv6->numvoxs*sizeof(kv6voxtype);
	nkv6 = (kv6data *)malloc(i);
	if (!nkv6) return(0);

	kv6->lowermip = nkv6;
	nkv6->xsiz = xs;
	nkv6->ysiz = ys;
	nkv6->zsiz = zs;
	nkv6->xpiv = kv6->xpiv*.5;
	nkv6->ypiv = kv6->ypiv*.5;
	nkv6->zpiv = kv6->zpiv*.5;
	nkv6->namoff = 0;
	nkv6->lowermip = 0;

	xptr = (long *)(((long)nkv6) + sizeof(kv6data));
	xyptr = (unsigned short *)(((long)xptr) + (xs<<2));
	voxptr = (kv6voxtype *)(((long)xyptr) + xysiz);
	n = 0;

	v0[0] = kv6->vox; sxyi2 = kv6->ylen; sxyi2i = (kv6->ysiz<<1);
	for(x=0;x<xs;x++)
	{
		v0[1] = v0[0]+kv6->xlen[x<<1];

			//vs: start pointer of each of the 4 columns
			//ve: end pointer of each of the 4 columns
		vs[0] = v0[0]; vs[2] = v0[1];

		xyi2 = sxyi2; sxyi2 += sxyi2i;

		oxn = n;
		for(y=0;y<ys;y++)
		{
			oxyn = n;

			ve[0] = vs[1] = vs[0]+xyi2[0];
			if ((x<<1)+1 < kv6->xsiz) { ve[2] = vs[3] = vs[2]+xyi2[kv6->ysiz]; }
			if ((y<<1)+1 < kv6->ysiz)
			{
				ve[1] = vs[1]+xyi2[1];
				if ((x<<1)+1 < kv6->xsiz) ve[3] = vs[3]+xyi2[kv6->ysiz+1];
			}
			xyi2 += 2;

			while (1)
			{
				z = 0x7fffffff;
				for(i=3;i>=0;i--)
					if ((vs[i] < ve[i]) && (vs[i]->z < z)) z = vs[i]->z;
				if (z == 0x7fffffff) break;

				z |= 1;

				r = g = b = vis = npix = 0;
				for(i=3;i>=0;i--)
					for(zz=z-1;zz<=z;zz++)
					{
						if ((vs[i] >= ve[i]) || (vs[i]->z > zz)) continue;
						r += (vs[i]->col&0xff00ff); //MMX-style trick!
						g += (vs[i]->col&  0xff00);
						//b += (vs[i]->col&    0xff);
						vis |= vs[i]->vis;
						vecbuf[npix] = vs[i]->dir;
						npix++; vs[i]++;
					}

				if (npix)
				{
					if (n >= kv6->numvoxs) return(0); //Don't let it crash!

					i = umulmip[npix]; j = (npix>>1);
					voxptr[n].col = (umulshr32(r+(j<<16),i)&0xff0000) +
										 (umulshr32(g+(j<< 8),i)&  0xff00) +
										 (umulshr32((r&0xfff)+ j     ,i));
					voxptr[n].z = (z>>1);
					voxptr[n].vis = vis;
					voxptr[n].dir = vecbuf[umulshr32(darand,npix)]; darand += i;
					n++;
				}
			}
			xyptr[0] = n-oxyn; xyptr++;
			vs[0] = ve[1]; vs[2] = ve[3];
		}
		xptr[x] = n-oxn;
		if ((x<<1)+1 >= kv6->xsiz) break; //Avoid read page fault
		v0[0] = v0[1]+kv6->xlen[(x<<1)+1];
	}

	nkv6->leng = sizeof(kv6data) + (xs<<2) + xysiz + n*sizeof(kv6voxtype);
	nkv6 = (kv6data *)realloc(nkv6,nkv6->leng); if (!nkv6) return(0);
	nkv6->xlen = (unsigned long *)(((long)nkv6) + sizeof(kv6data));
	nkv6->ylen = (unsigned short *)(((long)nkv6->xlen) + (xs<<2));
	nkv6->vox = (kv6voxtype *)(((long)nkv6->ylen) + xysiz);
	nkv6->numvoxs = n;
	kv6->lowermip = nkv6;
	return(nkv6);
}

void savekv6 (const char *filnam, kv6data *kv)
{
	FILE *fil;
	long i;

	if (fil = fopen(filnam,"wb"))
	{
		i = 0x6c78764b; fwrite(&i,4,1,fil); //Kvxl
		fwrite(&kv->xsiz,4,1,fil); fwrite(&kv->ysiz,4,1,fil); fwrite(&kv->zsiz,4,1,fil);
		fwrite(&kv->xpiv,4,1,fil); fwrite(&kv->ypiv,4,1,fil); fwrite(&kv->zpiv,4,1,fil);
		fwrite(&kv->numvoxs,4,1,fil);
		fwrite(kv->vox,kv->numvoxs*sizeof(kv6voxtype),1,fil);
		fwrite(kv->xlen,kv->xsiz*sizeof(long),1,fil);
		fwrite(kv->ylen,kv->xsiz*kv->ysiz*sizeof(short),1,fil);
		fclose(fil);
	}
}

	//NOTE: should make this inline to getkv6!
static kv6data *loadkv6 (const char *filnam)
{
	FILE *fil;
	kv6data tk, *newkv6;
	long i;

	if (!kzopen(filnam))
	{
    printf("KV6 file \"%s\" not found!\n",filnam);
			//File not found, but allocate a structure anyway
			//   so it can keep track of the filename
		if (!(newkv6 = (kv6data *)malloc(sizeof(kv6data)))) return(0);
		newkv6->leng = sizeof(kv6data);
		newkv6->xsiz = newkv6->ysiz = newkv6->zsiz = 0;
		newkv6->xpiv = newkv6->ypiv = newkv6->zpiv = 0;
		newkv6->numvoxs = 0;
		newkv6->namoff = 0;
		newkv6->lowermip = 0;
		newkv6->vox = (kv6voxtype *)(((long)newkv6)+sizeof(kv6data));
		newkv6->xlen = (unsigned long *)newkv6->vox;
		newkv6->ylen = (unsigned short *)newkv6->xlen;
		return(newkv6);
	}

	kzread((void *)&tk,32);

	i = tk.numvoxs*sizeof(kv6voxtype) + tk.xsiz*4 + tk.xsiz*tk.ysiz*2;
	newkv6 = (kv6data *)malloc(i+sizeof(kv6data));
	if (!newkv6) { kzclose(); return(0); }
	if (((long)newkv6)&3) evilquit("getkv6 malloc not 32-bit aligned!");

	newkv6->leng = i+sizeof(kv6data);
	memcpy(&newkv6->xsiz,&tk.xsiz,28);
	newkv6->namoff = 0;
	newkv6->lowermip = 0;
	newkv6->vox = (kv6voxtype *)(((long)newkv6)+sizeof(kv6data));
	newkv6->xlen = (unsigned long *)(((long)newkv6->vox)+tk.numvoxs*sizeof(kv6voxtype));
	newkv6->ylen = (unsigned short *)(((long)newkv6->xlen) + tk.xsiz*4);

	kzread((void *)newkv6->vox,i);
	kzclose();
	return(newkv6);
}

	//Cover-up function for LOADKV6: returns a pointer to the loaded kv6data
	//   structure. Loads file only if not already loaded before with getkv6.
kv6data *getkv6 (const char *filnam)
{
	kv6data *kv6ptr;
	long i;

	if (inkhash(filnam,&i)) return(*(kv6data **)&khashbuf[i+4]);
	if (i == -1) return(0);

	if (kv6ptr = loadkv6((char *)&khashbuf[i+9]))
		kv6ptr->namoff = i+9; //Must use offset for ptr->name conversion

	*(kv6data **)&khashbuf[i+4] = kv6ptr;
	*(char *)&khashbuf[i+8] = 0; //0 for KV6
	return(kv6ptr);
}

#ifdef __cplusplus
extern "C" {
#endif

extern void *caddasm;
#define cadd4 ((point4d *)&caddasm)
extern void *ztabasm;
#define ztab4 ((point4d *)&ztabasm)
extern short qsum0[4], qsum1[4], qbplbpp[4];
extern long kv6frameplace, kv6bytesperline;
extern float scisdist;
extern __int64 kv6colmul[256], kv6coladd[256];

char ptfaces16[43][8] =
{
	0, 0, 0,  0,  0, 0, 0,0,  4, 0,32,96, 64, 0,32,0,  4,16,80,112,48, 16,80,0,  0,0,0,0,0,0,0,0,
	4,64,96,112, 80,64,96,0,  6, 0,32,96,112,80,64,0,  6,16,80, 64,96,112,48,0,  0,0,0,0,0,0,0,0,
	4, 0,16, 48, 32, 0,16,0,  6, 0,16,48, 32,96,64,0,  6, 0,16, 80,112,48,32,0,  0,0,0,0,0,0,0,0,
	0, 0, 0,  0,  0, 0, 0,0,  0, 0, 0, 0,  0, 0, 0,0,  0, 0, 0,  0,  0, 0, 0,0,  0,0,0,0,0,0,0,0,
	4, 0,64, 80, 16, 0,64,0,  6, 0,32,96, 64,80,16,0,  6, 0,64, 80,112,48,16,0,  0,0,0,0,0,0,0,0,
	6, 0,64, 96,112,80,16,0,  6, 0,32,96,112,80,16,0,  6, 0,64, 96,112,48,16,0,  0,0,0,0,0,0,0,0,
	6, 0,64, 80, 16,48,32,0,  6,16,48,32, 96,64,80,0,  6, 0,64, 80,112,48,32,0,  0,0,0,0,0,0,0,0,
	0, 0, 0,  0,  0, 0, 0,0,  0, 0, 0, 0,  0, 0, 0,0,  0, 0, 0,  0,  0, 0, 0,0,  0,0,0,0,0,0,0,0,
	4,32,48,112, 96,32,48,0,  6, 0,32,48,112,96,64,0,  6,16,80,112, 96,32,48,0,  0,0,0,0,0,0,0,0,
	6,32,48,112, 80,64,96,0,  6, 0,32,48,112,80,64,0,  6,16,80, 64, 96,32,48,0,  0,0,0,0,0,0,0,0,
	6, 0,16, 48,112,96,32,0,  6, 0,16,48,112,96,64,0,  6, 0,16, 80,112,96,32,0,
};

void drawboundcubesseinit ();
void drawboundcubesse (kv6voxtype *, long);
void drawboundcube3dninit ();
void drawboundcube3dn (kv6voxtype *, long);

#ifdef __cplusplus
}
#endif

//static void initboundcubescr (long dafram, long dabpl, long x, long y, long dabpp)
//{
//   qsum1[3] = qsum1[1] = 0x7fff-y; qsum1[2] = qsum1[0] = 0x7fff-x;
//   qbplbpp[1] = dabpl; qbplbpp[0] = ((dabpp+7)>>3);
//   kv6frameplace = dafram; kv6bytesperline = dabpl;
//}

static __declspec(align(8)) short lightlist[MAXLIGHTS+1][4];
static __int64 all32767 = 0x7fff7fff7fff7fff;

static void updatereflects (vx5sprite *spr)
{
	__int64 fogmul;
	point3d tp;
	float f, g, h, fx, fy, fz;
	long i, j;

#if 0
	KV6 lighting calculations for: fog, white, black, intens(normal dot product), black currently not supported!

	long vx5.kv6black = 0x000000, vx5.kv6white = 0x808080;
	long nw.r = vx5.kv6white.r-vx5.kv6black.r, nb.r = vx5.kv6black.r*2;
	long nw.g = vx5.kv6white.g-vx5.kv6black.g, nb.g = vx5.kv6black.g*2;
	long nw.b = vx5.kv6white.b-vx5.kv6black.b, nb.b = vx5.kv6black.b*2;
	col.r = mulshr7(col.r,nw.r)+nb.r; col.r = mulshr7(col.r,intens); col.r += mulshr15(fogcol.r-col.r,fogmul);
	col.g = mulshr7(col.g,nw.g)+nb.g; col.g = mulshr7(col.g,intens); col.g += mulshr15(fogcol.g-col.g,fogmul);
	col.b = mulshr7(col.b,nw.b)+nb.b; col.b = mulshr7(col.b,intens); col.b += mulshr15(fogcol.b-col.b,fogmul);

	col.r = ((col.r*intens*nw.r*(32767-fogmul))>>29) +
			  ((      intens*nb.r*(32767-fogmul))>>22) + ((fogcol.r*fogmul)>>15);
	col.g = ((col.g*intens*nw.g*(32767-fogmul))>>29) +
			  ((      intens*nb.g*(32767-fogmul))>>22) + ((fogcol.g*fogmul)>>15);
	col.b = ((col.b*intens*nw.b*(32767-fogmul))>>29) +
			  ((      intens*nb.b*(32767-fogmul))>>22) + ((fogcol.b*fogmul)>>15);
#endif

		//Use cylindrical x-y distance for fog
	if (ofogdist >= 0)
	{
		ftol(sqrt((spr->p.x-gipos.x)*(spr->p.x-gipos.x) + (spr->p.y-gipos.y)*(spr->p.y-gipos.y)),&i);
		if (i > 2047) i = 2047;
		fogmul = foglut[i];

#if 0
		i = (long)(*(short *)&fogmul);
		((short *)kv6coladd)[0] = (short)((((long)(((short *)&fogcol)[0]))*i)>>1);
		((short *)kv6coladd)[1] = (short)((((long)(((short *)&fogcol)[1]))*i)>>1);
		((short *)kv6coladd)[2] = (short)((((long)(((short *)&fogcol)[2]))*i)>>1);
#else
		_asm
		{
			movq mm0, fogcol
			paddd mm0, mm0
			pmulhuw mm0, fogmul
			movq kv6coladd[0], mm0
			emms
		}
#endif
	} else { fogmul = 0I64; kv6coladd[0] = 0I64; }

	if (spr->flags&1)
	{
		//((short *)kv6colmul)[0] = 0x010001000100;                                        //Do (nothing)
		  ((short *)kv6colmul)[0] = (short)((vx5.kv6col&255)<<1);                          //Do     white
		//((short *)kv6colmul)[0] = (short)((32767-(short)fogmul)>>7);                     //Do fog
		//((short *)kv6colmul)[0] = (short)(((32767-(short)fogmul)*(vx5.kv6col&255))>>14); //Do fog&white

		((short *)kv6colmul)[1] = ((short *)kv6colmul)[0];
		((short *)kv6colmul)[2] = ((short *)kv6colmul)[0];
		((short *)kv6colmul)[3] = 0;
		for(i=1;i<256;i++) kv6colmul[i] = kv6colmul[0];
		return;
	}

	if (vx5.lightmode < 2)
	{
		fx = 1.0; fy = 1.0; fz = 1.0;
		tp.x = spr->s.x*fx + spr->s.y*fy + spr->s.z*fz;
		tp.y = spr->h.x*fx + spr->h.y*fy + spr->h.z*fz;
		tp.z = spr->f.x*fx + spr->f.y*fy + spr->f.z*fz;

		f = 64.0 / sqrt(tp.x*tp.x + tp.y*tp.y + tp.z*tp.z);

			//for(i=255;i>=0;i--)
			//{
			//   ftol(univec[i].x*tp.x + univec[i].y*tp.y + univec[i].z*tp.z,&j);
			//   j = (lbound0(j+128,255)<<8);
			//   ((unsigned short *)(&kv6colmul[i]))[0] = j;
			//   ((unsigned short *)(&kv6colmul[i]))[1] = j;
			//   ((unsigned short *)(&kv6colmul[i]))[2] = j;
			//}
		g = ((float)((((long)fogmul)&32767)^32767))*(16.f*8.f/65536.f);
		if (!(((vx5.kv6col&0xffff)<<8)^(vx5.kv6col&0xffff00))) //Cool way to check if R==G==B :)
		{
			g *= ((float)(vx5.kv6col&255))/256.f;
				//This case saves 1 MMX multiply per iteration
			f *= g;
			lightlist[0][0] = (short)(tp.x*f);
			lightlist[0][1] = (short)(tp.y*f);
			lightlist[0][2] = (short)(tp.z*f);
			lightlist[0][3] = (short)(g*128.f);
			_asm
			{
				movq mm6, lightlist[0]
				mov ecx, 255*8
  nolighta: movq mm0, iunivec[ecx]
				movq mm1, iunivec[ecx-8]
				pmaddwd mm0, mm6 ;mm0: [tp.a*iunivec.a + tp.z*iunivec.z][tp.y*iunivec.y + tp.x*iunivec.x]
				pmaddwd mm1, mm6
				pshufw mm2, mm0, 0x4e  ;Before: mm0: [ 0 ][ a ][   ][   ][ 0 ][ b ][   ][   ]
				pshufw mm3, mm1, 0x4e
				paddd mm0, mm2
				paddd mm1, mm3
				pshufw mm0, mm0, 0x55
				pshufw mm1, mm1, 0x55  ;After:  mm0: [   ][   ][   ][a+b][   ][a+b][   ][a+b]
				movq kv6colmul[ecx], mm0
				movq kv6colmul[ecx-8], mm1
				sub ecx, 2*8
				jnc short nolighta
			}
		}
		else
		{
			f *= g;
			lightlist[0][0] = (short)(tp.x*f);
			lightlist[0][1] = (short)(tp.y*f);
			lightlist[0][2] = (short)(tp.z*f);
			lightlist[0][3] = (short)(g*128.f);
			_asm
			{
				punpcklbw mm5, vx5.kv6col
				movq mm6, lightlist[0]
				mov ecx, 255*8
  nolightb: movq mm0, iunivec[ecx]
				movq mm1, iunivec[ecx-8]
				pmaddwd mm0, mm6 ;mm0: [tp.a*iunivec.a + tp.z*iunivec.z][tp.y*iunivec.y + tp.x*iunivec.x]
				pmaddwd mm1, mm6
				pshufw mm2, mm0, 0x4e ;Before: mm0: [ 0 ][ a ][   ][   ][ 0 ][ b ][   ][   ]
				pshufw mm3, mm1, 0x4e
				paddd mm0, mm2
				paddd mm1, mm3
				pshufw mm0, mm0, 0x55
				pshufw mm1, mm1, 0x55 ;After:  mm0: [   ][   ][   ][a+b][   ][a+b][   ][a+b]
				pmulhuw mm0, mm5
				pmulhuw mm1, mm5
				movq kv6colmul[ecx], mm0
				movq kv6colmul[ecx-8], mm1
				sub ecx, 2*8
				jnc short nolightb
			}
		}
		//NOTE: emms not necessary!
	}
	else
	{
		point3d sprs, sprh, sprf;
		float ff, gg, hh;
		long k, lightcnt;

			//WARNING: this only works properly for orthonormal matrices!
		f = 1.0 / sqrt(spr->s.x*spr->s.x + spr->s.y*spr->s.y + spr->s.z*spr->s.z);
		sprs.x = spr->s.x*f; sprs.y = spr->s.y*f; sprs.z = spr->s.z*f;
		f = 1.0 / sqrt(spr->h.x*spr->h.x + spr->h.y*spr->h.y + spr->h.z*spr->h.z);
		sprh.x = spr->h.x*f; sprh.y = spr->h.y*f; sprh.z = spr->h.z*f;
		f = 1.0 / sqrt(spr->f.x*spr->f.x + spr->f.y*spr->f.y + spr->f.z*spr->f.z);
		sprf.x = spr->f.x*f; sprf.y = spr->f.y*f; sprf.z = spr->f.z*f;

		hh = ((float)((((long)fogmul)&32767)^32767))/65536.f * 2.f;


			//Find which lights are close enough to affect sprite.
		lightcnt = 0;
		for(i=vx5.numlights-1;i>=0;i--)
		{
			fx = vx5.lightsrc[i].p.x-(spr->p.x);
			fy = vx5.lightsrc[i].p.y-(spr->p.y);
			fz = vx5.lightsrc[i].p.z-(spr->p.z);
			gg = fx*fx + fy*fy + fz*fz; ff = vx5.lightsrc[i].r2;
			if (*(long *)&gg < *(long *)&ff)
			{
				f = sqrt(ff); g = sqrt(gg);
				//h = (16.0/(sqrt(gg)*gg) - 16.0/(sqrt(ff)*ff))*vx5.lightsrc[i].sc;
				h = (f*ff - g*gg)/(f*ff*g*gg) * vx5.lightsrc[i].sc*16.0;
				if (g*h > 4096.0) h = 4096.0/g; //Max saturation clipping
				h *= hh;
				lightlist[lightcnt][0] = (short)((fx*sprs.x + fy*sprs.y + fz*sprs.z)*h);
				lightlist[lightcnt][1] = (short)((fx*sprh.x + fy*sprh.y + fz*sprh.z)*h);
				lightlist[lightcnt][2] = (short)((fx*sprf.x + fy*sprf.y + fz*sprf.z)*h);
				lightlist[lightcnt][3] = 0;
				lightcnt++;
			}
		}

		fx = 0.0; fy = 0.5; fz = 1.0;

			//tp.x = (sprs.x*fx + sprs.y*fy + sprs.z*fz)*16.0;
			//tp.y = (sprh.x*fx + sprh.y*fy + sprh.z*fz)*16.0;
			//tp.z = (sprf.x*fx + sprf.y*fy + sprf.z*fz)*16.0;
			//for(i=255;i>=0;i--)
			//{
			//   f = tp.x*univec[i].x + tp.y*univec[i].y + tp.z*univec[i].z + 48;
			//   for(k=lightcnt-1;k>=0;k--)
			//   {
			//      h = lightlist[k].x*univec[i].x + lightlist[k].y*univec[i].y + lightlist[k].z*univec[i].z;
			//      if (*(long *)&h < 0) f -= h;
			//   }
			//   if (f > 255) f = 255;
			//   ftol(f,&j); j <<= 8;
			//   ((unsigned short *)(&kv6colmul[i]))[0] = j;
			//   ((unsigned short *)(&kv6colmul[i]))[1] = j;
			//   ((unsigned short *)(&kv6colmul[i]))[2] = j;
			//}
		hh *= 16*16.f*8.f/2.f;
		lightlist[lightcnt][0] = (short)((sprs.x*fx + sprs.y*fy + sprs.z*fz)*hh);
		lightlist[lightcnt][1] = (short)((sprh.x*fx + sprh.y*fy + sprh.z*fz)*hh);
		lightlist[lightcnt][2] = (short)((sprf.x*fx + sprf.y*fy + sprf.z*fz)*hh);
		lightlist[lightcnt][3] = (short)(hh*(48/16.0));
		_asm
		{
			punpcklbw mm5, vx5.kv6col
			pxor mm6, mm6
			mov edx, lightcnt
			shl edx, 3
			mov ecx, 255*8
beglig:  movq mm3, iunivec[ecx]   ;mm3: 256 u[i].z*256 u[i].y*256 u[i].x*256
			mov eax, edx
			movq mm0, lightlist[edx] ;mm0: 48*256,0 tp.z*256 tp.y*256 tp.x*256
			pmaddwd mm0, mm3
			pshufw mm2, mm0, 0x4e
			paddd mm0, mm2
			sub eax, 8
			js short endlig
beglig2: movq mm1, lightlist[eax] ;mm1: 0 tp.z*256 tp.y*256 tp.x*256
			pmaddwd mm1, mm3
			pshufw mm2, mm1, 0x4e
			paddd mm1, mm2
			pminsw mm1, mm6          ;16-bits is ugly, but ok here
			psubd mm0, mm1
			sub eax, 8
			jns short beglig2        ;mm0: 00 II ii ii 00 II ii ii
endlig:  pshufw mm0, mm0, 0x55    ;mm0: 00 II 00 II 00 II 00 II
			pmulhuw mm0, mm5
			movq kv6colmul[ecx], mm0
			sub ecx, 8
			jnc short beglig
		}
		//NOTE: emms not necessary!
	}
}

#ifdef _MSC_VER

static _inline void movps (point4d *dest, point4d *src)
{
	_asm
	{
		mov eax, src
		movaps xmm7, [eax]
		mov eax, dest
		movaps [eax], xmm7
	}
}

static _inline void intss (point4d *dest, long src)
{
	_asm
	{
		mov eax, dest
		cvtsi2ss xmm7, src
		shufps xmm7, xmm7, 0
		movaps [eax], xmm7
	}
}

static _inline void addps (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movaps xmm7, [eax]
		mov eax, b
		addps xmm7, [eax]
		mov eax, sum
		movaps [eax], xmm7
	}
}

static _inline void mulps (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movaps xmm7, [eax]
		mov eax, b
		mulps xmm7, [eax]
		mov eax, sum
		movaps [eax], xmm7
	}
}

static _inline void subps (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movaps xmm7, [eax]
		mov eax, b
		subps xmm7, [eax]
		mov eax, sum
		movaps [eax], xmm7
	}
}

static _inline void minps (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movaps xmm7, [eax]
		mov eax, b
		minps xmm7, [eax]
		mov eax, sum
		movaps [eax], xmm7
	}
}

static _inline void maxps (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movaps xmm7, [eax]
		mov eax, b
		maxps xmm7, [eax]
		mov eax, sum
		movaps [eax], xmm7
	}
}

static _inline void movps_3dn (point4d *dest, point4d *src)
{
	_asm
	{
		mov eax, src
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, dest
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

static _inline void intss_3dn (point4d *dest, long src)
{
	_asm
	{
		mov eax, dest
		movd mm0, src
		pi2fd mm0, mm0
		punpckldq mm0, mm0
		movq [eax], mm0
		movq [eax+8], mm0
	}
}

static _inline void addps_3dn (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, b
		pfadd mm0, [eax]
		pfadd mm1, [eax+8]
		mov eax, sum
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

static _inline void mulps_3dn (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, b
		pfmul mm0, [eax]
		pfmul mm1, [eax+8]
		mov eax, sum
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

static _inline void subps_3dn (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, b
		pfsub mm0, [eax]
		pfsub mm1, [eax+8]
		mov eax, sum
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

static _inline void minps_3dn (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, b
		pfmin mm0, [eax]
		pfmin mm1, [eax+8]
		mov eax, sum
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

static _inline void maxps_3dn (point4d *sum, point4d *a, point4d *b)
{
	_asm
	{
		mov eax, a
		movq mm0, [eax]
		movq mm1, [eax+8]
		mov eax, b
		pfmax mm0, [eax]
		pfmax mm1, [eax+8]
		mov eax, sum
		movq [eax], mm0
		movq [eax+8], mm1
	}
}

#endif

#define DRAWBOUNDCUBELINE(const) \
	for(;v0<=v1 && v0->z<inz;v0++) drawboundcubesse(v0,const+0x20);\
	for(;v0<=v1 && v1->z>inz;v1--) drawboundcubesse(v1,const+0x10);\
						  if (v0 == v1) drawboundcubesse(v1,const+0x00);

#define DRAWBOUNDCUBELINE_3DN(const) \
	for(;v0<=v1 && v0->z<inz;v0++) drawboundcube3dn(v0,const+0x20);\
	for(;v0<=v1 && v1->z>inz;v1--) drawboundcube3dn(v1,const+0x10);\
						  if (v0 == v1) drawboundcube3dn(v1,const+0x00);

	//Code taken from renderboundcube of SLAB6D (Pentium III version :)
#define MAXZSIZ 1024
static void kv6draw (vx5sprite *spr)
{
	point4d *r0, *r1, *r2;
	kv6voxtype *xv, *yv, *v0, *v1;
	kv6data *kv;
	point3d ts, th, tf;
	point3d npos, nstr, nhei, nfor, tp, tp2;
	float f;
	long x, y, z, inx, iny, inz, nxplanemin, nxplanemax;
	unsigned short *ylenptr;

	kv = spr->voxnum; if (!kv) return;

	z = 0; //Quick & dirty estimation of distance
	ftol((spr->p.x-gipos.x)*gifor.x + (spr->p.y-gipos.y)*gifor.y + (spr->p.z-gipos.z)*gifor.z,&y);
	while ((kv->lowermip) && (y >= vx5.kv6mipfactor)) { kv = kv->lowermip; z++; y >>= 1; }
	if (!z)
	{
		nxplanemin = vx5.xplanemin; nxplanemax = vx5.xplanemax;
		ts = spr->s; th = spr->h; tf = spr->f;
	}
	else
	{
		nxplanemin = (vx5.xplanemin>>z);
		nxplanemax = (vx5.xplanemax>>z); f = (float)(1<<z);
		ts.x = spr->s.x*f; ts.y = spr->s.y*f; ts.z = spr->s.z*f;
		th.x = spr->h.x*f; th.y = spr->h.y*f; th.z = spr->h.z*f;
		tf.x = spr->f.x*f; tf.y = spr->f.y*f; tf.z = spr->f.z*f;
	}

		//View frustrum culling (72*,63+,12fabs,4cmp)
	tp2.x = ((float)kv->xsiz)*.5; tp.x = tp2.x - kv->xpiv;
	tp2.y = ((float)kv->ysiz)*.5; tp.y = tp2.y - kv->ypiv;
	tp2.z = ((float)kv->zsiz)*.5; tp.z = tp2.z - kv->zpiv;
	npos.x = tp.x*ts.x + tp.y*th.x + tp.z*tf.x + (spr->p.x-gipos.x);
	npos.y = tp.x*ts.y + tp.y*th.y + tp.z*tf.y + (spr->p.y-gipos.y);
	npos.z = tp.x*ts.z + tp.y*th.z + tp.z*tf.z + (spr->p.z-gipos.z);
	nstr.x = ts.x*tp2.x; nstr.y = ts.y*tp2.x; nstr.z = ts.z*tp2.x;
	nhei.x = th.x*tp2.y; nhei.y = th.y*tp2.y; nhei.z = th.z*tp2.y;
	nfor.x = tf.x*tp2.z; nfor.y = tf.y*tp2.z; nfor.z = tf.z*tp2.z;
	for(z=3;z>=0;z--) //72*,63+
	{
			//movaps xmm0, nx4      mulaps xmm0, ginor[0].x(dup 4)
			//movaps xmm1, ny4      mulaps xmm1, ginor[0].y(dup 4)
			//movaps xmm2, nz4      mulaps xmm2, ginor[0].z(dup 4)
			//addps xmm0, xmm1      addps xmm0, xmm2
			//andps xmm0, [0x7fffffff7fffffff7fffffffffffffff]
			//movhlps xmm1, xmm0    addps xmm0, xmm1
			//shufps xmm1, xmm0, 1  addss xmm0, xmm1
			//ucomiss xmm0, [0x0]   jnz retfunc
		if (fabs(nstr.x*ginor[z].x + nstr.y*ginor[z].y + nstr.z*ginor[z].z) +
			 fabs(nhei.x*ginor[z].x + nhei.y*ginor[z].y + nhei.z*ginor[z].z) +
			 fabs(nfor.x*ginor[z].x + nfor.y*ginor[z].y + nfor.z*ginor[z].z) +
					npos.x*ginor[z].x + npos.y*ginor[z].y + npos.z*ginor[z].z < 0) return;
	}
#if 0   //There are bugs when some vertices are behind ifor plane
	x = xres; y = xres; inx = 0; iny = 0;
	for(z=7;z>=0;z--) //This is useful for debugging.
	{
		tp.x = -kv->xpiv; if (z&1) tp.x += (float)kv->xsiz;
		tp.y = -kv->ypiv; if (z&2) tp.y += (float)kv->ysiz;
		tp.z = -kv->zpiv; if (z&4) tp.z += (float)kv->zsiz;
		drawspherefill(tp.x*ts.x+tp.y*th.x+tp.z*tf.x+spr->p.x,
							tp.x*ts.y+tp.y*th.y+tp.z*tf.y+spr->p.y,
							tp.x*ts.z+tp.y*th.z+tp.z*tf.z+spr->p.z,.5,0xf08040);
		tp2.x = tp.x*ts.x+tp.y*th.x+tp.z*tf.x+spr->p.x-gipos.x;
		tp2.y = tp.x*ts.y+tp.y*th.y+tp.z*tf.y+spr->p.y-gipos.y;
		tp2.z = tp.x*ts.z+tp.y*th.z+tp.z*tf.z+spr->p.z-gipos.z;
		tp.z = tp2.x*gifor.x + tp2.y*gifor.y + tp2.z*gifor.z; if (tp.z < 2) continue;
		tp.x = tp2.x*gistr.x + tp2.y*gistr.y + tp2.z*gistr.z;
		tp.y = tp2.x*gihei.x + tp2.y*gihei.y + tp2.z*gihei.z;
		ftol(tp.x*gihz/tp.z + gihx,&inz);
		if (inz < x) x = inz;
		if (inz > inx) inx = inz;
		ftol(tp.y*gihz/tp.z+gihy,&inz);
		if (inz < y) y = inz;
		if (inz > iny) iny = inz;
	}
	if (x < 0) x = 0;
	if (inx > xres) inx = xres;
	if (y < 0) y = 0;
	if (iny > yres) iny = yres;
	if (x < inx)
		for(inz=y;inz<iny;inz++)
			clearbuf((void *)(ylookup[inz]+(x<<2)+frameplace),inx-x,0L);
#endif

#if (USEZBUFFER == 0)
	lpoint3d lp;
	if (!cansee(&gipos,&spr->p,&lp)) return; //Very crappy Z-buffer!
#endif

	r0 = &ztab4[MAXZSIZ]; r1 = &ztab4[MAXZSIZ+1]; r2 = &ztab4[MAXZSIZ+2];

		//Rotate sprite from world to screen coordinates:
	mat2(&gixs,&giys,&gizs,&giadd, &ts,&th,&tf,&spr->p, &nstr,&nhei,&nfor,&npos);
	npos.x -= (kv->xpiv*nstr.x + kv->ypiv*nhei.x + kv->zpiv*nfor.x);
	npos.y -= (kv->xpiv*nstr.y + kv->ypiv*nhei.y + kv->zpiv*nfor.y);
	npos.z -= (kv->xpiv*nstr.z + kv->ypiv*nhei.z + kv->zpiv*nfor.z);

		//Find split point by using Cramer's rule
		//Must use Cramer's rule for non-orthonormal input matrices
	tp.x = nhei.y*nfor.z - nfor.y*nhei.z;
	tp.y = nfor.y*nstr.z - nstr.y*nfor.z;
	tp.z = nstr.y*nhei.z - nhei.y*nstr.z;
	f = nstr.x*tp.x + nhei.x*tp.y + nfor.x*tp.z;
	if (f != 0)
	{
		f = -1.0f / f;
		tp2.x = npos.y*nfor.z - nfor.y*npos.z;
		tp2.y = nhei.y*npos.z - npos.y*nhei.z;
		tp2.z = npos.y*nstr.z - nstr.y*npos.z;
		inx = (npos.x*tp.x - nhei.x*tp2.x - nfor.x*tp2.y)*f;
		iny = (npos.x*tp.y + nstr.x*tp2.x - nfor.x*tp2.z)*f;
		inz = (npos.x*tp.z + nstr.x*tp2.y + nhei.x*tp2.z)*f;
	}
	else { inx = iny = inz = -1; }
	inx = lbound(inx,-1,kv->xsiz);
	iny = lbound(iny,-1,kv->ysiz);
	inz = lbound(inz,-1,kv->zsiz);

	f = nhei.x; nhei.x = nfor.x; nfor.x = -f;
	f = nhei.y; nhei.y = nfor.y; nfor.y = -f;
	f = nhei.z; nhei.z = nfor.z; nfor.z = -f;

	if (kv->zsiz >= MAXZSIZ) return; //HACK TO PREVENT CRASHES FOR NOW... FIX!
	qsum0[2] = qsum0[0] = 0x7fff-(xres-(long)gihx);
	qsum0[3] = qsum0[1] = 0x7fff-(yres-(long)gihy);

		//r1->x = nstr.z; r1->y = nhei.z; r1->z = nfor.z;
		//minps(r1,r1,&ztab4[0]); //&ztab4[0] always 0
		//scisdist = -(r1->x + r1->y + r1->z);
	scisdist = 0;
	if (*(long *)&nstr.z < 0) scisdist -= nstr.z;
	if (*(long *)&nhei.z < 0) scisdist -= nhei.z;
	if (*(long *)&nfor.z < 0) scisdist -= nfor.z;

	cadd4[1].x = nstr.x*gihz; cadd4[1].y = nstr.y*gihz; cadd4[1].z = cadd4[1].z2 = nstr.z;
	cadd4[2].x = nhei.x*gihz; cadd4[2].y = nhei.y*gihz; cadd4[2].z = cadd4[2].z2 = nhei.z;
	cadd4[4].x = nfor.x*gihz; cadd4[4].y = nfor.y*gihz; cadd4[4].z = cadd4[4].z2 = nfor.z;
		  r1->x = npos.x*gihz;      r1->y = npos.y*gihz;      r1->z =      r1->z2 = npos.z;

	updatereflects(spr);
	//No more 8087 code after here!!! ----------------------------------------

	if (cputype&(1<<25))
	{
		addps(&cadd4[3],&cadd4[1],&cadd4[2]);
		addps(&cadd4[5],&cadd4[1],&cadd4[4]);
		addps(&cadd4[6],&cadd4[2],&cadd4[4]);
		addps(&cadd4[7],&cadd4[3],&cadd4[4]);

		for(z=1;z<kv->zsiz;z++) addps(&ztab4[z],&ztab4[z-1],&cadd4[2]);
		intss(r2,-kv->ysiz); mulps(r2,r2,&cadd4[4]);

		subps(r1,r1,&cadd4[4]); //ANNOYING HACK!!!

		_asm
		{
			movq mm6, qsum0
			movq mm7, qsum1
		}

		xv = kv->vox; ylenptr = kv->ylen;
		for(x=0;x<inx;x++,ylenptr+=kv->ysiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax))
				{ xv += kv->xlen[x]; addps(r1,r1,&cadd4[1]); continue; }
			yv = xv+kv->xlen[x]; movps(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = xv; xv += ylenptr[y]; v1 = xv-1;
				DRAWBOUNDCUBELINE(0xa)
				subps(r0,r0,&cadd4[4]);
			}
			xv = yv;
			addps(r0,r1,r2);
			addps(r1,r1,&cadd4[1]);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps(r0,r0,&cadd4[4]);
				v1 = yv-1; yv -= ylenptr[y]; v0 = yv;
				DRAWBOUNDCUBELINE(0x6)
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				addps(r0,r0,&cadd4[4]);
				v1 = yv-1; yv -= ylenptr[y]; v0 = yv;
				DRAWBOUNDCUBELINE(0x2)
			}
		}
		xv = &kv->vox[kv->numvoxs]; ylenptr = &kv->ylen[(kv->xsiz-1)*kv->ysiz];
		intss(r0,kv->xsiz-x); mulps(r0,r0,&cadd4[1]); addps(r1,r1,r0);
		for(x=kv->xsiz-1;x>inx;x--,ylenptr-=kv->ysiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax))
				{ xv -= kv->xlen[x]; subps(r1,r1,&cadd4[1]); continue; }
			yv = xv-kv->xlen[x];
			subps(r1,r1,&cadd4[1]);
			addps(r0,r1,r2);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps(r0,r0,&cadd4[4]);
				v1 = xv-1; xv -= ylenptr[y]; v0 = xv;
				DRAWBOUNDCUBELINE(0x5)
			}
			xv = yv; movps(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE(0x9)
				subps(r0,r0,&cadd4[4]);
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE(0x1)
			}
		}
		if ((unsigned long)inx < (unsigned long)kv->xsiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax)) { { _asm emms } return; }
			yv = xv-kv->xlen[x];
			subps(r1,r1,&cadd4[1]);
			addps(r0,r1,r2);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps(r0,r0,&cadd4[4]);
				v1 = xv-1; xv -= ylenptr[y]; v0 = xv;
				DRAWBOUNDCUBELINE(0x4)
			}
			xv = yv; movps(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE(0x8)
				subps(r0,r0,&cadd4[4]);
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE(0x0)
			}
		}
	}
	else
	{
		addps_3dn(&cadd4[3],&cadd4[1],&cadd4[2]);
		addps_3dn(&cadd4[5],&cadd4[1],&cadd4[4]);
		addps_3dn(&cadd4[6],&cadd4[2],&cadd4[4]);
		addps_3dn(&cadd4[7],&cadd4[3],&cadd4[4]);

		for(z=1;z<kv->zsiz;z++) addps_3dn(&ztab4[z],&ztab4[z-1],&cadd4[2]);
		intss_3dn(r2,-kv->ysiz); mulps_3dn(r2,r2,&cadd4[4]);

		subps_3dn(r1,r1,&cadd4[4]); //ANNOYING HACK!!!

		_asm
		{
			movq mm6, qsum0
			movq mm7, qsum1
		}

		xv = kv->vox; ylenptr = kv->ylen;
		for(x=0;x<inx;x++,ylenptr+=kv->ysiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax))
				{ xv += kv->xlen[x]; addps_3dn(r1,r1,&cadd4[1]); continue; }
			yv = xv+kv->xlen[x]; movps_3dn(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = xv; xv += ylenptr[y]; v1 = xv-1;
				DRAWBOUNDCUBELINE_3DN(0xa)
				subps_3dn(r0,r0,&cadd4[4]);
			}
			xv = yv;
			addps_3dn(r0,r1,r2);
			addps_3dn(r1,r1,&cadd4[1]);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps_3dn(r0,r0,&cadd4[4]);
				v1 = yv-1; yv -= ylenptr[y]; v0 = yv;
				DRAWBOUNDCUBELINE_3DN(0x6)
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				addps_3dn(r0,r0,&cadd4[4]);
				v1 = yv-1; yv -= ylenptr[y]; v0 = yv;
				DRAWBOUNDCUBELINE_3DN(0x2)
			}
		}
		xv = &kv->vox[kv->numvoxs]; ylenptr = &kv->ylen[(kv->xsiz-1)*kv->ysiz];
		intss_3dn(r0,kv->xsiz-x); mulps_3dn(r0,r0,&cadd4[1]); addps_3dn(r1,r1,r0);
		for(x=kv->xsiz-1;x>inx;x--,ylenptr-=kv->ysiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax))
				{ xv -= kv->xlen[x]; subps_3dn(r1,r1,&cadd4[1]); continue; }
			yv = xv-kv->xlen[x];
			subps_3dn(r1,r1,&cadd4[1]);
			addps_3dn(r0,r1,r2);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps_3dn(r0,r0,&cadd4[4]);
				v1 = xv-1; xv -= ylenptr[y]; v0 = xv;
				DRAWBOUNDCUBELINE_3DN(0x5)
			}
			xv = yv; movps_3dn(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE_3DN(0x9)
				subps_3dn(r0,r0,&cadd4[4]);
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE_3DN(0x1)
			}
		}
		if ((unsigned long)inx < (unsigned long)kv->xsiz)
		{
			if ((x < nxplanemin) || (x >= nxplanemax)) { { _asm emms } return; }
			yv = xv-kv->xlen[x];
			subps_3dn(r1,r1,&cadd4[1]);
			addps_3dn(r0,r1,r2);
			for(y=kv->ysiz-1;y>iny;y--)
			{
				addps_3dn(r0,r0,&cadd4[4]);
				v1 = xv-1; xv -= ylenptr[y]; v0 = xv;
				DRAWBOUNDCUBELINE_3DN(0x4)
			}
			xv = yv; movps_3dn(r0,r1);
			for(y=0;y<iny;y++)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE_3DN(0x8)
				subps_3dn(r0,r0,&cadd4[4]);
			}
			if ((unsigned long)iny < (unsigned long)kv->ysiz)
			{
				v0 = yv; yv += ylenptr[y]; v1 = yv-1;
				DRAWBOUNDCUBELINE_3DN(0x0)
			}
		}
	}
	_asm emms
}

#endif

//-------------------------- KFA sprite code begins --------------------------

static kv6voxtype *getvptr (kv6data *kv, long x, long y)
{
	kv6voxtype *v;
	long i, j;

	v = kv->vox;
	if ((x<<1) < kv->xsiz) { for(i=0         ;i< x;i++) v += kv->xlen[i]; }
	else { v += kv->numvoxs; for(i=kv->xsiz-1;i>=x;i--) v -= kv->xlen[i]; }
	j = x*kv->ysiz;
	if ((y<<1) < kv->ysiz) { for(i=0         ;i< y;i++) v += kv->ylen[j+i]; }
	else { v += kv->xlen[x]; for(i=kv->ysiz-1;i>=y;i--) v -= kv->ylen[j+i]; }
	return(v);
}

#define VFIFSIZ 16384 //SHOULDN'T BE STATIC ALLOCATION!!!
static long vfifo[VFIFSIZ];
static void floodsucksprite (vx5sprite *spr, kv6data *kv, long ox, long oy,
									  kv6voxtype *v0, kv6voxtype *v1)
{
	kv6voxtype *v, *ve, *ov, *v2, *v3;
	kv6data *kv6;
	long i, j, x, y, z, x0, y0, z0, x1, y1, z1, n, vfif0, vfif1;

	x0 = x1 = ox; y0 = y1 = oy; z0 = v0->z; z1 = v1->z;

	n = (((long)v1)-((long)v0))/sizeof(kv6voxtype)+1;
	v1->vis &= ~64;

	vfifo[0] = ox; vfifo[1] = oy;
	vfifo[2] = (long)v0; vfifo[3] = (long)v1;
	vfif0 = 0; vfif1 = 4;

	while (vfif0 < vfif1)
	{
		i = (vfif0&(VFIFSIZ-1)); vfif0 += 4;
		ox = vfifo[i]; oy = vfifo[i+1];
		v0 = (kv6voxtype *)vfifo[i+2]; v1 = (kv6voxtype *)vfifo[i+3];

		if (ox < x0) x0 = ox;
		if (ox > x1) x1 = ox;
		if (oy < y0) y0 = oy;
		if (oy > y1) y1 = oy;
		if (v0->z < z0) z0 = v0->z;
		if (v1->z > z1) z1 = v1->z;
		for(v=v0;v<=v1;v++) v->vis |= 128; //Mark as part of current piece

		for(j=0;j<4;j++)
		{
			switch(j)
			{
				case 0: x = ox-1; y = oy; break;
				case 1: x = ox+1; y = oy; break;
				case 2: x = ox; y = oy-1; break;
				case 3: x = ox; y = oy+1; break;
				default: __assume(0); //tells MSVC default can't be reached
			}
			if ((unsigned long)x >= kv->xsiz) continue;
			if ((unsigned long)y >= kv->ysiz) continue;

			v = getvptr(kv,x,y);
			for(ve=&v[kv->ylen[x*kv->ysiz+y]];v<ve;v++)
			{
				if (v->vis&16) ov = v;
				if (((v->vis&(64+32)) == 64+32) && (v0->z <= v->z) && (v1->z >= ov->z))
				{
					i = (vfif1&(VFIFSIZ-1)); vfif1 += 4;
					if (vfif1-vfif0 >= VFIFSIZ) //FIFO Overflow... make entire object 1 piece :/
					{
						for(i=kv->numvoxs-1;i>=0;i--)
						{
							if ((kv->vox[i].vis&(64+32)) == 64+32) { v1 = &kv->vox[i]; v1->vis &= ~64; }
							if (kv->vox[i].vis&16) for(v=&kv->vox[i];v<=v1;v++) kv->vox[i].vis |= 128;
						}
						x0 = y0 = z0 = 0; x1 = kv->xsiz; y1 = kv->ysiz; z1 = kv->zsiz; n = kv->numvoxs;
						goto floodsuckend;
					}
					vfifo[i] = x; vfifo[i+1] = y;
					vfifo[i+2] = (long)ov; vfifo[i+3] = (long)v;
					n += (((long)v)-((long)ov))/sizeof(kv6voxtype)+1;
					v->vis &= ~64;
				}
			}
		}
	}
	x1++; y1++; z1++;
floodsuckend:;

	i = sizeof(kv6data) + n*sizeof(kv6voxtype) + (x1-x0)*4 + (x1-x0)*(y1-y0)*2;
	if (!(kv6 = (kv6data *)malloc(i))) return;
	kv6->leng = i;
	kv6->xsiz = x1-x0;
	kv6->ysiz = y1-y0;
	kv6->zsiz = z1-z0;
	kv6->xpiv = 0; //Set limb pivots to 0 - don't need it twice!
	kv6->ypiv = 0;
	kv6->zpiv = 0;
	kv6->numvoxs = n;
	kv6->namoff = 0;
	kv6->lowermip = 0;
	kv6->vox = (kv6voxtype *)(((long)kv6)+sizeof(kv6data));
	kv6->xlen = (unsigned long *)(((long)kv6->vox)+n*sizeof(kv6voxtype));
	kv6->ylen = (unsigned short *)(((long)kv6->xlen)+(x1-x0)*4);

		//Extract sub-KV6 to newly allocated kv6data
	v3 = kv6->vox; n = 0;
	for(x=0,v=kv->vox;x<x0;x++) v += kv->xlen[x];
	for(;x<x1;x++)
	{
		v2 = v; ox = n;
		for(y=0;y<y0;y++) v += kv->ylen[x*kv->ysiz+y];
		for(;y<y1;y++)
		{
			oy = n;
			for(ve=&v[kv->ylen[x*kv->ysiz+y]];v<ve;v++)
				if (v->vis&128)
				{
					v->vis &= ~128;
					(*v3) = (*v);
					v3->z -= z0;
					v3++; n++;
				}
			kv6->ylen[(x-x0)*(y1-y0)+(y-y0)] = n-oy;
		}
		kv6->xlen[x-x0] = n-ox;
		v = v2+kv->xlen[x];
	}

	spr->p.x = x0-kv->xpiv;
	spr->p.y = y0-kv->ypiv;
	spr->p.z = z0-kv->zpiv;
	spr->s.x = 1; spr->s.y = 0; spr->s.z = 0;
	spr->h.x = 0; spr->h.y = 1; spr->h.z = 0;
	spr->f.x = 0; spr->f.y = 0; spr->f.z = 1;
	spr->voxnum = kv6;
	spr->flags = 0;
}

static char *stripdir (char *filnam)
{
	long i, j;
	for(i=0,j=-1;filnam[i];i++)
		if ((filnam[i] == '/') || (filnam[i] == '\\')) j = i;
	return(&filnam[j+1]);
}

static void kfasorthinge (hingetype *h, long nh, long *hsort)
{
	long i, j, n;

		//First pass: stick hinges with parent=-1 at end
	n = nh; j = 0;
	for(i=n-1;i>=0;i--)
	{
		if (h[i].parent < 0) hsort[--n] = i;
							 else hsort[j++] = i;
	}
		//Finish accumulation (n*log(n) if tree is perfectly balanced)
	while (n > 0)
	{
		i--; if (i < 0) i = n-1;
		j = hsort[i];
		if (h[h[j].parent].parent < 0)
		{
			h[j].parent = -2-h[j].parent; n--;
			hsort[i] = hsort[n]; hsort[n] = j;
		}
	}
		//Restore parents to original values
	for(i=nh-1;i>=0;i--) h[i].parent = -2-h[i].parent;
}

	//Returns a pointer to the loaded kfatype structure.
	//Loads data only if not already loaded before with getkfa
kfatype *getkfa (const char *kfanam)
{
	kfatype *kfa;
	kv6voxtype *v, *ov, *ve;
	kv6data *kv;
	long i, j, x, y;
	char *cptr, snotbuf[MAX_PATH];

	if (inkhash(kfanam,&i)) return(*(kfatype **)&khashbuf[i+4]);
	if (i == -1) return(0);

	if (!(kfa = (kfatype *)malloc(sizeof(kfatype)))) return(0);
	memset(kfa,0,sizeof(kfatype));

	kfa->namoff = i+9; //Must use offset for ptr->name conversion
	*(kfatype **)&khashbuf[i+4] = kfa;
	*(char *)&khashbuf[i+8] = 1; //1 for KFA

	if (!kzopen(kfanam)) return(0);
	kzread(&i,4); if (i != 0x6b6c774b) { kzclose(); return(0); } //Kwlk
	kzread(&i,4); strcpy(snotbuf,kfanam); cptr = stripdir(snotbuf);
	kzread(cptr,i); cptr[i] = 0;
	kzread(&kfa->numhin,4);

		//Actual allocation for ->spr is numspr, which is <= numhin!
	if (!(kfa->spr = (vx5sprite *)malloc(kfa->numhin*sizeof(vx5sprite)))) { kzclose(); return(0); }

	if (!(kfa->hinge = (hingetype *)malloc(kfa->numhin*sizeof(hingetype)))) { kzclose(); return(0); }
	kzread(kfa->hinge,kfa->numhin*sizeof(hingetype));

	kzread(&kfa->numfrm,4);
	if (!(kfa->frmval = (short *)malloc(kfa->numfrm*kfa->numhin*2))) { kzclose(); return(0); }
	kzread(kfa->frmval,kfa->numfrm*kfa->numhin*2);

	kzread(&kfa->seqnum,4);
	if (!(kfa->seq = (seqtyp *)malloc(kfa->seqnum*sizeof(seqtyp)))) { kzclose(); return(0); }
	kzread(kfa->seq,kfa->seqnum*sizeof(seqtyp));

	kzclose();

		//MUST load the associated KV6 AFTER the kzclose :/
	kfa->numspr = 0;
	kv = getkv6(snotbuf); if (!kv) return(0);
	kfa->basekv6 = kv;
	if (!kv->numvoxs) return(0);
	v = kv->vox;
	for(x=kv->numvoxs-1;x>=0;x--) v[x].vis |= ((v[x].vis&32)<<1);
	for(x=0;x<kv->xsiz;x++)
		for(y=0;y<kv->ysiz;y++)
			for(ve=&v[kv->ylen[x*kv->ysiz+y]];v<ve;v++)
			{
				if (v->vis&16) ov = v;
				if ((v->vis&(64+32)) == 64+32)
				{
					floodsucksprite(&kfa->spr[kfa->numspr],kv,x,y,ov,v);
					kfa->numspr++;
				}
			}

	kfa->hingesort = (long *)malloc(kfa->numhin*4);
	kfasorthinge(kfa->hinge,kfa->numhin,kfa->hingesort);

		//Remember position offsets of limbs with no parent in hinge[?].p[0]
	for(i=(kfa->numhin)-1;i>=0;i--)
	{
		j = kfa->hingesort[i]; if (j >= kfa->numspr) continue;
		if (kfa->hinge[j].parent < 0)
		{
			kfa->hinge[j].p[0].x = -kfa->spr[j].p.x;
			kfa->hinge[j].p[0].y = -kfa->spr[j].p.y;
			kfa->hinge[j].p[0].z = -kfa->spr[j].p.z;
		}
	}

	return(kfa);
}

void getspr (vx5sprite *s, const char *filnam)
{
	long i;

	if (!filnam) return;
	i = strlen(filnam); if (!i) return;

	if ((filnam[i-1] == 'A') || (filnam[i-1] == 'a'))
		{ s->kfaptr = getkfa(filnam); s->flags = 2; s->kfatim = 0; }
	else if (filnam[i-1] == '6')
		{ s->voxnum = getkv6(filnam); s->flags = 0; }
}

	//Given vector a, returns b&c that makes (a,b,c) orthonormal
void genperp (point3d *a, point3d *b, point3d *c)
{
	float t;

	if ((a->x == 0) && (a->y == 0) && (a->z == 0))
		{ b->x = 0; b->y = 0; b->z = 0; return; }
	if ((fabs(a->x) < fabs(a->y)) && (fabs(a->x) < fabs(a->z)))
		{ t = 1.0 / sqrt(a->y*a->y + a->z*a->z); b->x = 0; b->y = a->z*t; b->z = -a->y*t; }
	else if (fabs(a->y) < fabs(a->z))
		{ t = 1.0 / sqrt(a->x*a->x + a->z*a->z); b->x = -a->z*t; b->y = 0; b->z = a->x*t; }
	else
		{ t = 1.0 / sqrt(a->x*a->x + a->y*a->y); b->x = a->y*t; b->y = -a->x*t; b->z = 0; }
	c->x = a->y*b->z - a->z*b->y;
	c->y = a->z*b->x - a->x*b->z;
	c->z = a->x*b->y - a->y*b->x;
}

	//A * B = C, find A   36*, 27ñ
	//[asx ahx agx aox][bsx bhx bgx box]   [csx chx cgx cox]
	//[asy ahy agy aoy][bsy bhy bgy boy] = [csy chy cgy coy]
	//[asz ahz agz aoz][bsz bhz bgz boz]   [csz chz cgz coz]
	//[  0   0   0   1][  0   0   0   1]   [  0   0   0   1]
void mat0 (point3d *as, point3d *ah, point3d *ag, point3d *ao,
			  point3d *bs, point3d *bh, point3d *bg, point3d *bo,
			  point3d *cs, point3d *ch, point3d *cg, point3d *co)
{
	point3d ts, th, tg, to;
	ts.x = bs->x*cs->x + bh->x*ch->x + bg->x*cg->x;
	ts.y = bs->x*cs->y + bh->x*ch->y + bg->x*cg->y;
	ts.z = bs->x*cs->z + bh->x*ch->z + bg->x*cg->z;
	th.x = bs->y*cs->x + bh->y*ch->x + bg->y*cg->x;
	th.y = bs->y*cs->y + bh->y*ch->y + bg->y*cg->y;
	th.z = bs->y*cs->z + bh->y*ch->z + bg->y*cg->z;
	tg.x = bs->z*cs->x + bh->z*ch->x + bg->z*cg->x;
	tg.y = bs->z*cs->y + bh->z*ch->y + bg->z*cg->y;
	tg.z = bs->z*cs->z + bh->z*ch->z + bg->z*cg->z;
	to.x = co->x - bo->x*ts.x - bo->y*th.x - bo->z*tg.x;
	to.y = co->y - bo->x*ts.y - bo->y*th.y - bo->z*tg.y;
	to.z = co->z - bo->x*ts.z - bo->y*th.z - bo->z*tg.z;
	(*as) = ts; (*ah) = th; (*ag) = tg; (*ao) = to;
}

	//A * B = C, find B   36*, 27ñ
	//[asx ahx agx aox][bsx bhx bgx box]   [csx chx cgx cox]
	//[asy ahy agy aoy][bsy bhy bgy boy] = [csy chy cgy coy]
	//[asz ahz agz aoz][bsz bhz bgz boz]   [csz chz cgz coz]
	//[  0   0   0   1][  0   0   0   1]   [  0   0   0   1]
void mat1 (point3d *as, point3d *ah, point3d *ag, point3d *ao,
			  point3d *bs, point3d *bh, point3d *bg, point3d *bo,
			  point3d *cs, point3d *ch, point3d *cg, point3d *co)
{
	point3d ts, th, tg, to;
	float x = co->x-ao->x, y = co->y-ao->y, z = co->z-ao->z;
	ts.x = cs->x*as->x + cs->y*as->y + cs->z*as->z;
	ts.y = cs->x*ah->x + cs->y*ah->y + cs->z*ah->z;
	ts.z = cs->x*ag->x + cs->y*ag->y + cs->z*ag->z;
	th.x = ch->x*as->x + ch->y*as->y + ch->z*as->z;
	th.y = ch->x*ah->x + ch->y*ah->y + ch->z*ah->z;
	th.z = ch->x*ag->x + ch->y*ag->y + ch->z*ag->z;
	tg.x = cg->x*as->x + cg->y*as->y + cg->z*as->z;
	tg.y = cg->x*ah->x + cg->y*ah->y + cg->z*ah->z;
	tg.z = cg->x*ag->x + cg->y*ag->y + cg->z*ag->z;
	to.x = as->x*x + as->y*y + as->z*z;
	to.y = ah->x*x + ah->y*y + ah->z*z;
	to.z = ag->x*x + ag->y*y + ag->z*z;
	(*bs) = ts; (*bh) = th; (*bg) = tg; (*bo) = to;
}

	//A * B = C, find C   36*, 27ñ
	//[asx ahx afx aox][bsx bhx bfx box]   [csx chx cfx cox]
	//[asy ahy afy aoy][bsy bhy bfy boy] = [csy chy cfy coy]
	//[asz ahz afz aoz][bsz bhz bfz boz]   [csz chz cfz coz]
	//[  0   0   0   1][  0   0   0   1]   [  0   0   0   1]
void mat2 (point3d *a_s, point3d *a_h, point3d *a_f, point3d *a_o,
			  point3d *b_s, point3d *b_h, point3d *b_f, point3d *b_o,
			  point3d *c_s, point3d *c_h, point3d *c_f, point3d *c_o)
{
	if (cputype&(1<<25))
	{
		_asm
		{
			mov eax, b_s
			mov edx, b_h
			movups xmm0, [eax]      ;xmm0:   -  bs.z bs.y bs.x
			movups xmm4, [edx]      ;xmm4:   -  bh.z bh.y bh.x
			mov eax, b_f
			mov edx, b_o
			movups xmm6, [eax]      ;xmm6:   -  bf.z bf.y bf.x
			movups xmm3, [edx]      ;xmm3:   -  bo.z bo.y bo.x

			mov eax, a_s
			mov edx, a_h

			movaps xmm2, xmm0       ;xmm2:   -  bs.z bs.y bs.x
			movaps xmm5, xmm6       ;xmm5:   -  bf.z bf.y bf.x
			unpcklps xmm0, xmm4     ;xmm0: bh.y bs.y bh.x bs.x
			unpcklps xmm6, xmm3     ;xmm6: bo.y bf.y bo.x bf.x
			movhlps xmm1, xmm0      ;xmm1:   -    -  bh.y bs.y
			movhlps xmm7, xmm6      ;xmm7:   -    -  bo.y bf.y
			unpckhps xmm2, xmm4     ;xmm2:   -    -  bh.z bs.z
			unpckhps xmm5, xmm3     ;xmm5:   -    -  bo.z bf.z
			movlhps xmm0, xmm6      ;xmm0: bo.x bf.x bh.x bs.x
			movlhps xmm1, xmm7      ;xmm1: bo.y bf.y bh.y bs.y
			movlhps xmm2, xmm5      ;xmm2: bo.z bf.z bh.z bs.z

			movss xmm3, [eax]
			shufps xmm3, xmm3, 0
			movss xmm4, [eax+4]
			shufps xmm4, xmm4, 0
			movss xmm5, [eax+8]
			shufps xmm5, xmm5, 0
			mulps xmm3, xmm0
			mulps xmm4, xmm0
			mulps xmm5, xmm0

			mov eax, a_f

			movss xmm6, [edx]
			shufps xmm6, xmm6, 0
			movss xmm7, [edx+4]
			shufps xmm7, xmm7, 0
			movss xmm0, [edx+8]
			shufps xmm0, xmm0, 0
			mulps xmm6, xmm1
			mulps xmm7, xmm1
			mulps xmm0, xmm1
			addps xmm3, xmm6
			addps xmm4, xmm7
			addps xmm5, xmm0

			mov edx, c_s

			movss xmm6, [eax]
			shufps xmm6, xmm6, 0
			movss xmm7, [eax+4]
			shufps xmm7, xmm7, 0
			movss xmm0, [eax+8]
			shufps xmm0, xmm0, 0
			mulps xmm6, xmm2
			mulps xmm7, xmm2
			mulps xmm0, xmm2
			addps xmm3, xmm6        ;xmm3: to.x tf.x th.x ts.x
			addps xmm4, xmm7        ;xmm4: to.y tf.y th.y ts.y
			addps xmm5, xmm0        ;xmm5: to.z tf.z th.z ts.z

			mov eax, c_f

			movss [edx], xmm3
			movhlps xmm0, xmm3
			movss [edx+4], xmm4
			movhlps xmm1, xmm4
			movss [edx+8], xmm5
			movhlps xmm2, xmm5
			mov edx, c_h
			movss [eax], xmm0
			movss [eax+4], xmm1
			movss [eax+8], xmm2
			shufps xmm3, xmm3, 0xb1 ;xmm3:   -  to.x   -  th.x
			shufps xmm4, xmm4, 0xb1 ;xmm4:   -  to.y   -  th.y
			shufps xmm5, xmm5, 0xb1 ;xmm5:   -  to.z   -  th.z
			mov eax, a_o
			movss [edx], xmm3
			movss [edx+4], xmm4
			movss [edx+8], xmm5
			mov edx, c_o
			movhlps xmm0, xmm3
			addss xmm0, [eax]
			movhlps xmm1, xmm4
			addss xmm1, [eax+4]
			movhlps xmm2, xmm5
			addss xmm2, [eax+8]
			movss [edx], xmm0
			movss [edx+4], xmm1
			movss [edx+8], xmm2
		}
	}
	else
	{
		point3d ts, th, tf, to;
		ts.x = a_s->x*b_s->x + a_h->x*b_s->y + a_f->x*b_s->z;
		ts.y = a_s->y*b_s->x + a_h->y*b_s->y + a_f->y*b_s->z;
		ts.z = a_s->z*b_s->x + a_h->z*b_s->y + a_f->z*b_s->z;
		th.x = a_s->x*b_h->x + a_h->x*b_h->y + a_f->x*b_h->z;
		th.y = a_s->y*b_h->x + a_h->y*b_h->y + a_f->y*b_h->z;
		th.z = a_s->z*b_h->x + a_h->z*b_h->y + a_f->z*b_h->z;
		tf.x = a_s->x*b_f->x + a_h->x*b_f->y + a_f->x*b_f->z;
		tf.y = a_s->y*b_f->x + a_h->y*b_f->y + a_f->y*b_f->z;
		tf.z = a_s->z*b_f->x + a_h->z*b_f->y + a_f->z*b_f->z;
		to.x = a_s->x*b_o->x + a_h->x*b_o->y + a_f->x*b_o->z + a_o->x;
		to.y = a_s->y*b_o->x + a_h->y*b_o->y + a_f->y*b_o->z + a_o->y;
		to.z = a_s->z*b_o->x + a_h->z*b_o->y + a_f->z*b_o->z + a_o->z;
		(*c_s) = ts; (*c_h) = th; (*c_f) = tf; (*c_o) = to;
	}
}

static void setlimb (kfatype *kfa, long i, long p, long trans_type, short val)
{
	point3d ps, ph, pf, pp;
	point3d qs, qh, qf, qp;
	float r[2];

		//Generate orthonormal matrix in world space for child limb
	qp = kfa->hinge[i].p[0]; qs = kfa->hinge[i].v[0]; genperp(&qs,&qh,&qf);

	switch (trans_type)
	{
		case 0: //Hinge rotate!
			//fcossin(((float)val)*(PI/32768.0),&c,&s);
			ucossin(((long)val)<<16,r);
			ph = qh; pf = qf;
			qh.x = ph.x*r[0] - pf.x*r[1]; qf.x = ph.x*r[1] + pf.x*r[0];
			qh.y = ph.y*r[0] - pf.y*r[1]; qf.y = ph.y*r[1] + pf.y*r[0];
			qh.z = ph.z*r[0] - pf.z*r[1]; qf.z = ph.z*r[1] + pf.z*r[0];
			break;
		default: __assume(0); //tells MSVC default can't be reached
	}

		//Generate orthonormal matrix in world space for parent limb
	pp = kfa->hinge[i].p[1]; ps = kfa->hinge[i].v[1]; genperp(&ps,&ph,&pf);

		//mat0(rotrans, loc_velcro, par_velcro)
	mat0(&qs,&qh,&qf,&qp, &qs,&qh,&qf,&qp, &ps,&ph,&pf,&pp);
		//mat2(par, rotrans, parent * par_velcro * (loc_velcro x rotrans)^-1)
	mat2(&kfa->spr[p].s,&kfa->spr[p].h,&kfa->spr[p].f,&kfa->spr[p].p,
		  &qs,&qh,&qf,&qp,
		  &kfa->spr[i].s,&kfa->spr[i].h,&kfa->spr[i].f,&kfa->spr[i].p);
}

	//Uses binary search to find sequence index at time "tim"
static long kfatime2seq (kfatype *kfa, long tim)
{
	long i, a, b;

	for(a=0,b=(kfa->seqnum)-1;b-a>=2;)
		{ i = ((a+b)>>1); if (tim >= kfa->seq[i].tim) a = i; else b = i; }
	return(a);
}

void animsprite (vx5sprite *s, long ti)
{
	kfatype *kfa;
	long i, j, k, x, y, z, zz, trat;
	long trat2, z0, zz0, frm0;

	if (!(s->flags&2)) return;
	kfa = s->kfaptr; if (!kfa) return;

	z = kfatime2seq(kfa,s->kfatim);
	while (ti > 0)
	{
		z++; if (z >= kfa->seqnum) break;
		i = kfa->seq[z].tim-s->kfatim; if (i <= 0) break;
		if (i > ti) { s->kfatim += ti; break; }
		ti -= i;
		zz = ~kfa->seq[z].frm; if (zz >= 0) { if (z == zz) break; z = zz; }
		s->kfatim = kfa->seq[z].tim;
	}

// --------------------------------------------------------------------------

	z = kfatime2seq(kfa,s->kfatim); zz = z+1;
	if ((zz < kfa->seqnum) && (kfa->seq[zz].frm != ~zz))
	{
		trat = kfa->seq[zz].tim-kfa->seq[z].tim;
		if (trat) trat = shldiv16(s->kfatim-kfa->seq[z].tim,trat);
		i = kfa->seq[zz].frm; if (i < 0) zz = kfa->seq[~i].frm; else zz = i;
	} else trat = 0;
	z = kfa->seq[z].frm;
	if (z < 0)
	{
		z0 = kfatime2seq(kfa,s->okfatim); zz0 = z0+1;
		if ((zz0 < kfa->seqnum) && (kfa->seq[zz0].frm != ~zz0))
		{
			trat2 = kfa->seq[zz0].tim-kfa->seq[z0].tim;
			if (trat2) trat2 = shldiv16(s->okfatim-kfa->seq[z0].tim,trat2);
			i = kfa->seq[zz0].frm; if (i < 0) zz0 = kfa->seq[~i].frm; else zz0 = i;
		} else trat2 = 0;
		z0 = kfa->seq[z0].frm; if (z0 < 0) { z0 = zz0; trat2 = 0; }
	} else trat2 = -1;

	for(i=(kfa->numhin)-1;i>=0;i--)
	{
		if (kfa->hinge[i].parent < 0) continue;

		if (trat2 < 0) frm0 = (long)kfa->frmval[z*(kfa->numhin)+i];
		else
		{
			frm0 = (long)kfa->frmval[z0*(kfa->numhin)+i];
			if (trat2 > 0)
			{
				x = (((long)(kfa->frmval[zz0*(kfa->numhin)+i]-frm0))&65535);
				if (kfa->hinge[i].vmin == kfa->hinge[i].vmax) x = ((x<<16)>>16);
				else if ((((long)(kfa->frmval[zz0*(kfa->numhin)+i]-kfa->hinge[i].vmin))&65535) <
							(((long)(frm0-kfa->hinge[i].vmin))&65535))
					x -= 65536;
				frm0 += mulshr16(x,trat2);
			}
		}
		if (trat > 0)
		{
			x = (((long)(kfa->frmval[zz*(kfa->numhin)+i]-frm0))&65535);
			if (kfa->hinge[i].vmin == kfa->hinge[i].vmax) x = ((x<<16)>>16);
			else if ((((long)(kfa->frmval[zz*(kfa->numhin)+i]-kfa->hinge[i].vmin))&65535) <
						(((long)(frm0-kfa->hinge[i].vmin))&65535))
				x -= 65536;
			frm0 += mulshr16(x,trat);
		}
		vx5.kfaval[i] = frm0;
	}
}

static void kfadraw (vx5sprite *s)
{
	point3d tp;
	kfatype *kfa;
	long i, j, k;

	kfa = s->kfaptr; if (!kfa) return;

	for(i=(kfa->numhin)-1;i>=0;i--)
	{
		j = kfa->hingesort[i]; k = kfa->hinge[j].parent;
		if (k >= 0) setlimb(kfa,j,k,kfa->hinge[j].htype,vx5.kfaval[j]);
		else
		{
			kfa->spr[j].s = s->s;
			kfa->spr[j].h = s->h;
			kfa->spr[j].f = s->f;
			//kfa->spr[j].p = s->p;
			tp.x = kfa->hinge[j].p[0].x;
			tp.y = kfa->hinge[j].p[0].y;
			tp.z = kfa->hinge[j].p[0].z;
			kfa->spr[j].p.x = s->p.x - tp.x*s->s.x - tp.y*s->h.x - tp.z*s->f.x;
			kfa->spr[j].p.y = s->p.y - tp.x*s->s.y - tp.y*s->h.y - tp.z*s->f.y;
			kfa->spr[j].p.z = s->p.z - tp.x*s->s.z - tp.y*s->h.z - tp.z*s->f.z;
		}
		if (j < kfa->numspr) kv6draw(&kfa->spr[j]);
	}
}

//--------------------------- KFA sprite code ends ---------------------------

void drawsprite (vx5sprite *spr)
{
	if (spr->flags&4) return;
	if (!(spr->flags&2)) kv6draw(spr); else kfadraw(spr);
}

#if 0

void setkv6 (vx5sprite *spr)
{
	point3d r0, r1;
	long x, y, vx, vy, vz;
	kv6data *kv;
	kv6voxtype *v, *ve;

	if (spr->flags&2) return;
	kv = spr->voxnum; if (!kv) return;

	vx5.minx = ?; vx5.maxx = ?+1;
	vx5.miny = ?; vx5.maxy = ?+1;
	vx5.minz = ?; vx5.maxz = ?+1;

	v = kv->vox; //.01 is to fool rounding so they aren't all even numbers
	r0.x = spr->p.x - kv->xpiv*spr->s.x - kv->ypiv*spr->h.x - kv->zpiv*spr->f.x - .01;
	r0.y = spr->p.y - kv->xpiv*spr->s.y - kv->ypiv*spr->h.y - kv->zpiv*spr->f.y - .01;
	r0.z = spr->p.z - kv->xpiv*spr->s.z - kv->ypiv*spr->h.z - kv->zpiv*spr->f.z - .01;
	vx5.colfunc = curcolfunc;
	for(x=0;x<kv->xsiz;x++)
	{
		r1 = r0;
		for(y=0;y<kv->ysiz;y++)
		{
			for(ve=&v[kv->ylen[x*kv->ysiz+y]];v<ve;v++)
			{
				ftol(spr->f.x*v->z + r1.x,&vx);
				ftol(spr->f.y*v->z + r1.y,&vy);
				ftol(spr->f.z*v->z + r1.z,&vz);
				vx5.curcol = ((v->col&0xffffff)|0x80000000);
				setcube(vx,vy,vz,-2);
			}
			r1.x += spr->h.x; r1.y += spr->h.y; r1.z += spr->h.z;
		}
		r0.x += spr->s.x; r0.y += spr->s.y; r0.z += spr->s.z;
	}
}

#else

#ifdef _MSC_VER

	//dmulshr22 = ((a*b + c*d)>>22)
static _inline long dmulshr22 (long a, long b, long c, long d)
{
	_asm
	{
		mov eax, a
		imul b
		mov ecx, eax
		push edx
		mov eax, c
		imul d
		add eax, ecx
		pop ecx
		adc edx, ecx
		shrd eax, edx, 22
	}
}


#endif

static kv6data *gfrezkv;
static lpoint3d gfrezx, gfrezy, gfrezz, gfrezp;
static signed char gkv6colx[27] = {0,  0, 0, 0, 0, 1,-1, -1,-1,-1,-1, 0, 0, 0, 0, 1, 1, 1, 1,  1, 1, 1, 1,-1,-1,-1,-1};
static signed char gkv6coly[27] = {0,  0, 0, 1,-1, 0, 0,  0, 0,-1, 1, 1, 1,-1,-1, 0, 0,-1, 1,  1, 1,-1,-1, 1, 1,-1,-1};
static signed char gkv6colz[27] = {0,  1,-1, 0, 0, 0, 0, -1, 1, 0, 0, 1,-1, 1,-1, 1,-1, 0, 0,  1,-1, 1,-1, 1,-1, 1,-1};
long kv6colfunc (lpoint3d *p)
{
	kv6voxtype *v0, *v1, *v, *ve;
	long i, j, k, x, y, z, ox, oy, nx, ny, nz, mind, d;

	x = ((p->x*gfrezx.x + p->y*gfrezy.x + p->z*gfrezz.x + gfrezp.x)>>16);
	y = ((p->x*gfrezx.y + p->y*gfrezy.y + p->z*gfrezz.y + gfrezp.y)>>16);
	z = ((p->x*gfrezx.z + p->y*gfrezy.z + p->z*gfrezz.z + gfrezp.z)>>16);
	x = lbound0(x,gfrezkv->xsiz-1);
	y = lbound0(y,gfrezkv->ysiz-1);
	z = lbound0(z,gfrezkv->zsiz-1);

		//Process x
	v0 = gfrezkv->vox;
	if ((x<<1) < gfrezkv->xsiz) { ox = oy = j = 0; }
	else { v0 += gfrezkv->numvoxs; ox = gfrezkv->xsiz; oy = gfrezkv->ysiz; j = ox*oy; }
	v1 = v0;

	for(k=0;k<27;k++)
	{
		nx = ((long)gkv6colx[k])+x; if ((unsigned long)nx >= gfrezkv->xsiz) continue;
		ny = ((long)gkv6coly[k])+y; if ((unsigned long)ny >= gfrezkv->ysiz) continue;
		nz = ((long)gkv6colz[k])+z; if ((unsigned long)nz >= gfrezkv->zsiz) continue;

		if (nx != ox)
		{
			while (nx > ox) { v0 += gfrezkv->xlen[ox]; ox++; j += gfrezkv->ysiz; }
			while (nx < ox) { ox--; v0 -= gfrezkv->xlen[ox]; j -= gfrezkv->ysiz; }
			if ((ny<<1) < gfrezkv->ysiz) { oy = 0; v1 = v0; }
			else { oy = gfrezkv->ysiz; v1 = v0+gfrezkv->xlen[nx]; }
		}
		if (ny != oy)
		{
			while (ny > oy) { v1 += gfrezkv->ylen[j+oy]; oy++; }
			while (ny < oy) { oy--; v1 -= gfrezkv->ylen[j+oy]; }
		}

			//Process z
		for(v=v1,ve=&v1[gfrezkv->ylen[j+ny]];v<ve;v++)
			if (v->z == nz) return(v->col);
	}

		//Use brute force when all else fails.. :/
	v = gfrezkv->vox; mind = 0x7fffffff;
	for(nx=0;nx<gfrezkv->xsiz;nx++)
		for(ny=0;ny<gfrezkv->ysiz;ny++)
			for(ve=&v[gfrezkv->ylen[nx*gfrezkv->ysiz+ny]];v<ve;v++)
			{
				d = labs(x-nx)+labs(y-ny)+labs(z-v->z);
				if (d < mind) { mind = d; k = v->col; }
			}
	return(k);
}

static void kv6colfuncinit (vx5sprite *spr, float det)
{
	point3d tp, tp2;
	float f;

	gfrezkv = spr->voxnum; if (!gfrezkv) { vx5.colfunc = curcolfunc; return; }

	tp2.x = gfrezkv->xpiv + .5;
	tp2.y = gfrezkv->ypiv + .5;
	tp2.z = gfrezkv->zpiv + .5;
	tp.x = spr->p.x - spr->s.x*tp2.x - spr->h.x*tp2.y - spr->f.x*tp2.z;
	tp.y = spr->p.y - spr->s.y*tp2.x - spr->h.y*tp2.y - spr->f.y*tp2.z;
	tp.z = spr->p.z - spr->s.z*tp2.x - spr->h.z*tp2.y - spr->f.z*tp2.z;

		//spr->s.x*x + spr->h.x*y + spr->f.x*z = np.x; //Solve for x,y,z
		//spr->s.y*x + spr->h.y*y + spr->f.y*z = np.y;
		//spr->s.z*x + spr->h.z*y + spr->f.z*z = np.z;
	f = 65536.0 / det;

	tp2.x = (spr->h.y*spr->f.z - spr->h.z*spr->f.y)*f; ftol(tp2.x,&gfrezx.x);
	tp2.y = (spr->h.z*spr->f.x - spr->h.x*spr->f.z)*f; ftol(tp2.y,&gfrezy.x);
	tp2.z = (spr->h.x*spr->f.y - spr->h.y*spr->f.x)*f; ftol(tp2.z,&gfrezz.x);
	ftol(-tp.x*tp2.x - tp.y*tp2.y - tp.z*tp2.z,&gfrezp.x); gfrezp.x += 32767;

	tp2.x = (spr->f.y*spr->s.z - spr->f.z*spr->s.y)*f; ftol(tp2.x,&gfrezx.y);
	tp2.y = (spr->f.z*spr->s.x - spr->f.x*spr->s.z)*f; ftol(tp2.y,&gfrezy.y);
	tp2.z = (spr->f.x*spr->s.y - spr->f.y*spr->s.x)*f; ftol(tp2.z,&gfrezz.y);
	ftol(-tp.x*tp2.x - tp.y*tp2.y - tp.z*tp2.z,&gfrezp.y); gfrezp.y += 32767;

	tp2.x = (spr->s.y*spr->h.z - spr->s.z*spr->h.y)*f; ftol(tp2.x,&gfrezx.z);
	tp2.y = (spr->s.z*spr->h.x - spr->s.x*spr->h.z)*f; ftol(tp2.y,&gfrezy.z);
	tp2.z = (spr->s.x*spr->h.y - spr->s.y*spr->h.x)*f; ftol(tp2.z,&gfrezz.z);
	ftol(-tp.x*tp2.x - tp.y*tp2.y - tp.z*tp2.z,&gfrezp.z); gfrezp.z += 32768;
}

#define LSC3 8 //2 for testing, 8 is normal
typedef struct
{
	long xo, yo, zo, xu, yu, zu, xv, yv, zv, d, msk, pzi;
	long xmino, ymino, xmaxo, ymaxo, xusc, yusc, xvsc, yvsc;
} gfrezt;
static gfrezt gfrez[6];
typedef struct { char z[2]; long n; } slstype;
void setkv6 (vx5sprite *spr, long dacol)
{
	point3d tp, tp2; float f, det;
	long i, j, k, x, y, z, c, d, x0, y0, z0, x1, y1, z1, xi, yi, zi;
	long xo, yo, zo, xu, yu, zu, xv, yv, zv, stu, stv, tu, tv;
	long xx, yy, xmin, xmax, ymin, ymax, isrhs, ihxi, ihyi, ihzi, syshpit;
	long isx, isy, isz, ihx, ihy, ihz, ifx, ify, ifz, iox, ioy, ioz;
	long sx, sy, sx0, sy0, sz0, rx, ry, rz, pz, dcnt, dcnt2, vismask, xysiz;
	long bx0, by0, bz0, bx1, by1, bz1, *lptr, *shead, shpit, scnt, sstop;
	gfrezt *gf;
	slstype *slst;
	kv6data *kv;
	kv6voxtype *v0, *v1, *v2, *v3;
	void (*modslab)(long *, long, long);

	if (spr->flags&2) return;
	kv = spr->voxnum; if (!kv) return;

		//Calculate top-left-up corner in VXL world coordinates
	tp.x = kv->xpiv + .5;
	tp.y = kv->ypiv + .5;
	tp.z = kv->zpiv + .5;
	tp2.x = spr->p.x - spr->s.x*tp.x - spr->h.x*tp.y - spr->f.x*tp.z;
	tp2.y = spr->p.y - spr->s.y*tp.x - spr->h.y*tp.y - spr->f.y*tp.z;
	tp2.z = spr->p.z - spr->s.z*tp.x - spr->h.z*tp.y - spr->f.z*tp.z;

		//Get bounding x-y box of entire freeze area:
	bx0 = VSID; by0 = VSID; bz0 = MAXZDIM; bx1 = 0; by1 = 0; bz1 = 0;
	for(z=kv->zsiz;z>=0;z-=kv->zsiz)
		for(y=kv->ysiz;y>=0;y-=kv->ysiz)
			for(x=kv->xsiz;x>=0;x-=kv->xsiz)
			{
				ftol(spr->s.x*(float)x + spr->h.x*(float)y + spr->f.x*(float)z + tp2.x,&i);
				if (i < bx0) bx0 = i;
				if (i > bx1) bx1 = i;
				ftol(spr->s.y*(float)x + spr->h.y*(float)y + spr->f.y*(float)z + tp2.y,&i);
				if (i < by0) by0 = i;
				if (i > by1) by1 = i;
				ftol(spr->s.z*(float)x + spr->h.z*(float)y + spr->f.z*(float)z + tp2.z,&i);
				if (i < bz0) bz0 = i;
				if (i > bz1) bz1 = i;
			}
	bx0 -= 2; if (bx0 < 0) bx0 = 0;
	by0 -= 2; if (by0 < 0) by0 = 0;
	bz0 -= 2; if (bz0 < 0) bz0 = 0;
	bx1 += 2; if (bx1 > VSID) bx1 = VSID;
	by1 += 2; if (by1 > VSID) by1 = VSID;
	bz1 += 2; if (bz1 > MAXZDIM) bz1 = MAXZDIM;
	vx5.minx = bx0; vx5.maxx = bx1;
	vx5.miny = by0; vx5.maxy = by1;
	vx5.minz = bz0; vx5.maxz = bz1;

	shpit = bx1-bx0; i = (by1-by0)*shpit*sizeof(shead[0]);
		//Make sure to use array that's big enough: umost is 1MB
	shead = (long *)(((long)umost) - (by0*shpit+bx0)*sizeof(shead[0]));
	slst = (slstype *)(((long)umost)+i);
	scnt = 1; sstop = (sizeof(umost)-i)/sizeof(slstype);
	memset(umost,0,i);

	f = (float)(1<<LSC3);
	ftol(spr->s.x*f,&isx); ftol(spr->s.y*f,&isy); ftol(spr->s.z*f,&isz);
	ftol(spr->h.x*f,&ihx); ftol(spr->h.y*f,&ihy); ftol(spr->h.z*f,&ihz);
	ftol(spr->f.x*f,&ifx); ftol(spr->f.y*f,&ify); ftol(spr->f.z*f,&ifz);
	ftol(tp2.x*f,&iox);
	ftol(tp2.y*f,&ioy);
	ftol(tp2.z*f,&ioz);

		//Determine whether sprite is RHS(1) or LHS(0)
	det = (spr->h.y*spr->f.z - spr->h.z*spr->f.y)*spr->s.x +
			(spr->h.z*spr->f.x - spr->h.x*spr->f.z)*spr->s.y +
			(spr->h.x*spr->f.y - spr->h.y*spr->f.x)*spr->s.z;
	if ((*(long *)&det) > 0) isrhs = 1;
	else if ((*(long *)&det) < 0) isrhs = 0;
	else return;

	xi = (((ifx*ihy-ihx*ify)>>31)|1);
	yi = (((isx*ify-ifx*isy)>>31)|1);
	zi = (((ihx*isy-isx*ihy)>>31)|1);
	if (xi > 0) { x0 = 0; x1 = kv->xsiz; } else { x0 = kv->xsiz-1; x1 = -1; }
	if (yi > 0) { y0 = 0; y1 = kv->ysiz; } else { y0 = kv->ysiz-1; y1 = -1; }
	if (zi > 0) { z0 = 0; z1 = kv->zsiz; } else { z0 = kv->zsiz-1; z1 = -1; }

	vismask = (zi<<3)+24 + (yi<<1)+6 + (xi>>1)+2;

	dcnt = 0;
	for(j=2;j;j--)
	{
		dcnt2 = dcnt;
		vismask = ~vismask;
		for(i=1;i<64;i+=i)
		{
			if (!(vismask&i)) continue;

			if (i&0x15) { xo = yo = zo = 0; }
			else if (i == 2) { xo = isx; yo = isy; zo = isz; }
			else if (i == 8) { xo = ihx; yo = ihy; zo = ihz; }
			else             { xo = ifx; yo = ify; zo = ifz; }

				  if (i&3)  { xu = ihx; yu = ihy; zu = ihz; xv = ifx; yv = ify; zv = ifz; }
			else if (i&12) { xu = isx; yu = isy; zu = isz; xv = ifx; yv = ify; zv = ifz; }
			else           { xu = isx; yu = isy; zu = isz; xv = ihx; yv = ihy; zv = ihz; }

			if ((yu < 0) || ((!yu) && (xu < 0)))
				{ xo += xu; yo += yu; zo += zu; xu = -xu; yu = -yu; zu = -zu; }
			if ((yv < 0) || ((!yv) && (xv < 0)))
				{ xo += xv; yo += yv; zo += zv; xv = -xv; yv = -yv; zv = -zv; }
			d = xv*yu - xu*yv; if (!d) continue;
			if (d < 0)
			{
				k = xu; xu = xv; xv = k;
				k = yu; yu = yv; yv = k;
				k = zu; zu = zv; zv = k; d = -d;
			}
			xmin = ymin = xmax = ymax = 0;
			if (xu < 0) xmin += xu; else xmax += xu;
			if (yu < 0) ymin += yu; else ymax += yu;
			if (xv < 0) xmin += xv; else xmax += xv;
			if (yv < 0) ymin += yv; else ymax += yv;

			gf = &gfrez[dcnt];
			gf->xo = xo; gf->yo = yo; gf->zo = zo;
			gf->xu = xu; gf->yu = yu;
			gf->xv = xv; gf->yv = yv;
			gf->xmino = xmin; gf->ymino = ymin;
			gf->xmaxo = xmax; gf->ymaxo = ymax;
			gf->xusc = (xu<<LSC3); gf->yusc = (yu<<LSC3);
			gf->xvsc = (xv<<LSC3); gf->yvsc = (yv<<LSC3);
			gf->d = d; gf->msk = i;

			f = 1.0 / (float)d;
			ftol(((float)gf->yusc * (float)zv - (float)gf->yvsc * (float)zu) * f,&gf->pzi);
			f *= 4194304.0;
			ftol((float)zu*f,&gf->zu);
			ftol((float)zv*f,&gf->zv);

			dcnt++;
		}
	}

	ihxi = ihx*yi;
	ihyi = ihy*yi;
	ihzi = ihz*yi;

	if (xi < 0) v0 = kv->vox+kv->numvoxs; else v0 = kv->vox;
	for(x=x0;x!=x1;x+=xi)
	{
		i = (long)kv->xlen[x];
		if (xi < 0) v0 -= i;
		if (yi < 0) v1 = v0+i; else v1 = v0;
		if (xi >= 0) v0 += i;
		xysiz = x*kv->ysiz;
		sx0 = isx*x + ihx*y0 + iox;
		sy0 = isy*x + ihy*y0 + ioy;
		sz0 = isz*x + ihz*y0 + ioz;
		for(y=y0;y!=y1;y+=yi)
		{
			i = (long)kv->ylen[xysiz+y];
			if (yi < 0) v1 -= i;
			if (zi < 0) { v2 = v1+i-1; v3 = v1-1; }
					 else { v2 = v1; v3 = v1+i; }
			if (yi >= 0) v1 += i;
			while (v2 != v3)
			{
				z = v2->z; //c = v2->col;
				rx = ifx*z + sx0;
				ry = ify*z + sy0;
				rz = ifz*z + sz0;
				for(i=0;i<dcnt;i++)
				{
					gf = &gfrez[i]; if (!(v2->vis&gf->msk)) continue;
					xo = gf->xo + rx;
					yo = gf->yo + ry;
					zo = gf->zo + rz;
					xmin = ((gf->xmino + xo)>>LSC3); if (xmin < 0) xmin = 0;
					ymin = ((gf->ymino + yo)>>LSC3); if (ymin < 0) ymin = 0;
					xmax = ((gf->xmaxo + xo)>>LSC3)+1; if (xmax > VSID) xmax = VSID;
					ymax = ((gf->ymaxo + yo)>>LSC3)+1; if (ymax > VSID) ymax = VSID;
					xx = (xmin<<LSC3) - xo;
					yy = (ymin<<LSC3) - yo;
					stu = yy*gf->xu - xx*gf->yu;
					stv = yy*gf->xv - xx*gf->yv - gf->d;
					syshpit = ymin*shpit;
					for(sy=ymin;sy<ymax;sy++,syshpit+=shpit)
					{
						tu = stu; stu += gf->xusc;
						tv = stv; stv += gf->xvsc;
						sx = xmin;
						while ((tu&tv) >= 0)
						{
							sx++; if (sx >= xmax) goto freezesprcont;
							tu -= gf->yusc; tv -= gf->yvsc;
						}
						tu = ~tu; tv += gf->d;
						pz = dmulshr22(tu,gf->zv,tv,gf->zu) + zo; j = syshpit+sx;
						tu -= gf->d; tv = ~tv;
						while ((tu&tv) < 0)
						{
							if (i < dcnt2)
							{
								if (scnt >= sstop) return; //OUT OF BUFFER SPACE!
								slst[scnt].z[0] = (char)lbound0(pz>>LSC3,255);
								slst[scnt].n = shead[j]; shead[j] = scnt; scnt++;
							}
							else slst[shead[j]].z[1] = (char)lbound0(pz>>LSC3,255);
							tu += gf->yusc; tv += gf->yvsc; pz += gf->pzi; j++;
						}
freezesprcont:;
					}
				}
				v2 += zi;
			}
			sx0 += ihxi; sy0 += ihyi; sz0 += ihzi;
		}
	}

	if (dacol == -1) modslab = delslab; else modslab = insslab;

	if (vx5.colfunc == kv6colfunc) kv6colfuncinit(spr,det);

	j = by0*shpit+bx0;
	for(sy=by0;sy<by1;sy++)
		for(sx=bx0;sx<bx1;sx++,j++)
		{
			i = shead[j]; if (!i) continue;
			lptr = scum2(sx,sy);
			do
			{
				modslab(lptr,(long)slst[i].z[isrhs],(long)slst[i].z[isrhs^1]);
				i = slst[i].n;
			} while (i);
		}
	scum2finish();
	updatebbox(vx5.minx,vx5.miny,vx5.minz,vx5.maxx,vx5.maxy,vx5.maxz,dacol);
}

#endif

	//Sprite structure is already allocated
	//kv6, vox, xlen, ylen are all malloced in here!
long meltsphere (vx5sprite *spr, lpoint3d *hit, long hitrad)
{
	long i, j, x, y, z, xs, ys, zs, xe, ye, ze, sq, z0, z1;
	long oxvoxs, oyvoxs, numvoxs, cx, cy, cz, cw;
	float f, ff;
	kv6data *kv;
	kv6voxtype *voxptr;
	unsigned long *xlenptr;
	unsigned short *ylenptr;

	xs = max(hit->x-hitrad,0); xe = min(hit->x+hitrad,VSID-1);
	ys = max(hit->y-hitrad,0); ye = min(hit->y+hitrad,VSID-1);
	zs = max(hit->z-hitrad,0); ze = min(hit->z+hitrad,MAXZDIM-1);
	if ((xs > xe) || (ys > ye) || (zs > ze)) return(0);

	if (hitrad >= SETSPHMAXRAD-1) hitrad = SETSPHMAXRAD-2;

	tempfloatbuf[0] = 0.0f;
#if 0
		//Totally unoptimized
	for(i=1;i<=hitrad;i++) tempfloatbuf[i] = pow((float)i,vx5.curpow);
#else
	tempfloatbuf[1] = 1.0f;
	for(i=2;i<=hitrad;i++)
	{
		if (!factr[i][0]) tempfloatbuf[i] = exp(logint[i]*vx5.curpow);
		else tempfloatbuf[i] = tempfloatbuf[factr[i][0]]*tempfloatbuf[factr[i][1]];
	}
#endif
	*(long *)&tempfloatbuf[hitrad+1] = 0x7f7fffff; //3.4028235e38f; //Highest float

// ---------- Need to know how many voxels to allocate... SLOW!!! :( ----------
	cx = cy = cz = 0; //Centroid
	cw = 0;       //Weight (1 unit / voxel)
	numvoxs = 0;
	sq = 0; //pow(fabs(x-hit->x),vx5.curpow) + "y + "z < pow(vx5.currad,vx5.curpow)
	for(x=xs;x<=xe;x++)
	{
		ff = tempfloatbuf[hitrad]-tempfloatbuf[labs(x-hit->x)];
		for(y=ys;y<=ye;y++)
		{
			f = ff-tempfloatbuf[labs(y-hit->y)];
			if (*(long *)&f > 0) //WARNING: make sure to always write ylenptr!
			{
				while (*(long *)&tempfloatbuf[sq] <  *(long *)&f) sq++;
				while (*(long *)&tempfloatbuf[sq] >= *(long *)&f) sq--;
				z0 = max(hit->z-sq,zs); z1 = min(hit->z+sq+1,ze);
				for(z=z0;z<z1;z++)
				{
					i = getcube(x,y,z); //0:air, 1:unexposed solid, 2:vbuf col ptr
					if (i)
					{
						cx += (x-hit->x); cy += (y-hit->y); cz += (z-hit->z); cw++;
					}
					if ((i == 0) || ((i == 1) && (1))) continue; //not_on_border))) continue; //FIX THIS!!!
					numvoxs++;
				}
			}
		}
	}
	if (numvoxs <= 0) return(0); //No voxels found!
// ---------------------------------------------------------------------------

	f = 1.0 / (float)cw; //Make center of sprite the centroid
	spr->p.x = (float)hit->x + (float)cx*f;
	spr->p.y = (float)hit->y + (float)cy*f;
	spr->p.z = (float)hit->z + (float)cz*f;
	spr->s.x = 1.f; spr->h.x = 0.f; spr->f.x = 0.f;
	spr->s.y = 0.f; spr->h.y = 1.f; spr->f.y = 0.f;
	spr->s.z = 0.f; spr->h.z = 0.f; spr->f.z = 1.f;

	x = xe-xs+1; y = ye-ys+1; z = ze-zs+1;

	j = sizeof(kv6data) + numvoxs*sizeof(kv6voxtype) + x*4 + x*y*2;
	i = (long)malloc(j); if (!i) return(0); if (i&3) { free((void *)i); return(0); }
	spr->voxnum = kv = (kv6data *)i; spr->flags = 0;
	kv->leng = j;
	kv->xsiz = x;
	kv->ysiz = y;
	kv->zsiz = z;
	kv->xpiv = spr->p.x - xs;
	kv->ypiv = spr->p.y - ys;
	kv->zpiv = spr->p.z - zs;
	kv->numvoxs = numvoxs;
	kv->namoff = 0;
	kv->lowermip = 0;
	kv->vox = (kv6voxtype *)((long)spr->voxnum+sizeof(kv6data));
	kv->xlen = (unsigned long *)(((long)kv->vox)+numvoxs*sizeof(kv6voxtype));
	kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);

	voxptr = kv->vox; numvoxs = 0;
	xlenptr = kv->xlen; oxvoxs = 0;
	ylenptr = kv->ylen; oyvoxs = 0;

	sq = 0; //pow(fabs(x-hit->x),vx5.curpow) + "y + "z < pow(vx5.currad,vx5.curpow)
	for(x=xs;x<=xe;x++)
	{
		ff = tempfloatbuf[hitrad]-tempfloatbuf[labs(x-hit->x)];
		for(y=ys;y<=ye;y++)
		{
			f = ff-tempfloatbuf[labs(y-hit->y)];
			if (*(long *)&f > 0) //WARNING: make sure to always write ylenptr!
			{
				while (*(long *)&tempfloatbuf[sq] <  *(long *)&f) sq++;
				while (*(long *)&tempfloatbuf[sq] >= *(long *)&f) sq--;
				z0 = max(hit->z-sq,zs); z1 = min(hit->z+sq+1,ze);
				for(z=z0;z<z1;z++)
				{
					i = getcube(x,y,z); //0:air, 1:unexposed solid, 2:vbuf col ptr
					if ((i == 0) || ((i == 1) && (1))) continue; //not_on_border))) continue; //FIX THIS!!!
					voxptr[numvoxs].col = lightvox(*(long *)i);
					voxptr[numvoxs].z = z-zs;
					voxptr[numvoxs].vis = 63; //FIX THIS!!!
					voxptr[numvoxs].dir = 0; //FIX THIS!!!
					numvoxs++;
				}
			}
			*ylenptr++ = numvoxs-oyvoxs; oyvoxs = numvoxs;
		}
		*xlenptr++ = numvoxs-oxvoxs; oxvoxs = numvoxs;
	}
	return(cw);
}

	//Sprite structure is already allocated
	//kv6, vox, xlen, ylen are all malloced in here!
long meltspans (vx5sprite *spr, vspans *lst, long lstnum, lpoint3d *offs)
{
	float f;
	long i, j, x, y, z, xs, ys, zs, xe, ye, ze, z0, z1;
	long ox, oy, oxvoxs, oyvoxs, numvoxs, cx, cy, cz, cw;
	kv6data *kv;
	kv6voxtype *voxptr;
	unsigned long *xlenptr;
	unsigned short *ylenptr;

	if (lstnum <= 0) return(0);
// ---------- Need to know how many voxels to allocate... SLOW!!! :( ----------
	cx = cy = cz = 0; //Centroid
	cw = 0;       //Weight (1 unit / voxel)
	numvoxs = 0;
	xs = xe = ((long)lst[0].x)+offs->x;
	ys = ((long)lst[       0].y)+offs->y;
	ye = ((long)lst[lstnum-1].y)+offs->y;
	zs = ze = ((long)lst[0].z0)+offs->z;
	for(j=0;j<lstnum;j++)
	{
		x = ((long)lst[j].x)+offs->x;
		y = ((long)lst[j].y)+offs->y; if ((x|y)&(~(VSID-1))) continue;
			  if (x < xs) xs = x;
		else if (x > xe) xe = x;
		z0 = ((long)lst[j].z0)+offs->z;   if (z0 < 0) z0 = 0;
		z1 = ((long)lst[j].z1)+offs->z+1; if (z1 > MAXZDIM) z1 = MAXZDIM;
		if (z0 < zs) zs = z0;
		if (z1 > ze) ze = z1;
		for(z=z0;z<z1;z++) //getcube too SLOW... FIX THIS!!!
		{
			i = getcube(x,y,z); //0:air, 1:unexposed solid, 2:vbuf col ptr
			if (i) { cx += x-offs->x; cy += y-offs->y; cz += z-offs->z; cw++; }
			if (i&~1) numvoxs++;
		}
	}
	if (numvoxs <= 0) return(0); //No voxels found!
// ---------------------------------------------------------------------------

	f = 1.0 / (float)cw; //Make center of sprite the centroid
	spr->p.x = (float)offs->x + (float)cx*f;
	spr->p.y = (float)offs->y + (float)cy*f;
	spr->p.z = (float)offs->z + (float)cz*f;
	spr->x.x = 0.f; spr->y.x = 1.f; spr->z.x = 0.f;
	spr->x.y = 1.f; spr->y.y = 0.f; spr->z.y = 0.f;
	spr->x.z = 0.f; spr->y.z = 0.f; spr->z.z = 1.f;

	x = xe-xs+1; y = ye-ys+1; z = ze-zs;

	j = sizeof(kv6data) + numvoxs*sizeof(kv6voxtype) + y*4 + x*y*2;
	i = (long)malloc(j); if (!i) return(0); if (i&3) { free((void *)i); return(0); }
	spr->voxnum = kv = (kv6data *)i; spr->flags = 0;
	kv->leng = j;
	kv->xsiz = y;
	kv->ysiz = x;
	kv->zsiz = z;
	kv->xpiv = spr->p.y - ys;
	kv->ypiv = spr->p.x - xs;
	kv->zpiv = spr->p.z - zs;
	kv->numvoxs = numvoxs;
	kv->namoff = 0;
	kv->lowermip = 0;
	kv->vox = (kv6voxtype *)((long)spr->voxnum+sizeof(kv6data));
	kv->xlen = (unsigned long *)(((long)kv->vox)+numvoxs*sizeof(kv6voxtype));
	kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);

	voxptr = kv->vox; numvoxs = 0;
	xlenptr = kv->xlen; oxvoxs = 0;
	ylenptr = kv->ylen; oyvoxs = 0;
	ox = xs; oy = ys;
	for(j=0;j<lstnum;j++)
	{
		x = ((long)lst[j].x)+offs->x;
		y = ((long)lst[j].y)+offs->y; if ((x|y)&(~(VSID-1))) continue;
		while ((ox != x) || (oy != y))
		{
			*ylenptr++ = numvoxs-oyvoxs; oyvoxs = numvoxs; ox++;
			if (ox > xe)
			{
				*xlenptr++ = numvoxs-oxvoxs; oxvoxs = numvoxs;
				ox = xs; oy++;
			}
		}
		z0 = ((long)lst[j].z0)+offs->z;   if (z0 < 0) z0 = 0;
		z1 = ((long)lst[j].z1)+offs->z+1; if (z1 > MAXZDIM) z1 = MAXZDIM;
		for(z=z0;z<z1;z++) //getcube TOO SLOW... FIX THIS!!!
		{
			i = getcube(x,y,z); //0:air, 1:unexposed solid, 2:vbuf col ptr
			if (!(i&~1)) continue;
			voxptr[numvoxs].col = lightvox(*(long *)i);
			voxptr[numvoxs].z = z-zs;

			voxptr[numvoxs].vis = 63; //FIX THIS!!!
			//if (!isvoxelsolid(x-1,y,z)) voxptr[numvoxs].vis |= 1;
			//if (!isvoxelsolid(x+1,y,z)) voxptr[numvoxs].vis |= 2;
			//if (!isvoxelsolid(x,y-1,z)) voxptr[numvoxs].vis |= 4;
			//if (!isvoxelsolid(x,y+1,z)) voxptr[numvoxs].vis |= 8;
			//if (!isvoxelsolid(x,y,z-1)) voxptr[numvoxs].vis |= 16;
			//if (!isvoxelsolid(x,y,z+1)) voxptr[numvoxs].vis |= 32;

			voxptr[numvoxs].dir = 0; //FIX THIS!!!
			numvoxs++;
		}
	}
	while (1)
	{
		*ylenptr++ = numvoxs-oyvoxs; oyvoxs = numvoxs; ox++;
		if (ox > xe)
		{
			*xlenptr++ = numvoxs-oxvoxs; oxvoxs = numvoxs;
			ox = xs; oy++; if (oy > ye) break;
		}
	}
	return(cw);
}

static void setlighting (long x0, long y0, long z0, long x1, long y1, long z1, long lval)
{
	long i, x, y;
	char *v;

	x0 = max(x0,0); x1 = min(x1,VSID);
	y0 = max(y0,0); y1 = min(y1,VSID);
	z0 = max(z0,0); z1 = min(z1,MAXZDIM);

	lval <<= 24;

		//Set 4th byte of colors to full intensity
	for(y=y0;y<y1;y++)
		for(x=x0;x<x1;x++)
		{
			for(v=sptr[y*VSID+x];v[0];v+=v[0]*4)
				for(i=1;i<v[0];i++)
					(*(long *)&v[i<<2]) = (((*(long *)&v[i<<2])&0xffffff)|lval);
			for(i=1;i<=v[2]-v[1]+1;i++)
				(*(long *)&v[i<<2]) = (((*(long *)&v[i<<2])&0xffffff)|lval);
		}
}

	//Updates Lighting, Mip-mapping, and Floating objects list
typedef struct { long x0, y0, z0, x1, y1, z1, csgdel; } bboxtyp;
#define BBOXSIZ 256
static bboxtyp bbox[BBOXSIZ];
static long bboxnum = 0;
void updatevxl ()
{
	long i;

	for(i=bboxnum-1;i>=0;i--)
	{
		if (vx5.lightmode)
			updatelighting(bbox[i].x0,bbox[i].y0,bbox[i].z0,bbox[i].x1,bbox[i].y1,bbox[i].z1);
		if (vx5.vxlmipuse > 1)
			genmipvxl(bbox[i].x0,bbox[i].y0,bbox[i].x1,bbox[i].y1);
		if ((vx5.fallcheck) && (bbox[i].csgdel))
			checkfloatinbox(bbox[i].x0,bbox[i].y0,bbox[i].z0,bbox[i].x1,bbox[i].y1,bbox[i].z1);
	}
	bboxnum = 0;
}

void updatebbox (long x0, long y0, long z0, long x1, long y1, long z1, long csgdel)
{
	long i;

	if ((x0 >= x1) || (y0 >= y1) || (z0 >= z1)) return;
	for(i=bboxnum-1;i>=0;i--)
	{
		if ((x0 >= bbox[i].x1) || (bbox[i].x0 >= x1)) continue;
		if ((y0 >= bbox[i].y1) || (bbox[i].y0 >= y1)) continue;
		if ((z0 >= bbox[i].z1) || (bbox[i].z0 >= z1)) continue;
		if (bbox[i].x0 < x0) x0 = bbox[i].x0;
		if (bbox[i].y0 < y0) y0 = bbox[i].y0;
		if (bbox[i].z0 < z0) z0 = bbox[i].z0;
		if (bbox[i].x1 > x1) x1 = bbox[i].x1;
		if (bbox[i].y1 > y1) y1 = bbox[i].y1;
		if (bbox[i].z1 > z1) z1 = bbox[i].z1;
		csgdel |= bbox[i].csgdel;
		bboxnum--; bbox[i] = bbox[bboxnum];
	}
	bbox[bboxnum].x0 = x0; bbox[bboxnum].x1 = x1;
	bbox[bboxnum].y0 = y0; bbox[bboxnum].y1 = y1;
	bbox[bboxnum].z0 = z0; bbox[bboxnum].z1 = z1;
	bbox[bboxnum].csgdel = csgdel; bboxnum++;
	if (bboxnum >= BBOXSIZ) updatevxl();
}

static long lightlst[MAXLIGHTS];
static float lightsub[MAXLIGHTS];
	//Re-calculates lighting byte #4 of all voxels inside bounding box
void updatelighting (long x0, long y0, long z0, long x1, long y1, long z1)
{
	point3d tp;
	float f, g, h, fx, fy, fz;
	long i, j, x, y, z, sz0, sz1, offs, cstat, lightcnt;
	long x2, y2, x3, y3;
	char *v;

	if (!vx5.lightmode) return;
	xbsox = -17;

	x0 = max(x0-ESTNORMRAD,0); x1 = min(x1+ESTNORMRAD,VSID);
	y0 = max(y0-ESTNORMRAD,0); y1 = min(y1+ESTNORMRAD,VSID);
	z0 = max(z0-ESTNORMRAD,0); z1 = min(z1+ESTNORMRAD,MAXZDIM);

	x2 = x0; y2 = y0;
	x3 = x1; y3 = y1;
	for(y0=y2;y0<y3;y0=y1)
	{
		y1 = min(y0+64,y3);  //"justfly -" (256 lights): +1024:41sec 512:29 256:24 128:22 64:21 32:21 16:21
		for(x0=x2;x0<x3;x0=x1)
		{
			x1 = min(x0+64,x3);


			if (vx5.lightmode == 2)
			{
				lightcnt = 0; //Find which lights are close enough to affect rectangle
				for(i=vx5.numlights-1;i>=0;i--)
				{
					ftol(vx5.lightsrc[i].p.x,&x);
					ftol(vx5.lightsrc[i].p.y,&y);
					ftol(vx5.lightsrc[i].p.z,&z);
					if (x < x0) x -= x0; else if (x > x1) x -= x1; else x = 0;
					if (y < y0) y -= y0; else if (y > y1) y -= y1; else y = 0;
					if (z < z0) z -= z0; else if (z > z1) z -= z1; else z = 0;
					f = vx5.lightsrc[i].r2;
					if ((float)(x*x+y*y+z*z) < f)
					{
						lightlst[lightcnt] = i;
						lightsub[lightcnt] = 1/(sqrt(f)*f);
						lightcnt++;
					}
				}
			}

			for(y=y0;y<y1;y++)
				for(x=x0;x<x1;x++)
				{
					v = sptr[y*VSID+x]; cstat = 0;
					while (1)
					{
						if (!cstat)
						{
							sz0 = ((long)v[1]); sz1 = ((long)v[2])+1; offs = 7-(sz0<<2);
							cstat = 1;
						}
						else
						{
							sz0 = ((long)v[2])-((long)v[1])-((long)v[0])+2;
							if (!v[0]) break; v += v[0]*4;
							sz1 = ((long)v[3]); sz0 += sz1; offs = 3-(sz1<<2);
							cstat = 0;
						}
						if (z0 > sz0) sz0 = z0;
						if (z1 < sz1) sz1 = z1;
						if (vx5.lightmode < 2)
						{
							for(z=sz0;z<sz1;z++)
							{
								estnorm(x,y,z,&tp);
								ftol((tp.y*.5+tp.z)*64.f+103.5f,&i);
								v[(z<<2)+offs] = *(char *)&i;
							}
						}
						else
						{
							for(z=sz0;z<sz1;z++)
							{
								estnorm(x,y,z,&tp);
								f = (tp.y*.5+tp.z)*16+47.5;
								for(i=lightcnt-1;i>=0;i--)
								{
									j = lightlst[i];
									fx = vx5.lightsrc[j].p.x-(float)x;
									fy = vx5.lightsrc[j].p.y-(float)y;
									fz = vx5.lightsrc[j].p.z-(float)z;
									h = tp.x*fx+tp.y*fy+tp.z*fz; if (*(long *)&h >= 0) continue;
									g = fx*fx+fy*fy+fz*fz; if (g >= vx5.lightsrc[j].r2) continue;

										//g = 1.0/(g*sqrt(g))-lightsub[i]; //1.0/g;
									if (cputype&(1<<25))
									{
										_asm
										{
											movss xmm0, g        ;xmm0=g
											rcpss xmm1, xmm0     ;xmm1=1/g
											rsqrtss xmm0, xmm0   ;xmm0=1/sqrt(g)
											mulss xmm1, xmm0     ;xmm1=1/(g*sqrt(g))
											mov eax, i
											subss xmm1, lightsub[eax*4]
											movss g, xmm1
										}
									}
									else
									{
										_asm
										{
											movd mm0, g
											pfrcp mm1, mm0
											pfrsqrt mm0, mm0
											pfmul mm0, mm1
											mov eax, i
											pfsub mm0, lightsub[eax*4]
											movd g, xmm0
											femms
										}
									}
									f -= g*h*vx5.lightsrc[j].sc;
								}
								if (*(long *)&f > 0x437f0000) f = 255; //0x437f0000 is 255.0
								ftol(f,&i);
								v[(z<<2)+offs] = *(char *)&i;
							}
						}
					}
				}
		}
	}
}

//float detection & falling code begins --------------------------------------
//How to use this section of code:
//Step 1: Call checkfloatinbox after every "deleting" set* call
//Step 2: Call dofalls(); at a constant rate in movement code

	//Adds all slabs inside box (inclusive) to "float check" list
void checkfloatinbox (long x0, long y0, long z0, long x1, long y1, long z1)
{
	long x, y;
	char *ov, *v;

	if (flchkcnt >= FLCHKSIZ) return;

		//Make all off-by-1 hacks in other code unnecessary
	x0 = max(x0-1,0); x1 = min(x1+1,VSID);
	y0 = max(y0-1,0); y1 = min(y1+1,VSID);
	z0 = max(z0-1,0); z1 = min(z1+1,MAXZDIM);

		//Add local box's slabs to flchk list - checked in next dofalls()
	for(y=y0;y<y1;y++)
		for(x=x0;x<x1;x++)
		{
			v = sptr[y*VSID+x];
			while (1)
			{
				ov = v; if ((z1 <= v[1]) || (!v[0])) break;
				v += v[0]*4; if (z0 >= v[3]) continue;
				flchk[flchkcnt].x = x;
				flchk[flchkcnt].y = y;
				flchk[flchkcnt].z = ov[1];
				flchkcnt++; if (flchkcnt >= FLCHKSIZ) return;
			}
		}
}

void isnewfloatingadd (long f)
{
	long v = (((f>>(LOGHASHEAD+3))-(f>>3)) & ((1<<LOGHASHEAD)-1));
	vlst[vlstcnt].b = hhead[v]; hhead[v] = vlstcnt;
	vlst[vlstcnt].v = f; vlstcnt++;
}

long isnewfloatingot (long f)
{
	long v = hhead[((f>>(LOGHASHEAD+3))-(f>>3)) & ((1<<LOGHASHEAD)-1)];
	while (1)
	{
		if (v < 0) return(-1);
		if (vlst[v].v == f) return(v);
		v = vlst[v].b;
	}
}

	//removes a & adds b while preserving index; used only by meltfall(...)
	//Must do nothing if 'a' not in hash
void isnewfloatingchg (long a, long b)
{
	long ov, v, i, j;

	i = (((a>>(LOGHASHEAD+3))-(a>>3)) & ((1<<LOGHASHEAD)-1));
	j = (((b>>(LOGHASHEAD+3))-(b>>3)) & ((1<<LOGHASHEAD)-1));

	v = hhead[i]; ov = -1;
	while (v >= 0)
	{
		if (vlst[v].v == a)
		{
			vlst[v].v = b; if (i == j) return;
			if (ov < 0) hhead[i] = vlst[v].b; else vlst[ov].b = vlst[v].b;
			vlst[v].b = hhead[j]; hhead[j] = v;
			return;
		}
		ov = v; v = vlst[v].b;
	}
}

long isnewfloating (flstboxtype *flb)
{
	float f;
	lpoint3d p, cen;
	long i, j, nx, ny, z0, z1, fend, ovlstcnt, mass;
	char *v, *ov;

	p.x = flb->chk.x; p.y = flb->chk.y; p.z = flb->chk.z;
	v = sptr[p.y*VSID+p.x];
	while (1)
	{
		ov = v;
		if ((p.z < v[1]) || (!v[0])) return(0);
		v += v[0]*4;
		if (p.z < v[3]) break;
	}

	if (isnewfloatingot((long)ov) >= 0) return(0);
	ovlstcnt = vlstcnt;
	isnewfloatingadd((long)ov);
	if (vlstcnt >= VLSTSIZ) return(0); //EVIL HACK TO PREVENT CRASH!

		//Init: centroid, mass, bounding box
	cen = p; mass = 1;
	flb->x0 = p.x-1; flb->y0 = p.y-1; flb->z0 = p.z-1;
	flb->x1 = p.x+1; flb->y1 = p.y+1; flb->z1 = p.z+1;

	fend = 0;
	while (1)
	{
		z0 = ov[1];         if (z0 < flb->z0) flb->z0 = z0;
		z1 = ov[ov[0]*4+3]; if (z1 > flb->z1) flb->z1 = z1;

		i = z1-z0;
		cen.x += p.x*i;
		cen.y += p.y*i;
		cen.z += (((z0+z1)*i)>>1); //sum(z0 to z1-1)
		mass += i;

		for(i=0;i<8;i++) //26-connectivity
		{
			switch(i)
			{
				case 0: nx = p.x-1; ny = p.y  ; if (nx < flb->x0) flb->x0 = nx; break;
				case 1: nx = p.x  ; ny = p.y-1; if (ny < flb->y0) flb->y0 = ny; break;
				case 2: nx = p.x+1; ny = p.y  ; if (nx > flb->x1) flb->x1 = nx; break;
				case 3: nx = p.x  ; ny = p.y+1; if (ny > flb->y1) flb->y1 = ny; break;
				case 4: nx = p.x-1; ny = p.y-1; break;
				case 5: nx = p.x+1; ny = p.y-1; break;
				case 6: nx = p.x-1; ny = p.y+1; break;
				case 7: nx = p.x+1; ny = p.y+1; break;
				default: __assume(0); //tells MSVC default can't be reached
			}
			if ((unsigned long)(nx|ny) >= VSID) continue;

			v = sptr[ny*VSID+nx];
			while (1)
			{
				if (!v[0])
				{
					if (v[1] <= z1) return(0);  //This MUST be <=, (not <) !!!
					break;
				}
				ov = v; v += v[0]*4; //NOTE: this is a 'different' ov
				if ((ov[1] > z1) || (z0 > v[3])) continue; //26-connectivity
				j = isnewfloatingot((long)ov);
				if (j < 0)
				{
					isnewfloatingadd((long)ov);
					if (vlstcnt >= VLSTSIZ) return(0); //EVIL HACK TO PREVENT CRASH!
					fstk[fend].x = nx; fstk[fend].y = ny; fstk[fend].z = (long)ov;
					fend++; if (fend >= FSTKSIZ) return(0); //EVIL HACK TO PREVENT CRASH!
					continue;
				}
				if ((unsigned long)j < ovlstcnt) return(0);
			}
		}

		if (!fend)
		{
			flb->i0 = ovlstcnt;
			flb->i1 = vlstcnt;
			flb->mass = mass; f = 1.0 / (float)mass;
			flb->centroid.x = (float)cen.x*f;
			flb->centroid.y = (float)cen.y*f;
			flb->centroid.z = (float)cen.z*f;
			return(1);
		}
		fend--;
		p.x = fstk[fend].x; p.y = fstk[fend].y; ov = (char *)fstk[fend].z;
	}
}

void startfalls ()
{
	long i, z;

		//This allows clear to be MUCH faster when there isn't much falling
	if (vlstcnt < ((1<<LOGHASHEAD)>>1))
	{
		for(i=vlstcnt-1;i>=0;i--)
		{
			z = vlst[i].v;
			hhead[((z>>(LOGHASHEAD+3))-(z>>3)) & ((1<<LOGHASHEAD)-1)] = -1;
		}
	}
	else { for(z=0;z<(1<<LOGHASHEAD);z++) hhead[z] = -1; }

		//Float detection...
		//flstcnt[].i0/i1 tell which parts of vlst are floating
	vlstcnt = 0;

		//Remove any current pieces that are no longer floating
	for(i=vx5.flstnum-1;i>=0;i--)
		if (!isnewfloating(&vx5.flstcnt[i])) //Modifies flstcnt,vlst[],vlstcnt
			vx5.flstcnt[i] = vx5.flstcnt[--vx5.flstnum]; //onground, so delete flstcnt[i]

		//Add new floating pieces (while space is left on flstcnt)
	if (vx5.flstnum < FLPIECES)
		for(i=flchkcnt-1;i>=0;i--)
		{
			vx5.flstcnt[vx5.flstnum].chk = flchk[i];
			if (isnewfloating(&vx5.flstcnt[vx5.flstnum])) //Modifies flstcnt,vlst[],vlstcnt
			{
				vx5.flstcnt[vx5.flstnum].userval = -1; //New piece: let game programmer know
				vx5.flstnum++; if (vx5.flstnum >= FLPIECES) break;
			}
		}
	flchkcnt = 0;
}

	//Call 0 or 1 times (per flstcnt) between startfalls&finishfalls
void dofall (long i)
{
	long j, z;
	char *v;

		//Falling code... call this function once per piece
	vx5.flstcnt[i].chk.z++;
	for(z=vx5.flstcnt[i].i1-1;z>=vx5.flstcnt[i].i0;z--)
	{
		v = (char *)vlst[z].v; v[1]++; v[2]++;
		v = &v[v[0]*4];
		v[3]++;
		if ((v[3] == v[1]) && (vx5.flstcnt[i].i1 >= 0))
		{
			j = isnewfloatingot((long)v);
				//Make sure it's not part of the same floating object
			if ((j < vx5.flstcnt[i].i0) || (j >= vx5.flstcnt[i].i1))
				vx5.flstcnt[i].i1 = -1; //Mark flstcnt[i] for scum2 fixup
		}
	}

	if (vx5.vxlmipuse > 1)
	{
		long x0, y0, x1, y1;
		x0 = max(vx5.flstcnt[i].x0,0); x1 = min(vx5.flstcnt[i].x1+1,VSID);
		y0 = max(vx5.flstcnt[i].y0,0); y1 = min(vx5.flstcnt[i].y1+1,VSID);
		//FIX ME!!!
		//if ((x1 > x0) && (y1 > y0)) genmipvxl(x0,y0,x1,y1); //Don't replace with bbox!
	}
}

	//Sprite structure is already allocated
	//kv6, vox, xlen, ylen are all malloced in here!
long meltfall (vx5sprite *spr, long fi, long delvxl)
{
	long i, j, k, x, y, z, xs, ys, zs, xe, ye, ze;
	long oxvoxs, oyvoxs, numvoxs;
	char *v, *ov, *nv;
	kv6data *kv;
	kv6voxtype *voxptr;
	unsigned long *xlenptr;
	unsigned short *ylenptr;

	if (vx5.flstcnt[fi].i1 < 0) return(0);

	xs = max(vx5.flstcnt[fi].x0,0); xe = min(vx5.flstcnt[fi].x1,VSID-1);
	ys = max(vx5.flstcnt[fi].y0,0); ye = min(vx5.flstcnt[fi].y1,VSID-1);
	zs = max(vx5.flstcnt[fi].z0,0); ze = min(vx5.flstcnt[fi].z1,MAXZDIM-1);
	if ((xs > xe) || (ys > ye) || (zs > ze)) return(0);

		//Need to know how many voxels to allocate... SLOW :(
	numvoxs = vx5.flstcnt[fi].i0-vx5.flstcnt[fi].i1;
	for(i=vx5.flstcnt[fi].i0;i<vx5.flstcnt[fi].i1;i++)
		numvoxs += ((char *)vlst[i].v)[0];
	if (numvoxs <= 0) return(0); //No voxels found!

	spr->p = vx5.flstcnt[fi].centroid;
	spr->s.x = 1.f; spr->h.x = 0.f; spr->f.x = 0.f;
	spr->s.y = 0.f; spr->h.y = 1.f; spr->f.y = 0.f;
	spr->s.z = 0.f; spr->h.z = 0.f; spr->f.z = 1.f;

	x = xe-xs+1; y = ye-ys+1; z = ze-zs+1;

	j = sizeof(kv6data) + numvoxs*sizeof(kv6voxtype) + x*4 + x*y*2;
	i = (long)malloc(j); if (!i) return(0); if (i&3) { free((void *)i); return(0); }
	spr->voxnum = kv = (kv6data *)i; spr->flags = 0;
	kv->leng = j;
	kv->xsiz = x;
	kv->ysiz = y;
	kv->zsiz = z;
	kv->xpiv = spr->p.x - xs;
	kv->ypiv = spr->p.y - ys;
	kv->zpiv = spr->p.z - zs;
	kv->numvoxs = numvoxs;
	kv->namoff = 0;
	kv->lowermip = 0;
	kv->vox = (kv6voxtype *)((long)spr->voxnum+sizeof(kv6data));
	kv->xlen = (unsigned long *)(((long)kv->vox)+numvoxs*sizeof(kv6voxtype));
	kv->ylen = (unsigned short *)(((long)kv->xlen) + kv->xsiz*4);

	voxptr = kv->vox; numvoxs = 0;
	xlenptr = kv->xlen; oxvoxs = 0;
	ylenptr = kv->ylen; oyvoxs = 0;

	for(x=xs;x<=xe;x++)
	{
		for(y=ys;y<=ye;y++)
		{
			for(v=sptr[y*VSID+x];v[0];v=nv)
			{
				nv = v+v[0]*4;

				i = isnewfloatingot((long)v);
				if (((unsigned long)i >= vx5.flstcnt[fi].i1) || (i < vx5.flstcnt[fi].i0))
					continue;

				for(z=v[1];z<=v[2];z++)
				{
					voxptr[numvoxs].col = lightvox(*(long *)&v[((z-v[1])<<2)+4]);
					voxptr[numvoxs].z = z-zs;

					voxptr[numvoxs].vis = 0; //OPTIMIZE THIS!!!
					if (!isvoxelsolid(x-1,y,z)) voxptr[numvoxs].vis |= 1;
					if (!isvoxelsolid(x+1,y,z)) voxptr[numvoxs].vis |= 2;
					if (!isvoxelsolid(x,y-1,z)) voxptr[numvoxs].vis |= 4;
					if (!isvoxelsolid(x,y+1,z)) voxptr[numvoxs].vis |= 8;
					//if (z == v[1]) voxptr[numvoxs].vis |= 16;
					//if (z == nv[3]-1) voxptr[numvoxs].vis |= 32;
					if (!isvoxelsolid(x,y,z-1)) voxptr[numvoxs].vis |= 16;
					if (!isvoxelsolid(x,y,z+1)) voxptr[numvoxs].vis |= 32;

					voxptr[numvoxs].dir = 0; //FIX THIS!!!
					numvoxs++;
				}
				for(z=nv[3]+v[2]-v[1]-v[0]+2;z<nv[3];z++)
				{
					voxptr[numvoxs].col = lightvox(*(long *)&nv[(z-nv[3])<<2]);
					voxptr[numvoxs].z = z-zs;

					voxptr[numvoxs].vis = 0; //OPTIMIZE THIS!!!
					if (!isvoxelsolid(x-1,y,z)) voxptr[numvoxs].vis |= 1;
					if (!isvoxelsolid(x+1,y,z)) voxptr[numvoxs].vis |= 2;
					if (!isvoxelsolid(x,y-1,z)) voxptr[numvoxs].vis |= 4;
					if (!isvoxelsolid(x,y+1,z)) voxptr[numvoxs].vis |= 8;
					//if (z == v[1]) voxptr[numvoxs].vis |= 16;
					//if (z == nv[3]-1) voxptr[numvoxs].vis |= 32;
					if (!isvoxelsolid(x,y,z-1)) voxptr[numvoxs].vis |= 16;
					if (!isvoxelsolid(x,y,z+1)) voxptr[numvoxs].vis |= 32;

					voxptr[numvoxs].dir = 0; //FIX THIS!!!
					numvoxs++;
				}

#if 0
				if (delvxl) //Quick&dirty dealloc from VXL (bad for holes!)
				{
						//invalidate current vptr safely
					isnewfloatingchg((long)v,0);

					k = nv-v; //perform slng(nv) and adjust vlst at same time
					for(ov=nv;ov[0];ov+=ov[0]*4)
						isnewfloatingchg((long)ov,((long)ov)-k);

					j = (long)ov-(long)nv+(ov[2]-ov[1]+1)*4+4;

						//shift end of RLE column up
					v[0] = nv[0]; v[1] = nv[1]; v[2] = nv[2];
					for(i=4;i<j;i+=4) *(long *)&v[i] = *(long *)&nv[i];

						//remove end of RLE column from vbit
					i = ((((long)(&v[i]))-(long)vbuf)>>2); j = (k>>2)+i;
#if 0
					while (i < j) { vbit[i>>5] &= ~(1<<i); i++; }
#else
					if (!((j^i)&~31))
						vbit[i>>5] &= ~(p2m[j&31]^p2m[i&31]);
					else
					{
						vbit[i>>5] &=   p2m[i&31];  i >>= 5;
						vbit[j>>5] &= (~p2m[j&31]); j >>= 5;
						for(j--;j>i;j--) vbit[j] = 0;
					}
#endif
					nv = v;
				}
#endif
			}
			*ylenptr++ = numvoxs-oyvoxs; oyvoxs = numvoxs;
		}
		*xlenptr++ = numvoxs-oxvoxs; oxvoxs = numvoxs;
	}

	if (delvxl)
		for(x=xs;x<=xe;x++)
			for(y=ys;y<=ye;y++)
				for(v=sptr[y*VSID+x];v[0];v=nv)
				{
					nv = v+v[0]*4;

					i = isnewfloatingot((long)v);
					if (((unsigned long)i >= vx5.flstcnt[fi].i1) || (i < vx5.flstcnt[fi].i0))
						continue;

						//Quick&dirty dealloc from VXL (bad for holes!)

						//invalidate current vptr safely
					isnewfloatingchg((long)v,0);

					k = nv-v; //perform slng(nv) and adjust vlst at same time
					for(ov=nv;ov[0];ov+=ov[0]*4)
						isnewfloatingchg((long)ov,((long)ov)-k);

					j = (long)ov-(long)nv+(ov[2]-ov[1]+1)*4+4;

						//shift end of RLE column up
					v[0] = nv[0]; v[1] = nv[1]; v[2] = nv[2];
					for(i=4;i<j;i+=4) *(long *)&v[i] = *(long *)&nv[i];

						//remove end of RLE column from vbit
					i = ((((long)(&v[i]))-(long)vbuf)>>2); j = (k>>2)+i;
#if 0
					while (i < j) { vbit[i>>5] &= ~(1<<i); i++; }
#else
					if (!((j^i)&~31))
						vbit[i>>5] &= ~(p2m[j&31]^p2m[i&31]);
					else
					{
						vbit[i>>5] &=   p2m[i&31];  i >>= 5;
						vbit[j>>5] &= (~p2m[j&31]); j >>= 5;
						for(j--;j>i;j--) vbit[j] = 0;
					}
#endif
					nv = v;
				}

	vx5.flstcnt[fi].i1 = -2; //Mark flstcnt[i] invalid; no scum2 fixup

	if (vx5.vxlmipuse > 1) genmipvxl(xs,ys,xe+1,ye+1);

	return(vx5.flstcnt[fi].mass);
}

void finishfalls ()
{
	long i, x, y;

		//Scum2 box fixup: refreshes rle voxel data inside a bounding rectangle
	for(i=vx5.flstnum-1;i>=0;i--)
		if (vx5.flstcnt[i].i1 < 0)
		{
			if (vx5.flstcnt[i].i1 == -1)
			{
				for(y=vx5.flstcnt[i].y0;y<=vx5.flstcnt[i].y1;y++)
					for(x=vx5.flstcnt[i].x0;x<=vx5.flstcnt[i].x1;x++)
						scum2(x,y);
				scum2finish();
				updatebbox(vx5.flstcnt[i].x0,vx5.flstcnt[i].y0,vx5.flstcnt[i].z0,vx5.flstcnt[i].x1,vx5.flstcnt[i].y1,vx5.flstcnt[i].z1,0);
			}
			vx5.flstcnt[i] = vx5.flstcnt[--vx5.flstnum]; //onground, so delete flstcnt[i]
		}
}

//float detection & falling code ends ----------------------------------------

//----------------------------------------------------------------------------

void voxsetframebuffer (long p, long b, long x, long y)
{
	long i;

	frameplace = p;
	if (x > MAXXDIM) x = MAXXDIM; //This sucks, but it crashes without it
	if (y > MAXYDIM) y = MAXYDIM;

		//Set global variables used by kv6draw's PIII asm (drawboundcube)
	qsum1[3] = qsum1[1] = 0x7fff-y;
  qsum1[2] = qsum1[0] = 0x7fff-x;
	kv6bytesperline = qbplbpp[1] = b; qbplbpp[0] = 4;
	kv6frameplace = p - (qsum1[0]*qbplbpp[0] + qsum1[1]*qbplbpp[1]);

	if ((b != ylookup[1]) || (x != xres) || (y != yres))
	{
		bytesperline = b; xres = x; yres = y; xres4 = (xres<<2);
		ylookup[0] = 0; for(i=0;i<yres;i++) ylookup[i+1] = ylookup[i]+bytesperline;
		//gihx = gihz = (float)xres*.5f; gihy = (float)yres*.5f; //BAD!!!
#if (USEZBUFFER == 1)
		if ((ylookup[yres]+256 > zbuffersiz) || (!zbuffermem))  //Increase Z buffer size if too small
		{
			if (zbuffermem) { free(zbuffermem); zbuffermem = 0; }
			zbuffersiz = ylookup[yres]+256;
			if (!(zbuffermem = (long *)malloc(zbuffersiz))) evilquit("voxsetframebuffer: allocation too big");
		}
#endif
	}
#if (USEZBUFFER == 1)
		//zbuffer aligns its memory to the same pixel boundaries as the screen!
		//WARNING: Pentium 4's L2 cache has severe slowdowns when 65536-64 <= (zbufoff&65535) < 64
	zbufoff = (((((long)zbuffermem)-frameplace-128)+255)&~255)+128;
#endif
	uurend = &uurendmem[((frameplace&4)^(((long)uurendmem)&4))>>2];

	if (vx5.fogcol >= 0)
	{
		fogcol = (((__int64)(vx5.fogcol&0xff0000))<<16) +
					(((__int64)(vx5.fogcol&0x00ff00))<< 8) +
					(((__int64)(vx5.fogcol&0x0000ff))    );

		if (vx5.maxscandist > 2047) vx5.maxscandist = 2047;
		if ((vx5.maxscandist != ofogdist) && (vx5.maxscandist > 0))
		{
			ofogdist = vx5.maxscandist;

			//foglut[?>>20] = min(?*32767/vx5.maxscandist,32767)
#if 0
			long j, k, l;
			j = 0; l = 0x7fffffff/vx5.maxscandist;
			for(i=0;i<2048;i++)
			{
				k = (j>>16); j += l;
				if (k < 0) break;
				foglut[i] = (((__int64)k)<<32)+(((__int64)k)<<16)+((__int64)k);
			}
			while (i < 2048) foglut[i++] = all32767;
#else
			i = 0x7fffffff/vx5.maxscandist;
			_asm
			{
				xor eax, eax
				mov ecx, -2048*8
				mov edx, i
fogbeg:     movd mm0, eax
				add eax, edx
				jo short fogend
				pshufw mm0, mm0, 0x55
				movq foglut[ecx+2048*8], mm0
				add ecx, 8
				js short fogbeg
				jmp short fogend2
fogend:     movq mm0, all32767
fogbeg2:    movq foglut[ecx+2048*8], mm0
				add ecx, 8
				js short fogbeg2
fogend2:    emms
			}
#endif
		}
	} else ofogdist = -1;

	if (cputype&(1<<25)) drawboundcubesseinit(); else drawboundcube3dninit();
}

//------------------------ Simple PNG OUT code begins ------------------------
FILE *pngofil;
long pngoxplc, pngoyplc, pngoxsiz, pngoysiz;
unsigned long pngocrc, pngoadcrc;

#ifdef _MSC_VER

static _inline unsigned long bswap (unsigned long a)
{
	_asm
	{
		mov eax, a
		bswap eax
	}
}

#endif

long crctab32[256];  //SEE CRC32.C
#define updatecrc32(c,crc) crc=(crctab32[(crc^c)&255]^(((unsigned)crc)>>8))
#define updateadl32(c,crc) \
{  c += (crc&0xffff); if (c   >= 65521) c   -= 65521; \
	crc = (crc>>16)+c; if (crc >= 65521) crc -= 65521; \
	crc = (crc<<16)+c; \
} \

void fputbytes (unsigned long v, long n)
	{ for(;n;v>>=8,n--) { fputc(v,pngofil); updatecrc32(v,pngocrc); } }

void pngoutopenfile (const char *fnam, long xsiz, long ysiz)
{
	long i, j, k;
	char a[40];

	pngoxsiz = xsiz; pngoysiz = ysiz; pngoxplc = pngoyplc = 0;
	for(i=255;i>=0;i--)
	{
		k = i; for(j=8;j;j--) k = ((unsigned long)k>>1)^((-(k&1))&0xedb88320);
		crctab32[i] = k;
	}
	pngofil = fopen(fnam,"wb");
	*(long *)&a[0] = 0x474e5089; *(long *)&a[4] = 0x0a1a0a0d;
	*(long *)&a[8] = 0x0d000000; *(long *)&a[12] = 0x52444849;
	*(long *)&a[16] = bswap(xsiz); *(long *)&a[20] = bswap(ysiz);
	*(long *)&a[24] = 0x00000208; *(long *)&a[28] = 0;
	for(i=12,j=-1;i<29;i++) updatecrc32(a[i],j);
	*(long *)&a[29] = bswap(j^-1);
	fwrite(a,37,1,pngofil);
	pngocrc = 0xffffffff; pngoadcrc = 1;
	fputbytes(0x54414449,4); fputbytes(0x0178,2);
}

void pngoutputpixel (long rgbcol)
{
	long a[4];

	if (!pngoxplc)
	{
		fputbytes(pngoyplc==pngoysiz-1,1);
		fputbytes(((pngoxsiz*3+1)*0x10001)^0xffff0000,4);
		fputbytes(0,1); a[0] = 0; updateadl32(a[0],pngoadcrc);
	}
	fputbytes(bswap(rgbcol<<8),3);
	a[0] = (rgbcol>>16)&255; updateadl32(a[0],pngoadcrc);
	a[0] = (rgbcol>> 8)&255; updateadl32(a[0],pngoadcrc);
	a[0] = (rgbcol    )&255; updateadl32(a[0],pngoadcrc);
	pngoxplc++; if (pngoxplc < pngoxsiz) return;
	pngoxplc = 0; pngoyplc++; if (pngoyplc < pngoysiz) return;
	fputbytes(bswap(pngoadcrc),4);
	a[0] = bswap(pngocrc^-1); a[1] = 0; a[2] = 0x444e4549; a[3] = 0x826042ae;
	fwrite(a,1,16,pngofil);
	a[0] = bswap(ftell(pngofil)-(33+8)-16);
	fseek(pngofil,33,SEEK_SET); fwrite(a,1,4,pngofil);
	fclose(pngofil);
}
//------------------------- Simple PNG OUT code ends -------------------------

long screencapture32bit (const char *fname)
{
	long p, x, y;

	pngoutopenfile(fname,xres,yres);
	p = frameplace;
	for(y=0;y<yres;y++,p+=bytesperline)
		for(x=0;x<xres;x++)
			pngoutputpixel(*(long *)(p+(x<<2)));

	return(0);
}

	//Captures all direction onto an un-wrapped cube
long surroundcapture32bit (dpoint3d *pos, const char *fname, long boxsiz)
{
	lpoint3d hit;
	dpoint3d d;
	long x, y, hboxsiz, *hind, hdir;
	float f;

	//Picture layout:
	//   ÛÛÛÛÛÛúúúú
	//   úúúúÛÛÛÛÛÛ

	f = 2.0 / (float)boxsiz; hboxsiz = (boxsiz>>1);
	pngoutopenfile(fname,boxsiz*5,boxsiz*2);
	for(y=-hboxsiz;y<hboxsiz;y++)
	{
		for(x=-hboxsiz;x<hboxsiz;x++) //(1,1,-1) - (-1,1,1)
		{
			d.x = -(x+.5)*f; d.y = 1; d.z = (y+.5)*f;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
		for(x=-hboxsiz;x<hboxsiz;x++) //(-1,1,-1) - (-1,-1,1)
		{
			d.x = -1; d.y = -(x+.5)*f; d.z = (y+.5)*f;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
		for(x=-hboxsiz;x<hboxsiz;x++) //(-1,-1,-1) - (1,-1,1)
		{
			d.x = (x+.5)*f; d.y = -1; d.z = (y+.5)*f;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
		for(x=(boxsiz<<1);x>0;x--) pngoutputpixel(0);
	}
	for(y=-hboxsiz;y<hboxsiz;y++)
	{
		for(x=(boxsiz<<1);x>0;x--) pngoutputpixel(0);
		for(x=-hboxsiz;x<hboxsiz;x++) //(-1,-1,1) - (1,1,1)
		{
			d.x = (x+.5)*f; d.y = (y+.5)*f; d.z = 1;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
		for(x=-hboxsiz;x<hboxsiz;x++) //(1,-1,1) - (1,1,-1)
		{
			d.x = 1; d.y = (y+.5)*f; d.z = -(x+.5)*f;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
		for(x=-hboxsiz;x<hboxsiz;x++) //(1,-1,-1) - (-1,1,-1)
		{
			d.x = -(x+.5)*f; d.y = (y+.5)*f; d.z = -1;
			hitscan(pos,&d,&hit,&hind,&hdir);
			if (hind) pngoutputpixel(lightvox(*hind)); else pngoutputpixel(0);
		}
	}
	return(0);
}

static _inline long testflag (long c)
{
	_asm
	{
		mov ecx, c
		pushfd
		pop eax
		mov edx, eax
		xor eax, ecx
		push eax
		popfd
		pushfd
		pop eax
		xor eax, edx
		mov eax, 1
		jne menostinx
		xor eax, eax
		menostinx:
	}
}

static _inline void cpuid (long a, long *s)
{
	_asm
	{
		push ebx
		push esi
		mov eax, a
		cpuid
		mov esi, s
		mov dword ptr [esi+0], eax
		mov dword ptr [esi+4], ebx
		mov dword ptr [esi+8], ecx
		mov dword ptr [esi+12], edx
		pop esi
		pop ebx
	}
}

	//Bit numbers of return value:
	//0:FPU, 4:RDTSC, 15:CMOV, 22:MMX+, 23:MMX, 25:SSE, 26:SSE2, 30:3DNow!+, 31:3DNow!
static long getcputype ()
{
	long i, cpb[4], cpid[4];
	if (!testflag(0x200000)) return(0);
	cpuid(0,cpid); if (!cpid[0]) return(0);
	cpuid(1,cpb); i = (cpb[3]&~((1<<22)|(1<<30)|(1<<31)));
	cpuid(0x80000000,cpb);
	if (((unsigned long)cpb[0]) > 0x80000000)
	{
		cpuid(0x80000001,cpb);
		i |= (cpb[3]&(1<<31));
		if (!((cpid[1]^0x68747541)|(cpid[3]^0x69746e65)|(cpid[2]^0x444d4163))) //AuthenticAMD
			i |= (cpb[3]&((1<<22)|(1<<30)));
	}
	if (i&(1<<25)) i |= (1<<22); //SSE implies MMX+ support
	return(i);
}

#if 0
  //This doesn't speed it up and it only makes it crash on some computers :/
static _inline void fixsse ()
{
	static long asm32;
	_asm
	{
		stmxcsr [asm32]  ;Default is:0x1f80
		or asm32, 0x8040 ;enable ftz&daz to prevent slow denormals!
		ldmxcsr [asm32]
	}
}
#endif

void freekv6 (kv6data *kv6)
{
	if (kv6->lowermip) freekv6(kv6->lowermip); //NOTE: dangerous - recursive!
	free((void *)kv6);
}

void uninitvoxlap ()
{
	if (sxlbuf) { free(sxlbuf); sxlbuf = 0; }

	if (vbuf) { free(vbuf); vbuf = 0; }
	if (vbit) { free(vbit); vbit = 0; }

	if (khashbuf)
	{     //Free all KV6&KFA on hash list
		long i, j;
		kfatype *kfp;
		for(i=0;i<khashpos;i+=strlen(&khashbuf[i+9])+10)
		{
			switch (khashbuf[i+8])
			{
				case 0: //KV6
					freekv6(*(kv6data **)&khashbuf[i+4]);
					break;
				case 1: //KFA
					kfp = *(kfatype **)&khashbuf[i+4];
					if (!kfp) continue;
					if (kfp->seq) free((void *)kfp->seq);
					if (kfp->frmval) free((void *)kfp->frmval);
					if (kfp->hingesort) free((void *)kfp->hingesort);
					if (kfp->hinge) free((void *)kfp->hinge);
					if (kfp->spr)
					{
						for(j=kfp->numspr-1;j>=0;j--)
							if (kfp->spr[j].voxnum)
								freekv6((kv6data *)kfp->spr[j].voxnum);
						free((void *)kfp->spr);
					}
					free((void *)kfp);
					break;
				default: __assume(0); //tells MSVC default can't be reached
			}
		}
		free(khashbuf); khashbuf = 0; khashpos = khashsiz = 0;
	}

	if (skylng) { free((void *)skylng); skylng = 0; }
	if (skylat) { free((void *)skylat); skylat = 0; }
	if (skypic) { free((void *)skypic); skypic = skyoff = 0; }

	if (vx5.pic) { free(vx5.pic); vx5.pic = 0; }
#if (USEZBUFFER == 1)
	if (zbuffermem) { free(zbuffermem); zbuffermem = 0; }
#endif
	if (radarmem) { free(radarmem); radarmem = 0; radar = 0; }
}

long initvoxlap ()
{
	__int64 q;
	long i, j, k, z, zz;
	float f, ff;

	v5_asm_dep_unlock();

	cputype = getcputype();
		//CPU Must have: FPU,RDTSC,CMOV,MMX,MMX+
	if ((cputype&((1<<0)|(1<<4)|(1<<15)|(1<<22)|(1<<23))) !=
					 ((1<<0)|(1<<4)|(1<<15)|(1<<22)|(1<<23))) return(-1);
		//CPU UNSUPPORTED!
	if ((!(cputype&(1<<25))) && //SSE
		(!((cputype&((1<<30)|(1<<31))) == ((1<<30)|(1<<31))))) //3DNow!+
		return(-1);
	//if (cputype&(1<<25)) fixsse(); //SSE

	  //WARNING: xres&yres are local to VOXLAP5.C so don't rely on them here!
	if (!(radarmem = (long *)malloc(max((((MAXXDIM*MAXYDIM*27)>>1)+7)&~7,(VSID+4)*3*SCPITCH*4+8))))
		return(-1);
	radar = (long *)((((long)radarmem)+7)&~7);

	for(i=0;i<32;i++) { xbsflor[i] = (-1<<i); xbsceil[i] = ~xbsflor[i]; }

		//Setsphere precalculations (factr[] tables) (Derivation in POWCALC.BAS)
		//   if (!factr[z][0]) z's prime else factr[z][0]*factr[z][1] == z
	factr[2][0] = 0; i = 1; j = 9; k = 0;
	for(z=3;z<SETSPHMAXRAD;z+=2)
	{
		if (z == j) { j += (i<<2)+12; i += 2; }
		factr[z][0] = 0; factr[k][1] = z;
		for(zz=3;zz<=i;zz=factr[zz][1])
			if (!(z%zz)) { factr[z][0] = zz; factr[z][1] = z/zz; break; }
		if (!factr[z][0]) k = z;
		factr[z+1][0] = ((z+1)>>1); factr[z+1][1] = 2;
	}
	for(z=1;z<SETSPHMAXRAD;z++) logint[z] = log((double)z);

#if (ESTNORMRAD == 2)
		//LUT for ESTNORM
	fsqrecip[0] = 0.f; fsqrecip[1] = 1.f;
	fsqrecip[2] = (float)(1.f/sqrt(2.f)); fsqrecip[3] = (float)1.f/sqrt(3.f);
	for(z=4,i=3;z<sizeof(fsqrecip)/sizeof(fsqrecip[0]);z+=6) //fsqrecip[z] = 1/sqrt(z);
	{
		fsqrecip[z+0] = fsqrecip[(z+0)>>1]*fsqrecip[2];
		fsqrecip[z+2] = fsqrecip[(z+2)>>1]*fsqrecip[2];
		fsqrecip[z+4] = fsqrecip[(z+4)>>1]*fsqrecip[2];
		fsqrecip[z+5] = fsqrecip[i]*fsqrecip[3]; i += 2;

		f = (fsqrecip[z+0]+fsqrecip[z+2])*.5f;
		if (z <= 22) f = (1.5f-(.5f*((float)(z+1))) * f*f)*f;
		fsqrecip[z+1] = (1.5f-(.5f*((float)(z+1))) * f*f)*f;

		f = (fsqrecip[z+2]+fsqrecip[z+4])*.5f;
		if (z <= 22) f = (1.5f-(.5f*((float)(z+3))) * f*f)*f;
		fsqrecip[z+3] = (1.5f-(.5f*((float)(z+3))) * f*f)*f;
	}
#endif

		//Lookup table to save 1 divide for gline()
	for(i=1;i<CMPRECIPSIZ;i++) cmprecip[i] = CMPPREC/(float)i;

		//Flashscan equal-angle compare table
	for(i=0;i<(1<<LOGFLASHVANG)*8;i++)
	{
		if (!(i&((1<<LOGFLASHVANG)-1)))
			j = (gfclookup[i>>LOGFLASHVANG]<<4)+8 - (1<<LOGFLASHVANG)*64;
		gfc[i].y = j; j += 64*2;
		ftol(sqrt((1<<(LOGFLASHVANG<<1))*64.f*64.f-gfc[i].y*gfc[i].y),&gfc[i].x);
	}

		//Init norm flash variables:
	ff = (float)GSIZ*.5f; // /(1);
	for(z=1;z<(GSIZ>>1);z++)
	{
		ffxptr = &ffx[(z+1)*z-1];
		f = ff; ff = (float)GSIZ*.5f/((float)z+1);
		for(zz=-z;zz<=z;zz++)
		{
			if (zz <= 0) i = (long)(((float)zz-.5f)*f); else i = (long)(((float)zz-.5f)*ff);
			if (zz >= 0) j = (long)(((float)zz+.5f)*f); else j = (long)(((float)zz+.5f)*ff);
			ffxptr[zz].x = (unsigned short)max(i+(GSIZ>>1),0);
			ffxptr[zz].y = (unsigned short)min(j+(GSIZ>>1),GSIZ);
		}
	}
	for(i=0;i<=25*5;i+=5) xbsbuf[i] = 0x00000000ffffffff;
	for(z=0;z<32;z++) { p2c[z] = (1<<z); p2m[z] = p2c[z]-1; }

		//Drawtile lookup table:
	//q = 0;
	//for(i=0;i<256;i++) { alphalookup[i] = q; q += 0x1000100010; }

		//Initialize univec normals (for KV6 lighting)
	equivecinit(255);
	//for(i=0;i<255;i++)
	//{
	//   univec[i].z = ((float)((i<<1)-254))/255.0;
	//   f = sqrt(1.0 - univec[i].z*univec[i].z);
	//   fcossin((float)i*(GOLDRAT*PI*2),&univec[i].x,&univec[i].y);
	//   univec[i].x *= f; univec[i].y *= f;
	//}
	//univec[255].x = univec[255].y = univec[255].z = 0;
	for(i=0;i<256;i++)
	{
		iunivec[i][0] = (short)(univec[i].x*4096.0);
		iunivec[i][1] = (short)(univec[i].y*4096.0);
		iunivec[i][2] = (short)(univec[i].z*4096.0);
		iunivec[i][3] = 4096;
	}
	ucossininit();

	memset(mixn,0,sizeof(mixn));

		//Initialize hash table for getkv6()
	memset(khashead,-1,sizeof(khashead));
	if (!(khashbuf = (char *)malloc(KHASHINITSIZE))) return(-1);
	khashsiz = KHASHINITSIZE;

	vx5.anginc = 1; //Higher=faster (1:full,2:half)
	vx5.sideshademode = 0; setsideshades(0,0,0,0,0,0);
	vx5.mipscandist = 128;
	vx5.maxscandist = 256; //must be <= 2047
	vx5.colfunc = curcolfunc; //This prevents omission bugs from crashing voxlap5
	vx5.curcol = 0x80804c33;
	vx5.currad = 8;
	vx5.curhei = 0;
	vx5.curpow = 2.0;
	vx5.amount = 0x70707;
	vx5.pic = 0;
	vx5.cliphitnum = 0;
	vx5.xplanemin = 0;
	vx5.xplanemax = 0x7fffffff;
	vx5.flstnum = 0;
	vx5.lightmode = 0;
	vx5.numlights = 0;
	vx5.kv6mipfactor = 96;
	vx5.kv6col = 0x808080;
	vx5.vxlmipuse = 1;
	vx5.fogcol = -1;
	vx5.fallcheck = 0;

	gmipnum = 0;

	return(0);
}

#if 0 //ndef _WIN32
	long i, j, k, l;
	char *v;

	j = k = l = 0;
	for(i=0;i<VSID*VSID;i++)
	{
		for(v=sptr[i];v[0];v+=v[0]*4) { j++; k += v[2]-v[1]+1; l += v[0]-1; }
		k += v[2]-v[1]+1; l += v[2]-v[1]+1;
	}

	printf("VOXLAP5 programmed by Ken Silverman (www.advsys.net/ken)\n");
	printf("Please DO NOT DISTRIBUTE! If this leaks, I will not be happy.\n\n");
	//printf("This copy licensed to:  \n\n");
	printf("Memory statistics upon exit: (all numbers in bytes)");
	printf("\n");
	if (screen) printf("   screen: %8ld\n",imageSize);
	printf("    radar: %8ld\n",max((((MAXXDIM*MAXYDIM*27)>>1)+7)&~7,(VSID+4)*3*SCPITCH*4+8));
	printf("  bacsptr: %8ld\n",sizeof(bacsptr));
	printf("     sptr: %8ld\n",(VSID*VSID)<<2);
	printf("     vbuf: %8ld(%8ld)\n",(j+VSID*VSID+l)<<2,VOXSIZ);
	printf("     vbit: %8ld(%8ld)\n",VOXSIZ>>5);
	printf("\n");
	printf("vbuf head: %8ld\n",(j+VSID*VSID)<<2);
	printf("vbuf cols: %8ld\n",l<<2);
	printf("     fcol: %8ld\n",k<<2);
	printf("     ccol: %8ld\n",(l-k)<<2);
	printf("\n");
	printf("%.2f bytes/column\n",(float)((j+VSID*VSID+l)<<2)/(float)(VSID*VSID));
#endif