samratghale/Edit2D
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refator

Browse Source
This commit is contained in:
SamratGhale
2026-03-24 10:23:05 +05:45
parent 739a806493
commit 5bc235f1ab
9 changed files with 335 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files
box2d_draw.odin
+220
View File
@@ -0,0 +1,220 @@
package edit2d
import e2_draw "./draw"
import b2 "vendor:box2d"
import "base:runtime"
/*
This is the integration between box2d and engine's renderer
*/
/* Put the functions to the box2d debug_draw */
make_rgba :: proc(color : b2.HexColor, alpha : f32) -> e2_draw.RGBA8 {
c := i32(color)
return {
u8((c >> 16) & 0xFF),
u8((c >> 8) & 0xFF),
u8(c & 0xFF),
u8(0xFF * alpha),
}
}
make_hex_color :: proc(rgba: e2_draw.RGBA8) -> b2.HexColor {
return b2.HexColor((u32(rgba.r) << 16) | (u32(rgba.g) << 8) | u32(rgba.b))
}
DrawCircleFcn :: proc "c" (
center : [2]f32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
e2_draw.circle_add(&draw.circles, center, radius, rgba)
}
DrawSolidCircleFcn :: proc "c" (
transform : b2.Transform,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
transform := transform
transform.p = b2.TransformPoint(transform, {0, 0})
t := transmute(e2_draw.Transform)transform
rgba := make_rgba(color, 1.0)
e2_draw.DrawSolidCircle(
&draw.solid_circles,
t,
{0, 0},
radius,
rgba,
)
}
DrawSolidCapsuleFcn :: proc "c" (
p1, p2 : [2]f32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
e2_draw.solid_capsules_add(&draw.solid_capsules, p1, p2, radius, rgba)
}
DrawSegmentFcn :: proc "c" (
p1, p2 : [2]f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
e2_draw.lines_add(&draw.lines, p1, p2, rgba)
}
DrawTransform :: proc "c" (lines : ^e2_draw.Lines, transform : b2.Transform) {
context = runtime.default_context()
k_axis_scale : f32 = 0.2
p1 := transform.p
rgba_red := make_rgba(b2.HexColor.Red, 1.0)
rgba_green := make_rgba(b2.HexColor.Green, 1.0)
p2 := p1 + k_axis_scale * b2.Rot_GetXAxis(transform.q)
e2_draw.lines_add(lines, p1, p2, rgba_red)
p2 = p1 + k_axis_scale * b2.Rot_GetYAxis(transform.q)
e2_draw.lines_add(lines, p1, p2, rgba_green)
}
DrawTransformFcn :: proc "c" (transform : b2.Transform, ctx : rawptr) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
DrawTransform(&draw.lines, transform)
}
DrawSolidPolygonFcn :: proc "c" (
transform : b2.Transform,
vertices : [^][2]f32,
vertexCount : i32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
t := transmute(e2_draw.Transform)transform
draw := cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
e2_draw.solid_polygon_add(
&draw.polygons,
t,
vertices,
vertexCount,
radius,
rgba,
)
}
DrawPolygonFcn :: proc "c" (vertices : [^][2]f32, vertexCount : i32, color : b2.HexColor, ctx : rawptr)
{
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
p1 := vertices[vertexCount - 1]
for i in 0 ..< vertexCount
{
p2 := vertices[i]
e2_draw.lines_add(&draw.lines, p1, vertices[i], rgba)
p1 = p2
}
}
DrawStringFcn :: proc "c" (
p : [2]f32,
s : cstring,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw := cast(^e2_draw.Draw)ctx
e2_draw.DrawStringVec(draw, p, s)
}
DrawPointFcn :: proc "c" (
p : [2]f32,
size : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw :=cast(^e2_draw.Draw)ctx
rgba := make_rgba(color, 1.0)
e2_draw.points_add(&draw.points, p, size, rgba)
}
//After initilizing draw
draw_configure_box2d :: proc(state: ^engine_state)
{
debug_draw := &state.debug_draw
bounds : b2.AABB = {{-max(f32), -max(f32)}, {max(f32), max(f32)}}
debug_draw.DrawPolygonFcn = DrawPolygonFcn
debug_draw.DrawSolidPolygonFcn = DrawSolidPolygonFcn
debug_draw.DrawCircleFcn = DrawCircleFcn
debug_draw.DrawSolidCircleFcn = DrawSolidCircleFcn
debug_draw.DrawSolidCapsuleFcn = DrawSolidCapsuleFcn
debug_draw.DrawSegmentFcn = DrawSegmentFcn
debug_draw.DrawTransformFcn = DrawTransformFcn
debug_draw.DrawPointFcn = DrawPointFcn
debug_draw.DrawStringFcn = DrawStringFcn
debug_draw.drawingBounds = bounds
debug_draw.useDrawingBounds = false
debug_draw.drawShapes = true
debug_draw.drawJoints = true
debug_draw.drawJointExtras = false
debug_draw.drawBounds = false
debug_draw.drawMass = true
debug_draw.drawContacts = false
debug_draw.drawGraphColors = false
debug_draw.drawContactNormals = false
debug_draw.drawContactImpulses = false
debug_draw.drawContactFeatures = false
debug_draw.drawFrictionImpulses = false
debug_draw.drawIslands = false
debug_draw.userContext = rawptr(&state.draw)
state.draw.drawCounters = true
}
draw/draw.odin
+67 -286
View File
@@ -4,10 +4,9 @@ import e2_glyph "shared:Edit2D/glyph"
import "core:strings"
import "base:runtime"
import "core:fmt"
import "core:math"
import "core:math/linalg"
import gl "vendor:OpenGL"
import b2 "vendor:box2d"
CameraType :: enum
{
@@ -35,20 +34,12 @@ Rot :: struct
Transform :: struct
{
p: Vec2,
p: [2]f32,
q: Rot,
}
make_rgba :: proc(color : b2.HexColor, alpha : f32) -> RGBA8 {
c := i32(color)
return {
u8((c >> 16) & 0xFF),
u8((c >> 8) & 0xFF),
u8(c & 0xFF),
u8(0xFF * alpha),
}
}
make_rgba_i32 :: proc(color : i32, alpha : f32) -> RGBA8 {
c := i32(color)
@@ -60,10 +51,6 @@ make_rgba_i32 :: proc(color : i32, alpha : f32) -> RGBA8 {
}
}
make_hex_color :: proc(rgba: RGBA8) -> b2.HexColor {
return b2.HexColor((u32(rgba.r) << 16) | (u32(rgba.g) << 8) | u32(rgba.b))
}
camera_reset_view :: proc(camera : ^Camera) {
camera.center = {0, 0}
@@ -231,12 +218,14 @@ camera_build_project_matrix :: proc(
return m * mat_rot
}
/*
camera_get_view_bounds :: proc(cam : ^Camera) -> b2.AABB {
return b2.AABB {
lowerBound = camera_convert_screen_to_world(cam, [2]f32{0, f32(cam.height)}),
upperBound = camera_convert_screen_to_world(cam, [2]f32{f32(cam.width), 0}),
}
}
*/
Background :: struct {
@@ -430,8 +419,7 @@ points_destroy :: proc(point : ^Point) {
}
}
points_add :: proc(point : ^Point, v : [2]f32, size : f32, c : b2.HexColor) {
rgba := make_rgba(c, 1.0)
points_add :: proc(point : ^Point, v : [2]f32, size : f32, rgba : RGBA8) {
append(&point.points, PointData{v, size, rgba})
}
@@ -573,8 +561,7 @@ lines_destroy :: proc(line : ^Lines) {
}
lines_add :: proc(line : ^Lines, p1, p2 : [2]f32, c : b2.HexColor) {
rgba := make_rgba(c, 1.0)
lines_add :: proc(line : ^Lines, p1, p2 : [2]f32, rgba : RGBA8) {
append(&line.points, VertexData{p1, rgba})
append(&line.points, VertexData{p2, rgba})
}
@@ -747,9 +734,9 @@ circle_add :: proc(
circle : ^Circles,
center : [2]f32,
radius : f32,
color : b2.HexColor,
) {
rgba := make_rgba(color, 1.0)
rgba : RGBA8,
)
{
append(&circle.circles, CircleData{center, radius, rgba})
}
@@ -1098,11 +1085,11 @@ solid_capsules_add :: proc(
capsule : ^SolidCapsules,
p1, p2 : [2]f32,
radius : f32,
c : b2.HexColor,
rgba : RGBA8,
) {
d := p2 - p1
length := b2.Length(d)
length := math.sqrt(d.x * d.x + d.y * d.y)
if length < 0.001 do return
axis := d / length
@@ -1112,7 +1099,6 @@ solid_capsules_add :: proc(
q = {c = axis.x, s = axis.y},
}
rgba := make_rgba(c, 1.0)
append(&capsule.capsules, CapsuleData{transform, radius, length, rgba})
}
@@ -1235,86 +1221,21 @@ solid_polygon_create :: proc(polygon : ^SolidPolygon) {
}
gl.BindBuffer(gl.ARRAY_BUFFER, polygon.vbo[0])
gl.BufferData(
gl.ARRAY_BUFFER,
size_of([2]f32) * 6,
&vertices[0],
gl.STATIC_DRAW,
)
gl.BufferData(gl.ARRAY_BUFFER, size_of([2]f32) * 6, &vertices[0], gl.STATIC_DRAW)
gl.VertexAttribPointer(vertex_attribute, 2, gl.FLOAT, gl.FALSE, 0, 0)
//
gl.BindBuffer(gl.ARRAY_BUFFER, polygon.vbo[1])
gl.BufferData(
gl.ARRAY_BUFFER,
int(batch_size * size_of(PolygonData)),
nil,
gl.DYNAMIC_DRAW,
)
gl.BufferData(gl.ARRAY_BUFFER, int(batch_size * size_of(PolygonData)), nil, gl.DYNAMIC_DRAW)
gl.VertexAttribPointer(
instance_transform,
4,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, transform),
)
gl.VertexAttribPointer(
instance_point12,
4,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, p1),
)
gl.VertexAttribPointer(
instance_point34,
4,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, p3),
)
gl.VertexAttribPointer(
instance_point56,
4,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, p5),
)
gl.VertexAttribPointer(
instance_point78,
4,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, p7),
)
gl.VertexAttribIPointer(
instance_point_count,
1,
gl.INT,
size_of(PolygonData),
offset_of(PolygonData, count),
)
gl.VertexAttribPointer(
instance_radius,
1,
gl.FLOAT,
false,
size_of(PolygonData),
offset_of(PolygonData, radius),
)
gl.VertexAttribPointer(
instance_color,
4,
gl.UNSIGNED_BYTE,
true,
size_of(PolygonData),
offset_of(PolygonData, color),
)
gl.VertexAttribPointer(instance_transform, 4, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, transform))
gl.VertexAttribPointer(instance_point12, 4, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, p1))
gl.VertexAttribPointer(instance_point34, 4, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, p3))
gl.VertexAttribPointer(instance_point56, 4, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, p5))
gl.VertexAttribPointer(instance_point78, 4, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, p7))
gl.VertexAttribIPointer(instance_point_count, 1, gl.INT, size_of(PolygonData), offset_of(PolygonData, count))
gl.VertexAttribPointer(instance_radius, 1, gl.FLOAT, false, size_of(PolygonData), offset_of(PolygonData, radius))
gl.VertexAttribPointer(instance_color, 4, gl.UNSIGNED_BYTE, true, size_of(PolygonData), offset_of(PolygonData, color))
gl.VertexAttribDivisor(instance_transform, 1)
@@ -1339,12 +1260,11 @@ solid_polygon_add :: proc(
points : [^][2]f32,
count : i32,
radius : f32,
color : b2.HexColor,
color : RGBA8,
) {
data : PolygonData
data.transform = transform
n := min(count, 8)
@@ -1357,7 +1277,7 @@ solid_polygon_add :: proc(
data.count = n
data.radius = f32(radius)
data.color = make_rgba(color, 1.0)
data.color = color
append(&polygon.polygons, data)
}
@@ -1408,7 +1328,6 @@ solid_polygon_flush :: proc(polygon : ^SolidPolygon, cam : ^Camera) {
}
TextItem :: struct
{
str : string,
@@ -1419,7 +1338,6 @@ TextItem :: struct
Draw :: struct
{
show_ui : bool,
debug_draw : b2.DebugDraw,
cam : Camera,
background : Background,
points : Point,
@@ -1431,162 +1349,43 @@ Draw :: struct
drawCounters : bool,
//regular_font : im.Font,
frame_buffer : u32,
//There should be option to draw without glyph? maybe
glyph : e2_glyph.GlyphState,
texts : [dynamic]TextItem,
}
draw_aabb :: proc(draw : ^Draw, aabb : b2.AABB, c : b2.HexColor) {
/*
draw_aabb :: proc(draw : ^Draw, aabb : [2][2]f32, rgba : RGBA8) {
p1 := aabb.lowerBound
p2 : [2]f32 = {aabb.upperBound.x, aabb.lowerBound.y}
p3 := aabb.upperBound
p4 : [2]f32 = {aabb.lowerBound.x, aabb.upperBound.y}
lines_add(&draw.lines, p1, p2, c)
lines_add(&draw.lines, p2, p3, c)
lines_add(&draw.lines, p3, p4, c)
lines_add(&draw.lines, p4, p1, c)
lines_add(&draw.lines, p1, p2, rgba)
lines_add(&draw.lines, p2, p3, rgba)
lines_add(&draw.lines, p3, p4, rgba)
lines_add(&draw.lines, p4, p1, rgba)
}
*/
DrawPolygonFcn :: proc "c" (
vertices : [^][2]f32,
vertexCount : i32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
p1 := vertices[vertexCount - 1]
for i in 0 ..< vertexCount {
p2 := vertices[i]
lines_add(&draw.lines, p1, vertices[i], color)
p1 = p2
}
}
DrawSolidPolygonFcn :: proc "c" (
transform : Transform,
vertices : [^][2]f32,
vertexCount : i32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
solid_polygon_add(
&draw.polygons,
transform,
vertices,
vertexCount,
radius,
color,
)
}
DrawCircleFcn :: proc "c" (
center : [2]f32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
circle_add(&draw.circles, center, radius, color)
}
DrawSolidCircle :: proc(
circle : ^SolidCircle,
transform : Transform,
center : [2]f32,
radius : f32,
color : b2.HexColor,
rgba: RGBA8,
) {
context = runtime.default_context()
transform := transform
rgba := make_rgba(color, 1.0)
transform.p = b2.TransformPoint(transform, center)
solid_circle_add(circle, transform, radius, rgba)
}
DrawTransform :: proc "c" (lines : ^Lines, transform : Transform) {
context = runtime.default_context()
k_axis_scale : f32 = 0.2
p1 := transform.p
p2 := p1 + k_axis_scale * b2.Rot_GetXAxis(transform.q)
lines_add(lines, p1, p2, b2.HexColor.Red)
p2 = p1 + k_axis_scale * b2.Rot_GetYAxis(transform.q)
lines_add(lines, p1, p2, b2.HexColor.Green)
}
DrawSolidCircleFcn :: proc "c" (
transform : Transform,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
DrawSolidCircle(
&draw.solid_circles,
transform,
{0, 0},
radius,
color,
)
}
DrawSolidCapsuleFcn :: proc "c" (
p1, p2 : [2]f32,
radius : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
solid_capsules_add(&draw.solid_capsules, p1, p2, radius, color)
}
DrawSegmentFcn :: proc "c" (
p1, p2 : [2]f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
lines_add(&draw.lines, p1, p2, color)
}
DrawTransformFcn :: proc "c" (transform : Transform, ctx : rawptr) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
DrawTransform(&draw.lines, transform)
}
DrawPointFcn :: proc "c" (
p : [2]f32,
size : f32,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
points_add(&draw.points, p, size, color)
}
DrawString :: proc(draw : ^Draw, x, y : int, cstr: cstring)
{
ps := camera_convert_world_to_screen(&draw.cam, {f32(x), f32(y)})
@@ -1615,20 +1414,6 @@ DrawStringVec :: proc(draw : ^Draw, p : [2]f32, cstr: cstring)
append(&draw.texts, TextItem{str, {f32(ps.x), f32(ps.y)}, {200,200,200,255}})
/*
im.DrawList_AddText(im.GetForegroundDrawList(), ps,im.GetColorU32(.Text), str)
*/
}
DrawStringFcn :: proc "c" (
p : [2]f32,
s : cstring,
color : b2.HexColor,
ctx : rawptr,
) {
context = runtime.default_context()
draw : ^Draw = cast(^Draw)ctx
DrawStringVec(draw, p, s)
}
text_flush :: proc(draw: ^Draw)
@@ -1642,7 +1427,7 @@ text_flush :: proc(draw: ^Draw)
draw_flush :: proc(draw : ^Draw) {
background_draw(&draw.background, &draw.cam)
//background_draw(&draw.background, &draw.cam)
solid_circle_flush(&draw.solid_circles, &draw.cam)
solid_polygon_flush(&draw.polygons, &draw.cam)
@@ -1652,13 +1437,42 @@ draw_flush :: proc(draw : ^Draw) {
circle_flush(&draw.circles, &draw.cam)
text_flush(draw)
check_opengl()
}
/*
Create texture and render texture
create opengl texture when a buffer data is provided and store the textuer
The function returns the actual opengl texture_id
render_texture :: gets a texture_id and rect and displays the texture (generic but convinent for micorui)
*/
create_texutre :: proc(data: []u8, width, height: i32) -> u32
{
texture : u32
gl.GenTextures(1, &texture)
gl.BindTexture(gl.TEXTURE_2D, texture)
gl.TexImage2D( gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, raw_data(data))
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
gl.BindTexture(gl.TEXTURE_2D, 0)
return texture
}
//This should be handled in engine code separately
draw_create :: proc(draw : ^Draw, camera : ^Camera, font_path : string = "") {
draw_create :: proc(draw : ^Draw, camera : ^Camera, font_path : string = "")
{
background_create(&draw.background)
points_create(&draw.points)
@@ -1679,38 +1493,5 @@ draw_create :: proc(draw : ^Draw, camera : ^Camera, font_path : string = "") {
}
check_opengl()
bounds : b2.AABB = {{-max(f32), -max(f32)}, {max(f32), max(f32)}}
draw.debug_draw.DrawPolygonFcn = DrawPolygonFcn
draw.debug_draw.DrawSolidPolygonFcn = DrawSolidPolygonFcn
draw.debug_draw.DrawCircleFcn = DrawCircleFcn
draw.debug_draw.DrawSolidCircleFcn = DrawSolidCircleFcn
draw.debug_draw.DrawSolidCapsuleFcn = DrawSolidCapsuleFcn
draw.debug_draw.DrawSegmentFcn = DrawSegmentFcn
draw.debug_draw.DrawTransformFcn = DrawTransformFcn
draw.debug_draw.DrawPointFcn = DrawPointFcn
draw.debug_draw.DrawStringFcn = DrawStringFcn
draw.debug_draw.drawingBounds = bounds
draw.debug_draw.useDrawingBounds = false
draw.debug_draw.drawShapes = true
draw.debug_draw.drawJoints = true
draw.debug_draw.drawJointExtras = false
draw.debug_draw.drawBounds = false
draw.debug_draw.drawMass = true
draw.debug_draw.drawContacts = false
draw.debug_draw.drawGraphColors = false
draw.debug_draw.drawContactNormals = false
draw.debug_draw.drawContactImpulses = false
draw.debug_draw.drawContactFeatures = false
draw.debug_draw.drawFrictionImpulses = false
draw.debug_draw.drawIslands = false
draw.drawCounters = true
draw.debug_draw.userContext = rawptr(draw)
}
draw/shaders/texture.fs
+9
View File
@@ -0,0 +1,9 @@
#version 450 core
out vec4 FragColor;
in vec2 TexCoord;
uniform sampler2D ourTexture;
void main() {
FragColor = texture(ourTexture, TexCoord);
}
draw/shaders/texture.vs
+25
View File
@@ -0,0 +1,25 @@
#version 450 core
layout (location = 0) in vec2 aPos;
layout (location = 1) in vec2 aTexCoord;
out vec2 TexCoord;
uniform vec2 u_position; //Position in scrren coordinates (pixel)
uniform vec2 u_size; //size in pixels (width, height)
uniform vec2 u_resolution; //window resolution
void main(){
//Covert from screen coordinated to normalized device corrdinates
//Screen coordinates: origin at top-left , y down
vec2 screen_pos = aPos * u_size + u_position;
vec2 ndc;
ndc.x = (screen_pos.x / u_resolution.x) * 2.0 - 1.0;
ndc.y = 1.0 - (screen_pos.y / u_resolution.x) * 2.0;
gl_Position = vec4(ndc, 0.0, 1.0);
TexCoord = aTexCoord;
}
edit2d.odin
+6 -3
View File
@@ -20,6 +20,8 @@ import mu "vendor:microui"
engine_state :: struct
{
window : glfw.WindowHandle,
debug_draw : b2.DebugDraw,
draw : e2_draw.Draw,
restart, pause : bool,
substep_count : u32,
@@ -159,6 +161,7 @@ engine_init :: proc($GameType : typeid, state: ^engine_state, font_path : strin
state.draw.show_ui = true
e2_draw.draw_create(&state.draw, &state.draw.cam, font_path)
draw_configure_box2d(state)
cbor.tag_register_type({
marshal = proc(_: ^cbor.Tag_Implementation, e: cbor.Encoder, v: any) -> cbor.Marshal_Error {
@@ -260,8 +263,8 @@ end_frame :: proc(state: ^engine_state)
for &p, i in &points do points[i] = e2_draw.camera_convert_screen_to_world(&draw.cam, p)
color := c.color
hex_color := e2_draw.make_hex_color({color.r, color.g, color.b, color.a})
e2_draw.solid_polygon_add(&draw.polygons, {q = b2.Rot{c = 1}}, &points[0], 4, 0, hex_color)
//hex_color := e2_draw.make_hex_color({color.r, color.g, color.b, color.a})
e2_draw.solid_polygon_add(&draw.polygons, {q = e2_draw.Rot{c = 1}}, &points[0], 4, 0, transmute([4]u8)color)
}
case ^mu.Command_Clip:
{
@@ -278,7 +281,7 @@ end_frame :: proc(state: ^engine_state)
pos.y += f32(c.rect.h)/2.0
pos = e2_draw.camera_convert_screen_to_world(&draw.cam, pos)
e2_draw.solid_circle_add(&draw.solid_circles,{p = pos, q = b2.Rot{c = 1}} , 0.1,{255, 255, 255, 255})
e2_draw.solid_circle_add(&draw.solid_circles,{p = pos, q = e2_draw.Rot{c = 1}} , 0.1,{255, 255, 255, 255})
}else{
fmt.println(c.id)
}
handle_input.odin
+1 -9
View File
@@ -74,15 +74,7 @@ handle_entity_mode :: proc(
if is_key_pressed(state, glfw.MOUSE_BUTTON_LEFT)
{
aabb : b2.AABB = {mpos, mpos + 1}
r := b2.World_OverlapAABB(
level.engine.world_id,
aabb,
b2.DefaultQueryFilter(),
click_query_filter,
game,
)
r := b2.World_OverlapAABB(level.engine.world_id, aabb, b2.DefaultQueryFilter(), click_query_filter, game)
}
else if is_key_pressed(state, glfw.MOUSE_BUTTON_RIGHT)
{
interface.odin
+2 -2
View File
@@ -105,7 +105,7 @@ interface_get_default :: proc(interface: ^interface_state)
interface_draw_options :: proc(state: ^engine_state)
{
debug_draw := &state.debug_draw
im.SliderFloat("Zoom", &state.draw.cam.zoom, 0, 100)
im.Checkbox("Shapes", &debug_draw.drawShapes)
im.Checkbox("Joints", &debug_draw.drawJoints)
@@ -140,7 +140,7 @@ mu_interface_game_mode :: proc(state: ^engine_state, interface: ^interface_state
{
if mu.begin_window(&state.mu_ctx, "Options", {200, 150, 200, 400}){
debug_draw := &state.debug_draw
mu.label(&state.mu_ctx, "Zoom")
mu.slider(&state.mu_ctx, &state.draw.cam.zoom,0, 100)
interface_joints.odin
+3 -2
View File
@@ -42,11 +42,12 @@ interface_edit_joint_common :: proc(joint_def : ^joint_common, interface: ^inter
{
if joint_def.entity_a in level.static_indexes{
entity_a := interface.entity_defs[level.static_indexes[joint_def.entity_a]]
draw.points_add(&interface.state.draw.points, entity_a.body_def.position, 20.0, b2.HexColor.Plum)
draw.points_add(&interface.state.draw.points, entity_a.body_def.position, 20.0, {200, 240, 200, 200})
}
if joint_def.entity_b in level.static_indexes{
entity_b := interface.entity_defs[level.static_indexes[joint_def.entity_b]]
draw.points_add(&interface.state.draw.points, entity_b.body_def.position, 20.0, b2.HexColor.Plum)
draw.points_add(&interface.state.draw.points, entity_b.body_def.position, 20.0, {200, 240, 200, 200})
}
}
mui_draw.odin
+1
View File
@@ -0,0 +1 @@
package edit2d