jdduke · Lecrapouille · Mar 11, 2021 · Apr 10, 2021
diff --git a/.clang-format b/.clang-format
@@ -0,0 +1,14 @@
+BasedOnStyle: WebKit
+AlignAfterOpenBracket: Align
+AllowShortIfStatementsOnASingleLine: true
+BraceWrapping:
+  AfterClass: true
+  AfterControlStatement: true
+  AfterFunction: true
+  AfterStruct: true
+  BeforeElse: true
+BreakBeforeBraces: Custom
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+IndentPPDirectives: AfterHash
+MaxEmptyLinesToKeep: 2
+SortIncludes: false
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -46,7 +46,7 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLAN
     set(THREE_SIZE_TYPE x86 CACHE INTERNAL "" FORCE)
   endif()
 
-  set(THREE_COMMON_FLAGS "${THREE_COMMON_FLAGS} -Wall -Wno-missing-braces -Wno-unused-private-field")
+  set(THREE_COMMON_FLAGS "${THREE_COMMON_FLAGS} -Wall -Wno-missing-braces -Wno-unused-private-field -Wno-unused-result")
 
   if(THREE_TREAT_WARNINGS_AS_ERRORS)
     set(THREE_COMMON_FLAGS "${THREE_COMMON_FLAGS} -Werror")

