The Great Rewrite

.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build catch2
+
+      - name: Configure
+        run: cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug -DTWEENY_BUILD_TESTS=ON
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Test
+        run: ctest --test-dir build --output-on-failure

CHANGELOG.md

@@ -1,4 +1,28 @@
 # Tweeny Changelog
+- Version 4.0.0
+  - **Breaking:** Requires C++17
+  - **Breaking:** `tweeny::from()` returns a builder; call `.build()` to create a tween
+  - **Breaking:** Tweens are immutable after `build()` (keyframes, durations, and easings cannot be changed)
+  - **Breaking:** Durations must be `uint32_t` (`during(60U)`); `step()` accepts `int32_t` frame deltas only (no percentage mode)
+  - **Breaking:** `seek()` accepts `uint32_t` absolute frame positions only (no percentage mode)
+  - **Breaking:** Multi-value tweens return `std::tuple` instead of `std::array`
+  - **Breaking:** Callbacks use `on(event::…)` with `event::response` return values instead of `onStep()` / `onSeek()`
+  - **Breaking:** `forward()` / `backward()` removed; use negative `step()` values to move backward
+  - **Breaking:** Headers moved to `include/tweeny/`; include as `#include <tweeny/tweeny.h>`
+  - **Breaking:** Removed `easing::enumerated` and string-based `via("linear")` easing selection
+  - New event types: `complete`, `keyframeEnter`, `keyframeLeave`, `update`
+  - New methods: `peek()`, `peek(frame)`, `progress()`, `jump(keyframe)`
+  - Restructured internals under `tweeny::detail`; easing split into per-function headers
+  - Added Catch2 test suite and Doxygen manual with v3-to-v4 migration guide
+  - CMake: C++17 enforcement, `FILE_SET HEADERS`, optional tests and single-header target (via `uvx` + quom)
+  - Fixed exponential easing endpoints (`position == 0` / `== 1`) to match Penner behavior
+  - Expanded tests: Penner reference samples for bundled easings (direct + `via`); `def`/`stepped` (including multi-keyframe stepped); seek/step/jump vs `peek` consistency
+  - GitHub Actions CI (Ubuntu, Catch2, build + ctest)
+  - `scripts/create-release.sh` — release from an existing tag (docs sync to `gh-pages`, single-header asset, GitHub Release)
+  - README: CMake install + `find_package(Tweeny)`; fixed installed include interface so `#include <tweeny/tweeny.h>` works after install
+  - Docs: `event::update`, `progress()`, honest zero-`during()` behavior; Doxygen styling aligned with the site
+  - Removed sandbox CMake option/target
+
 - Version 3.2.1
   - Adds `<string>` as dependency
 

CMakeLists.txt

@@ -25,73 +25,83 @@
 # target that uses tweeny, a simple `target_link_libraries(target tweeny)` is sufficient to set up include and link
 # instructions.
 
-cmake_minimum_required(VERSION 3.0...3.28)
+cmake_minimum_required(VERSION 3.23...3.28)
 cmake_policy(SET CMP0063 NEW)
-project(Tweeny LANGUAGES CXX VERSION 3.2.1)
+project(Tweeny LANGUAGES CXX VERSION 4.0.0)
+
+# Enforce C++17 for targets built in this project
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
 # Setup variables and options
 option(TWEENY_BUILD_DOCUMENTATION "Attempts to build the documentation. You'll need doxygen and graphviz installed" OFF)
-option(TWEENY_BUILD_SINGLE_HEADER "Joins together all header files in a single one. Needs Python 3.6 and quom installed" OFF)
-option(TWEENY_BUILD_SANDBOX "Adds a 'sandbox' target that links to tweeny. Useful when exploring tweeny" OFF)
+option(TWEENY_BUILD_SINGLE_HEADER "Joins together all header files in a single one. Needs uv (https://docs.astral.sh/uv/) to run quom via uvx" OFF)
+option(TWEENY_BUILD_TESTS "Build Tweeny tests (requires Catch2 v3 to be findable via CMake)" OFF)
 
 # The library target
 add_library(tweeny INTERFACE)
 
