/*
 Copyright (c) 2013 yvt
 
 This file is part of OpenSpades.
 
 OpenSpades is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 OpenSpades is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.
 
 */

#include "GLOptimizedVoxelModel.h"
#include "GLRenderer.h"
#include "GLImage.h"
#include "GLProgram.h"
#include "GLProgramAttribute.h"
#include "GLProgramUniform.h"
#include "../Core/Debug.h"
#include "GLShadowShader.h"
#include "GLDynamicLightShader.h"
#include "IGLShadowMapRenderer.h"
#include "GLShadowMapShader.h"
#include "../poly2tri/poly2tri.h"
#include "../Core/Exception.h"
#include <set>
#include "../Core/Bitmap.h"
#include "../Core/BitmapAtlasGenerator.h"

namespace spades {
	namespace draw {
		void GLOptimizedVoxelModel::PreloadShaders(spades::draw::GLRenderer *renderer) {
			renderer->RegisterProgram("Shaders/OptimizedVoxelModel.program");
			renderer->RegisterProgram("Shaders/OptimizedVoxelModelDynamicLit.program");
			renderer->RegisterProgram("Shaders/OptimizedVoxelModelShadowMap.program");
			renderer->RegisterImage("Gfx/AmbientOcclusion.tga");
		}
		GLOptimizedVoxelModel::GLOptimizedVoxelModel(VoxelModel *m,
								   GLRenderer *r){
			SPADES_MARK_FUNCTION();
			
			renderer = r;
			device = r->GetGLDevice();
			
			BuildVertices(m);
			GenerateTexture();
			
			program = renderer->RegisterProgram("Shaders/OptimizedVoxelModel.program");
			dlightProgram = renderer->RegisterProgram("Shaders/OptimizedVoxelModelDynamicLit.program");
			shadowMapProgram = renderer->RegisterProgram("Shaders/OptimizedVoxelModelShadowMap.program");
			aoImage = (GLImage *)renderer->RegisterImage("Gfx/AmbientOcclusion.tga");
			
			
			buffer = device->GenBuffer();
			device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
			device->BufferData(IGLDevice::ArrayBuffer,
							   vertices.size() * sizeof(Vertex),
							   vertices.data(), IGLDevice::StaticDraw);
			
			idxBuffer = device->GenBuffer();
			device->BindBuffer(IGLDevice::ArrayBuffer, idxBuffer);
			device->BufferData(IGLDevice::ArrayBuffer,
							   indices.size() * sizeof(uint32_t),
							   indices.data(), IGLDevice::StaticDraw);
			device->BindBuffer(IGLDevice::ArrayBuffer, 0);
			
			origin = m->GetOrigin();
			origin -= .5f; // (0,0,0) is center of voxel (0,0,0)
			
			Vector3 minPos = {0, 0, 0};
			Vector3 maxPos = {
				(float)m->GetWidth(), (float)m->GetHeight(), (float)m->GetDepth()
			};
			minPos += origin; maxPos += origin;
			Vector3 maxDiff = {
				std::max(fabsf(minPos.x), fabsf(maxPos.x)),
				std::max(fabsf(minPos.y), fabsf(maxPos.y)),
				std::max(fabsf(minPos.z), fabsf(maxPos.z))
			};
			radius = maxDiff.GetLength();
			
			boundingBox.min = minPos;
			boundingBox.max = maxPos;
			
			// clean up
			numIndices = (unsigned int)indices.size();
			std::vector<Vertex>().swap(vertices);
			std::vector<uint32_t>().swap(indices);
		}
		GLOptimizedVoxelModel::~GLOptimizedVoxelModel() {
			SPADES_MARK_FUNCTION();
			
			image->Release();
			device->DeleteBuffer(idxBuffer);
			device->DeleteBuffer(buffer);
		}
		
		void GLOptimizedVoxelModel::GenerateTexture() {
			BitmapAtlasGenerator atlasGen;
			std::map<Bitmap *, int> idx;
			std::vector<IntVector3> poss;
			for(size_t i = 0; i < bmps.size(); i++){
				idx[bmps[i]] = i;
				atlasGen.AddBitmap(bmps[i]);
			}
			
			BitmapAtlasGenerator::Result result = atlasGen.Pack();
			Handle<Bitmap> bmp(result.bitmap, false);
			SPAssert(result.items.size() == bmps.size());
			for(size_t i = 0; i < bmps.size(); i++){
				bmps[i]->Release();
			}
			bmps.clear();
			
			poss.resize(result.items.size());
			for(size_t i = 0; i < result.items.size(); i++){
				const BitmapAtlasGenerator::Item& item = result.items[i];
				int id = idx[item.bitmap];
				poss[id] = IntVector3::Make(item.x, item.y, 0);
			}
			
			// move vertices' texture coord
			SPAssert(bmpIndex.size() == vertices.size());
			for(size_t i = 0; i < bmpIndex.size(); i++){
				int id = (int)bmpIndex[i];
				Vertex& v = vertices[i];
				IntVector3 p = poss[id];
				v.u += p.x;
				v.v += p.y;
			}
			
			std::vector<uint16_t>().swap(bmpIndex);
			
			image = static_cast<GLImage *>(renderer->CreateImage(bmp));
		}
		
