I need help Jolt crashes on me #1145

NeonXStudios · 2024-06-22T05:16:30Z

NeonXStudios
Jun 22, 2024

Hi I need help. if it is not too much trouble, I am trying to implement jolt in my engine but it crashes after a few executions I am using the helloworld.cpp example and it requires me 3 defines that are for debugging

/CPP/

#include "gamescene.h"

JPH_SUPPRESS_WARNINGS
using namespace JPH;
using namespace JPH::literals;

void gamescene::embraceTheDarkness()
{
ImVec4 *colors = ImGui::GetStyle().Colors;
colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGuiCol_WindowBg] = ImVec4(0.10f, 0.10f, 0.10f, 1.00f);
colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_PopupBg] = ImVec4(0.19f, 0.19f, 0.19f, 0.92f);
colors[ImGuiCol_Border] = ImVec4(0.19f, 0.19f, 0.19f, 0.29f);
colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.24f);
colors[ImGuiCol_FrameBg] = ImVec4(0.05f, 0.05f, 0.05f, 0.54f);
colors[ImGuiCol_FrameBgHovered] = ImVec4(0.19f, 0.19f, 0.19f, 0.54f);
colors[ImGuiCol_FrameBgActive] = ImVec4(0.20f, 0.22f, 0.23f, 1.00f);
colors[ImGuiCol_TitleBg] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.06f, 0.06f, 0.06f, 1.00f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_MenuBarBg] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
colors[ImGuiCol_ScrollbarBg] = ImVec4(0.05f, 0.05f, 0.05f, 0.54f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.34f, 0.34f, 0.34f, 0.54f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.40f, 0.54f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.56f, 0.56f, 0.56f, 0.54f);
colors[ImGuiCol_CheckMark] = ImVec4(0.33f, 0.67f, 0.86f, 1.00f);
colors[ImGuiCol_SliderGrab] = ImVec4(0.34f, 0.34f, 0.34f, 0.54f);
colors[ImGuiCol_SliderGrabActive] = ImVec4(0.56f, 0.56f, 0.56f, 0.54f);
colors[ImGuiCol_Button] = ImVec4(0.05f, 0.05f, 0.05f, 0.54f);
colors[ImGuiCol_ButtonHovered] = ImVec4(0.19f, 0.19f, 0.19f, 0.54f);
colors[ImGuiCol_ButtonActive] = ImVec4(0.20f, 0.22f, 0.23f, 1.00f);
colors[ImGuiCol_Header] = ImVec4(0.00f, 0.00f, 0.00f, 0.52f);
colors[ImGuiCol_HeaderHovered] = ImVec4(0.00f, 0.00f, 0.00f, 0.36f);
colors[ImGuiCol_HeaderActive] = ImVec4(0.20f, 0.22f, 0.23f, 0.33f);
colors[ImGuiCol_Separator] = ImVec4(0.28f, 0.28f, 0.28f, 0.29f);
colors[ImGuiCol_SeparatorHovered] = ImVec4(0.44f, 0.44f, 0.44f, 0.29f);
colors[ImGuiCol_SeparatorActive] = ImVec4(0.40f, 0.44f, 0.47f, 1.00f);
colors[ImGuiCol_ResizeGrip] = ImVec4(0.28f, 0.28f, 0.28f, 0.29f);
colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.44f, 0.44f, 0.44f, 0.29f);
colors[ImGuiCol_ResizeGripActive] = ImVec4(0.40f, 0.44f, 0.47f, 1.00f);
colors[ImGuiCol_Tab] = ImVec4(0.00f, 0.00f, 0.00f, 0.52f);
colors[ImGuiCol_TabHovered] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
colors[ImGuiCol_TabActive] = ImVec4(0.20f, 0.20f, 0.20f, 0.36f);
colors[ImGuiCol_TabUnfocused] = ImVec4(0.00f, 0.00f, 0.00f, 0.52f);
colors[ImGuiCol_TabUnfocusedActive] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
colors[ImGuiCol_DockingPreview] = ImVec4(0.33f, 0.67f, 0.86f, 1.00f);
colors[ImGuiCol_DockingEmptyBg] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogram] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TableHeaderBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.52f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.00f, 0.00f, 0.00f, 0.52f);
colors[ImGuiCol_TableBorderLight] = ImVec4(0.28f, 0.28f, 0.28f, 0.29f);
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
colors[ImGuiCol_TextSelectedBg] = ImVec4(0.20f, 0.22f, 0.23f, 1.00f);
colors[ImGuiCol_DragDropTarget] = ImVec4(0.33f, 0.67f, 0.86f, 1.00f);
colors[ImGuiCol_NavHighlight] = ImVec4(1.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 0.00f, 0.00f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(1.00f, 0.00f, 0.00f, 0.20f);
colors[ImGuiCol_ModalWindowDimBg] = ImVec4(1.00f, 0.00f, 0.00f, 0.35f);

ImGuiStyle &style = ImGui::GetStyle();
style.WindowPadding = ImVec2(8.00f, 8.00f);
style.FramePadding = ImVec2(5.00f, 2.00f);
style.CellPadding = ImVec2(6.00f, 6.00f);
style.ItemSpacing = ImVec2(6.00f, 6.00f);
style.ItemInnerSpacing = ImVec2(6.00f, 6.00f);
style.TouchExtraPadding = ImVec2(0.00f, 0.00f);
style.IndentSpacing = 25;
style.ScrollbarSize = 15;
style.GrabMinSize = 10;
style.WindowBorderSize = 1;
style.ChildBorderSize = 1;
style.PopupBorderSize = 1;
style.FrameBorderSize = 1;
style.TabBorderSize = 1;
style.WindowRounding = 7;
style.ChildRounding = 4;
style.FrameRounding = 3;
style.PopupRounding = 4;
style.ScrollbarRounding = 9;
style.GrabRounding = 3;
style.LogSliderDeadzone = 4;
style.TabRounding = 4;

}

