Bunch of small changes...

1 files changed, 294 insertions, 294 deletions

diff --git a/src/engine/normal.cpp b/src/engine/normal.cpp
index d8641ab..dad00b0 100644
--- a/src/engine/normal.cpp
+++ b/src/engine/normal.cpp
@@ -2,27 +2,27 @@
 
 struct normalgroup
 {
-    vec pos;
-    int flat, normals, tnormals;
+	vec pos;
+	int flat, normals, tnormals;
 
-    normalgroup() : flat(0), normals(-1), tnormals(-1) {}
-    normalgroup(const vec &pos) : pos(pos), flat(0), normals(-1), tnormals(-1) {}
+	normalgroup() : flat(0), normals(-1), tnormals(-1) {}
+	normalgroup(const vec &pos) : pos(pos), flat(0), normals(-1), tnormals(-1) {}
 };
 
-static inline bool htcmp(const vec &v, const normalgroup &n) { return v == n.pos; } 
+static inline bool htcmp(const vec &v, const normalgroup &n) { return v == n.pos; }
 
 struct normal
 {
-    int next;
-    vec surface;
+	int next;
+	vec surface;
 };
 
 struct tnormal
 {
-    int next;
-    float offset;
-    int normals[2];
-    normalgroup *groups[2];
+	int next;
+	float offset;
+	int normals[2];
+	normalgroup *groups[2];
 };
 
 hashset<normalgroup> normalgroups(1<<16);
