noobs 0.0.6

package/include/graphics/srgb.h

@@ -0,0 +1,177 @@
+/******************************************************************************
+    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.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static inline float gs_srgb_nonlinear_to_linear(float u)
+{
+	return (u <= 0.04045f) ? (u / 12.92f) : powf((u + 0.055f) / 1.055f, 2.4f);
+}
+
+static inline float gs_srgb_linear_to_nonlinear(float u)
+{
+	return (u <= 0.0031308f) ? (12.92f * u) : ((1.055f * powf(u, 1.0f / 2.4f)) - 0.055f);
+}
+
+static inline float gs_u8_to_float(uint8_t u)
+{
+	return (float)u / 255.0f;
+}
+
+static inline void gs_u8x4_to_float4(float *f, const uint8_t *u)
+{
+	f[0] = gs_u8_to_float(u[0]);
+	f[1] = gs_u8_to_float(u[1]);
+	f[2] = gs_u8_to_float(u[2]);
+	f[3] = gs_u8_to_float(u[3]);
+}
+
+static inline uint8_t gs_float_to_u8(float f)
+{
+	return (uint8_t)(f * 255.0f + 0.5f);
+}
+
+static inline void gs_premultiply_float4(float *f)
+{
+	f[0] *= f[3];
+	f[1] *= f[3];
+	f[2] *= f[3];
+}
+
+static inline void gs_float3_to_u8x3(uint8_t *u, const float *f)
+{
+	u[0] = gs_float_to_u8(f[0]);
+	u[1] = gs_float_to_u8(f[1]);
+	u[2] = gs_float_to_u8(f[2]);
+}
+
+static inline void gs_float4_to_u8x4(uint8_t *u, const float *f)
+{
+	u[0] = gs_float_to_u8(f[0]);
+	u[1] = gs_float_to_u8(f[1]);
+	u[2] = gs_float_to_u8(f[2]);
+	u[3] = gs_float_to_u8(f[3]);
+}
+
+static inline void gs_float3_srgb_nonlinear_to_linear(float *f)
+{
+	f[0] = gs_srgb_nonlinear_to_linear(f[0]);
+	f[1] = gs_srgb_nonlinear_to_linear(f[1]);
+	f[2] = gs_srgb_nonlinear_to_linear(f[2]);
+}
+
+static inline void gs_float3_srgb_linear_to_nonlinear(float *f)
+{
+	f[0] = gs_srgb_linear_to_nonlinear(f[0]);
+	f[1] = gs_srgb_linear_to_nonlinear(f[1]);
+	f[2] = gs_srgb_linear_to_nonlinear(f[2]);
+}
+
+static inline void gs_premultiply_xyza(uint8_t *data)
+{
+	uint8_t u[4];
+	float f[4];
+	memcpy(&u, data, sizeof(u));
+	gs_u8x4_to_float4(f, u);
+	gs_premultiply_float4(f);
+	gs_float3_to_u8x3(u, f);
+	memcpy(data, &u, sizeof(u));
+}
+
+static inline void gs_premultiply_xyza_srgb(uint8_t *data)
+{
+	uint8_t u[4];
+	float f[4];
+	memcpy(&u, data, sizeof(u));
+	gs_u8x4_to_float4(f, u);
+	gs_float3_srgb_nonlinear_to_linear(f);
+	gs_premultiply_float4(f);
+	gs_float3_srgb_linear_to_nonlinear(f);
+	gs_float3_to_u8x3(u, f);
+	memcpy(data, &u, sizeof(u));
+}
+
+static inline void gs_premultiply_xyza_restrict(uint8_t *__restrict dst, const uint8_t *__restrict src)
+{
+	uint8_t u[4];
+	float f[4];
+	memcpy(&u, src, sizeof(u));
+	gs_u8x4_to_float4(f, u);
+	gs_premultiply_float4(f);
+	gs_float3_to_u8x3(u, f);
+	memcpy(dst, &u, sizeof(u));
+}
+
+static inline void gs_premultiply_xyza_srgb_restrict(uint8_t *__restrict dst, const uint8_t *__restrict src)
+{
+	uint8_t u[4];
+	float f[4];
+	memcpy(&u, src, sizeof(u));
+	gs_u8x4_to_float4(f, u);
+	gs_float3_srgb_nonlinear_to_linear(f);
+	gs_premultiply_float4(f);
+	gs_float3_srgb_linear_to_nonlinear(f);
+	gs_float3_to_u8x3(u, f);
+	memcpy(dst, &u, sizeof(u));
+}
+
+static inline void gs_premultiply_xyza_loop(uint8_t *data, size_t texel_count)
+{
+	for (size_t i = 0; i < texel_count; ++i) {
+		gs_premultiply_xyza(data);
+		data += 4;
+	}
+}
+
+static inline void gs_premultiply_xyza_srgb_loop(uint8_t *data, size_t texel_count)
+{
+	for (size_t i = 0; i < texel_count; ++i) {
+		gs_premultiply_xyza_srgb(data);
+		data += 4;
+	}
+}
+
+static inline void gs_premultiply_xyza_loop_restrict(uint8_t *__restrict dst, const uint8_t *__restrict src,
+						     size_t texel_count)
+{
+	for (size_t i = 0; i < texel_count; ++i) {
+		gs_premultiply_xyza_restrict(dst, src);
+		dst += 4;
+		src += 4;
+	}
+}
+
+static inline void gs_premultiply_xyza_srgb_loop_restrict(uint8_t *__restrict dst, const uint8_t *__restrict src,
+							  size_t texel_count)
+{
+	for (size_t i = 0; i < texel_count; ++i) {
+		gs_premultiply_xyza_srgb_restrict(dst, src);
+		dst += 4;
+		src += 4;
+	}
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/vec2.h

@@ -0,0 +1,148 @@
+/******************************************************************************
+    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.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct vec2 {
+	union {
+		struct {
+			float x, y;
+		};
+		float ptr[2];
+	};
+};
+
+static inline void vec2_zero(struct vec2 *dst)
+{
+	dst->x = 0.0f;
+	dst->y = 0.0f;
+}
+
+static inline void vec2_set(struct vec2 *dst, float x, float y)
+{
+	dst->x = x;
+	dst->y = y;
+}
+
+static inline void vec2_copy(struct vec2 *dst, const struct vec2 *v)
+{
+	dst->x = v->x;
+	dst->y = v->y;
+}
+
+static inline void vec2_add(struct vec2 *dst, const struct vec2 *v1, const struct vec2 *v2)
+{
+	vec2_set(dst, v1->x + v2->x, v1->y + v2->y);
+}
+
+static inline void vec2_sub(struct vec2 *dst, const struct vec2 *v1, const struct vec2 *v2)
+{
+	vec2_set(dst, v1->x - v2->x, v1->y - v2->y);
+}
+
+static inline void vec2_mul(struct vec2 *dst, const struct vec2 *v1, const struct vec2 *v2)
+{
+	vec2_set(dst, v1->x * v2->x, v1->y * v2->y);
+}
+
+static inline void vec2_div(struct vec2 *dst, const struct vec2 *v1, const struct vec2 *v2)
+{
+	vec2_set(dst, v1->x / v2->x, v1->y / v2->y);
+}
+
+static inline void vec2_addf(struct vec2 *dst, const struct vec2 *v, float f)
+{
+	vec2_set(dst, v->x + f, v->y + f);
+}
+
+static inline void vec2_subf(struct vec2 *dst, const struct vec2 *v, float f)
+{
+	vec2_set(dst, v->x - f, v->y - f);
+}
+
+static inline void vec2_mulf(struct vec2 *dst, const struct vec2 *v, float f)
+{
+	vec2_set(dst, v->x * f, v->y * f);
+}
+
+static inline void vec2_divf(struct vec2 *dst, const struct vec2 *v, float f)
+{
+	vec2_set(dst, v->x / f, v->y / f);
+}
+
+static inline void vec2_neg(struct vec2 *dst, const struct vec2 *v)
+{
+	vec2_set(dst, -v->x, -v->y);
+}
+
+static inline float vec2_dot(const struct vec2 *v1, const struct vec2 *v2)
+{
+	return v1->x * v2->x + v1->y * v2->y;
+}
+
+static inline float vec2_len(const struct vec2 *v)
+{
+	return sqrtf(v->x * v->x + v->y * v->y);
+}
+
+static inline float vec2_dist(const struct vec2 *v1, const struct vec2 *v2)
+{
+	struct vec2 temp;
+	vec2_sub(&temp, v1, v2);
+	return vec2_len(&temp);
+}
+
+static inline void vec2_minf(struct vec2 *dst, const struct vec2 *v, float val)
+{
+	dst->x = (v->x < val) ? v->x : val;
+	dst->y = (v->y < val) ? v->y : val;
+}
+
+static inline void vec2_min(struct vec2 *dst, const struct vec2 *v, const struct vec2 *min_v)
+{
+	dst->x = (v->x < min_v->x) ? v->x : min_v->x;
+	dst->y = (v->y < min_v->y) ? v->y : min_v->y;
+}
+
+static inline void vec2_maxf(struct vec2 *dst, const struct vec2 *v, float val)
+{
+	dst->x = (v->x > val) ? v->x : val;
+	dst->y = (v->y > val) ? v->y : val;
+}
+
+static inline void vec2_max(struct vec2 *dst, const struct vec2 *v, const struct vec2 *max_v)
+{
+	dst->x = (v->x > max_v->x) ? v->x : max_v->x;
+	dst->y = (v->y > max_v->y) ? v->y : max_v->y;
+}
+
+EXPORT void vec2_abs(struct vec2 *dst, const struct vec2 *v);
+EXPORT void vec2_floor(struct vec2 *dst, const struct vec2 *v);
+EXPORT void vec2_ceil(struct vec2 *dst, const struct vec2 *v);
+EXPORT int vec2_close(const struct vec2 *v1, const struct vec2 *v2, float epsilon);
+EXPORT void vec2_norm(struct vec2 *dst, const struct vec2 *v);
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/vec3.h

@@ -0,0 +1,224 @@
+/******************************************************************************
+    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 "vec4.h"
+
+#include "../util/sse-intrin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct plane;
+struct matrix3;
+struct matrix4;
+struct quat;
+
+struct vec3 {
+	union {
+		struct {
+			float x, y, z, w;
+		};
+		float ptr[4];
+		__m128 m;
+	};
+};
+
+static inline void vec3_zero(struct vec3 *v)
+{
+	v->m = _mm_setzero_ps();
+}
+
+static inline void vec3_set(struct vec3 *dst, float x, float y, float z)
+{
+	dst->m = _mm_set_ps(0.0f, z, y, x);
+}
+
+static inline void vec3_copy(struct vec3 *dst, const struct vec3 *v)
+{
+	dst->m = v->m;
+}
+
+EXPORT void vec3_from_vec4(struct vec3 *dst, const struct vec4 *v);
+
+static inline void vec3_add(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_add_ps(v1->m, v2->m);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_sub(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_sub_ps(v1->m, v2->m);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_mul(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_mul_ps(v1->m, v2->m);
+}
+
+static inline void vec3_div(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_div_ps(v1->m, v2->m);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_addf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_add_ps(v->m, _mm_set1_ps(f));
+	dst->w = 0.0f;
+}
+
+static inline void vec3_subf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_sub_ps(v->m, _mm_set1_ps(f));
+	dst->w = 0.0f;
+}
+
+static inline void vec3_mulf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_mul_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec3_divf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_div_ps(v->m, _mm_set1_ps(f));
+	dst->w = 0.0f;
+}
+
+static inline float vec3_dot(const struct vec3 *v1, const struct vec3 *v2)
+{
+	struct vec3 add;
+	__m128 mul = _mm_mul_ps(v1->m, v2->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 vec3_cross(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	__m128 s1v1 = _mm_shuffle_ps(v1->m, v1->m, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 s1v2 = _mm_shuffle_ps(v2->m, v2->m, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 s2v1 = _mm_shuffle_ps(v1->m, v1->m, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 s2v2 = _mm_shuffle_ps(v2->m, v2->m, _MM_SHUFFLE(3, 0, 2, 1));
+	dst->m = _mm_sub_ps(_mm_mul_ps(s1v1, s1v2), _mm_mul_ps(s2v1, s2v2));
+}
+
+static inline void vec3_neg(struct vec3 *dst, const struct vec3 *v)
+{
+	dst->x = -v->x;
+	dst->y = -v->y;
+	dst->z = -v->z;
+	dst->w = 0.0f;
+}
+
+static inline float vec3_len(const struct vec3 *v)
+{
+	float dot_val = vec3_dot(v, v);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline float vec3_dist(const struct vec3 *v1, const struct vec3 *v2)
+{
+	struct vec3 temp;
+	float dot_val;
+
+	vec3_sub(&temp, v1, v2);
+	dot_val = vec3_dot(&temp, &temp);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline void vec3_norm(struct vec3 *dst, const struct vec3 *v)
+{
+	float dot_val = vec3_dot(v, v);
+	dst->m = (dot_val > 0.0f) ? _mm_mul_ps(v->m, _mm_set1_ps(1.0f / sqrtf(dot_val))) : _mm_setzero_ps();
+}
+
+static inline bool vec3_close(const struct vec3 *v1, const struct vec3 *v2, float epsilon)
+{
+	struct vec3 test;
+	vec3_sub(&test, v1, v2);
+	return test.x < epsilon && test.y < epsilon && test.z < epsilon;
+}
+
+static inline void vec3_min(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_min_ps(v1->m, v2->m);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_minf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_min_ps(v->m, _mm_set1_ps(f));
+	dst->w = 0.0f;
+}
+
+static inline void vec3_max(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
+{
+	dst->m = _mm_max_ps(v1->m, v2->m);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_maxf(struct vec3 *dst, const struct vec3 *v, float f)
+{
+	dst->m = _mm_max_ps(v->m, _mm_set1_ps(f));
+	dst->w = 0.0f;
+}
+
+static inline void vec3_abs(struct vec3 *dst, const struct vec3 *v)
+{
+	dst->x = fabsf(v->x);
+	dst->y = fabsf(v->y);
+	dst->z = fabsf(v->z);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_floor(struct vec3 *dst, const struct vec3 *v)
+{
+	dst->x = floorf(v->x);
+	dst->y = floorf(v->y);
+	dst->z = floorf(v->z);
+	dst->w = 0.0f;
+}
+
+static inline void vec3_ceil(struct vec3 *dst, const struct vec3 *v)
+{
+	dst->x = ceilf(v->x);
+	dst->y = ceilf(v->y);
+	dst->z = ceilf(v->z);
+	dst->w = 0.0f;
+}
+
+EXPORT float vec3_plane_dist(const struct vec3 *v, const struct plane *p);
+
+EXPORT void vec3_transform(struct vec3 *dst, const struct vec3 *v, const struct matrix4 *m);
+
+EXPORT void vec3_rotate(struct vec3 *dst, const struct vec3 *v, const struct matrix3 *m);
+EXPORT void vec3_transform3x4(struct vec3 *dst, const struct vec3 *v, const struct matrix3 *m);
+
+EXPORT void vec3_mirror(struct vec3 *dst, const struct vec3 *v, const struct plane *p);
+EXPORT void vec3_mirrorv(struct vec3 *dst, const struct vec3 *v, const struct vec3 *vec);
+
+EXPORT void vec3_rand(struct vec3 *dst, int positive_only);
+
+#ifdef __cplusplus
+}
+#endif