-# Specify the C++ features a compiler should have to use this library.
-if(NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
-    target_compile_features(tweeny
-        INTERFACE
-        cxx_auto_type
-        cxx_variadic_templates
-        cxx_lambdas
-        cxx_nullptr
-        cxx_right_angle_brackets
-        cxx_static_assert
-        cxx_template_template_parameters
-    )
-else()
-    list(APPEND CMAKE_CXX_FLAGS -std=c++11)
-endif()
+# Require C++17 for consumers of this interface library.
+target_compile_features(tweeny INTERFACE cxx_std_17)
+
+# Provide namespaced alias for consumers.
+add_library(tweeny::tweeny ALIAS tweeny)
 
 # Set up include directories
 target_include_directories(tweeny INTERFACE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include/tweeny>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:include>
+)
+
+# Attach headers to the interface target for IDEs and installation
+target_sources(tweeny INTERFACE
+  FILE_SET HEADERS
+  BASE_DIRS
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+  FILES
+    include/tweeny/event.h
+    include/tweeny/tweeny.h
+    include/tweeny/tween.h
+    include/tweeny/tween.tcc
+    include/tweeny/easing.h
+    include/tweeny/detail/event.h
+    include/tweeny/detail/interpolate.h
+    include/tweeny/detail/key-frame.h
+    include/tweeny/detail/tuple-utilities.h
+    include/tweeny/detail/tween-value.h
+    include/tweeny/detail/value-container.h
+    include/tweeny/detail/easing/back.h
+    include/tweeny/detail/easing/bounce.h
+    include/tweeny/detail/easing/circular.h
+    include/tweeny/detail/easing/cubic.h
+    include/tweeny/detail/easing/def.h
+    include/tweeny/detail/easing/elastic.h
+    include/tweeny/detail/easing/exponential.h
+    include/tweeny/detail/easing/linear.h
+    include/tweeny/detail/easing/quadratic.h
+    include/tweeny/detail/easing/quartic.h
+    include/tweeny/detail/easing/quintic.h
+    include/tweeny/detail/easing/sinusoidal.h
+    include/tweeny/detail/easing/stepped.h
 )
 
 # Set up install
 include(GNUInstallDirs)
-install(TARGETS tweeny EXPORT TweenyTargets)
-install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/tweeny)
+install(TARGETS tweeny EXPORT TweenyTargets FILE_SET HEADERS)
 
 # Set up export and config
 include(cmake/SetupExports.cmake)
 
 if (TWEENY_BUILD_DOCUMENTATION)
-    add_subdirectory(doc)
-endif()
+  add_subdirectory(src/doc)
+endif ()
 
