add markdownlint conf, apply format.

Author: dlyr

.github/workflows/pull-request-ci.yml

@@ -63,6 +63,7 @@ jobs:
           mkdir -p "${{ steps.paths.outputs.external_install_dir }}"
 
       - name: Clone Radium
+        id: sha
         run: |
           git clone --recurse-submodules https://github.com/STORM-IRIT/Radium-Engine.git --single-branch ${{ env.src_prefix }}/Radium-Engine
           radium_sha=`git -C ${{ env.src_prefix }}/Radium-Engine rev-parse --short HEAD`

.markdownlint.yaml

@@ -0,0 +1,12 @@
+# https://github.com/DavidAnson/markdownlint/blob/main/schema/.markdownlint.yaml
+default: true
+MD002: false
+MD033: false
+
+MD013:
+  line_length: 520
+  code_block_line_length: 200
+MD034: true
+MD041: false
+# link fragments from php markdown are not recognized
+MD051: false

CLISubdivider/README.md

@@ -1,8 +1,9 @@
 # Radium Subdivider Command-Line Interface
 
-Load a triangle mesh and subdivide it using OpenMesh. 
+Load a triangle mesh and subdivide it using OpenMesh.
 
 ## CLI parameters
+
 ```cpp
 std::cout << "Usage :\n"
           << argv[0] << " -i input.obj -o output -s type -n iteration  \n\n"
@@ -14,43 +15,47 @@ std::cout << "Usage :\n"
             "iteration of subdivision\n\n";
 ```
 
-
 ## Code breakdown
+
 Excluding command parsing, only very few steps are required to load, simplify and save the object:
 
- 1. Load triangular mesh or generate 
-```cpp
-Ra::Core::Geometry::TriangleMesh mesh;
-Ra::IO::OBJFileManager obj;
+1. Load triangular mesh or generate
 
-// Load geometry as triangle
-if ( inputFilename.empty() ) { mesh = Ra::Core::Geometry::makeBox(); }
-else                         { obj.load( inputFilename, mesh ); }
-```
+    ```cpp
+    Ra::Core::Geometry::TriangleMesh mesh;
+    Ra::IO::OBJFileManager obj;
 
- 2. Create topological structure from the loaded geometry, and OpenMesh datastructures.
-```cpp
-// Create topological structure
-Ra::Core::Geometry::TopologicalMesh topologicalMesh( mesh );
+    // Load geometry as triangle
+    if ( inputFilename.empty() ) { mesh = Ra::Core::Geometry::makeBox(); }
+    else                         { obj.load( inputFilename, mesh ); }
+    ```
 
-// Create CatmullClarkSubdivider
-using Subdivider = 
-OpenMesh::Subdivider::Uniform::SubdividerT<Ra::Core::Geometry::TopologicalMesh, Scalar>; 
-Subdiviser subdiviser(Ra::Core::Geometry::CatmullClarkSubdivider);
-```
+2. Create topological structure from the loaded geometry, and OpenMesh datastructures.
 
- 3. Create OpenMesh subdivider and process geometry
-```cpp
-subdivider.attach( topologicalMesh );
-subdivider( nIter );
-subdivider.detach();
-```
+    ```cpp
+    // Create topological structure
+    Ra::Core::Geometry::TopologicalMesh topologicalMesh( mesh );
 
- 4. Convert and save simplified geometry 
-```cpp
-// Convert processed topological structure to triangle mesh
-mesh = topologicalMesh.toTriangleMesh();
+    // Create CatmullClarkSubdivider
+    using Subdivider =
+    OpenMesh::Subdivider::Uniform::SubdividerT<Ra::Core::Geometry::TopologicalMesh, Scalar>;
+    Subdiviser subdiviser(Ra::Core::Geometry::CatmullClarkSubdivider);
+    ```
+
+3. Create OpenMesh subdivider and process geometry
+
+    ```cpp
+    subdivider.attach( topologicalMesh );
+    subdivider( nIter );
+    subdivider.detach();
+    ```
+
+4. Convert and save simplified geometry
+
+    ```cpp
+    // Convert processed topological structure to triangle mesh
+    mesh = topologicalMesh.toTriangleMesh();
 
