You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
224 lines
6.4 KiB
Plaintext
224 lines
6.4 KiB
Plaintext
|
|
#import "Window_Creation";
|
|
Debug :: #import "Debug";
|
|
Simp :: #import "Simp";
|
|
Input :: #import "Input";
|
|
|
|
Camera :: struct {
|
|
pos: Vector2;
|
|
zoom: float = 1.0;
|
|
};
|
|
|
|
window: Window;
|
|
quit: bool;
|
|
panning: bool = false;
|
|
camera : Camera;
|
|
mouse_frozen: bool;
|
|
mouse_frozen_at: Vector2;
|
|
|
|
|
|
local_to_world :: (using b: Body, local_point: Vector2) -> Vector2 {
|
|
return rotate(local_point, angle) + pos;
|
|
}
|
|
world_to_local :: (using b: Body, world_point: Vector2) -> Vector2 {
|
|
// world = rotate(local, angle) + pos
|
|
// world - pos = rotate(local, angle)
|
|
// rotate(world - pos, -angle) = local
|
|
return rotate(world_point - pos, -angle);
|
|
}
|
|
window_width : s32 = 1280;
|
|
window_height : s32 = 720;
|
|
|
|
dbgprint :: print; // so can be detected and removed
|
|
|
|
WHITE :: Vector4.{1.0, 1.0, 1.0, 1.0};
|
|
RED :: Vector4.{1.0, 0.0, 0.0, 1.0};
|
|
GREEN :: Vector4.{0.0, 1.0, 0.0, 1.0};
|
|
ORANGE :: Vector4.{1.0, 0xA5/255, 0.0, 1.0};
|
|
DrawingSettings :: struct {
|
|
world_space: bool = true;
|
|
color: Vector4 = WHITE;
|
|
};
|
|
line :: (using d: DrawingSettings, _from: Vector2, _to: Vector2, thickness: float = 1.0) {
|
|
width := thickness;
|
|
from := _from;
|
|
to := _to;
|
|
if world_space {
|
|
from = world_to_screen(from);
|
|
to = world_to_screen(to);
|
|
}
|
|
Simp.set_shader_for_color(true);
|
|
normal := rotate(unit_vector(to - from), PI/2.0);
|
|
Simp.immediate_quad(from + normal*width, from - normal*width, to + normal*width, to - normal*width, color = color);
|
|
}
|
|
vector :: (d: DrawingSettings, from: Vector2, vector: Vector2) {
|
|
line(d, from, from+vector);
|
|
|
|
arrow_head_length := length(vector) * 0.5;
|
|
|
|
// arrow head
|
|
line(d, from + vector, from + vector + rotate(normalize(vector)*arrow_head_length, PI/2.0 + PI/4.0));
|
|
line(d, from + vector, from + vector + rotate(normalize(vector)*arrow_head_length, -PI/2.0 + -PI/4.0));
|
|
}
|
|
|
|
pips : [10] LastingPip;
|
|
push_pip :: (d: DrawingSettings, at: Vector2) {
|
|
for * pips
|
|
{
|
|
if it.alive_for <= 0.0
|
|
{
|
|
it.alive_for = 1.0;
|
|
it.pos = at;
|
|
it.d = d;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
draw_pips :: (dt: float) {
|
|
for * pips if it.alive_for > 0.0
|
|
{
|
|
d := it.d;
|
|
d.color.w *= it.alive_for;
|
|
pip(d, it.pos);
|
|
it.alive_for -= dt;
|
|
}
|
|
}
|
|
pip :: (using d: DrawingSettings, _at: Vector2, size: float = 0.05) {
|
|
at := _at;
|
|
Simp.set_shader_for_color(true);
|
|
if world_space {
|
|
at = world_to_screen(at);
|
|
size /= camera.zoom;
|
|
}
|
|
Simp.immediate_quad(at + xy(-size, size), at + xy(size, size), at + xy(size, -size), at + xy(-size, -size), color = color);
|
|
}
|
|
|
|
font: *Simp.Dynamic_Font;
|
|
text :: (using d: DrawingSettings, t: string, p: Vector2) {
|
|
drawing_at := p;
|
|
if world_space {
|
|
drawing_at = world_to_screen(drawing_at);
|
|
}
|
|
Simp.draw_text(font, xx drawing_at.x, xx drawing_at.y, t, color = color);
|
|
}
|
|
|
|
init :: () {
|
|
window = create_window(window_width, window_height, "Test Kit");
|
|
// Actual render size in pixels can be different from the window dimensions we specified above (for example on high-resolution displays on macOS/iOS).
|
|
window_width, window_height = Simp.get_render_dimensions(window);
|
|
|
|
camera.pos = -xy(window_width, window_height)/2.0;
|
|
camera.zoom = 0.01;
|
|
|
|
Simp.set_render_target(window);
|
|
|
|
font = Simp.get_font_at_size(".", "Roboto-Regular.ttf", 18);
|
|
assert(font != null);
|
|
}
|
|
// screen coordinates
|
|
mouse_screen :: () -> Vector2 {
|
|
if mouse_frozen return mouse_frozen_at;
|
|
x, y := get_mouse_pointer_position();
|
|
pos: Vector2 = xy(cast(float)x, cast(float)y);
|
|
|
|
// simp is lower left is (0, 0) and y+ is up
|
|
pos.y = window_height - pos.y;
|
|
|
|
return pos;
|
|
}
|
|
mouse_world :: () -> Vector2 {
|
|
return screen_to_world(mouse());
|
|
}
|
|
|
|
// query quit to see if should quit. Call this in a loop
|
|
frame_start :: () {
|
|
last_time := get_time();
|
|
last_mouse_pos := mouse();
|
|
unprocessed_time: float = 0.0;
|
|
|
|
dt := cast(float)(get_time() - last_time);
|
|
last_time = get_time();
|
|
Input.update_window_events();
|
|
mouse_delta := mouse() - last_mouse_pos; // using Input.mouse_delta_x seems to incorrectly accumulate
|
|
last_mouse_pos = mouse();
|
|
|
|
for Input.get_window_resizes() {
|
|
Simp.update_window(it.window); // Simp will do nothing if it doesn't care about this window.
|
|
|
|
if it.window == window {
|
|
should_reinit := (it.width != window_width) || (it.height != window_height);
|
|
|
|
window_width = it.width;
|
|
window_height = it.height;
|
|
|
|
//if should_reinit my_init_fonts(); // Resize the font for the new window size.
|
|
}
|
|
}
|
|
|
|
camera.zoom *= 1.0 - 0.1*Input.mouse_delta_z/120.0;
|
|
if panning {
|
|
camera.pos -= mouse_delta;
|
|
}
|
|
Simp.immediate_begin();
|
|
Simp.clear_render_target(0.0, 0.0, 0.0, 1.0);
|
|
|
|
// draw grid
|
|
grid_d: DrawingSettings = .{true,.{0.2, 0.2, 0.2, 0.5}};
|
|
text_d := grid_d;
|
|
text_d.color = .{0.6, 0.6, 0.6, 1.0};
|
|
help_text_max :: 8;
|
|
help_zoom_max :: 0.04;
|
|
for x: -30..30 {
|
|
line(grid_d, xy(x, 30), xy(x, -30));
|
|
if camera.zoom <= help_zoom_max && abs(x) < help_text_max then text(text_d, tprint("%m", x), .{xx x, 0.0});
|
|
}
|
|
for y: -30..30 {
|
|
line(grid_d, xy(30, y), xy(-30, y));
|
|
if camera.zoom <= help_zoom_max && abs(y) < help_text_max then text(text_d, tprint("%m", y), .{0.0, xx y});
|
|
}
|
|
|
|
draw_pips(dt);
|
|
|
|
if mouse_frozen pip(.{false, ORANGE}, mouse_frozen_at, size = 20.0);
|
|
|
|
|
|
// handle inputs
|
|
for Input.events_this_frame {
|
|
if it.type == .QUIT then quit = true;
|
|
|
|
if it.type == {
|
|
case .KEYBOARD;
|
|
if it.key_pressed {
|
|
if it.key_code == {
|
|
case .ESCAPE;
|
|
quit = true;
|
|
|
|
case #char "T";
|
|
if !mouse_frozen mouse_frozen_at = mouse();
|
|
mouse_frozen = !mouse_frozen;
|
|
}
|
|
}
|
|
if it.key_code == .MOUSE_BUTTON_LEFT {
|
|
panning = cast(bool)it.key_pressed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
frame_end :: () {
|
|
Simp.immediate_flush();
|
|
Simp.swap_buffers(window);
|
|
}
|
|
|
|
screen_to_world :: (screen: Vector2) -> Vector2 {
|
|
using camera;
|
|
return (screen + pos)*zoom;
|
|
}
|
|
world_to_screen :: (world: Vector2) -> Vector2 {
|
|
using camera;
|
|
// world = (screen + pos)*zoom;
|
|
// world/zoom = screen + pos;
|
|
// world/zoom - pos = screen;
|
|
return (world/zoom) - pos;
|
|
}
|