noobs 0.0.6

package/include/graphics/matrix4.h

@@ -0,0 +1,102 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program 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 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "vec3.h"
+#include "vec4.h"
+#include "axisang.h"
+
+/* 4x4 Matrix */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct matrix3;
+
+struct matrix4 {
+	struct vec4 x, y, z, t;
+};
+
+static inline void matrix4_copy(struct matrix4 *dst, const struct matrix4 *m)
+{
+	dst->x.m = m->x.m;
+	dst->y.m = m->y.m;
+	dst->z.m = m->z.m;
+	dst->t.m = m->t.m;
+}
+
+static inline void matrix4_identity(struct matrix4 *dst)
+{
+	vec4_zero(&dst->x);
+	vec4_zero(&dst->y);
+	vec4_zero(&dst->z);
+	vec4_zero(&dst->t);
+	dst->x.x = 1.0f;
+	dst->y.y = 1.0f;
+	dst->z.z = 1.0f;
+	dst->t.w = 1.0f;
+}
+
+EXPORT void matrix4_from_matrix3(struct matrix4 *dst, const struct matrix3 *m);
+EXPORT void matrix4_from_quat(struct matrix4 *dst, const struct quat *q);
+EXPORT void matrix4_from_axisang(struct matrix4 *dst, const struct axisang *aa);
+
+EXPORT void matrix4_mul(struct matrix4 *dst, const struct matrix4 *m1, const struct matrix4 *m2);
+
+EXPORT float matrix4_determinant(const struct matrix4 *m);
+
+EXPORT void matrix4_translate3v(struct matrix4 *dst, const struct matrix4 *m, const struct vec3 *v);
+EXPORT void matrix4_translate4v(struct matrix4 *dst, const struct matrix4 *m, const struct vec4 *v);
+EXPORT void matrix4_rotate(struct matrix4 *dst, const struct matrix4 *m, const struct quat *q);
+EXPORT void matrix4_rotate_aa(struct matrix4 *dst, const struct matrix4 *m, const struct axisang *aa);
+EXPORT void matrix4_scale(struct matrix4 *dst, const struct matrix4 *m, const struct vec3 *v);
+EXPORT bool matrix4_inv(struct matrix4 *dst, const struct matrix4 *m);
+EXPORT void matrix4_transpose(struct matrix4 *dst, const struct matrix4 *m);
+
+EXPORT void matrix4_translate3v_i(struct matrix4 *dst, const struct vec3 *v, const struct matrix4 *m);
+EXPORT void matrix4_translate4v_i(struct matrix4 *dst, const struct vec4 *v, const struct matrix4 *m);
+EXPORT void matrix4_rotate_i(struct matrix4 *dst, const struct quat *q, const struct matrix4 *m);
+EXPORT void matrix4_rotate_aa_i(struct matrix4 *dst, const struct axisang *aa, const struct matrix4 *m);
+EXPORT void matrix4_scale_i(struct matrix4 *dst, const struct vec3 *v, const struct matrix4 *m);
+
+static inline void matrix4_translate3f(struct matrix4 *dst, const struct matrix4 *m, float x, float y, float z)
+{
+	struct vec3 v;
+	vec3_set(&v, x, y, z);
+	matrix4_translate3v(dst, m, &v);
+}
+
+static inline void matrix4_rotate_aa4f(struct matrix4 *dst, const struct matrix4 *m, float x, float y, float z,
+				       float rot)
+{
+	struct axisang aa;
+	axisang_set(&aa, x, y, z, rot);
+	matrix4_rotate_aa(dst, m, &aa);
+}
+
+static inline void matrix4_scale3f(struct matrix4 *dst, const struct matrix4 *m, float x, float y, float z)
+{
+	struct vec3 v;
+	vec3_set(&v, x, y, z);
+	matrix4_scale(dst, m, &v);
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/plane.h

@@ -0,0 +1,85 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program 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 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "math-defs.h"
+#include "vec3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct matrix3;
+struct matrix4;
+
+struct plane {
+	struct vec3 dir;
+	float dist;
+};
+
+static inline void plane_copy(struct plane *dst, const struct plane *p)
+{
+	vec3_copy(&dst->dir, &p->dir);
+	dst->dist = p->dist;
+}
+
+static inline void plane_set(struct plane *dst, const struct vec3 *dir, float dist)
+{
+	vec3_copy(&dst->dir, dir);
+	dst->dist = dist;
+}
+
+static inline void plane_setf(struct plane *dst, float a, float b, float c, float d)
+{
+	vec3_set(&dst->dir, a, b, c);
+	dst->dist = d;
+}
+
+EXPORT void plane_from_tri(struct plane *dst, const struct vec3 *v1, const struct vec3 *v2, const struct vec3 *v3);
+
+EXPORT void plane_transform(struct plane *dst, const struct plane *p, const struct matrix4 *m);
+EXPORT void plane_transform3x4(struct plane *dst, const struct plane *p, const struct matrix3 *m);
+
+EXPORT bool plane_intersection_ray(const struct plane *p, const struct vec3 *orig, const struct vec3 *dir, float *t);
+EXPORT bool plane_intersection_line(const struct plane *p, const struct vec3 *v1, const struct vec3 *v2, float *t);
+
+EXPORT bool plane_tri_inside(const struct plane *p, const struct vec3 *v1, const struct vec3 *v2, const struct vec3 *v3,
+			     float precision);
+
+EXPORT bool plane_line_inside(const struct plane *p, const struct vec3 *v1, const struct vec3 *v2, float precision);
+
+static inline bool plane_close(const struct plane *p1, const struct plane *p2, float precision)
+{
+	return vec3_close(&p1->dir, &p2->dir, precision) && close_float(p1->dist, p2->dist, precision);
+}
+
+static inline bool plane_coplanar(const struct plane *p1, const struct plane *p2, float precision)
+{
+	float cos_angle = vec3_dot(&p1->dir, &p2->dir);
+
+	if (close_float(cos_angle, 1.0f, precision))
+		return close_float(p1->dist, p2->dist, precision);
+	else if (close_float(cos_angle, -1.0f, precision))
+		return close_float(-p1->dist, p2->dist, precision);
+
+	return false;
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/quat.h

@@ -0,0 +1,170 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program 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 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/c99defs.h"
+#include "math-defs.h"
+#include "vec3.h"
+
+#include "../util/sse-intrin.h"
+
+/*
+ * Quaternion math
+ *
+ *   Generally used to represent rotational data more than anything.  Allows
+ * for efficient and correct rotational interpolation without suffering from
+ * things like gimbal lock.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct matrix3;
+struct matrix4;
+struct axisang;
+
+struct quat {
+	union {
+		struct {
+			float x, y, z, w;
+		};
+		float ptr[4];
+		__m128 m;
+	};
+};
+
+static inline void quat_identity(struct quat *q)
+{
+	q->m = _mm_setzero_ps();
+	q->w = 1.0f;
+}
+
+static inline void quat_set(struct quat *dst, float x, float y, float z, float w)
+{
+	dst->m = _mm_set_ps(x, y, z, w);
+}
+
+static inline void quat_copy(struct quat *dst, const struct quat *q)
+{
+	dst->m = q->m;
+}
+
+static inline void quat_add(struct quat *dst, const struct quat *q1, const struct quat *q2)
+{
+	dst->m = _mm_add_ps(q1->m, q2->m);
+}
+
+static inline void quat_sub(struct quat *dst, const struct quat *q1, const struct quat *q2)
+{
+	dst->m = _mm_sub_ps(q1->m, q2->m);
+}
+
+EXPORT void quat_mul(struct quat *dst, const struct quat *q1, const struct quat *q2);
+
+static inline void quat_addf(struct quat *dst, const struct quat *q, float f)
+{
+	dst->m = _mm_add_ps(q->m, _mm_set1_ps(f));
+}
+
+static inline void quat_subf(struct quat *dst, const struct quat *q, float f)
+{
+	dst->m = _mm_sub_ps(q->m, _mm_set1_ps(f));
+}
+
+static inline void quat_mulf(struct quat *dst, const struct quat *q, float f)
+{
+	dst->m = _mm_mul_ps(q->m, _mm_set1_ps(f));
+}
+
+static inline void quat_divf(struct quat *dst, const struct quat *q, float f)
+{
+	dst->m = _mm_div_ps(q->m, _mm_set1_ps(f));
+}
+
+static inline float quat_dot(const struct quat *q1, const struct quat *q2)
+{
+	struct vec3 add;
+	__m128 mul = _mm_mul_ps(q1->m, q2->m);
+	add.m = _mm_add_ps(_mm_movehl_ps(mul, mul), mul);
+	add.m = _mm_add_ps(_mm_shuffle_ps(add.m, add.m, 0x55), add.m);
+	return add.x;
+}
+
+static inline void quat_inv(struct quat *dst, const struct quat *q)
+{
+	dst->x = -q->x;
+	dst->y = -q->y;
+	dst->z = -q->z;
+}
+
+static inline void quat_neg(struct quat *dst, const struct quat *q)
+{
+	dst->x = -q->x;
+	dst->y = -q->y;
+	dst->z = -q->z;
+	dst->w = -q->w;
+}
+
+static inline float quat_len(const struct quat *q)
+{
+	float dot_val = quat_dot(q, q);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline float quat_dist(const struct quat *q1, const struct quat *q2)
+{
+	struct quat temp;
+	float dot_val;
+
+	quat_sub(&temp, q1, q2);
+	dot_val = quat_dot(&temp, &temp);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline void quat_norm(struct quat *dst, const struct quat *q)
+{
+	float dot_val = quat_dot(q, q);
+	dst->m = (dot_val > 0.0f) ? _mm_mul_ps(q->m, _mm_set1_ps(1.0f / sqrtf(dot_val))) : _mm_setzero_ps();
+}
+
+static inline bool quat_close(const struct quat *q1, const struct quat *q2, float epsilon)
+{
+	struct quat test;
+	quat_sub(&test, q1, q2);
+	return test.x < epsilon && test.y < epsilon && test.z < epsilon && test.w < epsilon;
+}
+
+EXPORT void quat_from_axisang(struct quat *dst, const struct axisang *aa);
+EXPORT void quat_from_matrix3(struct quat *dst, const struct matrix3 *m);
+EXPORT void quat_from_matrix4(struct quat *dst, const struct matrix4 *m);
+
+EXPORT void quat_get_dir(struct vec3 *dst, const struct quat *q);
+EXPORT void quat_set_look_dir(struct quat *dst, const struct vec3 *dir);
+
+EXPORT void quat_log(struct quat *dst, const struct quat *q);
+EXPORT void quat_exp(struct quat *dst, const struct quat *q);
+
+EXPORT void quat_interpolate(struct quat *dst, const struct quat *q1, const struct quat *q2, float t);
+EXPORT void quat_get_tangent(struct quat *dst, const struct quat *prev, const struct quat *q, const struct quat *next);
+EXPORT void quat_interpolate_cubic(struct quat *dst, const struct quat *q1, const struct quat *q2,
+				   const struct quat *m1, const struct quat *m2, float t);
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/shader-parser.h

@@ -0,0 +1,273 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program 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 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/cf-parser.h"
+#include "graphics.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXPORT enum gs_shader_param_type get_shader_param_type(const char *type);
+EXPORT enum gs_sample_filter get_sample_filter(const char *filter);
+EXPORT enum gs_address_mode get_address_mode(const char *address_mode);
+
+/*
+ * Shader Parser
+ *
+ *   Parses a shader and extracts data such as shader constants, samplers,
+ * and vertex input information.  Also allows the reformatting of shaders for
+ * different libraries.  This is usually used only by graphics libraries,
+ */
+
+enum shader_var_type {
+	SHADER_VAR_NONE,
+	SHADER_VAR_IN = SHADER_VAR_NONE,
+	SHADER_VAR_INOUT,
+	SHADER_VAR_OUT,
+	SHADER_VAR_UNIFORM,
+	SHADER_VAR_CONST
+};
+
+struct shader_var {
+	char *type;
+	char *name;
+	char *mapping;
+	enum shader_var_type var_type;
+	int array_count;
+	size_t gl_sampler_id; /* optional: used/parsed by GL */
+
+	DARRAY(uint8_t) default_val;
+};
+
+static inline void shader_var_init(struct shader_var *sv)
+{
+	memset(sv, 0, sizeof(struct shader_var));
+}
+
+static inline void shader_var_init_param(struct shader_var *sv, char *type, char *name, bool is_uniform, bool is_const)
+{
+	if (is_uniform)
+		sv->var_type = SHADER_VAR_UNIFORM;
+	else if (is_const)
+		sv->var_type = SHADER_VAR_CONST;
+	else
+		sv->var_type = SHADER_VAR_NONE;
+
+	sv->type = type;
+	sv->name = name;
+	sv->mapping = NULL;
+	sv->array_count = 0;
+	sv->gl_sampler_id = (size_t)-1;
+	da_init(sv->default_val);
+}
+
+static inline void shader_var_free(struct shader_var *sv)
+{
+	bfree(sv->type);
+	bfree(sv->name);
+	bfree(sv->mapping);
+	da_free(sv->default_val);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct shader_sampler {
+	char *name;
+	DARRAY(char *) states;
+	DARRAY(char *) values;
+};
+
+static inline void shader_sampler_init(struct shader_sampler *ss)
+{
+	memset(ss, 0, sizeof(struct shader_sampler));
+}
+
+static inline void shader_sampler_free(struct shader_sampler *ss)
+{
+	size_t i;
+	for (i = 0; i < ss->states.num; i++)
+		bfree(ss->states.array[i]);
+	for (i = 0; i < ss->values.num; i++)
+		bfree(ss->values.array[i]);
+
+	bfree(ss->name);
+	da_free(ss->states);
+	da_free(ss->values);
+}
+
+EXPORT void shader_sampler_convert(struct shader_sampler *ss, struct gs_sampler_info *info);
+
+/* ------------------------------------------------------------------------- */
+
+struct shader_struct {
+	char *name;
+	DARRAY(struct shader_var) vars;
+};
+
+static inline void shader_struct_init(struct shader_struct *ss)
+{
+	memset(ss, 0, sizeof(struct shader_struct));
+}
+
+static inline void shader_struct_free(struct shader_struct *ss)
+{
+	size_t i;
+
+	for (i = 0; i < ss->vars.num; i++)
+		shader_var_free(ss->vars.array + i);
+
+	bfree(ss->name);
+	da_free(ss->vars);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct shader_func {
+	char *name;
+	char *return_type;
+	char *mapping;
+	DARRAY(struct shader_var) params;
+
+	struct cf_token *start, *end;
+};
+
+static inline void shader_func_init(struct shader_func *sf, char *return_type, char *name)
+{
+	da_init(sf->params);
+
+	sf->return_type = return_type;
+	sf->mapping = NULL;
+	sf->name = name;
+	sf->start = NULL;
+	sf->end = NULL;
+}
+
+static inline void shader_func_free(struct shader_func *sf)
+{
+	size_t i;
+
+	for (i = 0; i < sf->params.num; i++)
+		shader_var_free(sf->params.array + i);
+
+	bfree(sf->name);
+	bfree(sf->return_type);
+	bfree(sf->mapping);
+	da_free(sf->params);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct shader_parser {
+	struct cf_parser cfp;
+
+	DARRAY(struct shader_var) params;
+	DARRAY(struct shader_struct) structs;
+	DARRAY(struct shader_sampler) samplers;
+	DARRAY(struct shader_func) funcs;
+};
+
+static inline void shader_parser_init(struct shader_parser *sp)
+{
+	cf_parser_init(&sp->cfp);
+
+	da_init(sp->params);
+	da_init(sp->structs);
+	da_init(sp->samplers);
+	da_init(sp->funcs);
+}
+
+static inline void shader_parser_free(struct shader_parser *sp)
+{
+	size_t i;
+
+	for (i = 0; i < sp->params.num; i++)
+		shader_var_free(sp->params.array + i);
+	for (i = 0; i < sp->structs.num; i++)
+		shader_struct_free(sp->structs.array + i);
+	for (i = 0; i < sp->samplers.num; i++)
+		shader_sampler_free(sp->samplers.array + i);
+	for (i = 0; i < sp->funcs.num; i++)
+		shader_func_free(sp->funcs.array + i);
+
+	cf_parser_free(&sp->cfp);
+	da_free(sp->params);
+	da_free(sp->structs);
+	da_free(sp->samplers);
+	da_free(sp->funcs);
+}
+
+EXPORT bool shader_parse(struct shader_parser *sp, const char *shader, const char *file);
+
+static inline char *shader_parser_geterrors(struct shader_parser *sp)
+{
+	return error_data_buildstring(&sp->cfp.error_list);
+}
+
+static inline struct shader_var *shader_parser_getparam(struct shader_parser *sp, const char *param_name)
+{
+	size_t i;
+	for (i = 0; i < sp->params.num; i++) {
+		struct shader_var *param = sp->params.array + i;
+		if (strcmp(param->name, param_name) == 0)
+			return param;
+	}
+
+	return NULL;
+}
+
+static inline struct shader_struct *shader_parser_getstruct(struct shader_parser *sp, const char *struct_name)
+{
+	size_t i;
+	for (i = 0; i < sp->structs.num; i++) {
+		struct shader_struct *st = sp->structs.array + i;
+		if (strcmp(st->name, struct_name) == 0)
+			return st;
+	}
+
+	return NULL;
+}
+
+static inline struct shader_sampler *shader_parser_getsampler(struct shader_parser *sp, const char *sampler_name)
+{
+	size_t i;
+	for (i = 0; i < sp->samplers.num; i++) {
+		struct shader_sampler *sampler = sp->samplers.array + i;
+		if (strcmp(sampler->name, sampler_name) == 0)
+			return sampler;
+	}
+
+	return NULL;
+}
+
+static inline struct shader_func *shader_parser_getfunc(struct shader_parser *sp, const char *func_name)
+{
+	size_t i;
+	for (i = 0; i < sp->funcs.num; i++) {
+		struct shader_func *func = sp->funcs.array + i;
+		if (strcmp(func->name, func_name) == 0)
+			return func;
+	}
+
+	return NULL;
+}
+
+#ifdef __cplusplus
+}
+#endif