ecker/engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Commit for 2022.07.10 23-56-57.7z

Browse Source
This commit is contained in:
mrq 2022-07-10 23:56:00 -05:00
parent cbd76acbd5
commit 403aa11343
69 changed files with 889 additions and 1099 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -343,7 +343,7 @@ clean:
@-rm -f $(OBJS_EXT_DLL)
@-rm -f $(OBJS)
@-rm $(shell find $(ENGINE_SRC_DIR) -name "*.$(PREFIX).o") $(shell find $(EXT_SRC_DIR) -name "*.$(PREFIX).o") $(shell find $(DEP_SRC_DIR) -name "*.$(PREFIX).o")
#@-rm $(shell find $(ENGINE_SRC_DIR) -name "*.$(PREFIX).o") $(shell find $(EXT_SRC_DIR) -name "*.$(PREFIX).o") $(shell find $(DEP_SRC_DIR) -name "*.$(PREFIX).o")
ifneq (,$(findstring dreamcast,$(ARCH)))
@-rm ./bin/dreamcast/build/*
@ -391,4 +391,4 @@ backup:
#make CC=zig RENDERER=opengl clean
#make CC=zig RENDERER=vulkan clean
@-rm $(shell find $(ENGINE_SRC_DIR) -name "*.o") $(shell find $(EXT_SRC_DIR) -name "*.o") $(shell find $(DEP_SRC_DIR) -name "*.o")
$(7Z) a -r ../misc/backups/$(shell date +"%Y.%m.%d\ %H-%M-%S").7z .
$(7Z) a -bsp1 -r ../misc/backups/$(shell date +"%Y.%m.%d\ %H-%M-%S").7z .

11
bin/data/config.json
View File

@ -6,12 +6,12 @@
"matrix": { "reverseInfinite": true },
"lights": { "enabled": true,
"useLightmaps": false,
"max": 32
"max": 48
},
"shadows": {
"enabled": true,
"update": 2,
"max": 16,
"update": 4,
"max": 24,
"samples": 1
},
"textures": {
@ -38,8 +38,8 @@
}
},
"rt": {
"size": [ 960, 540 ],
"filter": "NEAREST",
// "size": [ 1280, 720 ],
"filter": "nearest",
"defaultRayBounds": [ 0.001, 1024.0 ],
"alphaTestOffset": 0.001,
"samples": 1,
@ -193,6 +193,7 @@
"interpolate": false,
"debug draw": {
"enabled": false,
"line width": 8,
// "layer": "Gui",
"rate": 0.0125
}

52
bin/data/entities/burger.json Normal file
View File

@ -0,0 +1,52 @@
{
"type": "Object",
"name": "Burger",
"ignore": false,
"import": "/model.json",
"assets": [
// "/burger/burger.glb"
"/burger/burger/graph.json"
],
"behaviors": [],
"transform": {
"position": [ -0.574743, 2.3547, -5.05161 ],
"rotation": {
"axis": [ 0, 1, 0 ],
"angle": 0
},
"scale": [ 1, 1, 1 ]
},
"system": {
"hot reload": {
"enabled": true
}
},
"metadata": {
"holdable": true,
"physics": {
"gravity": [ 0, -9.81, 0 ],
"inertia": [ 0, 0, 0 ],
"mass": 10,
"type": "bounding box",
"recenter": false
},
"model": {
"exporter": {
"enabled": true,
"unwrap": false,
"optimize": false
},
"baking": {
"enabled": false
},
"renderer": {
"flip textures": false
},
"lighting": {
"lightmap": false
}
}
}
}

0
bin/data/scenes/sh2_mcdonalds/door.json → bin/data/entities/door.json
View File

24
bin/data/entities/model.json
View File

@ -38,7 +38,7 @@
},
"baking": {
"enabled": true,
"resolution": 8192,
"resolution": 2048,
"shadows": 1024,
"layers": 1,
"trigger": { "mode": "rendered", "quit": true },
@ -46,7 +46,7 @@
"output": "./lightmap.%i.png",
"settings": {
"useInputMeshUvs": true,
"maxIterations": 16,
"maxIterations": 4,
// "maxChartSize": 0,
"padding": 4,
// "texelsPerUnit": 0,
@ -59,19 +59,15 @@
}
},
"renderer": {
"front face": "ccw",
"front face": "auto",
"cull mode": "back",
"filter": "linear"
},
"flags": {
"ATLAS": false,
"INVERT": false,
"TRANSFORM": false,
"SKINNED": false,
"RENDER": true,
"SEPARATE": false,
"NORMALS": false
"filter": "linear",
"atlas": false,
"invert": true,
"skinned": false,
"render": true,
"separate": false
},
"lights": {
"lightmap": "auto",

11
bin/data/entities/player.json
View File

@ -2,7 +2,8 @@
"name": "Player",
"type": "Object",
"behaviors": [
"PlayerBehavior"
"PlayerBehavior",
"SoundEmitterBehavior"
],
"ignore": false,
"transform": {
@ -14,8 +15,11 @@
"scale": [ 1, 1, 1 ]
},
"assets": [
// { "filename": "./playerModel.json", "delay": 1 },
"./playerModel.json",
"./hands.json"
"./playerLight.json",
"./playerHands.json",
"./scripts/player.lua"
],
"system": {
"hot reload": {
@ -96,6 +100,9 @@
"clip" : [ 0.1, 64.0 ],
"size" : [ 0, 0 ]
}
},
"use": {
"length": 5
}
}
}

0
bin/data/entities/hands.json → bin/data/entities/playerHands.json
View File

32
bin/data/entities/playerLight.json Normal file
View File

@ -0,0 +1,32 @@
{
"import": "/light.json",
"ignore": false,
"assets": [
],
"transform": {
"track": "parent",
"position": [ 0, 1.7, 0 ]
},
"system": {
"hot reload": {
"enabled": true
}
},
"metadata": {
"light": {
"type": "point",
"color": [1, 1, 1],
"power": 15,
"fov": 90,
"bias": {
"constant": 1.25,
"slope": 1.75,
"shader": 0.000005 //0.000000005
},
"radius": [0.001, 0],
"resolution": 1024,
"shadows": false,
"static": false
}
}
}

30
bin/data/entities/playerModel.json
View File

@ -29,7 +29,11 @@
"track": true,
"hide": true,
"model": {
"lightmap": false,
"debug": {
"print": {
"animations": true
}
},
"exporter": {
"enabled": false,
"unwrap": false,
@ -38,17 +42,19 @@
"baking": {
"enabled": false
},
"animation": "wank",
"print animations": true,
"flags": {
"ATLAS": false,
"INVERT": true,
"TRANSFORM": false,
"SKINNED": false,
"RENDER": true,
"SEPARATE": false,
"NORMALS": false
"renderer": {
"cull mode": "back",
"filter": "linear"
},
"lights": {
"lightmap": false
},
"renderer": {
"flip textures": false,
"skinned": true
},
"animations": {
"animation": "wank"
}
}
}

14
bin/data/entities/prop.json Normal file
View File

@ -0,0 +1,14 @@
{
"assets": [],
"metadata": {
"holdable": true,
"physics": {
"gravity": [ 0, -9.81, 0 ],
"inertia": [10, 10, 10],
"mass": 10,
"type": "bounding box",
"recenter": true
}
}
}

15
bin/data/scenes/sh2_mcdonalds/scripts/door.lua → bin/data/entities/scripts/door.lua
View File

@ -86,13 +86,20 @@ ent:bind( "tick", function(self)
end )
-- on use
ent:addHook( "entity:Use.%UID%", function( payload )
if payload.user == ent:uid() then return end
-- if timer:elapsed() <= 0.125 then return end
-- timer:reset()
print("Processing use: " .. payload["uid"] .. " | " .. payload["depth"] )
if state == 0 or state == 3 then
state = 1
playSound("default_move")
if payload.uid ~= nil then
local player = entities.get( payload.uid )
local pTransform = player:getComponent("Transform")
local delta = transform.position - pTransform.position
local user = entities.get( payload.user )
local userTransform = user:getComponent("Transform")
local delta = transform.position - userTransform.position
local side = normal:dot(delta)
if side > 0 then
polarity = 1
@ -100,7 +107,7 @@ ent:addHook( "entity:Use.%UID%", function( payload )
polarity = -1
end
end
elseif state == 2 or state == 1 then
elseif state == 2 --[[or state == 1]] then
state = 3
playSound("default_move")
end

113
bin/data/entities/scripts/player.lua Normal file
View File

@ -0,0 +1,113 @@
local timer = Timer.new()
if not timer:running() then timer:start(); end
local scene = entities.currentScene()
local metadata = ent:getComponent("Metadata")
local transform = ent:getComponent("Transform")
local camera = ent:getComponent("Camera")
local cameraTransform = camera:getTransform()
local playSound = function( key, loop )
if not loop then loop = false end
local url = "/ui/" .. key .. ".ogg"
ent:queueHook("sound:Emit.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"]),
spatial = true,
streamed = true,
volume = "sfx",
loop = loop
}, 0)
end
local stopSound = function( key )
local url = "/ui/" .. key .. ".ogg"
ent:queueHook("sound:Stop.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"])
}, 0)
end
local heldObject = {
uid = 0,
distance = 0,
smoothSpeed = 4,
scrollSpeed = 16,
momentum = Vector3f(0,0,0)
}
-- on tick
ent:bind( "tick", function(self)
if heldObject.uid ~= 0 then
local wheel = inputs.analog("MouseWheel")
local mouse3 = inputs.key("Mouse3");
if wheel ~= 0 then
heldObject.distance = heldObject.distance + (wheel / 120 * heldObject.scrollSpeed) * time.delta()
end
if mouse3 then
heldObject.rotate = not heldObject.rotate
end
local prop = entities.get( heldObject.uid )
local heldObjectTransform = prop:getComponent("Transform")
local heldObjectPhysicsState = prop:getComponent("PhysicsState")
if heldObject.rotate then
heldObjectTransform.orientation = transform.orientation
end
local transform = cameraTransform:flatten()
local forward = transform.orientation:rotate( Vector3f(0,0,1) ) * heldObject.distance
if heldObject.smoothSpeed ~= 0 then
local target = transform.position + forward
local offset = target - heldObjectTransform.position
local delta = offset * time.delta() * heldObject.smoothSpeed
local distance = delta:norm()
if distance > 0.001 then
heldObjectTransform.position = heldObjectTransform.position + delta
heldObject.momentum = offset * 1000
else
heldObjectTransform.position = target
end
else
heldObjectTransform.position = transform.position + forward
end
end
end )
-- on use
ent:addHook( "entity:Use.%UID%", function( payload )
if payload.user ~= ent:uid() then return end
local validUse = false
if heldObject.uid == 0 then
local prop = entities.get( payload.uid )
local propMetadata = prop:getComponent("Metadata")
if propMetadata["holdable"] then
validUse = true
local offset = transform.position - prop:getComponent("Transform").position
heldObject.uid = payload.uid
heldObject.distance = offset:norm()
prop:getComponent("PhysicsState"):enableGravity(false)
end
elseif heldObject.uid ~= 0 then
validUse = true
local prop = entities.get( heldObject.uid )
local heldObjectPhysicsState = prop:getComponent("PhysicsState")
heldObjectPhysicsState:enableGravity(true)
heldObjectPhysicsState:applyImpulse( heldObject.momentum )
heldObject.uid = 0
heldObject.distance = 0
heldObject.momentum = Vector3f(0,0,0)
elseif payload.uid ~= 0 then
local hit = entities.get( heldObject.uid )
validUse = not string.match( hit:name(), "/^worldspawn_/" )
end
if validUse then
playSound("select")
else
playSound("deny")
end
end )

5
bin/data/scenes/construct/gm_construct.json
View File

@ -8,12 +8,11 @@
"model": {
"baking": {
"enabled": true,
"resolution": 1024,
"resolution": 2048,
"settings": {
// "useInputMeshUvs": false
"useInputMeshUvs": false
}
},
"cull mode": "none",
"tags": {
"/^worldspawn/": {
"physics": { "type": "mesh", "static": true },

11
bin/data/scenes/construct/player.json
View File

@ -4,16 +4,5 @@
// { "filename": "/gui/hud/hud.json", "delay": 0 }
],
"metadata": {
"overlay": {
"floating": true
},
"collider": true,
"light": {
"should": false,
"color": [1, 1, 1],
"position": [ 0, 2.5, 0 ],
"power": 1,
"radius": [0.001, 32]
}
}
}

3
bin/data/scenes/construct/scene.json
View File

@ -2,7 +2,8 @@
"import": "/scene.json",
"assets": [
"./audio/soundscape/ambience.ogg",
"./loading.json"
"./gm_construct.json"
// "./loading.json"
],
"system": {
"hot reload": {

5
bin/data/scenes/cornell/cornell.json
View File

@ -19,11 +19,6 @@
"useInputMeshUvs": false
}
},
"renderer": {
"front face": "cw",
"cull mode": "back",
"filter": "linear"
},
"tags": {
"/^Mesh_/": {
"physics": { "type": "mesh", "static": true },

16
bin/data/scenes/mcdonalds/craeture.json
View File

@ -1,16 +0,0 @@
{
"name": "Craeture",
"behaviors": [ "CraetureBehavior" ],
"assets": [
"./textures/craeture.jpg"
],
"transform": {
"position": [9.62326, 1.1872, -40.8126],
"scale": [8, 8, 8]
},
"metadata": {
"model": {
"cull mode": "none"
}
}
}

9
bin/data/scenes/mcdonalds/door.json
View File

@ -1,9 +0,0 @@
{
"assets": ["./scripts/door.lua"],
"metadata": {
"physics": {
"type": "bounding box",
"recenter": true
}
}
}

32
bin/data/scenes/mcdonalds/loading.json
View File

@ -1,32 +0,0 @@
{
"name": "Gui: Loading",
"type": "Object",
"behaviors": [
// "GuiBehavior"
],
"assets": [
{ "filename": "./mcdonalds.json", "delay": 0 }
],
"ignore": false,
"transform": {
"position": [ -0.830591, -0.699509, 0 ],
"rotation": {
"axis": [ 1, 0, 0 ],
"angle": 0
},
"scale": [ 0.258737, 0.115371, 1 ]
},
"metadata": {
"uv": [ 0, 0, 1, 1 ],
"color": [ 1, 1, 1, 0.1 ],
"location": "",
"scaling": "relative",
"text settings": {
"stroke": [ 1, 0.749, 0.368, 1 ],
"color": [ 1, 0.749, 0.368, 1 ],
"string": "Loading...",
"string1": "コマンド"
}
}
}

24
bin/data/scenes/mcdonalds/marker.json
View File

@ -1,24 +0,0 @@
{
"name": "Marker",
"type": "Gui",
"ignore": false,
"transform": {
"position": [ 0, 0, 0 ],
"rotation": {
"axis": [ 1, 0, 0 ],
"angle": 0
},
"scale": [ 1, 1, 1 ]
},
"metadata": {
"uv": [ 0, 0, 1, 1 ],
"color": [ 1, 1, 1, 0.8 ],
"location": "",
"scaling": [ 1, 1 ],
"world": true,
"gui layer": false
},
"assets": [
"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_in2.png"
]
}

62
bin/data/scenes/mcdonalds/mcdonalds.json
View File

@ -1,62 +0,0 @@
{
"import": "/model.json",
"assets": [
// { "filename": "./static.json", "delay": 8 },
// { "filename": "./models/mcdonalds.glb" }
{ "filename": "./models/mcdonalds/graph.json" }
// { "filename": "./models/mini_mcd.glb" }
// { "filename": "./models/mini_mcd/graph.json" }
// { "filename": "/cornell/cornell.glb" }
// { "filename": "/cornell/cornell/graph.json" }
],
"metadata": {
"model": {
"baking": {
"enabled": true,
"resolution": 2048,
"settings": {
"useInputMeshUvs": false
}
},
"renderer": {
"front face": "cw",
"cull mode": "back",
"filter": "linear"
},
"tags": {
"/^worldspawn/": {
"physics": { "type": "mesh", "static": true },
"grid": { "size": [4,1,4], "epsilon": 1.0, "cleanup": true, "print": true },
"optimize mesh": { "simplify": 0 },
"unwrap mesh": true
},
"info_player_spawn": { "action": "attach", "filename": "./player.json", "preserve orientation": true },
"cornellBox.000": {
"transform": { "position": [ 0, -2, -75 ], "scale": [ 3, 3, 3 ] }
},
"func_door_rotating_5409": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5487": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5495": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5568": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5568": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5576": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5584": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5656": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5664": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5689": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5698": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5712": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5212": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5548": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5931": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"tools/toolsnodraw": { "material": { "base": [0, 0, 0, 0] } }
}
}
}
}

10
bin/data/scenes/mcdonalds/player.json
View File

@ -1,10 +0,0 @@
{
"import": "/player.json",
"assets": [
// { "filename": "/gui/hud/hud.json", "delay": 0 }
],
"system": {
},
"metadata": {
}
}

90
bin/data/scenes/mcdonalds/scene.json
View File

@ -1,90 +0,0 @@
{
"import": "/scene.json",
"assets": [
"./audio/soundscape/ambience.ogg",
// "./loading.json",
"./mcdonalds.json",
"./static.json"
],
"system": {
"hot reload": {
"enabled": true
},
"renderer": {
"shader": {
"mode": 1,
"scalar": 16,
"parameters": [ 0, 0, 0, "time" ],
"frame accumulate limit": 0
},
"clear values": [
[ 1, 1, 1, 0 ]
]
}
},
"metadata": {
"menus": {
"pause": "/gui/pause/menu.json"
},
"bloom": {
"scale": 6.0,
"strength": 0.125,
"sigma": 0.125,
"samples": 8
},
"light": {
"exposure": 1.0,
"gamma": 1.0,
"brightnessThreshold": 1.2,
// "ambient": [ 0, 0, 0 ],
"ambient": [ 0.025, 0.025, 0.025 ],
// "ambient": [ 0.075, 0.075, 0.075 ],
// "ambient": [ 0.1, 0.1, 0.1 ],
// "ambient": [ 0.4, 0.4, 0.4 ],
"fog-": {
"color": [ 0.5, 0.5, 0.5 ],
"range": [ 16, 32 ],
"step scale": 2,
"absorbtion": 0.01,
"density": {
"threshold": 0.35,
"multiplier": 5.0,
"scale": 25.0,
"offset": [0, -1, 1],
"timescale": 8
}
},
"should": true,
"shadows": true
},
"noise": {
"size": [ 32, 32, 32 ]
},
"vxgi": {
/*
"limiter": 1,
"size": 96,
"dispatch": 8,
"cascades": 2,
"cascadePower": 4,
"voxelizeScale": 1,
"shadows": 0,
*/
"occlusionFalloff": 2,
"traceStartOffsetFactor": 1,
"granularity": 2,
"extents": {
"min": [ -1.5, -1.5, -1.5 ],
"max": [ 1.5, 1.5, 1.5 ]
}
},
"rt": {
"defaultRayBounds": [ 0.001, 1024.0 ],
"alphaTestOffset": 1.125,
"samples": 1,
"paths": 1,
"frameAccumulationMinimum": 0
}
}
}

