463 lines
17 KiB
Zig
463 lines
17 KiB
Zig
pub export fn startup(p_allocator: *anyopaque, p_a: ?*anyopaque) bool {
|
|
const allocator = core.modulePreamble(p_allocator, p_a) catch return false;
|
|
_ = allocator;
|
|
imgui.setupFromModule();
|
|
platform.setupFromModule();
|
|
sys.setupFromModule();
|
|
rend.setupFromModule();
|
|
backlog.physics.setupFromModule();
|
|
// backlog.net.setupFromModule();
|
|
// TODO backlog.setupFromModule
|
|
|
|
core.engine_logs("creating externgame");
|
|
start_module(core.startup_getArgs(p_a.?)) catch return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
pub export fn add(a: i32, b: i32) i32 {
|
|
return a + b;
|
|
}
|
|
|
|
pub export fn subtract(a: i32, b: i32) i32 {
|
|
return a + b;
|
|
}
|
|
|
|
var gAllocator: std.mem.Allocator = undefined;
|
|
|
|
pub fn start_module(args: core.ModuleLoaderArgs) !void {
|
|
if (args.firstLoad) {
|
|
_ = core.createObject(ExternGameObject, .{}) catch {};
|
|
core.engine_logs("creating externgame");
|
|
return;
|
|
}
|
|
|
|
core.logDisplay("externGame", "accessing old object at {x} same object? {d}", .{ @intFromPtr(core.EngineObject(ExternGameObject).get()), @sizeOf(ExternGameObject) });
|
|
|
|
// getting rid of dumb comment
|
|
//log("gonna try something dumb- lets patch the vtable of that old object with my vtable's values", .{});
|
|
const ref = core.getEngineObjectRef(ExternGameObject).?;
|
|
const vtable: *core.EngineObjectVTable = @constCast(ref.vtable);
|
|
vtable.* = ExternGameObject.NeonObjectTable;
|
|
|
|
core.PatchStruct(ExternGameObject, @ptrCast(@alignCast(ref.ptr)), ref.vtable.fieldList.?);
|
|
}
|
|
|
|
pub const BoxObject = struct {
|
|
playing: bool = false,
|
|
|
|
pub fn create(allocator: std.mem.Allocator, entity: core.Entity, params: core.SpawnParameters) !*@This() {
|
|
const position = params.posRot.position;
|
|
|
|
const box2 = entity;
|
|
const scene = box2.addComponent(core.Scene).?;
|
|
|
|
const mesh = box2.addComponent(rend.MeshComponent).?;
|
|
mesh.setMesh("m_crate");
|
|
mesh.setTexture("t_crate");
|
|
|
|
scene.setPosition(position);
|
|
scene.setScaleV(params.posRot.scale);
|
|
scene.setMobility(.moveable);
|
|
|
|
const collider = box2.addComponent(physics.PhysicsCollider).?;
|
|
try collider.setupByShapeName(core.MakeName("ph_small_box"), .{
|
|
.motion_type = .dynamic,
|
|
.object_layer = physics.ObjectLayers.moving,
|
|
.friction = 0.8,
|
|
.mass_properties_override = .{ .mass = 12 },
|
|
.override_mass_properties = .calc_inertia,
|
|
});
|
|
|
|
return try allocator.create(@This());
|
|
}
|
|
|
|
pub fn createSmoky(allocator: std.mem.Allocator, entity: core.Entity, params: core.SpawnParameters) !*@This() {
|
|
const rv = try create(allocator, entity, params);
|
|
|
|
const particle = entity.addComponent(rend.ParticleEmitter).?;
|
|
particle.start();
|
|
particle.gravity = .{ .y = 1.0 };
|
|
particle.particleVelocity = .{ .min = 0.6, .max = 1.2 };
|
|
particle.particleLife = .{ .min = 5, .max = 6 };
|
|
var name = core.MakeName("t_pixelSmoke");
|
|
particle.texture = rend.getTexture(&name).?;
|
|
|
|
return rv;
|
|
}
|
|
|
|
pub fn destroy(self: *@This(), alloc: std.mem.Allocator) void {
|
|
alloc.destroy(self);
|
|
}
|
|
};
|
|
|
|
pub const ExternGameObject = struct {
|
|
pub var NeonObjectTable = core.EngineObjectVTable.from(@This(), "game.ExternGameObject");
|
|
pub const Slack = core.SlackStruct(@This(), 512);
|
|
|
|
allocator: std.mem.Allocator = undefined,
|
|
consoleWindow: imgui.utils.ConsoleWindow = undefined,
|
|
tbMap: ?*bsp.maploader.TBMap = null,
|
|
physicsObjectsWindow: *extras.PhysicsObjectList = undefined,
|
|
fireTraceFilter: physics.IgnoreFixedBodiesFilter = .{},
|
|
particleDebugger: extras.ParticleDebugger.ParticleDebugger = undefined,
|
|
|
|
session: ?*net.Session = null,
|
|
clientLink: ?*net.Link = null,
|
|
|
|
volume: f32 = 100,
|
|
//lmao: bool = false,
|
|
//lmao2: bool = true,
|
|
// lib: bool = false,
|
|
//s: u32 = 0x42,
|
|
//
|
|
firstTick: bool = true,
|
|
|
|
fireInput: ?*core.ActionBinding = null,
|
|
altFireInput: ?*core.ActionBinding = null,
|
|
|
|
a: core.Vector2f = .{ .x = 1, .y = 4 },
|
|
b: core.Vector2f = .{ .x = 4, .y = 1 },
|
|
|
|
Anormal: core.Vector2f = .{ .x = -1, .y = 3 },
|
|
Bnormal: core.Vector2f = .{ .x = -1, .y = -3 },
|
|
|
|
spawnedEntities: std.ArrayListUnmanaged(core.Entity) = .{},
|
|
|
|
displayVectorsTest: bool = false,
|
|
|
|
pub fn beginPlay(p: *anyopaque) void {
|
|
const self = core.cast(*@This(), p);
|
|
self._beginPlay() catch {
|
|
core.engine_errs("unable to beginplay");
|
|
};
|
|
}
|
|
|
|
pub fn _beginPlay(self: *@This()) !void {
|
|
if (self.fireInput == null) {
|
|
self.fireInput = try core.ActionBinding.create(core.MakeName("fire"));
|
|
self.fireInput.?.addKey(.Mouse1, .keyDown);
|
|
_ = self.fireInput.?.data.addListener(self, onFire);
|
|
}
|
|
self.fireInput.?.activate();
|
|
|
|
if (self.altFireInput == null) {
|
|
self.altFireInput = try core.ActionBinding.create(core.MakeName("altFire"));
|
|
self.altFireInput.?.addKey(.Mouse3, .keyDown);
|
|
_ = self.altFireInput.?.data.addListener(self, onAltFire);
|
|
}
|
|
self.altFireInput.?.activate();
|
|
}
|
|
|
|
pub fn endPlay(p: *anyopaque) void {
|
|
const self = core.cast(*@This(), p);
|
|
self.fireInput.?.deactivate();
|
|
self.altFireInput.?.deactivate();
|
|
}
|
|
|
|
pub fn loadMap2(self: *@This()) !void {
|
|
if (self.tbMap) |tbMap| {
|
|
core.engine_log("killing the map", .{});
|
|
tbMap.destroy();
|
|
}
|
|
|
|
self.tbMap = try bsp.maploader.LoadTrenchbroomMap(self.allocator, .{
|
|
.rotation = core.Rotation.eulerX(core.radians(-90.0)),
|
|
.mapName = "bsp/testmap.map",
|
|
});
|
|
|
|
core.engine_log("map loaded", .{});
|
|
}
|
|
|
|
pub fn create(allocator: std.mem.Allocator) !*@This() {
|
|
const self = try Slack.create(allocator);
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.consoleWindow = imgui.utils.ConsoleWindow.init(allocator),
|
|
.particleDebugger = extras.ParticleDebugger.ParticleDebugger.init(),
|
|
};
|
|
|
|
imgui.utils.addMenuFunc(self, "Input Stack Viewer", extras.inputDebugger.windowOpen);
|
|
|
|
self.physicsObjectsWindow = try extras.PhysicsObjectList.create(self.allocator);
|
|
self.consoleWindow.setup();
|
|
|
|
try core.registerObject(BoxObject, "Box");
|
|
try core.registerObjectAdvanced(BoxObject, "BoxSmoky", "createSmoky");
|
|
|
|
const settings: physics.ShapeSettings = .{ .box = try physics.BoxShapeSettings.create(.{ 1.0, 1.0, 1.0 }) };
|
|
defer settings.release();
|
|
try physics.addShape("ph_small_box", settings);
|
|
|
|
if (true) {
|
|
const ctx = ui.getScreen();
|
|
const panel2 = try ctx.addPanel(.{});
|
|
ctx.drawDebug = true;
|
|
{
|
|
ctx.getPanel(panel2).hasTitle = true;
|
|
//ctx.get(panel2).anchor = .TopRight;
|
|
// ctx.get(panel2).fill = .FillY; todo, this is a bug. why.
|
|
ctx.get(panel2).pos = .{ .x = 900, .y = 200 };
|
|
ctx.get(panel2).size = .{ .x = 300, .y = 500 };
|
|
ctx.get(panel2).style.backgroundColor = ui.ModernStyle.GreyDark;
|
|
ctx.getPanel(panel2).titleColor = ui.ModernStyle.GreyDark;
|
|
ctx.getPanel(panel2).layoutMode = .Vertical;
|
|
|
|
// add some text to this panel
|
|
const text = try ctx.addText(panel2, "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
|
|
ctx.get(text).pos = .{ .x = 2, .y = 2 };
|
|
ctx.get(text).size = .{ .x = 296, .y = 300 };
|
|
|
|
const btn = try ctx.addButton(panel2, "select file...");
|
|
_ = btn;
|
|
}
|
|
}
|
|
|
|
try extras.games.addGame("ExternGame", self, @This());
|
|
|
|
extras.beginGame("ExternGame");
|
|
|
|
return self;
|
|
}
|
|
|
|
fn editVector2(comptime Name: []const u8, v: *core.Vector2f) void {
|
|
const ItemWidth = 120;
|
|
|
|
ig.textFmt(Name, .{}) catch {};
|
|
ig.sameLine(0, 10);
|
|
ig.setNextItemWidth(ItemWidth);
|
|
_ = ig.inputFloat("X##particleEd" ++ Name, &v.x, 1.0, 5.0, null, .{});
|
|
ig.sameLine(0, 10);
|
|
ig.setNextItemWidth(ItemWidth);
|
|
_ = ig.inputFloat("Y##particleEd" ++ Name, &v.y, 1.0, 5.0, null, .{});
|
|
}
|
|
|
|
fn v2ToV3(v: core.Vector2f) core.Vectorf {
|
|
return core.Vectorf{ .x = v.x, .z = v.y, .y = 0 };
|
|
}
|
|
|
|
pub fn intersectLine(p1: core.Vector2f, v1: core.Vector2f, p2: core.Vector2f, v2: core.Vector2f) ?core.Vector2f {
|
|
const denom = v1.x * v2.y - v1.y * v2.x;
|
|
|
|
if (@abs(denom) < 0.00001) {
|
|
return null;
|
|
}
|
|
const t = ((p2.x - p1.x) * v2.y - (p2.y - p1.y) * v2.x) / denom;
|
|
|
|
return .{
|
|
.x = p1.x + t * v1.x,
|
|
.y = p1.y + t * v1.y,
|
|
};
|
|
}
|
|
|
|
pub fn drawVector2Test(self: *@This()) void {
|
|
if (ig.begin("vector2Test", null, .{})) {
|
|
editVector2("a", &self.a);
|
|
editVector2("Anormal", &self.Anormal);
|
|
ig.separator();
|
|
editVector2("b", &self.b);
|
|
editVector2("Bnormal", &self.Bnormal);
|
|
}
|
|
ig.end();
|
|
|
|
const a = core.Vectorf{ .x = self.a.x, .z = self.a.y, .y = 0 };
|
|
const b = core.Vectorf{ .x = self.b.x, .z = self.b.y, .y = 0 };
|
|
|
|
const A = core.Vectorf{ .x = self.Anormal.x, .z = self.Anormal.y, .y = 0 };
|
|
const B = core.Vectorf{ .x = self.Bnormal.x, .z = self.Bnormal.y, .y = 0 };
|
|
|
|
core.debugSphere(a, 0.1, .{});
|
|
core.debugSphere(b, 0.1, .{});
|
|
|
|
core.debugLine(a, a.add(A), .{ .color = .{ .y = 0, .x = 1.0 } });
|
|
core.debugLine(b, b.add(B), .{ .color = .{ .y = 0, .x = 1.0 } });
|
|
|
|
const Vab = self.b.sub(self.a);
|
|
const Vba = Vab.negate();
|
|
|
|
core.debugLine(a, a.add(v2ToV3(Vab)), .{ .color = .{ .x = 1.0, .z = 1.0 } });
|
|
// const ADwall = Vab.dot(self.Anormal.removeComponent(Vab.normalize()).normalize());
|
|
// const BDwall = Vba.dot(self.Anormal.removeComponent(Vba.normalize()).normalize());
|
|
|
|
//const Awall = Vab.removeComponent(self.Anormal.normalize()).normalize().fmul(ADwall).normalize();
|
|
const Awall = Vab.removeComponent(self.Anormal.normalize()).normalize();
|
|
const Bwall = Vba.removeComponent(self.Bnormal.normalize()).normalize();
|
|
|
|
//ig.textFmt("Awall: {d} {d}", .{ Awall.x, Awall.y }) catch {};
|
|
core.debugLine(a.sub(v2ToV3(Awall).fmul(10)), a.add(v2ToV3(Awall).fmul(10)), .{ .color = .{ .y = 1.0, .z = 1.0 } });
|
|
|
|
// ig.textFmt("Bwall: {d} {d}", .{ Bwall.x, Bwall.y }) catch {};
|
|
core.debugLine(b.sub(v2ToV3(Bwall).fmul(10)), b.add(v2ToV3(Bwall).fmul(10)), .{ .color = .{ .y = 1.0, .z = 1.0 } });
|
|
|
|
const vp = intersectLine(self.a, Awall.normalize(), self.b, Bwall.normalize()) orelse {
|
|
return;
|
|
};
|
|
|
|
// ig.textFmt("p, y: {d} {d}", .{ vp.x, vp.y }) catch {};
|
|
core.debugSphere(v2ToV3(vp), 0.1, .{ .color = .{ .y = 1.0, .z = 1.0, .x = 1.0 } });
|
|
}
|
|
|
|
fn onAltFire(ctx: ?*anyopaque, _: core.ActionEvent) void {
|
|
const self: *@This() = @ptrCast(@alignCast(ctx));
|
|
|
|
if (platform.context().isCursorEnabled()) {
|
|
core.engine_logs("moving light");
|
|
const ray = rend.context().activeCamera.?.getNormalRayFromScreen(platform.getCursorPosition());
|
|
if (physics.traceLine(ray.start, ray.dir.fmul(10000), .{ .bodyFilter = &self.fireTraceFilter, .getNormalsSlow = true })) |r| {
|
|
if (r.normal) |n| {
|
|
const p = r.point.add(n.fmul(0.2));
|
|
core.debugSphere(p, 0.2, .{ .color = .{ .y = 1.0 }, .duration = 10.0 });
|
|
rend.context().lightPosition = p;
|
|
}
|
|
|
|
// core.debugLine(ray.start, ray.start.add(ray.dir.fmul(1000)), .{ .duration = 2.5 });
|
|
// physics.applyForce(r.body, ray.dir.fmul(400), r.point);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn onFire(ctx: ?*anyopaque, _: core.ActionEvent) void {
|
|
const self: *@This() = @ptrCast(@alignCast(ctx));
|
|
|
|
if (platform.context().isCursorEnabled()) {
|
|
core.engine_logs("moving light");
|
|
const ray = rend.context().activeCamera.?.getNormalRayFromScreen(platform.getCursorPosition());
|
|
if (physics.traceLine(ray.start, ray.dir.fmul(10000), .{ .bodyFilter = &self.fireTraceFilter, .getNormalsSlow = true })) |r| {
|
|
if (r.normal) |n| {
|
|
const p: core.Vectorf = r.point.add(n.fmul(0.2));
|
|
|
|
const posRot = core.ScenePosRot{
|
|
.position = p,
|
|
};
|
|
self.spawnedEntities.append(self.allocator, core.get(extras.ObjectSystemSpawner).spawnObjectAt(posRot) orelse return) catch unreachable;
|
|
|
|
// addBox(p.add(n.fmul(1.0))) catch unreachable;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn tick(self: *@This(), dt: f64) void {
|
|
const rctx = rend.context();
|
|
_ = rctx;
|
|
_ = dt;
|
|
|
|
if (core.getEngineObject(imgui.utils.TopBar)) |topbar| {
|
|
topbar.menuOpen = platform.context().isCursorEnabled();
|
|
}
|
|
|
|
if (self.displayVectorsTest) {
|
|
self.drawVector2Test();
|
|
}
|
|
|
|
if (self.firstTick) {
|
|
self.loadMap2() catch unreachable;
|
|
self.firstTick = false;
|
|
}
|
|
|
|
if (platform.context().isCursorEnabled()) {
|
|
if (ig.begin("meh", null, .{})) {
|
|
// if (ig.checkbox("move lights ", null)) {}
|
|
|
|
ig.textFmt("info: - WASD to move, mouse to look,\n- Q and E to go up and down lol", .{}) catch return;
|
|
ig.textFmt("- shift to slow down camera speed", .{}) catch return;
|
|
ig.textFmt("- T to enable/disable mouse cursor", .{}) catch return;
|
|
ig.textFmt("- f2 to route all inputs to the doom player", .{}) catch return;
|
|
ig.textFmt("- movingLight checkbox makes the light stop moving with you", .{}) catch return;
|
|
|
|
if (ig.smallButton("reload map")) {
|
|
self.loadMap2() catch unreachable;
|
|
}
|
|
|
|
if (ig.smallButton("destroy map")) {
|
|
if (self.tbMap) |tbMap| {
|
|
core.engine_log("killing the map", .{});
|
|
tbMap.destroy();
|
|
self.tbMap = null;
|
|
}
|
|
}
|
|
if (ig.smallButton("dumpTimeline")) {
|
|
core.MemoryTracker.dumpTimeline("timeline.txt") catch unreachable;
|
|
}
|
|
|
|
if (ig.checkbox("vectors test", &self.displayVectorsTest)) {}
|
|
if (ig.checkbox("showdebug", &ui.context().screenContext.drawDebug)) {}
|
|
|
|
if (ig.smallButton("click for fun")) {
|
|
// var soundname = core.MakeName("s_macintosh");
|
|
// audio.context().playSound(&soundname) catch {};
|
|
}
|
|
|
|
if (ig.sliderFloat("sliderFloat", &self.volume, 0, 100, null, .{})) {
|
|
audio.context().setVolume(self.volume / 100);
|
|
}
|
|
|
|
if (ig.smallButton("host")) {
|
|
self.session = net.hostSession(&.{"7777"}) catch unreachable;
|
|
}
|
|
|
|
if (ig.smallButton("connect")) {
|
|
self.clientLink = net.connect("127.0.0.1:7777") catch unreachable;
|
|
}
|
|
|
|
if (self.clientLink) |link| {
|
|
if (ig.smallButton("sendMessageToServer")) {
|
|
link.sendMessage("hello from client", true) catch {};
|
|
}
|
|
}
|
|
}
|
|
ig.end();
|
|
|
|
if (platform.context().isCursorEnabled()) {
|
|
if (rend.context().activeCamera) |cam| {
|
|
const ray = cam.getNormalRayFromScreen(platform.getCursorPosition());
|
|
|
|
if (physics.traceLine(ray.start, ray.dir.fmul(10000), .{ .bodyFilter = &self.fireTraceFilter, .getNormalsSlow = false })) |r| {
|
|
core.debugSphere(r.point, 0.2, .{ .color = .{ .x = 1.0 }, .duration = 0 });
|
|
}
|
|
}
|
|
}
|
|
self.particleDebugger.particleDebug();
|
|
}
|
|
}
|
|
|
|
pub fn destroy(self: *@This()) void {
|
|
if (self.clientLink) |link| {
|
|
link.destroy();
|
|
}
|
|
|
|
if (self.session) |session| {
|
|
session.destroy();
|
|
}
|
|
|
|
if (self.tbMap) |map| {
|
|
map.destroy();
|
|
}
|
|
for (self.spawnedEntities.items) |*entity| {
|
|
entity.destroy();
|
|
}
|
|
|
|
self.spawnedEntities.deinit(self.allocator);
|
|
self.consoleWindow.deinit();
|
|
self.physicsObjectsWindow.destroy();
|
|
self.allocator.destroy(Slack.fromPtr(self));
|
|
}
|
|
};
|
|
|
|
pub export fn shutdown() void {}
|
|
|
|
const std = @import("std");
|
|
const backlog = @import("backlog");
|
|
const core = backlog.core;
|
|
const imgui = backlog.imgui;
|
|
const physics = backlog.physics;
|
|
const rend = backlog.rend;
|
|
const ig = imgui.api;
|
|
const sys = backlog.sys;
|
|
const ui = backlog.ui;
|
|
const net = backlog.net;
|
|
const audio = backlog.audio;
|
|
const platform = backlog.platform;
|
|
const extras = @import("gameExtras");
|
|
const bsp = @import("bsp");
|