diff --git a/examples/common.hpp b/examples/common.hpp
@@ -16,30 +16,35 @@
 
 namespace three {
 
-struct ExampleSession {
-
-  ExampleSession(  three::RendererParameters parameters = three::RendererParameters() ) {
-    if ( !three::sdl::init( parameters ) || !three::glew::init( parameters ) ) {
-      return;
+struct ExampleSession
+{
+
+    ExampleSession(three::RendererParameters parameters = three::RendererParameters())
+    {
+        if (!three::sdl::init(parameters) || !three::glew::init(parameters))
+        {
+            return;
+        }
+        renderer = three::GLRenderer::create(parameters);
     }
-    renderer = three::GLRenderer::create( parameters );
-  }
 
-  ~ExampleSession() {
-    three::sdl::quit();
-  }
+    ~ExampleSession()
+    {
+        three::sdl::quit();
+    }
 
-  template < typename Example >
-  void run( Example example ) {
-    if ( renderer )
-      example( renderer );
-  }
+    template <typename Example>
+    void run(Example example)
+    {
+        if (renderer)
+            example(renderer);
+    }
 
 private:
-  ExampleSession(ExampleSession&);
-  ExampleSession& operator=(ExampleSession&);
+    ExampleSession(ExampleSession&);
+    ExampleSession& operator=(ExampleSession&);
 
-  three::GLRenderer::Ptr renderer;
+    three::GLRenderer::Ptr renderer;
 };
 
 } // namespace three

diff --git a/examples/custom_attributes_particles.cpp b/examples/custom_attributes_particles.cpp
@@ -9,172 +9,172 @@
 #include <three/renderers/renderer_parameters.hpp>
 #include <three/renderers/gl_renderer.hpp>
 
-const std::string vertexShader =
-"attribute float size;\n"
-"attribute vec3 customColor;\n"
-"varying vec3 vColor;\n"
-"void main() {\n"
-"  vColor = customColor;\n"
-"  vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n"
-"  //gl_PointSize = size;\n"
-"  gl_PointSize = size * ( 300.0 / length( mvPosition.xyz ) );\n"
-"  gl_Position = projectionMatrix * mvPosition;\n"
-"}\n";
-
-const std::string fragmentShader =
-"\n"
-"uniform vec3 color;\n"
-"uniform sampler2D texture;\n"
-"varying vec3 vColor;\n"
-"void main() {\n"
-"  gl_FragColor = vec4( color * vColor, 1.0 );\n"
-"  gl_FragColor = gl_FragColor * texture2D( texture, gl_PointCoord );\n"
-"}\n";
+const std::string vertexShader = "attribute float size;\n"
+                                 "attribute vec3 customColor;\n"
+                                 "varying vec3 vColor;\n"
+                                 "void main() {\n"
+                                 "  vColor = customColor;\n"
+                                 "  vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n"
+                                 "  //gl_PointSize = size;\n"
+                                 "  gl_PointSize = size * ( 300.0 / length( mvPosition.xyz ) );\n"
+                                 "  gl_Position = projectionMatrix * mvPosition;\n"
+                                 "}\n";
+
+const std::string fragmentShader = "\n"
+                                   "uniform vec3 color;\n"
+                                   "uniform sampler2D texture;\n"
+                                   "varying vec3 vColor;\n"
+                                   "void main() {\n"
+                                   "  gl_FragColor = vec4( color * vColor, 1.0 );\n"
+                                   "  gl_FragColor = gl_FragColor * texture2D( texture, gl_PointCoord );\n"
+                                   "}\n";
 
 using namespace three;
 
-void shader( GLRenderer::Ptr renderer ) {
-
- auto camera = PerspectiveCamera::create(
-    60, ( float )renderer->width() / renderer->height(), 1, 10000
-  );
-  camera->position.z = 300;
-
-  auto scene = Scene::create();
-  auto texture = ImageUtils::loadTexture( threeDataPath( "textures/sprites/spark1.png" ) );
-
-  Uniforms uniforms;
-  uniforms[ "color" ]      = Uniform( THREE::c, Color( 0xffffff ) );
-  uniforms[ "texture" ]    = Uniform( THREE::t, texture.get() );
-
-  Attributes attributes;
-  attributes[ "size" ]        = Attribute( THREE::f );
-  attributes[ "customColor" ] = Attribute( THREE::c );
-
-  auto shaderMaterial = ShaderMaterial::create(
-    vertexShader,
-    fragmentShader,
-    uniforms,
-    attributes,
-    Material::Parameters().add( "blending", THREE::AdditiveBlending )
-                          .add( "depthTest", false )
-                          .add( "transparent", true )
-  );
-
-  // Geometries
-  const auto radius = 200.f;
-  const auto pointCount = 100000;
-
-  auto geometry = Geometry::create();
-
-  auto& vertices = geometry->vertices;
-  vertices.reserve( pointCount );
-
-  std::generate_n(
-    std::back_inserter(vertices),
-    pointCount,
-    [=]() -> Vector3 {
-      return Vector3( Math::random(-1.f, 1.f),
-                      Math::random(-1.f, 1.f),
-                      Math::random(-1.f, 1.f) ).multiplyScalar( radius );
-    }
-  );
+void shader(GLRenderer::Ptr renderer)
+{
+
+    auto camera = PerspectiveCamera::create(
+        60, (float)renderer->width() / renderer->height(), 1, 10000);
+    camera->position.z = 300;
 
-  auto sphere = ParticleSystem::create( geometry, shaderMaterial );
-  sphere->geometry->dynamic = true;
-  sphere->sortParticles = false;
+    auto scene = Scene::create();
+    auto texture = ImageUtils::loadTexture(threeDataPath("textures/sprites/spark1.png"));
 
-  std::vector<float> values_size( pointCount );
-  std::vector<Color> values_color( pointCount );
+    Uniforms uniforms;
+    uniforms["color"] = Uniform(THREE::c, Color(0xffffff));
+    uniforms["texture"] = Uniform(THREE::t, texture.get());
 
-  for ( int v = 0; v < pointCount; v++ ) {
+    Attributes attributes;
+    attributes["size"] = Attribute(THREE::f);
+    attributes["customColor"] = Attribute(THREE::c);
 
-    values_size[ v ] = 10;
-    values_color[ v ].setHex( 0xffaa00 );
+    auto shaderMaterial = ShaderMaterial::create(
+        vertexShader,
+        fragmentShader,
+        uniforms,
+        attributes,
+        Material::Parameters().add("blending", THREE::AdditiveBlending).add("depthTest", false).add("transparent", true));
 
-    if ( vertices[ v ].x < 0 )
-      values_color[ v ].setHSV( 0.5f + 0.1f * ( (float)v / pointCount ), 0.7f, 0.9f );
-    else
-      values_color[ v ].setHSV( 0.0f + 0.1f * ( (float)v / pointCount), 0.9f, 0.9f );
+    // Geometries
+    const auto radius = 200.f;
+    const auto pointCount = 100000;
 
-  }
+    auto geometry = Geometry::create();
 
-  auto& size  = shaderMaterial->attributes[ "size" ];
-  auto& color = shaderMaterial->attributes[ "customColor" ];
+    auto& vertices = geometry->vertices;
+    vertices.reserve(pointCount);
 
-  size.value  = values_size;
-  color.value = values_color;
+    std::generate_n(
+        std::back_inserter(vertices),
+        pointCount,
+        [=]() -> Vector3 {
+            return Vector3(Math::random(-1.f, 1.f),
+                           Math::random(-1.f, 1.f),
+                           Math::random(-1.f, 1.f))
+                .multiplyScalar(radius);
+        });
 
-  scene->add( sphere );
+    auto sphere = ParticleSystem::create(geometry, shaderMaterial);
+    sphere->geometry->dynamic = true;
+    sphere->sortParticles = false;
 
-  /////////////////////////////////////////////////////////////////////////
+    std::vector<float> values_size(pointCount);
+    std::vector<Color> values_color(pointCount);
 
-  auto running = true, renderStats = true;
-  sdl::addEventListener( SDL_KEYDOWN, [&]( const sdl::Event& e ) {
-    switch (e.key.keysym.sym) {
-    case SDLK_q:
-    case SDLK_ESCAPE:
-      running = false; break;
-    default:
-      renderStats = !renderStats; break;
-    };
-  } );
+    for (int v = 0; v < pointCount; v++)
+    {
 
-  sdl::addEventListener( SDL_QUIT, [&]( const sdl::Event& ) {
-    running = false;
-  } );
+        values_size[v] = 10;
+        values_color[v].setHex(0xffaa00);
 
-  sdl::addEventListener( SDL_VIDEORESIZE, [&]( const sdl::Event event ) {
-    camera->aspect = ( float )event.resize.w / event.resize.h;
-    camera->updateProjectionMatrix();
-    renderer->setSize( event.resize.w, event.resize.h );
-  } );
+        if (vertices[v].x < 0)
+            values_color[v].setHSV(0.5f + 0.1f * ((float)v / pointCount), 0.7f, 0.9f);
+        else
+            values_color[v].setHSV(0.0f + 0.1f * ((float)v / pointCount), 0.9f, 0.9f);
+    }
 
-  /////////////////////////////////////////////////////////////////////////
+    auto& size = shaderMaterial->attributes["size"];
+    auto& color = shaderMaterial->attributes["customColor"];
 
-  stats::Stats stats( *renderer );
-  auto time = 0.f;
+    size.value = values_size;
+    color.value = values_color;
 
-  anim::gameLoop( [&]( float dt ) -> bool {
+    scene->add(sphere);
 
-    time += dt;
-    sphere->rotation.z = time * .03f;
+    /////////////////////////////////////////////////////////////////////////
 
-    auto& sizes = size.value.cast<std::vector<float>>();
-    for( size_t i = 0; i < sizes.size(); i++ ) {
-      sizes[ i ] = 10.f + 9.f * Math::sin( 0.1f * i + time * 3.f );
-    }
-    size.needsUpdate = true;
+    auto running = true, renderStats = true;
+    sdl::addEventListener(SDL_KEYDOWN, [&](const sdl::Event& e) {
+        switch (e.key.keysym.sym)
+        {
+        case SDLK_q:
+        case SDLK_ESCAPE:
+            running = false;
+            break;
+        default:
+            renderStats = !renderStats;
+            break;
+        };
+    });
+
+    sdl::addEventListener(SDL_QUIT, [&](const sdl::Event&) {
+        running = false;
+    });
+
+    sdl::addEventListener(SDL_VIDEORESIZE, [&](const sdl::Event event) {
+        camera->aspect = (float)event.resize.w / event.resize.h;
+        camera->updateProjectionMatrix();
+        renderer->setSize(event.resize.w, event.resize.h);
+    });
+
+    /////////////////////////////////////////////////////////////////////////
 
-    renderer->render( *scene, *camera );
+    stats::Stats stats(*renderer);
+    auto time = 0.f;
 
-    stats.update( dt, renderStats );
+    anim::gameLoop([&](float dt) -> bool {
+        time += dt;
+        sphere->rotation.z = time * .03f;
 
-    return running;
+        auto& sizes = size.value.cast<std::vector<float>>();
+        for (size_t i = 0; i < sizes.size(); i++)
+        {
+            sizes[i] = 10.f + 9.f * Math::sin(0.1f * i + time * 3.f);
+        }
+        size.needsUpdate = true;
 
-  }, 2000 );
+        renderer->render(*scene, *camera);
 
+        stats.update(dt, renderStats);
+
+        return running;
+    },
+                   2000);
 }
 
-int main( int argc, char* argv[] ) {
+int main(int argc, char* argv[])
+{
 
-  auto onQuit = defer( sdl::quit );
+    auto onQuit = defer(sdl::quit);
 
-  RendererParameters parameters;
-  parameters.clearColor = Color( 0x000000 );
-  parameters.clearAlpha = 1.f;
-  parameters.vsync = false;
+    RendererParameters parameters;
+    parameters.clearColor = Color(0x000000);
+    parameters.clearAlpha = 1.f;
+    parameters.vsync = false;
 
-  if ( !sdl::init( parameters ) || !glew::init( parameters ) ) {
-    return 0;
-  }
+    if (!sdl::init(parameters) || !glew::init(parameters))
+    {
+        return 0;
+    }
 
-  auto renderer = GLRenderer::create( parameters );
-  if ( !renderer ) {
-    return 0;
-  }
+    auto renderer = GLRenderer::create(parameters);
+    if (!renderer)
+    {
+        return 0;
+    }
 
-  shader( renderer );
+    shader(renderer);
 
-  return 0;
+    return 0;
 }