@@ -36,91 +36,91 @@ static bool usetnormals = true;
 
 static int addnormal(const vec &key, const vec &surface)
 {
-    normalgroup &g = normalgroups.access(key, key);
-    normal &n = normals.add();
-    n.next = g.normals;
-    n.surface = surface;
-    return g.normals = normals.length()-1;
+	normalgroup &g = normalgroups.access(key, key);
+	normal &n = normals.add();
+	n.next = g.normals;
+	n.surface = surface;
+	return g.normals = normals.length()-1;
 }
 
 static void addtnormal(const vec &key, float offset, int normal1, int normal2, normalgroup *group1, normalgroup *group2)
 {
-    normalgroup &g = normalgroups.access(key, key);
-    tnormal &n = tnormals.add();
-    n.next = g.tnormals;
-    n.offset = offset;
-    n.normals[0] = normal1;
-    n.normals[1] = normal2;
-    n.groups[0] = group1;
-    n.groups[1] = group2;
-    g.tnormals = tnormals.length()-1;
+	normalgroup &g = normalgroups.access(key, key);
+	tnormal &n = tnormals.add();
+	n.next = g.tnormals;
+	n.offset = offset;
+	n.normals[0] = normal1;
+	n.normals[1] = normal2;
+	n.groups[0] = group1;
+	n.groups[1] = group2;
+	g.tnormals = tnormals.length()-1;
 }
 
 static int addnormal(const vec &key, int axis)
 {
-    normalgroup &g = normalgroups.access(key, key);
-    g.flat += 1<<(4*axis);
-    return axis - 6;
+	normalgroup &g = normalgroups.access(key, key);
+	g.flat += 1<<(4*axis);
+	return axis - 6;
 }
 
 static inline void findnormal(const normalgroup &g, const vec &surface, vec &v)
 {
-    v = vec(0, 0, 0);
-    int total = 0;
-    if(surface.x >= lerpthreshold) { int n = (g.flat>>4)&0xF; v.x += n; total += n; }
-    else if(surface.x <= -lerpthreshold) { int n = g.flat&0xF; v.x -= n; total += n; }
-    if(surface.y >= lerpthreshold) { int n = (g.flat>>12)&0xF; v.y += n; total += n; }
-    else if(surface.y <= -lerpthreshold) { int n = (g.flat>>8)&0xF; v.y -= n; total += n; }
-    if(surface.z >= lerpthreshold) { int n = (g.flat>>20)&0xF; v.z += n; total += n; }
-    else if(surface.z <= -lerpthreshold) { int n = (g.flat>>16)&0xF; v.z -= n; total += n; }
-    for(int cur = g.normals; cur >= 0;)
-    {
-        normal &o = normals[cur];
-        if(o.surface.dot(surface) >= lerpthreshold)
-        {
-            v.add(o.surface);
-            total++;
-        }
-        cur = o.next;
-    }
-    if(total > 1) v.normalize();
-    else if(!total) v = surface;
+	v = vec(0, 0, 0);
+	int total = 0;
+	if(surface.x >= lerpthreshold) { int n = (g.flat>>4)&0xF; v.x += n; total += n; }
+	else if(surface.x <= -lerpthreshold) { int n = g.flat&0xF; v.x -= n; total += n; }
+	if(surface.y >= lerpthreshold) { int n = (g.flat>>12)&0xF; v.y += n; total += n; }
+	else if(surface.y <= -lerpthreshold) { int n = (g.flat>>8)&0xF; v.y -= n; total += n; }
+	if(surface.z >= lerpthreshold) { int n = (g.flat>>20)&0xF; v.z += n; total += n; }
+	else if(surface.z <= -lerpthreshold) { int n = (g.flat>>16)&0xF; v.z -= n; total += n; }
+	for(int cur = g.normals; cur >= 0;)
+	{
+		normal &o = normals[cur];
+		if(o.surface.dot(surface) >= lerpthreshold)
+		{
+			v.add(o.surface);
+			total++;
+		}
+		cur = o.next;
+	}
+	if(total > 1) v.normalize();
+	else if(!total) v = surface;
 }
 
 static inline bool findtnormal(const normalgroup &g, const vec &surface, vec &v)
 {
-    float bestangle = lerpthreshold;
-    tnormal *bestnorm = NULL;
-    for(int cur = g.tnormals; cur >= 0;)
-    {
-        tnormal &o = tnormals[cur];
-        static const vec flats[6] = { vec(-1, 0, 0), vec(1, 0, 0), vec(0, -1, 0), vec(0, 1, 0), vec(0, 0, -1), vec(0, 0, 1) };
-        vec n1 = o.normals[0] < 0 ? flats[o.normals[0]+6] : normals[o.normals[0]].surface,
-            n2 = o.normals[1] < 0 ? flats[o.normals[1]+6] : normals[o.normals[1]].surface,
-            nt;
-        nt.lerp(n1, n2, o.offset).normalize();
-        float tangle = nt.dot(surface);
-        if(tangle >= bestangle)
-        {
-            bestangle = tangle;
-            bestnorm = &o;
-        }
-        cur = o.next;
-    }
-    if(!bestnorm) return false;
-    vec n1, n2;
-    findnormal(*bestnorm->groups[0], surface, n1);
-    findnormal(*bestnorm->groups[1], surface, n2);
-    v.lerp(n1, n2, bestnorm->offset).normalize();
-    return true;
+	float bestangle = lerpthreshold;
+	tnormal *bestnorm = NULL;
+	for(int cur = g.tnormals; cur >= 0;)
+	{
+		tnormal &o = tnormals[cur];
+		static const vec flats[6] = { vec(-1, 0, 0), vec(1, 0, 0), vec(0, -1, 0), vec(0, 1, 0), vec(0, 0, -1), vec(0, 0, 1) };
+		vec n1 = o.normals[0] < 0 ? flats[o.normals[0]+6] : normals[o.normals[0]].surface,
+			n2 = o.normals[1] < 0 ? flats[o.normals[1]+6] : normals[o.normals[1]].surface,
+			nt;
+		nt.lerp(n1, n2, o.offset).normalize();
+		float tangle = nt.dot(surface);
+		if(tangle >= bestangle)
+		{
+			bestangle = tangle;
+			bestnorm = &o;
+		}
+		cur = o.next;
+	}
+	if(!bestnorm) return false;
+	vec n1, n2;
+	findnormal(*bestnorm->groups[0], surface, n1);
+	findnormal(*bestnorm->groups[1], surface, n2);
+	v.lerp(n1, n2, bestnorm->offset).normalize();
+	return true;
 }
 
 void findnormal(const vec &key, const vec &surface, vec &v)
 {
-    const normalgroup *g = normalgroups.access(key);
-    if(!g) v = surface;
-    else if(g->tnormals < 0 || !findtnormal(*g, surface, v)) 
-        findnormal(*g, surface, v);
+	const normalgroup *g = normalgroups.access(key);
+	if(!g) v = surface;
+	else if(g->tnormals < 0 || !findtnormal(*g, surface, v))
+		findnormal(*g, surface, v);
 }
 
 VARR(lerpsubdiv, 0, 2, 4);
