Compile under VS

Author: Tiffany Bennett

IntenseLogic

@@ -7,13 +7,13 @@
 #include <fenv.h>
 #include <vector>
 #include <string>
+#include <memory>
 
 #include "tgl/tgl.h"
 
 extern "C" {
 #include "util/logger.h"
 #include "util/log.h"
-#include "util/version.h"
 #include "util/opt.h"
 #include "graphics/graphics.h"
 }
@@ -32,7 +32,6 @@ const struct {
     const char *l, *h;
 } help[] = {
     {NO_ARG,    'h', "help",    "Prints this message and exits"},
-    {NO_ARG,    'v', "version", "Prints the version and exits"},
     {REQUIRED,  'd', "data",    "Adds a directory to look for data files"},
     {REQUIRED,  's', "shaders", "Adds a directory to look for GLSL shaders"},
     {REQUIRED,  'f', "shader",  "ShaderToy demo: Select shader to load"},
@@ -50,11 +49,10 @@ void demoLoad(int argc, char **argv)
 
     for (i = 0; main_opts && i < main_opts->args.length; i++) {
         il_opt *opt = &main_opts->args.data[i];
-        char *arg = strndup(opt->arg.str, opt->arg.len);
+        std::string arg(opt->arg.str, opt->arg.len);
 #define option(s, l) if (il_string_cmp(opt->name, il_string_new(const_cast<char*>(s))) || \
                          il_string_cmp(opt->name, il_string_new(const_cast<char*>(l))))
         option("h", "help") {
-            printf("IntenseLogic %s\n", il_version);
             printf("Usage: %s [OPTIONS]\n\n", argv[0]);
             printf("Options:\n");
             for (i = 0; help[i].l; i++) {
@@ -78,46 +76,38 @@ void demoLoad(int argc, char **argv)
             }
             exit(0);
         }
-        option("v", "version") {
-            printf("IntenseLogic %s\n", il_version);
-            printf("Commit: %s\n", il_commit);
-            printf("Built: %s\n", il_build_date);
-            exit(0);
-        }
         option("d", "data") {
-            ilA_adddir(&demo_fs, arg, -1);
+            ilA_adddir(&demo_fs, arg.c_str(), -1);
         }
         option("s", "shaders") {
-            ilG_shaders_addPath(arg);
+            ilG_shaders_addPath(arg.c_str());
         }
         option("f", "shader") {
-            demo_shader = arg;
-            continue; // don't free arg
+            demo_shader = std::move(arg);
         }
         option("", "fpe") {
+#ifdef _WIN32
+            _controlfp(_EM_INVALID | _EM_ZERODIVIDE | _EM_OVERFLOW, _MCW_EM);
+#else
             feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
+#endif
             il_log("Floating point exceptions enabled");
         }
-        free(arg);
     }
 
     ilG_shaders_addPath("shaders");
     ilG_shaders_addPath("IntenseLogic/shaders");
 
     il_log("Initializing engine.");
-    il_log("IntenseLogic %s", il_version);
-    il_log("IL Commit: %s", il_commit);
-    il_log("Built %s", il_build_date);
-
     il_load_ilgraphics();
 }
 
 struct DebugGroupStack {
     vector<string> entries;
 };
 
-static GLvoid error_cb(GLenum esource, GLenum etype, GLuint id, GLenum eseverity,
-                       GLsizei length, const GLchar* message, const GLvoid* user)
+static GLvoid APIENTRY error_cb(GLenum esource, GLenum etype, GLuint id, GLenum eseverity,
+                                GLsizei length, const GLchar* message, const GLvoid* user)
 {
     auto &stack = *reinterpret_cast<DebugGroupStack*>(const_cast<void*>(user));
     const char *ssource;
@@ -228,5 +218,38 @@ Window createWindow(const char *title, unsigned msaa)
     return window;
 }
 
