klepto2

With the latest release 0.9.5 (Build 567) it seems the lib files are damaged. Both debug and release.

The scene settings is removed and is replaced with a world-settings dialog under Edit -> World Settings.

This is a wierd one (at least it looks like a weird one) i have a simple scene with a terrain and a sphere. the sphere is set to a red color. In release: The result is always a white sphere but whith a correct looking terrain. In debug: sometimes the same result as in release, but sometimes the sphere gets its color (and can be changed at runtime) but then the terrain is pure black as long as the sphere is in view. #include "UltraEngine.h" #include "ComponentSystem.h" //#include "Steamworks/Steamworks.h" using namespace UltraEngine; int main(int argc, const char* argv[]) { #ifdef STEAM_API_H if (not Steamworks::Initialize()) { RuntimeError("Steamworks failed to initialize."); return 1; } #endif RegisterComponents(); auto cl = ParseCommandLine(argc, argv); //Load FreeImage plugin (optional) auto fiplugin = LoadPlugin("Plugins/FITextureLoader"); //Get the displays auto displays = GetDisplays(); //Create a window auto window = CreateWindow("Ultra Engine", 0, 0, 1280 * displays[0]->scale, 720 * displays[0]->scale, displays[0], WINDOW_CENTER | WINDOW_TITLEBAR); //Create a framebuffer auto framebuffer = CreateFramebuffer(window); //Create a world auto world = CreateWorld(); auto camera = CreateCamera(world); camera->SetClearColor(0.125); camera->SetFov(70); camera->Move(0, 2, -8); camera->AddComponent<CameraControls>(); //Create light auto light = CreateDirectionalLight(world); light->SetRotation(45, 35, 0); light->SetColor(2); world->RecordStats(true); auto main_instance = CreateTerrain(world, 512, 512); auto sphere = CreateSphere(world, 2.0, 32); sphere->SetColor(1.0, 0.0, 0.0); //Main loop while (window->Closed() == false and window->KeyDown(KEY_ESCAPE) == false) { if(window->KeyHit(KEY_F1)) sphere->SetColor(1.0, 0.0, 0.0); if (window->KeyHit(KEY_F2)) sphere->SetColor(0.0, 1.0, 0.0); world->Update(); world->Render(framebuffer); #ifdef STEAM_API_H Steamworks::Update(); #endif } #ifdef STEAM_API_H Steamworks::Shutdown(); #endif return 0; } Above is release (everytime) /debug(not everytime) ( color can't be changed with F1/F2) the same with debug build, sometimes the color works. (then the color can be changed with F1/F2)

If i remember correctly you need to modify gl_FragDepth in the fragment shader. If gl_FragDepth is not set in fragment, then the fixed function depth method will be used. Ref: https://registry.khronos.org/OpenGL-Refpages/gl4/html/gl_FragDepth.xhtml

I thought the same. Take a look here: and here: For the parameters i think the object which calls the hook should be included and an extra field for custom data. The most important thing for me is that it will be possible to get the internal opengl data. (not only the texture ids, but maybe also the buffers etc) . As i posted in the first linked thread i would prefer hooks on the way BEFORE / AFTER and also one for the world update and then for the camera.

Just my thought. The debug-build was mainly slower because the vulkan validation-layer kicks in and slows everything down. In Leadwerks there was also no difference between debug and release (for simple apps).

As you mentioned physics: a callback into the function where the force is applied. (possibly needed for adding additional effectors like buoyancy or other forces)