void gamescene::on_start()
{
runner = new GameBehaviourRunner();
configs->load_config();

Graphics::get_current_scene()->load_scene(configs->current_scene);

DebugGame::add_message("GAME SCENE STARTED", DebugGame::logger);

GarinUI::make_ui_context();

camera = new Camera();
main_camera = camera;

std::cout << "CARPETA DE EJECUCION: " << FileManager::get_execute_path() << std::endl;

embraceTheDarkness();

inspector = new InspectorUI();
mainbar = new MainBarUI();
sceneui = new SceneUI();
filesui = new FilesUI();
assetsui = new AssetsUI();
settingsui = new GameSettingsUI();
hierarchyui = new HierarchyUI();
menuui = new MenuUI();

notify = new UINotification();

string info = "OPEN FILE: " + configs->current_scene;
notify->AddNotification(info, 5.0f);

RegisterDefaultAllocator();

// Instalar trace y assert callbacks
Trace = TraceImpl;
JPH_IF_ENABLE_ASSERTS(AssertFailed = AssertFailedImpl;)

// Crear una fábrica
std::unique_ptr<Factory> factory = std::make_unique<Factory>();
Factory::sInstance = factory.get();

// Registrar todos los tipos de físicas
RegisterTypes();

// Crear un asignador temporal
temp_allocator = std::make_unique<TempAllocatorImpl>(10 * 1024 * 1024);

// Crear un sistema de trabajo
job_system = std::make_unique<JobSystemThreadPool>(cMaxPhysicsJobs, cMaxPhysicsBarriers, thread::hardware_concurrency() - 1);

// Definir constantes
const uint cMaxBodies = 1024;
const uint cNumBodyMutexes = 0;
const uint cMaxBodyPairs = 1024;
const uint cMaxContactConstraints = 1024;

// Crear interfaces de capas
broad_phase_layer_interface = std::make_unique<BPLayerInterfaceImpl>();
object_vs_broadphase_layer_filter = std::make_unique<ObjectVsBroadPhaseLayerFilterImpl>();
object_vs_object_layer_filter = std::make_unique<ObjectLayerPairFilterImpl>();

// Crear el sistema de físicas
physics_system = std::make_unique<PhysicsSystem>();
physics_system->Init(cMaxBodies, cNumBodyMutexes, cMaxBodyPairs, cMaxContactConstraints, *broad_phase_layer_interface, *object_vs_broadphase_layer_filter, *object_vs_object_layer_filter);

// Crear listeners
std::unique_ptr<MyBodyActivationListener> body_activation_listener = std::make_unique<MyBodyActivationListener>();
physics_system->SetBodyActivationListener(body_activation_listener.get());

std::unique_ptr<MyContactListener> contact_listener = std::make_unique<MyContactListener>();
physics_system->SetContactListener(contact_listener.get());

// Obtener la interfaz de cuerpos
BodyInterface &body_interface = physics_system->GetBodyInterface();

// Crear el cuerpo rígido del piso
BoxShapeSettings floor_shape_settings(Vec3(100.0f, 1.0f, 100.0f));
floor_shape_settings.SetEmbedded();

ShapeSettings::ShapeResult floor_shape_result = floor_shape_settings.Create();
ShapeRefC floor_shape = floor_shape_result.Get();

BodyCreationSettings floor_settings(floor_shape, RVec3(0.0_r, -1.0_r, 0.0_r), Quat::sIdentity(), EMotionType::Static, Layers::NON_MOVING);
Body *floor = body_interface.CreateBody(floor_settings);
body_interface.AddBody(floor->GetID(), EActivation::DontActivate);

// Crear el cuerpo dinámico de la esfera
BodyCreationSettings sphere_settings(new SphereShape(0.5f), RVec3(0.0_r, 2.0_r, 0.0_r), Quat::sIdentity(), EMotionType::Dynamic, Layers::MOVING);
BodyID sphere_id = body_interface.CreateAndAddBody(sphere_settings, EActivation::Activate);
body_interface.SetLinearVelocity(sphere_id, Vec3(0.0f, -5.0f, 0.0f));

physics_system->OptimizeBroadPhase();

// uint step = 0;
// while (body_interface.IsActive(sphere_id))
// {
//     ++step;

//     RVec3 position = body_interface.GetCenterOfMassPosition(sphere_id);
//     Vec3 velocity = body_interface.GetLinearVelocity(sphere_id);
//     cout << "Step " << step << ": Position = (" << position.GetX() << ", " << position.GetY() << ", " << position.GetZ() << "), Velocity = (" << velocity.GetX() << ", " << velocity.GetY() << ", " << velocity.GetZ() << ")" << endl;

//     const int cCollisionSteps = 1;
//     physics_system->Update(cDeltaTime, cCollisionSteps, temp_allocator.get(), job_system.get());
// }

// runner->on_init();

}

