291 lines
9.9 KiB
Python
291 lines
9.9 KiB
Python
import sys
|
|
|
|
op_idx = 0
|
|
opname_idx = 1
|
|
symbols = [
|
|
["+", "add"],
|
|
["-", "sub"],
|
|
["*", "mul"],
|
|
["/", "div"],
|
|
]
|
|
|
|
basic_types = [
|
|
"f32",
|
|
"f64",
|
|
"i32",
|
|
"i64",
|
|
]
|
|
|
|
name_idx = 0
|
|
member_idx = 1
|
|
|
|
vec_types = [
|
|
["v2", ["x", "y"]],
|
|
["v3", ["x", "y", "z"]],
|
|
["v4", ["x", "y", "z", "w"]],
|
|
]
|
|
|
|
rect_types = [
|
|
["r2", ["x0", "y0", "x1", "y1"]],
|
|
["r3", ["x0", "y0", "z0", "x1", "y1", "z1"]],
|
|
]
|
|
|
|
struct_types = vec_types + rect_types
|
|
|
|
|
|
# fd = open("mathx.gen.h", "w")
|
|
# sys.stdout = fd
|
|
|
|
# print("// auto generated using:", __file__)
|
|
|
|
# for bt in basic_types:
|
|
# s = """
|
|
# typedef union v2f64_t v2f64_t;
|
|
# union v2f64_t {
|
|
# struct { f64 x, y; };
|
|
# f64 e[2];
|
|
# };
|
|
|
|
# typedef union v3f64_t v3f64_t;
|
|
# union v3f64_t {
|
|
# struct { f64 x, y, z; };
|
|
# struct { v2f64_t xy; };
|
|
# struct { f64 _x0; v2f64_t zw; };
|
|
# struct { f64 r, g, b; };
|
|
# struct { f64 h, s, l; };
|
|
# f64 e[3];
|
|
# };
|
|
|
|
# typedef union v4f64_t v4f64_t;
|
|
# union v4f64_t {
|
|
# struct { f64 x, y, z, w; };
|
|
# struct { v2f64_t xy; v2f64_t zw; };
|
|
# struct { v3f64_t xyz; };
|
|
# struct { f64 _x0; f64 yzw; };
|
|
# struct { f64 r, g, b, a; };
|
|
# struct { f64 h, s, l, _a; };
|
|
# f64 e[4];
|
|
# };
|
|
|
|
# typedef union r1f64_t r1f64_t;
|
|
# union r1f64_t {
|
|
# struct { f64 min, max; };
|
|
# struct { f64 x0, x1; };
|
|
# f64 e[2];
|
|
# };
|
|
|
|
# typedef union r2f64_t r2f64_t;
|
|
# union r2f64_t {
|
|
# struct { v2f64_t min, max; };
|
|
# struct { f64 x0, y0, x1, y1; };
|
|
# v4f64_t e4;
|
|
# f64 e[4];
|
|
# };
|
|
|
|
# typedef union r3f64_t r3f64_t;
|
|
# union r3f64_t {
|
|
# struct { v3f64_t min, max; };
|
|
# struct { f64 x0, y0, z0, x1, y1, z1; };
|
|
# f64 e[6];
|
|
# };
|
|
#
|
|
#
|
|
# type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2,
|
|
# .members = (type_member_t[]){
|
|
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)},
|
|
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)},
|
|
# }
|
|
# };
|
|
|
|
# type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64_t), .count = 3,
|
|
# .members = (type_member_t[]){
|
|
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)},
|
|
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)},
|
|
# {s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)},
|
|
# }
|
|
# };
|
|
|
|
# type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4,
|
|
# .members = (type_member_t[]){
|
|
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)},
|
|
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)},
|
|
# {s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)},
|
|
# {s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)},
|
|
# }
|
|
# };
|
|
|
|
# type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6,
|
|
# .members = (type_member_t[]){
|
|
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)},
|
|
# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)},
|
|
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)},
|
|
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)},
|
|
# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)},
|
|
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)},
|
|
# }
|
|
# };
|
|
|
|
# type_member_t members__r2f64_t[] = {
|
|
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)},
|
|
# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)},
|
|
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)},
|
|
# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)},
|
|
# };
|
|
# DEFINE_STRUCT(r2f64_t);
|
|
|
|
# type_member_t members__r1f64_t[] = {
|
|
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)},
|
|
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)},
|
|
# };
|
|
# DEFINE_STRUCT(r1f64_t);
|
|
# """
|
|
# s = s.replace("f64", bt)
|
|
# print(s)
|
|
|
|
|
|
fd = open("mathx.gen.c", "w")
|
|
sys.stdout = fd
|
|
|
|
print("// auto generated using:", __file__)
|
|
|
|
for basic_type in basic_types:
|
|
for st in struct_types:
|
|
type = f"{st[name_idx]}{basic_type}"
|
|
typedef = f"{type}_t"
|
|
members = st[member_idx]
|
|
|
|
def members_as_func_params(members, basic_type):
|
|
result = ""
|
|
for i, m in enumerate(members):
|
|
result += f"{basic_type} {m}"
|
|
if i != len(members) - 1:
|
|
result += ", "
|
|
return result
|
|
|
|
print(f"""{type}_t {type}({members_as_func_params(members, basic_type)}) {{ return ({type}_t){{ {members_as_func_params(members, "")} }}; }}""")
|
|
|
|
for sym in symbols:
|
|
op = sym[op_idx]
|
|
opname = sym[opname_idx]
|
|
|
|
|
|
def op_str(members, op, skip_right = False):
|
|
result = ""
|
|
for i in range(len(members)):
|
|
mem = members[i]
|
|
if skip_right:
|
|
result += f"a.{mem} {op} b"
|
|
else:
|
|
result += f"a.{mem} {op} b.{mem}"
|
|
|
|
if i != len(members) - 1:
|
|
result += ", "
|
|
return result
|
|
|
|
|
|
|
|
print(f"{type}_t {type}_{opname}({type}_t a, {type}_t b) {{ return ({type}_t){{ {op_str(members, op)} }}; }}")
|
|
print(f"{type}_t {type}_{opname}s({type}_t a, {basic_type} b) {{ return ({type}_t){{ {op_str(members, op, skip_right = True)} }}; }}")
|
|
|
|
for basic_type in basic_types:
|
|
for i in range(len(rect_types)):
|
|
vec_type = vec_types[i]
|
|
rect_type = rect_types[i]
|
|
|
|
vec_name = vec_type[name_idx] + basic_type
|
|
vec_members = vec_type[member_idx]
|
|
rect_name = rect_type[name_idx] + basic_type
|
|
rect_members = rect_type[member_idx]
|
|
|
|
print(f"{rect_name}_t {rect_name}_mindim({vec_name}_t pos, {vec_name}_t size) {{ return ({rect_name}_t){{ pos, {vec_name}_add(pos, size) }}; }}")
|
|
print(f"{rect_name}_t {rect_name}_center_halfdim({vec_name}_t center, {vec_name}_t halfdim) {{ return ({rect_name}_t){{ {vec_name}_sub(center, halfdim), {vec_name}_add(center, halfdim) }}; }}")
|
|
|
|
for basic_type in basic_types:
|
|
s = """
|
|
r2f64_t r2f64_cut_left(r2f64_t *r, f64 value) {
|
|
f64 minx = r->min.x;
|
|
r->min.x = MIN(r->min.x + value, r->max.x);
|
|
return (r2f64_t){ .min = {.x = minx, .y = r->min.y}, .max = {.x = r->min.x, .y =r->max.y} };
|
|
}
|
|
r2f64_t r2f64_cut_right(r2f64_t *r, f64 value) {
|
|
f64 maxx = r->max.x;
|
|
r->max.x = MAX(r->min.x, r->max.x - value);
|
|
return (r2f64_t){ .min = {.x = r->max.x, .y = r->min.y}, .max = {.x = maxx, .y = r->max.y} };
|
|
}
|
|
r2f64_t r2f64_cut_top(r2f64_t *r, f64 value) { /* Y is down */
|
|
f64 miny = r->min.y;
|
|
r->min.y = MIN(r->max.y, r->min.y + value);
|
|
return (r2f64_t){ .min = {.x = r->min.x, .y = miny}, .max = {.x = r->max.x, .y = r->min.y} };
|
|
}
|
|
r2f64_t r2f64_cut_bottom(r2f64_t *r, f64 value) { /* Y is down */
|
|
f64 maxy = r->max.y;
|
|
r->max.y = MAX(r->min.y, r->max.y - value);
|
|
return (r2f64_t){ .min = {.x = r->min.x, .y = r->max.y}, .max = {.x = r->max.x, .y = maxy} };
|
|
}
|
|
|
|
// get past left
|
|
r2f64_t r2f64_getp_left(const r2f64_t *rect, f64 value) {
|
|
r2f64_t result = r2f64(rect->min.x - value, rect->min.y, rect->min.x, rect->max.y);
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_getp_right(const r2f64_t *rect, f64 value) {
|
|
r2f64_t result = r2f64(rect->max.x, rect->min.y, rect->max.x + value, rect->max.y);
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_getp_bottom(const r2f64_t *rect, f64 value) {
|
|
r2f64_t result = r2f64(rect->min.x, rect->max.y, rect->max.x, rect->max.y + value);
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_getp_top(const r2f64_t *rect, f64 value) {
|
|
r2f64_t result = r2f64(rect->min.x, rect->min.y - value, rect->max.x, rect->min.y);
|
|
return result;
|
|
}
|
|
|
|
r2f64_t r2f64_get_left(const r2f64_t *r, f64 value) {
|
|
f64 minx = r->min.x;
|
|
r2f64_t result = (r2f64_t){ .min = {.x = minx, .y = r->min.y}, .max = {.x = MIN(r->min.x + value, r->max.x), .y =r->max.y} };
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_get_right(const r2f64_t *r, f64 value) {
|
|
f64 maxx = r->max.x;
|
|
r2f64_t result = (r2f64_t){ .min = {.x = MAX(r->min.x, r->max.x - value), .y = r->min.y}, .max = {.x = maxx, .y = r->max.y} };
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_get_top(const r2f64_t *r, f64 value) { /* Y is down */
|
|
f64 miny = r->min.y;
|
|
r2f64_t result = (r2f64_t){ .min = {.x = r->min.x, .y = miny}, .max = {.x = r->max.x, .y = MIN(r->max.y, r->min.y + value)} };
|
|
return result;
|
|
}
|
|
r2f64_t r2f64_get_bottom(const r2f64_t *r, f64 value) { /* Y is down */
|
|
f64 maxy = r->max.y;
|
|
r2f64_t result = (r2f64_t){ .min = {.x = r->min.x, .y = MAX(r->min.y, r->max.y - value)}, .max = {.x = r->max.x, .y = maxy} };
|
|
return result;
|
|
}
|
|
|
|
r2f64_t r2f64_shrink(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_add(rect.min, value), v2f64_sub(rect.max, value) }; }
|
|
v2f64_t r2f64_get_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
|
|
v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_get_size(r), 2)); }
|
|
b32 r2f64_contains(r2f64_t rec, v2f64_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
|
|
"""
|
|
s = s.replace("r2f64", f"r2{basic_type}")
|
|
s = s.replace("f64", basic_type)
|
|
s = s.replace("v2f64", f"v2{basic_type}")
|
|
print(s)
|
|
|
|
for at in basic_types:
|
|
for bt in basic_types:
|
|
if at == bt: continue
|
|
for st in struct_types:
|
|
atype = f"{st[name_idx]}{at}"
|
|
btype = f"{st[name_idx]}{bt}"
|
|
members = st[member_idx]
|
|
|
|
def cast_members(members, type):
|
|
result = ""
|
|
for i in range(len(members)):
|
|
result += f"({type})v.{members[i]}"
|
|
if i != len(members) - 1:
|
|
result += ", "
|
|
return result
|
|
|
|
print(f"{btype}_t {atype}_to_{btype}({atype}_t v) {{ return ({btype}_t){{ {cast_members(members, bt)} }}; }}") |