2D physics engine for games

Related tags

Physics liquidfun
Overview

LiquidFun logo

LiquidFun Version 1.1.0

Welcome to LiquidFun!

LiquidFun is a 2D physics engine for games. Go to our landing page to browse our documentation and see some examples.

LiquidFun is an extension of Box2D. It adds a particle based fluid and soft body simulation to the rigid body functionality of Box2D. LiquidFun can be built for many different systems, including Android, iOS, Windows, OS X, Linux, and JavaScript. Please see Box2D/Documentation/Building/ for details.

Discuss LiquidFun with other developers and users on the LiquidFun Google Group. File issues on the LiquidFun Issues Tracker or post your questions to stackoverflow.com with a mention of liquidfun.

Please see Box2D/Documentation/Building/ to learn how to build LiquidFun and run the testbed.

LiquidFun has a logo that you can use, in your splash screens or documentation, for example. Please see the Programmer's Guide for the graphics and further details.

For applications on Google Play that integrate this tool, usage is tracked. This tracking is done automatically using the embedded version string (b2_liquidFunVersionString), and helps us continue to optimize it. Aside from consuming a few extra bytes in your application binary, it shouldn't affect your application at all. We use this information to let us know if LiquidFun is useful and if we should continue to invest in it. Since this is open source, you are free to remove the version string but we would appreciate if you would leave it in.