std::string gamescene::demangle(const char name)
{
int status = -1;
std::unique_ptr<char, void ()(void *)> res{
abi::__cxa_demangle(name, nullptr, nullptr, &status),
std::free};
return (status == 0) ? res.get() : name;
}

void gamescene::on_update(float delta_time)
{
const int cCollisionSteps = 1;
const float cDeltaTime = 1.0f / 60.0f;
// RVec3 position = body_interface.GetCenterOfMassPosition(sphere_id);
// Vec3 velocity = body_interface.GetLinearVelocity(sphere_id);
// cout << "Step " << step << ": Position = (" << position.GetX() << ", " << position.GetY() << ", " << position.GetZ() << "), Velocity = (" << velocity.GetX() << ", " << velocity.GetY() << ", " << velocity.GetZ() << ")" << endl;

physics_system->Update(cDeltaTime, cCollisionSteps, temp_allocator.get(), job_system.get());

// runner->on_tick();

if (ImGui::IsMouseDown(ImGuiMouseButton_Right))
{
    camera->move_forward(delta_time, InputSystem::get_axis(GLFW_KEY_W, GLFW_KEY_S) * 0.1f);
    camera->move_left(delta_time, InputSystem::get_axis(GLFW_KEY_A, GLFW_KEY_D) * 0.1f);

    if (glfwGetKey(Graphics::get_game_window(), GLFW_KEY_Q) == GLFW_PRESS)
    {
        camera->cameraPosition.y -= 0.1f;
    }

    if (glfwGetKey(Graphics::get_game_window(), GLFW_KEY_E) == GLFW_PRESS)
    {
        camera->cameraPosition.y += 0.1f;
    }

    glm::vec3 newOrientation = glm::rotate(camera->Orientation, glm::radians(InputSystem::get_mouse_y()), glm::normalize(glm::cross(camera->Orientation, camera->GetUp())));

    if (abs(glm::angle(newOrientation, camera->GetUp()) - glm::radians(90.0f)) <= glm::radians(85.0f))
    {
        camera->Orientation = newOrientation;
    }

    camera->Orientation = glm::rotate(camera->Orientation, glm::radians(-InputSystem::get_mouse_x()), camera->GetUp());
}

std::string window_name = "Garin Editor - " + Graphics::get_current_scene()->scene_name;

glfwSetWindowTitle(Graphics::get_game_window(), window_name.c_str());

}