110
bin/data/scenes/mcdonalds/scripts/door.lua
View File

@ -1,110 +0,0 @@
local scene = entities.currentScene()
local controller = entities.controller()
local timer = Timer.new()
if not timer:running() then
timer:start();
end
local polarity = 1
local state = 0
local targetAlpha = 1
local alpha = 0
local target = Vector3f(0,0,0)
local transform = ent:getComponent("Transform")
local metadata = ent:getComponent("Metadata")
local speed = metadata["speed"] or 1.0
local normal = Vector3f(0,0,-1)
if metadata["normal"] ~= nil then
local sign = -1
if metadata["angle"] < 0 then sign = 1 end
normal = Vector3f( metadata["normal"][1] * sign, metadata["normal"][2] * sign, metadata["normal"][3] * sign ):normalize()
end
local starting = Quaternion(transform.orientation)
local ending = transform.orientation:multiply(Quaternion.axisAngle( Vector3f(0,1,0), metadata["angle"] ))
local soundEmitter = ent:loadChild("./sound.json",true)
local playSound = function( key, loop )
if not loop then loop = false end
local url = "/door/" .. key .. ".ogg"
soundEmitter:queueHook("sound:Emit.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"]),
spatial = true,
streamed = true,
volume = "sfx",
loop = loop
}, 0)
end
local stopSound = function( key )
local url = "/door/" .. key .. ".ogg"
soundEmitter:queueHook("sound:Stop.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"])
}, 0)
end
local playSoundscape = function( key )
local url = "/soundscape/" .. key .. ".ogg"
soundEmitter:queueHook("sound:Emit.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"]),
spatial = false,
volume = "sfx",
loop = true,
streamed = true
}, 0)
end
local stopSoundscape = function( key )
local url = "/soundscape/" .. key .. ".ogg"
soundEmitter:queueHook("sound:Stop.%UID%", {
filename = string.resolveURI(url, metadata["system"]["root"])
}, 0)
end
soundEmitter:getComponent("Transform"):setReference( transform )
-- on tick
ent:bind( "tick", function(self)
-- transform.orientation = starting:slerp( ending, math.cos(time.current() * speed) * 0.5 + 0.5 )
if state == 1 then
alpha = alpha + time.delta() * speed
if alpha > targetAlpha then
state = 2
alpha = targetAlpha
playSound("default_stop")
end
end
if state == 3 then
alpha = alpha - time.delta() * speed
if alpha < 0 then
state = 0
alpha = 0
playSound("default_stop")
end
end
if state > 0 then
transform.orientation = starting:slerp( ending, alpha * polarity )
end
end )
-- on use
ent:addHook( "entity:Use.%UID%", function( payload )
if state == 0 then
state = 1
playSound("default_move")
if payload.uid ~= nil then
local player = entities.get( payload.uid )
local pTransform = player:getComponent("Transform")
local delta = transform.position - pTransform.position
local side = normal:dot(delta)
if side > 0 then
polarity = 1
elseif side < 0 then
polarity = -1
end
end
io.print(ent:name())
end
if state == 2 then
state = 3
playSound("default_move")
end
io.print( state, json.encode( payload ) )
end )

22
bin/data/scenes/mcdonalds/scripts/realign.lua
View File

@ -1,22 +0,0 @@
local scene = entities.currentScene()
local controller = entities.controller()
local timer = Timer.new()
if not timer:running() then
timer:start();
end
local transform = ent:getComponent("Transform")
-- on tick
ent:bind( "tick", function(self)
local offset = Vector3f(0,0,0)
if window.keyPressed("J") then offset.x = offset.x - time.delta() end
if window.keyPressed("L") then offset.x = offset.x + time.delta() end
if window.keyPressed("N") then offset.y = offset.y - time.delta() end
if window.keyPressed("M") then offset.y = offset.y + time.delta() end
if window.keyPressed("I") then offset.z = offset.z - time.delta() end
if window.keyPressed("K") then offset.z = offset.z + time.delta() end
if offset:magnitude() > 0.0001 then
transform.position = transform.position + offset
end
end )

90
bin/data/scenes/mcdonalds/scripts/static.lua
View File

@ -1,90 +0,0 @@
local scene = entities.currentScene()
local controller = entities.controller()
local timer = Timer.new()
if not timer:running() then
timer:start();
end
-- release control
--[[
hooks.call("window:Mouse.CursorVisibility", { state = true })
hooks.call("window:Mouse.Lock", {});
]]
-- on tick
ent:bind( "tick", function(self)
-- update static effect
local metadatas = {
ent = ent:getComponent("Metadata"),
scene = scene:getComponent("Metadata")
}
local transforms = {
ent = ent:getComponent("Transform"),
controller = controller:getComponent("Transform")
}
local distanceSquared = transforms.controller.position:distance( transforms.ent.position )
distanceSquared = distanceSquared * distanceSquared
if type(metadatas.ent["static"]["scale"]) == "number" then
distanceSquared = distanceSquared * metadatas.ent["static"]["scale"]
end
local lo = type(metadatas.ent["static"]["range"][1]) == "number" and metadatas.ent["static"]["range"][1] or 0.1
local hi = type(metadatas.ent["static"]["range"][2]) == "number" and metadatas.ent["static"]["range"][2] or 0.5
local staticBlend = distanceSquared > 1 and 1.0 / distanceSquared or 1.0
staticBlend = math.clamp( staticBlend, lo, hi )
local flicker = type(metadatas.ent["static"]["flicker"]) == "number" and metadatas.ent["static"]["flicker"] or 0.001
local pieces = type(metadatas.ent["static"]["pieces"]) == "number" and metadatas.ent["static"]["pieces"] or 1000
local payload = {
mode = 2,
parameters = {
[1] = flicker,
[2] = pieces,
[3] = staticBlend,
[4] = "time"
}
}
scene:callHook("shader:Update.%UID%", payload)
end )
--[[
local hud = ent:loadChild("/hud.json", true)
hud:bind( "tick", function(self)
-- update distance HUD element
if timer:elapsed() <= 0.0125 then return end
timer:reset()
local metadata = self:getComponent("Metadata")
local transforms = {
controller = controller:getComponent("Transform"),
source = ent:getComponent("Transform")
}
local distance = transforms.controller.position:distance( transforms.source.position )
--distance = string.si( distance, "m" )
local maximum = 40
local value = math.floor(distance/maximum * 100)
if value >= 100 then value = 100 end
distance = "Sanity: " .. value .. "%"
--distance = math.floor((15-distance)/15 * 100) .. "%"
if metadata["text settings"]["string"] ~= distance then
self:callHook( "gui:UpdateString.%UID%", {
string = distance
} )
end
end )
]]
--[[
local marker = ent:loadChild("./marker.json", true)
marker:bind( "tick", function(self)
local transform = marker:getComponent("Transform")
local parentTransform = ent:getComponent("Transform")
local controllerTransform = controller:getComponent("Transform")
local controllerCamera = controller:getComponent("Camera")
local controllerCameraTransform = controllerCamera:getTransform()
transform.position = parentTransform.position + Vector3f(0,3,0)
transform.orientation = Quaternion.lookAt( transform.position - controllerTransform.position, Vector3f(0,1,0) )
-- transform.orientation = transform.orientation:normalize()
-- transform.model = controllerCamera:getProjection() * controllerCamera:getView() * Matrix4f.translate( transform.position ) * transform.orientation:matrix()
end )
]]

34
bin/data/scenes/mcdonalds/sound.json
View File

@ -1,34 +0,0 @@
{
"type": "Object",
"name": "Sound Emitter",
"ignore": false,
"assets": [
],
"behaviors": [
"SoundEmitterBehavior"
],
"transform": {
"reference": true
},
"system": {
"hot reload": {
"enabled": true
},
"defaults": {
"render": true,
"asset load": true
},
"load": {
"ignore": true
}
},
"metadata": {
"audio": {
"spatial": true,
"loop": false,
"volume": 1,
"rolloffFactor": 0.5,
"epsilon": 0.5
}
}
}

48
bin/data/scenes/mcdonalds/static.json
View File

@ -1,48 +0,0 @@
{
"type": "Object",
"name": "Static Emitter",
"ignore": false,
"assets": [
"/overworld/static.ogg",
"./scripts/static.lua"
],
"behaviors": [
"SoundEmitterBehavior"
],
"transform": {
"position": [ -13.4342, 2.43658, 298.797 ],
"rotation": {
"axis": [ 0, 1, 0 ],
"angle": 0
},
"scale": [ 1, 1, 1 ]
},
"system": {
"hot reload": {
"enabled": true
},
"defaults": {
"render": true,
"asset load": true
},
"load": {
"ignore": true
}
},
"metadata": {
"audio": {
"spatial": true,
"loop": true,
"streamed": false,
"volume": 1.6,
"rolloffFactor": 2
},
"static": {
"range": [ 0.0025, 1 ],
"flicker": 0.5,
"pieces": 16,
"scale": 0.4
},
"distance": false
}
}

5
bin/data/scenes/sh2_mcdonalds/player.json
View File

@ -1,9 +1,6 @@
{
"import": "/player.json",
"assets": [
// { "filename": "/gui/hud/hud.json", "delay": 0 }
"./playerLight.json"
],
"assets": [],
"metadata": {
}
}

11
bin/data/scenes/sh2_mcdonalds/prop.json
View File

@ -1,11 +0,0 @@
{
"assets": [],
"metadata": {
"physics": {
"mass": 0,
"inertia": [0, 0, 0],
"type": "bounding box",
"recenter": true
}
}
}

48
bin/data/scenes/sh2_mcdonalds/scene.json
View File

@ -26,28 +26,31 @@
"pause": "/gui/pause/menu.json"
},
"bloom": {
"scale": 1.0,
"strength": 1.0,
"sigma": 2.0,
"samples": 2
"scale": 6.0,
"strength": 0.125,
"sigma": 0.125,
"samples": 8
},
"light": {
"exposure": 1.0,
"gamma": 1.0,
"brightnessThreshold": 1.2,
"ambient": [ 0.15, 0.15, 0.15 ],
// "ambient": [ 0, 0, 0 ],
// "ambient": [ 0.025, 0.025, 0.025 ],
// "ambient": [ 0.075, 0.075, 0.075 ],
"ambient": [ 0.1, 0.1, 0.1 ],
// "ambient": [ 0.4, 0.4, 0.4 ],
"fog": {
"color": [ 0.5, 0.5, 0.5 ],
"range": [ 8, 256 ],
"range": [ 16, 32 ],
"step scale": 2,
"absorbtion": 0.07,
"absorbtion": 0.01,
"density": {
"threshold": 0.35,
"multiplier": 5.0,
"scale": 25.0,
"offset": [0.2, 0, 1],
"offset": [0, -1, 1],
"timescale": 8
}
},
@ -55,7 +58,32 @@
"shadows": true
},
"noise": {
"size": [ 16, 16, 16 ]
"size": [ 32, 32, 32 ]
},
"vxgi": {
/*
"limiter": 1,
"size": 96,
"dispatch": 8,
"cascades": 2,
"cascadePower": 4,
"voxelizeScale": 1,
"shadows": 0,
*/
"occlusionFalloff": 2,
"traceStartOffsetFactor": 1,
"granularity": 2,
"extents": {
"min": [ -1.5, -1.5, -1.5 ],
"max": [ 1.5, 1.5, 1.5 ]
}
},
"rt": {
"defaultRayBounds": [ 0.5, 1024.0 ],
"alphaTestOffset": 1.125,
"samples": 1,
"paths": 1,
"frameAccumulationMinimum": 0
}
}
}

104
bin/data/scenes/sh2_mcdonalds/sh2_mcdonalds.json
View File

@ -7,28 +7,27 @@
// { "filename": "./models/sh_mcd/graph.json" }
// { "filename": "./models/mcdonalds.glb" }
{ "filename": "./models/mcdonalds/graph.json" }
{ "filename": "./models/mcdonalds/graph.json" },
// { "filename": "./models/mini_mcd.glb" }
// { "filename": "./models/mini_mcd/graph.json" }
// { "filename": "/cornell/cornell.glb" }
// { "filename": "/cornell/cornell/graph.json" }
{ "filename": "/burger.json" }
],
"metadata": {
"model": {
"baking": {
"enabled": true,
"resolution": 1024,
"resolution": 2048,
"settings": {
"useInputMeshUvs": false
}
},
"renderer": {
"front face": "cw",
"cull mode": "back",
"filter": "linear",
"alpha mode": "blend"
"filter": "linear"
},
"tags": {
"/^worldspawn/": {
@ -42,84 +41,31 @@
// "worldspawn_sh2": { "physics": { "type": "mesh", "static": true } },
"info_player_spawn": { "action": "attach", "filename": "./player.json", "preserve orientation": true },
"func_door_rotating_5409": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5487": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5495": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5656": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5664": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5689": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5698": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5712": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5409": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5487": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5495": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5656": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle": 1.570795, "normal": [ 1,0,0] } } },
"func_door_rotating_5664": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5689": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5698": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5712": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5212": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5548": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5931": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5212": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5548": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5931": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5568": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5576": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5584": { "action": "load", "payload": { "import": "./door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5568": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5576": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_door_rotating_5584": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"/^func_door_/": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"func_physbox_5212": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_5548": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_5931": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5839": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5848": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5857": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5864": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5872": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5879": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5886": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5893": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5905": { "action": "load", "payload": { "import": "./prop.json" } },
"func_physbox_multiplayer_5913": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5563": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5564": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5687": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5719": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5721": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5722": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5815": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5816": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5817": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5818": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5819": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5820": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_multiplayer_5821": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5227": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5373": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5374": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5375": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5545": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5546": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5565": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5566": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5591": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5675": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5680": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5681": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5682": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5683": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5684": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5685": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5696": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5707": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5723": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5749": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5750": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5760": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5764": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5787": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5807": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5808": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5809": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5810": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5814": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5822": { "action": "load", "payload": { "import": "./prop.json" } },
"prop_physics_override_5824": { "action": "load", "payload": { "import": "./prop.json" } },
"/^func_physbox/": { "action": "load", "payload": { "import": "/prop.json" } },
"/^prop_physics/": { "action": "load", "payload": { "import": "/prop.json" } },
"tools/toolsnodraw": { "material": { "base": [0, 0, 0, 0] } },
"materials/models/props_wasteland/prison_lamp001a": { "material": { "emissive": [0, 0, 0, 0] } }
}
"materials/models/props_wasteland/prison_lamp001a": { "material": { "emissive": [0, 0, 0, 0] } },
"/alpha_mtl/": { "material": { "modeAlpha": "blend" } }
}
}
}
}

