OpenGL texture, POSIX benchmark

Author: cirosantilli

README.md

@@ -36,7 +36,8 @@ C and C++ minimal examples. Asserts used wherever possible. Cheatsheets, tutoria
 1.  [Linting tools](linting-tools.md)
     1.  [Frama-C](frama-c/)
 1.  [Boost](boost/)
-1.  [CMake](cmake.md)
+1.  [Build systems](build-systems.md)
+    1.  [CMake](cmake.md)
 1.  [Flex and Bison](flex-bison/)
 1.  [glibc](glibc/)
 1.  [hello_world_cpp.cpp](hello_world_cpp.cpp)
@@ -52,6 +53,7 @@ C and C++ minimal examples. Asserts used wherever possible. Cheatsheets, tutoria
     1. [LAPACK](lapack/)
     1. [OpenCV](opencv/)
     1. [PLplot](plplot/)
+    1. [Bullet physics](bullet/)
 1.  [CONTRIBUTING](CONTRIBUTING.md)
 1.  [TODO](TODO.md)
 1.  [Bibliography](bibliography.md)

build-systems.md

@@ -0,0 +1,3 @@
+# Build systems
+
+- premake: 

bullet.md

@@ -0,0 +1 @@
+../Makefile_many

bullet/Makefile

@@ -0,0 +1,17 @@
+# TODO get rid of this. Bullet headers are horribly coded for Linux:
+# the toplevel include all btBulletDynamicsCommon.h uses #include "subdir"
+# instead of the better #include "bullet/subdir".
+# So we are forced to add it to the search path.
+# Maybe some cmake magic would prevent that?
+I := -I/usr/include/bullet -I/usr/local/include/bullet
+LIBS := \
+	-lBullet2FileLoader \
+	-lBullet3Collision \
+	-lBullet3Common \
+	-lBullet3Dynamics \
+	-lBullet3Geometry \
+	-lBullet3OpenCL_clew \
+	-lBulletCollision \
+	-lBulletDynamics \
+	-lBulletSoftBody \
+	-lLinearMath

bullet/Makefile_params

@@ -0,0 +1,9 @@
+# Bullet
+
+1.  [Introduction](introduction.md)
+1.  [Concepts](concepts.md)
+1.  [Build](build.md)
+1.  [Users](users.md)
+1.  Examples
+    1.  [Hello world](hello_world.cpp)
+1.  [TODO](TODO.md)

bullet/README.md

@@ -0,0 +1,3 @@
+# TODO
+
+- Stairs physics: http://gamedev.stackexchange.com/questions/74794/make-the-player-run-onto-stairs-smoothly

bullet/TODO.md

@@ -0,0 +1,30 @@
+# Alternatives
+
+2009 comparison: <http://physxinfo.com/articles/?page_id=154>
+
+Open source:
+
+- ODE
+- Newton
+
+Proprietary:
+
+- PhysX: bought by NVIDIA from a Swiss company. NVIDIA GPU acceleration.
+    - 2015 Flex demo with lots of water / cloth: <https://www.youtube.com/watch?v=pfonMfP__Ks>
+- Havoc: first bought by Intel from an Irish company, then Microsoft.
+    - Has GPU support.
+    - Used by Assassin's Creed (Ubisoft)
+    - Havoc destruction
+        - car demo 2015: https://www.youtube.com/watch?v=iiRR6DtR1z8
+        - 2010 demo: https://www.youtube.com/watch?v=cIcg5eotZlY
+
+2D:
+
+- Box2D
+
+## Fluids
+
+-   https://github.com/rchoetzlein/fluids3
+    - https://github.com/erwincoumans/fluids_v3
+    - https://en.wikipedia.org/wiki/Smoothed-particle_hydrodynamics
+    - Windows focused build, https://github.com/erwincoumans/fluids_v3/pull/2 might port it to Linux

bullet/alternatives.md

@@ -0,0 +1,35 @@
+# Build
+
+Tested on Ubuntu 2.83.5 in Ubuntu 15.10.
+
+Just forget that `premake` build, use the much more popular CMake and be done with it! Why both exist: <https://github.com/bulletphysics/bullet3/issues/600>
+
+    git clone https://github.com/bulletphysics/bullet3
+    git checkout 2.83.5
+    mkdir -p build
+    cd build
+    cmake .. -DBUILD_SHARED_LIBS=ON
+    make
+    sudo make install
+
+Run examples:
+
+    cd build/examples
+    ./ExampleBrowser/App_ExampleBrowser
+    ./HelloWorld/App_HelloWorld
+
+If you don't use:
+
+    -DBUILD_SHARED_LIBS=ON
+
+only the static `.a` files are generated, and you will get link errors if you try to use them with `-lBulletSomething`.
+
+The example browser allows you to:
+
+- view simulations OpenGL
+- mouse drag objects around
+- move camera with mouse wheel or Ctrl + mouse drag
+
+Make dynamic libraries: <https://github.com/bulletphysics/bullet3/issues/447>
+
+TODO: compile examples without the example browser.

