Commit for 2021.12.29 23-43-26.7z

2021-12-29 23:43:00 -06:00 · 2021-12-29 23:43:00 -06:00 · ae6bb02cdd
commit ae6bb02cdd
parent 3bd7dc76b4
16 changed files with 295 additions and 62 deletions
--- a/2
+++ b/2
@ -3,7 +3,7 @@ CC						= $(shell cat "./bin/exe/default.config")
 TARGET_NAME 			= program
 TARGET_EXTENSION 		= exe
 TARGET_LIB_EXTENSION 	= dll
-RENDERER 				= vulkan
+RENDERER 				= opengl

 include makefiles/$(ARCH).$(CC).make

--- a/bin/data/entities/player.json
+++ b/bin/data/entities/player.json
@ -9,7 +9,7 @@
 		"position": [ 0, 0, 0 ],
 		"rotation": {
 			"axis": [ 0, 1, 0 ],
-			"angle": 0.0
+			"angle": 3.1415926
 		},
 		"scale": [ 1, 1, 1 ]
 	},
--- a/bin/data/entities/playerModel.json
+++ b/bin/data/entities/playerModel.json
@ -1,7 +1,7 @@
 {
 	"type": "Object",
 	"name": "Player: Model",
-	"ignore": false,
+	"ignore": true,
 	"assets": [
 		"/player/bear.glb"
 	//	{ "filename": "/player/bear/graph.json", "delay": 0, "single threaded": false, "category": "models" }
--- a/bin/data/scenes/ss2/medsci.json
+++ b/bin/data/scenes/ss2/medsci.json
@ -1,10 +1,13 @@
 {
 	"import": "/model.json",
 	"assets": [
+	//	{ "filename": "./models/tiny_msci.glb", "delay": 0, "single threaded": false, "category": "models" }
+		{ "filename": "./models/tiny_msci/graph.json.gz", "delay": 0, "single threaded": false, "category": "models" }
+
 	//	{ "filename": "./models/micro_sci.glb", "delay": 0, "single threaded": false, "category": "models" }
 	//	{ "filename": "./models/micro_sci/graph.json", "delay": 0, "single threaded": false, "category": "models" }
-		{ "filename": "./models/micro_sci/graph.json.gz", "delay": 0, "single threaded": false, "category": "models" },
-		{ "filename": "./craeture.json", "delay": 1 }
+	//	{ "filename": "./models/micro_sci/graph.json.gz", "delay": 0, "single threaded": false, "category": "models" }
+	//	{ "filename": "./craeture.json", "delay": 1 }

 	//	{ "filename": "./models/msci.glb", "delay": 0, "single threaded": false, "category": "models" }
 	//	{ "filename": "./models/msci/graph.json", "delay": 0, "single threaded": false, "category": "models" }
@ -16,6 +19,13 @@
 	],
 	"metadata": {
 		"model": {
+			"baking": {
+				"enabled": true,
+				"resolution": 8192,
+				"shadows": 1024,
+				"trigger": { "mode": "rendered" },
+				"output": "./lightmap.png"
+			},
 			"tags": {
 				"worldspawn": {  "physics": { "type": "mesh", "static": true } },
 			//	"worldspawn": {  "physics": { "type": "bounding boxes", "static": true } },
--- a/bin/dreamcast/config.json
+++ b/bin/dreamcast/config.json
@ -149,6 +149,7 @@
 		"mode" : "windowed",
 		"icon" : "./data/textures/icon.png",
 		"size" :  [ 640, 480 ],
+	//	"size" :  [ 320, 240 ],
 		"title" : "Grimgram",
 		"visible" : true
 	}
--- a/client/main.cpp
+++ b/client/main.cpp
@ -63,6 +63,7 @@ int main(int argc, char** argv){
 	client::initialize();
 	ext::initialize();

+
 	// For Multithreaded initialization
 	while ( !client::ready || !ext::ready ) {
 		static uf::Timer<long long> timer(false);
--- a/engine/inc/uf/macros.h
+++ b/engine/inc/uf/macros.h
@ -4,10 +4,12 @@
 #define UF_NS_GET_LAST(name) uf::string::replace( uf::string::split( #name, "::" ).back(), "<>", "" )

 /*
+-x * 1000, uf::Time<long long>::milliseconds
+
 #define TIMER(x, ...) auto TOKEN_PASTE(TIMER, __LINE__) = []( uf::physics::num_t every = 1 ) {\
 		static uf::Timer<long long> timer(false);\
 		if ( !timer.running() ) {\
-			timer.start(uf::Time<long long>(-x * 1000, uf::Time<long long>::milliseconds));\
+			timer.start(uf::Time<long long>(-1000000));\
 		}\
 		uf::physics::num_t time = 0;\
 		if ( (time = timer.elapsed()) >= every ) {\
@ -21,7 +23,7 @@
 */
 #define TIMER_LAMBDA(x) []() {\
 	static uf::Timer<long long> timer(false);\
-	if ( !timer.running() ) timer.start(uf::Time<long long>(-x * 1000, uf::Time<long long>::milliseconds));\
+	if ( !timer.running() ) timer.start(uf::Time<long long>(-1000000));\
 	uf::physics::num_t time = timer.elapsed();\
 	if ( time >= every ) timer.reset();\
 	static bool first = true; if ( first ) { first = false; return every; }\
@ -30,7 +32,7 @@

 #define TIMER(x, ...)\
 	static uf::Timer<long long> timer(false);\
-	if ( !timer.running() ) timer.start(uf::Time<long long>(-x * 1000, uf::Time<long long>::milliseconds));\
+	if ( !timer.running() ) timer.start(uf::Time<long long>(-1000000));\
 	uf::physics::num_t time = timer.elapsed();\
 	if ( time >= x ) timer.reset();\
 	if ( __VA_ARGS__ time >= x )
--- a/engine/src/engine/asset/asset.cpp
+++ b/engine/src/engine/asset/asset.cpp
@ -183,17 +183,19 @@ uf::Asset::Payload uf::Asset::resolveToPayload( const uf::stl::string& uri, cons
 	uf::Asset::Payload payload;

 	static uf::stl::unordered_map<uf::stl::string,uf::Asset::Type> typemap = {
-		{ "jpg", uf::Asset::Type::IMAGE },
-		{ "jpeg", uf::Asset::Type::IMAGE },
-		{ "png", uf::Asset::Type::IMAGE },
+		{ "jpg", 	uf::Asset::Type::IMAGE },
+		{ "jpeg", 	uf::Asset::Type::IMAGE },
+		{ "png", 	uf::Asset::Type::IMAGE },
 		
-		{ "ogg", uf::Asset::Type::AUDIO },
+		{ "ogg", 	uf::Asset::Type::AUDIO },

-		{ "json", uf::Asset::Type::JSON },
+		{ "json", 	uf::Asset::Type::JSON },

-		{ "lua", uf::Asset::Type::LUA },
+		{ "lua", 	uf::Asset::Type::LUA },

-		{ "mdl", uf::Asset::Type::GRAPH },
+		{ "glb",  	uf::Asset::Type::GRAPH },
+		{ "gltf", 	uf::Asset::Type::GRAPH },
+		{ "mdl",  	uf::Asset::Type::GRAPH },
 	};

 	payload.filename = uri;
@ -274,7 +276,7 @@ uf::stl::string uf::Asset::load(const uf::Asset::Payload& payload ) {
 		} break;
 		case uf::Asset::Type::AUDIO: {
 			UF_ASSET_REGISTER(uf::Audio)
-			asset.stream(filename);
+			asset.open(filename, true);
 		} break;
 		case uf::Asset::Type::JSON: {
 			UF_ASSET_REGISTER(uf::Serializer)
--- a/engine/src/ext/opengl/opengl.cpp
+++ b/engine/src/ext/opengl/opengl.cpp
@ -13,8 +13,8 @@
 #include <fstream>
 #include <atomic>

-uint32_t ext::opengl::settings::width = 1280;
-uint32_t ext::opengl::settings::height = 720;
+uint32_t ext::opengl::settings::width = 640;
+uint32_t ext::opengl::settings::height = 480;
 uint8_t ext::opengl::settings::msaa = 1;
 bool ext::opengl::settings::validation = true;
 // constexpr size_t ext::opengl::settings::maxViews = 6;
--- a/engine/src/ext/opengl/shader.cpp
+++ b/engine/src/ext/opengl/shader.cpp
@ -109,31 +109,16 @@ void ext::opengl::Shader::destroy() {
 bool ext::opengl::Shader::validate() {
 	// check if uniforms match buffer size
 	bool valid = true;
-#if 0
-	{
-		auto it = uniforms.begin();
-		for ( auto& buffer : buffers ) {
-			if ( !(buffer.usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
-			if ( it == uniforms.end() ) break;
-			auto& uniform = *(it++);
-			if ( uniform.data().len != buffer.allocationInfo.size ) {
-				GL_DEBUG_VALIDATION_MESSAGE("Uniform size mismatch: Expected " << buffer.allocationInfo.size << ", got " << uniform.data().len << "; fixing...");
-				uniform.destroy();
-				uniform.create(buffer.allocationInfo.size);
-				valid = false;
-			}
-		}
-	}
-#endif
+
 	return valid;
 }
 bool ext::opengl::Shader::hasUniform( const uf::stl::string& name ) const {
-//	return !ext::json::isNull(metadata.json["definitions"]["uniforms"][name]);
-	return metadata.definitions.uniforms.count(name) > 0;
+//	return metadata.definitions.uniforms.count(name) > 0;
+	return true;
 }
 ext::opengl::Buffer& ext::opengl::Shader::getUniformBuffer( const uf::stl::string& name ) {
 	UF_ASSERT( hasUniform(name) );
-	size_t uniformIndex = metadata.definitions.uniforms[name].index;
+	size_t uniformIndex = 0; // metadata.definitions.uniforms[name].index;
 	for ( size_t bufferIndex = 0, uniformCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
 		if ( !(buffers[bufferIndex].usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
 		if ( uniformCounter++ != uniformIndex ) continue;
@ -143,7 +128,7 @@ ext::opengl::Buffer& ext::opengl::Shader::getUniformBuffer( const uf::stl::strin
 }
 const ext::opengl::Buffer& ext::opengl::Shader::getUniformBuffer( const uf::stl::string& name ) const {
 	UF_ASSERT( hasUniform(name) );
-	size_t uniformIndex = metadata.definitions.uniforms.at(name).index;
+	size_t uniformIndex = 0; // metadata.definitions.uniforms.at(name).index;
 	for ( size_t bufferIndex = 0, uniformCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
 		if ( !(buffers.at(bufferIndex).usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
 		if ( uniformCounter++ != uniformIndex ) continue;
@ -153,28 +138,28 @@ const ext::opengl::Buffer& ext::opengl::Shader::getUniformBuffer( const uf::stl:
 }
 ext::opengl::userdata_t& ext::opengl::Shader::getUniform( const uf::stl::string& name ) {
 	UF_ASSERT( hasUniform(name) );
-	return uniforms[metadata.definitions.uniforms[name].index];
+	return uniforms[0/*metadata.definitions.uniforms[name].index*/];
 }
 const ext::opengl::userdata_t& ext::opengl::Shader::getUniform( const uf::stl::string& name ) const {
 	UF_ASSERT( hasUniform(name) );
-	return uniforms.at(metadata.definitions.uniforms.at(name).index);
+	return uniforms.at(0/*metadata.definitions.uniforms.at(name).index*/);
 }
 bool ext::opengl::Shader::updateUniform( const uf::stl::string& name, const void* data, size_t size ) const {
 	if ( !hasUniform(name) ) return false;
 	auto& bufferObject = getUniformBuffer(name);
-	size = MAX(metadata.definitions.uniforms.at(name).size, bufferObject.allocationInfo.size);
+//	size = MAX(metadata.definitions.uniforms.at(name).size, bufferObject.allocationInfo.size);
 	updateBuffer( data, size, bufferObject );
 	return true;
 }

 bool ext::opengl::Shader::hasStorage( const uf::stl::string& name ) const {
-//	return !ext::json::isNull(metadata["definitions"]["storage"][name]);
-	return metadata.definitions.storage.count(name) > 0;
+//	return metadata.definitions.storage.count(name) > 0;
+	return true;
 }

 ext::opengl::Buffer& ext::opengl::Shader::getStorageBuffer( const uf::stl::string& name ) {
 	UF_ASSERT( hasStorage(name) );
-	size_t storageIndex = metadata.definitions.storage[name].index;
+	size_t storageIndex = 0; // metadata.definitions.storage[name].index;
 	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
 		if ( !(buffers[bufferIndex].usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
 		if ( storageCounter++ != storageIndex ) continue;
@ -184,7 +169,7 @@ ext::opengl::Buffer& ext::opengl::Shader::getStorageBuffer( const uf::stl::strin
 }
 const ext::opengl::Buffer& ext::opengl::Shader::getStorageBuffer( const uf::stl::string& name ) const {
 	UF_ASSERT( hasStorage(name) );
-	size_t storageIndex = metadata.definitions.storage.at(name).index;
+	size_t storageIndex = 0; // metadata.definitions.storage.at(name).index;
 	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
 		if ( !(buffers.at(bufferIndex).usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
 		if ( storageCounter++ != storageIndex ) continue;
--- a/engine/src/spec/controller/dreamcast.cpp
+++ b/engine/src/spec/controller/dreamcast.cpp
@ -5,6 +5,11 @@
 #include <limits>
 #include <uf/utils/string/ext.h>
 #include <uf/utils/math/vector.h>
+
+#include <uf/utils/io/inputs.h>
+
+#define NORMALIZE(X) ((float) (X) / (float) std::numeric_limits<decltype(X)>::max())
+
 namespace {
 	struct {
 		maple_device_t* device = NULL;
@ -64,6 +69,54 @@ void spec::dreamcast::controller::initialize() {
 void spec::dreamcast::controller::tick() {
 	if ( !::controller.device ) ::controller.device = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
 	if ( ::controller.device ) ::controller.state = (cont_state_t*) maple_dev_status(::controller.device);
+
+	if ( !::controller.state ) return;
+
+//	uf::inputs::controller::states::C = ::controller.state->buttons & CONT_C;
+	uf::inputs::controller::states::B = ::controller.state->buttons & CONT_B;
+	uf::inputs::controller::states::A = ::controller.state->buttons & CONT_A;
+	uf::inputs::controller::states::START = ::controller.state->buttons & CONT_START;
+	uf::inputs::controller::states::DPAD_UP = ::controller.state->buttons & CONT_DPAD_UP;
+	uf::inputs::controller::states::DPAD_DOWN = ::controller.state->buttons & CONT_DPAD_DOWN;
+	uf::inputs::controller::states::DPAD_LEFT = ::controller.state->buttons & CONT_DPAD_LEFT;
+	uf::inputs::controller::states::DPAD_RIGHT = ::controller.state->buttons & CONT_DPAD_RIGHT;
+//	uf::inputs::controller::states::Z = ::controller.state->buttons & CONT_Z;
+	uf::inputs::controller::states::Y = ::controller.state->buttons & CONT_Y;
+	uf::inputs::controller::states::X = ::controller.state->buttons & CONT_X;
+//	uf::inputs::controller::states::D = ::controller.state->buttons & CONT_D;
+
+	uf::inputs::controller::states::L_DPAD_UP = ::controller.state->buttons & CONT_DPAD_UP;
+	uf::inputs::controller::states::L_DPAD_DOWN = ::controller.state->buttons & CONT_DPAD_DOWN;
+	uf::inputs::controller::states::L_DPAD_LEFT = ::controller.state->buttons & CONT_DPAD_LEFT;
+	uf::inputs::controller::states::L_DPAD_RIGHT = ::controller.state->buttons & CONT_DPAD_RIGHT;
+
+	uf::inputs::controller::states::R_DPAD_UP = ::controller.state->buttons & CONT_DPAD2_UP;
+	uf::inputs::controller::states::R_DPAD_DOWN = ::controller.state->buttons & CONT_DPAD2_DOWN;
+	uf::inputs::controller::states::R_DPAD_LEFT = ::controller.state->buttons & CONT_DPAD2_LEFT;
+	uf::inputs::controller::states::R_DPAD_RIGHT = ::controller.state->buttons & CONT_DPAD2_RIGHT;
+
+/*
+	if ( uf::inputs::controller::states::B ) UF_MSG_DEBUG("[Pressed] B");
+	if ( uf::inputs::controller::states::A ) UF_MSG_DEBUG("[Pressed] A");
+	if ( uf::inputs::controller::states::START ) UF_MSG_DEBUG("[Pressed] START");
+	if ( uf::inputs::controller::states::DPAD_UP ) UF_MSG_DEBUG("[Pressed] DPAD_UP");
+	if ( uf::inputs::controller::states::DPAD_DOWN ) UF_MSG_DEBUG("[Pressed] DPAD_DOWN");
+	if ( uf::inputs::controller::states::DPAD_LEFT ) UF_MSG_DEBUG("[Pressed] DPAD_LEFT");
+	if ( uf::inputs::controller::states::DPAD_RIGHT ) UF_MSG_DEBUG("[Pressed] DPAD_RIGHT");
+	if ( uf::inputs::controller::states::Y ) UF_MSG_DEBUG("[Pressed] Y");
+	if ( uf::inputs::controller::states::X ) UF_MSG_DEBUG("[Pressed] X");
+
+	if ( uf::inputs::controller::states::L_DPAD_UP ) UF_MSG_DEBUG("[Pressed] L_DPAD_UP");
+	if ( uf::inputs::controller::states::L_DPAD_DOWN ) UF_MSG_DEBUG("[Pressed] L_DPAD_DOWN");
+	if ( uf::inputs::controller::states::L_DPAD_LEFT ) UF_MSG_DEBUG("[Pressed] L_DPAD_LEFT");
+	if ( uf::inputs::controller::states::L_DPAD_RIGHT ) UF_MSG_DEBUG("[Pressed] L_DPAD_RIGHT");
+
+	if ( uf::inputs::controller::states::R_DPAD_UP ) UF_MSG_DEBUG("[Pressed] R_DPAD_UP");
+	if ( uf::inputs::controller::states::R_DPAD_DOWN ) UF_MSG_DEBUG("[Pressed] R_DPAD_DOWN");
+	if ( uf::inputs::controller::states::R_DPAD_LEFT ) UF_MSG_DEBUG("[Pressed] R_DPAD_LEFT");
+	if ( uf::inputs::controller::states::R_DPAD_RIGHT ) UF_MSG_DEBUG("[Pressed] R_DPAD_RIGHT");
+*/
+
 #if 0
 	uf::stl::vector<uf::stl::string> str;
 	pod::Vector2f joystick = { analog("L_JOYSTICK_X"), analog("L_JOYSTICK_Y") };
@ -97,7 +150,6 @@ bool spec::dreamcast::controller::pressed( const uf::stl::string& str, size_t i
 	return ::controller.state->buttons & GetKeyCode( str );
 }
 float spec::dreamcast::controller::analog( const uf::stl::string& str, size_t i ) {
-#define NORMALIZE(X) ((float) (X) / (float) std::numeric_limits<decltype(X)>::max())
 	if ( !::controller.state ) return false;
 	
 	if ( str == "L_TRIGGER" ) return NORMALIZE(::controller.state->ltrig); 
--- a/engine/src/spec/window/dreamcast.cpp
+++ b/engine/src/spec/window/dreamcast.cpp
@ -3,6 +3,7 @@
 #include <uf/utils/string/utf.h>
 #include <uf/utils/string/ext.h>
 #include <uf/utils/window/payloads.h>
+#include <uf/utils/io/inputs.h>

 #if UF_ENV_DREAMCAST

@ -32,6 +33,8 @@ namespace {
 		mouse_state_t* state = NULL;
 	} mouse;

+	pod::Vector2ui resolution = { 640, 480 };
+
 	bool GetModifier( uint8_t modifier ) {
 		if ( !::keyboard.state ) return false;
 		return ::keyboard.state->cond.modifiers & modifier;
@ -303,6 +306,8 @@ UF_API_CALL spec::dreamcast::Window::Window( const spec::dreamcast::Window::vect
 }
 void UF_API_CALL spec::dreamcast::Window::create( const spec::dreamcast::Window::vector_t& _size, const spec::dreamcast::Window::title_t& title ) {
 	::keyboard.device = maple_enum_type(1, MAPLE_FUNC_KEYBOARD);
+
+	this->setSize(_size);
 }

 spec::dreamcast::Window::~Window() {
@ -317,7 +322,7 @@ spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getPositi
 	return { 0, 0 };
 }
 spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getSize() const {
-	return { 640, 480 };
+	return ::resolution;
 }
 size_t UF_API_CALL spec::dreamcast::Window::getRefreshRate() const {
 	return 60;
@ -330,9 +335,27 @@ void UF_API_CALL spec::dreamcast::Window::setPosition( const spec::dreamcast::Wi
 void UF_API_CALL spec::dreamcast::Window::setMousePosition( const spec::dreamcast::Window::vector_t& position ) {
 }
 spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getMousePosition( ) {
-	return { 320, 240 };
+	return { ::resolution.x / 2, ::resolution.y / 2 };
 }
 void UF_API_CALL spec::dreamcast::Window::setSize( const spec::dreamcast::Window::vector_t& size ) {
+	int e = 0;
+	int p = PM_RGB565;
+
+	if ( size.x == 320 && size.y == 240 ) e = DM_320x240;
+	else if ( size.x == 640 && size.y == 480 ) e = DM_640x480;
+	else if ( size.x == 800 && size.y == 608 ) e = DM_800x608;
+	else if ( size.x == 256 && size.y == 256 ) e = DM_256x256;
+	else if ( size.x == 768 && size.y == 480 ) e = DM_768x480;
+	else if ( size.x == 768 && size.y == 576 ) e = DM_768x576;
+
+	if ( !e ) {
+		UF_MSG_ERROR("invalid resolution set");
+		return;
+	}
+
+	::resolution = size;
+	vid_set_mode(e, p);
+	UF_MSG_DEBUG("Changing resolution to " << uf::vector::toString( size ));
 }

 void UF_API_CALL spec::dreamcast::Window::setTitle( const spec::dreamcast::Window::title_t& title ) {
@ -356,7 +379,119 @@ bool UF_API_CALL spec::dreamcast::Window::hasFocus() const {

 #include <uf/utils/serialize/serializer.h>
 void UF_API_CALL spec::dreamcast::Window::bufferInputs() {
+	uf::inputs::kbm::states::LShift = GetModifier(KBD_MOD_LSHIFT);
+	uf::inputs::kbm::states::RShift = GetModifier(KBD_MOD_RSHIFT);
+
+	uf::inputs::kbm::states::LAlt = GetModifier(KBD_MOD_LALT);
+	uf::inputs::kbm::states::RAlt = GetModifier(KBD_MOD_RALT);
+
+	uf::inputs::kbm::states::LControl = GetModifier(KBD_MOD_LCTRL);
+	uf::inputs::kbm::states::RControl = GetModifier(KBD_MOD_RCTRL);
+
+	uf::inputs::kbm::states::LSystem = GetModifier(KBD_MOD_S1);
+	uf::inputs::kbm::states::RSystem = GetModifier(KBD_MOD_S2);
+
+//	uf::inputs::kbm::states::Menu = KBD_KEY_APPS;
+	uf::inputs::kbm::states::SemiColon = KBD_KEY_SEMICOLON;
+	uf::inputs::kbm::states::Slash = KBD_KEY_SLASH;
+//	uf::inputs::kbm::states::Equal = KBD_KEY_EQUAL;
+	uf::inputs::kbm::states::Dash = KBD_KEY_MINUS;
+	uf::inputs::kbm::states::LBracket = KBD_KEY_LBRACKET;
+	uf::inputs::kbm::states::RBracket = KBD_KEY_RBRACKET;
+	uf::inputs::kbm::states::Comma = KBD_KEY_COMMA;
+	uf::inputs::kbm::states::Period = KBD_KEY_PERIOD;
+	uf::inputs::kbm::states::Quote = KBD_KEY_QUOTE;
+	uf::inputs::kbm::states::BackSlash = KBD_KEY_BACKSLASH;
+	uf::inputs::kbm::states::Tilde = KBD_KEY_TILDE;
+
+	uf::inputs::kbm::states::Escape = KBD_KEY_ESCAPE;
+	uf::inputs::kbm::states::Space = KBD_KEY_SPACE;
+	uf::inputs::kbm::states::Enter = KBD_KEY_ENTER;
+	uf::inputs::kbm::states::BackSpace = KBD_KEY_BACKSPACE;
+	uf::inputs::kbm::states::Tab = KBD_KEY_TAB;
+	uf::inputs::kbm::states::PageUp = KBD_KEY_PGUP;
+	uf::inputs::kbm::states::PageDown = KBD_KEY_PGDOWN;
+	uf::inputs::kbm::states::End = KBD_KEY_END;
+	uf::inputs::kbm::states::Home = KBD_KEY_HOME;
+	uf::inputs::kbm::states::Insert = KBD_KEY_INSERT;
+	uf::inputs::kbm::states::Delete = KBD_KEY_DEL;
+	uf::inputs::kbm::states::Add = KBD_KEY_PAD_PLUS;
+	uf::inputs::kbm::states::Subtract = KBD_KEY_PAD_MINUS;
+	uf::inputs::kbm::states::Multiply = KBD_KEY_PAD_MULTIPLY;
+	uf::inputs::kbm::states::Divide = KBD_KEY_PAD_DIVIDE;
+	uf::inputs::kbm::states::Pause = KBD_KEY_PAUSE;
 	
+	uf::inputs::kbm::states::F1 = KBD_KEY_F1;
+	uf::inputs::kbm::states::F2 = KBD_KEY_F2;
+	uf::inputs::kbm::states::F3 = KBD_KEY_F3;
+	uf::inputs::kbm::states::F4 = KBD_KEY_F4;
+	uf::inputs::kbm::states::F5 = KBD_KEY_F5;
+	uf::inputs::kbm::states::F6 = KBD_KEY_F6;
+	uf::inputs::kbm::states::F7 = KBD_KEY_F7;
+	uf::inputs::kbm::states::F8 = KBD_KEY_F8;
+	uf::inputs::kbm::states::F9 = KBD_KEY_F9;
+	uf::inputs::kbm::states::F10 = KBD_KEY_F10;
+	uf::inputs::kbm::states::F11 = KBD_KEY_F11;
+	uf::inputs::kbm::states::F12 = KBD_KEY_F12;
+//	uf::inputs::kbm::states::F13 = KBD_KEY_F13;
+//	uf::inputs::kbm::states::F14 = KBD_KEY_F14;
+//	uf::inputs::kbm::states::F15 = KBD_KEY_F15;
+	
+	uf::inputs::kbm::states::Left = KBD_KEY_LEFT;
+	uf::inputs::kbm::states::Right = KBD_KEY_RIGHT;
+	uf::inputs::kbm::states::Up = KBD_KEY_UP;
+	uf::inputs::kbm::states::Down = KBD_KEY_DOWN;
+
+	uf::inputs::kbm::states::Numpad0 = KBD_KEY_PAD_0;
+	uf::inputs::kbm::states::Numpad1 = KBD_KEY_PAD_1;
+	uf::inputs::kbm::states::Numpad2 = KBD_KEY_PAD_2;
+	uf::inputs::kbm::states::Numpad3 = KBD_KEY_PAD_3;
+	uf::inputs::kbm::states::Numpad4 = KBD_KEY_PAD_4;
+	uf::inputs::kbm::states::Numpad5 = KBD_KEY_PAD_5;
+	uf::inputs::kbm::states::Numpad6 = KBD_KEY_PAD_6;
+	uf::inputs::kbm::states::Numpad7 = KBD_KEY_PAD_7;
+	uf::inputs::kbm::states::Numpad8 = KBD_KEY_PAD_8;
+	uf::inputs::kbm::states::Numpad9 = KBD_KEY_PAD_9;
+
+	uf::inputs::kbm::states::Q = KBD_KEY_Q;
+	uf::inputs::kbm::states::W = KBD_KEY_W;
+	uf::inputs::kbm::states::E = KBD_KEY_E;
+	uf::inputs::kbm::states::R = KBD_KEY_R;
+	uf::inputs::kbm::states::T = KBD_KEY_T;
+	uf::inputs::kbm::states::Y = KBD_KEY_Y;
+	uf::inputs::kbm::states::U = KBD_KEY_U;
+	uf::inputs::kbm::states::I = KBD_KEY_I;
+	uf::inputs::kbm::states::O = KBD_KEY_O;
+	uf::inputs::kbm::states::P = KBD_KEY_P;
+	
+	uf::inputs::kbm::states::A = KBD_KEY_A;
+	uf::inputs::kbm::states::S = KBD_KEY_S;
+	uf::inputs::kbm::states::D = KBD_KEY_D;
+	uf::inputs::kbm::states::F = KBD_KEY_F;
+	uf::inputs::kbm::states::G = KBD_KEY_G;
+	uf::inputs::kbm::states::H = KBD_KEY_H;
+	uf::inputs::kbm::states::J = KBD_KEY_J;
+	uf::inputs::kbm::states::K = KBD_KEY_K;
+	uf::inputs::kbm::states::L = KBD_KEY_L;
+	
+	uf::inputs::kbm::states::Z = KBD_KEY_Z;
+	uf::inputs::kbm::states::X = KBD_KEY_X;
+	uf::inputs::kbm::states::C = KBD_KEY_C;
+	uf::inputs::kbm::states::V = KBD_KEY_V;
+	uf::inputs::kbm::states::B = KBD_KEY_B;
+	uf::inputs::kbm::states::N = KBD_KEY_N;
+	uf::inputs::kbm::states::M = KBD_KEY_M;
+	
+	uf::inputs::kbm::states::Num1 = KBD_KEY_1;
+	uf::inputs::kbm::states::Num2 = KBD_KEY_2;
+	uf::inputs::kbm::states::Num3 = KBD_KEY_3;
+	uf::inputs::kbm::states::Num4 = KBD_KEY_4;
+	uf::inputs::kbm::states::Num5 = KBD_KEY_5;
+	uf::inputs::kbm::states::Num6 = KBD_KEY_6;
+	uf::inputs::kbm::states::Num7 = KBD_KEY_7;
+	uf::inputs::kbm::states::Num8 = KBD_KEY_8;
+	uf::inputs::kbm::states::Num9 = KBD_KEY_9;
+	uf::inputs::kbm::states::Num0 = KBD_KEY_0;
 }
 void UF_API_CALL spec::dreamcast::Window::processEvents() {	
 	if ( !::keyboard.device ) ::keyboard.device = maple_enum_type(0, MAPLE_FUNC_KEYBOARD);
@ -426,24 +561,20 @@ bool UF_API_CALL spec::dreamcast::Window::pollEvents( bool block ) {
 		auto& event = this->m_events.front();
 		if ( event.payload.is<uf::stl::string>() ) {
 			ext::json::Value payload = uf::Serializer( event.payload.as<uf::stl::string>() );
+			uf::hooks.call( "window:Event", payload );
 			uf::hooks.call( event.name, payload );
 		} else if ( event.payload.is<uf::Serializer>() ) {
 			uf::Serializer& payload = event.payload.as<uf::Serializer>();
+			uf::hooks.call( "window:Event", payload );
 			uf::hooks.call( event.name, payload );
 		} else if ( event.payload.is<ext::json::Value>() ) {
 			ext::json::Value& payload = event.payload.as<ext::json::Value>();
-			uf::hooks.call( event.name, payload );
-		} else {
-			uf::hooks.call( event.name, event.payload );
-		}
-	/*
-		try {
 			uf::hooks.call( "window:Event", payload );
 			uf::hooks.call( event.name, payload );
-		} catch ( ... ) {
-			// Let the hook handler handle the exceptions
+		} else {
+			uf::hooks.call( "window:Event", event.payload );
+			uf::hooks.call( event.name, event.payload );
 		}
-	*/
 		this->m_events.pop();
 	}
 	return true;
@ -463,7 +594,7 @@ void UF_API_CALL spec::dreamcast::Window::setMouseGrabbed(bool state) {
 void UF_API_CALL spec::dreamcast::Window::grabMouse(bool state) {
 }
 pod::Vector2ui UF_API_CALL spec::dreamcast::Window::getResolution() {
-	return { 640, 480 };
+	return ::resolution;
 }
 void UF_API_CALL spec::dreamcast::Window::switchToFullscreen( bool borderless ) {
 }
--- a/engine/src/utils/image/image.cpp
+++ b/engine/src/utils/image/image.cpp
@ -99,6 +99,7 @@ bool uf::Image::open( const uf::stl::string& filename, bool flip ) {
 	}
 #endif
 	if ( !uf::io::exists(filename) ) UF_EXCEPTION("IO error: file does not exist: " + filename);
+	
 	this->m_filename = filename;
 	this->m_pixels.clear();
 	int width = 0, height = 0, channelsDud = 0, bit_depth = 8, channels = 4;
--- a/ext/behaviors/player/behavior.cpp
+++ b/ext/behaviors/player/behavior.cpp
@ -255,10 +255,15 @@ void ext::PlayerBehavior::tick( uf::Object& self ) {
 		float friction = 0.8f;
 		float air = 1.0f;
 	} speed; {
+		float scale = 1;
+	#if UF_USE_OPENGL
+		scale = 10;
+	#endif
+
 		speed.rotate = metadata.movement.rotate * uf::physics::time::delta;
-		speed.move = metadata.movement.move;
-		speed.run = metadata.movement.run;
-		speed.walk = metadata.movement.walk;
+		speed.move = metadata.movement.move * scale;
+		speed.run = metadata.movement.run * scale;
+		speed.walk = metadata.movement.walk * scale;
 		speed.friction = metadata.movement.friction;
 		speed.air = metadata.movement.air;
 		
--- a/ext/behaviors/scene/behavior.cpp
+++ b/ext/behaviors/scene/behavior.cpp
@ -206,7 +206,6 @@ void ext::ExtSceneBehavior::tick( uf::Object& self ) {
 	auto& metadataJson = this->getComponent<uf::Serializer>();
 #if 1
 	uf::hooks.call("game:Frame.Start");
-	metadata.shader.invalidated = false;

 	/* Print World Tree */ {
 		TIMER(1, uf::inputs::kbm::states::U && ) {
--- a/ext/gui/behavior.cpp
+++ b/ext/gui/behavior.cpp
@ -751,6 +751,49 @@ void ext::GuiBehavior::tick( uf::Object& self ) {

 		bool isGlyph = this->hasComponent<ext::GuiBehavior::GlyphMetadata>();
 	#if UF_USE_OPENGL
+		auto model = uf::matrix::identity();
+		auto& shader = graphic.material.getShader("vertex");
+		pod::Uniform uniform;
+		if ( metadata.mode == 1 ) {
+			uniform.modelView = transform.model; 
+			uniform.projection = uf::matrix::identity();
+		} else if ( metadata.mode == 2 ) {
+			auto& scene = uf::scene::getCurrentScene();
+			auto& controller = scene.getController();
+			auto& camera = controller.getComponent<uf::Camera>();
+			uniform.modelView = camera.getView() * uf::transform::model( transform );
+			uniform.projection = camera.getProjection();
+			model = uniform.modelView;
+		} else if ( metadata.mode == 3 ) {
+			pod::Transform<> flatten = uf::transform::flatten( transform );
+			uniform.modelView = 
+				uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+				uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+				uf::quaternion::matrix( flatten.orientation ) *
+				flatten.model;
+			uniform.projection = camera.getProjection();
+			model = uniform.modelView;
+		} else {
+			pod::Transform<> flatten = uf::transform::flatten( transform );
+			model = 
+				uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+				uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+				uf::quaternion::matrix( flatten.orientation ) *
+				flatten.model;
+			
+			flatten.position.y = -flatten.position.y;
+			if ( isGlyph ) flatten.scale.y = -flatten.scale.y;
+
+			flatten.position.z = 1;
+			uniform.modelView = 
+				uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+				uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+				uf::quaternion::matrix( flatten.orientation ) *
+				flatten.model;
+			uniform.projection = uf::matrix::identity();
+		}
+		shader.updateUniform( "UBO", (const void*) &uniform, sizeof(uniform) );
+	/*
 		auto model = uf::matrix::identity();
 		auto uniformBuffer = graphic.getUniform();
 		pod::Uniform& uniform = *((pod::Uniform*) graphic.device->getBuffer(uniformBuffer.buffer));
@ -793,6 +836,7 @@ void ext::GuiBehavior::tick( uf::Object& self ) {
 			uniform.projection = uf::matrix::identity();
 		}
 		graphic.updateUniform( &uniform, sizeof(uniform) );
+	*/
 	#elif UF_USE_VULKAN
 		if ( !graphic.material.hasShader("vertex") ) return;