5
bin/data/scenes/sm64/sm64.json
View File

@ -14,7 +14,6 @@
}
},
"renderer": {
"front face": "cw",
"cull mode": "none",
"filter": "nearest"
},
@ -27,8 +26,8 @@
},
"info_player_spawn": { "action": "attach", "filename": "./player.json" },
"Material.071_574B138E_c.bmp": { "material": { "modeAlpha": "BLEND" } },
"Material.070_41A41EE3_c.bmp": { "material": { "modeAlpha": "BLEND" } },
"Material.071_574B138E_c.bmp": { "material": { "modeAlpha": "blend" } },
"Material.070_41A41EE3_c.bmp": { "material": { "modeAlpha": "blend" } },
"light_sun": { "light": { "power": 25000 } }
}

15
bin/data/scenes/ss2/medsci.json
View File

@ -11,20 +11,18 @@
// { "filename": "./models/micro_sci/graph.json" }
// { "filename": "./models/msci.glb" }
// { "filename": "./models/msci/graph.json" }
{ "filename": "./models/msci/graph.json" }
// { "filename": "./models/medsci.glb" }
{ "filename": "./models/medsci/graph.json" }
// { "filename": "./models/medsci/graph.json" }
],
"metadata": {
"model": {
"baking": {
"enabled": true,
"resolution": 1024
"resolution": 2048
},
"renderer": {
"front face": "cw",
"cull mode": "back",
"filter": "linear"
},
"tags": {
@ -49,7 +47,12 @@
"prop_camera_103118": { /*"bake": false,*/ "action": "load", "payload": { "import": "./camera.json" } },
"func_movelinear_57637": { /*"bake": false,*/ "action": "load", "payload": { "import": "./lift.json", "metadata": { "delta": [ 0,8.6,0 ] } } },
"func_movelinear_82820": { /*"bake": false,*/ "action": "load", "payload": { "import": "./lift.json", "metadata": { "delta": [ 0,9.2,0 ] } } },
"func_movelinear_103114": { /*"bake": false,*/ "action": "load", "payload": { "import": "./lift.json", "metadata": { "delta": [ 0,-3.0,0 ] } } }
"func_movelinear_103114": { /*"bake": false,*/ "action": "load", "payload": { "import": "./lift.json", "metadata": { "delta": [ 0,-3.0,0 ] } } },
"/^func_door_/": { "action": "load", "payload": { "import": "/door.json", "metadata": { "angle":-1.570795, "normal": [-1,0,0] } } },
"/^func_physbox/": { "action": "load", "payload": { "import": "/prop.json" } },
"/^prop_physics/": { "action": "load", "payload": { "import": "/prop.json" } }
}
}
}

3
bin/data/scenes/ss2/scene.json
View File

