Chewico/DeerEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Finished refactoring angelscript internal api

Browse Source
This commit is contained in:
Chewico 2026-01-14 17:56:41 +01:00
parent 47871fa1dc
commit 54f8156b6b
18 changed files with 2005 additions and 1890 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Deer/src/Deer/Core/Log.cpp
View File

@ -8,7 +8,7 @@ namespace Deer {
void Log::init() {
// spdlog::set_pattern("%^[%T] %n: %v%$");
spdlog::set_pattern("%n: %v%$");
spdlog::set_pattern("%v%$");
coreLogger = spdlog::stdout_color_mt("Core");
clientLogger = spdlog::stdout_color_mt("Client");

2591
Deer/vendor/angelScript/include/angelscript.h vendored
View File

File diff suppressed because it is too large Load Diff

802
Deer/vendor/angelScript/src/scriptbuilder.cpp vendored
View File

File diff suppressed because it is too large Load Diff

24
DeerStudio/headers/DeerStudio/AngelScriptEngine.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "DeerRender/Tools/Memory.h"
#include "DeerRender/Tools/Path.h"
#include <string>
#include <unordered_map>
@ -9,8 +10,10 @@ class asIScriptModule;
class asIScriptContext;
class asIScriptObject;
class asIScriptFunction;
class asIScriptFunction;
class asITypeInfo;
class CScriptBuilder;
class asIScriptGeneric;
namespace Deer {
namespace AngelScriptEngine {
@ -20,6 +23,12 @@ namespace Deer {
void render();
void deinitialize();
struct ServiceExposedFunctionData {
asIScriptFunction* exposedFunction = nullptr;
asIScriptObject* exposedObject = nullptr;
std::string exposedFunctionName;
};
struct Service {
public:
Service(asITypeInfo*);
@ -34,14 +43,25 @@ namespace Deer {
void update();
void shutdown();
void updateTypes(asIScriptModule*);
void registerApiExpose();
protected:
asITypeInfo* type = nullptr;
asIScriptObject* object = nullptr;
asIScriptFunction* updateFunction = nullptr;
asIScriptFunction* initFunction = nullptr;
asIScriptFunction* shutdownFunction = nullptr;
std::vector<Scope<ServiceExposedFunctionData>> exposedFunctions;
std::string typeName;
private:
void registerExposedFunction(asIScriptFunction*);
};
void service_exposed_generic_call(asIScriptGeneric*);
struct Panel : public Service {
public:
Panel(asITypeInfo*);
@ -52,6 +72,7 @@ namespace Deer {
Panel& operator=(Panel&&) = default;
void render();
void updateTypes(asIScriptModule*);
private:
asIScriptFunction* renderFunction;
@ -93,7 +114,8 @@ namespace Deer {
void render();
void shutdown();
void extractTypes();
void extract(asIScriptModule*);
void updateTypes();
inline void invalidate() { state = ModuleState::ExecutionError; }

24
DeerStudio/src/DeerStudio/AngelScriptEngine/Module.cpp
View File

@ -7,27 +7,45 @@ namespace Deer {
namespace AngelScriptEngine {
Module::Module(const ModuleDescription& _mi) : moduleInfo(_mi) {}
void Module::extractTypes() {
void Module::extract(asIScriptModule* _module) {
if (state != ModuleState::Built)
return;
angelscriptModule = AngelScriptEngine::scriptEngine->GetModule(moduleInfo.moduleName.c_str());
uint32_t typeCount = angelscriptModule->GetObjectTypeCount();
angelscriptModule = _module;
scriptEngine->SetDefaultNamespace(moduleInfo.moduleName.c_str());
uint32_t typeCount = angelscriptModule->GetObjectTypeCount();
for (uint32_t typeId = 0; typeId < typeCount; typeId++) {
asITypeInfo* typeInfo = angelscriptModule->GetObjectTypeByIndex(typeId);
if (ImplementsInterface(typeInfo, serviceBaseType)) {
services.push_back({typeInfo});
services.back().registerApiExpose();
} else if (ImplementsInterface(typeInfo, panelBaseType)) {
panels.push_back({typeInfo});
panels.back().registerApiExpose();
}
}
scriptEngine->SetDefaultNamespace("");
}
void Module::updateTypes() {
if (state != ModuleState::Built)
return;
angelscriptModule = AngelScriptEngine::scriptEngine->GetModule(moduleInfo.moduleName.c_str());
for (Service& service : services)
service.updateTypes(angelscriptModule);
for (Panel& panel : panels)
panel.updateTypes(angelscriptModule);
}
void Module::init() {
if (state != ModuleState::Built)
return;
angelscriptModule->BindAllImportedFunctions();
for (Service& service : services)

18
DeerStudio/src/DeerStudio/AngelScriptEngine/ModuleLoading.cpp
View File

@ -44,10 +44,12 @@ namespace Deer {
}
bool AngelScriptEngine::loadModule(Module& module) {
if (module.state != ModuleState::NotBuilt)
return false;
int err;
module.state = ModuleState::Building;
DEER_CORE_TRACE("Loading module {}", module.moduleInfo.moduleName);
for (const std::string& dependency : module.moduleInfo.module_requires) {
if (!module_id.contains(dependency)) {
DEER_CORE_ERROR("Failed to find dependency {} for module {}",
@ -79,6 +81,7 @@ namespace Deer {
}
}
}
DEER_CORE_TRACE("Loading module {}", module.moduleInfo.moduleName);
scriptBuilder.StartNewModule(scriptEngine, module.moduleInfo.moduleName.c_str());
if (err < 0) {
@ -109,6 +112,8 @@ namespace Deer {
}
module.state = ModuleState::Built;
module.extract(as_module);
return true;
}
@ -151,12 +156,16 @@ namespace Deer {
desc.modulePath = path.string();
if (module_id.contains(desc.moduleName)) {
DEER_CORE_ERROR("Module name duplicated {}", path.string().c_str());
return;
}
module_id[desc.moduleName] = modules.size();
modules.push_back({desc});
}
void AngelScriptEngine::loadModules() {
generateAngelscriptPredefined();
const Path path = Path("Editor") / Path("Modules");
if (!fs::exists(path) || !fs::is_directory(path)) {
@ -173,14 +182,15 @@ namespace Deer {
}
for (Module& module : modules) {
saveAngelscriptPredefined(module.moduleInfo.modulePath);
if (module.state == ModuleState::NotBuilt) {
loadModule(module);
generateAngelscriptPredefined();
}
saveAngelscriptPredefined(module.moduleInfo.modulePath);
}
for (Module& module : modules) {
module.extractTypes();
module.updateTypes();
}
}
} // namespace Deer

7
DeerStudio/src/DeerStudio/AngelScriptEngine/Panel.cpp
View File

@ -12,6 +12,13 @@ namespace Deer {
menuBarFunction = type->GetMethodByDecl("void menuBar()");
}
void Panel::updateTypes(asIScriptModule* typeInfo) {
Service::updateTypes(typeInfo);
renderFunction = type->GetMethodByDecl("void render()");
menuBarFunction = type->GetMethodByDecl("void menuBar()");
}
void Panel::render() {
// IMPLEMENT REMOVE PADDING
if (menuBarFunction) {

58
DeerStudio/src/DeerStudio/AngelScriptEngine/PredefinedAngelScript.cpp
View File

@ -4,6 +4,7 @@
// https://github.com/sashi0034/angel-lsp/blob/main/examples/OpenSiv3D/make_predefined.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "DeerRender/Log.h"
#include "DeerStudio/AngelScriptEngine.h"
#include "angelscript.h"
@ -71,6 +72,43 @@ void printEnumList(const asIScriptEngine& engine) {
}
}
void writeParameters(asIScriptFunction* function) {
for (int n = 0; n < function->GetParamCount(); n++) {
int typeId;
asDWORD flags;
const char* name;
const char* defaultArgument;
function->GetParam(n, &typeId, &flags, &name, &defaultArgument);
if (typeId == -1) {
stream << "?";
} else {
asITypeInfo* ti = function->GetEngine()->GetTypeInfoById(typeId);
if (ti && (ti->GetFlags() & asOBJ_FUNCDEF)) {
stream << ti->GetName();
} else {
const char* typeName = function->GetEngine()->GetTypeDeclaration(typeId, false);
stream << typeName;
}
}
if (flags & asTM_INREF)
stream << " &in ";
else if (flags & asTM_OUTREF)
stream << " &out ";
else if (flags & asTM_INOUTREF)
stream << " &inout ";
if (name) {
stream << " " << name;
}
if (n != function->GetParamCount() - 1)
stream << ", ";
}
}
void printClassTypeList(const asIScriptEngine& engine) {
for (int i = 0; i < engine.GetObjectTypeCount(); ++i) {
asITypeInfo* t = engine.GetObjectTypeByIndex(i);
@ -109,7 +147,9 @@ void printClassTypeList(const asIScriptEngine& engine) {
for (int j = 0; j < t->GetFactoryCount(); ++j) {
asIScriptFunction* f = t->GetFactoryByIndex(j);
stream << "\t" << f->GetDeclaration(false, false, true) << ";\n";
stream << "\t" << t->GetName() << "(";
writeParameters(f);
stream << ");\n";
}
for (int j = 0; j < t->GetBehaviourCount(); ++j) {
@ -125,7 +165,21 @@ void printClassTypeList(const asIScriptEngine& engine) {
for (int j = 0; j < t->GetMethodCount(); ++j) {
const auto m = t->GetMethodByIndex(j);
stream << "\t" << m->GetDeclaration(false, false, true);
stream << "\t";
int methodReturnId = m->GetReturnTypeId();
if (methodReturnId == -1) {
stream << "? ";
} else {
stream << t->GetEngine()->GetTypeDeclaration(methodReturnId) << " ";
}
stream << m->GetName() << "(";
writeParameters(m);
stream << ")";
// stream << "\t" << m->GetDeclaration(false, false, true);
if (m->IsProperty())
stream << " property";

218
DeerStudio/src/DeerStudio/AngelScriptEngine/Service.cpp
View File

@ -1,8 +1,11 @@
#include "DeerStudio/AngelScriptEngine.h"
#include "DeerStudio/AngelScriptEngine/ErrorHandle.h"
#include "angelscript.h"
#include "scriptbuilder.h"
#include <cstring>
#include <string>
#include <vector>
namespace Deer {
namespace AngelScriptEngine {
@ -27,6 +30,11 @@ namespace Deer {
object->AddRef();
AS_CHECK(scriptContext->Unprepare());
for (Scope<ServiceExposedFunctionData>& exposedFunction : exposedFunctions) {
exposedFunction->exposedFunction = type->GetMethodByName(exposedFunction->exposedFunctionName.c_str());
exposedFunction->exposedObject = object;
}
if (!initFunction)
return;
@ -37,6 +45,214 @@ namespace Deer {
AS_CHECK(scriptContext->Unprepare());
}
void Service::registerApiExpose() {
int functionCount = type->GetMethodCount();
for (int i = 0; i < functionCount; i++) {
asIScriptFunction* function = type->GetMethodByIndex(i);
bool containsExposeMetadata = false;
std::vector<std::string> metadata = scriptBuilder.GetMetadataForTypeMethod(type->GetTypeId(), function);
for (std::string& meta : metadata) {
if (meta == "Expose") {
containsExposeMetadata = true;
break;
}
}
if (!containsExposeMetadata)
continue;
registerExposedFunction(function);
}
}
void Service::registerExposedFunction(asIScriptFunction* function) {
asITypeInfo* returnType = scriptEngine->GetTypeInfoById(function->GetReturnTypeId());
if (returnType && returnType->GetModule()) {
DEER_CORE_ERROR("Error registering function {}, you can not register engine non specific type for return type", function->GetDeclaration());
return;
}
std::string declaration;
declaration = scriptEngine->GetTypeDeclaration(function->GetReturnTypeId(), false);
declaration += " ";
declaration += function->GetName();
declaration += "(";
int paramCount = function->GetParamCount();
for (int n = 0; n < paramCount; n++) {
int typeId;
asDWORD flags;
const char* name;
const char* defaultArgument;
function->GetParam(n, &typeId, &flags, &name, &defaultArgument);
asITypeInfo* paramType = scriptEngine->GetTypeInfoById(typeId);
if (paramType && paramType->GetModule()) {
DEER_CORE_ERROR("Error registering function {}, you can not register engine non specific type in parameter", function->GetDeclaration());
return;
}
const char* typeName = scriptEngine->GetTypeDeclaration(typeId, false);
declaration += typeName;
if (flags & asTM_INREF)
declaration += " in ";
else if (flags & asTM_OUTREF)
declaration += " out ";
else if (flags & asTM_INOUTREF)
declaration += " inout ";
if (name) {
declaration += " ";
declaration += name;
}
if (defaultArgument) {
declaration += "= ";
declaration += defaultArgument;
}
if (n != paramCount - 1)
declaration += ", ";
}
declaration += ")";
exposedFunctions.push_back(MakeScope<ServiceExposedFunctionData>());
ServiceExposedFunctionData* exposedFunctionData = exposedFunctions.back().get();
exposedFunctionData->exposedFunction = function;
exposedFunctionData->exposedFunctionName = function->GetName();
exposedFunctionData->exposedObject = object;
DEER_CORE_TRACE("Registering {}", declaration.c_str());
scriptEngine->RegisterGlobalFunction(declaration.c_str(), asFUNCTION(service_exposed_generic_call), asCALL_GENERIC, exposedFunctionData);
}
void service_exposed_generic_call(asIScriptGeneric* genericFun) {
AS_CHECK(scriptContext->PushState());
ServiceExposedFunctionData* data = (ServiceExposedFunctionData*)genericFun->GetAuxiliary();
AS_CHECK(scriptContext->Prepare(data->exposedFunction));
AS_CHECK(scriptContext->SetObject(data->exposedObject));
int argCount = genericFun->GetArgCount();
for (int i = 0; i < argCount; ++i) {
int typeId = genericFun->GetArgTypeId(i);
if (typeId & asTYPEID_OBJHANDLE) {
void* obj = genericFun->GetAddressOfArg(i);
AS_CHECK(scriptContext->SetArgAddress(i, obj));
} else if (typeId & asTYPEID_MASK_OBJECT) {
void* obj = genericFun->GetArgObject(i);
AS_CHECK(scriptContext->SetArgObject(i, obj));
} else {
switch (typeId) {
case asTYPEID_BOOL:
case asTYPEID_INT8:
case asTYPEID_UINT8:
AS_CHECK(scriptContext->SetArgByte(i, genericFun->GetArgByte(i)));
break;
case asTYPEID_INT16:
case asTYPEID_UINT16:
AS_CHECK(scriptContext->SetArgWord(i, genericFun->GetArgWord(i)));
break;
case asTYPEID_INT32:
case asTYPEID_UINT32:
AS_CHECK(scriptContext->SetArgDWord(i, genericFun->GetArgDWord(i)));
break;
case asTYPEID_INT64:
case asTYPEID_UINT64:
AS_CHECK(scriptContext->SetArgQWord(i, genericFun->GetArgQWord(i)));
break;
case asTYPEID_FLOAT:
AS_CHECK(scriptContext->SetArgFloat(i, genericFun->GetArgFloat(i)));
break;
case asTYPEID_DOUBLE:
AS_CHECK(scriptContext->SetArgDouble(i, genericFun->GetArgDouble(i)));
break;
default:
AS_CHECK(scriptContext->SetArgObject(i, genericFun->GetArgObject(i)));
break;
}
}
}
AS_CHECK(scriptContext->Execute());
int retTypeId = genericFun->GetReturnTypeId();
if (retTypeId == asTYPEID_VOID) {
} else if (retTypeId & asTYPEID_OBJHANDLE) {
void* obj = scriptContext->GetReturnObject();
genericFun->SetReturnObject(obj);
} else if (retTypeId & asTYPEID_MASK_OBJECT) {
void* obj = scriptContext->GetReturnObject();
genericFun->SetReturnObject(obj);
} else {
switch (retTypeId) {
case asTYPEID_BOOL:
case asTYPEID_INT8:
case asTYPEID_UINT8:
genericFun->SetReturnByte(scriptContext->GetReturnByte());
break;
case asTYPEID_INT16:
case asTYPEID_UINT16:
genericFun->SetReturnWord(scriptContext->GetReturnWord());
break;
case asTYPEID_INT32:
case asTYPEID_UINT32:
genericFun->SetReturnDWord(scriptContext->GetReturnDWord());
break;
case asTYPEID_INT64:
case asTYPEID_UINT64:
genericFun->SetReturnQWord(scriptContext->GetReturnQWord());
break;
case asTYPEID_FLOAT:
genericFun->SetReturnFloat(scriptContext->GetReturnFloat());
break;
case asTYPEID_DOUBLE:
genericFun->SetReturnDouble(scriptContext->GetReturnDouble());
break;
default:
// value types returned by value
genericFun->SetReturnObject(scriptContext->GetReturnObject());
break;
}
}
AS_CHECK(scriptContext->PopState());
}
void Service::updateTypes(asIScriptModule* module) {
type = module->GetTypeInfoByName(typeName.c_str());
updateFunction = type->GetMethodByDecl("void update()");
initFunction = type->GetMethodByDecl("void init()");
shutdownFunction = type->GetMethodByDecl("void shutdown()");
for (Scope<ServiceExposedFunctionData>& exposedFunction : exposedFunctions) {
exposedFunction->exposedFunction = type->GetMethodByName(exposedFunction->exposedFunctionName.c_str());
exposedFunction->exposedObject = object;
}
}
void Service::update() {
if (!updateFunction)
return;
@ -70,6 +286,8 @@ namespace Deer {
Service::Service(asITypeInfo* _type)
: type(_type) {
typeName = _type->GetName();
updateFunction = type->GetMethodByDecl("void update()");
initFunction = type->GetMethodByDecl("void init()");
shutdownFunction = type->GetMethodByDecl("void shutdown()");

25
Editor/Modules/ActiveEntity/ActiveEntity.as
View File

@ -1,8 +1,21 @@
Entity entity = Resource::getMainEnvironment().getRootEntity();
Entity getActiveEntity() {
return entity;
}
class ActiveEntity : Service {
Entity entity;
void setActiveEntity(Entity ent) {
entity = ent;
[Expose]
Entity getActiveEntity() {
return entity;
}
[Expose]
void setActiveEntity(Entity ent) {
entity = ent;
}
void init() {
entity = Resource::getMainEnvironment().getRootEntity();
}
[Expose]
void wtf() {
Engine::print("Exposed");
}
}

4
Editor/Modules/EntityManipulation/MeshProperties.as
View File

@ -57,4 +57,8 @@ class MeshComponentRender {
entity.removeMeshComponent();
}
}
void init() {
ActiveEntity::wtf();
}
}

7
Editor/Modules/EntityManipulation/PropertiesPannel.as
View File

@ -1,13 +1,10 @@
import Entity getActiveEntity() from "ActiveEntity";
import void setActiveEntity(Entity) from "ActiveEntity";
class PropertiesPanel : Panel {
float slider = 0;
vec3 slid;
vec3 slid2;
void render() {
Entity entity = getActiveEntity();
Entity entity = ActiveEntity::getActiveEntity();
// NAME
// Id:0 [+ add component]
@ -60,7 +57,7 @@ class PropertiesPanel : Panel {
}
void renameEntityMenu() {
Entity entity = getActiveEntity();
Entity entity = ActiveEntity::getActiveEntity();
if (!entity.isRoot) {
if (UI::menuItem("Rename")) {

32
Editor/Modules/Previewer/MeshPreview.as
View File

@ -1,19 +1,10 @@
RenderService@ mainRenderService;
FrameBuffer renderMeshPreview(GPUMesh mesh) {
return mainRenderService.renderMeshPreview(mesh);
}
FrameBuffer renderMeshPreview(GPUMesh mesh, float fase) {
return mainRenderService.renderMeshPreview(mesh, fase);
}
void setSceneCamera(SceneCamera sc) {
}
class RenderService : Service {
Environment env;
SceneCamera sceneCamera;
MeshComponent meshC;
Entity child;
void init() {
@mainRenderService = this;
env = Resource::createLoadEnvironment("PreviewerEnv");
child = env.getRootEntity().createChild("Render");
@ -27,30 +18,27 @@ class RenderService : Service {
}
[Expose]
FrameBuffer renderMeshPreview(GPUMesh mesh) {
FrameBuffer buffer = Resource::createLoadRGBA8FrameBuffer(mesh.path, 128, 128, 4);
buffer.clearRGBA(0, 0, 0, 0);
meshC.meshResource = mesh;
child.transform.rotation = vec3(0, 0, 0);
mainRenderService.env.render(buffer, mainRenderService.sceneCamera);
env.render(buffer, sceneCamera);
return buffer;
}
FrameBuffer renderMeshPreview(GPUMesh mesh, float fase) {
[Expose]
FrameBuffer renderMeshPreview_fase(GPUMesh mesh, float fase) {
FrameBuffer buffer = Resource::createLoadRGBA8FrameBuffer(mesh.path, 128, 128, 4);
buffer.clearRGBA(0, 0, 0, 0);
meshC.meshResource = mesh;
child.transform.rotation = vec3(0, (1-(1/(1+fase * fase)))*45, 0);
mainRenderService.env.render(buffer, mainRenderService.sceneCamera);
env.render(buffer, sceneCamera);
return buffer;
}
Environment env;
SceneCamera sceneCamera;
MeshComponent meshC;
Entity child;
}

4
Editor/Modules/ResourceExplorer/ResourceExplorer.as
View File

@ -1,5 +1,3 @@
import FrameBuffer renderMeshPreview(GPUMesh mesh) from "Previewer";
import FrameBuffer renderMeshPreview(GPUMesh mesh, float fase) from "Previewer";
string selectedResource = "";
class ResourceExplorer : Panel {
@ -62,7 +60,7 @@ class ResourceExplorer : Panel {
//}
GPUMesh mesh = Resource::loadGPUMesh(filename);
frameBuffer = renderMeshPreview(mesh, fase);
frameBuffer = Previewer::renderMeshPreview_fase(mesh, fase);
meshFrameBuffer[filename] = frameBuffer;
alreadyRendered = true;

8
Editor/Modules/Test/ActiveEntity.as Normal file
View File

@ -0,0 +1,8 @@
class Test : Service {
void init() {
Engine::print("Initing");
Entity entity = ActiveEntity::getActiveEntity();
Engine::print(entity.name);
Engine::print("Ending");
}
}

5
Editor/Modules/Test/module.json Normal file
View File

@ -0,0 +1,5 @@
{
"patch": 1,
"name": "Test",
"requires": ["ActiveEntity"]
}

7
Editor/Modules/TreeExplorer/Tree.as
View File

@ -1,6 +1,3 @@
import Entity getActiveEntity() from "ActiveEntity";
import void setActiveEntity(Entity) from "ActiveEntity";
class EntityTreeRender {
EntityTreeRender(Entity _entity) {
entity = _entity;
@ -8,7 +5,7 @@ class EntityTreeRender {
Entity entity;
bool isActiveEntity() {
return entity == getActiveEntity();
return entity == ActiveEntity::getActiveEntity();
}
void renderEntity() {
@ -47,7 +44,7 @@ class EntityTreeRender {
UI::contextItemPopup("POP_ENTITY_" + entity.id, Callback(this.renderContextMenu));
if (UI::isItemClicked(0)) {
setActiveEntity(entity);
ActiveEntity::setActiveEntity(entity);
}
}

3
Editor/Modules/Viewport/Viewport.as
View File

@ -1,5 +1,3 @@
import void setSceneCamera (SceneCamera sc) from "Previewer";
class ViewportPanel : Panel {
FrameBuffer frameBuffer;
SceneCamera sceneCamera;
@ -68,7 +66,6 @@ class ViewportPanel : Panel {
vertically--;
sceneCamera.transform.position = sceneCamera.transform.position + vec3(0, vertically * vel, 0);
setSceneCamera(sceneCamera);
}
void init() {