void gamescene::on_draw()
{
}

void gamescene::draw_ui()
{
GarinUI::get_ui_manager()->render_new_frame_ui_context(true);

DebugGame::run_debug_console();

if (ImGui::IsKeyDown(ImGuiKey_Backslash))
{
    DebugGame::active_console(!DebugGame::console_is_active());
}

hierarchyui->game = this;

inspector->draw(select_obj);
mainbar->draw(select_obj);
sceneui->draw(select_obj);
filesui->draw(select_obj, configs);
assetsui->draw(configs);
settingsui->draw(configs);
hierarchyui->draw(select_obj);
menuui->draw(this);
notify->RenderNotifications();

GarinUI::get_ui_manager()->render_ui_context();

}

void gamescene::on_destroy()
{
configs->save_config();
}

void gamescene::set_object_select(Entity *obj)
{
select_obj = obj;
}

/H/
#pragma once
#define JPH_PROFILE_ENABLED
#define JPH_OBJECT_STREAM
#define JPH_USE_FMADD

#include <Jolt/Jolt.h>

// Jolt includes
#include <Jolt/RegisterTypes.h>
#include <Jolt/Core/Factory.h>
#include <Jolt/Core/TempAllocator.h>
#include <Jolt/Core/JobSystemThreadPool.h>
#include <Jolt/Physics/PhysicsSettings.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Collision/Shape/BoxShape.h>
#include <Jolt/Physics/Collision/Shape/SphereShape.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Body/BodyActivationListener.h>

#include <GarinCore.h>
#include "EditorSystems/WindowsCompiler.h"
#include "EditorSystems/UIAdministrator.h"

#include "EditorGUI.h"
#include "EditorConfigs.h"

#include <TerrainGenerator.h>

#include
#include
#include

// Disable common warnings triggered by Jolt, you can use JPH_SUPPRESS_WARNING_PUSH / JPH_SUPPRESS_WARNING_POP to store and restore the warning state
JPH_SUPPRESS_WARNINGS

// All Jolt symbols are in the JPH namespace
using namespace JPH;

// If you want your code to compile using single or double precision write 0.0_r to get a Real value that compiles to double or float depending if JPH_DOUBLE_PRECISION is set or not.
using namespace JPH::literals;

using namespace std;

class Drawer;
class Camera;
class Entity;
class EditorConfigs;
class GameBehaviourRunner;
class InspectorUI;
class MainBarUI;
class SceneUI;
class FilesUI;
class AssetsUI;
class GameSettingsUI;
class HierarchyUI;
class MenuUI;
class UINotification;

// Callback for traces, connect this to your own trace function if you have one
static void TraceImpl(const char *inFMT, ...)
{
// Format the message
va_list list;
va_start(list, inFMT);
char buffer[1024];
vsnprintf(buffer, sizeof(buffer), inFMT, list);
va_end(list);

// Print to the TTY
cout << buffer << endl;

}

#ifdef JPH_ENABLE_ASSERTS