		uint8_t GLOptimizedVoxelModel::calcAOID(VoxelModel *m,
									   int x, int y, int z,
									   int ux, int uy, int uz,
									   int vx, int vy, int vz){
			int v = 0;
			if(m->IsSolid(x - ux, y - uy, z - uz))
				v |= 1;
			if(m->IsSolid(x + ux, y + uy, z + uz))
				v |= 1 << 1;
			if(m->IsSolid(x - vx, y - vy, z - vz))
				v |= 1 << 2;
			if(m->IsSolid(x + vx, y + vy, z + vz))
				v |= 1 << 3;
			if(m->IsSolid(x - ux + vx, y - uy + vy, z - uz + vz))
				v |= 1 << 4;
			if(m->IsSolid(x - ux - vx, y - uy - vy, z - uz - vz))
				v |= 1 << 5;
			if(m->IsSolid(x + ux + vx, y + uy + vy, z + uz + vz))
				v |= 1 << 6;
			if(m->IsSolid(x + ux - vx, y + uy - vy, z + uz - vz))
				v |= 1 << 7;
			return (uint8_t)v;
		}
		
		template <class C> static void FreeClear( C & cntr ) {
			for ( typename C::iterator it = cntr.begin();
				 it != cntr.end(); ++it ) {
				delete * it;
			}
			cntr.clear();
		}
		
		class GLOptimizedVoxelModel::SliceGenerator {
			
		public:
			//0 - air
			//1 - unprocessed solid
			//2 - "inside" the processed area, but not connected
			//3 - found holes
			uint8_t *slice;
			int usize, vsize;
			int minU, maxU, minV, maxV;
			
			struct Point {
				int x;
				int y;
				int sx, sy;
				Point(){}
				Point(int x, int y):x(x),y(y){}
				Point(int x, int y, int sx, int sy):x(x),y(y),sx(x),sy(y){}
			};
			
			// poly2tri point pool
			std::vector<p2t::Point> gPoints;
			typedef p2t::Point *PointIndex;
			
			
			uint8_t& Slice(int u, int v){
				SPAssert(u >= 0); SPAssert(v >= 0);
				SPAssert(u < usize); SPAssert(v < vsize);
				return slice[u * vsize + v];
			}
			uint8_t GetSlice(int u, int v){
				if(u < 0 || v < 0 || u >= usize || v >= vsize)
					return 0;
				return Slice(u, v);
			}
			
			PointIndex EmitPoint(int x, int y){
				gPoints.push_back(p2t::Point(x, y));
				return (PointIndex)(gPoints.size() - 1);
			}
			
			PointIndex EmitPoint(const Point& p){
				// exact coordinate causes error on p2t library...
				gPoints.push_back(p2t::Point(p.x + p.sx * 0.001 + (GetRandom() - GetRandom()) * 0.0005,
											 p.y + p.sy * 0.001 + (GetRandom() - GetRandom()) * 0.0005));
				return (PointIndex)(gPoints.size() - 1);
			}
			
			void ResolvePoints(std::vector<PointIndex>& points){
				SPADES_MARK_FUNCTION_DEBUG();
				for(size_t i = 0; i < points.size(); i++){
					points[i] = &(gPoints[(size_t)points[i]]);
				}
			}
			
			class PolygonFillIterator {
				int top, height;
				struct Span {
					std::set<int> xs;
				};
				Span *spans;
				int curX, curY;
				std::set<int>::iterator nextIt;
			public:
				PolygonFillIterator(const std::vector<Point>& points) {
					SPADES_MARK_FUNCTION_DEBUG();
					int minY = -1, maxY = -1;
					for(size_t i = 0; i < points.size(); i++){
						const Point& p = points[i];
						if(minY == -1 || p.y < minY) minY = p.y;
						if(maxY == -1 || p.y > maxY) maxY = p.y;
					}
					top = minY;
					height = maxY - minY;
					if(height == 0){
						spans = NULL;
					}else{
						spans = new Span[height];
						Point last = points[points.size() - 1];
						for(size_t i = 0; i < points.size(); i++){
							Point p = points[i];
							if(p.y != last.y){
								SPAssert(p.x == last.x);
								minY = std::min(p.y, last.y);
								maxY = std::max(p.y, last.y);
								for(int y = minY; y < maxY; y++){
									SPAssert(spans[y-top].xs.find(p.x) ==
											 spans[y-top].xs.end());
									SPAssert(y - top < height);
									spans[y - top].xs.insert(p.x);
								}
							}
							last = p;
						}
					}
					curY = -1;
				}
				~PolygonFillIterator() {
					if(spans)
						delete[] spans;
				}
				