@@ -130,254 +130,254 @@ static uint progress = 0;
 
 void show_addnormals_progress()
 {
-    float bar1 = float(progress) / float(allocnodes);
-    renderprogress(bar1, "computing normals...");
+	float bar1 = float(progress) / float(allocnodes);
+	renderprogress(bar1, "computing normals...");
 }
 
 void addnormals(cube &c, const ivec &o, int size)
 {
-    CHECK_CALCLIGHT_PROGRESS(return, show_addnormals_progress);
-
-    if(c.children)
-    {
-        progress++;
-        size >>= 1;
-        loopi(8) addnormals(c.children[i], ivec(i, o, size), size);
-        return;
-    }
-    else if(isempty(c)) return;
-
-    vec pos[MAXFACEVERTS];
-    int norms[MAXFACEVERTS];
-    int tj = usetnormals && c.ext ? c.ext->tjoints : -1, vis;
-    loopi(6) if((vis = visibletris(c, i, o, size)))
-    {
-        CHECK_CALCLIGHT_PROGRESS(return, show_addnormals_progress);
-        if(c.texture[i] == DEFAULT_SKY) continue;
-
-        vec planes[2];
-        int numverts = c.ext ? c.ext->surfaces[i].numverts&MAXFACEVERTS : 0, convex = 0, numplanes = 0;
-        if(numverts)
-        {
-            vertinfo *verts = c.ext->verts() + c.ext->surfaces[i].verts;
-            vec vo(ivec(o).mask(~0xFFF));
-            loopj(numverts)
-            {
-                vertinfo &v = verts[j];
-                pos[j] = vec(v.x, v.y, v.z).mul(1.0f/8).add(vo);
-            }
-            if(!(c.merged&(1<<i)) && !flataxisface(c, i)) convex = faceconvexity(verts, numverts, size);
-        }
-        else if(c.merged&(1<<i)) continue;
-        else
-        {
-            ivec v[4];
-            genfaceverts(c, i, v);
-            if(!flataxisface(c, i)) convex = faceconvexity(v);
-            int order = vis&4 || convex < 0 ? 1 : 0;
-            vec vo(o);
-            pos[numverts++] = vec(v[order]).mul(size/8.0f).add(vo);
-            if(vis&1) pos[numverts++] = vec(v[order+1]).mul(size/8.0f).add(vo);
-            pos[numverts++] = vec(v[order+2]).mul(size/8.0f).add(vo);
-            if(vis&2) pos[numverts++] = vec(v[(order+3)&3]).mul(size/8.0f).add(vo);
-        }
-
-        if(!flataxisface(c, i))
-        {
-            planes[numplanes++].cross(pos[0], pos[1], pos[2]).normalize();
-            if(convex) planes[numplanes++].cross(pos[0], pos[2], pos[3]).normalize();
-        }
-
-        if(!numplanes) loopk(numverts) norms[k] = addnormal(pos[k], i);
-        else if(numplanes==1) loopk(numverts) norms[k] = addnormal(pos[k], planes[0]);
-        else 
-        { 
-            vec avg = vec(planes[0]).add(planes[1]).normalize();
-            norms[0] = addnormal(pos[0], avg);
-            norms[1] = addnormal(pos[1], planes[0]);
-            norms[2] = addnormal(pos[2], avg);
-            for(int k = 3; k < numverts; k++) norms[k] = addnormal(pos[k], planes[1]);
-        }
-
-        while(tj >= 0 && tjoints[tj].edge < i*(MAXFACEVERTS+1)) tj = tjoints[tj].next;
-        while(tj >= 0 && tjoints[tj].edge < (i+1)*(MAXFACEVERTS+1))
-        {
-            int edge = tjoints[tj].edge, e1 = edge%(MAXFACEVERTS+1), e2 = (e1+1)%numverts;
-            const vec &v1 = pos[e1], &v2 = pos[e2];
-            ivec d(vec(v2).sub(v1).mul(8));
-            int axis = abs(d.x) > abs(d.y) ? (abs(d.x) > abs(d.z) ? 0 : 2) : (abs(d.y) > abs(d.z) ? 1 : 2);
-            if(d[axis] < 0) d.neg();
-            reduceslope(d);
-            int origin = int(min(v1[axis], v2[axis])*8)&~0x7FFF,
-                offset1 = (int(v1[axis]*8) - origin) / d[axis],
-                offset2 = (int(v2[axis]*8) - origin) / d[axis];
-            vec o = vec(v1).sub(vec(d).mul(offset1/8.0f)), n1, n2;
-            float doffset = 1.0f / (offset2 - offset1);
-
-            while(tj >= 0)
-            {
-                tjoint &t = tjoints[tj];
-                if(t.edge != edge) break;
-                float offset = (t.offset - offset1) * doffset;
-                vec tpos = vec(d).mul(t.offset/8.0f).add(o); 
-                addtnormal(tpos, offset, norms[e1], norms[e2], normalgroups.access(v1), normalgroups.access(v2));
-                tj = t.next;
-            }
-        }
-    }
+	CHECK_CALCLIGHT_PROGRESS(return, show_addnormals_progress);
+
+	if(c.children)
+	{
+		progress++;
+		size >>= 1;
+		loopi(8) addnormals(c.children[i], ivec(i, o, size), size);
+		return;
+	}
+	else if(isempty(c)) return;
+
+	vec pos[MAXFACEVERTS];
+	int norms[MAXFACEVERTS];
+	int tj = usetnormals && c.ext ? c.ext->tjoints : -1, vis;
+	loopi(6) if((vis = visibletris(c, i, o, size)))
+	{
+		CHECK_CALCLIGHT_PROGRESS(return, show_addnormals_progress);
+		if(c.texture[i] == DEFAULT_SKY) continue;
+
+		vec planes[2];
+		int numverts = c.ext ? c.ext->surfaces[i].numverts&MAXFACEVERTS : 0, convex = 0, numplanes = 0;
+		if(numverts)
+		{
+			vertinfo *verts = c.ext->verts() + c.ext->surfaces[i].verts;
+			vec vo(ivec(o).mask(~0xFFF));
+			loopj(numverts)
+			{
+				vertinfo &v = verts[j];
+				pos[j] = vec(v.x, v.y, v.z).mul(1.0f/8).add(vo);
+			}
+			if(!(c.merged&(1<<i)) && !flataxisface(c, i)) convex = faceconvexity(verts, numverts, size);
+		}
+		else if(c.merged&(1<<i)) continue;
+		else
+		{
+			ivec v[4];
+			genfaceverts(c, i, v);
+			if(!flataxisface(c, i)) convex = faceconvexity(v);
+			int order = vis&4 || convex < 0 ? 1 : 0;
+			vec vo(o);
+			pos[numverts++] = vec(v[order]).mul(size/8.0f).add(vo);
+			if(vis&1) pos[numverts++] = vec(v[order+1]).mul(size/8.0f).add(vo);
+			pos[numverts++] = vec(v[order+2]).mul(size/8.0f).add(vo);
+			if(vis&2) pos[numverts++] = vec(v[(order+3)&3]).mul(size/8.0f).add(vo);
+		}
+
+		if(!flataxisface(c, i))
+		{
+			planes[numplanes++].cross(pos[0], pos[1], pos[2]).normalize();
+			if(convex) planes[numplanes++].cross(pos[0], pos[2], pos[3]).normalize();
+		}
+
+		if(!numplanes) loopk(numverts) norms[k] = addnormal(pos[k], i);
+		else if(numplanes==1) loopk(numverts) norms[k] = addnormal(pos[k], planes[0]);
+		else
+		{
+			vec avg = vec(planes[0]).add(planes[1]).normalize();
+			norms[0] = addnormal(pos[0], avg);
+			norms[1] = addnormal(pos[1], planes[0]);
+			norms[2] = addnormal(pos[2], avg);
+			for(int k = 3; k < numverts; k++) norms[k] = addnormal(pos[k], planes[1]);
+		}
+
+		while(tj >= 0 && tjoints[tj].edge < i*(MAXFACEVERTS+1)) tj = tjoints[tj].next;
+		while(tj >= 0 && tjoints[tj].edge < (i+1)*(MAXFACEVERTS+1))
+		{
+			int edge = tjoints[tj].edge, e1 = edge%(MAXFACEVERTS+1), e2 = (e1+1)%numverts;
+			const vec &v1 = pos[e1], &v2 = pos[e2];
+			ivec d(vec(v2).sub(v1).mul(8));
+			int axis = abs(d.x) > abs(d.y) ? (abs(d.x) > abs(d.z) ? 0 : 2) : (abs(d.y) > abs(d.z) ? 1 : 2);
+			if(d[axis] < 0) d.neg();
+			reduceslope(d);
+			int origin = int(min(v1[axis], v2[axis])*8)&~0x7FFF,
+				offset1 = (int(v1[axis]*8) - origin) / d[axis],
+				offset2 = (int(v2[axis]*8) - origin) / d[axis];
+			vec o = vec(v1).sub(vec(d).mul(offset1/8.0f)), n1, n2;
+			float doffset = 1.0f / (offset2 - offset1);
+
+			while(tj >= 0)
+			{
+				tjoint &t = tjoints[tj];
+				if(t.edge != edge) break;
+				float offset = (t.offset - offset1) * doffset;
+				vec tpos = vec(d).mul(t.offset/8.0f).add(o);
+				addtnormal(tpos, offset, norms[e1], norms[e2], normalgroups.access(v1), normalgroups.access(v2));
+				tj = t.next;
+			}
+		}
+	}
 }
 
 void calcnormals(bool lerptjoints)
 {
-    if(!lerpangle) return;
-    usetnormals = lerptjoints; 
-    if(usetnormals) findtjoints();
-    lerpthreshold = cos(lerpangle*RAD) - 1e-5f; 
-    progress = 1;
-    loopi(8) addnormals(worldroot[i], ivec(i, ivec(0, 0, 0), worldsize/2), worldsize/2);
+	if(!lerpangle) return;
+	usetnormals = lerptjoints;
+	if(usetnormals) findtjoints();
+	lerpthreshold = cos(lerpangle*RAD) - 1e-5f;
+	progress = 1;
+	loopi(8) addnormals(worldroot[i], ivec(i, ivec(0, 0, 0), worldsize/2), worldsize/2);
 }
 
 void clearnormals()
 {
-    normalgroups.clear();
-    normals.setsize(0);
-    tnormals.setsize(0);
+	normalgroups.clear();
+	normals.setsize(0);
+	tnormals.setsize(0);
 }
 
 void calclerpverts(const vec2 *c, const vec *n, lerpvert *lv, int &numv)
 {
-    int i = 0;
-    loopj(numv)
-    {
-        if(j)
-        {
-            if(c[j] == c[j-1] && n[j] == n[j-1]) continue;
-            if(j == numv-1 && c[j] == c[0] && n[j] == n[0]) continue;
-        }
-        lv[i].normal = n[j];
-        lv[i].tc = c[j];
-        i++;
-    }
-    numv = i;
+	int i = 0;
+	loopj(numv)
+	{
+		if(j)
+		{
+			if(c[j] == c[j-1] && n[j] == n[j-1]) continue;
+			if(j == numv-1 && c[j] == c[0] && n[j] == n[0]) continue;
+		}
+		lv[i].normal = n[j];
+		lv[i].tc = c[j];
+		i++;
+	}
+	numv = i;
 }
 
 void setlerpstep(float v, lerpbounds &bounds)
 {
-    if(bounds.min->tc.y + 1 > bounds.max->tc.y)
-    {
-        bounds.nstep = vec(0, 0, 0);
-        bounds.normal = bounds.min->normal;
-        if(bounds.min->normal != bounds.max->normal)
-        {
-            bounds.normal.add(bounds.max->normal);
-            bounds.normal.normalize();
-        }
-        bounds.ustep = 0;
-        bounds.u = bounds.min->tc.x;
-        return;
-    }
-
-    bounds.nstep = bounds.max->normal;
-    bounds.nstep.sub(bounds.min->normal);
-    bounds.nstep.div(bounds.max->tc.y-bounds.min->tc.y);
-
-    bounds.normal = bounds.nstep;
-    bounds.normal.mul(v - bounds.min->tc.y);
-    bounds.normal.add(bounds.min->normal);
-
-    bounds.ustep = (bounds.max->tc.x-bounds.min->tc.x) / (bounds.max->tc.y-bounds.min->tc.y);
-    bounds.u = bounds.ustep * (v-bounds.min->tc.y) + bounds.min->tc.x;
+	if(bounds.min->tc.y + 1 > bounds.max->tc.y)
+	{
+		bounds.nstep = vec(0, 0, 0);
+		bounds.normal = bounds.min->normal;
+		if(bounds.min->normal != bounds.max->normal)
+		{
+			bounds.normal.add(bounds.max->normal);
+			bounds.normal.normalize();
+		}
+		bounds.ustep = 0;
+		bounds.u = bounds.min->tc.x;
+		return;
+	}
+
+	bounds.nstep = bounds.max->normal;
+	bounds.nstep.sub(bounds.min->normal);
+	bounds.nstep.div(bounds.max->tc.y-bounds.min->tc.y);
+
+	bounds.normal = bounds.nstep;
+	bounds.normal.mul(v - bounds.min->tc.y);
+	bounds.normal.add(bounds.min->normal);
+
+	bounds.ustep = (bounds.max->tc.x-bounds.min->tc.x) / (bounds.max->tc.y-bounds.min->tc.y);
+	bounds.u = bounds.ustep * (v-bounds.min->tc.y) + bounds.min->tc.x;
 }
 
 void initlerpbounds(float u, float v, const lerpvert *lv, int numv, lerpbounds &start, lerpbounds &end)
 {
-    const lerpvert *first = &lv[0], *second = NULL;
-    loopi(numv-1)
-    {
-        if(lv[i+1].tc.y < first->tc.y) { second = first; first = &lv[i+1]; }
-        else if(!second || lv[i+1].tc.y < second->tc.y) second = &lv[i+1];
-    }
-
-    if(int(first->tc.y) < int(second->tc.y)) { start.min = end.min = first; }
-    else if(first->tc.x > second->tc.x) { start.min = second; end.min = first; }
-    else { start.min = first; end.min = second; }
-
-    if((lv[1].tc.x - lv->tc.x)*(lv[2].tc.y - lv->tc.y) > (lv[1].tc.y - lv->tc.y)*(lv[2].tc.x - lv->tc.x))
-    { 
-        start.winding = end.winding = 1;
-        start.max = (start.min == lv ? &lv[numv-1] : start.min-1);
-        end.max = (end.min == &lv[numv-1] ? lv : end.min+1);
-    }
-    else
-    {
-        start.winding = end.winding = -1;
-        start.max = (start.min == &lv[numv-1] ? lv : start.min+1);
-        end.max = (end.min == lv ? &lv[numv-1] : end.min-1);
-    }
-
-    setlerpstep(v, start);
-    setlerpstep(v, end);
+	const lerpvert *first = &lv[0], *second = NULL;
+	loopi(numv-1)
+	{
+		if(lv[i+1].tc.y < first->tc.y) { second = first; first = &lv[i+1]; }
+		else if(!second || lv[i+1].tc.y < second->tc.y) second = &lv[i+1];
+	}
+
+	if(int(first->tc.y) < int(second->tc.y)) { start.min = end.min = first; }
+	else if(first->tc.x > second->tc.x) { start.min = second; end.min = first; }
+	else { start.min = first; end.min = second; }
+
+	if((lv[1].tc.x - lv->tc.x)*(lv[2].tc.y - lv->tc.y) > (lv[1].tc.y - lv->tc.y)*(lv[2].tc.x - lv->tc.x))
+	{
+		start.winding = end.winding = 1;
+		start.max = (start.min == lv ? &lv[numv-1] : start.min-1);
+		end.max = (end.min == &lv[numv-1] ? lv : end.min+1);
+	}
+	else
+	{
+		start.winding = end.winding = -1;
+		start.max = (start.min == &lv[numv-1] ? lv : start.min+1);
+		end.max = (end.min == lv ? &lv[numv-1] : end.min-1);
+	}
+
+	setlerpstep(v, start);
+	setlerpstep(v, end);
 }
 
 void updatelerpbounds(float v, const lerpvert *lv, int numv, lerpbounds &start, lerpbounds &end)
 {
-    if(v >= start.max->tc.y)
-    {
-        const lerpvert *next = start.winding > 0 ?
-                (start.max == lv ? &lv[numv-1] : start.max-1) :
-                (start.max == &lv[numv-1] ? lv : start.max+1);
-        if(next->tc.y > start.max->tc.y)
-        {
-            start.min = start.max;
-            start.max = next;
-            setlerpstep(v, start);
-        }
-    }
-    if(v >= end.max->tc.y)
-    {
-        const lerpvert *next = end.winding > 0 ?
-                (end.max == &lv[numv-1] ? lv : end.max+1) :
-                (end.max == lv ? &lv[numv-1] : end.max-1);
-        if(next->tc.y > end.max->tc.y)
-        {
-            end.min = end.max;
-            end.max = next;
-            setlerpstep(v, end);
-        }
-    }
+	if(v >= start.max->tc.y)
+	{
+		const lerpvert *next = start.winding > 0 ?
+				(start.max == lv ? &lv[numv-1] : start.max-1) :
+				(start.max == &lv[numv-1] ? lv : start.max+1);
+		if(next->tc.y > start.max->tc.y)
+		{
+			start.min = start.max;
+			start.max = next;
+			setlerpstep(v, start);
+		}
+	}
+	if(v >= end.max->tc.y)
+	{
+		const lerpvert *next = end.winding > 0 ?
+				(end.max == &lv[numv-1] ? lv : end.max+1) :
+				(end.max == lv ? &lv[numv-1] : end.max-1);
+		if(next->tc.y > end.max->tc.y)
+		{
+			end.min = end.max;
+			end.max = next;
+			setlerpstep(v, end);
+		}
+	}
 }
 
 void lerpnormal(float u, float v, const lerpvert *lv, int numv, lerpbounds &start, lerpbounds &end, vec &normal, vec &nstep)
