texture.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 <math.h>

#include "common.h"
#include "texture.h"
#include "map.h"
#include "log.h"
#include "file.h"

#include "lodepng/lodepng.c"

struct texture texture_splash;
struct texture texture_minimap;
struct texture texture_gradient;
struct texture texture_dummy;

struct texture texture_health;
struct texture texture_block;
struct texture texture_grenade;
struct texture texture_ammo_semi;
struct texture texture_ammo_smg;
struct texture texture_ammo_shotgun;

struct texture texture_color_selection;

struct texture texture_zoom_semi;
struct texture texture_zoom_smg;
struct texture texture_zoom_shotgun;

struct texture texture_white;
struct texture texture_target;
struct texture texture_indicator;

struct texture texture_player;
struct texture texture_medical;
struct texture texture_intel;
struct texture texture_command;
struct texture texture_tracer;

struct texture texture_ui_wait;
struct texture texture_ui_join;
struct texture texture_ui_reload;
struct texture texture_ui_bg;
struct texture texture_ui_input;
struct texture texture_ui_box_empty;
struct texture texture_ui_box_check;
struct texture texture_ui_expanded;
struct texture texture_ui_collapsed;
struct texture texture_ui_flags;
struct texture texture_ui_alert;
struct texture texture_ui_joystick;
struct texture texture_ui_knob;

static char* texture_flags[251]
	= {"AD",  "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA",
	   "BB",  "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BL", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY",
	   "BZ",  "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CS", "CU", "CV", "CX",
	   "CY",  "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK",
	   "FM",  "FO", "FR", "FX", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR",
	   "GS",  "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IN", "IO", "IQ", "IR",
	   "IS",  "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA",
	   "LAN", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH",
	   "MK",  "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC",
	   "NE",  "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL",
	   "PM",  "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA", "SB", "SC", "SD", "SE",
	   "SG",  "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG",
	   "TH",  "TJ", "TK", "TL", "TM", "TN", "TO", "TP", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY",
	   "UZ",  "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "XT", "YE", "YT", "YU", "ZA", "ZM", "ZW"};

static int texture_flag_cmp(const void* a, const void* b) {
	return strcmp(a, *(const void* const*)b);
}

int texture_flag_index(const char* country) {
	char** res = bsearch(country, texture_flags, sizeof(texture_flags) / sizeof(texture_flags[0]), sizeof(char*),
						 texture_flag_cmp);
	return res ? (res - texture_flags) : -1;
}

void texture_flag_offset(int index, float* u, float* v) {
	if(index >= 0) {
		*u = (index % 14) * (18.0F / 256.0F);
		*v = (index / 14) * (12.0F / 256.0F);
	} else {
		*u = 0.0F;
		*v = 0.9375F;
	}
}

void texture_filter(struct texture* t, int filter) {
	glBindTexture(GL_TEXTURE_2D, t->texture_id);
	switch(filter) {
		case TEXTURE_FILTER_NEAREST:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			break;
		case TEXTURE_FILTER_LINEAR:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			break;
	}
	glBindTexture(GL_TEXTURE_2D, 0);
}

int texture_create(struct texture* t, char* filename) {
	int sz = file_size(filename);
	void* data = file_load(filename);
	int error = lodepng_decode32(&t->pixels, &t->width, &t->height, data, sz);
	free(data);

	if(error) {
		log_warn("Could not load texture (%u): %s", error, lodepng_error_text(error));
		return 0;
	}

	texture_resize_pow2(t, 0);

	glGenTextures(1, &t->texture_id);
	glBindTexture(GL_TEXTURE_2D, t->texture_id);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, t->width, t->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, t->pixels);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glBindTexture(GL_TEXTURE_2D, 0);
}

int texture_create_buffer(struct texture* t, int width, int height, unsigned char* buff, int new) {
	if(new)
		glGenTextures(1, &t->texture_id);
	t->width = width;
	t->height = height;
	t->pixels = buff;
	texture_resize_pow2(t, max(width, height));

	glBindTexture(GL_TEXTURE_2D, t->texture_id);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, t->width, t->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, t->pixels);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glBindTexture(GL_TEXTURE_2D, 0);
}

void texture_delete(struct texture* t) {
	if(t->pixels)
		free(t->pixels);
	glDeleteTextures(1, &t->texture_id);
}

void texture_draw_sector(struct texture* t, float x, float y, float w, float h, float u, float v, float us, float vs) {
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glBindTexture(GL_TEXTURE_2D, t->texture_id);

	float vertices[12] = {x, y, x, y - h, x + w, y - h, x, y, x + w, y - h, x + w, y};
	float texcoords[12] = {u, v, u, v + vs, u + us, v + vs, u, v, u + us, v + vs, u + us, v};
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_VERTEX_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisableClientState(GL_VERTEX_ARRAY);

	glBindTexture(GL_TEXTURE_2D, 0);
	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);
}