@ -35,7 +35,8 @@
"gamma": 1.0,
"brightnessThreshold": 1.2,
"ambient": [ 0.0, 0.0, 0.0 ],
// "ambient": [ 0.0, 0.0, 0.0 ],
"ambient": [ 0.1, 0.1, 0.2 ],
"fog": {
"color": [ 0.025, 0.025, 0.1 ],

5
bin/data/shaders/common/vxgi.h
View File

@ -150,6 +150,7 @@ void indirectLighting() {
indirectDiffuse += voxelConeTrace( ray, DIFFUSE_CONE_APERTURE ) * weight;
weight = PI * 0.15f;
}
// indirectDiffuse.rgb *= surface.material.albedo.rgb;
surface.material.occlusion += 1.0 - clamp(indirectDiffuse.a, 0.0, 1.0);
// outFragColor.rgb = indirectDiffuse.rgb; return;
// outFragColor.rgb = vec3(surface.material.occlusion); return;
@ -160,10 +161,8 @@ void indirectLighting() {
ray.direction = R;
ray.origin = P; // + ray.direction;
indirectSpecular = voxelConeTrace( ray, SPECULAR_CONE_APERTURE );
// indirectSpecular.rgb *= surface.material.albedo.rgb;
// outFragColor.rgb = indirectSpecular.rgb; return;
if ( length(indirectSpecular) < 0.0125 ) {
// indirectSpecular += (1.0 - indirectSpecular.a) * texture( samplerCubemaps[ubo.indexSkybox], R ) * SPECULAR_CONE_APERTURE;
}
}
surface.material.indirect = indirectDiffuse * DIFFUSE_INDIRECT_FACTOR + indirectSpecular * SPECULAR_INDIRECT_FACTOR;

6
bin/data/shaders/raytrace/shader.ray-gen.glsl
View File

@ -13,9 +13,7 @@ layout (constant_id = 3) const uint CASCADES = 1;
#define PBR 1
#define VXGI 0
#define RAYTRACE 1
#define FOG 1
#define FOG_RAY_MARCH 0
#define FOG_BASIC 1
#define FOG 0
#define BLOOM 0
#define WHITENOISE 0
#define MAX_TEXTURES TEXTURES
@ -98,7 +96,7 @@ float shadowFactor( const Light light, float def ) {
ray.direction = light.position - ray.origin;
float tMin = ubo.settings.rt.defaultRayBounds.x;
float tMax = length(ray.direction);
float tMax = length(ray.direction) - 0.0001;
ray.direction = normalize(ray.direction);

2
bin/dreamcast/config.json
View File

@ -1,7 +1,7 @@
{
"engine": {
"scenes": {
"start": "SM64",
"start": "SS2",
"meshes": { "interleaved": false },
"matrix": { "reverseInfinite": false },
"lights": { "enabled": false,

9
engine/inc/uf/engine/object/payloads.h
View File

@ -6,5 +6,14 @@ namespace pod {
size_t uid{};
uf::Object* pointer = NULL;
};
struct entitySpawn {
uf::stl::string filename;
uf::Serializer metadata;
pod::Transform<> transform;
pod::payloads::Entity parent;
};
}
}

12
engine/inc/uf/ext/json/json.h
View File

@ -46,6 +46,8 @@ namespace ext {
void UF_API forEach( const ext::json::Value& json, const std::function<void(size_t, const ext::json::Value&, bool&)>& function );
void UF_API forEach( const ext::json::Value& json, const std::function<void(const uf::stl::string&, const ext::json::Value&, bool&)>& function );
template<typename T> uf::stl::vector<T> vector( const ext::json::Value& value );
ext::json::Value UF_API reencode( const ext::json::Value& json, const ext::json::EncodingSettings& settings );
ext::json::Value& UF_API reencode( ext::json::Value& json, const ext::json::EncodingSettings& settings );
@ -71,6 +73,16 @@ namespace ext {
}
}
template<typename T>
uf::stl::vector<T> ext::json::vector( const ext::json::Value& value ) {
uf::stl::vector<T> res;
res.reserve( value.size() );
ext::json::forEach( value, [&]( const ext::json::Value& value ){
res.emplace_back( value.as<T>() );
});
return res;
}
template<typename T>
T& ext::json::encode( const ext::json::Value& json, T& output, const ext::json::EncodingSettings& settings ) {
// ext::json::Value json = ext::json::reencode( _json, settings );

1
engine/inc/uf/ext/reactphysics/reactphysics.h
View File

@ -92,6 +92,7 @@ namespace ext {
// synchronize bullet transforms to engine transforms
void UF_API syncFrom( float = 1 );
// apply impulse
void UF_API setImpulse( pod::PhysicsState&, const pod::Vector3f& = {} );
void UF_API applyImpulse( pod::PhysicsState&, const pod::Vector3f& );
// directly move a transform
void UF_API applyMovement( pod::PhysicsState&, const pod::Vector3f& );

15
engine/inc/uf/utils/io/inputs.h
View File

@ -125,6 +125,11 @@ namespace uf {
constexpr key_t Num8 = UF_KEY("Num8");
constexpr key_t Num9 = UF_KEY("Num9");
constexpr key_t Num0 = UF_KEY("Num0");
constexpr key_t Mouse1 = UF_KEY("Mouse1");
constexpr key_t Mouse2 = UF_KEY("Mouse2");
constexpr key_t Mouse3 = UF_KEY("Mouse3");
constexpr key_t MouseWheel = UF_KEY("MouseWheel");
};
namespace states {
extern UF_API state_t LShift;
@ -228,6 +233,12 @@ namespace uf {
extern UF_API state_t Num8;
extern UF_API state_t Num9;
extern UF_API state_t Num0;
extern UF_API state_t Mouse1;
extern UF_API state_t Mouse2;
extern UF_API state_t Mouse3;
extern UF_API analog_t MouseWheel;
};
}
namespace controller {
@ -296,5 +307,9 @@ namespace uf {
extern UF_API state_t START;
};
}
state_t key( const uf::stl::string& );
analog_t analog( const uf::stl::string& );
analog2_t analog2( const uf::stl::string& );
}
}

57
engine/inc/uf/utils/mesh/grid.h
View File

@ -121,59 +121,4 @@ namespace uf {
return partitioned;
}
}
}
#if 0
namespace uf {
class UF_API MeshGrid {
protected:
struct Node {
pod::Vector3f center = {}; // not necessary since we can easily calculate this on the fly in get()
pod::Vector3f extent = {}; // not necessary since this can be pre-computed on initialization()
#if 0
size_t count = 0;
uint32_t* indices = NULL;
#else
uf::stl::vector<uint32_t> indices;
#endif
};
pod::Vector3ui m_size = {1,1,1};
pod::Vector3f m_center = {};
pod::Vector3f m_extent = {};
uf::stl::vector<Node> m_nodes;
void initialize( const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3ui& );
void destroy();
void allocate( Node&, size_t );
Node& at( const pod::Vector3f& );
const Node& at( const pod::Vector3f& ) const;
pod::Vector3f centroid( const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3f& ) const;
pod::Vector3i wrapIndex( size_t index );
size_t unwrapIndex( const pod::Vector3i& );
void insert( uint32_t, uint32_t, uint32_t, const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3f& );
public:
~MeshGrid();
template<typename T, typename U>
void initialize( const uf::Mesh<T,U>& mesh, size_t = 1 );
template<typename T, typename U>
void initialize( const uf::Mesh<T,U>& mesh, const pod::Vector3ui& );
template<typename U = uint32_t>
uf::stl::vector<U> get() const;
template<typename U = uint32_t>
const uf::stl::vector<U>& get( const pod::Vector3f& ) const;
const pod::Vector3f& center() const;
const pod::Vector3f& extent() const;
void analyze() const;
};
};
#include "grid.inl"
#endif
}

67
engine/inc/uf/utils/mesh/grid.inl
View File

@ -1,67 +0,0 @@
#if 0
template<typename T, typename U>
void uf::MeshGrid::initialize( const uf::Mesh<T,U>& mesh, size_t divisions ) {
return initialize<T,U>( mesh, pod::Vector3ui{ divisions, divisions, divisions } );
}
template<typename T, typename U>
void uf::MeshGrid::initialize( const uf::Mesh<T,U>& mesh, const pod::Vector3ui& size ) {
// calculate our extents
pod::Vector3f min = { std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max() };
pod::Vector3f max = { -std::numeric_limits<float>::max(), -std::numeric_limits<float>::max(), -std::numeric_limits<float>::max() };
for ( auto& vertex : mesh.vertices ) {
auto& position = vertex.position;
min.x = std::min( position.x, min.x );
min.y = std::min( position.z, min.y );
min.z = std::min( position.y, min.z );
max.x = std::max( position.x, max.x );
max.y = std::max( position.z, max.y );
max.z = std::max( position.y, max.z );
}
pod::Vector3f center = (max + min) * 0.5f;
pod::Vector3f extent = (max - min) * 0.5f;
// pre-generate nodes
initialize( center, extent, size );
// fill our nodes
for ( size_t i = 0; i < mesh.indices.size() / 3; ++i ) {
// triangle face
auto& i1 = mesh.indices[i*3+0];
auto& i2 = mesh.indices[i*3+1];
auto& i3 = mesh.indices[i*3+2];
// triangle positions
auto& v1 = mesh.vertices[i1].position;
auto& v2 = mesh.vertices[i2].position;
auto& v3 = mesh.vertices[i3].position;
insert(i1, i2, i3, v1, v2, v3);
}
}
template<typename U>
uf::stl::vector<U> uf::MeshGrid::get() const {
#if 0
auto& node = get( point );
uf::stl::vector<U> indices(node.count);
for ( size_t i = 0; i < node.count; ++i ) indices[i] = node.indices[i];
return indices;
#else
uf::stl::vector<U> indices;
for ( auto& node : this->m_nodes ) {
indices.insert( indices.end(), node.indices.begin(), node.indices.end() );
}
return indices;
#endif
}
template<typename U>
const uf::stl::vector<U>& uf::MeshGrid::get( const pod::Vector3f& point ) const {
#if 0
auto& node = get( point );
uf::stl::vector<U> indices(node.count);
for ( size_t i = 0; i < node.count; ++i ) indices[i] = node.indices[i];
return indices;
#else
return at( point ).indices;
#endif
}
#endif

50
engine/src/engine/asset/asset.cpp
View File

@ -40,6 +40,8 @@ namespace {
std::mutex mutex;
uint64_t uid = 0;
struct Job {
typedef uf::stl::vector<Job> container_t;
uf::stl::string callback;
uf::stl::string type;
uf::Asset::Payload payload;
@ -49,37 +51,43 @@ namespace {
uf::Asset uf::Asset::masterAssetLoader;
bool uf::Asset::assertionLoad = true;
#define UF_ASSET_MULTITHREAD 1
void uf::Asset::processQueue() {
// uf::thread::queue([&]{
mutex.lock();
auto jobs = std::move(this->getComponent<std::queue<Job>>());
while ( !jobs.empty() ) {
auto job = jobs.front();
jobs.pop();
#if UF_ASSET_MULTITHREAD
auto tasks = uf::thread::schedule(true, true);
#else
auto tasks = uf::thread::schedule(false, true);
#endif
uf::stl::string callback = job.callback;
uf::stl::string type = job.type;
uf::Asset::Payload payload = job.payload;
mutex.lock();
auto jobs = std::move(this->getComponent<Job::container_t>());
mutex.unlock();
if ( payload.filename == "" || callback == "" ) continue;
for ( auto& job : jobs ) tasks.queue([=]{
uf::stl::string callback = job.callback;
uf::stl::string type = job.type;
uf::Asset::Payload payload = job.payload;
uf::stl::string filename = type == "cache" ? this->cache(payload) : this->load(payload);
if ( payload.filename == "" || callback == "" ) return;
uf::stl::string filename = type == "cache" ? this->cache(payload) : this->load(payload);
if ( callback != "" && filename != "" ) uf::hooks.call(callback, payload);
}
mutex.unlock();
// });
if ( callback != "" && filename != "" ) uf::hooks.call(callback, payload);
});
uf::thread::execute( tasks );
}
void uf::Asset::cache( const uf::stl::string& callback, const uf::Asset::Payload& payload ) {
mutex.lock();
auto& jobs = this->getComponent<std::queue<Job>>();
jobs.push({ callback, "cache", payload });
auto& jobs = this->getComponent<Job::container_t>();
jobs.emplace_back(Job{ callback, "cache", payload });
mutex.unlock();
}
void uf::Asset::load( const uf::stl::string& callback, const uf::Asset::Payload& payload ) {
mutex.lock();
auto& jobs = this->getComponent<std::queue<Job>>();
jobs.push({ callback, "load", payload });
auto& jobs = this->getComponent<Job::container_t>();
jobs.emplace_back(Job{ callback, "load", payload });
mutex.unlock();
}
@ -258,8 +266,8 @@ uf::stl::string uf::Asset::load(const uf::Asset::Payload& payload ) {
#if UF_USE_OPENGL
// combining mesh is only really a (negligent) gain on Vulkan
// collision meshes still use separated meshes, so avoid having to duplicate a mesh for very little gains, if any
metadata[payload.filename]["flags"]["ATLAS"] = false;
metadata[payload.filename]["flags"]["SEPARATE"] = true;
metadata[payload.filename]["renderer"]["atlas"] = false;
metadata[payload.filename]["renderer"]["separate"] = true;
#endif
asset = uf::graph::load( filename, metadata[payload.filename] );
uf::graph::process( asset );

28
engine/src/engine/graph/decode.cpp
View File

@ -225,27 +225,16 @@ namespace {
});
// remove extraneous buffers
#if 0
uf::stl::vector<uf::stl::string> attributesKept = ext::json::vector<uf::stl::string>(graph.metadata["decode"]["attributes"]);
#if 1
if ( !mesh.isInterleaved() ) {
uf::stl::vector<size_t> remove; remove.reserve(mesh.vertex.attributes.size());
for ( size_t i = 0; i < mesh.vertex.attributes.size(); ++i ) {
auto& attribute = mesh.vertex.attributes[i];
if ( attribute.descriptor.name == "position" ) continue;
if ( attribute.descriptor.name == "color" ) continue;
if ( attribute.descriptor.name == "uv" ) continue;
if ( attribute.descriptor.name == "st" ) continue;
#if !UF_USE_OPENGL
if ( attribute.descriptor.name == "normal" ) continue;
if ( attribute.descriptor.name == "tangent" ) continue;
if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) {
if ( attribute.descriptor.name == "joints" ) continue;
if ( attribute.descriptor.name == "weights" ) continue;
}
#endif
if ( std::find( attributesKept.begin(), attributesKept.end(), attribute.descriptor.name ) != attributesKept.end() ) continue;
remove.insert(remove.begin(), i);
// UF_MSG_DEBUG("Removing mesh attribute: {}", attribute.descriptor.name);
}
for ( auto& i : remove ) {
mesh.buffers[mesh.vertex.attributes[i].buffer].clear();
@ -258,7 +247,6 @@ namespace {
#endif
mesh.updateDescriptor();
#if 0
// swap winding order
if ( graph.metadata["decode"]["invert winding order"].as<bool>() ) {
@ -359,6 +347,14 @@ pod::Graph uf::graph::load( const uf::stl::string& filename, const uf::Serialize
auto tasks = uf::thread::schedule(false);
#endif
if ( !ext::json::isArray(graph.metadata["decode"]["attributes"]) ) {
#if UF_USE_OPENGL
graph.metadata["decode"]["attributes"] = uf::stl::vector({ "position", "uv", "st" });
#else
graph.metadata["decode"]["attributes"] = uf::stl::vector({ "position", "color", "uv", "st", "tangent", "joints", "weights", "normal", "id" });
#endif
}
tasks.queue([&]{
// load images
UF_DEBUG_TIMER_MULTITRACE("Reading instances...");

2
engine/src/engine/graph/encode.cpp
View File

@ -154,7 +154,7 @@ namespace {
if ( attribute.descriptor.name == "uv" ) continue;
if ( attribute.descriptor.name == "st" ) continue;
if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) {
if ( graph.metadata["renderer"]["skinned"].as<bool>() ) {
if ( attribute.descriptor.name == "tangent" ) continue;
if ( attribute.descriptor.name == "joints" ) continue;
if ( attribute.descriptor.name == "weights" ) continue;

34
engine/src/engine/graph/graph.cpp
View File

@ -88,8 +88,8 @@ void uf::graph::initializeGraphics( pod::Graph& graph, uf::Object& entity, uf::M
graphic.device = &uf::renderer::device;
graphic.material.device = &uf::renderer::device;
graphic.descriptor.frontFace = uf::renderer::enums::Face::CCW;
graphic.descriptor.cullMode = !(graph.metadata["flags"]["INVERT"].as<bool>()) ? uf::renderer::enums::CullMode::BACK : uf::renderer::enums::CullMode::FRONT;
graphic.descriptor.frontFace = graph.metadata["renderer"]["invert"].as<bool>(true) ? uf::renderer::enums::Face::CW : uf::renderer::enums::Face::CCW;
graphic.descriptor.cullMode = uf::renderer::enums::CullMode::BACK;
auto tag = ::findTag( entity.getName(), graph );
if ( !ext::json::isObject( tag ) ) {
@ -100,6 +100,13 @@ void uf::graph::initializeGraphics( pod::Graph& graph, uf::Object& entity, uf::M
const auto mode = uf::string::lowercase( tag["renderer"]["front face"].as<uf::stl::string>() );
if ( mode == "cw" ) graphic.descriptor.frontFace = uf::renderer::enums::Face::CW;
else if ( mode == "ccw" ) graphic.descriptor.frontFace = uf::renderer::enums::Face::CCW;
else if ( mode == "auto" ) {
if ( uf::matrix::reverseInfiniteProjection ) {
graphic.descriptor.frontFace = graph.metadata["renderer"]["invert"].as<bool>(true) ? uf::renderer::enums::Face::CW : uf::renderer::enums::Face::CCW;
} else {
graphic.descriptor.frontFace = graph.metadata["renderer"]["invert"].as<bool>(true) ? uf::renderer::enums::Face::CCW : uf::renderer::enums::Face::CW;
}
}
else UF_MSG_WARNING("Invalid Face enum string specified: {}", mode);
}
if ( tag["renderer"]["cull mode"].is<uf::stl::string>() ) {
@ -111,6 +118,15 @@ void uf::graph::initializeGraphics( pod::Graph& graph, uf::Object& entity, uf::M
else UF_MSG_WARNING("Invalid CullMode enum string specified: {}", mode);
}
/*
#if UF_USE_OPENGL
if ( !uf::matrix::reverseInfiniteProjection ) {
if ( graphic.descriptor.cullMode == uf::renderer::enums::CullMode::FRONT ) graphic.descriptor.cullMode = uf::renderer::enums::CullMode::BACK;
if ( graphic.descriptor.cullMode == uf::renderer::enums::CullMode::BACK ) graphic.descriptor.cullMode = uf::renderer::enums::CullMode::FRONT;
}
#endif
*/
{
// for ( auto& s : graph.samplers ) graphic.material.samplers.emplace_back( uf::graph::storage.samplers.map[s] );
// for ( auto pair : uf::graph::storage.samplers.map ) graphic.material.samplers.emplace_back( pair.second );
@ -143,8 +159,8 @@ void uf::graph::initializeGraphics( pod::Graph& graph, uf::Object& entity, uf::M
// standard pipeline
uf::stl::string vertexShaderFilename = graph.metadata["shaders"]["vertex"].as<uf::stl::string>("/graph/base.vert.spv"); {
std::pair<bool, uf::stl::string> settings[] = {
{ graph.metadata["flags"]["SKINNED"].as<bool>(), "skinned.vert" },
{ !graph.metadata["flags"]["SEPARATE"].as<bool>(), "instanced.vert" },
{ graph.metadata["renderer"]["skinned"].as<bool>(), "skinned.vert" },
{ !graph.metadata["renderer"]["separate"].as<bool>(), "instanced.vert" },
};
FOR_ARRAY(settings) if ( settings[i].first ) vertexShaderFilename = uf::string::replace( vertexShaderFilename, "vert", settings[i].second );
vertexShaderFilename = entity.resolveURI( vertexShaderFilename, root );
@ -753,7 +769,7 @@ void uf::graph::process( pod::Graph& graph ) {
uf::graph::reload();
// setup combined mesh if requested
if ( !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ) {
if ( !(graph.metadata["renderer"]["separate"].as<bool>()) ) {
graph.root.mesh = graph.meshes.size();
auto keyName = graph.name + "/" + graph.root.name;
auto& mesh = uf::graph::storage.meshes[graph.meshes.emplace_back(keyName)];
@ -974,7 +990,7 @@ void uf::graph::process( pod::Graph& graph, int32_t index, uf::Object& parent )
instance.model = model;
instance.objectID = objectID;
instance.jointID = graph.metadata["flags"]["SKINNED"].as<bool>() ? 0 : -1;
instance.jointID = graph.metadata["renderer"]["skinned"].as<bool>() ? 0 : -1;
bounds.min = uf::vector::min( bounds.min, instance.bounds.min );
bounds.max = uf::vector::max( bounds.max, instance.bounds.max );
@ -987,7 +1003,7 @@ void uf::graph::process( pod::Graph& graph, int32_t index, uf::Object& parent )
drawCommand.instanceID = instanceID;
}
}
if ( (graph.metadata["flags"]["SEPARATE"].as<bool>()) && graph.metadata["flags"]["RENDER"].as<bool>() ) {
if ( (graph.metadata["renderer"]["separate"].as<bool>()) && graph.metadata["renderer"]["render"].as<bool>() ) {
// uf::instantiator::bind("RenderBehavior", entity);
uf::graph::initializeGraphics( graph, entity, mesh );
}
@ -1077,7 +1093,7 @@ void uf::graph::initialize( pod::Graph& graph ) {
}
void uf::graph::animate( pod::Graph& graph, const uf::stl::string& _name, float speed, bool immediate ) {
if ( !(graph.metadata["flags"]["SKINNED"].as<bool>()) ) return;
if ( !(graph.metadata["renderer"]["skinned"].as<bool>()) ) return;
const uf::stl::string name = /*graph.name + "/" +*/ _name;
// if ( graph.animations.count( name ) > 0 ) {
if ( uf::graph::storage.animations.map.count( name ) > 0 ) {
@ -1119,7 +1135,7 @@ void uf::graph::update( pod::Graph& graph, float delta ) {
#endif
// no skins
if ( !(graph.metadata["flags"]["SKINNED"].as<bool>()) ) {
if ( !(graph.metadata["renderer"]["skinned"].as<bool>()) ) {
return;
}

16
engine/src/engine/object/behaviors/graph.cpp
View File

@ -61,7 +61,7 @@ void uf::GraphBehavior::initialize( uf::Object& self ) {
uf::graph::initialize( graph );
if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) {
if ( graph.metadata["renderer"]["skinned"].as<bool>() ) {
if ( metadata["model"]["animation"].is<uf::stl::string>() ) {
uf::graph::animate( graph, metadata["model"]["animation"].as<uf::stl::string>() );
}
@ -79,7 +79,7 @@ void uf::GraphBehavior::tick( uf::Object& self ) {
}
/* Update animations */ if ( this->hasComponent<pod::Graph>() ) {
auto& graph = this->getComponent<pod::Graph>();
// if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) uf::graph::update( graph );
// if ( graph.metadata["renderer"]["skinned"].as<bool>() ) uf::graph::update( graph );
}
if ( !this->hasComponent<uf::Graphic>() ) return;
@ -106,7 +106,7 @@ void uf::GraphBehavior::tick( uf::Object& self ) {
auto& shader = graphic.material.getShader("vertex");
auto& mesh = this->getComponent<pod::Graph::Mesh>();
if ( !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ) {
if ( !(graph.metadata["renderer"]["separate"].as<bool>()) ) {
uf::stl::vector<pod::Matrix4f> instances( graph.nodes.size() );
for ( size_t i = 0; i < graph.nodes.size(); ++i ) {
auto& node = graph.nodes[i];
@ -114,7 +114,7 @@ void uf::GraphBehavior::tick( uf::Object& self ) {
}
shader.updateBuffer( (const void*) instances.data(), instances.size() * sizeof(pod::Matrix4f), graph.buffers.instance );
shader.execute( graphic, mesh.attributes.vertex.pointer );
} else if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) {
} else if ( graph.metadata["renderer"]["skinned"].as<bool>() ) {
shader.execute( graphic, mesh.attributes.vertex.pointer );
}
}
@ -122,7 +122,7 @@ void uf::GraphBehavior::tick( uf::Object& self ) {
if ( graphic.material.hasShader("vertex") ) {
auto& shader = graphic.material.getShader("vertex");
if ( !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ) {
if ( !(graph.metadata["renderer"]["separate"].as<bool>()) ) {
uf::stl::vector<pod::Matrix4f> instances( graph.nodes.size() );
for ( size_t i = 0; i < graph.nodes.size(); ++i ) {
auto& node = graph.nodes[i];
@ -151,7 +151,7 @@ void uf::GraphBehavior::tick( uf::Object& self ) {
}
}
#if 0
if ( graphic.material.hasShader("vertex") && !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ) {
if ( graphic.material.hasShader("vertex") && !(graph.metadata["renderer"]["separate"].as<bool>()) ) {
auto& shader = graphic.material.getShader("vertex");
uf::stl::vector<pod::Matrix4f> instances( graph.nodes.size() );
for ( size_t i = 0; i < graph.nodes.size(); ++i ) {
@ -191,13 +191,13 @@ void uf::GraphBehavior::render( uf::Object& self ) {
auto uniforms = graphic.getUniform();
pod::Uniform& uniform = *((pod::Uniform*) graphic.device->getBuffer(uniforms.buffer));
uniform = {
.modelView = !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ? camera.getView() : camera.getView() * uf::transform::model( transform ),
.modelView = !(graph.metadata["renderer"]["separate"].as<bool>()) ? camera.getView() : camera.getView() * uf::transform::model( transform ),
.projection = camera.getProjection();
};
graphic.updateUniform( (const void*) &uniform, sizeof(uniform) );
#else
pod::Uniform uniform = {
.modelView = !(graph.metadata["flags"]["SEPARATE"].as<bool>()) ? camera.getView() : camera.getView() * uf::transform::model( transform ),
.modelView = !(graph.metadata["renderer"]["separate"].as<bool>()) ? camera.getView() : camera.getView() * uf::transform::model( transform ),
.projection = camera.getProjection(),
};
graphic.updateUniform( (const void*) &uniform, sizeof(uniform) );

62
engine/src/engine/object/object.cpp
View File

@ -257,9 +257,9 @@ bool uf::Object::load( const uf::Serializer& _json ) {
uf::Asset::Payload payload = uf::Asset::resolveToPayload( filename, mime );
if ( !uf::Asset::isExpected( payload, assetType ) ) continue;
payload.hash = isObject ? target[i]["hash"].as<uf::stl::string>("") : "";
payload.monoThreaded = isObject ? target[i]["single threaded"].as<bool>() : false;
payload.monoThreaded = isObject ? !target[i]["multithreaded"].as<bool>(true) : !true;
this->queueHook( "asset:QueueLoad.%UID%", payload, isObject ? target[i]["delay"].as<float>() : 0 );
bool bind = isObject && target[i]["bind"].is<bool>() ? target[i]["bind"].as<bool>() : true;
bool bind = isObject ? target[i]["bind"].as<bool>(true) : true;
switch ( assetType ) {
case uf::Asset::Type::LUA: {
@ -274,64 +274,6 @@ bool uf::Object::load( const uf::Serializer& _json ) {
}
}
}
/*
#define UF_OBJECT_LOAD_ASSET_HEADER(type)\
uf::Asset::Type assetType = uf::Asset::Type::type;\
uf::stl::string assetTypeString = uf::string::lowercase( #type );\
uf::Serializer target;\
bool override = false;\
if ( ext::json::isObject( metadataJson["system"]["assets"] ) ) {\
target = metadataJson["system"]["assets"];\
} else if ( ext::json::isArray( json["assets"] ) ) {\
target = json["assets"];\
} else if ( ext::json::isObject( json["assets"] ) && !ext::json::isNull( json["assets"][assetTypeString] ) ) {\
target = json["assets"][assetTypeString];\
}
#define UF_OBJECT_LOAD_ASSET()\
bool isObject = ext::json::isObject( target[i] );\
uf::stl::string f = isObject ? target[i]["filename"].as<uf::stl::string>() : target[i].as<uf::stl::string>();\
uf::stl::string filename = uf::io::resolveURI( f, metadata.system.root );\
uf::stl::string mime = isObject ? target[i]["mime"].as<uf::stl::string>("") : "";\
uf::Asset::Payload payload = uf::Asset::resolveToPayload( filename, mime );\
if ( !uf::Asset::isExpected( payload, assetType ) ) continue;\
payload.hash = isObject ? target[i]["hash"].as<uf::stl::string>("") : "";\
payload.monoThreaded = isObject ? target[i]["single threaded"].as<bool>() : false;\
this->queueHook( "asset:QueueLoad.%UID%", payload, isObject ? target[i]["delay"].as<float>() : 0 );\
bool bind = isObject && target[i]["bind"].is<bool>() ? target[i]["bind"].as<bool>() : true;\
{
UF_OBJECT_LOAD_ASSET_HEADER(AUDIO)
for ( size_t i = 0; i < target.size(); ++i ) {
UF_OBJECT_LOAD_ASSET()
}
}
{
UF_OBJECT_LOAD_ASSET_HEADER(IMAGE)
for ( size_t i = 0; i < target.size(); ++i ) {
UF_OBJECT_LOAD_ASSET()
}
}
{
UF_OBJECT_LOAD_ASSET_HEADER(GRAPH)
for ( size_t i = 0; i < target.size(); ++i ) {
UF_OBJECT_LOAD_ASSET()
if ( bind ) uf::instantiator::bind("GraphBehavior", *this);
auto& aMetadata = assetLoader.getComponent<uf::Serializer>();
aMetadata[filename] = json["metadata"]["model"];
aMetadata[filename]["root"] = json["root"];
}
}
{
UF_OBJECT_LOAD_ASSET_HEADER(LUA)
for ( size_t i = 0; i < target.size(); ++i ) {
UF_OBJECT_LOAD_ASSET()
if ( bind ) uf::instantiator::bind("LuaBehavior", *this);
}
}
*/
// Bind behaviors
{
if ( json["type"].is<uf::stl::string>() ) uf::instantiator::bind( json["type"].as<uf::stl::string>(), *this );

24
engine/src/ext/gltf/gltf.cpp
View File

@ -81,7 +81,7 @@ namespace {
} else {
transform.position = { 0, 0, 0 };
}
if ( !(graph.metadata["flags"]["INVERT"].as<bool>()) ) {
if ( graph.metadata["renderer"]["invert"].as<bool>(true) ) {
transform.position.x *= -1;
}
if ( node.rotation.size() == 4 ) {
@ -155,11 +155,11 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto imageID = graph.images.size();
auto keyName = graph.images.emplace_back(/*filename + "/" +*/ i.name);
auto& image = /*graph.storage*/uf::graph::storage.images[keyName];
if ( graph.metadata["debug"]["print"]["image"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["images"].as<bool>() ) {
UF_MSG_DEBUG("Image: {}", i.name );
}
image.loadFromBuffer( &i.image[0], {i.width, i.height}, 8, i.component, graph.metadata["flip textures"].as<bool>(true) );
image.loadFromBuffer( &i.image[0], {i.width, i.height}, 8, i.component, graph.metadata["renderer"]["flip textures"].as<bool>(true) );
}
}
// load samplers
@ -169,7 +169,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto samplerID = graph.samplers.size();
auto keyName = graph.samplers.emplace_back(/*filename + "/" +*/ s.name);
auto& sampler = /*graph.storage*/uf::graph::storage.samplers[keyName];
if ( graph.metadata["debug"]["print"]["sampler"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["samplers"].as<bool>() ) {
UF_MSG_DEBUG("Sampler: {}", s.name );
}
@ -189,7 +189,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto textureID = graph.textures.size();
auto keyName = graph.textures.emplace_back((t.name == "" ? graph.images[t.source] : (/*filename + "/" +*/ t.name)));
auto& texture = /*graph.storage*/uf::graph::storage.textures[keyName];
if ( graph.metadata["debug"]["print"]["texture"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["textures"].as<bool>() ) {
UF_MSG_DEBUG("Texture: {}", t.name );
}
@ -206,7 +206,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto materialID = graph.materials.size();
auto keyName = graph.materials.emplace_back(/*filename + "/" +*/ m.name);
auto& material = /*graph.storage*/uf::graph::storage.materials[keyName];
if ( graph.metadata["debug"]["print"]["material"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["materials"].as<bool>() ) {
UF_MSG_DEBUG("Material: {}", m.name );
}
@ -253,7 +253,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
for ( auto& m : model.meshes ) {
auto meshID = graph.meshes.size();
auto keyName = graph.meshes.emplace_back(/*filename + "/" +*/ m.name);
if ( graph.metadata["debug"]["print"]["mesh"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["meshes"].as<bool>() ) {
UF_MSG_DEBUG("Mesh: {}", m.name );
}
@ -295,7 +295,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
meshgrid.cleanup = meshgrid.metadata["cleanup"].as(meshgrid.cleanup);
}
if ( graph.metadata["flags"]["SKINNED"].as<bool>() ) {
if ( graph.metadata["renderer"]["skinned"].as<bool>(true) ) {
#define UF_GRAPH_MESH_FORMAT uf::graph::mesh::Skinned, uint32_t
#define UF_GRAPH_PROCESS_PRIMITIVES_FULL 1
#define UF_GRAPH_GRID 1
@ -320,7 +320,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto skinID = graph.skins.size();
auto keyName = graph.skins.emplace_back(/*filename + "/" +*/ s.name);
auto& skin = /*graph.storage*/uf::graph::storage.skins[keyName];
if ( graph.metadata["debug"]["print"]["skin"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["skins"].as<bool>() ) {
UF_MSG_DEBUG("Skin: {}", s.name );
}
@ -357,7 +357,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
auto animationID = graph.animations.size();
auto keyName = graph.animations.emplace_back(/*filename + "/" +*/ a.name);
auto& animation = /*graph.storage*/uf::graph::storage.animations[keyName];
if ( graph.metadata["debug"]["print"]["animation"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["animations"].as<bool>() ) {
UF_MSG_DEBUG("Animation: {}", a.name );
}
@ -417,7 +417,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
{
for ( auto& l : model.lights ) {
auto& light = graph.lights[l.name];
if ( graph.metadata["debug"]["print"]["light"].as<bool>() ) {
if ( graph.metadata["debug"]["print"]["lights"].as<bool>() ) {
UF_MSG_DEBUG("Light: {}", l.name );
}
@ -440,7 +440,7 @@ pod::Graph ext::gltf::load( const uf::stl::string& filename, const uf::Serialize
}
}
// generate atlas
if ( graph.metadata["flags"]["ATLAS"].as<bool>() ) {
if ( graph.metadata["renderer"]["atlas"].as<bool>() ) {
auto atlasName = filename + "/" + "atlas";
auto& atlas = /*graph.storage*/uf::graph::storage.atlases[atlasName];
auto atlasImageIndex = graph.images.size();

10
engine/src/ext/gltf/processPrimitives.inl
View File

@ -6,7 +6,7 @@ struct {
} windingOrder;
} sanitizer;
if ( graph.metadata["sanitizer"]["winding order"].as<bool>(true) ) {
if ( graph.metadata["sanitizer"]["winding order"].as<bool>(true) || graph.metadata["renderer"]["invert"].as<bool>(true) ) {
sanitizer.windingOrder.should = true;
}
@ -55,7 +55,7 @@ for ( auto& p : m.primitives ) {
meshlet.primitive.instance.bounds.min = pod::Vector3f{ accessor.minValues[0], accessor.minValues[1], accessor.minValues[2] };
meshlet.primitive.instance.bounds.max = pod::Vector3f{ accessor.maxValues[0], accessor.maxValues[1], accessor.maxValues[2] };
if ( !(graph.metadata["flags"]["INVERT"].as<bool>()) ){
if ( graph.metadata["renderer"]["invert"].as<bool>(true) ){
meshlet.primitive.instance.bounds.min.x = -meshlet.primitive.instance.bounds.min.x;
meshlet.primitive.instance.bounds.max.x = -meshlet.primitive.instance.bounds.max.x;
}
@ -129,7 +129,7 @@ for ( auto& p : m.primitives ) {
// required due to reverse-Z projection matrix flipping the X axis as well
// default is to proceed with this
if ( !(graph.metadata["flags"]["INVERT"].as<bool>()) ){
if ( !(graph.metadata["renderer"].as<bool>(true)) ){
vertex.position.x = -vertex.position.x;
vertex.normal.x = -vertex.normal.x;
#if UF_GRAPH_PROCESS_PRIMITIVES_FULL
@ -234,10 +234,10 @@ for ( auto& p : m.primitives ) {
}
}
if ( sanitizer.windingOrder.should ) {
if ( sanitizer.windingOrder.should && !graph.metadata["renderer"]["invert"].as<bool>(true) ) {
UF_MSG_DEBUG("Winding order correction: {:.3f}%", ( (float) sanitizer.windingOrder.corrected / (float) sanitizer.windingOrder.total ) * 100.0f );
if ( sanitizer.windingOrder.corrected * 2 > sanitizer.windingOrder.total ) {
UF_MSG_DEBUG("Consider inverting the front face settings for mesh: {}", m.name);
UF_MSG_DEBUG("Consider enablind renderer.invert for mesh: {}", m.name);
}
}

32
engine/src/ext/lua/lua.cpp
View File

@ -15,6 +15,7 @@ uf::stl::unordered_map<uf::stl::string, uf::stl::string> ext::lua::modules;
#include <uf/utils/string/ext.h>
#include <uf/utils/window/window.h>
#include <uf/utils/audio/audio.h>
#include <uf/utils/io/inputs.h>
sol::table ext::lua::createTable() {
return sol::table(ext::lua::state, sol::create);
@ -31,7 +32,7 @@ std::optional<uf::stl::string> ext::lua::encode( sol::table table ) {
auto result = fun( table );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what())
return "{}";
}
return result;
@ -41,7 +42,7 @@ std::optional<sol::table> ext::lua::decode( const uf::stl::string& string ) {
auto result = fun( string );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what())
return createTable();
}
return result;
@ -65,7 +66,7 @@ namespace binds {
auto result = function( table );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what())
}
});
};
@ -117,10 +118,11 @@ namespace binds {
size_t count = va.size();
for ( auto value : va ) {
uf::stl::string str = ext::lua::state["tostring"]( value );
uf::iostream << str;
if ( --count != 0 ) uf::iostream << "\t";
fmt::print("{}", str);
if ( --count != 0 ) fmt::print("\t");
}
uf::iostream << "\n";
fmt::print("\n");
std::cout.flush();
};
}
namespace math {
@ -206,6 +208,9 @@ void ext::lua::initialize() {
string["extension"] = UF_LUA_C_FUN(::binds::string::extension);
string["resolveURI"] = UF_LUA_C_FUN(::binds::string::resolveURI);
string["si"] = UF_LUA_C_FUN(::binds::string::si);
string["match"] = UF_LUA_C_FUN(uf::string::match);
string["matched"] = UF_LUA_C_FUN(uf::string::matched);
}
// `io` table
{
@ -240,6 +245,13 @@ void ext::lua::initialize() {
auto os = state["os"].get_or_create<sol::table>();
os["arch"] = UF_LUA_C_FUN(::binds::os::arch);
}
// `inputs` table
{
auto inputs = state["inputs"].get_or_create<sol::table>();
inputs["key"] = UF_LUA_C_FUN(uf::inputs::key);
inputs["analog"] = UF_LUA_C_FUN(uf::inputs::analog);
inputs["analog2"] = UF_LUA_C_FUN(uf::inputs::analog2);
}
run(main);
}
bool ext::lua::run( const uf::stl::string& s, bool safe ) {
@ -249,7 +261,7 @@ bool ext::lua::run( const uf::stl::string& s, bool safe ) {
auto result = state.safe_script_file( uf::io::resolveURI( s ), sol::script_pass_on_error );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what());
return false;
}
} else {
@ -261,7 +273,7 @@ bool ext::lua::run( const uf::stl::string& s, bool safe ) {
auto result = state.safe_script( s, sol::script_pass_on_error );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what());
return false;
}
} else {
@ -286,7 +298,7 @@ bool ext::lua::run( const pod::LuaScript& s, bool safe ) {
auto result = state.safe_script_file( s.file, s.env, sol::script_pass_on_error );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what());
return false;
}
} else {
@ -298,7 +310,7 @@ bool ext::lua::run( const pod::LuaScript& s, bool safe ) {
auto result = state.safe_script( s.file, s.env, sol::script_pass_on_error );
if ( !result.valid() ) {
sol::error err = result;
uf::iostream << err.what() << "\n";
UF_MSG_ERROR("{}", err.what());
return false;
}
} else {

7
engine/src/ext/lua/usertypes/physics.cpp
View File

@ -8,6 +8,11 @@ namespace binds {
void setLinearVelocity( pod::Physics& self, const pod::Vector3f& v ) { self.linear.velocity = v; }
void setRotationalVelocity( pod::Physics& self, const pod::Quaternion<>& v ) { self.rotational.velocity = v; }
void enableGravity( pod::PhysicsState& state, bool s ) {
if ( !state.body ) return;
state.body->enableGravity(s);
}
}
UF_LUA_REGISTER_USERTYPE(pod::Physics,
@ -20,10 +25,12 @@ UF_LUA_REGISTER_USERTYPE(pod::Physics,
UF_LUA_REGISTER_USERTYPE(pod::PhysicsState,
UF_LUA_REGISTER_USERTYPE_DEFINE( setVelocity, UF_LUA_C_FUN(uf::physics::impl::setVelocity) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( setImpulse, UF_LUA_C_FUN(uf::physics::impl::setImpulse) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( applyImpulse, UF_LUA_C_FUN(uf::physics::impl::applyImpulse) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( applyMovement, UF_LUA_C_FUN(uf::physics::impl::applyMovement) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( applyVelocity, UF_LUA_C_FUN(uf::physics::impl::applyVelocity) ),
// UF_LUA_REGISTER_USERTYPE_DEFINE( applyRotation, UF_LUA_C_FUN(uf::physics::impl::applyRotation) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( enableGravity, UF_LUA_C_FUN(::binds::enableGravity) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( activateCollision, UF_LUA_C_FUN(uf::physics::impl::activateCollision) )
)

4
engine/src/ext/lua/usertypes/transform.cpp
View File

@ -37,6 +37,9 @@ namespace binds {
void setReference( pod::Transform<>& self, pod::Transform<>& t ) {
self.reference = &t;
}
void unreference( pod::Transform<>& self ) {
self.reference = NULL;
}
pod::Transform<> lookAt( const pod::Transform<>& t, pod::Vector3f& at ) {
auto transform = t;
return uf::transform::lookAt( transform, at );
@ -61,6 +64,7 @@ UF_LUA_REGISTER_USERTYPE(pod::Transform<>,
UF_LUA_REGISTER_USERTYPE_DEFINE(reorient, UF_LUA_C_FUN(::binds::reorient)),
UF_LUA_REGISTER_USERTYPE_DEFINE(getReference, UF_LUA_C_FUN(::binds::getReference)),
UF_LUA_REGISTER_USERTYPE_DEFINE(setReference, UF_LUA_C_FUN(::binds::setReference)),
UF_LUA_REGISTER_USERTYPE_DEFINE(unreference, UF_LUA_C_FUN(::binds::unreference)),
UF_LUA_REGISTER_USERTYPE_DEFINE(lookAt, UF_LUA_C_FUN(::binds::lookAt)),
UF_LUA_REGISTER_USERTYPE_DEFINE(getModel, UF_LUA_C_FUN(::binds::getModel))
)

8
engine/src/ext/lua/usertypes/vector.cpp
View File

@ -37,6 +37,9 @@ namespace binds {
float magnitude( const pod::Vector3f& self ) {
return uf::vector::magnitude( self );
}
float norm( const pod::Vector3f& self ) {
return uf::vector::norm( self );
}
float dot( const pod::Vector3f& left, const pod::Vector3f& right ) {
return uf::vector::dot( left, right );
}
@ -78,6 +81,9 @@ namespace binds {
float magnitude( const pod::Vector4f& self ) {
return uf::vector::magnitude( self );
}
float norm( const pod::Vector4f& self ) {
return uf::vector::norm( self );
}
float dot( const pod::Vector4f& left, const pod::Vector4f& right ) {
return uf::vector::dot( left, right );
}
@ -114,6 +120,7 @@ UF_LUA_REGISTER_USERTYPE(pod::Vector3f,
UF_LUA_REGISTER_USERTYPE_DEFINE( lerp, UF_LUA_C_FUN(::binds::v3f::lerp) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( normalize, UF_LUA_C_FUN(::binds::v3f::normalize) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( magnitude, UF_LUA_C_FUN(::binds::v3f::magnitude) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( norm, UF_LUA_C_FUN(::binds::v3f::norm) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( dot, UF_LUA_C_FUN(::binds::v3f::dot) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( __tostring, UF_LUA_C_FUN(::binds::v3f::toString) )
)
@ -145,6 +152,7 @@ UF_LUA_REGISTER_USERTYPE(pod::Vector4f,
UF_LUA_REGISTER_USERTYPE_DEFINE( lerp, UF_LUA_C_FUN(::binds::v4f::lerp) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( normalize, UF_LUA_C_FUN(::binds::v4f::normalize) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( magnitude, UF_LUA_C_FUN(::binds::v4f::magnitude) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( norm, UF_LUA_C_FUN(::binds::v4f::norm) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( dot, UF_LUA_C_FUN(::binds::v4f::dot) ),
UF_LUA_REGISTER_USERTYPE_DEFINE( __tostring, UF_LUA_C_FUN(::binds::v4f::toString) )
)

2
engine/src/ext/opengl/commands.cpp
View File

@ -102,12 +102,10 @@ void ext::opengl::CommandBuffer::submit() {
switch ( header->type ) {
case ext::opengl::enums::Command::CLEAR: {
InfoClear* info = (InfoClear*) header;
/*
GL_ERROR_CHECK(glClearColor(info->color[0], info->color[1], info->color[2], info->color[3]));
GL_ERROR_CHECK(glClearDepth(info->depth));
GL_ERROR_CHECK(glClear(info->bits));
GL_ERROR_CHECK(glLightModelfv(GL_LIGHT_MODEL_AMBIENT, &info->color[0]));
*/
} break;
case ext::opengl::enums::Command::VIEWPORT: {
InfoViewport* info = (InfoViewport*) header;

25
engine/src/ext/opengl/graphic.cpp
View File

@ -366,15 +366,13 @@ void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, const GraphicDe
CommandBuffer::InfoDraw drawCommandInfoBase = {};
drawCommandInfoBase.type = ext::opengl::enums::Command::DRAW;
drawCommandInfoBase.descriptor = descriptor;
if ( descriptor.inputs.index.count ) {
drawCommandInfoBase.attributes.index = descriptor.inputs.index.attributes.front();
}
if ( descriptor.inputs.index.count ) drawCommandInfoBase.attributes.index = descriptor.inputs.index.attributes.front();
for ( uf::Mesh::Attribute attribute : descriptor.inputs.vertex.attributes ) {
if ( attribute.descriptor.name == "position" ) drawCommandInfoBase.attributes.position = attribute;
else if ( attribute.descriptor.name == "uv" ) drawCommandInfoBase.attributes.uv = attribute;
else if ( attribute.descriptor.name == "st" ) drawCommandInfoBase.attributes.st = attribute;
// else if ( attribute.descriptor.name == "normal" ) drawCommandInfoBase.attributes.normal = attribute;
else if ( attribute.descriptor.name == "normal" ) drawCommandInfoBase.attributes.normal = attribute;
else if ( attribute.descriptor.name == "color" ) drawCommandInfoBase.attributes.color = attribute;
}
@ -386,6 +384,11 @@ void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, const GraphicDe
drawCommandInfoBase.matrices.projection = &viewports2->projection;
}
struct {
uf::stl::vector<CommandBuffer::InfoDraw> opaques;
uf::stl::vector<CommandBuffer::InfoDraw> translucents;
} drawCommandInfos;
if ( descriptor.inputs.indirect.count ) {
auto& indirectAttribute = descriptor.inputs.indirect.attributes.front();
@ -444,7 +447,10 @@ void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, const GraphicDe
auto texture2DID = textures[instance.lightmapID].index;
drawCommandInfo.textures.secondary = this->material.textures.at(texture2DID).descriptor;
}
commandBuffer.record(drawCommandInfo);
switch ( drawCommandInfo.blend.modeAlpha ) {
case 0: drawCommandInfos.opaques.emplace_back(drawCommandInfo); break;
default: drawCommandInfos.translucents.emplace_back(drawCommandInfo); break;
}
}
} else {
CommandBuffer::InfoDraw drawCommandInfo = drawCommandInfoBase;
@ -468,9 +474,14 @@ void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, const GraphicDe
break;
}
}
commandBuffer.record(drawCommandInfo);
switch ( drawCommandInfo.blend.modeAlpha ) {
case 0: drawCommandInfos.opaques.emplace_back(drawCommandInfo); break;
default: drawCommandInfos.translucents.emplace_back(drawCommandInfo); break;
}
}
for ( auto& drawCommandInfo : drawCommandInfos.opaques ) commandBuffer.record(drawCommandInfo);
for ( auto& drawCommandInfo : drawCommandInfos.translucents ) commandBuffer.record(drawCommandInfo);
}
void ext::opengl::Graphic::destroy() {
for ( auto& pair : pipelines ) pair.second.destroy();

7
engine/src/ext/opengl/opengl.cpp
View File

@ -418,16 +418,15 @@ void UF_API ext::opengl::render(){
clearCommandInfo.bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
clearCommandInfo.depth = uf::matrix::reverseInfiniteProjection ? 0.0f : 1.0f;
#if 1
if ( !ext::json::isNull( sceneMetadata["system"]["renderer"]["clear values"][0] ) ) {
clearCommandInfo.color = uf::vector::decode( sceneMetadata["system"]["renderer"]["clear values"][0], pod::Vector4f{0,0,0,0} );
}
if ( !ext::json::isNull( sceneMetadata["light"]["ambient"] ) ) {
clearCommandInfo.color = uf::vector::decode( sceneMetadata["light"]["ambient"], pod::Vector4f{0,0,0,0} );
// auto ambient = uf::vector::decode( sceneMetadata["light"]["ambient"], pod::Vector4f{1,1,1,1} );
// GL_ERROR_CHECK(glLightfv(GL_LIGHT0, GL_AMBIENT, &ambient[0]));
auto ambient = uf::vector::decode( sceneMetadata["light"]["ambient"], pod::Vector4f{1,1,1,1} );
GL_ERROR_CHECK(glLightfv(GL_LIGHT0, GL_AMBIENT, &ambient[0]));
}
#endif
GL_ERROR_CHECK(glClearColor(clearCommandInfo.color[0], clearCommandInfo.color[1], clearCommandInfo.color[2], clearCommandInfo.color[3]));
GL_ERROR_CHECK(glClearDepth(clearCommandInfo.depth));

27
engine/src/ext/reactphysics/reactphysics.cpp
View File

@ -214,8 +214,8 @@ void ext::reactphysics::initialize() {
// Select the contact points and contact normals to be displayed
debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::COLLIDER_AABB, true);
debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::COLLISION_SHAPE, true);
debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::CONTACT_POINT, true);
debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::CONTACT_NORMAL, true);
// debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::CONTACT_POINT, true);
// debugRenderer.setIsDebugItemDisplayed(rp3d::DebugRenderer::DebugItem::CONTACT_NORMAL, true);
}
}
void ext::reactphysics::tick( float delta ) {
@ -284,6 +284,8 @@ void ext::reactphysics::attach( pod::PhysicsState& state ) {
state.body = ::world->createRigidBody( ::convert( *state.transform.reference ) );
auto* collider = state.body->addCollider(state.shape, colliderTransform);
collider->setCollisionCategoryBits(0xFF);
collider->setCollideWithMaskBits(0xFF);
state.body->setUserData(state.object);
state.body->setMass(state.stats.mass);
@ -509,7 +511,19 @@ void ext::reactphysics::syncFrom( float interp ) {
}
}
// apply impulse
void ext::reactphysics::setImpulse( pod::PhysicsState& state, const pod::Vector3f& v ) {
if ( !state.body ) return;
state.body->resetForce();
state.body->resetTorque();
state.body->setLinearVelocity( ::convert(pod::Vector3f{}) );
state.body->setAngularVelocity( ::convert(pod::Vector3f{}) );
// ext::reactphysics::applyImpulse( state, v );
}
void ext::reactphysics::applyImpulse( pod::PhysicsState& state, const pod::Vector3f& v ) {
if ( !state.body ) return;
state.body->applyWorldForceAtCenterOfMass( ::convert(v) );
}
// directly move a transform
void ext::reactphysics::applyMovement( pod::PhysicsState& state, const pod::Vector3f& v ) {
@ -584,7 +598,14 @@ float ext::reactphysics::rayCast( const pod::Vector3f& center, const pod::Vector
// allows noclip
void ext::reactphysics::activateCollision( pod::PhysicsState& state, bool s ) {
if ( !state.body ) return;
// state.body->setIsActive(s);
auto colliders = state.body->getNbColliders();
for ( auto i = 0; i < colliders; ++i ) {
auto* collider = state.body->getCollider(i);
collider->setCollisionCategoryBits(s ? 0xFF : 0x00);
collider->setCollideWithMaskBits(s ? 0xFF : 0x00);
}
}
#endif

3
engine/src/ext/vulkan/buffer.cpp
View File

@ -127,7 +127,8 @@ bool ext::vulkan::Buffer::update( const void* data, VkDeviceSize length, bool st
if ( !length ) return false;
if ( !buffer ) return false;
if ( length > allocationInfo.size ) {
UF_MSG_DEBUG("LENGTH OF {} EXCEEDS BUFFER SIZE {}", length, allocationInfo.size );
UF_MSG_WARNING("Buffer update of {} exceeds buffer size of {}", length, allocationInfo.size );
Buffer& b = *const_cast<Buffer*>(this);
b.destroy();
b.initialize( data, length, usage, memoryProperties, stage );

85
engine/src/ext/vulkan/graphic.cpp
View File

@ -1018,12 +1018,17 @@ void ext::vulkan::Graphic::initializeMesh( uf::Mesh& mesh, bool buffer ) {
#define PARSE_INPUT(name, usage){\
if ( mesh.isInterleaved( mesh.name.interleaved ) ) {\
auto& buffer = mesh.buffers[mesh.name.interleaved];\
if ( !buffer.empty() ) mesh.name.interleaved = initializeBuffer( (const void*) buffer.data(), buffer.size(), usage | baseUsage );\
else mesh.name.interleaved = -1;\
} else for ( auto& attribute : descriptor.inputs.name.attributes ) {\
if ( !buffer.empty() ) {\
descriptor.inputs.name.interleaved = initializeBuffer( (const void*) buffer.data(), buffer.size(), usage | baseUsage );\
this->metadata.buffers[#name"[0]"] = descriptor.inputs.name.interleaved;\
} else mesh.name.interleaved = -1;\
} else for ( size_t i = 0; i < descriptor.inputs.name.attributes.size(); ++i ) {\
auto& attribute = descriptor.inputs.name.attributes[i];\
auto& buffer = mesh.buffers[attribute.buffer];\
if ( !buffer.empty() ) attribute.buffer = initializeBuffer( (const void*) buffer.data(), buffer.size(), usage | baseUsage );\
else attribute.buffer = -1;\
if ( !buffer.empty() ) {\
attribute.buffer = initializeBuffer( (const void*) buffer.data(), buffer.size(), usage | baseUsage );\
this->metadata.buffers[#name"["+std::to_string(i)+"]"] = attribute.buffer;\
} else attribute.buffer = -1;\
}\
}
// allocate buffers
@ -1042,8 +1047,6 @@ void ext::vulkan::Graphic::initializeMesh( uf::Mesh& mesh, bool buffer ) {
}
}
bool ext::vulkan::Graphic::updateMesh( uf::Mesh& mesh ) {
// UF_MSG_ERROR("need to fix"); return false;
// generate indices if not found
// if ( mesh.index.count == 0 ) mesh.generateIndices();
// generate indirect data if not found
@ -1051,7 +1054,27 @@ bool ext::vulkan::Graphic::updateMesh( uf::Mesh& mesh ) {
// ensure our descriptors are proper
mesh.updateDescriptor();
/*
// copy descriptors
#define UPDATE_DESCRIPTOR(N) {\
for ( size_t i = 0; i < mesh.N.attributes.size(); ++i ) {\
descriptor.inputs.N.attributes[i].descriptor = mesh.N.attributes[i].descriptor;\
descriptor.inputs.N.attributes[i].offset = mesh.N.attributes[i].offset;\
descriptor.inputs.N.attributes[i].stride = mesh.N.attributes[i].stride;\
descriptor.inputs.N.attributes[i].length = mesh.N.attributes[i].length;\
descriptor.inputs.N.attributes[i].pointer = mesh.N.attributes[i].pointer;\
}\
descriptor.inputs.N.count = mesh.N.count;\
descriptor.inputs.N.first = mesh.N.first;\
descriptor.inputs.N.size = mesh.N.size;\
descriptor.inputs.N.offset = mesh.N.offset;\
}
UPDATE_DESCRIPTOR(vertex);
UPDATE_DESCRIPTOR(index);
UPDATE_DESCRIPTOR(instance);
UPDATE_DESCRIPTOR(indirect);
*/
descriptor.inputs.vertex = mesh.vertex;
descriptor.inputs.index = mesh.index;
descriptor.inputs.instance = mesh.instance;
@ -1076,6 +1099,7 @@ bool ext::vulkan::Graphic::updateMesh( uf::Mesh& mesh ) {
else for ( auto& attribute : descriptor.inputs.name.attributes ) PARSE_ATTRIBUTE(attribute.buffer, usage)\
}
*/
/*
#define PARSE_INPUT(name, usage){\
if ( mesh.isInterleaved( mesh.name.interleaved ) ) {\
auto& buffer = mesh.buffers[mesh.name.interleaved];\
@ -1085,6 +1109,28 @@ bool ext::vulkan::Graphic::updateMesh( uf::Mesh& mesh ) {
if ( !buffer.empty() ) rebuild = rebuild || updateBuffer( (const void*) buffer.data(), buffer.size(), descriptor.inputs.name.attributes[i].buffer );\
}\
}
*/
#define PARSE_INPUT(name, usage){\
if ( mesh.isInterleaved( mesh.name.interleaved ) ) {\
auto& buffer = mesh.buffers[mesh.name.interleaved];\
if ( !buffer.empty() ) {\
const uf::stl::string key = #name"[0]";\
if ( this->metadata.buffers.count(key) > 0 ) {\
descriptor.inputs.name.interleaved = this->metadata.buffers[key];\
rebuild = rebuild || updateBuffer( (const void*) buffer.data(), buffer.size(), descriptor.inputs.name.interleaved );\
}\
} else mesh.name.interleaved = -1;\
} else for ( size_t i = 0; i < descriptor.inputs.name.attributes.size(); ++i ) {\
auto& attribute = descriptor.inputs.name.attributes[i];\
auto& buffer = mesh.buffers[attribute.buffer];\
if ( !buffer.empty() ) {\
const uf::stl::string key = #name"["+std::to_string(i)+"]";\
if ( this->metadata.buffers.count(key) == 0 ) continue;\
attribute.buffer = this->metadata.buffers[key];\
rebuild = rebuild || updateBuffer( (const void*) buffer.data(), buffer.size(), attribute.buffer );\
} else attribute.buffer = -1;\
}\
}
bool rebuild = false;
auto previousRequestedAlignment = this->requestedAlignment;
@ -1288,6 +1334,7 @@ void ext::vulkan::Graphic::generateBottomAccelerationStructures() {
// create BLAS buffer and handle
size_t blasBufferIndex = this->initializeBuffer( NULL, totalBlasBufferSize, uf::renderer::enums::Buffer::ACCELERATION_STRUCTURE | uf::renderer::enums::Buffer::ADDRESS );
size_t blasBufferOffset = 0;
this->metadata.buffers["blasBuffer"] = blasBufferIndex;
#endif
scratchBuffer.alignment = acclerationStructureProperties.minAccelerationStructureScratchOffsetAlignment;
@ -1386,12 +1433,21 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
size_t instanceIndex{};
size_t tlasBufferIndex{};
if ( !update ) {
const size_t EXTRANEOUS_SIZE = 2048;
size_t bufferSize = MAX( instancesVK.size(), EXTRANEOUS_SIZE );
instanceIndex = this->initializeBuffer(
(const void*) instancesVK.data(), instancesVK.size() * sizeof(VkAccelerationStructureInstanceKHR),
NULL, bufferSize * sizeof(VkAccelerationStructureInstanceKHR),
uf::renderer::enums::Buffer::ADDRESS | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, false
);
this->updateBuffer( (const void*) instancesVK.data(), instancesVK.size() * sizeof(VkAccelerationStructureInstanceKHR), instanceIndex, false );
this->metadata.buffers["tlasInstance"] = instanceIndex;
} else {
for ( size_t i = 0; i < buffers.size(); ++i ) {
if ( this->metadata.buffers.count("tlasInstance") > 0 ) {
instanceIndex = this->metadata.buffers["tlasInstance"];
} else for ( int i = 0; i < buffers.size(); ++i ) {
if ( !(this->buffers[i].usage & (uf::renderer::enums::Buffer::ADDRESS | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR)) ) continue;
instanceIndex = i;
break;
@ -1431,9 +1487,15 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
// create BLAS buffer and handle
auto tlasBufferUsageFlags = uf::renderer::enums::Buffer::ACCELERATION_STRUCTURE | uf::renderer::enums::Buffer::ADDRESS;
if ( !update ) {
tlasBufferIndex = this->initializeBuffer( NULL, sizeInfo.accelerationStructureSize, tlasBufferUsageFlags);
const size_t EXTRANEOUS_SIZE = 1024 * 1024;
size_t bufferSize = MAX( sizeInfo.accelerationStructureSize, EXTRANEOUS_SIZE );
tlasBufferIndex = this->initializeBuffer( NULL, bufferSize, tlasBufferUsageFlags);
this->metadata.buffers["tlasBuffer"] = tlasBufferIndex;
} else {
for ( int i = buffers.size() - 1; i >= 0; --i ) {
if ( this->metadata.buffers.count("tlasBuffer") > 0 ) {
tlasBufferIndex = this->metadata.buffers["tlasBuffer"];
} else for ( int i = buffers.size() - 1; i >= 0; --i ) {
if ( !(this->buffers[i].usage & tlasBufferUsageFlags) ) continue;
tlasBufferIndex = i;
break;
@ -1481,6 +1543,7 @@ void ext::vulkan::Graphic::generateTopAccelerationStructure( const uf::stl::vect
}
if ( rebuild ) {
// uf::renderer::states::rebuild = true;
auto& renderMode = ext::vulkan::getRenderMode( descriptor.renderMode, true );
renderMode.rebuild = true;
}

22
engine/src/spec/window/windows.cpp
View File

@ -192,6 +192,10 @@ namespace {
if ( uf::inputs::kbm::states::Num8 ) keys.emplace_back('8');
if ( uf::inputs::kbm::states::Num9 ) keys.emplace_back('9');
if ( uf::inputs::kbm::states::Num0 ) keys.emplace_back('0');
if ( uf::inputs::kbm::states::Mouse1 ) keys.emplace_back(VK_LBUTTON);
if ( uf::inputs::kbm::states::Mouse2 ) keys.emplace_back(VK_RBUTTON);
if ( uf::inputs::kbm::states::Mouse3 ) keys.emplace_back(VK_MBUTTON);
return keys;
}
@ -424,13 +428,16 @@ namespace {
else if ( name == "F14" ) return VK_F14;
else if ( name == "F15" ) return VK_F15;
else if ( name == "PAUSE" ) return VK_PAUSE;
else if ( name == "LEFTMOUSE" ) return VK_LBUTTON;
else if ( name == "RIGHTMOUSE" ) return VK_RBUTTON;
else if ( name == "MIDDLEMOUSE" ) return VK_MBUTTON;
else if ( name == "MOUSE1" ) return VK_LBUTTON;
else if ( name == "MOUSE2" ) return VK_RBUTTON;
else if ( name == "MOUSE3" ) return VK_MBUTTON;
else if ( name == "XBUTTON1" ) return VK_XBUTTON1;
else if ( name == "XBUTTON2" ) return VK_XBUTTON2;
return 0;
}
float lastMouseWheel;
}
UF_API_CALL spec::win32::Window::Window() :
@ -807,6 +814,13 @@ void UF_API_CALL spec::win32::Window::bufferInputs() {
uf::inputs::kbm::states::Num8 = GetAsyncKeyState('8') & 0x8000;
uf::inputs::kbm::states::Num9 = GetAsyncKeyState('9') & 0x8000;
uf::inputs::kbm::states::Num0 = GetAsyncKeyState('0') & 0x8000;
uf::inputs::kbm::states::Mouse1 = GetAsyncKeyState(VK_LBUTTON) & 0x8000;
uf::inputs::kbm::states::Mouse2 = GetAsyncKeyState(VK_RBUTTON) & 0x8000;
uf::inputs::kbm::states::Mouse3 = GetAsyncKeyState(VK_MBUTTON) & 0x8000;
uf::inputs::kbm::states::MouseWheel = ::lastMouseWheel;
::lastMouseWheel = 0;
}
void UF_API_CALL spec::win32::Window::processEvents() {
if ( !this->m_callback ) {
@ -1215,7 +1229,7 @@ void UF_API_CALL spec::win32::Window::processEvent(UINT message, WPARAM wParam,
},
{
pod::Vector2ui{ position.x, position.y },
delta,
::lastMouseWheel = delta,
}
};
#if UF_HOOK_USE_USERDATA

150
engine/src/utils/io/inputs.cpp
View File

@ -102,6 +102,12 @@ uf::inputs::state_t uf::inputs::kbm::states::Num8 = false;
uf::inputs::state_t uf::inputs::kbm::states::Num9 = false;
uf::inputs::state_t uf::inputs::kbm::states::Num0 = false;
uf::inputs::state_t uf::inputs::kbm::states::Mouse1 = false;
uf::inputs::state_t uf::inputs::kbm::states::Mouse2 = false;
uf::inputs::state_t uf::inputs::kbm::states::Mouse3 = false;
uf::inputs::analog_t uf::inputs::kbm::states::MouseWheel = 0.0f;
uf::inputs::state_t uf::inputs::controller::states::R_DPAD_UP = false;
uf::inputs::state_t uf::inputs::controller::states::R_DPAD_DOWN = false;
uf::inputs::state_t uf::inputs::controller::states::R_DPAD_LEFT = false;
@ -136,4 +142,146 @@ uf::inputs::analog2_t uf::inputs::controller::states::R_JOYSTICK = {};
uf::inputs::analog_t uf::inputs::controller::states::L_TRIGGER = false;
uf::inputs::analog_t uf::inputs::controller::states::R_TRIGGER = false;
uf::inputs::state_t uf::inputs::controller::states::START = false;
uf::inputs::state_t uf::inputs::controller::states::START = false;
uf::inputs::state_t uf::inputs::key( const uf::stl::string& key ) {
if ( key == uf::inputs::kbm::enums::LShift ) return uf::inputs::kbm::states::LShift;
else if ( key == uf::inputs::kbm::enums::RShift ) return uf::inputs::kbm::states::RShift;
else if ( key == uf::inputs::kbm::enums::LControl ) return uf::inputs::kbm::states::LControl;
else if ( key == uf::inputs::kbm::enums::RControl ) return uf::inputs::kbm::states::RControl;
else if ( key == uf::inputs::kbm::enums::LAlt ) return uf::inputs::kbm::states::LAlt;
else if ( key == uf::inputs::kbm::enums::RAlt ) return uf::inputs::kbm::states::RAlt;
else if ( key == uf::inputs::kbm::enums::LSystem ) return uf::inputs::kbm::states::LSystem;
else if ( key == uf::inputs::kbm::enums::RSystem ) return uf::inputs::kbm::states::RSystem;
else if ( key == uf::inputs::kbm::enums::Menu ) return uf::inputs::kbm::states::Menu;
else if ( key == uf::inputs::kbm::enums::SemiColon ) return uf::inputs::kbm::states::SemiColon;
else if ( key == uf::inputs::kbm::enums::Slash ) return uf::inputs::kbm::states::Slash;
else if ( key == uf::inputs::kbm::enums::Equal ) return uf::inputs::kbm::states::Equal;
else if ( key == uf::inputs::kbm::enums::Dash ) return uf::inputs::kbm::states::Dash;
else if ( key == uf::inputs::kbm::enums::LBracket ) return uf::inputs::kbm::states::LBracket;
else if ( key == uf::inputs::kbm::enums::RBracket ) return uf::inputs::kbm::states::RBracket;
else if ( key == uf::inputs::kbm::enums::Comma ) return uf::inputs::kbm::states::Comma;
else if ( key == uf::inputs::kbm::enums::Period ) return uf::inputs::kbm::states::Period;
else if ( key == uf::inputs::kbm::enums::Quote ) return uf::inputs::kbm::states::Quote;
else if ( key == uf::inputs::kbm::enums::BackSlash ) return uf::inputs::kbm::states::BackSlash;
else if ( key == uf::inputs::kbm::enums::Tilde ) return uf::inputs::kbm::states::Tilde;
else if ( key == uf::inputs::kbm::enums::Escape ) return uf::inputs::kbm::states::Escape;
else if ( key == uf::inputs::kbm::enums::Space ) return uf::inputs::kbm::states::Space;
else if ( key == uf::inputs::kbm::enums::Enter ) return uf::inputs::kbm::states::Enter;
else if ( key == uf::inputs::kbm::enums::BackSpace ) return uf::inputs::kbm::states::BackSpace;
else if ( key == uf::inputs::kbm::enums::Tab ) return uf::inputs::kbm::states::Tab;
else if ( key == uf::inputs::kbm::enums::PageUp ) return uf::inputs::kbm::states::PageUp;
else if ( key == uf::inputs::kbm::enums::PageDown ) return uf::inputs::kbm::states::PageDown;
else if ( key == uf::inputs::kbm::enums::End ) return uf::inputs::kbm::states::End;
else if ( key == uf::inputs::kbm::enums::Home ) return uf::inputs::kbm::states::Home;
else if ( key == uf::inputs::kbm::enums::Insert ) return uf::inputs::kbm::states::Insert;
else if ( key == uf::inputs::kbm::enums::Delete ) return uf::inputs::kbm::states::Delete;
else if ( key == uf::inputs::kbm::enums::Add ) return uf::inputs::kbm::states::Add;
else if ( key == uf::inputs::kbm::enums::Subtract ) return uf::inputs::kbm::states::Subtract;
else if ( key == uf::inputs::kbm::enums::Multiply ) return uf::inputs::kbm::states::Multiply;
else if ( key == uf::inputs::kbm::enums::Divide ) return uf::inputs::kbm::states::Divide;
else if ( key == uf::inputs::kbm::enums::Pause ) return uf::inputs::kbm::states::Pause;
else if ( key == uf::inputs::kbm::enums::F1 ) return uf::inputs::kbm::states::F1;
else if ( key == uf::inputs::kbm::enums::F2 ) return uf::inputs::kbm::states::F2;
else if ( key == uf::inputs::kbm::enums::F3 ) return uf::inputs::kbm::states::F3;
else if ( key == uf::inputs::kbm::enums::F4 ) return uf::inputs::kbm::states::F4;
else if ( key == uf::inputs::kbm::enums::F5 ) return uf::inputs::kbm::states::F5;
else if ( key == uf::inputs::kbm::enums::F6 ) return uf::inputs::kbm::states::F6;
else if ( key == uf::inputs::kbm::enums::F7 ) return uf::inputs::kbm::states::F7;
else if ( key == uf::inputs::kbm::enums::F8 ) return uf::inputs::kbm::states::F8;
else if ( key == uf::inputs::kbm::enums::F9 ) return uf::inputs::kbm::states::F9;
else if ( key == uf::inputs::kbm::enums::F10 ) return uf::inputs::kbm::states::F10;
else if ( key == uf::inputs::kbm::enums::F11 ) return uf::inputs::kbm::states::F11;
else if ( key == uf::inputs::kbm::enums::F12 ) return uf::inputs::kbm::states::F12;
else if ( key == uf::inputs::kbm::enums::F13 ) return uf::inputs::kbm::states::F13;
else if ( key == uf::inputs::kbm::enums::F14 ) return uf::inputs::kbm::states::F14;
else if ( key == uf::inputs::kbm::enums::F15 ) return uf::inputs::kbm::states::F15;
else if ( key == uf::inputs::kbm::enums::Left ) return uf::inputs::kbm::states::Left;
else if ( key == uf::inputs::kbm::enums::Right ) return uf::inputs::kbm::states::Right;
else if ( key == uf::inputs::kbm::enums::Up ) return uf::inputs::kbm::states::Up;
else if ( key == uf::inputs::kbm::enums::Down ) return uf::inputs::kbm::states::Down;
else if ( key == uf::inputs::kbm::enums::Numpad0 ) return uf::inputs::kbm::states::Numpad0;
else if ( key == uf::inputs::kbm::enums::Numpad1 ) return uf::inputs::kbm::states::Numpad1;
else if ( key == uf::inputs::kbm::enums::Numpad2 ) return uf::inputs::kbm::states::Numpad2;
else if ( key == uf::inputs::kbm::enums::Numpad3 ) return uf::inputs::kbm::states::Numpad3;
else if ( key == uf::inputs::kbm::enums::Numpad4 ) return uf::inputs::kbm::states::Numpad4;
else if ( key == uf::inputs::kbm::enums::Numpad5 ) return uf::inputs::kbm::states::Numpad5;
else if ( key == uf::inputs::kbm::enums::Numpad6 ) return uf::inputs::kbm::states::Numpad6;
else if ( key == uf::inputs::kbm::enums::Numpad7 ) return uf::inputs::kbm::states::Numpad7;
else if ( key == uf::inputs::kbm::enums::Numpad8 ) return uf::inputs::kbm::states::Numpad8;
else if ( key == uf::inputs::kbm::enums::Numpad9 ) return uf::inputs::kbm::states::Numpad9;
else if ( key == uf::inputs::kbm::enums::Q ) return uf::inputs::kbm::states::Q;
else if ( key == uf::inputs::kbm::enums::W ) return uf::inputs::kbm::states::W;
else if ( key == uf::inputs::kbm::enums::E ) return uf::inputs::kbm::states::E;
else if ( key == uf::inputs::kbm::enums::R ) return uf::inputs::kbm::states::R;
else if ( key == uf::inputs::kbm::enums::T ) return uf::inputs::kbm::states::T;
else if ( key == uf::inputs::kbm::enums::Y ) return uf::inputs::kbm::states::Y;
else if ( key == uf::inputs::kbm::enums::U ) return uf::inputs::kbm::states::U;
else if ( key == uf::inputs::kbm::enums::I ) return uf::inputs::kbm::states::I;
else if ( key == uf::inputs::kbm::enums::O ) return uf::inputs::kbm::states::O;
else if ( key == uf::inputs::kbm::enums::P ) return uf::inputs::kbm::states::P;
else if ( key == uf::inputs::kbm::enums::A ) return uf::inputs::kbm::states::A;
else if ( key == uf::inputs::kbm::enums::S ) return uf::inputs::kbm::states::S;
else if ( key == uf::inputs::kbm::enums::D ) return uf::inputs::kbm::states::D;
else if ( key == uf::inputs::kbm::enums::F ) return uf::inputs::kbm::states::F;
else if ( key == uf::inputs::kbm::enums::G ) return uf::inputs::kbm::states::G;
else if ( key == uf::inputs::kbm::enums::H ) return uf::inputs::kbm::states::H;
else if ( key == uf::inputs::kbm::enums::J ) return uf::inputs::kbm::states::J;
else if ( key == uf::inputs::kbm::enums::K ) return uf::inputs::kbm::states::K;
else if ( key == uf::inputs::kbm::enums::L ) return uf::inputs::kbm::states::L;
else if ( key == uf::inputs::kbm::enums::Z ) return uf::inputs::kbm::states::Z;
else if ( key == uf::inputs::kbm::enums::X ) return uf::inputs::kbm::states::X;
else if ( key == uf::inputs::kbm::enums::C ) return uf::inputs::kbm::states::C;
else if ( key == uf::inputs::kbm::enums::V ) return uf::inputs::kbm::states::V;
else if ( key == uf::inputs::kbm::enums::B ) return uf::inputs::kbm::states::B;
else if ( key == uf::inputs::kbm::enums::N ) return uf::inputs::kbm::states::N;
else if ( key == uf::inputs::kbm::enums::M ) return uf::inputs::kbm::states::M;
else if ( key == uf::inputs::kbm::enums::Num1 ) return uf::inputs::kbm::states::Num1;
else if ( key == uf::inputs::kbm::enums::Num2 ) return uf::inputs::kbm::states::Num2;
else if ( key == uf::inputs::kbm::enums::Num3 ) return uf::inputs::kbm::states::Num3;
else if ( key == uf::inputs::kbm::enums::Num4 ) return uf::inputs::kbm::states::Num4;
else if ( key == uf::inputs::kbm::enums::Num5 ) return uf::inputs::kbm::states::Num5;
else if ( key == uf::inputs::kbm::enums::Num6 ) return uf::inputs::kbm::states::Num6;
else if ( key == uf::inputs::kbm::enums::Num7 ) return uf::inputs::kbm::states::Num7;
else if ( key == uf::inputs::kbm::enums::Num8 ) return uf::inputs::kbm::states::Num8;
else if ( key == uf::inputs::kbm::enums::Num9 ) return uf::inputs::kbm::states::Num9;
else if ( key == uf::inputs::kbm::enums::Num0 ) return uf::inputs::kbm::states::Num0;
else if ( key == uf::inputs::kbm::enums::Mouse1 ) return uf::inputs::kbm::states::Mouse1;
else if ( key == uf::inputs::kbm::enums::Mouse2 ) return uf::inputs::kbm::states::Mouse2;
else if ( key == uf::inputs::kbm::enums::Mouse3 ) return uf::inputs::kbm::states::Mouse3;
else if ( key == uf::inputs::controller::enums::R_DPAD_UP ) return uf::inputs::controller::states::R_DPAD_UP;
else if ( key == uf::inputs::controller::enums::R_DPAD_DOWN ) return uf::inputs::controller::states::R_DPAD_DOWN;
else if ( key == uf::inputs::controller::enums::R_DPAD_LEFT ) return uf::inputs::controller::states::R_DPAD_LEFT;
else if ( key == uf::inputs::controller::enums::R_DPAD_RIGHT ) return uf::inputs::controller::states::R_DPAD_RIGHT;
else if ( key == uf::inputs::controller::enums::R_A ) return uf::inputs::controller::states::R_A;
else if ( key == uf::inputs::controller::enums::L_DPAD_UP ) return uf::inputs::controller::states::L_DPAD_UP;
else if ( key == uf::inputs::controller::enums::L_DPAD_DOWN ) return uf::inputs::controller::states::L_DPAD_DOWN;
else if ( key == uf::inputs::controller::enums::L_DPAD_LEFT ) return uf::inputs::controller::states::L_DPAD_LEFT;
else if ( key == uf::inputs::controller::enums::L_DPAD_RIGHT ) return uf::inputs::controller::states::L_DPAD_RIGHT;
else if ( key == uf::inputs::controller::enums::L_A ) return uf::inputs::controller::states::L_A;
else if ( key == uf::inputs::controller::enums::DPAD_UP ) return uf::inputs::controller::states::DPAD_UP;
else if ( key == uf::inputs::controller::enums::DPAD_DOWN ) return uf::inputs::controller::states::DPAD_DOWN;
else if ( key == uf::inputs::controller::enums::DPAD_LEFT ) return uf::inputs::controller::states::DPAD_LEFT;
else if ( key == uf::inputs::controller::enums::DPAD_RIGHT ) return uf::inputs::controller::states::DPAD_RIGHT;
else if ( key == uf::inputs::controller::enums::A ) return uf::inputs::controller::states::A;
else if ( key == uf::inputs::controller::enums::B ) return uf::inputs::controller::states::B;
else if ( key == uf::inputs::controller::enums::X ) return uf::inputs::controller::states::X;
else if ( key == uf::inputs::controller::enums::Y ) return uf::inputs::controller::states::Y;
else if ( key == uf::inputs::controller::enums::START ) return uf::inputs::controller::states::START;
return false;
}
uf::inputs::analog_t uf::inputs::analog( const uf::stl::string& key ) {
if ( key == uf::inputs::kbm::enums::MouseWheel ) return uf::inputs::kbm::states::MouseWheel;
else if ( key == uf::inputs::controller::enums::L_TRIGGER ) return uf::inputs::controller::states::L_TRIGGER;
else if ( key == uf::inputs::controller::enums::R_TRIGGER ) return uf::inputs::controller::states::R_TRIGGER;
return 0.0;
}
uf::inputs::analog2_t uf::inputs::analog2( const uf::stl::string& key ) {
if ( key == uf::inputs::controller::enums::L_JOYSTICK ) return uf::inputs::controller::states::L_JOYSTICK;
else if ( key == uf::inputs::controller::enums::R_JOYSTICK ) return uf::inputs::controller::states::R_JOYSTICK;
return {};
}

4
engine/src/utils/string/ext.cpp
View File

@ -19,7 +19,7 @@ bool UF_API uf::string::isRegex( const uf::stl::string& str ) {
return str.front() == '/' && str.back() == '/';
}
uf::stl::vector<uf::stl::string> UF_API uf::string::match( const uf::stl::string& str, const uf::stl::string& r ) {
std::regex regex(r.substr(1,r.length()-2));
std::regex regex(uf::string::isRegex(r) ? r.substr(1,r.length()-2) : r);
std::smatch match;
uf::stl::vector<uf::stl::string> matches;
if ( std::regex_search( str, match, regex ) ) {
@ -31,7 +31,7 @@ uf::stl::vector<uf::stl::string> UF_API uf::string::match( const uf::stl::string
return matches;
}
bool UF_API uf::string::matched( const uf::stl::string& str, const uf::stl::string& r ) {
std::regex regex(r.substr(1,r.length()-2));
std::regex regex(uf::string::isRegex(r) ? r.substr(1,r.length()-2) : r);
std::smatch match;
return std::regex_search( str, match, regex );
}

89
ext/behaviors/player/behavior.cpp
View File

@ -203,7 +203,7 @@ void ext::PlayerBehavior::tick( uf::Object& self ) {
stats.noclipped = metadata.system.noclipped;
stats.floored = stats.noclipped;
auto& collider = this->getComponent<pod::PhysicsState>();
// if ( !stats.floored && collider.body && uf::physics::impl::rayCast( transform.position, transform.position - pod::Vector3f{0,1,0} ) >= 0.0f ) stats.floored = true;
{
uf::Object* hit = NULL;
pod::Vector3f center = transform.position + metadata.movement.floored.feet;
@ -218,33 +218,41 @@ void ext::PlayerBehavior::tick( uf::Object& self ) {
TIMER(0.25, keys.use && ) {
size_t uid = 0;
uf::Object* pointer = NULL;
float length = 4.0f;
float length = metadata.use.length;
pod::Vector3f center = transform.position + cameraTransform.position;
pod::Vector3f direction = uf::vector::normalize( transform.forward + pod::Vector3f{ 0, cameraTransform.forward.y, 0 } ) * length;
float depth = uf::physics::impl::rayCast( center, direction, this, pointer );
ext::json::Value payload;
if ( pointer ) {
ext::json::Value payload;
payload["uid"] = this->getUid();
payload["depth"] = depth;
payload["user"] = this->getUid();
payload["uid"] = pointer->getUid();
payload["depth"] = uf::vector::norm(direction * depth);
pointer->callHook( "entity:Use.%UID%", payload );
} else {
auto& emitter = this->getComponent<uf::MappedSoundEmitter>();
uf::stl::string filename = "./ui/deny.ogg";
uf::Audio& sfx = emitter.has(filename) ? emitter.get(filename) : emitter.load(filename);
bool playing = false;
if ( !sfx.playing() ) {
#if UF_AUDIO_MAPPED_VOLUMES
sfx.setVolume(uf::audio::volumes.count("sfx") > 0 ? uf::audio::volumes.at("sfx") : 1.0);
#else
sfx.setVolume(uf::audio::volumes::sfx);
#endif
sfx.setPosition( transform.position );
sfx.setTime( 0 );
sfx.play();
}
payload["user"] = this->getUid();
payload["uid"] = 0;
payload["depth"] = -1;
}
this->callHook( "entity:Use.%UID%", payload );
/*
auto& emitter = this->getComponent<uf::MappedSoundEmitter>();
uf::stl::string filename = pointer ? "./ui/select.ogg" : "./ui/deny.ogg";
uf::Audio& sfx = emitter.has(filename) ? emitter.get(filename) : emitter.load(filename);
bool playing = false;
if ( !sfx.playing() ) {
#if UF_AUDIO_MAPPED_VOLUMES
sfx.setVolume(uf::audio::volumes.count("sfx") > 0 ? uf::audio::volumes.at("sfx") : 1.0);
#else
sfx.setVolume(uf::audio::volumes::sfx);
#endif
sfx.setPosition( transform.position );
sfx.setTime( 0 );
sfx.play();
}
*/
}
if ( collider.stats.gravity == pod::Vector3f{0,0,0} ) stats.noclipped = true;
@ -291,23 +299,6 @@ void ext::PlayerBehavior::tick( uf::Object& self ) {
}
metadata.system.menu = stats.menu;
}
/*
{
uf::Object* guiManager = (uf::Object*) scene.globalFindByName("Gui Manager");
bool menu = guiManager && !guiManager->getChildren().empty();
if ( !menu ) stats.menu = "";
if ( stats.menu == "" && keys.paused ) {
stats.menu = "paused";
metadata.system.control = false;
pod::payloads::menuOpen payload;
payload.name = "pause";
uf::hooks.call("menu:Open", payload);
} else {
metadata.system.control = stats.menu == "";
}
metadata.system.menu = stats.menu;
}
*/
pod::Transform<> translator = transform;
#if UF_USE_OPENVR
@ -339,23 +330,13 @@ void ext::PlayerBehavior::tick( uf::Object& self ) {
TIMER(0.25, keys.vee && ) {
bool state = !stats.noclipped;
metadata.system.noclipped = state;
if ( collider.body ) collider.body->enableGravity(!state);
UF_MSG_DEBUG( "{}abled noclip: {}", (state ? "En" : "Dis"), uf::vector::toString(transform.position));
#if 0
if ( state ) {
if ( collider.body ) {
collider.body->setGravity(btVector3(0,0.0,0));
collider.body->setCollisionFlags(collider.body->getCollisionFlags() | btCollisionObject::CF_NO_CONTACT_RESPONSE);
}
} else {
if ( collider.body ) {
collider.body->setGravity(btVector3(0,-9.81,0));
collider.body->setCollisionFlags(collider.body->getCollisionFlags() & ~btCollisionObject::CF_NO_CONTACT_RESPONSE);
}
if ( collider.body ) {
collider.body->enableGravity(!state);
uf::physics::impl::activateCollision(collider, !state);
}
#endif
stats.noclipped = state;
UF_MSG_DEBUG( "{}abled noclip: {}", (state ? "En" : "Dis"), uf::vector::toString(transform.position));
}
// movement handler
// setup desired direction
@ -549,6 +530,8 @@ void ext::PlayerBehavior::Metadata::serialize( uf::Object& self, uf::Serializer&
serializerCameraLimit["current"] = uf::vector::encode(/*this->*/camera.limit.current);
serializerCameraLimit["minima"] = uf::vector::encode(/*this->*/camera.limit.min);
serializerCameraLimit["maxima"] = uf::vector::encode(/*this->*/camera.limit.max);
serializer["use"]["length"] = /*this->*/use.length;
}
void ext::PlayerBehavior::Metadata::deserialize( uf::Object& self, uf::Serializer& serializer ){
auto& serializerSystem = serializer["system"];
@ -583,5 +566,7 @@ void ext::PlayerBehavior::Metadata::deserialize( uf::Object& self, uf::Serialize
/*this->*/camera.limit.current = uf::vector::decode( serializerCameraLimit["current"], /*this->*/camera.limit.current );
/*this->*/camera.limit.min = uf::vector::decode( serializerCameraLimit["minima"], /*this->*/camera.limit.min );
/*this->*/camera.limit.max = uf::vector::decode( serializerCameraLimit["maxima"], /*this->*/camera.limit.max );
/*this->*/use.length = serializer["use"]["length"].as(/*this->*/use.length);
}
#undef this

3
ext/behaviors/player/behavior.h
View File

@ -52,6 +52,9 @@ namespace ext {
float volume;
} footstep;
} audio;
struct {
float length = 4.0f;
} use;
);
}
}

17
ext/behaviors/player/model/behavior.cpp
View File

@ -24,9 +24,8 @@ void ext::PlayerModelBehavior::initialize( uf::Object& self ) {
auto& transform = this->getComponent<pod::Transform<>>();
auto& metadata = this->getComponent<ext::PlayerModelBehavior::Metadata>();
auto& metadataJson = this->getComponent<uf::Serializer>();
transform.reference = &controllerTransform;
metadata.reference = &controllerTransform;
// transform.reference = &controllerTransform;
// metadata.reference = &controllerTransform;
this->addHook( "object:Serialize.%UID%", [&](ext::json::Value& json){ metadata.serialize(self, metadataJson); });
this->addHook( "object:Deserialize.%UID%", [&](ext::json::Value& json){ metadata.deserialize(self, metadataJson); });
@ -34,6 +33,18 @@ void ext::PlayerModelBehavior::initialize( uf::Object& self ) {
}
void ext::PlayerModelBehavior::tick( uf::Object& self ) {
auto& metadata = this->getComponent<ext::PlayerModelBehavior::Metadata>();
if ( metadata.track ) {
auto& scene = uf::scene::getCurrentScene();
auto& controller = scene.getController();
auto& controllerTransform = controller.getComponent<pod::Transform<>>();
auto& transform = this->getComponent<pod::Transform<>>();
transform.reference = &controllerTransform;
metadata.reference = &controllerTransform;
}
if ( !metadata.hide || metadata.set || this->getChildren().size() != 1 ) return;
auto& metadataJson = this->getComponent<uf::Serializer>();
#if UF_ENTITY_METADATA_USE_JSON

35
ext/behaviors/scene/behavior.cpp
View File

@ -74,22 +74,6 @@ void ext::ExtSceneBehavior::initialize( uf::Object& self ) {
uf::Serializer& metadataJson = gui.getComponent<uf::Serializer>();
gui.initialize();
};
/*
static uf::Timer<long long> timer(false);
if ( !timer.running() ) timer.start( uf::Time<>(-1000000) );
if ( timer.elapsed().asDouble() < 1 ) return;
timer.reset();
uf::Object* manager = (uf::Object*) this->globalFindByName("Gui Manager");
if ( !manager ) return;
ext::json::Value payload;
uf::stl::string config = metadataJson["menus"]["pause"].as<uf::stl::string>("/entites/gui/pause/menu.json");
uf::Object& gui = manager->loadChild(config, false);
payload["uid"] = gui.getUid();
uf::Serializer& metadataJson = gui.getComponent<uf::Serializer>();
metadataJson["menu"] = payload.menu;
gui.initialize();
*/
});
this->addHook( "world:Entity.LoadAsset", [&](pod::payloads::assetLoad& payload){
assetLoader.load("asset:Load." + std::to_string(payload.uid), payload);
@ -109,6 +93,25 @@ void ext::ExtSceneBehavior::initialize( uf::Object& self ) {
this->addHook( "window:Resized", [&](pod::payloads::windowResized& payload){
ext::gui::size.current = payload.window.size;
});
/* Spawn an entity */
this->addHook( "entity:Spawn", [&](pod::payloads::entitySpawn& payload){
if ( payload.parent.uid ) {
payload.parent.pointer = (uf::Object*) this->globalFindByUid(payload.parent.uid);
}
if ( !payload.parent.pointer ) payload.parent.pointer = this;
uf::Object* child = NULL;
if ( payload.filename != "" ) child = payload.parent.pointer->loadChildPointer( payload.filename );
else child = payload.parent.pointer->loadChildPointer( payload.metadata );
if ( !child ) return;
auto& transform = child->getComponent<pod::Transform<>>();
if ( payload.transform.position != pod::Vector3f{0,0,0} ) transform.position = payload.transform.position;
if ( payload.transform.orientation != uf::quaternion::identity() ) transform.orientation = payload.transform.orientation;
if ( !payload.transform.reference ) transform.reference = payload.transform.reference;
});
this->addHook( "object:Serialize.%UID%", [&](ext::json::Value& json){ metadata.serialize(self, metadataJson); });
this->addHook( "object:Deserialize.%UID%", [&](ext::json::Value& json){ metadata.deserialize(self, metadataJson); });