				bool Next(Point& outPoint) {
					if(curY >= height)
						return false;
					SPADES_MARK_FUNCTION_DEBUG();
					
					// check current span
					if(curY != -1){
						Span& span = spans[curY];
						if(nextIt != span.xs.end()){
							// emit
							outPoint.x = curX;
							outPoint.y = curY + top;
							curX++;
							SPAssert(curX <= *nextIt);
							if(curX == *nextIt){
								nextIt++;
								// move to next solid
								if(nextIt == span.xs.end()){
									// span end
								}else{
									// next solid
									curX = *nextIt;
									nextIt++;
									SPAssert(nextIt != span.xs.end());
								}
							}
							return true;
						}
					}
					
					// move to next span
					curY++;
					while(curY < height){
						if(!spans[curY].xs.empty()){
							break;
						}
						curY++;
					}
					
					if(curY >= height){
						return false;
					}
					
					Span& span = spans[curY];
					SPAssert(!span.xs.empty());
					nextIt = span.xs.begin();
					outPoint.x = *nextIt;
					outPoint.y = curY + top;
					
					curX = outPoint.x + 1;
					nextIt++;
					SPAssert(curX <= *nextIt);
					if(curX == *nextIt){
						nextIt++;
						// move to next solid
						if(nextIt == span.xs.end()){
							// span end
						}else{
							// next solid
							curX = *nextIt;
							nextIt++;
							SPAssert(nextIt != span.xs.end());
						}
					}
					
					return true;
				}
			};
			
			// given a top-side point, makes path
			std::vector<Point> MakePolyline(int su, int sv, uint8_t inner) {
				std::vector<Point> poly;
				SPADES_MARK_FUNCTION_DEBUG();
				SPAssert(GetSlice(su, sv) == inner);
				SPAssert(GetSlice(su, sv - 1) != inner);
				
				// go as backward as possible
				while(GetSlice(su, sv) == inner){
					su--;
				}
				su++;
				
				// we support only the case (su, sv) is a corner
				SPAssert(GetSlice(su, sv - 1) != inner);
				
				int u = su, v = sv;
				int du = 1, dv = 0;
				bool corner = true;
				bool first = true;
				// coord. system: u = right, v = down
				if(u == 3 && v == 3){
					first = true;
				}
				
				while(u != su || v != sv || du != 1 || dv != 0 || first) {
					int outU, outV; // vector to outside (polygon normal)
					if(dv == 0) { outU = 0; outV = -du; }
					else { outU = dv; outV = 0; }
					
					SPAssert(GetSlice(u, v) == inner);
					SPAssert(GetSlice(u + outU, v + outV) != inner);
					
					if(corner){
						if(du == 1)
							poly.push_back(Point(u, v,1,1));
						else if(du == -1)
							poly.push_back(Point(u+1, v+1, -1,-1));
						else if(dv == 1)
							poly.push_back(Point(u+1, v, -1,1));
						else if(dv == -1)
							poly.push_back(Point(u, v+1, 1,-1));
						else
							SPAssert(false);
						corner = false;
					}
					
					// go forward
					u += du; v += dv;
					
					if(GetSlice(u, v) != inner){
						// go back, and turn right
						u -= du; v -= dv;
						int odu = du, odv = dv;
						du = -odv; dv = odu;
						corner = true;
					}else if(GetSlice(u + outU, v + outV) == inner){
						// turn left, and go forward
						int odu = du, odv = dv;
						du = odv; dv = -odu;
						u += du; v += dv;
						corner = true;
					}
				
					first = false;
				}
				
				SPAssert(corner);
				SPAssert(!first);
				SPAssert(poly.size() >= 4);
				
				return poly;
			}
			
			/** start scanning area from (su, sv) */
			p2t::CDT *ProcessArea(int su, int sv) {
				SPADES_MARK_FUNCTION_DEBUG();
				gPoints.clear();
				
				std::vector<Point> exteria;
				std::vector<std::vector<Point> > holes;
				exteria = MakePolyline(su, sv, 1);
				
				{
					// find holes
					PolygonFillIterator filler(exteria);
					Point pt;
					while(filler.Next(pt)){
						int type = GetSlice(pt.x, pt.y);
						if(type == 0){
							// hole
							std::vector<Point> hole;
							hole = MakePolyline(pt.x, pt.y, 0);
							holes.push_back(hole);
							
							// exclude areas inside the hole
							PolygonFillIterator filler2(hole);
							while(filler2.Next(pt)){
								type = GetSlice(pt.x, pt.y);
								if(type == 1){
									Slice(pt.x, pt.y) = 2;
								}else if(type == 0){
									Slice(pt.x, pt.y) = 3;
								}else{
									SPAssert(false);
								}
							}
						}
					}
				}
				
				{
					// remove this area
					PolygonFillIterator filler(exteria);
					Point pt;
					while(filler.Next(pt)){
						int type = GetSlice(pt.x, pt.y);
						if(type == 0){
							SPAssert(false);
						}else if(type == 1){ // this area
							Slice(pt.x, pt.y) = 0;
						}else if(type == 2){ // not this area, but inside
							Slice(pt.x, pt.y) = 1;
						}else if(type == 3){ // hole of this area
							Slice(pt.x, pt.y) = 0;
						}else{
							SPAssert(false);
						}
					}
				}
				
				std::vector<std::vector<PointIndex> > pts2;
				p2t::CDT *cdt;
				{
					std::vector<PointIndex> poly;
					for(size_t i = 0; i < exteria.size(); i++){
						Point pt = exteria[i];
						poly.push_back(EmitPoint(pt));
					}
					pts2.push_back(poly);
				}
				for(size_t j = 0; j < holes.size(); j++){
					std::vector<PointIndex> poly;
					const std::vector<Point>& ipoly = holes[j];
					for(size_t i = 0; i < ipoly.size(); i++){
						Point pt = ipoly[i];
						poly.push_back(EmitPoint(pt));
					}
					pts2.push_back(poly);
				}
				
				for(size_t i = 0; i < pts2.size(); i++){
					ResolvePoints(pts2[i]);
				}
				
				cdt = new p2t::CDT(pts2[0]);
				
				for(size_t i = 1; i < pts2.size(); i++)
					cdt->AddHole(pts2[i]);
				
				cdt->Triangulate();
				
				return cdt;
			}
			
		};
		