-{   
-    updatelerpbounds(v, lv, numv, start, end);
-
-    if(start.u + 1 > end.u)
-    {
-        nstep = vec(0, 0, 0);
-        normal = start.normal;
-        normal.add(end.normal);
-        normal.normalize();
-    }
-    else
-    {
-        vec nstart(start.normal), nend(end.normal);
-        nstart.normalize();
-        nend.normalize();
-       
-        nstep = nend;
-        nstep.sub(nstart);
-        nstep.div(end.u-start.u);
-
-        normal = nstep;
-        normal.mul(u-start.u);
-        normal.add(nstart);
-        normal.normalize();
-    }
-     
-    start.normal.add(start.nstep);
-    start.u += start.ustep;
-
-    end.normal.add(end.nstep); 
-    end.u += end.ustep;
+{
+	updatelerpbounds(v, lv, numv, start, end);
+
+	if(start.u + 1 > end.u)
+	{
+		nstep = vec(0, 0, 0);
+		normal = start.normal;
+		normal.add(end.normal);
+		normal.normalize();
+	}
+	else
+	{
+		vec nstart(start.normal), nend(end.normal);
+		nstart.normalize();
+		nend.normalize();
+
+		nstep = nend;
+		nstep.sub(nstart);
+		nstep.div(end.u-start.u);
+
+		normal = nstep;
+		normal.mul(u-start.u);
+		normal.add(nstart);
+		normal.normalize();
+	}
+
+	start.normal.add(start.nstep);
+	start.u += start.ustep;
+
+	end.normal.add(end.nstep);
+	end.u += end.ustep;
 }