// Callback for asserts, connect this to your own assert handler if you have one
static bool AssertFailedImpl(const char *inExpression, const char *inMessage, const char *inFile, uint inLine)
{
// Print to the TTY
cout << inFile << ":" << inLine << ": (" << inExpression << ") " << (inMessage != nullptr ? inMessage : "") << endl;

// Breakpoint
return true;

};

#endif // JPH_ENABLE_ASSERTS

// Layer that objects can be in, determines which other objects it can collide with
// Typically you at least want to have 1 layer for moving bodies and 1 layer for static bodies, but you can have more
// layers if you want. E.g. you could have a layer for high detail collision (which is not used by the physics simulation
// but only if you do collision testing).
namespace Layers
{
static constexpr ObjectLayer NON_MOVING = 0;
static constexpr ObjectLayer MOVING = 1;
static constexpr ObjectLayer NUM_LAYERS = 2;
};

/// Class that determines if two object layers can collide
class ObjectLayerPairFilterImpl : public ObjectLayerPairFilter
{
public:
virtual bool ShouldCollide(ObjectLayer inObject1, ObjectLayer inObject2) const override
{
switch (inObject1)
{
case Layers::NON_MOVING:
return inObject2 == Layers::MOVING; // Non moving only collides with moving
case Layers::MOVING:
return true; // Moving collides with everything
default:
JPH_ASSERT(false);
return false;
}
}
};

// Each broadphase layer results in a separate bounding volume tree in the broad phase. You at least want to have
// a layer for non-moving and moving objects to avoid having to update a tree full of static objects every frame.
// You can have a 1-on-1 mapping between object layers and broadphase layers (like in this case) but if you have
// many object layers you'll be creating many broad phase trees, which is not efficient. If you want to fine tune
// your broadphase layers define JPH_TRACK_BROADPHASE_STATS and look at the stats reported on the TTY.
namespace BroadPhaseLayers
{
static constexpr BroadPhaseLayer NON_MOVING(0);
static constexpr BroadPhaseLayer MOVING(1);
static constexpr uint NUM_LAYERS(2);
};

// BroadPhaseLayerInterface implementation
// This defines a mapping between object and broadphase layers.
class BPLayerInterfaceImpl final : public BroadPhaseLayerInterface
{
public:
BPLayerInterfaceImpl()
{
// Create a mapping table from object to broad phase layer
mObjectToBroadPhase[Layers::NON_MOVING] = BroadPhaseLayers::NON_MOVING;
mObjectToBroadPhase[Layers::MOVING] = BroadPhaseLayers::MOVING;
}

virtual uint GetNumBroadPhaseLayers() const override
{
    return BroadPhaseLayers::NUM_LAYERS;
}

virtual BroadPhaseLayer GetBroadPhaseLayer(ObjectLayer inLayer) const override
{
    JPH_ASSERT(inLayer < Layers::NUM_LAYERS);
    return mObjectToBroadPhase[inLayer];
}

#if defined(JPH_EXTERNAL_PROFILE) || defined(JPH_PROFILE_ENABLED)
virtual const char *GetBroadPhaseLayerName(BroadPhaseLayer inLayer) const override
{
switch ((BroadPhaseLayer::Type)inLayer)
{
case (BroadPhaseLayer::Type)BroadPhaseLayers::NON_MOVING:
return "NON_MOVING";
case (BroadPhaseLayer::Type)BroadPhaseLayers::MOVING:
return "MOVING";
default:
JPH_ASSERT(false);
return "INVALID";
}
}
#endif // JPH_EXTERNAL_PROFILE || JPH_PROFILE_ENABLED

private:
BroadPhaseLayer mObjectToBroadPhase[Layers::NUM_LAYERS];
};

/// Class that determines if an object layer can collide with a broadphase layer
class ObjectVsBroadPhaseLayerFilterImpl : public ObjectVsBroadPhaseLayerFilter
{
public:
virtual bool ShouldCollide(ObjectLayer inLayer1, BroadPhaseLayer inLayer2) const override
{
switch (inLayer1)
{
case Layers::NON_MOVING:
return inLayer2 == BroadPhaseLayers::MOVING;
case Layers::MOVING:
return true;
default:
JPH_ASSERT(false);
return false;
}
}
};