bullet/build.md

@@ -0,0 +1,11 @@
+# Concepts
+
+-   acceleration: continuous speed change, ignores mass
+-   force: continuous speed change, considers mass
+-   impulse: instantaneous speed change, considers mass
+-   velocity change: instantaneous speed change, ignores mass
+-   rag doll physics: https://www.youtube.com/watch?v=XKuleYcVF-U
+    - https://en.wikipedia.org/wiki/Ragdoll_physics
+    - http://www.havok.com/physics/
+    I distinctly remember sing that on a CS:GO game in 2016-04-15, when a dead body fell from a platform
+-   AABB axis-aligned bounding-box http://www.gamasutra.com/view/feature/131833/when_two_hearts_collide_.php

bullet/concepts.md

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+sudo apt-get update
+sudo apt-get install -y libbullet-dev

bullet/configure

@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <btBulletDynamicsCommon.h>
+
+int main() {
+    int i, j;
+
+    btDefaultCollisionConfiguration* collisionConfiguration
+            = new btDefaultCollisionConfiguration();
+    btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);
+    btBroadphaseInterface* overlappingPairCache = new btDbvtBroadphase();
+    btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;
+    btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(
+            dispatcher, overlappingPairCache, solver, collisionConfiguration);
+
+    dynamicsWorld->setGravity(btVector3(0, -10, 0));
+    btCollisionShape* groundShape = new btBoxShape(
+            btVector3(btScalar(50.0), btScalar(50.0), btScalar(50.0)));
+    btAlignedObjectArray<btCollisionShape*> collisionShapes;
+    collisionShapes.push_back(groundShape);
+    btTransform groundTransform;
+    groundTransform.setIdentity();
+    groundTransform.setOrigin(btVector3(0, 0, 0));
+
+    // Shpere at position 0, 10, 0.
+    {
+        btCollisionShape *colShape = new btSphereShape(btScalar(1.0));
+        collisionShapes.push_back(colShape);
+        btTransform startTransform;
+        startTransform.setIdentity();
+        startTransform.setOrigin(btVector3(0, 10, 0));
+        btVector3 localInertia(0, 0, 0);
+        btScalar mass(1.0f);
+        colShape->calculateLocalInertia(mass, localInertia);
+        btDefaultMotionState *myMotionState = new btDefaultMotionState(startTransform);
+        btRigidBody *body = new btRigidBody(btRigidBody::btRigidBodyConstructionInfo(
+                mass, myMotionState, colShape, localInertia));
+        dynamicsWorld->addRigidBody(body);
+    }
+
+    // Main loop. Update state and print it.
+    for (i = 0; i < 100; ++i) {
+        dynamicsWorld->stepSimulation(1.0f / 60.0f, 10);
+        for (j = dynamicsWorld->getNumCollisionObjects() - 1; j >= 0; --j) {
+            btCollisionObject *obj = dynamicsWorld->getCollisionObjectArray()[j];
+            btRigidBody *body = btRigidBody::upcast(obj);
+            btTransform trans;
+            if (body && body->getMotionState()) {
+                body->getMotionState()->getWorldTransform(trans);
+            } else {
+                trans = obj->getWorldTransform();
+            }
+            printf("%d = %7.3f, %7.3f, %7.3f\n",
+                    j,
+                    float(trans.getOrigin().getX()),
+                    float(trans.getOrigin().getY()),
+                    float(trans.getOrigin().getZ()));
+        }
+    }
+
+    // Cleanup.
+    for (i = dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; --i) {
+        btCollisionObject* obj = dynamicsWorld->getCollisionObjectArray()[i];
+        btRigidBody* body = btRigidBody::upcast(obj);
+        if (body && body->getMotionState()) {
+            delete body->getMotionState();
+        }
+        dynamicsWorld->removeCollisionObject( obj );
+        delete obj;
+    }
+    for (i = 0; i < collisionShapes.size(); ++i) {
+        btCollisionShape* shape = collisionShapes[i];
+        collisionShapes[i] = 0;
+        delete shape;
+    }
+    delete dynamicsWorld;
+    delete solver;
+    delete overlappingPairCache;
+    delete dispatcher;
+    delete collisionConfiguration;
+    collisionShapes.clear();
+}

bullet/hello_world.cpp

