0.2.2.

.gitignore

@@ -1,3 +1,3 @@
-/target
+**/target
 **/*.rs.bk
 Cargo.lock

.travis.yml

@@ -12,6 +12,13 @@ os:
 script:
   - rustc --version
   - cargo --version
+  - echo "Testing default crate configuration"
   - cargo build --verbose
-  - cargo test --lib --verbose
+  - cargo test --verbose
   - cd examples && cargo check --verbose
+  - echo "Testing feature serialization"
+  - cargo build --verbose --features serialization
+  - cargo test --verbose --features serialization
+  - echo "Testing without std"
+  - cargo build --verbose --no-default-features
+  - cargo test --verbose --no-default-features

CHANGELOG.md

@@ -0,0 +1,34 @@
+## 0.2.2
+
+> Sun 30th September 2018
+
+  - Bump version numbers (`splines-0.2`) in examples.
+  - Fix several typos in the documentation.
+
+## 0.2.1
+
+> Thu 20th September 2018
+
+  - Enhance the features documentation.
+
+# 0.2
+
+> Thu 6th September 2018
+
+  - Add the `"std"` feature gate, that can be used to compile with the standard library.
+  - Add the `"impl-cgmath"` in order to make it optional, if wanted, the `cgmath` dependency.
+  - Enhance the documentation.
+
+## 0.1.1
+
+> Wed 8th August 2018
+
+  - Add a feature gate, `"serialization"`, that can be used to automatically derive `Serialize` and
+    `Deserialize` from the [serde](https://crates.io/crates/serde) crate.
+  - Enhance the documentation.
+
+# 0.1
+
+> Sunday 5th August 2018
+
+  - Initial revision.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "splines"
-version = "0.1.0"
+version = "0.2.2"
 license = "BSD-3-Clause"
 authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
 description = "Spline interpolation made easy"
@@ -17,5 +17,20 @@ is-it-maintained-issue-resolution = { repository = "phaazon/splines" }
 is-it-maintained-open-issues = { repository = "phaazon/splines" }
 maintenance = { status = "actively-developed" }
 
-[dependencies]
-cgmath = "0.16"
+[features]
+default = ["std", "impl-cgmath"]
+serialization = ["serde", "serde_derive"]
+std = []
+impl-cgmath = ["cgmath"]
+
+[dependencies.cgmath]
+version = "0.16"
+optional = true
+
+[dependencies.serde]
+version = "1"
+optional = true
+
+[dependencies.serde_derive]
+version = "1"
+optional = true

README.md

@@ -1,4 +1,22 @@
+# splines
+
 This crate provides [splines](https://en.wikipedia.org/wiki/Spline_(mathematics)), mathematic curves
 defined piecewise through control keys a.k.a. knots.
 
 Feel free to dig in the [online documentation](https://docs.rs/splines) for further information.
+
+## A note on features
+
+This crate has features! Here’s a comprehensive list of what you can enable:
+
+  - **Serialization / deserialization.**
+    + This feature implements both the `Serialize` and `Deserialize` traits from `serde`.
+    + Enable with the `"serialization"` feature.
+  - **[cgmath](https://crates.io/crates/cgmath) implementors**
+    + Adds some usefull implementations of `Interpolate` for some cgmath types.
+    + Enable with the `"impl-cgmath"` feature.
+  - **Standard library / no standard library.**
+    + It’s possible to compile against the standard library or go on your own without it.
+    + Compiling with the standard library is enabled by default.
+    + Use `default-features = []` in your `Cargo.toml` to disable.
+    + Enable explicitly with the `"std"` feature.

examples/01-hello-world/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "hello-world"
+version = "0.2.0"
+authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
+
+[dependencies]
+splines = "0.2"

examples/01-hello-world/src/main.rs

@@ -0,0 +1,11 @@
+extern crate splines;
+
+use splines::{Interpolation, Key, Spline};
+
+fn main() {
+  let keys = vec![Key::new(0., 0., Interpolation::default()), Key::new(5., 1., Interpolation::default())];
+  let spline = Spline::from_vec(keys);
+
+  println!("value at 0: {}", spline.clamped_sample(0.));
+  println!("value at 3: {}", spline.clamped_sample(3.));
+}

examples/02-serialization/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "serialization"
+version = "0.2.0"
+authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
+
+[dependencies]
+serde_json = "1"
+
+[dependencies.splines]
+version = "0.2"
+features = ["serialization"]

examples/02-serialization/src/main.rs

@@ -0,0 +1,30 @@
+#[macro_use] extern crate serde_json;
+extern crate splines;
+
+use serde_json::{Value, from_value};
+use splines::Spline;
+
+fn main() {
+  let value = json!{
+    [
+      {
+        "t": 0,
+        "interpolation": "linear",
+        "value": 0
+      },
+      {
+        "t": 1,
+        "interpolation": { "step": 0.5 },
+        "value": 1
+      },
+      {
+        "t": 5,
+        "interpolation": "cosine",
+        "value": 10
+      },
+    ]
+  };
+
+  let spline = from_value::<Spline<f32>>(value);
+  println!("{:?}", spline);
+}

examples/Cargo.toml

@@ -0,0 +1,9 @@
+[workspace]
+
+members = [
+  "01-hello-world",
+  "02-serialization"
+]
+
+[patch.crates-io]
+splines = { path = ".." }

src/lib.rs

@@ -61,15 +61,56 @@
 //! assert_eq!(spline.clamped_sample(-0.9), 0.); // clamped to the first key
 //! assert_eq!(spline.clamped_sample(1.1), 10.); // clamped to the last key
 //! ```
+//! # Features and customization
 //!
-//! Feel free to have a look at the rest of the documentation for advanced usage.
+//! This crate was written with features baked in and hidden behind feature-gates. The idea is that
+//! the default configuration (i.e. you just add `"spline = …"` to your `Cargo.toml`) will always
+//! give you the minimal, core and raw concepts of what splines, keys / knots and interpolation
+//! modes are. However, you might want more. Instead of letting other people do the extra work to
+//! add implementations for very famous and useful traits – and do it in less efficient way, because
+//! they wouldn’t have access to the internals of this crate, it’s possible to enable features in an
+//! ad hoc way.
+//!
+//! This mechanism is not final and this is currently an experiment to see how people like it or
+//! not. It’s especially important to see how it copes with the documentation.
+//!
+//! So here’s a list of currently supported features and how to enable them:
+//!
+//!   - **Serialization / deserialization.**
+//!     + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+//!       types exported by this crate.
+//!     + Enable with the `"serialization"` feature.
+//!   - **[cgmath](https://crates.io/crates/cgmath) implementors.**
+//!     + Adds some usefull implementations of `Interpolate` for some cgmath types.
+//!     + Enable with the `"impl-cgmath"` feature.
+//!   - **Standard library / no standard library.**
+//!     + It’s possible to compile against the standard library or go on your own without it.
+//!     + Compiling with the standard library is enabled by default.
+//!     + Use `default-features = []` in your `Cargo.toml` to disable.
+//!     + Enable explicitly with the `"std"` feature.
 
-extern crate cgmath;
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+#![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
 
-use cgmath::{InnerSpace, Quaternion, Vector2, Vector3, Vector4};
-use std::cmp::Ordering;
-use std::f32::consts;
-use std::ops::{Add, Div, Mul, Sub};
+// on no_std, we also need the alloc crate for Vec
+#[cfg(not(feature = "std"))] extern crate alloc;
+
+#[cfg(feature = "impl-cgmath")] extern crate cgmath;
+
+#[cfg(feature = "serialization")] extern crate serde;
+#[cfg(feature = "serialization")] #[macro_use] extern crate serde_derive;
+
+#[cfg(feature = "impl-cgmath")] use cgmath::{InnerSpace, Quaternion, Vector2, Vector3, Vector4};
+
+#[cfg(feature = "std")] use std::cmp::Ordering;
+#[cfg(feature = "std")] use std::f32::consts;
+#[cfg(feature = "std")] use std::ops::{Add, Div, Mul, Sub};
+
+#[cfg(not(feature = "std"))] use alloc::vec::Vec;
+#[cfg(not(feature = "std"))] use core::cmp::Ordering;
+#[cfg(not(feature = "std"))] use core::f32::consts;
+#[cfg(not(feature = "std"))] use core::ops::{Add, Div, Mul, Sub};
 
 /// A spline control point.
 ///
@@ -77,6 +118,8 @@ use std::ops::{Add, Div, Mul, Sub};
 /// interpolation hint used to determine how to interpolate values on the segment defined by this
 /// key and the next one – if existing.
 #[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
 pub struct Key<T> {
   /// Interpolation parameter at which the [`Key`] should be reached.
   pub t: f32,
@@ -99,6 +142,8 @@ impl<T> Key<T> {
 
 /// Interpolation mode.
 #[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
 pub enum Interpolation {
   /// Hold a [`Key`] until the time passes the normalized step threshold, in which case the next
   /// key is used.
@@ -125,6 +170,7 @@ impl Default for Interpolation {
 
 /// Spline curve used to provide interpolation between control points (keys).
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
 pub struct Spline<T>(Vec<Key<T>>);
 
 impl<T> Spline<T> {
@@ -186,7 +232,18 @@ impl<T> Spline<T> {
       Interpolation::Cosine => {
         let cp1 = &keys[i+1];
         let nt = normalize_time(t, cp0, cp1);
-        let cos_nt = (1. - f32::cos(nt * consts::PI)) * 0.5;
+        let cos_nt = {
+          #[cfg(feature = "std")]
+          {
+            (1. - f32::cos(nt * consts::PI)) * 0.5
+          }
+
+          #[cfg(not(feature = "std"))]
+          {
+            use core::intrinsics::cosf32;
+            unsafe { (1. - cosf32(nt * consts::PI)) * 0.5 }
+          }
+        };
 
         Some(Interpolate::lerp(cp0.value, cp1.value, cos_nt))
       },
@@ -288,6 +345,7 @@ impl Interpolate for f32 {
   }
 }
 
+#[cfg(feature = "impl-cgmath")]
 impl Interpolate for Vector2<f32> {
   fn lerp(a: Self, b: Self, t: f32) -> Self {
     a.lerp(b, t)
@@ -298,6 +356,7 @@ impl Interpolate for Vector2<f32> {
   }
 }
 
+#[cfg(feature = "impl-cgmath")]
 impl Interpolate for Vector3<f32> {
   fn lerp(a: Self, b: Self, t: f32) -> Self {
     a.lerp(b, t)
@@ -308,6 +367,7 @@ impl Interpolate for Vector3<f32> {
   }
 }
 
+#[cfg(feature = "impl-cgmath")]
 impl Interpolate for Vector4<f32> {
   fn lerp(a: Self, b: Self, t: f32) -> Self {
     a.lerp(b, t)
@@ -318,6 +378,7 @@ impl Interpolate for Vector4<f32> {
   }
 }
 
+#[cfg(feature = "impl-cgmath")]
 impl Interpolate for Quaternion<f32> {
   fn lerp(a: Self, b: Self, t: f32) -> Self {
     a.nlerp(b, t)