		static IntVector3 ExactPoint(const p2t::Point *pt){
			return IntVector3::Make(lround(pt->x), lround(pt->y),0);
		}
		
		static int64_t DoubledTriangleArea(IntVector3 v1, IntVector3 v2, IntVector3 v3) {
			int64_t x1 = v1.x, y1 = v1.y;
			int64_t x2 = v2.x, y2 = v2.y;
			int64_t x3 = v3.x, y3 = v3.y;
			return (x1 - x3) * (y2 - y1) -
			(x1 - x2) * (y3 - y1);
		}
		
		void GLOptimizedVoxelModel::EmitSlice(uint8_t *slice,
											  int usize, int vsize,
											  int sx, int sy, int sz,
											  int ux, int uy, int uz,
											  int vx, int vy, int vz,
											  int mx, int my, int mz,
											  bool flip,
											  VoxelModel *model) {
			SPADES_MARK_FUNCTION();
			int minU = -1, minV = -1, maxU = -1, maxV = -1;
			
			for(int u = 0; u < usize; u++){
				for(int v = 0; v < vsize; v++){
					if(slice[u * vsize + v]){
						if(minU == -1 || u < minU) minU = u;
						if(maxU == -1 || u > maxU) maxU = u;
						if(minV == -1 || v < minV) minV = v;
						if(maxV == -1 || v > maxV) maxV = v;
					}
				}
			}
			
			if(minU == -1){
				// no face
				return;
			}
			
			int nx, ny, nz;
			nx = uy * vz - uz * vy;
			ny = uz * vx - ux * vz;
			nz = ux * vy - uy * vx;
			if(!flip){
				nx = -nx;
				ny = -ny;
				nz = -nz;
			}
			
			SliceGenerator generator;
			generator.slice = slice;
			generator.usize = usize;
			generator.vsize = vsize;
			generator.minU = minU;
			generator.maxU = maxU;
			generator.minV = minV;
			generator.maxV = maxV;
			
			int tu = minU - 1, tv = minV - 1;
			int bw = (maxU - minU) + 3, bh = (maxV - minV) + 3;
			int bId = bmps.size();
			Bitmap *bmp = new Bitmap(bw, bh);
			bmps.push_back(bmp);
			{
				uint32_t *pixels = bmp->GetPixels();
				IntVector3 p1 = {mx, my, mz};
				
				IntVector3 uu = {ux, uy, uz};
				IntVector3 vv = {vx, vy, vz};
				IntVector3 nn = {nx, ny, nz};
				
				p1 += uu * tu; p1 += vv * tv;
				
				for(int y = 0; y < bh; y++){
					IntVector3 p2 = p1;
					for(int x = 0; x < bw; x++){
						IntVector3 p3 = p2;
						int u = x + tu, v = y + tv;
						if(u < 0 || v < 0 || u >= usize || v >= vsize ||
						   !slice[u*vsize+v]){
							if((v >= 0 && v < vsize) && u > 0 && slice[(u-1)*vsize+(v)]){
								u--;
								p3 -= uu;
							}else if((v >= 0 && v < vsize) && u < usize-1 && slice[(u+1)*vsize+(v)]){
								u++;
								p3 += uu;
							}else if((u >= 0 && u < usize) && v > 0 && slice[(u)*vsize+(v-1)]){
								v--;
								p3 -= vv;
							}else if((u >= 0 && u < usize) && v < vsize-1 && slice[(u)*vsize+(v+1)]){
								v++;
								p3 += vv;
							}else if(u > 0 && v > 0 && slice[(u-1)*vsize+(v-1)]){
								u--; v--;
								p3 -= uu; p3 -= vv;
							}else if(u > 0 && v < vsize-1 && slice[(u-1)*vsize+(v+1)]){
								u--; v++;
								p3 -= uu; p3 += vv;
							}else if(u < usize-1 && v > 0 && slice[(u+1)*vsize+(v-1)]){
								u++; v--;
								p3 += uu; p3 -= vv;
							}else if(u < usize-1 && v < vsize-1 && slice[(u+1)*vsize+(v+1)]){
								u++; v++;
								p3 += uu; p3 += vv;
							}else{
								*(pixels++) = 0x00ff00ff;
								p2 += uu;
								continue;
							}
						}
						
						SPAssert(model->IsSolid(p3.x, p3.y, p3.z));
						uint32_t col = model->GetColor(p3.x, p3.y, p3.z);
						
						col &= 0xffffff;
						
						// add AOID
						p3 += nn;
						SPAssert(!model->IsSolid(p3.x, p3.y, p3.z));
						uint8_t aoId = calcAOID(model,
												p3.x, p3.y, p3.z,
												ux, uy, uz,
												vx, vy, vz);
						col |= ((uint8_t)aoId) << 24;
						
						*(pixels++) = col;
						
						p2 += uu;
					}
					
					p1 += vv;
				}
			}
			
			// TODO: optimize scan range
			for(int v = 0; v < vsize; v++){
				for(int u = 0; u < usize; u++){
					if(slice[u * vsize + v]){
						p2t::CDT *cdt = generator.ProcessArea(u, v);
						std::vector<p2t::Triangle *> triangles = cdt->GetTriangles();
						
						for(size_t i = 0; i < triangles.size(); i++){
							p2t::Triangle& tri = *triangles[i];
							uint32_t idx = (uint32_t)vertices.size();
							IntVector3 pt1 = ExactPoint(tri.GetPoint(0));
							IntVector3 pt2 = ExactPoint(tri.GetPoint(1));
							IntVector3 pt3 = ExactPoint(tri.GetPoint(2));
							
							// degenerate triangle
							if(DoubledTriangleArea(pt1, pt2, pt3) == 0)
								continue;
							
							Vertex vtx;
							vtx.nx = nx; vtx.ny = ny; vtx.nz = nz;
							
							vtx.x = sx + (int)pt1.x * ux + (int)pt1.y * vx;
							vtx.y = sy + (int)pt1.x * uy + (int)pt1.y * vy;
							vtx.z = sz + (int)pt1.x * uz + (int)pt1.y * vz;
							vtx.u = (int)pt1.x - tu;
							vtx.v = (int)pt1.y - tv;
							vertices.push_back(vtx);
							
							vtx.x = sx + (int)pt2.x * ux + (int)pt2.y * vx;
							vtx.y = sy + (int)pt2.x * uy + (int)pt2.y * vy;
							vtx.z = sz + (int)pt2.x * uz + (int)pt2.y * vz;
							vtx.u = (int)pt2.x - tu;
							vtx.v = (int)pt2.y - tv;
							vertices.push_back(vtx);
							
							vtx.x = sx + (int)pt3.x * ux + (int)pt3.y * vx;
							vtx.y = sy + (int)pt3.x * uy + (int)pt3.y * vy;
							vtx.z = sz + (int)pt3.x * uz + (int)pt3.y * vz;
							vtx.u = (int)pt3.x - tu;
							vtx.v = (int)pt3.y - tv;
							vertices.push_back(vtx);
							
							if(flip){
								indices.push_back(idx+2);
								indices.push_back(idx+1);
								indices.push_back(idx);
								
							}else{
								indices.push_back(idx);
								indices.push_back(idx+1);
								indices.push_back(idx+2);
							}
							bmpIndex.push_back(bId);
							bmpIndex.push_back(bId);
							bmpIndex.push_back(bId);
						}
						
						delete cdt;
					}
				}
			}
			
		}
		