Issues
  • Segmentation fault when running Convex Hull

    Segmentation fault when running Convex Hull

    Hi,

    I installed Liquid Fun v1.0 (stable) with DEBUG build type mentioned here. However, after executing the Testbed, the program throws segmentation fault whenever I select Convex Hull test from the menu.

    opened by raivivek 5
  • lfjs: support b2Contact.SetEnabled and fix b2WorldManifold.GetPoint

    lfjs: support b2Contact.SetEnabled and fix b2WorldManifold.GetPoint

    for javascript version.

    1. add support for b2Contact.SetEnabled and b2Contact.IsEnabled

    2. b2WorldManifold.GetPoint, each point data position interval should be 8 instead of 2

    opened by haskasu 4
  • liquidfun.js bugs

    liquidfun.js bugs

    I found some problems with the existing bindings.

    b2Body.CreateFixtureFrom(Def|Shape) accesses a global variable called world instead of the world the b2Body belongs to.

    The methods GetParticleCount/GetPositionBuffer don't work quite right. Sometimes GetParticleCount is off by one, which might be because of the int/double casting. The position buffer is too small. It has the same size as the numberGetParticleCount() returns, but should be twice as large. The current bindings code seems to allocate the buffers correctly, but still results in this problem while running the code. Unfortunately, I'm not so acquainted with Emscripten so I can't figure out where the problem lies.

    opened by zilluss 4
  • Update CMakeLists.txt to successfully build Xcode project from cmake -G Xcode

    Update CMakeLists.txt to successfully build Xcode project from cmake -G Xcode

    This wasn't compiling properly. I had originally opened https://github.com/google/liquidfun/issues/37 but then closed it as I wasn't too sure if the project was being kept up to date. Anyways, someone commented on issue 37, so creating a pull request for the fix.

    opened by mobileben 4
  • OSX build results in blank white screen when running Testbed

    OSX build results in blank white screen when running Testbed

    So this is sort of a combo problem. First issue is that using

    cmake -G Xcode

    A proper Xcode project file does not build. There are a slew of errors. They range from TryCompile issues to get_filename_component called with incorrect number of arguments. If you try running cmake -G Xcode a few times, it eventually churns out an Xcode project file, which does build. However, when running 64-bit, it produces a white screen only. In 32-bit, you see the graphics, but the simulators do not run and it seems to have no keyboard input.

    Alternatively, I tried to build it using build.sh. This worked. But the result was the same: Testbed ran with a pure white screen.

    I'm running OSX 10.9.5. I installed XQuartz 2.7.7. My cmake version is 2.8.12.1. I am however, using Xcode 6.1. I should also note that the iOS version runs fine.

    opened by mobileben 4
  • Cannot build on windows without commenting out line 154+ in CMakeLists.txt

    Cannot build on windows without commenting out line 154+ in CMakeLists.txt

    When pthread.h is not available (didn't test with an available one), the build fails with:

    CMake Error at CMakeLists.txt:158 (set_target_properties): set_target_properties Can not find target to add properties to: Threads::Threads

    opened by rhtgrg 3
  • Remove sdk after $ANDROID_SDK_HOME

    Remove sdk after $ANDROID_SDK_HOME

    $ANDROID_SDK_HOME should point to SDK home directory, not a directory above with hardcoded sdk directory.

    Trying to build Testbed with build_apk.sh fails due to wrong path under Linux, since SDK unpacks to android-sdk-linux.

    opened by auselen 3
  • Compacting list is a big problem

    Compacting list is a big problem

    We're running physics at a fixed rate and interpolating motion between the last two physics steps. For this reason we need the current and previous position of a particle, but the self-compacting list feature causes the particle indexes to become invalid. How can we persistently track a single particle?

    opened by Leadwerks 2
  • Based on SPH ?

    Based on SPH ?

    I have a question, is liquidfun based on some form of SPH ? After looking at source code it doesn't seem so. Is there any paper I can read about algorithms being used ?

    opened by Sheph 2
  • Particles collide with second fixture at shared vertex

    Particles collide with second fixture at shared vertex

    When particles move along a fixture and one of the vertices is shared with another fixture, the particles then behave as if they collide with the second fixture.

    particle vertex collision

    Here's the example in full:

    liquidfun_particle_bug.zip

    opened by colludium 2
  • Finished JS bindings for basic collision filtering

    Finished JS bindings for basic collision filtering

    This adds JavaScript bindings for b2Fixture.Refilter, and a JavaScript version of b2Fixture.SetFilterData. It also makes b2Body set the fixture's filter from the fixtureDef.

    opened by camerondm9 2
  • Fix YouTube video embeds in documentation

    Fix YouTube video embeds in documentation

    The examples at https://google.github.io/liquidfun/#Examples do not load currently, because as the console reports:

    Mixed Content: The page at '<URL>' was loaded over HTTPS, but requested an insecure frame '<URL>'.
    This request has been blocked; the content must be served over HTTPS.
    
    opened by ashtonsix 1
  • Major fixes

    Major fixes

    • Several major fixes to BeginContact and EndContact
    • Makes fixture<->particle collision distance use radius instead of diameter, and if the extra distance was intentional, the setting b2_fixtureParticleCollisionRadiusScaler gives control over this instead of it being a constant 2.
    • Makes b2ParticleSystem forces clear in b2World::ClearForces(), the same way that b2Body forces are cleared. This fixes forces from being applied at only the first particleIteration.
    • SolveCollision and SolveBarrier relied on (delayed) forces to be cleared immediately, in order to generate the contacts they desire, so I added m_impulseBuffer for them to use, which clears immediately.
    • Fixes elastic directional bias. I believe that this bias was more noticeable with smaller time steps.
    opened by Steffenvy 1
  • Can't build liquidfun on Ubuntu.

    Can't build liquidfun on Ubuntu.

    Hello everyone,

    following the procedure described in the https://google.github.io/liquidfun/Building/html/md__building_linux.html page, cd liquidfun/Box2D cmake -G'Unix Makefiles' make

    i get many errors, as follow:

    This warning is for project developers. Use -Wno-dev to suppress it.

    CMake Error at CMakeLists.txt:158 (set_target_properties): set_target_properties Can not find target to add properties to: X11::X11

    CMake Error at CMakeLists.txt:158 (set_target_properties): set_target_properties Can not find target to add properties to: X11::ICE

    CMake Error at CMakeLists.txt:158 (set_target_properties): set_target_properties Can not find target to add properties to: X11::SM

    CMake Error at CMakeLists.txt:158 (set_target_properties): set_target_properties Can not find target to add properties to: X11::Xau

    How can i fix and complete the build?

    Thank you very much

    opened by AmigaBlitter 1
  • In the case of free fall movement, the change value of moving distance in the same time interval cannot be greater than 2, that is to say, it will change from free fall movement to uniform linear movement

    In the case of free fall movement, the change value of moving distance in the same time interval cannot be greater than 2, that is to say, it will change from free fall movement to uniform linear movement

    In the case of free fall movement, the change value of moving distance in the same time interval cannot be greater than 2, that is to say, it will change from free fall movement to uniform linear movement

    I want to know how to modify it

    code:

    const bodyDef = new b2BodyDef; bodyDef.type = b2_dynamicBody; bodyDef.position.Set(0, 4); this.body = world.CreateBody(bodyDef);

    const dynamicBox = new b2PolygonShape(); dynamicBox.SetAsBoxXY(0.1, 0.1); var lastX = this.body.GetPosition().y; setInterval(() => { var X = this.body.GetPosition().y;

    console.log(X - lastX);
    lastX = X;
    

    }, 1000 / 60) const fixtureDef = new b2FixtureDef; fixtureDef.shape = dynamicBox; fixtureDef.density = 1; fixtureDef.friction = 0.2;

    this.body.CreateFixtureFromDef(fixtureDef);

    opened by oxDesigner 0
  • b2ParticleAssembly.neon.s unable to compile under arm64-v8a

    b2ParticleAssembly.neon.s unable to compile under arm64-v8a

    Trying to compile under ARM64-V8a has been unsuccessful...

    running these flags:

        QMAKE_CXXFLAGS_RELEASE = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp
        QMAKE_CFLAGS_DEBUG = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp
        QMAKE_CXXFLAGS_DEBUG = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp
    

    you get :-1: error: the clang compiler does not support '-march=armv7-a'

    Omitting it you get the same error for cortex-a8, omitting THAT and you get a problem with the neon assembly file. I am able to compile and deploy without those flags for armeabi-v7a which tells me the compiler does not like the assembly file. I have a feeling this is me being inexperienced with android compilers but I was able to compiler the library, and link with the .a

    Doing so ran into another issue where the library could not see the Box2DParticleSystem, which led me back to trying to link the static library

    opened by monckey100 0
Releases(v1.1.0)
  • v1.1.0(Jul 16, 2014)

    Overview

    The 1.1.0 release of LiquidFun adds support for new platforms, speeds-up the simulation, and documents the particle simulation algorithm with a fun, visual presentation. Some highlights:

    • iOS support.
    • JavaScript support via Emscripten.
    • Improved Java support via more SWIG bindings.
    • An Inside LiquidFun presentation explaining the particle simulation algorithm.
    • ARM optimizations using NEON.
    • Stability and collision improvements to the particle simulation.
    • More ways to inspect particle contacts.
    • A LiquidFun logo to use in your splash screens and documentation, if you like.

    The API Modifications are minimal in this release, but please review them carefully before upgrading your project.

    LiquidFun now supports Mac, Windows, Linux, Android, iOS, and browsers. Note that LiquidFun code is portable C++98, so you should be able to compile it for other platforms too.

    Your program can use LiquidFun if it is written in C++, Java, or JavaScript.

    LiquidFun 1.1.0 is based on Box2D revision 280, the 2.3.0 release of Box2D.

    New Features

    • Translated LiquidFun into JavaScript using Emscripten. Please see Box2D/lfjs for the JavaScript bindings and a JavaScript version of the Testbed.
    • Added iOS XCode projects for the Testbed application and EyeCandy demo.
    • Added b2ParticleSystem::SplitParticleGroup, which finds disjoint blobs of particles, and puts each into its own b2ParticleGroup.
    • Added several accessor functions that use only int32s, float32s, and void pointers. These accessors are wrapped in the LIQUIDFUN_EXTERNAL_LANGUAGE_API preprocessor define. They enable binding with other languages--for example, via SWIG.
    • Particle indices can be represented with 16-bits instead of 32-bits. This is a nice optimization if you know you will have less than 32k particles per simulation.
    • b2ParticleSimulation::UpdateContacts has been rewritten to take advantage of NEON SIMD. The original implementation remains, for reference, and for platforms that do not support NEON SIMD. The NEON SIMD version requires 16-bit particle indices.

    API Modifications

    • b2ParticleContact's members are now accessed via Get and Set functions.
    • b2ParticleSystemDef now has members for strictContactCheck, density, gravityScale, radius, and maxCount. You can still set these values after b2ParticleSystem creation, however, for example via b2ParticleSystem::SetDensity.

    Other Changes

    • Added b2ParticleSystem::GetAllParticleFlags, b2ParticleSystem::GetAllGroupFlags, and b2ParticleGroup::GetAllParticleFlags, which OR-together all the flags in a particle system or group.
    • Expose the contact weight buffer. The weight represents how closely two particles overlap.
    • Expose particle pairs and triads for reading. These arrays indicate which particles are interacting.
    • Added b2ParticleGroup::GetLinearVelocityFromWorldPoint, which returns the average velocity of a particle group with respect to a position. The position is used to calculate the angular velocity of the group.
    • Added b2World::CalculateReasonableParticleIterations to give a good estimate of the number of particle iterations you should pass into b2World::Step.
    Source code(tar.gz)
    Source code(zip)
    liquidfun-1.1.0.tar.gz(8.87 MB)
    liquidfun-1.1.0.zip(10.45 MB)
  • v1.0.0(Mar 18, 2014)

    Overview

    The 1.0.0 release of LiquidFun introduces a number of new features to the API described below. Some of the highlights are:

    • Multiple particle systems.
    • New particle behaviors: barrier, static-pressure, and repulsive.
    • Particle lifetimes.
    • Detection of stuck particles.
    • The ability to apply forces and impulses to particles.
    • Java support via SWIG.
    • A host of new demos: inside the existing Testbed application, and gorgeous new "EyeCandy" demo for Android.

    Users of 0.9.0 should carefully read through the API Modifications section to understand what they need to change to get their existing applications to work with the latest release of LiquidFun.

    New Features

    • Added option to substep particle simulation independently of b2World.
    • Added barrier particles which can be used to prevent particle tunneling due to large particle velocities or simulation steps.
    • Added static pressure particles to reduce compression of fluids.
    • Added repulsive particles to separate particle groups from each other.
    • Added support for multiple independent particle systems.
    • Added option to create particles in an existing particle group.
    • Added option to detect stuck particles.
    • Added option to pause particle simulations. Paused simluations don't consume cycles in b2World::Step.
    • Added option to enable a more strict check for Particle/Body interactions in cases where complex world geometry may cause false positive contacts.
    • Added option to call a contact listener or filter on particle / fixture or particle / particle interactions.
    • Added the ability to apply forces and impulses to particles.
    • Added "EyeCandy" sample to demonstrate different particle rendering methods on Android.
    • Added "Sparky", "Sandbox" and "Soup Stirrer" tests to the Testbed example to demonstrate particle and rigid body interaction.
    • Added "Ramp", "Pointy", and "AntiPointy" tests to the Testbed example to illustrate the difference with strict contact checking.
    • Added "Maxwell" test to the Testbed to demonstrate the direct modification of particle velocities.
    • Added "Fracker" test to demonstrate particle viscous fluids and particle destruction callbacks.
    • Added "Multiple Systems" test to the Testbed to demonstrate multiple particle systems.
    • Added Java Native Interface support via SWIG. It covers a subset of the API.
    • Added the ability to pass a list of shapes to be passed in for particle-group creation.

    API Modifications

    • b2Draw::e_particleBit flag now enables/disables b2World::DrawDebugData() drawing the particle system.

    To render the particle system using b2World::DrawDebugData(), the b2Draw::e_particleBit flag must be set on the b2Draw object passed to b2World::SetDebugDraw(). It is possible to set flags on b2Draw objects using b2Draw::SetFlags().

    Release 0.9.0 unconditionally called b2Draw::DrawParticles() from b2World::DrawDebugData().

    • Building LiquidFun on Linux, using cmake -G"Unix Makefiles", now places output files in a build type sub-directory.

    For example, the output executable of the Testbed example is now written to Box2D/Testbed/Release/Testbed when building using the Release configuration.

    • Multiple independent particle systems can now exist, each with its own physical coefficients. Previously, only one particle system existed, and it always existed. Use b2World::CreateParticleSystem to create particle systems, and b2World::DestroyParticleSystem to destroy them.
    • b2DestructionListener::SayGoodbye, b2QueryCallback::ReportParticle, and b2RayCastCallback::ReportParticle each now takes a b2ParticleSystem pointer as its first parameter. This change is necessary since multiple particle systems can now exist.
    • The particle system API has moved from b2World to b2ParticleSystem. For example, b2ParticleSystem::DestroyParticlesInShape replaces b2World::DestroyParticlesInShape. You can use b2World::CreateParticleSystem or b2World::GetParticleSystemList() to acquire references to b2ParticleSystem.
    • Removed "Particle" from many of the functions in the particle system API. The word is redundant now that the API is under b2ParticleSystem. The API now has the following naming convention:
    • Each function that takes a particle index or handle has a "Particle" component (e.g. "SetParticle").
    • Each function that operates on the entire system has no "Particle" component (e.g. "SetRadius").
    ```
    GetParticleMaxCount ==> GetMaxParticleCount
    SetParticleMaxCount ==> SetMaxParticleCount
    GetParticleDensity ==> GetDensity
    SetParticleDensity ==> SetDensity
    SetParticleGravityScale ==> SetGravityScale
    GetParticleGravityScale ==> GetGravityScale
    SetParticleDamping ==> SetDamping
    GetParticleDamping ==> GetDamping
    GetParticleStaticPressureIterations ==> GetStaticPressureIterations
    SetParticleStaticPressureIterations ==> SetStaticPressureIterations
    SetParticleRadius ==> SetRadius
    GetParticleRadius ==> GetRadius
    GetParticlePositionBuffer ==> GetPositionBuffer
    GetParticlePositionBuffer ==> GetPositionBuffer
    GetParticleVelocityBuffer ==> GetVelocityBuffer
    GetParticleVelocityBuffer ==> GetVelocityBuffer
    GetParticleColorBuffer ==> GetColorBuffer
    GetParticleColorBuffer ==> GetColorBuffer
    GetParticleGroupBuffer ==> GetGroupBuffer
    GetParticleGroupBuffer ==> GetGroupBuffer
    GetParticleUserDataBuffer ==> GetUserDataBuffer
    GetParticleUserDataBuffer ==> GetUserDataBuffer
    GetParticleFlagsBuffer ==> GetFlagsBuffer
    SetParticleFlagsBuffer ==> SetFlagsBuffer
    SetParticlePositionBuffer ==> SetPositionBuffer
    SetParticleVelocityBuffer ==> SetVelocityBuffer
    SetParticleColorBuffer ==> SetColorBuffer
    SetParticleUserDataBuffer ==> SetUserDataBuffer
    GetParticleContacts ==> GetContacts
    GetParticleContactCount ==> GetContactCount
    GetParticleBodyContacts ==> GetBodyContacts
    GetParticleBodyContactCount ==> GetBodyContactCount
    DestroyParticlesInGroup ==> DestroyParticles (moved to b2ParticleGroup)
    ```
    
    • Renamed b2ParticleFlag b2DestructionListener to b2DestructionListenerParticle to be consistent with other particle flag names.
    • Better particle-behavior stability.

    Other Changes

    • Integrated Box2D 2.3.0 release from Box2D revision 280.
    • Reduced the size of particles in Testbed particle tests to be consistent with the size of rigid bodies.
    • Improved damping force to prevent particle explosions.
    • Fixed b2Timer bug that occurs when the usec component wraps.
    • Added b2Stat to calculate min/max/mean of a set of samples, and integrated this functionality into Testbed to measure performance.
    • Fixed memory leaks of large blocks allocated by b2BlockAllocator.
    • Fixed incorrect stack-capacity calculation in b2VoronoiDiagram.
    • Added operators to b2ParticleColor.
    • Improved parameter and option selection in Testbed with the fullscreen UI.
    • Cleaned up statistics display in Testbed.
    • Fixed depth-buffer allocation when creating an empty particle group.
    • Added build step to unit-test execution scripts.
    • Added generation of code coverage report for unit-tests.
    • Added a script to clean up temporary cmake files.
    • Increased warning level and enabled conversion of warnings to errors.
    • Added unit-test for b2IsValid().
    • Added b2World::QueryShapeAABB() convenience function to query the world for objects in the AABB which encloses a shape.
    • Inlined some simple b2ParticleSystem and b2ParticleGroup functions.
    • Allowed particle systems to be culled from b2World::QueryAABB and b2World::RayCast.
    • Added callbacks so an application can override b2Alloc() and b2Free() without modifying the library.
    • Added valgrind support to unit-test runner on Linux / OSX.
    • Added cygwin wrapper script for build.bat and build_android.bat on Windows.
    • Added option to archive build artifacts from build scripts.
    • Changed Android C++ runtime library to gnustl_static.
    Source code(tar.gz)
    Source code(zip)
    liquidfun-1.0.0.tar.gz(6.10 MB)
    liquidfun-1.0.0.zip(7.51 MB)
  • v0.9.0(Dec 10, 2013)

    Overview

    The initial release of LiquidFun is available for download from the 0.9.0 release release page.

    New Features

    • Particle system added to Box2D.
    • Example applications ported to Android.

    API Modifications

    • No changes to the Box2D 2.3.0 pre-release API.

    Other Changes

    • Integrated Box2D 2.3.0 pre-release from Box2D revision 255
    • Unit tests implemented for the particle system.
    • Particle system tests added to the Testbed example application.
    • Build-system support for Android.
    • Moved documentation to Markdown/HTML.
    Source code(tar.gz)
    Source code(zip)
    liquidfun-0.9.0.tar.gz(3.63 MB)
    liquidfun-0.9.0.zip(4.85 MB)
Owner
Google
Google ❤️ Open Source
Google
2D physics engine for games

LiquidFun Version 1.1.0 Welcome to LiquidFun! LiquidFun is a 2D physics engine for games. Go to our landing page to browse our documentation and see s

Google 4.4k May 7, 2022
A fast and lightweight 2D game physics library.

NEW IN CHIPMUNK 7 Chipmunk 7 is complete and now includes the ARM NEON optimizations, the autogeometry code, and the mulithreaded solver. The latest p

Scott Lembcke 1.8k May 11, 2022
C++ library for multi-physics simulation

Project CHRONO Project Chrono represents a community effort aimed at producing a physics-based modelling and simulation infrastructure based on a plat

null 1.4k May 13, 2022
High-performance C++ multibody dynamics/physics library for simulating articulated biomechanical and mechanical systems like vehicles, robots, and the human skeleton.

Simbody Simbody is a high-performance, open-source toolkit for science- and engineering-quality simulation of articulated mechanisms, including biomec

Simbody Project 1.9k May 7, 2022
Real-time multi-physics simulation with an emphasis on medical simulation.

Introduction SOFA is an open source framework primarily targeted at real-time simulation, with an emphasis on medical simulation. It is mainly intende

SOFA Framework 605 May 10, 2022
Natively multithreaded physics for threejs with PhysX.

Three-Physx Natively multithreaded physics for threejs with PhysX and an easy interface. Credit to Milkshake inc, physx-js, three-ammo, three-to-canno

XR Foundation 12 Feb 17, 2022
Bullet Physics SDK: real-time collision detection and multi-physics simulation for VR, games, visual effects, robotics, machine learning etc.

Bullet Physics SDK: real-time collision detection and multi-physics simulation for VR, games, visual effects, robotics, machine learning etc.

Bullet Physics SDK 9.3k May 11, 2022
Box2D is a 2D physics engine for games

Build Status Box2D Box2D is a 2D physics engine for games. Contributing Please do not submit pull requests with new features or core library changes.

Erin Catto 5.7k May 17, 2022
2D physics engine for games

LiquidFun Version 1.1.0 Welcome to LiquidFun! LiquidFun is a 2D physics engine for games. Go to our landing page to browse our documentation and see s

Google 4.4k May 7, 2022
Bounce is a 3D physics engine for games.

Bounce Welcome! Bounce is a 3D physics engine for games. Features Common Efficient data structures with no use of STL Fast memory allocators Built-in

Irlan Robson 56 May 8, 2022
Box2D is a 2D physics engine for games

Build Status Box2D Box2D is a 2D physics engine for games. Contributing Please do not submit pull requests with new features or core library changes.

Erin Catto 5.7k May 8, 2022
Real-time oriented physics engine and library that's currently best suited for 2D games.

PlayRho A way to play with physical behaviors like the conservation of momentum. PlayRho is a real-time oriented physics engine and library that's cur

Louis Langholtz 82 Apr 22, 2022
Defold Engine integration with Yandex.Metrica to track your games on Yandex.Games.

Yandex.Metrica for Defold Yandex.Metrica is a free of charge web analytics tool for websites, that's the reason why we can use it for HTML5 games. Yan

Indiesoft LLC 6 Jan 20, 2022
A multi core friendly rigid body physics and collision detection library suitable for games and VR applications.

Jolt Physics Library A multi core friendly rigid body physics and collision detection library suitable for games and VR applications. A YouTube video

null 1.6k May 14, 2022
A multi core friendly rigid body physics and collision detection library suitable for games and VR applications.

A multi core friendly rigid body physics and collision detection library suitable for games and VR applications.

null 1.6k May 11, 2022
This repository is about a school project about games with physics, written in C++.

Eight Ball Pool ?? A game about playing physics-based eight ball pool. ?? Table of Contents About Getting Started Usage Built Using About the creators

Valeri Ivanov 17 Apr 23, 2022
This is a list of different open-source video games and commercial video games open-source remakes.

This is a list of different open-source video games and commercial video games open-source remakes.

Ivan Bobev 55 May 7, 2022
Tactile-Arcade-Games - Wrote a C program comprised of four separate games that run in a loop using the PSoC 5LP board and Cypress IDE.

Tactile-Arcade-Games - Wrote a C program comprised of four separate games that run in a loop using the PSoC 5LP board and Cypress IDE. Used two potentiometers, two ADCs to convert their voltages to digital values, a PWM to drive two servos, an 8x8 RGB LED matrix, 40 digital output pins and 8 power MOSFETS to control the matrix, and a character LCD display.

null 2 Dec 24, 2021
Nimble: Physics Engine for Deep Learning

Nimble: Physics Engine for Deep Learning

Keenon Werling 259 May 10, 2022
Godot bindings for the Rapier3D physics engine

Godot bindings for the Rapier3D physics library How to use There are two parts: A Godot module which must be compiled with the engine.

David Hoppenbrouwers 20 Oct 26, 2021
SKR_Physics is a lightweight and easy to use 2D physics engine which is written in C++.

SKR_Physics SKR_Physics is a lightweight and easy to use 2D physics engine which is written in C++. Features Rectangle based collision system Very sim

Şükrü 0 Mar 8, 2022
Sequential impulses physics engine made for learning purposes

A 3D physics engine that uses Separating Axis Test for collision detection, the clipping method for generating contact manifold, contact point reducti

Ahmad Saleh 1 Nov 24, 2021
Open source C++ physics engine library in 3D

ReactPhysics3D ReactPhysics3D is an open source C++ physics engine library that can be used in 3D simulations and games. www.reactphysics3d.com ?? Fea

Daniel Chappuis 991 May 9, 2022
Improved version of real-time physics engine that couples FEM-based deformables and rigid body dynamics

Enhanced version of coupled FEM and constrained rigid body simulation Description This little playground aimed to test our Conjugate Gradients based M

Andrey Voroshilov 25 Apr 11, 2022
A small 2D physics engine

Box2D-Lite Box2D-Lite is a small 2D physics engine. It was developed for the 2006 GDC Physics Tutorial. This is the original version of the larger Box

Erin Catto 606 May 10, 2022
Phyxed is a 2D physics engine with support for fixed point math.

Phyxed is a 2D physics engine with support for fixed point math.

Anders Elfgren 23 Jan 18, 2022
A 2D Physics Engine written in C++, supporting circles and orientable, non-regular convex polygons.

PhysicsEngine A basic physics engine supporting circles and orientable non-regular convex polygons. Oh, and it has undamped springs and strings. Demo

ThePythonator 3 Mar 19, 2022
Open-source, cross-platform, C++ game engine for creating 2D/3D games.

GamePlay v3.0.0 GamePlay is an open-source, cross-platform, C++ game framework/engine for creating 2D/3D mobile and desktop games. Website Wiki API De

gameplay3d 3.6k May 15, 2022
Tools for interacting with music data in GBA games that use the Engine Software replayer.

A suite of tools for interacting with the XM-like music data found in certain Game Boy Advance games - specifically those that use the Engine Software replayer middleware.

Luna 17 Nov 16, 2021