void texture_draw(struct texture* t, float x, float y, float w, float h) {
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glBindTexture(GL_TEXTURE_2D, t->texture_id);
	texture_draw_empty(x, y, w, h);
	glBindTexture(GL_TEXTURE_2D, 0);
	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);
}

void texture_draw_rotated(struct texture* t, float x, float y, float w, float h, float angle) {
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glBindTexture(GL_TEXTURE_2D, t->texture_id);
	texture_draw_empty_rotated(x, y, w, h, angle);
	glBindTexture(GL_TEXTURE_2D, 0);
	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);
}

void texture_draw_empty(float x, float y, float w, float h) {
	float vertices[12] = {x, y, x, y - h, x + w, y - h, x, y, x + w, y - h, x + w, y};
	float texcoords[12] = {0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F, 0.0F};
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_VERTEX_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisableClientState(GL_VERTEX_ARRAY);
}

#define texture_emit_rotated(tx, ty, x, y, a) cos(a) * (x)-sin(a) * (y) + (tx), sin(a) * (x) + cos(a) * (y) + (ty)

void texture_draw_empty_rotated(float x, float y, float w, float h, float angle) {
	float vertices[12]
		= {texture_emit_rotated(x, y, -w / 2, h / 2, angle), texture_emit_rotated(x, y, -w / 2, -h / 2, angle),
		   texture_emit_rotated(x, y, w / 2, -h / 2, angle), texture_emit_rotated(x, y, -w / 2, h / 2, angle),
		   texture_emit_rotated(x, y, w / 2, -h / 2, angle), texture_emit_rotated(x, y, w / 2, h / 2, angle)};
	float texcoords[12] = {0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F, 0.0F};
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_VERTEX_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisableClientState(GL_VERTEX_ARRAY);
}

void texture_resize_pow2(struct texture* t, int min_size) {
	if(!t->pixels)
		return;
	int max_size = 0;
	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
	max_size = max(max_size, min_size);

	int w = 1, h = 1;
	if(strstr(glGetString(GL_EXTENSIONS), "ARB_texture_non_power_of_two") != NULL) {
		if(t->width <= max_size && t->height <= max_size)
			return;
		w = t->width;
		h = t->height;
	} else {
		while(w < t->width)
			w += w;
		while(h < t->height)
			h += h;
	}

	w = min(w, max_size);
	h = min(h, max_size);

	if(t->width == w && t->height == h)
		return;

	log_info("texture original: %i:%i now: %i:%i limit: %i", t->width, t->height, w, h, max_size);

	if(!t->pixels)
		return;

	unsigned int* pixels_new = malloc(w * h * sizeof(unsigned int));
	CHECK_ALLOCATION_ERROR(pixels_new)
	for(int y = 0; y < h; y++) {
		for(int x = 0; x < w; x++) {
			float px = (float)x / (float)w * (float)t->width;
			float py = (float)y / (float)h * (float)t->height;
			float u = px - (int)px;
			float v = py - (int)py;
			unsigned int aa = ((unsigned int*)t->pixels)[(int)px + (int)py * t->width];
			unsigned int ba = ((unsigned int*)t->pixels)[min((int)px + (int)py * t->width + 1, t->width * t->height)];
			unsigned int ab
				= ((unsigned int*)t->pixels)[min((int)px + (int)py * t->width + t->width, t->width * t->height)];
			unsigned int bb
				= ((unsigned int*)t->pixels)[min((int)px + (int)py * t->width + 1 + t->width, t->width * t->height)];
			pixels_new[x + y * w] = 0;
			pixels_new[x + y * w] |= (int)((1.0F - v) * u * red(ba) + (1.0F - v) * (1.0F - u) * red(aa)
										   + v * u * red(bb) + v * (1.0F - u) * red(ab));
			pixels_new[x + y * w] |= (int)((1.0F - v) * u * green(ba) + (1.0F - v) * (1.0F - u) * green(aa)
										   + v * u * green(bb) + v * (1.0F - u) * green(ab))
				<< 8;
			pixels_new[x + y * w] |= (int)((1.0F - v) * u * blue(ba) + (1.0F - v) * (1.0F - u) * blue(aa)
										   + v * u * blue(bb) + v * (1.0F - u) * blue(ab))
				<< 16;
			pixels_new[x + y * w] |= (int)((1.0F - v) * u * alpha(ba) + (1.0F - v) * (1.0F - u) * alpha(aa)
										   + v * u * alpha(bb) + v * (1.0F - u) * alpha(ab))
				<< 24;
		}
	}

	t->width = w;
	t->height = h;
	free(t->pixels);
	t->pixels = (unsigned char*)pixels_new;
}

