model.c

/*
	Copyright (c) 2017-2020 ByteBit

	This file is part of BetterSpades.

	BetterSpades 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.

	BetterSpades 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 BetterSpades.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "common.h"
#include "model_normals.h"

struct kv6_t model_playerdead;
struct kv6_t model_playerhead;
struct kv6_t model_playertorso;
struct kv6_t model_playertorsoc;
struct kv6_t model_playerarms;
struct kv6_t model_playerleg;
struct kv6_t model_playerlegc;
struct kv6_t model_intel;
struct kv6_t model_tent;

struct kv6_t model_semi;
struct kv6_t model_smg;
struct kv6_t model_shotgun;
struct kv6_t model_spade;
struct kv6_t model_block;
struct kv6_t model_grenade;

struct kv6_t model_semi_tracer;
struct kv6_t model_smg_tracer;
struct kv6_t model_shotgun_tracer;

struct kv6_t model_semi_casing;
struct kv6_t model_smg_casing;
struct kv6_t model_shotgun_casing;

void kv6_init() {
	kv6_load(&model_playerdead, file_load("kv6/playerdead.kv6"), 0.1F);
	kv6_load(&model_playerhead, file_load("kv6/playerhead.kv6"), 0.1F);
	kv6_load(&model_playertorso, file_load("kv6/playertorso.kv6"), 0.1F);
	kv6_load(&model_playertorsoc, file_load("kv6/playertorsoc.kv6"), 0.1F);
	kv6_load(&model_playerarms, file_load("kv6/playerarms.kv6"), 0.1F);
	kv6_load(&model_playerleg, file_load("kv6/playerleg.kv6"), 0.1F);
	kv6_load(&model_playerlegc, file_load("kv6/playerlegc.kv6"), 0.1F);

	kv6_load(&model_intel, file_load("kv6/intel.kv6"), 0.2F);
	kv6_load(&model_tent, file_load("kv6/cp.kv6"), 0.278F);

	kv6_load(&model_semi, file_load("kv6/semi.kv6"), 0.05F);
	kv6_load(&model_smg, file_load("kv6/smg.kv6"), 0.05F);
	kv6_load(&model_shotgun, file_load("kv6/shotgun.kv6"), 0.05F);
	kv6_load(&model_spade, file_load("kv6/spade.kv6"), 0.05F);
	kv6_load(&model_block, file_load("kv6/block.kv6"), 0.05F);
	model_block.colorize = 1;
	kv6_load(&model_grenade, file_load("kv6/grenade.kv6"), 0.05F);

	kv6_load(&model_semi_tracer, file_load("kv6/semitracer.kv6"), 0.05F);
	kv6_load(&model_smg_tracer, file_load("kv6/smgtracer.kv6"), 0.05F);
	kv6_load(&model_shotgun_tracer, file_load("kv6/shotguntracer.kv6"), 0.05F);

	kv6_load(&model_semi_casing, file_load("kv6/semicasing.kv6"), 0.0125F);
	kv6_load(&model_smg_casing, file_load("kv6/smgcasing.kv6"), 0.0125F);
	kv6_load(&model_shotgun_casing, file_load("kv6/shotguncasing.kv6"), 0.0125F);
}

void kv6_rebuild_all() {
	// only needed for models that contain team colors
	kv6_rebuild(&model_playerdead);
	kv6_rebuild(&model_playerhead);
	kv6_rebuild(&model_playertorso);
	kv6_rebuild(&model_playertorsoc);
	kv6_rebuild(&model_playerarms);
	kv6_rebuild(&model_playerleg);
	kv6_rebuild(&model_playerlegc);
	kv6_rebuild(&model_intel);
	kv6_rebuild(&model_tent);
}

void kv6_rebuild_complete() {
	kv6_rebuild_all();
	kv6_rebuild(&model_semi);
	kv6_rebuild(&model_smg);
	kv6_rebuild(&model_shotgun);
	kv6_rebuild(&model_spade);
	kv6_rebuild(&model_block);
	kv6_rebuild(&model_grenade);
	kv6_rebuild(&model_semi_tracer);
	kv6_rebuild(&model_smg_tracer);
	kv6_rebuild(&model_shotgun_tracer);
	kv6_rebuild(&model_semi_casing);
	kv6_rebuild(&model_smg_casing);
	kv6_rebuild(&model_shotgun_casing);
}

void kv6_load(struct kv6_t* kv6, unsigned char* bytes, float scale) {
	kv6->colorize = 0;
	kv6->has_display_list = 0;
	kv6->scale = scale;
	int index = 0;
	if(buffer_read32(bytes, index) == 0x6C78764B) { //"Kvxl"
		index += 4;
		kv6->xsiz = buffer_read32(bytes, index);
		index += 4;
		kv6->ysiz = buffer_read32(bytes, index);
		index += 4;
		kv6->zsiz = buffer_read32(bytes, index);
		index += 4;

		kv6->xpiv = buffer_readf(bytes, index);
		index += 4;
		kv6->ypiv = buffer_readf(bytes, index);
		index += 4;
		kv6->zpiv = kv6->zsiz - buffer_readf(bytes, index);
		index += 4;

		int blklen = buffer_read32(bytes, index);
		index += 4;
		unsigned int* blkdata_color = malloc(blklen * 4);
		CHECK_ALLOCATION_ERROR(blkdata_color)
		unsigned short* blkdata_zpos = malloc(blklen * 2);
		CHECK_ALLOCATION_ERROR(blkdata_zpos)
		unsigned char* blkdata_visfaces = malloc(blklen);
		CHECK_ALLOCATION_ERROR(blkdata_visfaces)
		unsigned char* blkdata_lighting = malloc(blklen);
		CHECK_ALLOCATION_ERROR(blkdata_lighting)
		for(int k = 0; k < blklen; k++) {
			blkdata_color[k] = buffer_read32(bytes, index);
			index += 4;
			blkdata_zpos[k] = buffer_read16(bytes, index);
			index += 2;
			blkdata_visfaces[k] = buffer_read8(bytes, index++); // 0x00zZyYxX
			blkdata_lighting[k]
				= buffer_read8(bytes, index++); // compressed normal vector (also referred to as lighting)
		}
		index += 4 * kv6->xsiz;
		kv6->voxels = malloc(kv6->xsiz * kv6->ysiz * kv6->zsiz * sizeof(struct kv6_voxel));
		CHECK_ALLOCATION_ERROR(kv6->voxels)
		kv6->voxel_count = 0;
		for(int x = 0; x < kv6->xsiz; x++) {
			for(int y = 0; y < kv6->ysiz; y++) {
				int size = buffer_read16(bytes, index);
				index += 2;
				for(int z = 0; z < size; z++) {
					struct kv6_voxel* voxel = &kv6->voxels[kv6->voxel_count];
					voxel->x = x;
					voxel->y = y;
					voxel->z = (kv6->zsiz - 1) - blkdata_zpos[kv6->voxel_count];
					voxel->color
						= (blkdata_color[kv6->voxel_count] & 0xFFFFFF) | (blkdata_lighting[kv6->voxel_count] << 24);
					voxel->visfaces = blkdata_visfaces[kv6->voxel_count];
					kv6->voxel_count++;
				}
			}
		}
		kv6->voxels = realloc(kv6->voxels, kv6->voxel_count * sizeof(struct kv6_voxel));
		CHECK_ALLOCATION_ERROR(kv6->voxels)

		free(blkdata_color);
		free(blkdata_zpos);
		free(blkdata_visfaces);
		free(blkdata_lighting);
	}
}

void kv6_boundingbox(struct kv6_t* kv6, AABB* bb) {
	matrix_push();
	matrix_load(matrix_model);
	matrix_multiply(matrix_view);
	matrix_multiply(matrix_projection);

	for(int k = 0; k < 8; k++) {
		float v[4] = {(kv6->xsiz * ((k & 1) > 0) - kv6->xpiv) * kv6->scale,
					  (kv6->zsiz * ((k & 2) > 0) - kv6->zpiv) * kv6->scale,
					  (kv6->ysiz * ((k & 4) > 0) - kv6->ypiv) * kv6->scale, 1.0F};
		matrix_vector(v);

		bb->min_x = min(bb->min_x, v[0]);
		bb->min_y = min(bb->min_y, v[1]);
		bb->max_x = max(bb->max_x, v[0]);
		bb->max_y = max(bb->max_y, v[1]);
	}

	matrix_pop();
}

float kv6_intersection(struct kv6_t* kv6, Ray* r) {
	AABB bb;

	for(int k = 0; k < 8; k++) {
		float v[4] = {(kv6->xsiz * ((k & 1) > 0) - kv6->xpiv) * kv6->scale,
					  (kv6->zsiz * ((k & 2) > 0) - kv6->zpiv) * kv6->scale,
					  (kv6->ysiz * ((k & 4) > 0) - kv6->ypiv) * kv6->scale, 1.0F};
		matrix_vector(v);
		bb.min_x = (k == 0) ? v[0] : min(bb.min_x, v[0]);
		bb.min_y = (k == 0) ? v[1] : min(bb.min_y, v[1]);
		bb.min_z = (k == 0) ? v[2] : min(bb.min_z, v[2]);

		bb.max_x = (k == 0) ? v[0] : max(bb.max_x, v[0]);
		bb.max_y = (k == 0) ? v[1] : max(bb.max_y, v[1]);
		bb.max_z = (k == 0) ? v[2] : max(bb.max_z, v[2]);
	}

	return aabb_intersection_ray(&bb, r);
}

void kv6_rebuild(struct kv6_t* kv6) {
	if(kv6->has_display_list) {
		glx_displaylist_destroy(&kv6->display_list[0]);
		glx_displaylist_destroy(&kv6->display_list[1]);
		glx_displaylist_destroy(&kv6->display_list[2]);
		if(kv6->colorize) {
			free(kv6->vertices_final);
			free(kv6->colors_final);
			free(kv6->normals_final);
		}
		kv6->has_display_list = 0;
	}
}

void kv6_calclight(int x, int y, int z) {
	float f = 1.0F;
	if(x >= 0 && y >= 0 && z >= 0)
		f = map_sunblock(x, y, z);
	float lambient[4] = {0.5F * f, 0.5F * f, 0.5F * f, 1.0F};
	float ldiffuse[4] = {0.5F * f, 0.5F * f, 0.5F * f, 1.0F};
	glLightfv(GL_LIGHT0, GL_AMBIENT, lambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, ldiffuse);
}

static int kv6_program = -1;
void kv6_render(struct kv6_t* kv6, unsigned char team) {
	if(!kv6)
		return;
	if(team == TEAM_SPECTATOR)
		team = 2;
	if(!settings.voxlap_models) {
		if(!kv6->has_display_list) {
			int size = kv6->voxel_count * 6;

#ifdef OPENGL_ES
			kv6->vertices_final = malloc(size * 3 * 6 * sizeof(float));
			CHECK_ALLOCATION_ERROR(kv6->vertices_final)
			kv6->colors_final = malloc(size * 4 * 6 * sizeof(unsigned char) * 2);
			CHECK_ALLOCATION_ERROR(kv6->colors_final)
			kv6->normals_final = malloc(size * 3 * 6 * sizeof(unsigned char));
			CHECK_ALLOCATION_ERROR(kv6->normals_final)
#else
			kv6->vertices_final = malloc(size * 3 * 4 * sizeof(float));
			CHECK_ALLOCATION_ERROR(kv6->vertices_final)
			kv6->colors_final = malloc(size * 4 * 4 * sizeof(unsigned char) * 2);
			CHECK_ALLOCATION_ERROR(kv6->colors_final)
			kv6->normals_final = malloc(size * 3 * 4 * sizeof(unsigned char));
			CHECK_ALLOCATION_ERROR(kv6->normals_final)
#endif

			if(!kv6->colorize) {
				glx_displaylist_create(&kv6->display_list[0]);
				glx_displaylist_create(&kv6->display_list[1]);
				glx_displaylist_create(&kv6->display_list[2]);
			}

			int v, c, n;
			for(int t = 0; t < 3; t++) {
				v = c = n = 0;
				for(int k = 0; k < kv6->voxel_count; k++) {
					int x = kv6->voxels[k].x;
					int y = kv6->voxels[k].y;
					int z = kv6->voxels[k].z;
					int b = kv6->voxels[k].color & 0xFF;
					int g = (kv6->voxels[k].color >> 8) & 0xFF;
					int r = (kv6->voxels[k].color >> 16) & 0xFF;
					int a = (kv6->voxels[k].color >> 24) & 0xFF;
					if(r == 0 && g == 0 && b == 0) {
						switch(t) {
							case TEAM_1:
								r = gamestate.team_1.red * 0.75F;
								g = gamestate.team_1.green * 0.75F;
								b = gamestate.team_1.blue * 0.75F;
								break;
							case TEAM_2:
								r = gamestate.team_2.red * 0.75F;
								g = gamestate.team_2.green * 0.75F;
								b = gamestate.team_2.blue * 0.75F;
								break;
						}
					}

					float p[3]
						= {(x - kv6->xpiv) * kv6->scale, (z - kv6->zpiv) * kv6->scale, (y - kv6->ypiv) * kv6->scale};

					int i = 0;
					float alpha[12];

					// negative y
					if(kv6->voxels[k].visfaces & 16) {
						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;

#ifdef OPENGL_ES
						alpha[i++] = 1.0F;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;
#endif

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];
						alpha[i++] = 1.0F;
					}

					// positive y
					if(kv6->voxels[k].visfaces & 32) {
						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;

#ifdef OPENGL_ES
						alpha[i++] = 0.6F;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;
#endif

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;
						alpha[i++] = 0.6F;
					}

					// negative z
					if(kv6->voxels[k].visfaces & 4) {
						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];

#ifdef OPENGL_ES
						alpha[i++] = 0.95F;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];
#endif

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];
						alpha[i++] = 0.95F;
					}

					// positive z
					if(kv6->voxels[k].visfaces & 8) {
						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;

#ifdef OPENGL_ES
						alpha[i++] = 0.9F;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;
#endif

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;
						alpha[i++] = 0.9F;
					}

					// negative x
					if(kv6->voxels[k].visfaces & 1) {
						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;

#ifdef OPENGL_ES
						alpha[i++] = 0.85F;

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;
#endif

						kv6->vertices_final[v++] = p[0];
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];
						alpha[i++] = 0.85F;
					}

					// positive x
					if(kv6->voxels[k].visfaces & 2) {
						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;

#ifdef OPENGL_ES
						alpha[i++] = 0.8F;

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2];

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1] + kv6->scale;
						kv6->vertices_final[v++] = p[2] + kv6->scale;
#endif

						kv6->vertices_final[v++] = p[0] + kv6->scale;
						kv6->vertices_final[v++] = p[1];
						kv6->vertices_final[v++] = p[2] + kv6->scale;
						alpha[i++] = 0.8F;
					}

#ifdef OPENGL_ES
					for(int k = 0; k < i * 3; k++) {
						kv6->colors_final[c++] = r * alpha[k / 3];
						kv6->colors_final[c++] = g * alpha[k / 3];
						kv6->colors_final[c++] = b * alpha[k / 3];
						kv6->colors_final[c++] = 255;
#else
					for(int k = 0; k < i * 4; k++) {
						kv6->colors_final[c++] = r * alpha[k / 4];
						kv6->colors_final[c++] = g * alpha[k / 4];
						kv6->colors_final[c++] = b * alpha[k / 4];
						kv6->colors_final[c++] = 255;
#endif
						kv6->normals_final[n++] = kv6_normals[a][0] * 128;
						kv6->normals_final[n++] = -kv6_normals[a][2] * 128;
						kv6->normals_final[n++] = kv6_normals[a][1] * 128;
					}
				}

				if(!kv6->colorize)
					glx_displaylist_update(&kv6->display_list[t], v / 3, GLX_DISPLAYLIST_ENHANCED, kv6->colors_final,
										   kv6->vertices_final, kv6->normals_final);
			}

			if(!kv6->colorize) {
				free(kv6->vertices_final);
				free(kv6->colors_final);
				free(kv6->normals_final);
			} else {
				memcpy(kv6->colors_final + c * sizeof(unsigned char), kv6->colors_final, c * sizeof(unsigned char));
				kv6->size = v / 3;
			}

			kv6->has_display_list = 1;
		} else {
			glEnable(GL_LIGHTING);
			glEnable(GL_LIGHT0);
			glEnable(GL_COLOR_MATERIAL);
#ifndef OPENGL_ES
			glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
#endif
			glEnable(GL_NORMALIZE);
			if(!kv6->colorize) {
				glx_displaylist_draw(&kv6->display_list[team % 3], GLX_DISPLAYLIST_ENHANCED);
			} else {
				for(int k = 0; k < kv6->size * 4; k += 4) {
					kv6->colors_final[k + 0] = min(
						((float)kv6->colors_final[k + 0 + kv6->size * 4 * sizeof(unsigned char)]) / 0.4335F * kv6->red,
						255);
					kv6->colors_final[k + 1]
						= min(((float)kv6->colors_final[k + 1 + kv6->size * 4 * sizeof(unsigned char)]) / 0.4335F
								  * kv6->green,
							  255);
					kv6->colors_final[k + 2] = min(
						((float)kv6->colors_final[k + 2 + kv6->size * 4 * sizeof(unsigned char)]) / 0.4335F * kv6->blue,
						255);
				}
				glEnableClientState(GL_VERTEX_ARRAY);
				glEnableClientState(GL_COLOR_ARRAY);
				glEnableClientState(GL_NORMAL_ARRAY);
				glVertexPointer(3, GL_FLOAT, 0, kv6->vertices_final);
				glColorPointer(4, GL_UNSIGNED_BYTE, 0, kv6->colors_final);
				glNormalPointer(GL_BYTE, 0, kv6->normals_final);
#ifdef OPENGL_ES
				glDrawArrays(GL_TRIANGLES, 0, kv6->size);
#else
				glDrawArrays(GL_QUADS, 0, kv6->size);
#endif
				glDisableClientState(GL_NORMAL_ARRAY);
				glDisableClientState(GL_COLOR_ARRAY);
				glDisableClientState(GL_VERTEX_ARRAY);
			}
			glDisable(GL_NORMALIZE);
			glDisable(GL_COLOR_MATERIAL);
			glDisable(GL_LIGHT0);
			glDisable(GL_LIGHTING);
		}
	} else {
		// render like in voxlap
		if(!kv6->has_display_list) {
			kv6->vertices_final = malloc(kv6->voxel_count * 3 * sizeof(float));
			CHECK_ALLOCATION_ERROR(kv6->vertices_final)
			kv6->colors_final = malloc(kv6->voxel_count * 4 * sizeof(unsigned char) * 2);
			CHECK_ALLOCATION_ERROR(kv6->colors_final)
			kv6->normals_final = malloc(kv6->voxel_count * 3 * sizeof(unsigned char));
			CHECK_ALLOCATION_ERROR(kv6->normals_final)
			kv6->has_display_list = 1;

			for(int t = 0; t < 3; t++) {
				int k = 0;
				glx_displaylist_create(&kv6->display_list[t]);
				for(int i = 0; i < kv6->voxel_count; i++) {
					int b = kv6->voxels[i].color & 0xFF;
					int g = (kv6->voxels[i].color >> 8) & 0xFF;
					int r = (kv6->voxels[i].color >> 16) & 0xFF;
					int a = (kv6->voxels[i].color >> 24) & 0xFF;
					if((r | g | b) == 0) {
						switch(t) {
							case TEAM_1:
								r = gamestate.team_1.red * 0.75F;
								g = gamestate.team_1.green * 0.75F;
								b = gamestate.team_1.blue * 0.75F;
								break;
							case TEAM_2:
								r = gamestate.team_2.red * 0.75F;
								g = gamestate.team_2.green * 0.75F;
								b = gamestate.team_2.blue * 0.75F;
								break;
						}
					}

					float v[3]
						= {(kv6->voxels[i].x - kv6->xpiv) * kv6->scale, (kv6->voxels[i].z - kv6->zpiv) * kv6->scale,
						   (kv6->voxels[i].y - kv6->ypiv) * kv6->scale};

					kv6->colors_final[k * 4 + 0] = r;
					kv6->colors_final[k * 4 + 1] = g;
					kv6->colors_final[k * 4 + 2] = b;
					kv6->colors_final[k * 4 + 3] = 255;

					kv6->normals_final[k * 3 + 0] = kv6_normals[a][0] * 128;
					kv6->normals_final[k * 3 + 1] = -kv6_normals[a][2] * 128;
					kv6->normals_final[k * 3 + 2] = kv6_normals[a][1] * 128;

					kv6->vertices_final[k * 3 + 0] = v[0] + kv6->scale * 0.5F;
					kv6->vertices_final[k * 3 + 1] = v[1] + kv6->scale * 0.5F;
					kv6->vertices_final[k * 3 + 2] = v[2] + kv6->scale * 0.5F;

					k++;
				}

				glx_displaylist_update(&kv6->display_list[t], k, GLX_DISPLAYLIST_POINTS, kv6->colors_final,
									   kv6->vertices_final, kv6->normals_final);
				kv6->size = k;
			}

			if(!kv6->colorize) {
				free(kv6->colors_final);
				free(kv6->vertices_final);
				free(kv6->normals_final);
			} else {
				memcpy(kv6->colors_final + kv6->size * 4 * sizeof(unsigned char), kv6->colors_final,
					   kv6->size * 4 * sizeof(unsigned char));
			}

			if(kv6_program < 0) {
				kv6_program
					= glx_shader("uniform float size;\n"
								 "uniform vec3 fog;\n"
								 "uniform vec3 camera;\n"
								 "uniform mat4 model;\n"
								 "uniform float dist_factor;\n"
								 "void main(void) {\n"
								 "	gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;\n"
								 "	float dist = length((model*gl_Vertex).xz-camera.xz)*dist_factor;\n"
								 "	vec3 N = normalize(model*vec4(gl_Normal,0)).xyz;\n"
								 "	vec3 L = normalize(vec3(0,-1,1));\n"
								 "	float d = clamp(dot(N,L),0.0,1.0)*0.5+0.5;\n"
								 "	gl_FrontColor = mix(vec4(d,d,d,1.0)*gl_Color,vec4(fog,1.0),min(dist,1.0));\n"
								 "	gl_PointSize = size/gl_Position.w;\n"
								 "}\n",
								 "void main(void) {\n"
								 "	gl_FragColor = gl_Color;\n"
								 "}\n");
			}
		}

		float near_plane_height
			= (float)settings.window_height / (2.0F * tan(camera_fov_scaled() * 1.570796F / 180.0F));

		float len_x = len3D(matrix_model[0], matrix_model[1], matrix_model[2]);
		float len_y = len3D(matrix_model[4], matrix_model[5], matrix_model[6]);
		float len_z = len3D(matrix_model[8], matrix_model[9], matrix_model[10]);

#ifndef OPENGL_ES
		if(!glx_version)
#endif
		{
			float params[3] = {0.0F, 0.0F, 1.0F};
			glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, params);
			glPointSize(1.414F * near_plane_height * kv6->scale * (len_x + len_y + len_z) / 3.0F);
			glEnable(GL_LIGHTING);
			glEnable(GL_LIGHT0);
			glEnable(GL_COLOR_MATERIAL);
#ifndef OPENGL_ES
			glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
#endif
			glEnable(GL_NORMALIZE);
		}

#ifndef OPENGL_ES
		if(glx_version) {
			glEnable(GL_PROGRAM_POINT_SIZE);
			glUseProgram(kv6_program);
			glUniform1f(glGetUniformLocation(kv6_program, "dist_factor"),
						glx_fog ? 1.0F / settings.render_distance : 0.0F);
			glUniform1f(glGetUniformLocation(kv6_program, "size"),
						1.414F * near_plane_height * kv6->scale * (len_x + len_y + len_z) / 3.0F);
			glUniform3f(glGetUniformLocation(kv6_program, "fog"), fog_color[0], fog_color[1], fog_color[2]);
			glUniform3f(glGetUniformLocation(kv6_program, "camera"), camera_x, camera_y, camera_z);
			glUniformMatrix4fv(glGetUniformLocation(kv6_program, "model"), 1, 0, matrix_model);
		}
#endif
		if(settings.multisamples)
			glDisable(GL_MULTISAMPLE);

		if(kv6->colorize) {
			for(int k = 0; k < kv6->size * 4; k += 4) {
				kv6->colors_final[k + 0] = min(((float)kv6->colors_final[k + 0 + kv6->size * 4 * sizeof(unsigned char)])
												   / 0.4335F * kv6->red,
											   255);
				kv6->colors_final[k + 1] = min(((float)kv6->colors_final[k + 1 + kv6->size * 4 * sizeof(unsigned char)])
												   / 0.4335F * kv6->green,
											   255);
				kv6->colors_final[k + 2] = min(((float)kv6->colors_final[k + 2 + kv6->size * 4 * sizeof(unsigned char)])
												   / 0.4335F * kv6->blue,
											   255);
			}
			glEnableClientState(GL_VERTEX_ARRAY);
			glEnableClientState(GL_COLOR_ARRAY);
			glEnableClientState(GL_NORMAL_ARRAY);
			glVertexPointer(3, GL_FLOAT, 0, kv6->vertices_final);
			glColorPointer(4, GL_UNSIGNED_BYTE, 0, kv6->colors_final);
			glNormalPointer(GL_BYTE, 0, kv6->normals_final);
			glDrawArrays(GL_POINTS, 0, kv6->size);
			glDisableClientState(GL_NORMAL_ARRAY);
			glDisableClientState(GL_VERTEX_ARRAY);
			glDisableClientState(GL_COLOR_ARRAY);
		} else {
			glx_displaylist_draw(&kv6->display_list[team % 3], GLX_DISPLAYLIST_POINTS);
		}

		if(settings.multisamples)
			glEnable(GL_MULTISAMPLE);
#ifndef OPENGL_ES
		if(glx_version) {
			glUseProgram(0);
			glDisable(GL_PROGRAM_POINT_SIZE);
		}
#endif

#ifndef OPENGL_ES
		if(!glx_version)
#endif
		{
			glDisable(GL_NORMALIZE);
			glDisable(GL_COLOR_MATERIAL);
			glDisable(GL_LIGHT0);
			glDisable(GL_LIGHTING);
		}
	}
}