-# This library is a convenience library to force files appear in the IDE properly.
-add_library(tweeny-dummy
-        include/tweeny.h
-        include/tweeny.tcc
-        include/tween.h
-        include/tween.tcc
-        include/tweenone.tcc
-        include/tweenpoint.h
-        include/tweenpoint.tcc
-        include/tweentraits.h
-        include/easing.h
-        include/easingresolve.h
-        include/int2type.h
-        include/dispatcher.h)
-set_target_properties(tweeny-dummy PROPERTIES LINKER_LANGUAGE CXX EXCLUDE_FROM_ALL TRUE)
+if (TWEENY_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(src/tests)
+endif ()
 
 if (TWEENY_BUILD_SINGLE_HEADER)
-    include(cmake/GenerateSingleHeader.cmake)
-endif()
-
-if (TWEENY_BUILD_SANDBOX)
-    add_executable(sandbox src/sandbox.cc)
-    target_link_libraries(sandbox tweeny)
-endif()
+  include(cmake/GenerateSingleHeader.cmake)
+endif ()

README-3.md

@@ -0,0 +1,86 @@
+> **Note:** This is the README for Tweeny 3.x, kept for reference. For Tweeny 4.x, see [README.md](README.md).
+
+# Tweeny
+<a href="https://repology.org/project/tweeny/versions">
+    <img src="https://repology.org/badge/vertical-allrepos/tweeny.svg" alt="Packaging status" align="right" style="padding-left: 20px">
+</a>
+
+Tweeny is an inbetweening library designed for the creation of complex animations for games and other beautiful interactive software. It leverages features of modern C++ to empower developers with an intuitive API for declaring tweenings of any type of value, as long as they support arithmetic operations.
+
+The goal of Tweeny is to provide means to create fluid interpolations when animating position, scale, rotation, frames or other values of screen objects, by setting their values as the tween starting point and then, after each tween step, plugging back the result.
+
+**It features**:
+
+- A descriptive and (hopefully) intuitive API,
+- 30+ easing functions,
+- Allows custom easing functions,
+- Multi-point tweening,
+- Simultaneous tween of heterogeneous value sets,
+- Timeline-like usage (allows seeking to any point),
+- Header-only
+- Zero external dependencies
+- Steps forwards or backwards :)
+- Accepts lambdas, functors and functions as step and seek callbacks
+
+**Obligatory hello world example**:
+
+Linearly interpolate character by character from the word *hello* to *world* in `50` steps:
+
+```cpp
+auto helloworld = tweeny::from('h','e','l','l','o').to('w','o','r','l','d').during(50);
+for (int i = 0; i < 50; i++) {
+    for (char c : helloworld.step(1)) { printf("%c", c); }
+    printf("\n");
+}
+```
+
+Relevant code:
+
+- **1**: create the tween instance starting with characters of the `hello` word, adds a tween target with the chars of the `world` word and specify it should reach it in `50` steps.
+- **3**: move the tween forward by one step. Use the return value of it (which ill be a `std::array<char, 5>` in this case) to set up a for loop iterating in each char, printing it.
+
+## Installation methods:
+
+**Using your package manager**
+
+There are some packages for tweeny made by some great people. Repology has a list of them and their versions [here](https://repology.org/metapackage/tweeny/versions). Thanks, great people!
+
+**Not installing it**
+
+You just need to adjust your include path to point to the `include/` folder after you've cloned this repository.
+
+**Copying the `include` folder:**
+
+Tweeny itself is a header only library. You can copy the `include/` folder into your project folder and then include from it: `#include "tweeny/tweeny.h"`
+
+**Copying the `tweeny-<version>.h` header**
+
+Since version 3.1.1 tweeny releases include a single-header file with all the necessary code glued together. Simply drop it on your project and/or adjust the include path and then `#include "tweeny-3.1.1.h"`.
+
+**CMake subproject**
+
+This is useful if you are using CMake already. Copy the whole tweeny project and include it in a top-level `CMakeLists.txt` file and then use `target_link_libraries` to add it to your target:
+
+```
+add_subdirectory(tweeny)
+target_link_libraries(yourtarget tweeny)
+```
+This will add the `include/` folder to your search path, and you can `#include "tweeny.h"`.
+
+## Doxygen documentation
+
+This library is documented using Doxygen. If you intend to generate docs, specify the flag `TWEENY_BUILD_DOCUMENTATION` when generating CMake build files (e.g: `cmake .. -DTWEENY_BUILD_DOCUMENTATION=1`). You will need doxygen installed.
+
+## Contributing
+
+Tweeny is open-source, meaning that it is open to modifications and contrubutions from the community (you are very much encouraged to do so!). However, we'd appreciate if you follow these guidelines:
+
+- Don't use `PascalCase` nor `snake_case` in names
+- Use `camelCase`, but try to avoid multi word names as hard as possible
+- Document code using Doxygen
+- Implementation details should go inside `tweeny::detail` namespace.
+- Template implementations should go into a `.tcc` file
+
+## Examples:
+
+Demo code showcasing some of Tweeny features can be seen in the [tweeny-demo](https://github.com/mobius3/tweeny-demos) repository. This repository also has instructions on how to build them.