@@ -0,0 +1,33 @@
+# Introduction
+
+## C API
+
+Bullet is written in C++, and exposes only a C++ API.
+
+A C API has been somewhat considered: <https://github.com/bulletphysics/bullet3/issues/130>
+
+## Android
+
+- <http://stackoverflow.com/questions/6004381/ideas-for-physics-for-rolling-dice>
+- <http://stackoverflow.com/questions/1034253/are-there-any-decent-physics-engines-for-android>
+
+## 2D
+
+TODO: efficient compared to say, Box2D?
+
+- official example classified under experiments in the example browser <https://github.com/bulletphysics/bullet3/blob/2.83/examples/Planar2D/Planar2D.cpp>
+- <http://gamedev.stackexchange.com/questions/6130/is-it-worth-it-to-use-bullet-for-2d-physics-instead-of-box2d-for-the-sake-of-lea>
+- 2D demo https://www.youtube.com/watch?v=CsPgMmgsU7E
+
+## History
+
+Library creator worked at:
+
+- Havok
+- Sony
+- AMD (on Bullet)
+- Google (on Bullet)
+
+<https://www.linkedin.com/in/erwincoumans>
+
+<https://twitter.com/erwincoumans>

bullet/introduction.md

@@ -0,0 +1,6 @@
+# Users
+
+Notables who uses Bullet.
+
+- Blender <https://wiki.blender.org/index.php/User:Sculptorjim/Game_Engine/Physics>
+- libgdx: <https://github.com/libgdx/libgdx/wiki/Bullet-physics>

bullet/users.md

@@ -21,16 +21,35 @@ All of those features allow to:
 
 at the cost of:
 
--   adding huge complexity to the language (probably at least doubles the complexity).
+-   adding huge complexity to the language.
 
-    The problem is that individual features sometimes interact in ways which are not obvious to understand, so the complexity growth is exponential per feature.
+    The C++ standards have twice as many pages as the C standards.
 
--   making it harder to track what assembly code is generated thus:
+-   harder to track what assembly code is generated thus:
 
-    -   making it harder to write very efficient code
+    -   harder to write very efficient code
 
-    -   generating executables that are very large
+    -   generated executables are very large and compilation is slow
 
-        For exmple, at one point I had a 7k line C file whose assembly was 8k lines, but a 7k C++ file generated 55k assembly code lines!!
+        For exmple, at one point I had a 7k line C file whose assembly was 8k lines, but a 7k C++ file generated 55k assembly code lines!
 
-All things considered, C++ offers huge productivity boosts over C *once you learn it*... It should be used on any new project, except if code efficiency is absolutelly crucial, and even in those cases it might be worth it to have a C++ project that use C only features for the 20% critical sections.
+    -   harder to interface with other languages because of name mangling.
+
+        `extern C` reduces the pain a bit: http://stackoverflow.com/questions/1041866/in-c-source-what-is-the-effect-of-extern-c/30526795#30526795
+
+All things considered, C++ offers huge productivity boosts over C *once you learn it*...
+
+It should be used on any new project, except if code efficiency is absolutely crucial, and even in those cases it might be worth it to have a C++ project that use C only features for the 20% critical sections.
+
+## C++11 N3337 standard draft Annex C
+
+Not all behaviour changes in C++ from C are new features!
+
+Some are just deprecation of archaic C ugliness.
+
+This section of the C++ standard lists those differences.
+
+Some examples:
+
+- `static struct` definitions deprecated: <http://stackoverflow.com/questions/7259830/why-and-when-to-use-static-structures-in-c-programming>
+- char literals `a` are... chars, not int: <http://stackoverflow.com/questions/433895/why-are-c-character-literals-ints-instead-of-chars>

c-vs-cpp.md

@@ -17,6 +17,7 @@
     1.  [main function](main_function.c)
     1.  Data
         1.  [Identifier](identifier.c)
+            1.  [Uninitialized variable](uninitialized_variable.c)
         1.  [Types](types.c)
             1.  [Basic types](basic_types.md)
             1.  [Incomplete types](incomplete_type.c)

c/README.md

@@ -1,24 +1,36 @@
+/*
+C11 for clock_gettime
+http://stackoverflow.com/questions/361363/how-to-measure-time-in-milliseconds-using-ansi-c/36095407#36095407
+
+Vs clock: http://stackoverflow.com/questions/12392278/measure-time-in-linux-getrusage-vs-clock-gettime-vs-clock-vs-gettimeofday
+All we know about the clock output is that dividing it by 
+*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
-static long get_nanos() {
+/*
+We use double because time_t can be either floating point or integer.
+POSIX guarantees that it is an integer, we could use uintmax_t then.
+*/
+static long double get_nanos(void) {
     struct timespec ts;
     timespec_get(&ts, TIME_UTC);
-    return (long)ts.tv_sec * 1000000000L + ts.tv_nsec;
+    return ts.tv_sec * 1e9 + ts.tv_nsec;
 }
 
-int main() {
-    long nanos;
-    long last_nanos;
-    long start;
+int main(void) {
+    long double last_nanos;
+    long double nanos;
+    long double start;
     nanos = get_nanos();
     last_nanos = nanos;
     start = nanos;
     while (1) {
         nanos = get_nanos();
-        if (nanos - last_nanos > 1000000L) {
-            printf("current nanos: %ld\n", nanos - start);
+        if (nanos - last_nanos > 1e7) {
+            printf("%Lf\n", nanos - start);
             last_nanos = nanos;
         }
     }