// An example contact listener
class MyContactListener : public ContactListener
{
public:
// See: ContactListener
virtual ValidateResult OnContactValidate(const Body &inBody1, const Body &inBody2, RVec3Arg inBaseOffset, const CollideShapeResult &inCollisionResult) override
{
cout << "Contact validate callback" << endl;

    // Allows you to ignore a contact before it is created (using layers to not make objects collide is cheaper!)
    return ValidateResult::AcceptAllContactsForThisBodyPair;
}

virtual void OnContactAdded(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, ContactSettings &ioSettings) override
{
    cout << "A contact was added" << endl;
}

virtual void OnContactPersisted(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, ContactSettings &ioSettings) override
{
    cout << "A contact was persisted" << endl;
}

virtual void OnContactRemoved(const SubShapeIDPair &inSubShapePair) override
{
    cout << "A contact was removed" << endl;
}

};

// An example activation listener
class MyBodyActivationListener : public BodyActivationListener
{
public:
virtual void OnBodyActivated(const BodyID &inBodyID, uint64 inBodyUserData) override
{
cout << "A body got activated" << endl;
}

virtual void OnBodyDeactivated(const BodyID &inBodyID, uint64 inBodyUserData) override
{
    cout << "A body went to sleep" << endl;
}

};

class gamescene : public scenes
{
public:
Drawer *drawcube;
Camera *camera;

Entity *select_obj;
EditorConfigs *configs = new EditorConfigs();
GameBehaviourRunner *runner;

InspectorUI *inspector;
MainBarUI *mainbar;
SceneUI *sceneui;
FilesUI *filesui;
AssetsUI *assetsui;
GameSettingsUI *settingsui;
HierarchyUI *hierarchyui;
MenuUI *menuui;
UINotification *notify;
std::unique_ptr<BPLayerInterfaceImpl> broad_phase_layer_interface;
std::unique_ptr<ObjectVsBroadPhaseLayerFilterImpl> object_vs_broadphase_layer_filter;
std::unique_ptr<ObjectLayerPairFilterImpl> object_vs_object_layer_filter;
std::unique_ptr<PhysicsSystem> physics_system;
std::unique_ptr<TempAllocatorImpl> temp_allocator;
std::unique_ptr<JobSystemThreadPool> job_system;

void embraceTheDarkness();

void on_start() override;
void on_update(float delta_time) override;
void on_draw() override;
void draw_ui() override;
void on_destroy() override;
void set_object_select(Entity *obj);

std::string demangle(const char *name);

};

jrouwe · 2024-06-22T11:16:23Z

jrouwe
Jun 22, 2024
Maintainer

Hello,

Unfortunately I don't have time to figure out how to compile and run this chunk of code. Please give me a callstack + console output + show on which line it is crashing + list the values of local variables.

Note that if you want your code to be readable then use 3 backticks to escape it:

11 replies

jrouwe Jun 22, 2024
Maintainer

I'm sorry, you say it crashes but you don't say where. I can't help you if you don't supply the relevant information.

NeonXStudios Jun 22, 2024
Author

the crashes happen this way when i start the systems. i start the physics_system, and the update that is to activate the physics world, but the crashes happen when i add a rigidbody then the error happens.

jrouwe Jun 22, 2024
Maintainer

Callstack please.

NeonXStudios Jun 22, 2024
Author

I'd better send you a video to show you how the blocking works.

NeonXStudios Jun 24, 2024
Author

NeonXStudios · 2024-06-24T06:12:08Z

NeonXStudios
Jun 24, 2024
Author

2024-06-24.01-08-58.mp4

2 replies

NeonXStudios Jun 24, 2024
Author

it crashes when I try to create a dynamic object

NeonXStudios Jun 24, 2024
Author

with a static object if it works

NeonXStudios · 2024-06-24T06:12:10Z

