100 lines
1.5 KiB
PSL
100 lines
1.5 KiB
PSL
func print(c: u8) {
|
|
foreign func putchar(c: i32) -> i32
|
|
putchar(c as i32)
|
|
}
|
|
|
|
func print_i32(x: i32) {
|
|
if x < 0 {
|
|
print('-')
|
|
print_i32(-x)
|
|
return
|
|
}
|
|
if x >= 10 {
|
|
print_i32(x / 10)
|
|
}
|
|
print('0' + (x % 10 as u8))
|
|
}
|
|
|
|
func print_f32(x: f32) {
|
|
if x < 0.0 {
|
|
print('-')
|
|
print_f32(-x)
|
|
return
|
|
}
|
|
foreign func floorf(x: f32) -> f32
|
|
let floor = floorf(x) as i32
|
|
print_i32(floor)
|
|
print('.')
|
|
mut y = x - (floor as f32)
|
|
mut i = 0
|
|
while i < 5 {
|
|
y = y * 10.0
|
|
let yfloor = floorf(y) as i32
|
|
print('0' + (yfloor as u8))
|
|
y = y - (yfloor as f32)
|
|
i = i + 1
|
|
}
|
|
}
|
|
|
|
struct vec3 {
|
|
x: f32
|
|
y: f32
|
|
z: f32
|
|
}
|
|
|
|
func print_vec3(v: vec3) {
|
|
print('(')
|
|
print_f32(v.x)
|
|
print(',')
|
|
print_f32(v.y)
|
|
print(',')
|
|
print_f32(v.z)
|
|
print(')')
|
|
}
|
|
|
|
func dot(a: vec3, b: vec3) -> f32 {
|
|
return a.x * b.x + a.y * b.y + a.z * b.z
|
|
}
|
|
|
|
func add(a: vec3, b: vec3) -> vec3 {
|
|
return vec3(a.x + b.x, a.y + b.y, a.z + b.z)
|
|
}
|
|
|
|
func mult(a: vec3, b: f32) -> vec3 {
|
|
return vec3(a.x * b, a.y * b, a.z * b)
|
|
}
|
|
|
|
func normalized(v: vec3) -> vec3 {
|
|
foreign func sqrtf(x: f32) -> f32
|
|
return mult(v, 1.0 / sqrtf(dot(v, v)))
|
|
}
|
|
|
|
struct ray {
|
|
origin: vec3
|
|
direction: vec3
|
|
}
|
|
|
|
func intersect_plane(ray: ray, normal: vec3, value: f32) -> f32 {
|
|
return (value - dot(ray.origin, normal)) / dot(ray.direction, normal)
|
|
}
|
|
|
|
func test() -> i32[3] {
|
|
return [70, 60, 50]
|
|
}
|
|
|
|
func print_i32_3(a: i32[3]) {
|
|
print('[')
|
|
print_i32(a[0])
|
|
print(',')
|
|
print_i32(a[1])
|
|
print(',')
|
|
print_i32(a[2])
|
|
print(']')
|
|
}
|
|
|
|
mut a = [1, 2, 3]
|
|
a = test()
|
|
a[0] = 10
|
|
print_i32_3(test())
|
|
print('\n')
|
|
|