unsigned int texture_block_color(int x, int y) {
	int base[3][8] = {{15, 31, 31, 31, 0, 0, 0, 31}, {15, 0, 15, 31, 31, 31, 0, 0}, {15, 0, 0, 0, 0, 31, 31, 31}};

	if(x < 4) {
		return rgb(base[0][y] + x * (base[0][y] * 2 + 2) * (base[0][y] > 0),
				   base[1][y] + x * (base[1][y] * 2 + 2) * (base[1][y] > 0),
				   base[2][y] + x * (base[2][y] * 2 + 2) * (base[2][y] > 0));
	} else {
		return rgb(
			min(base[0][y] + x * (base[0][y] * 2 + 2) * (base[0][y] > 0) + ((x - 3) * 64 - 33) * (!base[0][y]), 255),
			min(base[1][y] + x * (base[1][y] * 2 + 2) * (base[1][y] > 0) + ((x - 3) * 64 - 33) * (!base[1][y]), 255),
			min(base[2][y] + x * (base[2][y] * 2 + 2) * (base[2][y] > 0) + ((x - 3) * 64 - 33) * (!base[2][y]), 255));
	}
}

void texture_gradient_fog(unsigned int* gradient) {
	int size = 512;
	for(int y = 0; y < size; y++) {
		for(int x = 0; x < size; x++) {
			int d = min(sqrt(distance2D(size / 2, size / 2, x, y)) / (float)size * 2.0F * 255.0F, 255);
			gradient[x + y * size] = rgba(d, d, d, 255);
		}
	}
}

void texture_init() {
	texture_create(&texture_splash, "png/splash.png");

	texture_create(&texture_health, "png/health.png");
	texture_create(&texture_block, "png/block.png");
	texture_create(&texture_grenade, "png/grenade.png");
	texture_create(&texture_ammo_semi, "png/semiammo.png");
	texture_create(&texture_ammo_smg, "png/smgammo.png");
	texture_create(&texture_ammo_shotgun, "png/shotgunammo.png");

	texture_create(&texture_zoom_semi, "png/semi.png");
	texture_create(&texture_zoom_smg, "png/smg.png");
	texture_create(&texture_zoom_shotgun, "png/shotgun.png");

	texture_create(&texture_white, "png/white.png");
	texture_create(&texture_target, "png/target.png");
	texture_create(&texture_indicator, "png/indicator.png");

	texture_create(&texture_player, "png/player.png");
	texture_create(&texture_medical, "png/medical.png");
	texture_create(&texture_intel, "png/intel.png");
	texture_create(&texture_command, "png/command.png");
	texture_create(&texture_tracer, "png/tracer.png");

	texture_create(&texture_ui_wait, "png/ui/wait.png");
	texture_filter(&texture_ui_wait, TEXTURE_FILTER_LINEAR);
	texture_create(&texture_ui_join, "png/ui/join.png");
	texture_create(&texture_ui_reload, "png/ui/reload.png");
	texture_create(&texture_ui_bg, "png/ui/bg.png");
	texture_create(&texture_ui_input, "png/ui/input.png");
	texture_create(&texture_ui_box_empty, "png/ui/box_empty.png");
	texture_create(&texture_ui_box_check, "png/ui/box_check.png");
	texture_create(&texture_ui_collapsed, "png/ui/collapsed.png");
	texture_create(&texture_ui_expanded, "png/ui/expanded.png");
	texture_create(&texture_ui_flags, "png/ui/flags.png");
	texture_filter(&texture_ui_flags, TEXTURE_FILTER_LINEAR);
	texture_create(&texture_ui_alert, "png/ui/alert.png");
	texture_filter(&texture_ui_alert, TEXTURE_FILTER_LINEAR);

#ifdef USE_TOUCH
	texture_create(&texture_ui_knob, "png/ui/knob.png");
	texture_filter(&texture_ui_knob, TEXTURE_FILTER_LINEAR);
	texture_create(&texture_ui_joystick, "png/ui/joystick.png");
	texture_filter(&texture_ui_joystick, TEXTURE_FILTER_LINEAR);
#endif

	unsigned int pixels[64 * 64];
	memset(pixels, 0, sizeof(pixels));

	for(int y = 0; y < 8; y++) {
		for(int x = 0; x < 8; x++) {
			for(int ys = 0; ys < 6; ys++) {
				for(int xs = 0; xs < 6; xs++) {
					pixels[(x * 8 + xs) + (y * 8 + ys) * 64] = 0xFF000000 | texture_block_color(x, y);
				}
			}
		}
	}

	texture_create_buffer(&texture_color_selection, 64, 64, (unsigned char*)pixels, 1);

	texture_create_buffer(&texture_minimap, map_size_x, map_size_z, NULL, 1);

	unsigned int* gradient = malloc(512 * 512 * sizeof(unsigned int));
	CHECK_ALLOCATION_ERROR(gradient)
	texture_gradient_fog(gradient);
	texture_create_buffer(&texture_gradient, 512, 512, (unsigned char*)gradient, 1);
	texture_filter(&texture_gradient, TEXTURE_FILTER_LINEAR);

	texture_create_buffer(&texture_dummy, 1, 1, (unsigned char[]) {0, 0, 0, 0}, 1);
}