+#ifdef _WIN32
+
+int main(int argc, char **argv);
+
+int CALLBACK WinMain(
+    _In_ HINSTANCE hInstance,
+    _In_ HINSTANCE hPrevInstance,
+    _In_ LPSTR     lpCmdLine,
+    _In_ int       nCmdShow)
+{
+    LPWSTR lpwCmdLine = NULL;
+    int len = MultiByteToWideChar(CP_UTF8, MB_PRECOMPOSED, lpCmdLine, -1, lpwCmdLine, 0);
+    lpwCmdLine = new WCHAR[len];
+    MultiByteToWideChar(CP_UTF8, MB_PRECOMPOSED, lpCmdLine, -1, lpwCmdLine, len);
+    int argc;
+    LPWSTR *argvw = CommandLineToArgvW(lpwCmdLine, &argc);
+    delete[] lpwCmdLine;
+    LPSTR *argv = new LPSTR[argc];
+    for (int i = 0; i < argc; i++) {
+        int len = WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS | WC_COMPOSITECHECK | WC_DEFAULTCHAR, argvw[i], -1, argv[i], 0, NULL, NULL);
+        argv[i] = new CHAR[len + 1];
+        argv[i][len] = 0;
+        WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS | WC_COMPOSITECHECK | WC_DEFAULTCHAR, argvw[i], -1, argv[i], len, NULL, NULL);
+    }
+    LocalFree(argvw);
+    main(argc, argv);
+    for (int i = 0; i < argc; i++) {
+        delete[] argv[i];
+    }
+}
+
+#endif
+
 ilA_fs demo_fs;
-const char *demo_shader;
+std::string demo_shader;

src/Demo.cpp

@@ -3,6 +3,7 @@
 
 #include <SDL.h>
 #include <utility>
+#include <string>
 
 #include "tgl/tgl.h"
 
@@ -32,6 +33,6 @@ struct Window {
 Window createWindow(const char *title, unsigned msaa = 0);
 
 extern ilA_fs demo_fs;
-extern const char *demo_shader;
+extern std::string demo_shader;
 
 #endif

src/Demo.h

@@ -31,7 +31,7 @@ bool Graphics::init(const Flags &flags)
     }
     initialized = true;
 
-    ilG_renderman_setup(rm, flags.msaa, flags.hdr);
+    ilG_renderman_setup(rm, flags.msaa != 0, flags.hdr);
     ilG_renderman_resize(rm, 800, 600);
     glClampColor(GL_CLAMP_READ_COLOR, GL_FALSE);
 
@@ -76,17 +76,17 @@ bool Graphics::init(const Flags &flags)
         ::free(error);
         return false;
     }