NeonXStudios
Jun 24, 2024
Author

There is no error in the console or anything else it just closes the program it closes only when I add a rigidbody and if there is no rigidbody it works without problems.

0 replies

jrouwe · 2024-06-24T20:04:30Z

jrouwe
Jun 24, 2024
Maintainer

I see a clear error here:

You're triggering an assert trying to set a velocity on a static body. This is not allowed as a static body cannot move. If you had been running in the debugger it would have stopped there and you would have seen immediately what's going on, but if you run without a debugger then a breakpoint exception will exit the application.

2 replies

NeonXStudios Jun 24, 2024
Author

okay i understand my question is how do i compile the library as release because i am using Mingw32-make to compile and generate the .a

iSLC Jun 24, 2024

Set CMAKE_BUILD_TYPE to Release or Distribution either via command line by adding -DCMAKE_BUILD_TYPE=Release or via the GUI window by searching for the option and changing it or adding it manually.

But all of that won't quite solve your issue as jrouwe already mentioned, you're doing something you're not supposed to do. The assert is there to tell you that.

NeonXStudios · 2024-06-26T16:33:51Z

NeonXStudios
Jun 26, 2024
Author

now it crashes when I try to create a body after everything has been started. I don't know what to do and I don't know how to compile in release because I use mingw.

0 replies

jrouwe · 2024-06-26T19:54:11Z

jrouwe
Jun 26, 2024
Maintainer

Please understand that your question is equivalent to the following:

Your car engine is broken, if you turn the key, wierd noises come out of the engine and it starts smoking. You take a picture of your car:

You send an e-mail to the car's manufacturer and type: 'my car doesn't work, how do i fix it' and you attach your beautiful picture.

What do you expect the car manufacturer to say?

Please learn how to attach a debugger to your application. I'm sure that as soon as you do, some error message will trigger and will tell you exactly what is going wrong or at least it will tell you where it is going wrong. If anything, compiling the executable in Release mode will make it more difficult to figure out what the issue is.

0 replies

NeonXStudios · 2024-06-26T21:56:09Z

NeonXStudios
Jun 26, 2024
Author

ok thank you I will

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

I need help Jolt crashes on me #1145

{{title}}

Replies: 7 comments 15 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

I need help Jolt crashes on me #1145

NeonXStudios Jun 22, 2024

Replies: 7 comments · 15 replies

jrouwe Jun 22, 2024 Maintainer

jrouwe Jun 22, 2024 Maintainer

NeonXStudios Jun 22, 2024 Author

jrouwe Jun 22, 2024 Maintainer

NeonXStudios Jun 22, 2024 Author

NeonXStudios Jun 24, 2024 Author

NeonXStudios Jun 24, 2024 Author

NeonXStudios Jun 24, 2024 Author

NeonXStudios Jun 24, 2024 Author

NeonXStudios Jun 24, 2024 Author

jrouwe Jun 24, 2024 Maintainer

NeonXStudios Jun 24, 2024 Author

iSLC Jun 24, 2024

NeonXStudios Jun 26, 2024 Author

jrouwe Jun 26, 2024 Maintainer

NeonXStudios Jun 26, 2024 Author

NeonXStudios
Jun 22, 2024

Replies: 7 comments 15 replies

jrouwe
Jun 22, 2024
Maintainer

jrouwe Jun 22, 2024
Maintainer

NeonXStudios Jun 22, 2024
Author

jrouwe Jun 22, 2024
Maintainer

NeonXStudios Jun 22, 2024
Author

NeonXStudios Jun 24, 2024
Author

NeonXStudios
Jun 24, 2024
Author

NeonXStudios Jun 24, 2024
Author

NeonXStudios Jun 24, 2024
Author

NeonXStudios
Jun 24, 2024
Author

jrouwe
Jun 24, 2024
Maintainer

NeonXStudios Jun 24, 2024
Author

NeonXStudios
Jun 26, 2024
Author

jrouwe
Jun 26, 2024
Maintainer

NeonXStudios
Jun 26, 2024
Author