There are already some hooks, but to have more flexibility and abilities to add more functionality i would suggest to add things like: BEFORE_WORLD_UPDATE AFTER_WORLD_UPDATE BEFORE_CAMERA_RENDER (Used to update meshes based on the camera) AFTER_CAMERA_RENDER (Maybe to reset some states) Also some more for the render pipeline: RENDER_INIT (don't know if its the same in 0.9.5, but in < 0.9.5 the VKdevice etc was lazy initialized, so that you need to HOOK into the RENDER or TRANSFER Hook to get the data) Some more detailed Hooks into RENDER and/or TRANSFER (to add commands before the actual commands or after) thats it for now. If someone has more ideas, you can add these here.

While this might not be needed for most users, and a lot can change in the Render* classes can change. It is needed to have access to have access to this classes from its highlevel counterparts. (eg: Texture -> RenderTexture) Why: More flexibility Easier to add extensions which require low level access like GLHandles or VK handles depending on the renderer Integration of third party things will be easier. I noticed that there were some kind of methods to get this data. Like the commented Ultraengine::Render::GetRenderTexture function. something like this for all Render* items would be nice.

I will rebuild and refactor it as soon as the new Ultra Engine version is out, as I think there will be some kind of refactoring needed. I think most work will go into the actual Compute-Pipeline. For my current Environment (atmosphere and ocean) WIP I already have optimized a lot which might cause issues in this build, but I need time to polish it further and make it more future prove and stable.

You can try this: To have fully black ambient you can try to lower the iblintensity : https://www.ultraengine.com/learn/World_SetIblIntensity?lang=cpp

ok, this is a weird bug i have encountered while trying to optimze some texture generation. Sometimes a camera which is set to not render in realtime still renders in realtime. #include "UltraEngine.h" using namespace UltraEngine; int main(int argc, const char* argv[]) { //Get the displays auto displays = GetDisplays(); //Create a window auto window = CreateWindow("Ultra Engine", 0, 0, 1280, 720, displays[0], WINDOW_CENTER | WINDOW_TITLEBAR); //Create a world auto world = CreateWorld(); //Create a framebuffer auto framebuffer = CreateFramebuffer(window); //Create light auto light = CreateBoxLight(world); light->SetRange(-10, 10); light->SetRotation(15, 15, 0); light->SetColor(2); //Create camera auto camera = CreateCamera(world); camera->SetClearColor(0.125); camera->SetPosition(0, 0, -3); camera->SetFov(70); //Create scenery auto box = CreateBox(world); auto cone = CreateCone(world); cone->SetPosition(1.25, 0, 0); cone->SetColor(0, 0, 1); auto sphere = CreateSphere(world); sphere->SetPosition(-1.25, 0, 0); sphere->SetColor(1, 0, 0); //Create camera and texture buffer auto texbuffer = CreateTextureBuffer(256, 256); auto cam2 = CreateCamera(world); cam2->SetClearColor(1, 1, 1); cam2->SetRenderTarget(texbuffer); cam2->SetRealtime(false); //Create material auto mtl = CreateMaterial(); auto tex = texbuffer->GetColorAttachment(); mtl->SetTexture(tex); box->SetMaterial(mtl); cone->SetMaterial(mtl); sphere->SetMaterial(mtl); //Main loop while (window->Closed() == false and window->KeyDown(KEY_ESCAPE) == false) { //Orient the texturebuffer camera //Play around with these values and restart the app, sometimes the cam2 is rendered constantly even it is not set to realtime cam2->SetPosition(0, 0, 0); cam2->Turn(0, 1, 0); cam2->Move(0, 0, -2); cam2->SetRange(0.1, 1000.0); //Press the space key to redraw the texture buffer camera // if (window->KeyHit(KEY_SPACE)) cam2->Render(); world->Update(); world->Render(framebuffer); } return 0; } Run this snippet in release mode, mutliple times. You may need to change the cam2 values (position, turn, move or range) in order too get the bug. in most cases you get the desired one time render, but (it seems randomly) you get realtime rendering sometimes as well. In my bigger project my non realtime cameras are updated all the time and i am not calling the render function at all.

it might be that you need to invert the light_direction. The reason i use RGBA32 o RGBA16 is that you don't need to make any bitshifting etc. if you store a float in a RGBA32 texture the value will be the same as how you uploaded it. RGBA16 will just loose some precision, while RGBA will clamp the float to 0.0-1.0. As long as you store values between 0.0 and 1.0 the bytes to float should work the same. But is not needed with a RGBA32/16 texture. I use also texelFetch, otherwise sampling might corrupt the actual value. I simply access the data in the shader like this: vec4 data = texelFetch(texture2DSampler[configId],ivec2(0,i+1),0); cascades[i].spectrumHandle = int(data.x); cascades[i].normalHandle = int(data.y); cascades[i].size = data.z;

I haven't seen this problem in my applications, of course the update might be a bit off, but i don't see flickering. But maybe its because i use WritePixel with a Float32 pixmap directly instead of a using a buffer. I have something like this: class MaterialExtensionInfo : public Object { private: shared_ptr<Pixmap> _data; shared_ptr<Texture> _dataTexture; int current_ptr = 0; public: MaterialExtensionInfo(); void Sync(); shared_ptr<Texture> GetDataTexture(); void Add(int x, int y, Vec2 value); void Add(int x, int y, Vec3 value); void Add(int x, int y, Vec4 value); void Add(int x, int y, Mat3 value); void Add(int x, int y, Mat4 value); }; MaterialExtensionInfo::MaterialExtensionInfo() { _dataTexture = CreateTexture(TEXTURE_2D, 64, 32, TEXTURE_RGBA32, {}, 1, TEXTURE_DEFAULT, TEXTUREFILTER_NEAREST); _data = CreatePixmap(64, 32, TEXTURE_RGBA32); } void MaterialExtensionInfo::Sync() { _dataTexture->SetPixels(_data); } shared_ptr<Texture> MaterialExtensionInfo::GetDataTexture() { return _dataTexture; } void MaterialExtensionInfo::Add(int x, int y, Vec2 value) { _data->WritePixel(x, y, Vec4(value.x, value.y, 0.0, 0.0)); } void MaterialExtensionInfo::Add(int x, int y, Vec3 value) { _data->WritePixel(x, y, Vec4(value.x, value.y, value.z, 0.0)); } void MaterialExtensionInfo::Add(int x, int y, Vec4 value) { _data->WritePixel(x, y, value); } void MaterialExtensionInfo::Add(int x, int y, Mat3 value) { _data->WritePixel(x, y, Vec4(value.i.x, value.i.y, value.i.z,0.0)); _data->WritePixel(x + 1, y, Vec4(value.j.x, value.j.y, value.j.z, 0.0)); _data->WritePixel(x + 2, y, Vec4(value.k.x, value.k.y, value.k.z, 0.0)); } void MaterialExtensionInfo::Add(int x, int y, Mat4 value) { _data->WritePixel(x, y, value.i); _data->WritePixel(x + 1, y, value.j); _data->WritePixel(x + 2, y, value.k); _data->WritePixel(x + 3, y, value.t); } In your case, the sun direction is already available in the shader, you don't need to pass it down like that, In ultraEngine you can always access nearly anything at anytime in the shader. This itroduces a lot of possbilities: eg calculating combined atmospheric effects for multiple suns. to iterate over all Directional Lights you can do something like this in your shader: #include "../../Base/Lighting.glsl" ... in main() ... uint n; uint lightIndex; // Global lights (affects all cells) uint lightlistpos = GetGlobalLightsReadPosition(); uint countlights = ReadLightGridValue(lightlistpos); for (n = 0; n < countlights; ++n) { ++lightlistpos; lightIndex = ReadLightGridValue(lightlistpos); int ShadowSoftness = 2; const float minlight = 0.004f; vec3 lightDir, lightPosition; vec4 shadowCoord, color; bool transparent = false; mat4 lightmatrix; uint flags, lightflags; int shadowMapID, lighttype, shadowcachemapID; float attenuation = 1.0f; dFloat d; #ifdef DOUBLE_FLOAT dvec2 lightrange, coneangles, shadowrange; #else vec2 lightrange, coneangles, shadowrange; #endif int shadowkernel; ExtractEntityInfo(lightIndex, lightmatrix, color, flags); ExtractLightInfo(lightIndex, shadowMapID, shadowcachemapID, lightrange, coneangles, shadowrange, lightflags, shadowkernel); const int falloffmode = ((lightflags & ENTITYFLAGS_LIGHT_LINEARFALLOFF) != 0) ? LIGHTFALLOFF_LINEAR : LIGHTFALLOFF_INVERSESQUARE; if ((lightflags & ENTITYFLAGS_LIGHT_STRIP) != 0) lighttype = LIGHT_STRIP; // This needs to come first because the flag is a combination of others else if ((lightflags & ENTITYFLAGS_LIGHT_BOX) != 0) lighttype = LIGHT_BOX; else if ((lightflags & ENTITYFLAGS_LIGHT_DIRECTIONAL) != 0) lighttype = LIGHT_DIRECTIONAL; else if ((lightflags & ENTITYFLAGS_LIGHT_SPOT) != 0) lighttype = LIGHT_SPOT; else lighttype = LIGHT_POINT; if(lighttype == LIGHT_DIRECTIONAL) { #ifdef DOUBLE_FLOAT lightDir = vec3(normalize(lightmatrix[2].xyz)); #else lightDir = normalize(lightmatrix[2].xyz); #endif // Do calculations, break out if needed } }

Just to show a more extreme sample which i came up with (might be interesting for you as well @SpiderPig) It is a combination of multiple factors and shows multiple problems at once. Instantiating still has a memleak, not that high than then previously but still visible in this scenario Debug leads to rendertimes > 4000 ms while release is much lower but still too high in my opinion (even if you comment out the extra rendertargets and cameras) Having too many instances at the same position leads to an exception in the physicsthread Having too many instances leads to vulkan buffer size and index validation errors. #include "UltraEngine.h" #include "ComponentSystem.h" //#include "Steamworks/Steamworks.h" using namespace UltraEngine; SIZE_T PrintMemoryInfo() { auto myHandle = GetCurrentProcess(); //to fill in the process' memory usage details PROCESS_MEMORY_COUNTERS pmc; //return the usage (bytes), if I may if (GetProcessMemoryInfo(myHandle, &pmc, sizeof(pmc))) return(pmc.WorkingSetSize); else return 0; } int main(int argc, const char* argv[]) { #ifdef STEAM_API_H if (not Steamworks::Initialize()) { RuntimeError("Steamworks failed to initialize."); return 1; } #endif RegisterComponents(); auto cl = ParseCommandLine(argc, argv); //Load FreeImage plugin (optional) auto fiplugin = LoadPlugin("Plugins/FITextureLoader"); //Get the displays auto displays = GetDisplays(); //Create a window auto window = CreateWindow("Ultra Engine", 0, 0, 1280 * displays[0]->scale, 720 * displays[0]->scale, displays[0], WINDOW_CENTER | WINDOW_TITLEBAR); if (!AttachConsole(ATTACH_PARENT_PROCESS)) { if (AllocConsole()) { freopen("conin$", "r", stdin); freopen("conout$", "w", stdout); freopen("conout$", "w", stderr); } } else { auto consoleHandleOut = GetStdHandle(STD_OUTPUT_HANDLE); auto consoleHandleIn = GetStdHandle(STD_INPUT_HANDLE); auto consoleHandleErr = GetStdHandle(STD_ERROR_HANDLE); if (consoleHandleOut != INVALID_HANDLE_VALUE) { freopen("conout$", "w", stdout); setvbuf(stdout, NULL, _IONBF, 0); } if (consoleHandleIn != INVALID_HANDLE_VALUE) { freopen("conin$", "r", stdin); setvbuf(stdin, NULL, _IONBF, 0); } if (consoleHandleErr != INVALID_HANDLE_VALUE) { freopen("conout$", "w", stderr); setvbuf(stderr, NULL, _IONBF, 0); } } //Create a framebuffer auto framebuffer = CreateFramebuffer(window); //Create a world auto world = CreateWorld(); auto camera = CreateCamera(world); camera->SetClearColor(0.125); camera->SetFov(70); camera->Move(0, 2, -8); camera->AddComponent<CameraControls>(); //Create light auto light = CreateDirectionalLight(world); light->SetRotation(45, 35, 0); light->SetColor(2); auto render_target = CreateTextureBuffer(framebuffer->size.x, framebuffer->size.y); auto render_target_2 = CreateTextureBuffer(framebuffer->size.x, framebuffer->size.y); auto test_camera = CreateCamera(world); test_camera->SetRenderTarget(render_target); auto test_camera_2 = CreateCamera(world); test_camera_2->SetRenderTarget(render_target_2); camera->SetSweptCulling(true); world->RecordStats(true); int waterLevel = 20; shared_ptr<Entity> main_instance = CreateTerrain(world, 1024, 1024); auto sphere = CreateSphere(nullptr, 2.0, 32); vector<shared_ptr<Entity>> test_instances; bool set_position = true; //Set to false and it leads to a exception in the Physicsthread int step_size = 32; //Lower that and it will lead to invalid buffersize indices / size in vulkan //Main loop while (window->Closed() == false and window->KeyDown(KEY_ESCAPE) == false) { test_camera->SetMatrix(camera->GetMatrix()); test_camera->SetRange(camera->GetRange()); test_camera_2->SetRotation(camera->GetRotation() * Vec3(-1.0, 1.0, -1.0)); test_camera_2->SetPosition(camera->position.x, -camera->position.y + 2 * (waterLevel + 5.0), camera->position.z); test_camera_2->SetRange(camera->GetRange()); test_instances.clear(); for (int x = -512; x <= 512; x += step_size) for (int z = -512; z <= 512; z += step_size) { auto i = sphere->Instantiate(world); if(set_position) i->SetPosition(x, 1.0, z); i->SetColor(Vec4(1.0, 0.0, 0.0, 1.0)); test_instances.push_back(i); } world->Update(); world->Render(framebuffer); #ifdef STEAM_API_H Steamworks::Update(); #endif window->SetText("rt: " +String(world->renderstats.rendertime) + " MEM: " + String(PrintMemoryInfo() / 1024) + " kb"); } #ifdef STEAM_API_H Steamworks::Shutdown(); #endif return 0; } this is the interesting part for the multiple errors: bool set_position = true; //Set to false and it leads to a exception in the Physicsthread int step_size = 32; //Lower that and it will lead to invalid buffersize indices / size in vulkan I hope you can resolve this as it breaks the in majority very fast renderer.

As the title said. In the header source, there is already a outcommented void SetClipPlane(const int index, const Plane& p); function. While this might not be needed for many people, it is a nice and simple feature. I would need it for a deifferent approach for the water renderer to support realtime reflections without ssr (while ssr is nice, it has some downsides and needs a lot of tweking to look right in larger environments.) and proper refraction without the need to modify the integrated refraction shader.

With the provided code I simulate the behaviour of a much more complex problem to show the problem in an extreme way. In the production ready code i get a slower mem increase, but it slows down the program and leads to a out of memory exception. Things to notice in the program: The memusage increases fast The displayed instance count is much higher than it should I let the program instantiate 100 planes, so the actual count should be 101 (with the orignal plane) In the loop the instances are cleared and reinstantiated. #include "UltraEngine.h" #include "ComponentSystem.h" //#include "Steamworks/Steamworks.h" using namespace UltraEngine; SIZE_T PrintMemoryInfo() { auto myHandle = GetCurrentProcess(); //to fill in the process' memory usage details PROCESS_MEMORY_COUNTERS pmc; //return the usage (bytes), if I may if (GetProcessMemoryInfo(myHandle, &pmc, sizeof(pmc))) return(pmc.WorkingSetSize); else return 0; } int main(int argc, const char* argv[]) { #ifdef STEAM_API_H if (not Steamworks::Initialize()) { RuntimeError("Steamworks failed to initialize."); return 1; } #endif RegisterComponents(); auto cl = ParseCommandLine(argc, argv); //Load FreeImage plugin (optional) auto fiplugin = LoadPlugin("Plugins/FITextureLoader"); //Get the displays auto displays = GetDisplays(); //Create a window auto window = CreateWindow("Ultra Engine", 0, 0, 1280 * displays[0]->scale, 720 * displays[0]->scale, displays[0], WINDOW_CENTER | WINDOW_TITLEBAR); if (!AttachConsole(ATTACH_PARENT_PROCESS)) { if (AllocConsole()) { freopen("conin$", "r", stdin); freopen("conout$", "w", stdout); freopen("conout$", "w", stderr); } } else { auto consoleHandleOut = GetStdHandle(STD_OUTPUT_HANDLE); auto consoleHandleIn = GetStdHandle(STD_INPUT_HANDLE); auto consoleHandleErr = GetStdHandle(STD_ERROR_HANDLE); if (consoleHandleOut != INVALID_HANDLE_VALUE) { freopen("conout$", "w", stdout); setvbuf(stdout, NULL, _IONBF, 0); } if (consoleHandleIn != INVALID_HANDLE_VALUE) { freopen("conin$", "r", stdin); setvbuf(stdin, NULL, _IONBF, 0); } if (consoleHandleErr != INVALID_HANDLE_VALUE) { freopen("conout$", "w", stderr); setvbuf(stderr, NULL, _IONBF, 0); } } //Create a framebuffer auto framebuffer = CreateFramebuffer(window); //Create a world auto world = CreateWorld(); auto camera = CreateCamera(world); camera->SetClearColor(0.125); camera->SetFov(70); camera->Move(0, 2, -8); //Create light auto light = CreateDirectionalLight(world); light->SetRotation(45, 35, 0); light->SetColor(2); world->RecordStats(true); shared_ptr<Entity> main_instance = CreatePlane(world, 10.0,10.0, 256,256); vector<shared_ptr<Entity>> instances; //Main loop while (window->Closed() == false and window->KeyDown(KEY_ESCAPE) == false) { instances.clear(); for (int i = 0; i < 100; i++) { instances.push_back(main_instance->Instantiate(world)); } world->Update(); world->Render(framebuffer); #ifdef STEAM_API_H Steamworks::Update(); #endif window->SetText("Instances: " +String(world->renderstats.instances) + " MEM: " + String(PrintMemoryInfo() / 1024) + " kb"); } #ifdef STEAM_API_H Steamworks::Shutdown(); #endif return 0; }

If I remember correctly, the instance count measures the instances which get drawn in the current frame. In your case the instance increase might be 2 because 1 instance is rendered for the rendering and the other one is rendered for the shadowmap of the directional light. So in the stats you need to consider all render targets.

Currently, there is just a small context menu if you right-click on an assigned component which allows the deletion. I would suggest adding small tool buttons to the component header section with: Edit / component and JSON file Delete I think that would make the interface more clear.

2 Things: I believe the WidgetBlock Family is not the right one, better use the unlit family for this. your sprite with the material has a size of 0,0 so it will never be displayed no matter what you try to do auto pixmap = CreatePixmap(iVec2(100, 100)); pixmap->Fill(Vec4(0.5f, 0.5f, 1, 1)); auto tex = CreateTexture(TEXTURE_2D, 100, 100, TEXTURE_RGBA, { pixmap }, 1, TEXTURE_CLAMP_UV); auto mtl = CreateMaterial(); mtl->SetTexture(tex); mtl->SetShadow(false); mtl->SetTransparent(true); mtl->SetShaderFamily(LoadShaderFamily("Shaders/Unlit.fam")); //Create pixmap sprite auto sprite = CreateSprite(world, 40, 40); sprite->SetPosition(20, 20); //sprite->SetViewMode(SPRITEVIEW_BILLBOARD); sprite->SetMaterial(mtl); sprite->SetText("Test"); sprite->SetRenderLayers(2); with these changes the colored sprite is visible in the lower left corner.

You need to copy the material, shader and maybe the plugin folder from an existing project. The sample is based on a very old beta. Also you need to remove the LoadShaderFamily part in the section where the materials are loaded. (or rename pbr.json to pbr.fam) I have debugged the app with nvidia nsight and the textures are generated correctly.

The swept culling works nicely, but i noticed that it is not working with terrains. As soon as a terrain is visible i get a "vector subscript out of range" exception: > $PROJECTNAME_d.exe!std::vector<class UltraEngine::Vec3,class std::allocator<class UltraEngine::Vec3> >::operator[](unsigned __int64) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingTerrain::Draw(class std::shared_ptr<class UltraEngine::Culling::CameraVisibilityList> &,class std::map<class std::shared_ptr<class UltraEngine::Render::RenderMesh>,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch>,struct std::less<class std::shared_ptr<class UltraEngine::Render::RenderMesh> >,class std::allocator<struct std::pair<class std::shared_ptr<class UltraEngine::Render::RenderMesh> const ,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch> > > > &,class std::shared_ptr<class UltraEngine::Culling::CullingWorld>,class std::shared_ptr<class UltraEngine::Culling::CullingBuffer>,class std::shared_ptr<class UltraEngine::Culling::CullingCamera>,class std::shared_ptr<class UltraEngine::Render::RenderCamera>,bool,int) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingOctreeNode::DrawEntities(class std::shared_ptr<class UltraEngine::Culling::CameraVisibilityList> &,class std::map<class std::shared_ptr<class UltraEngine::Render::RenderMesh>,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch>,struct std::less<class std::shared_ptr<class UltraEngine::Render::RenderMesh> >,class std::allocator<struct std::pair<class std::shared_ptr<class UltraEngine::Render::RenderMesh> const ,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch> > > > &,class std::shared_ptr<class UltraEngine::Culling::CullingWorld>,class std::shared_ptr<class UltraEngine::Culling::CullingBuffer>,class std::shared_ptr<class UltraEngine::Culling::CullingCamera>,class std::shared_ptr<class UltraEngine::Render::RenderCamera>,class UltraEngine::Vec3 const &,int,int,bool,int) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingOctreeNode::Draw(class std::shared_ptr<class UltraEngine::Culling::CameraVisibilityList> &,class std::map<class std::shared_ptr<class UltraEngine::Render::RenderMesh>,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch>,struct std::less<class std::shared_ptr<class UltraEngine::Render::RenderMesh> >,class std::allocator<struct std::pair<class std::shared_ptr<class UltraEngine::Render::RenderMesh> const ,class std::shared_ptr<class UltraEngine::Culling::SurfaceBatch> > > > &,class std::shared_ptr<class UltraEngine::Culling::CullingWorld>,class std::shared_ptr<class UltraEngine::Culling::CullingBuffer>,class std::shared_ptr<class UltraEngine::Culling::CullingCamera>,class std::shared_ptr<class UltraEngine::Render::RenderCamera>,class UltraEngine::Vec3 const &,int,bool,bool,int) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingCamera::BuildVisibilityLists(class std::shared_ptr<class UltraEngine::Culling::CullingWorld>,class std::shared_ptr<class UltraEngine::Culling::CullingBuffer>,class std::shared_ptr<class UltraEngine::Culling::VisibilityList>) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingWorld::BuildVisibilityLists(class std::shared_ptr<class UltraEngine::Culling::CullingBuffer>,class std::shared_ptr<class UltraEngine::Culling::CullingWorld>) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Culling::CullingThreadManager::Update(bool) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Core::ThreadManager::EntryPoint(class std::shared_ptr<class UltraEngine::Object>) Unbekannt $PROJECTNAME_d.exe!UltraEngine::Thread::thread_function(void *) Unbekannt ucrtbased.dll!00007ff985793010() Unbekannt kernel32.dll!00007ffa6a8e7344() Unbekannt ntdll.dll!00007ffa6c1026b1() Unbekannt