-    if (!ilG_lighting_build(&sun, rm, &ico, ILG_SUN, flags.msaa, &error)) {
+    if (!ilG_lighting_build(&sun, rm, &ico, ILG_SUN, flags.msaa != 0, &error)) {
         il_error("sunlighting: %s", error);
         ::free(error);
         return false;
     }
-    if (!ilG_lighting_build(&point, rm, &ico, ILG_POINT, flags.msaa, &error)) {
+    if (!ilG_lighting_build(&point, rm, &ico, ILG_POINT, flags.msaa != 0, &error)) {
         il_error("lighting: %s", error);
         ::free(error);
         return false;
     }
-    if (!ilG_tonemapper_build(&tonemapper, rm, flags.msaa, &error)) {
+    if (!ilG_tonemapper_build(&tonemapper, rm, flags.msaa != 0, &error)) {
         il_error("tonemapper: %s", error);
         ::free(error);
         return false;

src/Graphics.cpp

@@ -16,10 +16,10 @@ struct State {
     bool mouse_grab = false;
     bool vsync = true;
     il_mat projection;
-    float fov = M_PI / 4;
-    float zmin = 0.5, zfar = 1024.0;
-    il_vec3 ambient_col = il_vec3_new(.2,.2,.2);
-    float exposure = 1.0, gamma = 1.0;
+    float fov = float(M_PI) / 4.f;
+    float zmin = 0.5f, zfar = 1024.f;
+    il_vec3 ambient_col = il_vec3_new(.2f,.2f,.2f);
+    float exposure = 1.f, gamma = 1.f;
 
     unsigned *sunlight_locs = nullptr;
     ilG_light *sunlight_lights = nullptr;

src/Graphics.h

@@ -9,8 +9,7 @@
 #include <utility>
 #include <ctime>
 #include <math.h>
-
-#include <experimental/optional>
+#include <random>
 
 #include "tgl/tgl.h"
 #include "debugdraw.hpp"
@@ -38,11 +37,6 @@ extern "C" {
 
 const btScalar arenaWidth = 128;
 
-float rand_float(unsigned *seedp)
-{
-    return (float)rand_r(seedp) / RAND_MAX;
-}
-
 struct Scene : public Drawable {
     Scene(BulletSpace &space)
         : space(space) {}
@@ -51,7 +45,7 @@ struct Scene : public Drawable {
     vector<BulletSpace::BodyID> bodies;
     vector<il_vec3> colors;
     vector<ilG_light> lights;
-    experimental::optional<BulletSpace::BodyID> heightmap_body;
+    BulletSpace::BodyID heightmap_body = BulletSpace::BodyID(0);
     ilG_heightmap heightmap;
     BallRenderer ball;
     btSphereShape sphere_shape = btSphereShape(1);
@@ -62,13 +56,13 @@ struct Scene : public Drawable {
         btStaticPlaneShape(btVector3( 0, 0, -1), 1)
     };
     btDefaultMotionState ground_motion_state[4], heightmap_motion_state;
-    experimental::optional<btHeightfieldTerrainShape> heightmap_shape;
+    btHeightfieldTerrainShape *heightmap_shape;
 
     void draw(Graphics &graphics) override {
         (void)graphics;
         il_mat hmvp, himt;
-        space.objmats(&hmvp, &*heightmap_body, ILG_MVP, 1);
-        space.objmats(&himt, &*heightmap_body, ILG_IMT, 1);
+        space.objmats(&hmvp, &heightmap_body, ILG_MVP, 1);
+        space.objmats(&himt, &heightmap_body, ILG_IMT, 1);
         ilG_heightmap_draw(&heightmap, hmvp, himt);
 
         vector<il_mat> mvp, imt;
@@ -112,17 +106,17 @@ struct Scene : public Drawable {
         // Physics
         /////////////////////
         const unsigned height = 50;
-        heightmap_shape = btHeightfieldTerrainShape(hm.width, hm.height, hm.data, height/255.f, 0,
-                                                    height, 1, PHY_UCHAR, false);
+        heightmap_shape = new btHeightfieldTerrainShape(hm.width, hm.height, hm.data, height/255.f, 0,
+                                                        height, 1, PHY_UCHAR, false);
         heightmap_shape->setLocalScaling(btVector3(arenaWidth/hm.width, 1, arenaWidth/hm.height));
         btTransform trans = btTransform(btQuaternion(0,0,0,1),
                                         btVector3(arenaWidth/2, height/2, arenaWidth/2));
         heightmap_motion_state = trans;
         btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI
             (0, &heightmap_motion_state, &*heightmap_shape, btVector3(0,0,0));
         heightmap_body = space.add(groundRigidBodyCI);
-        space.getBody(*heightmap_body).setRestitution(1.0);
-        space.setBodyScale(*heightmap_body, il_vec3_new(128, 50, 128));
+        space.getBody(heightmap_body).setRestitution(1.0);
+        space.setBodyScale(heightmap_body, il_vec3_new(128, 50, 128));
         // Rendering
         ///////////////////////
         ilA_img norm;
@@ -164,12 +158,16 @@ struct Scene : public Drawable {
 
     void populate(size_t count) {
         unsigned seed;
+        std::default_random_engine gen;
+        std::uniform_int_distribution<> mod128(0, 127);
+        std::uniform_int_distribution<> from50to75(50, 75);
+        std::uniform_real_distribution<> unit(0.f, 1.f);
         for (size_t i = 0; i < count; i++) {
             // Physics body
-            btVector3 position
-                (rand_r(&seed) % 128,
-                 rand_r(&seed) % 32 + 50,
-                 rand_r(&seed) % 128);
+            btVector3 position(
+                mod128(gen),
+                from50to75(gen),
+                mod128(gen));
             auto state = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1), position));
             float mass = 1.f;
             btVector3 inertia(0,0,0);
@@ -179,11 +177,11 @@ struct Scene : public Drawable {
             space.getBody(id).setRestitution(1.0);
 
             // Color
-            float brightness = rand_float(&seed) + 1;
+            float brightness = unit(gen) + 1;
             auto col = il_vec3_new(
-                rand_float(&seed) * brightness,
-                rand_float(&seed) * brightness,
-                rand_float(&seed) * brightness);
+                unit(gen) * brightness,
+                unit(gen) * brightness,
+                unit(gen) * brightness);
 
             // Light
             ilG_light light;

src/bouncing-lights/bouncinglights.cpp

@@ -26,12 +26,13 @@ struct BulletSpace {
 
 public:
     class BodyID {
-        BodyID(unsigned id) : id(id) {}
         unsigned id;
         friend BulletSpace;
+
     public:
-        unsigned value() const
-        {
+        BodyID(unsigned id) : id(id) {}
+
+        unsigned value() const {
             return id;
         }
     };

src/bouncing-lights/bulletspace.hpp

@@ -1,7 +1,7 @@
 #include <SDL.h>
 #include <time.h>
-#include <sys/time.h>
 #include <math.h>
+#include <chrono>
 
 #include "Demo.h"
 
@@ -63,6 +63,8 @@ static const float cube[] = {
     1.0, -1.0,  1.0,
 };
 
+using namespace std;
+
 int main(int argc, char **argv)
 {
     demoLoad(argc, argv);
@@ -100,7 +102,7 @@ int main(int argc, char **argv)
 
     ilG_floatspace fs;
     ilG_floatspace_init(&fs, 1);
-    fs.projection = il_mat_perspective(M_PI / 4.0, 4.0/3, .5, 200);
+    fs.projection = il_mat_perspective(float(M_PI / 4.f), 4.f/3, .5f, 200.f);
 
     il_pos_setPosition(&fs.camera, il_vec3_new(0, 0, 5));
 
@@ -111,6 +113,10 @@ int main(int argc, char **argv)
     glBindBuffer(GL_ARRAY_BUFFER, vbo);
     glEnable(GL_DEPTH_TEST);
 
+    typedef chrono::steady_clock clock;
+    typedef chrono::duration<double> duration;
+
+    clock::time_point start = clock::now();
     while (1) {
         SDL_Event ev;
         while (SDL_PollEvent(&ev)) {
@@ -124,15 +130,14 @@ int main(int argc, char **argv)
             }
         }
 
-        struct timeval ts;
-        gettimeofday(&ts, NULL);
-        int secs = 5;
-        float delta = ((float)(ts.tv_sec%secs) + ts.tv_usec / 1000000.0) / secs;
+        duration delta = clock::now() - start;
         il_vec3 v;
-        v.x = sinf(delta * M_PI * 2) * 5;
-        v.y = 0;
-        v.z = cosf(delta * M_PI * 2) * 5;
-        il_quat q = il_quat_fromAxisAngle(0, 1, 0, delta * M_PI * 2);
+        const float secs = 5.f;
+        const float dist = 5.f;
+        v.x = float(sin(delta.count() * M_PI * 2.0 / secs) * dist);
+        v.y = 0.f;
+        v.z = float(cos(delta.count() * M_PI * 2.0 / secs) * dist);
+        il_quat q = il_quat_fromAxisAngle(0, 1, 0, float(delta.count() * M_PI * 2 / secs));
         il_pos_setPosition(&fs.camera, v);
         il_pos_setRotation(&fs.camera, q);