		void GLOptimizedVoxelModel::BuildVertices(spades::VoxelModel *model) {
			SPADES_MARK_FUNCTION();
			
			SPAssert(vertices.empty());
			SPAssert(indices.empty());
			
			int w = model->GetWidth();
			int h = model->GetHeight();
			int d = model->GetDepth();
			
			std::vector<uint8_t> slice;
			
			// x-slice
			slice.resize(h * d);
			std::fill(slice.begin(), slice.end(), 0);
			for(int x = 0; x < w; x++){
				for(int y = 0; y < h; y++){
					for(int z = 0; z < d; z++){
						uint8_t& s = slice[y * d + z];
						if(x == 0)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x - 1, y, z))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), h, d,
						  x, 0, 0,
						  0, 1, 0,
						  0, 0, 1,
						  x, 0, 0,
						  false,
						  model);
				
				for(int y = 0; y < h; y++){
					for(int z = 0; z < d; z++){
						uint8_t& s = slice[y * d + z];
						if(x == w - 1)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x + 1, y, z))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), h, d,
						  x + 1, 0, 0,
						  0, 1, 0,
						  0, 0, 1,
						  x, 0, 0,
						  true,
						  model);
			}
			
			// y-slice
			slice.resize(w * d);
			std::fill(slice.begin(), slice.end(), 0);
			for(int y = 0; y < h; y++){
				for(int x = 0; x < w; x++){
					for(int z = 0; z < d; z++){
						uint8_t& s = slice[x * d + z];
						if(y == 0)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x, y - 1, z))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), w, d,
						  0, y, 0,
						  1, 0, 0,
						  0, 0, 1,
						  0, y, 0,
						  true,
						  model);
				
				for(int x = 0; x < w; x++){
					for(int z = 0; z < d; z++){
						uint8_t& s = slice[x * d + z];
						if(y == h - 1)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x, y + 1, z))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), w, d,
						  0, y + 1, 0,
						  1, 0, 0,
						  0, 0, 1,
						  0, y, 0,
						  false,
						  model);
			}
			
			// z-slice
			slice.resize(w * h);
			std::fill(slice.begin(), slice.end(), 0);
			for(int z = 0; z < d; z++){
				for(int x = 0; x < w; x++){
					for(int y = 0; y < h; y++){
						uint8_t& s = slice[x * h + y];
						if(z == 0)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x, y, z - 1))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), w, h,
						  0, 0, z,
						  1, 0, 0,
						  0, 1, 0,
						  0, 0, z,
						  false,
						  model);
				
				for(int x = 0; x < w; x++){
					for(int y = 0; y < h; y++){
						uint8_t& s = slice[x * h + y];
						if(z == d - 1)
							s = model->IsSolid(x, y, z) ? 1 : 0;
						else
							s = (model->IsSolid(x, y, z) &&
								 !model->IsSolid(x, y, z + 1))
							? 1 : 0;
					}
				}
				EmitSlice(slice.data(), w, h,
						  0, 0, z + 1,
						  1, 0, 0,
						  0, 1, 0,
						  0, 0, z,
						  true,
						  model);
			}
			
			printf("%d vertices emit\n", (int)indices.size());
		}
		
		void GLOptimizedVoxelModel::RenderShadowMapPass(std::vector<client::ModelRenderParam> params) {
			SPADES_MARK_FUNCTION();
			
			device->Enable(IGLDevice::CullFace, true);
			device->Enable(IGLDevice::DepthTest, true);
			
			shadowMapProgram->Use();
			
			static GLShadowMapShader shadowMapShader;
			shadowMapShader(renderer, shadowMapProgram, 0);
			
			static GLProgramUniform modelOrigin("modelOrigin");
			modelOrigin(shadowMapProgram);
			modelOrigin.SetValue(origin.x, origin.y, origin.z);
			
			// setup attributes
			static GLProgramAttribute positionAttribute("positionAttribute");
			static GLProgramAttribute normalAttribute("normalAttribute");
			
			positionAttribute(shadowMapProgram);
			normalAttribute(shadowMapProgram);
			
			device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
			device->VertexAttribPointer(positionAttribute(),
										4, IGLDevice::UnsignedByte,
										false, sizeof(Vertex),
										(void *)0);
			if(normalAttribute() != -1){
				device->VertexAttribPointer(normalAttribute(),
											3, IGLDevice::Byte,
											false, sizeof(Vertex),
											(void *)8);
			}
			device->BindBuffer(IGLDevice::ArrayBuffer, 0);
			
			device->EnableVertexAttribArray(positionAttribute(), true);
			if(normalAttribute() != -1)
				device->EnableVertexAttribArray(normalAttribute(), true);
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, idxBuffer);
			
			for(size_t i = 0; i < params.size(); i++){
				const client::ModelRenderParam& param = params[i];
				
				// frustrum cull
				float rad = radius;
				rad *= param.matrix.GetAxis(0).GetLength();
				
				if(param.depthHack)
					continue;
				
				if(!renderer->GetShadowMapRenderer()->SphereCull(param.matrix.GetOrigin(),
																 rad)){
					continue;
				}
				
				Matrix4 modelMatrix = param.matrix;
				
				static GLProgramUniform modelMatrixU("modelMatrix");
				modelMatrixU(shadowMapProgram);
				modelMatrixU.SetValue(modelMatrix);
				
				modelMatrix.m[12] = 0.f;
				modelMatrix.m[13] = 0.f;
				modelMatrix.m[14] = 0.f;
				static GLProgramUniform modelNormalMatrix("modelNormalMatrix");
				modelNormalMatrix(shadowMapProgram);
				modelNormalMatrix.SetValue(modelMatrix);
				
				device->DrawElements(IGLDevice::Triangles,
									 numIndices,
									 IGLDevice::UnsignedInt,
									 (void *)0);
				
			}
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
			
			
			device->EnableVertexAttribArray(positionAttribute(), false);
			if(normalAttribute() != -1)
				device->EnableVertexAttribArray(normalAttribute(), false);
			
			device->ActiveTexture(0);
			device->BindTexture(IGLDevice::Texture2D, 0);
		}
		
		void GLOptimizedVoxelModel::RenderSunlightPass(std::vector<client::ModelRenderParam> params) {
			SPADES_MARK_FUNCTION();
			
			bool mirror = renderer->IsRenderingMirror();
			
			device->ActiveTexture(0);
			aoImage->Bind(IGLDevice::Texture2D);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMinFilter,
								 IGLDevice::Linear);
			
			device->ActiveTexture(1);
			image->Bind(IGLDevice::Texture2D);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMinFilter,
								 IGLDevice::Nearest);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMagFilter,
								 IGLDevice::Nearest);
			
			device->Enable(IGLDevice::CullFace, true);
			device->Enable(IGLDevice::DepthTest, true);
			
			program->Use();
			
			static GLShadowShader shadowShader;
			shadowShader(renderer, program, 2);
			
			static GLProgramUniform fogDistance("fogDistance");
			fogDistance(program);
			fogDistance.SetValue(renderer->GetFogDistance());
			
			static GLProgramUniform fogColor("fogColor");
			fogColor(program);
			Vector3 fogCol = renderer->GetFogColorForSolidPass();
			fogCol *= fogCol; // linearize
			fogColor.SetValue(fogCol.x, fogCol.y, fogCol.z);
			
			static GLProgramUniform aoUniform("ambientOcclusionTexture");
			aoUniform(program);
			aoUniform.SetValue(0);
			
			static GLProgramUniform modelOrigin("modelOrigin");
			modelOrigin(program);
			modelOrigin.SetValue(origin.x, origin.y, origin.z);
			
			static GLProgramUniform texScale("texScale");
			texScale(program);
			texScale.SetValue(1.f / image->GetWidth(),
							  1.f / image->GetHeight());
			
			static GLProgramUniform modelTexture("modelTexture");
			modelTexture(program);
			modelTexture.SetValue(1);
			
			static GLProgramUniform sunLightDirection("sunLightDirection");
			sunLightDirection(program);
			Vector3 sunPos = MakeVector3(0, -1, -1);
			sunPos = sunPos.Normalize();
			sunLightDirection.SetValue(sunPos.x, sunPos.y, sunPos.z);
			
			// setup attributes
			static GLProgramAttribute positionAttribute("positionAttribute");
			static GLProgramAttribute textureCoordAttribute("textureCoordAttribute");
			static GLProgramAttribute normalAttribute("normalAttribute");
			
			positionAttribute(program);
			textureCoordAttribute(program);
			normalAttribute(program);
			
			device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
			device->VertexAttribPointer(positionAttribute(),
										4, IGLDevice::UnsignedByte,
										false, sizeof(Vertex),
										(void *)0);
			device->VertexAttribPointer(textureCoordAttribute(),
										2, IGLDevice::UnsignedShort,
										false, sizeof(Vertex),
										(void *)4);
			device->VertexAttribPointer(normalAttribute(),
										3, IGLDevice::Byte,
										false, sizeof(Vertex),
										(void *)8);
			device->BindBuffer(IGLDevice::ArrayBuffer, 0);
			
			device->EnableVertexAttribArray(positionAttribute(), true);
			device->EnableVertexAttribArray(textureCoordAttribute(), true);
			device->EnableVertexAttribArray(normalAttribute(), true);
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, idxBuffer);
			
			for(size_t i = 0; i < params.size(); i++){
				const client::ModelRenderParam& param = params[i];
				
				if(mirror && param.depthHack)
					continue;
				
				// frustrum cull
				float rad = radius;
				rad *= param.matrix.GetAxis(0).GetLength();
				if(!renderer->SphereFrustrumCull(param.matrix.GetOrigin(),
												 rad)){
					continue;
				}
				
				
				static GLProgramUniform customColor("customColor");
				customColor(program);
				customColor.SetValue(param.customColor.x, param.customColor.y, param.customColor.z);
				
				
				Matrix4 modelMatrix = param.matrix;
				static GLProgramUniform projectionViewModelMatrix("projectionViewModelMatrix");
				projectionViewModelMatrix(program);
				projectionViewModelMatrix.SetValue(renderer->GetProjectionViewMatrix() * modelMatrix);
				
				static GLProgramUniform viewModelMatrix("viewModelMatrix");
				viewModelMatrix(program);
				viewModelMatrix.SetValue(renderer->GetViewMatrix() * modelMatrix);
				
				static GLProgramUniform modelMatrixU("modelMatrix");
				modelMatrixU(program);
				modelMatrixU.SetValue(modelMatrix);
				
				modelMatrix.m[12] = 0.f;
				modelMatrix.m[13] = 0.f;
				modelMatrix.m[14] = 0.f;
				static GLProgramUniform modelNormalMatrix("modelNormalMatrix");
				modelNormalMatrix(program);
				modelNormalMatrix.SetValue(modelMatrix);
				
				if(param.depthHack){
					device->DepthRange(0.f, 0.1f);
				}
				
				device->DrawElements(IGLDevice::Triangles,
									 numIndices,
									 IGLDevice::UnsignedInt,
									 (void *)0);
				if(param.depthHack){
					device->DepthRange(0.f, 1.f);
				}
				
			}
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
			
			
			device->EnableVertexAttribArray(positionAttribute(), false);
			device->EnableVertexAttribArray(textureCoordAttribute(), false);
			device->EnableVertexAttribArray(normalAttribute(), false);
			
			device->ActiveTexture(1);
			device->BindTexture(IGLDevice::Texture2D, 0);
			device->ActiveTexture(0);
			device->BindTexture(IGLDevice::Texture2D, 0);
		}
		
		void GLOptimizedVoxelModel::RenderDynamicLightPass(std::vector<client::ModelRenderParam> params, std::vector<GLDynamicLight> lights) {
			SPADES_MARK_FUNCTION();
			
			bool mirror = renderer->IsRenderingMirror();
			
			device->ActiveTexture(0);
			aoImage->Bind(IGLDevice::Texture2D);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMinFilter,
								 IGLDevice::Linear);
			
			device->ActiveTexture(1);
			image->Bind(IGLDevice::Texture2D);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMinFilter,
								 IGLDevice::Nearest);
			device->TexParamater(IGLDevice::Texture2D,
								 IGLDevice::TextureMagFilter,
								 IGLDevice::Nearest);
			
			device->Enable(IGLDevice::CullFace, true);
			device->Enable(IGLDevice::DepthTest, true);
						
			dlightProgram->Use();
			
			static GLDynamicLightShader dlightShader;
			
			static GLProgramUniform fogDistance("fogDistance");
			fogDistance(dlightProgram);
			fogDistance.SetValue(renderer->GetFogDistance());
			
			static GLProgramUniform modelOrigin("modelOrigin");
			modelOrigin(dlightProgram);
			modelOrigin.SetValue(origin.x, origin.y, origin.z);
			
			
			static GLProgramUniform texScale("texScale");
			texScale(dlightProgram);
			texScale.SetValue(1.f / image->GetWidth(),
							  1.f / image->GetHeight());
			
			static GLProgramUniform modelTexture("modelTexture");
			modelTexture(dlightProgram);
			modelTexture.SetValue(1);
			
			// setup attributes
			static GLProgramAttribute positionAttribute("positionAttribute");
			static GLProgramAttribute textureCoordAttribute("textureCoordAttribute");
			static GLProgramAttribute normalAttribute("normalAttribute");
			
			positionAttribute(dlightProgram);
			textureCoordAttribute(dlightProgram);
			normalAttribute(dlightProgram);
			
			device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
			device->VertexAttribPointer(positionAttribute(),
										4, IGLDevice::UnsignedByte,
										false, sizeof(Vertex),
										(void *)0);
			device->VertexAttribPointer(textureCoordAttribute(),
										2, IGLDevice::UnsignedShort,
										false, sizeof(Vertex),
										(void *)4);
			device->VertexAttribPointer(normalAttribute(),
										3, IGLDevice::Byte,
										false, sizeof(Vertex),
										(void *)8);
			device->BindBuffer(IGLDevice::ArrayBuffer, 0);
			
			device->EnableVertexAttribArray(positionAttribute(), true);
			device->EnableVertexAttribArray(textureCoordAttribute(), true);
			device->EnableVertexAttribArray(normalAttribute(), true);
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, idxBuffer);
			
			for(size_t i = 0; i < params.size(); i++){
				const client::ModelRenderParam& param = params[i];
				
				if(mirror && param.depthHack)
					continue;
				
				// frustrum cull
				float rad = radius;
				rad *= param.matrix.GetAxis(0).GetLength();
				if(!renderer->SphereFrustrumCull(param.matrix.GetOrigin(),
												 rad)){
					continue;
				}
				
				
				static GLProgramUniform customColor("customColor");
				customColor(dlightProgram);
				customColor.SetValue(param.customColor.x, param.customColor.y, param.customColor.z);
				
				
				Matrix4 modelMatrix = param.matrix;
				static GLProgramUniform projectionViewModelMatrix("projectionViewModelMatrix");
				projectionViewModelMatrix(dlightProgram);
				projectionViewModelMatrix.SetValue(renderer->GetProjectionViewMatrix() * modelMatrix);
				
				static GLProgramUniform viewModelMatrix("viewModelMatrix");
				viewModelMatrix(dlightProgram);
				viewModelMatrix.SetValue(renderer->GetViewMatrix() * modelMatrix);
				
				static GLProgramUniform modelMatrixU("modelMatrix");
				modelMatrixU(dlightProgram);
				modelMatrixU.SetValue(modelMatrix);
				
				modelMatrix.m[12] = 0.f;
				modelMatrix.m[13] = 0.f;
				modelMatrix.m[14] = 0.f;
				static GLProgramUniform modelNormalMatrix("modelNormalMatrix");
				modelNormalMatrix(dlightProgram);
				modelNormalMatrix.SetValue(modelMatrix);
				
				if(param.depthHack){
					device->DepthRange(0.f, 0.1f);
				}
				for(size_t i = 0; i < lights.size(); i++){
					if(!GLDynamicLightShader::SphereCull(lights[i],
														 param.matrix.GetOrigin(), rad))
						continue;
					
					dlightShader(renderer, dlightProgram, lights[i], 2);
					
					device->DrawElements(IGLDevice::Triangles,
										 numIndices,
										 IGLDevice::UnsignedInt,
										 (void *)0);
				}
				if(param.depthHack){
					device->DepthRange(0.f, 1.f);
				}
				
			}
			
			device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
			
			
			device->EnableVertexAttribArray(positionAttribute(), false);
			device->EnableVertexAttribArray(textureCoordAttribute(), false);
			device->EnableVertexAttribArray(normalAttribute(), false);
			
			device->ActiveTexture(0);
		}
		
	}
}