bilbo/sandbox-intersection
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
sandbox-intersection/main.cpp
Zack Buhman 71021e3388 model collision demo
2025-04-15 15:11:37 -05:00

815 lines
20 KiB
C++
Raw Permalink Blame History

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <math.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <SDL3/SDL.h>
#include "math/vec2.hpp"
#include "math/vec3.hpp"
#include "math/vec4.hpp"
#include "math/mat3x3.hpp"
#include "math/mat4x4.hpp"
using vec2 = vec<2, float>;
using vec3 = vec<3, float>;
using vec4 = vec<4, float>;
using mat3x3 = mat<3, 3, float>;
using mat4x4 = mat<4, 4, float>;
using vertex_position = vec<3, float>;
using vertex_normal = vec<3, float>;
using vertex_texture = vec<2, float>;
#include "model_collision.h"
struct glyph {
int32_t width;
int32_t height;
int32_t horiBearingX;
int32_t horiBearingY;
int32_t horiAdvance;
SDL_Texture * texture;
};
static struct glyph glyphs[0x80 - 0x20] = {0};
int32_t face_height;
int
load_outline_char(SDL_Renderer * renderer,
const FT_Face face,
const FT_Int32 load_flags,
const FT_Render_Mode render_mode,
const FT_ULong char_code)
{
FT_Error error;
FT_UInt glyph_index = FT_Get_Char_Index(face, char_code);
error = FT_Load_Glyph(face, glyph_index, load_flags);
if (error) {
printf("FT_Load_Glyph %s\n", FT_Error_String(error));
return -1;
}
error = FT_Render_Glyph(face->glyph, render_mode);
if (error) {
printf("FT_Render_Glyph %s\n", FT_Error_String(error));
return -1;
}
struct glyph * glyph = &glyphs[char_code - 0x20];
glyph->width = face->glyph->bitmap.width;
glyph->height = face->glyph->bitmap.rows;
glyph->horiBearingX = face->glyph->metrics.horiBearingX;
glyph->horiBearingY = face->glyph->metrics.horiBearingY;
glyph->horiAdvance = face->glyph->metrics.horiAdvance;
if (face->glyph->bitmap.pitch != 0) {
SDL_Surface * surface = SDL_CreateSurface(face->glyph->bitmap.width,
face->glyph->bitmap.rows,
SDL_PIXELFORMAT_RGBA8888);
SDL_LockSurface(surface);
for (unsigned int y = 0; y < face->glyph->bitmap.rows; y++) {
for (unsigned int x = 0; x < face->glyph->bitmap.width; x++) {
int s_ix = y * face->glyph->bitmap.pitch + x;
int d_ix = y * surface->pitch + x * 4;
uint8_t gray = face->glyph->bitmap.buffer[s_ix];
((uint8_t *)surface->pixels)[d_ix + 0] = gray;
((uint8_t *)surface->pixels)[d_ix + 1] = gray;
((uint8_t *)surface->pixels)[d_ix + 2] = gray;
((uint8_t *)surface->pixels)[d_ix + 3] = 255;
}
}
SDL_UnlockSurface(surface);
if (glyph->texture != NULL)
SDL_DestroyTexture(glyph->texture);
glyph->texture = SDL_CreateTextureFromSurface(renderer, surface);
if (glyph->texture == NULL) {
printf("%s\n", SDL_GetError());
}
assert(glyph->texture != NULL);
SDL_DestroySurface(surface);
}
return 0;
}
int load_font(SDL_Renderer * renderer, int font_size)
{
FT_Library library;
FT_Face face;
FT_Error error;
error = FT_Init_FreeType(&library);
if (error) {
printf("FT_Init_FreeType\n");
return -1;
}
error = FT_New_Face(library, "/home/bilbo/timer/DejaVuSansMono.ttf", 0, &face);
if (error) {
printf("FT_New_Face\n");
return -1;
}
error = FT_Set_Pixel_Sizes(face, 0, font_size);
if (error) {
printf("FT_Set_Pixel_Sizes: %s %d\n", FT_Error_String(error), error);
return -1;
}
for (int char_code = 0x20; char_code <= 0x7f; char_code++) {
load_outline_char(renderer, face, FT_LOAD_DEFAULT, FT_RENDER_MODE_NORMAL, char_code);
}
printf("loaded size %ld\n", face->size->metrics.height >> 6);
face_height = face->size->metrics.height;
return 0;
}
int32_t render_text(SDL_Renderer * renderer, int32_t x, int32_t y, const char * s, int length)
{
int32_t x_advance = x;
int32_t y_advance = y;
for (int i = 0; i < length; i++) {
char c = s[i];
struct glyph * glyph = &glyphs[c - 0x20];
x_advance += glyph->horiAdvance;
if (glyph->texture != NULL) {
float x = (float)(x_advance + glyph->horiBearingX) / 64.f;
float y = (float)(y_advance - glyph->horiBearingY) / 64.f;
SDL_FRect srect = {
.x = 0.f,
.y = 0.f,
.w = (float)glyph->width,
.h = (float)glyph->height
};
SDL_FRect drect = {
.x = x,
.y = y,
.w = (float)glyph->width,
.h = (float)glyph->height
};
SDL_RenderTexture(renderer, glyph->texture, &srect, &drect);
}
}
return x_advance;
}
struct line3 {
vec3 a;
vec3 b;
};
constexpr int num_lines = 5;
struct state {
struct line3 line[num_lines];
vec3 normal;
vec3 mouse_position;
};
struct state state = {
.line = {
{{ 0, -0.5, 0 }, { 0, 0.5, 0 }},
{{ 0, -0.5, -0.5 }, { 0, 0.5, -0.5 }},
{{ 0, -0.5, 0.5 }, { 0, 0.5, 0.5 }},
{{ 0, 0.5, 0.5 }, { 0, 0.5, -0.5 }},
{{ 0, -0.5, 0.5 }, { 0, -0.5, -0.5 }},
},
.normal = { -1, 0, 0 },
};
struct edge_normal {
struct line3 edge;
vec3 normal;
};
struct edge_normal quad[4] = {
{
.edge = {{-1, -1, 0}, { 1, -1, 0}},
.normal = {0, -1, 0},
},
{
.edge = {{ 1, -1, 0}, { 1, 1, 0}},
.normal = {1, 0, 0},
},
{
.edge = {{ 1, 1, 0}, {-1, 1, 0}},
.normal = {0, 1, 0},
},
{
.edge = {{-1, 1, 0}, {-1, -1, 0}},
.normal = {-1, 0, 0},
},
};
static int window_width = 1;
static int window_height = 1;
static inline int max(int a, int b)
{
return (a > b) ? a : b;
}
static inline int min(int a, int b)
{
return (a > b) ? b : a;
}
const float deg = 0.017453292519943295;
float deg45 = 0.7853981633974483;
static float vtheta = 0.5;
mat4x4 trans;
vec3 screen_transform_vertex(vec3 v)
{
float dim = ((float)min(window_height, window_width)) / 2.0f;
return {
v.x * dim + window_width / 2.0f,
v.y * dim + window_height / 2.0f,
v.z,
};
}
vec3 _transform_vertex(vec3 v, float w)
{
vec4 v4 = {v.x, v.y, v.z, w};
vec4 v4t = trans * v4;
return {v4t.x, v4t.y, v4t.z};
}
vec3 transform_vertex(vec3 v, float scale)
{
return screen_transform_vertex(_transform_vertex(v * scale, 1.0f));
}
vec3 inverse_transform(float x, float y)
{
float dim = ((float)min(window_height, window_width)) / 2.0f;
assert(dim != 0);
return {
-(window_width - 2 * x) / (2 * dim),
-(window_height - 2 * y) / (2 * dim),
0,
};
}
struct line3 transform_line(struct line3 line, float scale)
{
return {
transform_vertex(line.a, scale),
transform_vertex(line.b, scale),
};
}
static inline void render_line(SDL_Renderer * renderer, struct line3 line)
{
assert(SDL_RenderLine(renderer, line.a.x, line.a.y, line.b.x, line.b.y));
}
static inline void render_line_vtx(SDL_Renderer * renderer, vec3 a, vec3 b)
{
assert(SDL_RenderLine(renderer, a.x, a.y, b.x, b.y));
}
void render_basis(SDL_Renderer * renderer)
{
// magenta: Z
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0, 1, 1));
render_line(renderer, transform_line({{0, 0, 0}, {0, 0, 1}}, 1.0f));
// yellow: Y
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 1, 0, 1));
render_line(renderer, transform_line({{0, 0, 0}, {0, 1, 0}}, 1.0f));
// cyan: X
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 1, 1, 1));
render_line(renderer, transform_line({{0, 0, 0}, {1, 0, 0}}, 1.0f));
vec3 z = transform_vertex({0, 0, 1}, 1.1);
vec3 y = transform_vertex({0, 1, 0}, 1.1);
vec3 x = transform_vertex({1, 0, 0}, 1.1);
render_text(renderer, ((z.x - 30) * 64), ((z.y + 10) * 64), "+z", 2);
render_text(renderer, ((y.x - 30) * 64), ((y.y + 10) * 64), "+y", 2);
render_text(renderer, ((x.x - 30) * 64), ((x.y + 10) * 64), "+x", 2);
}
vec3 update_light(SDL_Renderer * renderer)
{
static float ltheta = 0;
vec3 light_origin = {0, 0, 0};
vec3 light_pos = {1, 1, 1};
mat3x3 rot = {
cos(ltheta), -sin(ltheta), 0,
sin(ltheta), cos(ltheta), 0,
0, 0, 1,
};
light_pos = rot * light_pos;
ltheta += deg / 4;
vec3 light_vec = light_origin - light_pos;
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 1, 0, 1));
render_line(renderer, transform_line({light_origin, light_pos}, 0.5f));
return light_vec;
}
void _render_quad(SDL_Renderer * renderer, vec3 light_vec)
{
for (int i = 0; i < 4; i++) {
float d = dot(light_vec, quad[i].normal);
if (d > 0)
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 1, 1, 1));
else
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 0, 1, 1));
render_line(renderer, transform_line(quad[i].edge, 0.25f));
vec3 origin = (quad[i].edge.a + quad[i].edge.b) / 2.0f;
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0, 0, 1));
render_line(renderer, transform_line({origin, origin + quad[i].normal}, 0.25f));
}
}
void set_edge_coloring(uint8_t * edge_coloring,
const int edge_stride,
float l_dot_n, int a, int b)
{
bool d = l_dot_n > 0;
int ma = min(a, b);
int mb = max(a, b);
int bit = 1 << ((int)d);
edge_coloring[ma * edge_stride + mb] |= bit;
}
mat4x4 translate(const vec3 v)
{
return (mat4x4){
1, 0, 0, v.x,
0, 1, 0, v.y,
0, 0, 1, v.z,
0, 0, 0, 1,
};
}
void render_quad(SDL_Renderer * renderer,
const vec3 * position,
const vec3 * normal,
const quadrilateral * quadrilateral,
const vec3 light_vec,
uint8_t * edge_coloring,
const int edge_stride)
{
vec3 n = normal[quadrilateral->a.normal];
float l_dot_n = dot(light_vec, n);
if (l_dot_n > 0)
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 1, 1, 1));
else
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 0, 1, 1));
float scale = 0.5f;
set_edge_coloring(edge_coloring,
edge_stride,
l_dot_n,
quadrilateral->a.position,
quadrilateral->b.position);
set_edge_coloring(edge_coloring,
edge_stride,
l_dot_n,
quadrilateral->b.position,
quadrilateral->c.position);
set_edge_coloring(edge_coloring,
edge_stride,
l_dot_n,
quadrilateral->c.position,
quadrilateral->d.position);
set_edge_coloring(edge_coloring,
edge_stride,
l_dot_n,
quadrilateral->d.position,
quadrilateral->a.position);
vec3 ap = position[quadrilateral->a.position];
vec3 bp = position[quadrilateral->b.position];
vec3 cp = position[quadrilateral->c.position];
vec3 dp = position[quadrilateral->d.position];
vec3 n10 = n * 0.1f;
vec3 a = transform_vertex(ap + n10, scale);
vec3 b = transform_vertex(bp + n10, scale);
vec3 c = transform_vertex(cp + n10, scale);
vec3 d = transform_vertex(dp + n10, scale);
render_line_vtx(renderer, a, b);
render_line_vtx(renderer, b, c);
render_line_vtx(renderer, c, d);
render_line_vtx(renderer, d, a);
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0, 0, 1));
vec3 origin = (position[quadrilateral->a.position] +
position[quadrilateral->b.position] +
position[quadrilateral->c.position] +
position[quadrilateral->d.position]) / 4.0f;
vec3 origin_t = transform_vertex(origin, scale);
vec3 origin_n_t = transform_vertex(origin + n, scale);
render_line_vtx(renderer, origin_t, origin_n_t);
}
void render_silhouette(SDL_Renderer * renderer,
const vec3 * position,
const uint8_t * edge_coloring,
const int edge_stride)
{
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0.5, 0, 1));
for (int a = 0; a < edge_stride; a++) {
for (int b = 0; b < edge_stride; b++) {
uint8_t coloring = edge_coloring[a * edge_stride + b];
if (coloring == 0b11) {
vec3 ap = position[a];
vec3 bp = position[b];
float scale = 0.5f;
vec3 av = transform_vertex(ap, scale);
vec3 bv = transform_vertex(bp, scale);
render_line_vtx(renderer, av, bv);
}
}
}
}
mat3x3 rotate_to(vec3 old_normal, vec3 new_normal)
{
vec3 s = cross(old_normal, new_normal);
float c = dot(old_normal, new_normal);
mat3x3 i = mat3x3();
mat3x3 v = {
0, -s.z, s.y,
s.z, 0, -s.x,
-s.y, s.x, 0,
};
float mag = magnitude(s);
mat3x3 v2 = v * v;
float c_mag2 = (1 - c) / (mag * mag);
mat3x3 v2_c_mag2 = (v2 * c_mag2);
mat3x3 t = i + v + v2_c_mag2;
return t;
}
mat4x4 look_at(vec3 eye, vec3 center, vec3 up)
{
vec3 x;
vec3 y;
vec3 z;
z = eye - center;
z = z / magnitude(z);
y = up;
x = cross(y, z);
y = cross(z, x);
x = x / magnitude(x);
y = y / magnitude(y);
mat4x4 t = {
x.x, x.y, x.z, -dot(x, eye),
y.x, y.y, y.z, -dot(y, eye),
z.x, z.y, z.z, -dot(z, eye),
0, 0, 0, 1.0f
};
return t;
}
void render_lines(SDL_Renderer * renderer)
{
// line
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0.5, 0.5, 1));
for (int i = 0; i < num_lines; i++) {
struct line3 tl = transform_line(state.line[i], 1.0f);
render_line(renderer, tl);
}
// normal
assert(SDL_SetRenderDrawColorFloat(renderer, 1, 0, 0, 1));
struct line3 normal_line = {{0, 0, 0}, state.normal};
render_line(renderer, transform_line(normal_line, 0.5f));
// mouse
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 0, 1, 1));
struct line3 mouse_line = {{0, 0, 0}, state.mouse_position};
render_line(renderer, transform_line(mouse_line, 0.5f));
// foo
mat3x3 t = rotate_to(state.normal, -state.mouse_position);
vec3 nr = t * state.normal;
//mat4x4 t = look_at({0, 0, 0}, state.mouse_position - state.normal, {0, 0, 1});
//vec4 nr4 = t * (vec4){state.normal.x, state.normal.y, state.normal.z, 0};
//vec3 nr = {nr.x, nr.y, nr.z};
assert(SDL_SetRenderDrawColorFloat(renderer, 0, 1, 0, 1));
struct line3 nr_line = {{0, 0, 0}, nr};
render_line(renderer, transform_line(nr_line, 0.5f));
{
assert(SDL_SetRenderDrawColorFloat(renderer, 0.5, 1, 0.5, 1));
for (int i = 0; i < num_lines; i++) {
struct line3 l = state.line[i];
/*
vec4 a4 = t * l.a;
vec4 b4 = t * l.b;
vec3 a = {a4.x, a4.y, a4.z};
vec3 b = {b4.x, b4.y, b4.z};
*/
vec3 a = t * l.a;
vec3 b = t * l.b;
struct line3 tl = {a, b};
render_line(renderer, transform_line(tl, 1.0f));
}
}
}
void render_text_state(SDL_Renderer * renderer)
{
int32_t x_advance = 10 << 6;
int32_t y_advance = face_height;
x_advance = render_text(renderer, x_advance, y_advance, "dot: ", 5);
//float d = dot(state.normal, state.mouse_position);
/*
float d = dot({0, 1}, state.mouse_position);
char buf[64];
int len = snprintf(buf, 64, "%.03f", d);
x_advance = render_text(renderer, x_advance, y_advance, buf, len);
*/
}
bool collided[256] = {0};
void render_collision(SDL_Renderer * renderer)
{
const struct model * model = &haunted_mansion_collision_model;
const struct object * object = &haunted_mansion_collision_house_coll_display;
float scale = 1.f;
for (int i = 0; i < object->line_count; i++) {
const union line * line = &object->line[i];
if (collided[i])
SDL_SetRenderDrawColor(renderer, 255, 100, 100, 255);
else
SDL_SetRenderDrawColor(renderer, 100, 100, 255, 255);
render_line_vtx(renderer,
transform_vertex(model->position[line->a], scale),
transform_vertex(model->position[line->b], scale));
}
}
static float theta = 0;
void update_mouse_position()
{
vec3 pos = {0, 1, 1};
pos = pos / magnitude(pos);
mat3x3 rot1 = {
cos(theta), -sin(theta), 0,
sin(theta), cos(theta), 0,
0, 0, 1,
};
state.mouse_position = rot1 * pos;
theta += deg;
}
vec2 line_intersection(vec2 a1, vec2 a2,
vec2 b1, vec2 b2)
{
float x1 = a1.x;
float y1 = a1.y;
float x2 = a2.x;
float y2 = a2.y;
float x3 = b1.x;
float y3 = b1.y;
float x4 = b2.x;
float y4 = b2.y;
float x1x2 = x1 - x2;
float x1x3 = x1 - x3;
float x3x4 = x3 - x4;
float y1y2 = y1 - y2;
float y1y3 = y1 - y3;
float y3y4 = y3 - y4;
float div = 1.0f / (x1x2 * y3y4 - y1y2 * x3x4);
float t = (x1x3 * y3y4 - y1y3 * x3x4) * div;
float u = -(x1x2 * y1y3 - y1y2 * x1x3) * div;
return {t, u};
}
bool line_has_collision(vec3 a1, vec3 a2)
{
const struct model * model = &haunted_mansion_collision_model;
const struct object * object = &haunted_mansion_collision_house_coll_display;
for (int i = 0; i < object->line_count; i++) {
const union line * line = &object->line[i];
vec3 b1 = _transform_vertex(model->position[line->a], 1.0f);
vec3 b2 = _transform_vertex(model->position[line->b], 1.0f);
vec2 tu = line_intersection({a1.x, a1.y},
{a2.x, a2.y},
{b1.x, b1.y},
{b2.x, b2.y});
if (tu.x >= 0.0f && tu.x <= 1.0f && tu.y >= 0.0f && tu.y <= 1.0f) {
collided[i] = true;
return true;
}
}
return false;
}
void move(SDL_Renderer * renderer, vec3 direction)
{
SDL_SetRenderDrawColor(renderer, 128, 255, 50, 255);
render_line_vtx(renderer,
screen_transform_vertex({0, 0, 0}),
screen_transform_vertex(-direction * 2.0f));
if (!line_has_collision({0, 0, 0}, -direction * 1.0f))
trans = translate(direction) * trans;
}
int main()
{
SDL_Window * window;
SDL_Renderer * renderer;
bool success = SDL_Init(SDL_INIT_VIDEO);
if (!success) printf("error: `%s`\n", SDL_GetError());
assert(success == true);
window = SDL_CreateWindow("sandbox",
640, // w
480, // h
SDL_WINDOW_RESIZABLE);// | SDL_WINDOW_MAXIMIZED);
int num_drivers = SDL_GetNumRenderDrivers();
printf("available drivers:\n");
for (int i = 0; i < num_drivers; i++) {
const char * s = SDL_GetRenderDriver(i);
printf(" %s\n", s);
}
renderer = SDL_CreateRenderer(window, "opengles2");
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
const char * name = SDL_GetRendererName(renderer);
assert(name != NULL);
printf("renderer: %s\n", name);
const SDL_PixelFormat * formats = (const SDL_PixelFormat *)SDL_GetPointerProperty(props, SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, NULL);
assert(formats != NULL);
while (*formats != SDL_PIXELFORMAT_UNKNOWN) {
printf("%s\n", SDL_GetPixelFormatName(*formats++));
}
uint64_t ticks = SDL_GetTicks();
int font_size = 25;
load_font(renderer, font_size);
trans = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
};
trans = trans * 0.2f;
mat4x4 rot1 = {
cos(deg45), -sin(deg45), 0, 0,
sin(deg45), cos(deg45), 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
};
mat4x4 rot2 = {
1, 0, 0, 0,
0, cos(deg45), -sin(deg45), 0,
0, sin(deg45), cos(deg45), 0,
0, 0, 0, 1,
};
mat4x4 rot3 = {
cos(-deg45), 0, sin(-deg45), 0,
0, 1, 0, 0,
sin(-deg45), 0, cos(-deg45), 0,
0, 0, 0, 1,
};
(void)rot1; (void)rot2; (void)rot3;
trans = rot2 * rot1 * trans;
while (1) {
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
bool success = SDL_GetWindowSizeInPixels(window, &window_width, &window_height);
assert(success == true);
render_text_state(renderer);
render_basis(renderer);
render_collision(renderer);
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_EVENT_QUIT:
goto exit;
case SDL_EVENT_KEY_DOWN:
if (event.key.key == SDLK_ESCAPE)
goto exit;
if (event.key.key == SDLK_LEFT)
move(renderer, {0.03, 0.0, 0.0});
if (event.key.key == SDLK_RIGHT)
move(renderer, {-0.03, 0.0, 0.0});
if (event.key.key == SDLK_UP)
move(renderer, {0.0, 0.03, 0.0});
if (event.key.key == SDLK_DOWN)
move(renderer, {0.0, -0.03, 0.0});
break;
case SDL_EVENT_MOUSE_BUTTON_DOWN:
if (event.button.button == 1) {
//vec3 mv = inverse_transform(event.button.x, event.button.y);
//float m = magnitude(mv);
//state.mouse_position = mv / m;
}
break;
default:
break;
}
}
while (SDL_GetTicks() - ticks < (1000 / 60)) { SDL_Delay(1); }
SDL_RenderPresent(renderer);
ticks = SDL_GetTicks();
//update_mouse_position();
//vtheta += deg / 10;
}
exit:
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
}
Reference in New Issue View Git Blame Copy Permalink