-// Save triangle mesh to obj file
-obj.save( outputFilename, mesh );
-```
+    // Save triangle mesh to obj file
+    obj.save( outputFilename, mesh );
+    ```

README.md

@@ -1,45 +1,52 @@
 # Radium Applications
+
 Radium is a research 3D Engine for rendering, animation and processing.
 It is developed and maintained by the [STORM research group](https://www.irit.fr/STORM/site/).
 
 This repository holds front-end applications (GUI, command line) based on Radium Libraries
- - Sandbox: Graphical frontend of the Radium Engine. This application aims at demonstrating the capabilities of the Radium Libraries. It can be extended using Radium plugins.
- - CLISubdivider: Example of command line application. Loads obj files and run subdivision algorithms implemented with OpenMesh.
- 
+
+- Sandbox: Graphical frontend of the Radium Engine. This application aims at demonstrating the capabilities of the Radium Libraries. It can be extended using Radium plugins.
+- CLISubdivider: Example of command line application. Loads obj files and run subdivision algorithms implemented with OpenMesh.
+
 To get more details about each application, checkout the Readme files in each application directory.
 
-# How to get these applications
-## Pre-compiled binaries
-Pre-compiled binaries can be downloaded from https://github.com/STORM-IRIT/Radium-Releases/releases/.
+## How to get these applications
+
+### Pre-compiled binaries
+
+Pre-compiled binaries can be downloaded from <https://github.com/STORM-IRIT/Radium-Releases/releases/>.
 
 The downloaded archive contains:
- - Radium libraries
- - Radium example applications (this repository)
 
-## Compilation instructions
+- Radium libraries
+- Radium example applications (this repository)
+
+### Compilation instructions
+
 To compile this repository, you first need to compile and install the [Radium libraries](https://github.com/STORM-IRIT/Radium-Engine).
-Then, configure this project using cmake. 
-You need to tell cmake where to find the installed Radium package by setting the `Radium_DIR` variable to the right location (see more details in Radium Engine documentation: https://storm-irit.github.io/Radium-Engine/).
+Then, configure this project using cmake.
+You need to tell cmake where to find the installed Radium package by setting the `Radium_DIR` variable to the right location (see more details in Radium Engine documentation: <https://storm-irit.github.io/Radium-Engine/>).
 
+## How to write your own application
 
-# How to write your own application
 This repository also demonstrate how to write applications and extend Radium ecosystem.
 Radium provides a set of tools simplifying the deployment of such applications,
 which among other things take care of the portability and relocatability of the
 binaries.
 
-Other minimal application examples are available at https://github.com/STORM-IRIT/Radium-Engine/tree/master/tests/ExampleApps.
+Other minimal application examples are available at <https://github.com/STORM-IRIT/Radium-Engine/tree/master/tests/ExampleApps>.
 
 In order to write your own application, you need to follow theses instructions.
 
+### Setting a CMakeLists.txt to compile and install an application
 
-## Setting a CMakeLists.txt to compile and install an application
 To compile and execute an application, either in the build tree
 or after installation, the Radium environment must be configured,
 compiled and installed beforehand.
 
 The main CMakeLists.txt file for compiling a Radium Based application
 could be as simple as
+
 ```cmake
 # set the minimal cmake version supported by Radium cmake system
 cmake_minimum_required(VERSION 3.6)
@@ -82,18 +89,22 @@ configure_radium_app(
 )
 ```
 
-### Configure the application
+#### Configure the application
+
 Radium does not support in-source builds (it is bad practice anyway).
 You then must first create a buid directory that will be the root of the buildtree.
 
-    mkdir build
-    cd build
+```bash
+mkdir build
+cd build
+```
 
 If the Radium environment was installed in the directory `pathToRadiumInstallation`,
 configure the project with :
 
-    cmake ../ -DRadium_DIR=pathToRadiumInstallation/lib/cmake/Radium
-
+```bash
+cmake ../ -DRadium_DIR=pathToRadiumInstallation/lib/cmake/Radium
+```
 
 By default, the application will be installed in a directory
 called `installed-<Compiler_id>` in the application buildtree. This installed