Add more sfKeyboard tests

This change allows now having these variables as array sizes that
are not Variable Length Arrays like in structs for example.

To note however that this changes the type from unsigned int to an
implementation defined type which usually `int` which is signed and
not unsigned.

.clang-format

@@ -0,0 +1,173 @@
+---
+# Project
+Standard: c++17
+ColumnLimit: 120
+
+# Indentation
+AccessModifierOffset: -4
+BitFieldColonSpacing: Both
+ContinuationIndentWidth: 4
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentExternBlock: Indent
+IndentPPDirectives: None
+IndentRequires: true
+IndentWidth: 4
+IndentWrappedFunctionNames: true
+TabWidth: 4
+UseTab: Never
+
+# Alignment
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: Consecutive
+AlignConsecutiveBitFields: Consecutive
+AlignConsecutiveDeclarations: Consecutive
+AlignConsecutiveMacros: Consecutive
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments: true
+
+# Allow
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AllowShortLambdasOnASingleLine: All
+
+# Break
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeConceptDeclarations: true
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakBeforeBinaryOperators: None
+BreakInheritanceList: AfterColon
+BreakStringLiterals: true
+
+# Initializers & arguments
+BinPackArguments: false
+BinPackParameters: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 0
+Cpp11BracedListStyle: true
+
+# Braces
+BreakBeforeBraces: Custom
+BraceWrapping:
+    AfterCaseLabel: true
+    AfterClass: true
+    AfterControlStatement: Always
+    AfterEnum: true
+    AfterFunction: true
+    AfterNamespace: true
+    AfterStruct: true
+    AfterUnion: true
+    AfterExternBlock: true
+    BeforeCatch: false
+    BeforeElse: true
+    BeforeLambdaBody: true
+    BeforeWhile: false
+    IndentBraces: false
+    SplitEmptyFunction: true
+    SplitEmptyRecord: true
+    SplitEmptyNamespace: true
+
+# Namespaces
+CompactNamespaces: false
+FixNamespaceComments: true
+NamespaceIndentation: None
+
+# Derive
+DeriveLineEnding: false
+DerivePointerAlignment: false
+
+# Empty lines
+EmptyLineBeforeAccessModifier: Always
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 2
+
+# Sorting
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Priority: 1
+    Regex: '^<CSFML\/Config.h>$'
+  - Priority: 2
+    Regex: '^<CSFML\/(.+)\/Export.h>$'
+  - Priority: 3
+    Regex: '^<CSFML\/'
+  - Priority: 4
+    Regex: '^<SFML\/'
+  - Priority: 5
+    Regex: '^<(catch2)'
+  - Priority: 6
+    Regex: '^<(.+)>$'
+SortIncludes: true
+SortUsingDeclarations: true
+
+# Penalties
+PenaltyBreakAssignment: 1000
+PenaltyBreakBeforeFirstCallParameter: 1000
+PenaltyBreakComment: 200
+PenaltyBreakFirstLessLess: 100
+PenaltyBreakString: 1
+PenaltyBreakTemplateDeclaration: 0
+PenaltyExcessCharacter: 5
+PenaltyIndentedWhitespace: 1
+PenaltyReturnTypeOnItsOwnLine: 500
+
+# Pointer alignment
+PointerAlignment: Left
+
+# Comments
+ReflowComments: false
+
+# Spaces
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+
+# Line endings
+UseCRLF: false
+
+# Qualifiers (const, volatile, static, etc)
+QualifierAlignment: Custom
+QualifierOrder: ['static', 'inline', 'constexpr', 'const', 'volatile', 'type']
+
+---
+Language: ObjC
+IndentWidth: 4
+BreakBeforeBraces: Custom
+BraceWrapping:
+    AfterObjCDeclaration: true
+
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 4
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: false
+
+...

.clang-tidy

@@ -0,0 +1,37 @@
+Checks: >
+  bugprone-*,
+  clang-analyzer-*,
+  cppcoreguidelines-*,
+  modernize-*,
+  readability-identifier-naming,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-narrowing-conversions,
+  -clang-analyzer-core.NonNullParamChecker,
+  -clang-analyzer-security.insecureAPI.strcpy,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-macro-to-enum,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-no-malloc,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-special-member-functions,
+  -modernize-avoid-c-arrays,
+  -modernize-macro-to-enum,
+  -modernize-redundant-void-arg,
+  -modernize-use-trailing-return-type,
+  -modernize-use-using,
+CheckOptions:
+  - { key: readability-identifier-naming.VariableCase,        value: camelBack }
+  - { key: readability-identifier-naming.GlobalVariableCase,  value: aNy_CasE }
+  - { key: readability-identifier-naming.ParameterCase,       value: camelBack }
+HeaderFilterRegex: '.*'
+WarningsAsErrors: '*'
+UseColor: true

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: SFML
+open_collective: sfml

.github/workflows/ci.yml

@@ -6,9 +6,16 @@ concurrency:
   group: environment-${{github.ref}}
   cancel-in-progress: true
 
+env:
+  SFML_VERSION: 3.0.0
+
+defaults:
+  run:
+    shell: bash
+
 jobs:
   build:
-    name: ${{ matrix.platform.name }} ${{ matrix.type.name }}
+    name: ${{ matrix.platform.name }} ${{ matrix.config.name }} ${{ matrix.type.name }}
     runs-on: ${{ matrix.platform.os }}
 
     strategy:
@@ -23,7 +30,10 @@ jobs:
         - { name: Windows Clang,       os: windows-2022, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
         - { name: Linux GCC,           os: ubuntu-22.04, flags: -GNinja }
         - { name: Linux Clang,         os: ubuntu-22.04, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
-        - { name: MacOS,               os: macos-12,     flags: -GNinja }
+        - { name: MacOS,               os: macos-14,     flags: -GNinja }
+        config:
+        - { name: Shared, flags: -DBUILD_SHARED_LIBS=ON,  csfml_flags: -DCSFML_LINK_SFML_STATICALLY=OFF }
+        - { name: Static, flags: -DBUILD_SHARED_LIBS=OFF, csfml_flags: -DCSFML_LINK_SFML_STATICALLY=ON }
         type:
         - { name: Debug }
         - { name: Release }
@@ -36,32 +46,117 @@ jobs:
 
     - name: Install Linux Dependencies
       if: runner.os == 'Linux'
-      run: sudo apt-get update && sudo apt-get install libxrandr-dev libxcursor-dev libudev-dev libopenal-dev libflac-dev libvorbis-dev libgl1-mesa-dev libegl1-mesa-dev
+      run: sudo apt-get update && sudo apt-get install libxrandr-dev libxcursor-dev libxi-dev libudev-dev libflac-dev libvorbis-dev libgl1-mesa-dev libegl1-mesa-dev libfreetype-dev
 
     - name: Checkout SFML
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: 2.6.0
+        ref: ${{env.SFML_VERSION}}
         path: SFML
 
     - name: Configure SFML CMake
-      shell: bash
+      run: cmake -S SFML -B SFML/build -DCMAKE_INSTALL_PREFIX=SFML/install ${{matrix.platform.flags}} ${{matrix.config.flags}} -DCMAKE_BUILD_TYPE=${{matrix.type.name}}
-      run: cmake -S $GITHUB_WORKSPACE/SFML -B $GITHUB_WORKSPACE/SFML/build -DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML/install -DBUILD_SHARED_LIBS=TRUE -DSFML_BUILD_EXAMPLES=FALSE -DSFML_BUILD_TEST_SUITE=FALSE -DCMAKE_VERBOSE_MAKEFILE=ON ${{matrix.platform.flags}} -DCMAKE_BUILD_TYPE=${{matrix.type.name}}
 
     - name: Build SFML
-      shell: bash
+      run: cmake --build SFML/build --config ${{matrix.type.name}} --target install
-      run: cmake --build $GITHUB_WORKSPACE/SFML/build --config ${{matrix.type.name}} --target install
 
     - name: Checkout CSFML
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         path: CSFML
 
     - name: Configure CSFML CMake
-      shell: bash
+      run: cmake --preset dev -S CSFML -B CSFML/build -DCMAKE_INSTALL_PREFIX=CSFML/install -DSFML_ROOT=SFML/install -DCMAKE_VERBOSE_MAKEFILE=ON ${{matrix.platform.flags}} ${{matrix.config.flags}} ${{matrix.config.csfml_flags}} -DCMAKE_BUILD_TYPE=${{matrix.type.name}}
-      run: cmake -S $GITHUB_WORKSPACE/CSFML -B $GITHUB_WORKSPACE/CSFML/build -DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML/install -DBUILD_SHARED_LIBS=TRUE -DCSFML_BUILD_EXAMPLES=TRUE -DCSFML_LINK_SFML_STATICALLY=FALSE -DSFML_DIR=$GITHUB_WORKSPACE/SFML/install/lib/cmake/SFML -DCMAKE_VERBOSE_MAKEFILE=ON -DWARNINGS_AS_ERRORS=TRUE ${{matrix.platform.flags}} -DCMAKE_BUILD_TYPE=${{matrix.type.name}}
 
     - name: Build CSFML
-      shell: bash
+      run: cmake --build CSFML/build --config ${{matrix.type.name}} --target install
-      run: cmake --build $GITHUB_WORKSPACE/CSFML/build --config ${{matrix.type.name}} --target install
+
+    - name: Test
+      run: ctest --test-dir CSFML/build -C ${{matrix.type.name}} --output-on-failure
+
+  format:
+    name: Formatting
+    runs-on: ubuntu-24.04
+
+    steps:
+    - name: Install Clang Format
+      run: sudo apt-get install clang-format-17
+
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Format Code
+      run: cmake -DCLANG_FORMAT_EXECUTABLE=clang-format-17 -P cmake/Format.cmake
+
+    - name: Check Formatting
+      run: git diff --exit-code
+
+  tidy:
+    name: Analyze
+    runs-on: macos-14
+
+    steps:
+    - name: Install Dependencies
+      run: |
+        brew update
+        brew install llvm ninja
+        echo /opt/homebrew/opt/llvm/bin >> $GITHUB_PATH
+
+    - name: Checkout SFML
+      uses: actions/checkout@v4
+      with:
+        repository: SFML/SFML
+        ref: ${{env.SFML_VERSION}}
+        path: SFML
+
+    - name: Configure SFML CMake
+      run: cmake -S SFML -B SFML/build -GNinja -DCMAKE_INSTALL_PREFIX=SFML/install -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Debug
+
+    - name: Build SFML
+      run: cmake --build SFML/build --target install
+
+    - name: Checkout CSFML
+      uses: actions/checkout@v4
+      with:
+        path: CSFML
+
+    - name: Configure CSFML CMake
+      run: cmake --preset dev -S CSFML -B CSFML/build -DSFML_ROOT=SFML/install -DCMAKE_BUILD_TYPE=Debug
+
+    - name: Tidy
+      run: cmake --build CSFML/build --target tidy
+
+  docs:
+    name: Documentation
+    runs-on: macos-14
+
+    steps:
+    - name: Install Doxygen
+      run: |
+        brew update
+        brew install doxygen ninja || true
+
+    - name: Checkout SFML
+      uses: actions/checkout@v4
+      with:
+        repository: SFML/SFML
+        ref: ${{env.SFML_VERSION}}
+        path: SFML
+
+    - name: Configure SFML
+      run: cmake -S SFML -B SFML/build -GNinja -DCMAKE_INSTALL_PREFIX=SFML/install
+
+    - name: Build SFML
+      run: cmake --build SFML/build --target install
+
+    - name: Checkout CSFML
+      uses: actions/checkout@v4
+      with:
+        path: CSFML
+
+    - name: Configure CSFML
+      run: cmake -S CSFML -B CSFML/build -GNinja -DSFML_ROOT=SFML/install -DCSFML_BUILD_DOC=ON -DCSFML_LINK_SFML_STATICALLY=ON
+
+    - name: Build Doxygen Site
+      run: cmake --build CSFML/build --target doc

.github/workflows/nuget.yml

@@ -0,0 +1,252 @@
+name: NuGet Release
+
+on:
+    push:
+        branches:
+            - master
+            - 2.6.x
+    workflow_dispatch: {}
+
+concurrency:
+    group: nuget-${{github.ref}}
+    cancel-in-progress: true
+
+env:
+    DOTNET_CLI_TELEMETRY_OPTOUT: 1
+
+jobs:
+    windows:
+        name: Windows VS2022
+        runs-on: windows-2022
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build x86
+              shell: pwsh
+              run: |
+                  cd CSFML/tools/nuget
+                  ./build.win.ps1 "win-x86"
+
+            - name: Build x64
+              shell: pwsh
+              run: |
+                  cd CSFML/tools/nuget
+                  ./build.win.ps1 "win-x64"
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-win-x86-x64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    linux-x64:
+        name: Linux x64
+        runs-on: ubuntu-22.04
+        container:
+            image: ubuntu:22.04
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build
+              shell: bash
+              run: |
+                  cd ./CSFML/tools/nuget
+                  chmod +x ./docker.linux-x64.sh
+                  ./docker.linux-x64.sh
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-linux-x64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    linux-arm:
+        name: Linux ARM
+        runs-on: ubuntu-22.04
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build in an ARM container
+              uses: uraimo/run-on-arch-action@v2.7.2
+              with:
+                  arch: armv7
+                  distro: ubuntu22.04
+                  githubToken: ${{ github.token }}
+                  dockerRunArgs: |
+                      --volume "${PWD}/CSFML:/CSFML"
+                  install: |
+                      apt-get update -y
+                      apt-get install -y git libfreetype6-dev xorg-dev libxrandr-dev libxcursor-dev libxi-dev libudev-dev libgl1-mesa-dev libflac-dev libogg-dev libvorbis-dev cmake g++
+                  run: |
+                      cd /CSFML/tools/nuget
+                      chmod +x ./build.linux.sh
+                      ./build.linux.sh linux-arm
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-linux-arm
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    linux-arm64:
+        name: Linux ARM64
+        runs-on: ubuntu-22.04
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build in an ARM64 container
+              uses: uraimo/run-on-arch-action@v2.7.2
+              with:
+                  arch: aarch64
+                  distro: ubuntu22.04
+                  githubToken: ${{ github.token }}
+                  dockerRunArgs: |
+                      --volume "${PWD}/CSFML:/CSFML"
+                  install: |
+                      apt-get update -y
+                      apt-get install -y git libfreetype6-dev xorg-dev libxrandr-dev libxcursor-dev libudev-dev libgl1-mesa-dev libflac-dev libogg-dev libvorbis-dev cmake g++
+                  run: |
+                      cd /CSFML/tools/nuget
+                      chmod +x ./build.linux.sh
+                      ./build.linux.sh linux-arm64
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-linux-arm64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    linux-musl-x64:
+        name: Linux MUSL x64
+        runs-on: ubuntu-22.04
+        container:
+            image: alpine:3.20.3
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build
+              shell: sh
+              run: |
+                  cd ./CSFML/tools/nuget
+                  chmod +x ./docker.linux-musl-x64.sh
+                  ./docker.linux-musl-x64.sh
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-linux-musl-x64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    fedora-x64:
+        name: Fedora x64
+        runs-on: ubuntu-22.04
+        container:
+            image: fedora:37
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Build
+              shell: bash
+              run: |
+                  cd ./CSFML/tools/nuget
+                  chmod +x ./docker.fedora-x64.sh
+                  ./docker.fedora-x64.sh
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-fedora-x64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    macos:
+        name: macOS
+        runs-on: macos-14
+
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+
+            - name: Install necessary tooling
+              run: brew install coreutils
+
+            - name: Build x64
+              run: |
+                  cd CSFML/tools/nuget
+                  ./build.macos.sh "osx-x64"
+
+            - name: Build ARM64
+              run: |
+                  cd CSFML/tools/nuget
+                  ./build.macos.sh "osx-arm64"
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-macOS-x64-arm64
+                  path: CSFML/tools/nuget/CSFML/runtimes
+
+    package:
+        name: Package Builds
+        runs-on: ubuntu-22.04
+        needs:
+            - windows
+            - linux-x64
+            - linux-arm
+            - linux-arm64
+            - linux-musl-x64
+            - fedora-x64
+            - macos
+        steps:
+            - name: Checkout CSFML
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
+            - name: Download Artifacts
+              uses: actions/download-artifact@v4
+              with:
+                  path: CSFML/tools/nuget/CSFML/runtimes
+                  merge-multiple: true
+            - name: Setup .NET 8 SDK
+              id: setup-dotnet
+              uses: actions/setup-dotnet@v4
+              with:
+                  dotnet-version: 8.0.x
+            - name: Enforce SDK Version
+              run: dotnet new globaljson --sdk-version ${{ steps.setup-dotnet.outputs.dotnet-version }} --force
+            - name: Verify SDK Installation
+              run: dotnet --info
+            - name: Build NuGet Package
+              run: |
+                  cd CSFML/tools/nuget
+                  dotnet build --configuration Release --verbosity detailed
+            - name: Upload NuGet Package
+              uses: actions/upload-artifact@v4
+              with:
+                  name: CSFML-NuGet-Package
+                  path: CSFML/tools/nuget/CSFML/bin/Release/*.nupkg

.gitignore

@@ -1,45 +1,7 @@
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Build folders
-build/
-cmake-build-*/
-
-# Cache/IDE folders
 .cache/
-.vscode/
 .idea/
 .vs/
-
+.vscode/
-# System files
+build/
-.DS_Store
+cmake-build-*/
+CMakeUserPresets.json

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.7.2)
+cmake_minimum_required(VERSION 3.22)
 
 # define a macro that helps defining an option
 macro(csfml_set_option var default type docstring)
@@ -13,62 +13,78 @@ endmacro()
 csfml_set_option(CMAKE_BUILD_TYPE Release STRING "Choose the type of build (Debug or Release)")
 
 # project name
-project(CSFML VERSION 2.6.0)
+project(CSFML VERSION 3.0.0)
+
+# we use the paths from the cmake GNUInstallDirs module as defaults
+# you can override these if you like
+# https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
 
 # include the configuration file
 include(${PROJECT_SOURCE_DIR}/cmake/Config.cmake)
 
+# add options to select which modules to build
+csfml_set_option(CSFML_BUILD_WINDOW ON BOOL "ON to build CSFML's Window module. This setting is ignored, if the graphics module is built.")
+csfml_set_option(CSFML_BUILD_GRAPHICS ON BOOL "ON to build CSFML's Graphics module.")
+csfml_set_option(CSFML_BUILD_AUDIO ON BOOL "ON to build CSFML's Audio module.")
+csfml_set_option(CSFML_BUILD_NETWORK ON BOOL "ON to build CSFML's Network module.")
+
 # add an option for choosing the build type (shared or static)
-csfml_set_option(BUILD_SHARED_LIBS TRUE BOOL "TRUE to build CSFML as shared libraries, FALSE to build it as static libraries")
+csfml_set_option(BUILD_SHARED_LIBS ON BOOL "ON to build CSFML as shared libraries, OFF to build it as static libraries")
 
 # add an option for building the API documentation
-csfml_set_option(CSFML_BUILD_DOC FALSE BOOL "TRUE to generate the API documentation, FALSE to ignore it")
+csfml_set_option(CSFML_BUILD_DOC OFF BOOL "ON to generate the API documentation, OFF to ignore it")
 
 # add an option for linking to sfml either statically or dynamically
 # default on windows to static and on other platforms to dynamic
 if(SFML_OS_WINDOWS)
-    set(LINK_STATICALLY_DEFAULT TRUE)
+    set(LINK_STATICALLY_DEFAULT ON)
 else()
-    set(LINK_STATICALLY_DEFAULT FALSE)
+    set(LINK_STATICALLY_DEFAULT OFF)
 endif()
-csfml_set_option(CSFML_LINK_SFML_STATICALLY ${LINK_STATICALLY_DEFAULT} BOOL "TRUE to link to a static version of SFML, FALSE to link dynamically")
+csfml_set_option(CSFML_LINK_SFML_STATICALLY ${LINK_STATICALLY_DEFAULT} BOOL "ON to link to a static version of SFML, OFF to link dynamically")
-
-# disable the rpath stuff
-set(CMAKE_SKIP_BUILD_RPATH TRUE)
 
 # define an option for choosing between static and dynamic C runtime (Windows only)
 if(SFML_OS_WINDOWS)
-    set(STATIC_STD_LIBS FALSE CACHE BOOL "TRUE to statically link to the standard libraries, FALSE to use them as DLLs")
+    csfml_set_option(CSFML_USE_STATIC_STD_LIBS OFF BOOL "ON to statically link to the standard libraries, OFF to use them as DLLs")
-
-    # for VC++, we can apply it globally by modifying the compiler flags
-    if(SFML_COMPILER_MSVC AND STATIC_STD_LIBS)
-        foreach(flag
-                CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-            if(${flag} MATCHES "/MD")
-                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
-            endif()
-        endforeach()
-    endif()
 endif()
 
+# find SFML libraries (C++)
+if(CSFML_LINK_SFML_STATICALLY)
+    set(SFML_STATIC_LIBRARIES ON)
+endif()
+set(SFML_MODULES "System")
+if(CSFML_BUILD_AUDIO)
+    list(PREPEND SFML_MODULES "Audio")
+endif()
+if(CSFML_BUILD_GRAPHICS)
+    list(PREPEND SFML_MODULES "Graphics")
+endif()
+if(CSFML_BUILD_WINDOW)
+    list(PREPEND SFML_MODULES "Window")
+endif()
+if(CSFML_BUILD_NETWORK)
+    list(PREPEND SFML_MODULES "Network")
+endif()
+find_package(SFML 3.0.0 COMPONENTS ${SFML_MODULES} REQUIRED)
+
 # add the subdirectories
-add_subdirectory(src/SFML)
+add_subdirectory(src/CSFML)
 if(CSFML_BUILD_DOC)
     add_subdirectory(doc)
 endif()
 
 # on Linux and BSD-like OS, install pkg-config files by default
-set(CSFML_INSTALL_PKGCONFIG_DEFAULT FALSE)
+set(CSFML_INSTALL_PKGCONFIG_DEFAULT OFF)
 
 if(SFML_OS_LINUX OR SFML_OS_FREEBSD OR SFML_OS_OPENBSD OR SFML_OS_NETBSD)
-    set(CSFML_INSTALL_PKGCONFIG_DEFAULT TRUE)
+    set(CSFML_INSTALL_PKGCONFIG_DEFAULT ON)
 endif()
 
-csfml_set_option(CSFML_INSTALL_PKGCONFIG_FILES ${CSFML_INSTALL_PKGCONFIG_DEFAULT} BOOL "TRUE to automatically install pkg-config files so other projects can find SFML")
+csfml_set_option(CSFML_INSTALL_PKGCONFIG_FILES ${CSFML_INSTALL_PKGCONFIG_DEFAULT} BOOL "ON to automatically install pkg-config files so other projects can find SFML")
 
 if(CSFML_INSTALL_PKGCONFIG_FILES)
-    csfml_set_option(CSFML_PKGCONFIG_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/${CSFML_PKGCONFIG_DIR}" PATH "Install directory for CSFML's pkg-config .pc files")
+    csfml_set_option(CSFML_PKGCONFIG_INSTALL_DIR "${CSFML_PKGCONFIG_DIR}" PATH "Install directory for CSFML's pkg-config .pc files")
 
     foreach(csfml_module IN ITEMS all system window graphics audio network)
         configure_file(
@@ -76,7 +92,7 @@ if(CSFML_INSTALL_PKGCONFIG_FILES)
             "tools/pkg-config/csfml-${csfml_module}.pc"
             @ONLY)
         install(FILES "${CMAKE_CURRENT_BINARY_DIR}/tools/pkg-config/csfml-${csfml_module}.pc"
-            DESTINATION "${CSFML_PKGCONFIG_INSTALL_PREFIX}")
+            DESTINATION "${CSFML_PKGCONFIG_INSTALL_DIR}")
     endforeach()
 endif()
 
@@ -87,8 +103,30 @@ install(DIRECTORY include/
 install(FILES license.md DESTINATION ${INSTALL_MISC_DIR})
 install(FILES readme.md DESTINATION ${INSTALL_MISC_DIR})
 
+# stop configuration if consuming CSFML as a subdirectory
+if(NOT PROJECT_IS_TOP_LEVEL)
+    return()
+endif()
+
 # add an option for building the examples
-csfml_set_option(CSFML_BUILD_EXAMPLES FALSE BOOL "TRUE to build the CSFML examples, FALSE to ignore them")
+csfml_set_option(CSFML_BUILD_EXAMPLES OFF BOOL "ON to build the CSFML examples, OFF to ignore them")
 if(CSFML_BUILD_EXAMPLES)
     add_subdirectory(examples)
 endif()
+
+# add an option for building the tests
+csfml_set_option(CSFML_BUILD_TEST_SUITE OFF BOOL "ON to build the CSFML test suite, OFF to ignore it")
+if(CSFML_BUILD_TEST_SUITE)
+    enable_testing()
+    add_subdirectory(test)
+endif()
+
+csfml_set_option(CLANG_FORMAT_EXECUTABLE clang-format STRING "Override clang-format executable, requires version 17")
+add_custom_target(format
+    COMMAND ${CMAKE_COMMAND} -DCLANG_FORMAT_EXECUTABLE=${CLANG_FORMAT_EXECUTABLE} -P ./cmake/Format.cmake
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} VERBATIM)
+
+csfml_set_option(CLANG_TIDY_EXECUTABLE clang-tidy STRING "Override clang-tidy executable, requires minimum version 14")
+add_custom_target(tidy
+    COMMAND ${CMAKE_COMMAND} -DCLANG_TIDY_EXECUTABLE=${CLANG_TIDY_EXECUTABLE} -DPROJECT_BINARY_DIR=${PROJECT_BINARY_DIR} -P ./cmake/Tidy.cmake
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} VERBATIM)

CMakePresets.json

@@ -0,0 +1,19 @@
+{
+  "version": 3,
+  "configurePresets":[
+    {
+      "name": "dev",
+      "binaryDir": "build",
+      "installDir": "${sourceDir}/build/install",
+      "cacheVariables": {
+        "CMAKE_C_EXTENSIONS": "OFF",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+        "CMAKE_RUNTIME_OUTPUT_DIRECTORY": "${sourceDir}/build/bin",
+        "CSFML_BUILD_EXAMPLES": "ON",
+        "CSFML_BUILD_TEST_SUITE": "ON",
+        "CSFML_WARNINGS_AS_ERRORS": "ON"
+      }
+    }
+  ]
+}

cmake/CompilerWarnings.cmake

@@ -2,9 +2,9 @@
 #
 # https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
 
-# Helper function to enable compiler warnings for a specific set of files
+# Helper function to enable compiler warnings for a specific target
-function(set_file_warnings)
+function(set_target_warnings target)
-    option(WARNINGS_AS_ERRORS "Treat compiler warnings as errors" FALSE)
+    option(CSFML_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
 
     set(MSVC_WARNINGS
         /W4 # Baseline reasonable warnings
@@ -27,13 +27,11 @@ function(set_file_warnings)
         /w14905 # wide string literal cast to 'LPSTR'
         /w14906 # string literal cast to 'LPWSTR'
         /w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
-        # /permissive- # standards conformance mode for MSVC compiler. Disabled until all out-of-the-box Windows SDKs can successfully build with it.
+        /permissive- # standards conformance mode for MSVC compiler
 
         # Disables, remove when appropriate
         /wd4996 # disable warnings about deprecated functions
-        /wd4068 # disable warnings about unknown pragmas (e.g. #pragma GCC)
+        /wd5105 # disable warning about expansion of 'defined' keyword
-        /wd4505 # disable warnings about unused functions that might be platform-specific
-        /wd4800 # disable warnings regarding implicit conversions to bool
     )
 
     set(CLANG_AND_GCC_WARNINGS
@@ -57,18 +55,17 @@ function(set_file_warnings)
 
     # Disable warnings as errors when using Clang on Windows to work around deprecation warnings in Windows APIs
     if(SFML_OS_WINDOWS AND (SFML_COMPILER_CLANG OR SFML_COMPILER_CLANG_CL))
-        set(WARNINGS_AS_ERRORS FALSE)
+        set(CSFML_WARNINGS_AS_ERRORS OFF)
     endif()
 
-    if(WARNINGS_AS_ERRORS)
+    if(CSFML_WARNINGS_AS_ERRORS)
-        set(CLANG_AND_GCC_WARNINGS ${CLANG_AND_GCC_WARNINGS} -Werror)
+        list(APPEND CLANG_AND_GCC_WARNINGS -Werror)
-        set(MSVC_WARNINGS ${MSVC_WARNINGS} /WX)
+        list(APPEND MSVC_WARNINGS /WX)
     endif()
 
     set(CLANG_WARNINGS
         ${CLANG_AND_GCC_WARNINGS}
         -Wno-unknown-warning-option # do not warn on GCC-specific warning diagnostic pragmas
-        -Wno-c++11-long-long # do not warn on uses of long long
     )
 
     set(GCC_WARNINGS
@@ -82,8 +79,7 @@ function(set_file_warnings)
     # Don't enable -Wduplicated-branches for GCC < 8.1 since it will lead to false positives
     # https://github.com/gcc-mirror/gcc/commit/6bebae75035889a4844eb4d32a695bebf412bcd7
     if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
-        set(GCC_WARNINGS
+        list(APPEND GCC_WARNINGS
-            ${GCC_WARNINGS}
             -Wduplicated-branches # warn if if / else branches have duplicated code
         )
     endif()
@@ -98,7 +94,5 @@ function(set_file_warnings)
         message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
     endif()
 
-    foreach(WARNING ${FILE_WARNINGS})
+    target_compile_options(${target} PRIVATE ${FILE_WARNINGS})
-        set_property(SOURCE ${ARGV} APPEND_STRING PROPERTY COMPILE_FLAGS " ${WARNING}")
-    endforeach()
 endfunction()

cmake/Config.cmake

@@ -1,32 +1,12 @@
 # detect the OS
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
     set(SFML_OS_WINDOWS 1)
-
-    # detect the architecture (note: this test won't work for cross-compilation)
-    include(CheckTypeSize)
-    check_type_size(void* SIZEOF_VOID_PTR)
-    if("${SIZEOF_VOID_PTR}" STREQUAL "4")
-        set(ARCH_32BITS 1)
-    elseif("${SIZEOF_VOID_PTR}" STREQUAL "8")
-        set(ARCH_64BITS 1)
-    else()
-        message(FATAL_ERROR "Unsupported architecture")
-        return()
-    endif()
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     set(SFML_OS_LINUX 1)
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
     set(SFML_OS_FREEBSD 1)
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(SFML_OS_MACOSX 1)
-
-    # detect OS X version. (use '/usr/bin/sw_vers -productVersion' to extract V from '10.V.x'.)
-    EXEC_PROGRAM(/usr/bin/sw_vers ARGS -productVersion OUTPUT_VARIABLE MACOSX_VERSION_RAW)
-    STRING(REGEX REPLACE "10\\.([0-9]+).*" "\\1" MACOSX_VERSION "${MACOSX_VERSION_RAW}")
-    if(${MACOSX_VERSION} LESS 5)
-        message(FATAL_ERROR "Unsupported version of OS X : ${MACOSX_VERSION_RAW}")
-        return()
-    endif()
 else()
     message(FATAL_ERROR "Unsupported operating system")
     return()
@@ -34,10 +14,10 @@ endif()
 
 # set pkgconfig install directory
 # this could be e.g. macports on mac or msys2 on windows etc.
-set(CSFML_PKGCONFIG_DIR "/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+set(CSFML_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
 
 if(SFML_OS_FREEBSD OR SFML_OS_OPENBSD OR SFML_OS_NETBSD)
-    set(CSFML_PKGCONFIG_DIR "/libdata/pkgconfig")
+    set(CSFML_PKGCONFIG_DIR "libdata/pkgconfig")
 endif()
 
 # detect the compiler and its version
@@ -52,24 +32,13 @@ if(MSVC)
     endif()
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(SFML_COMPILER_CLANG 1)
-
-    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "--version" OUTPUT_VARIABLE CLANG_VERSION_OUTPUT)
-    string(REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" SFML_CLANG_VERSION "${CLANG_VERSION_OUTPUT}")
 elseif(CMAKE_COMPILER_IS_GNUCXX)
     set(SFML_COMPILER_GCC 1)
 
-    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-dumpversion" OUTPUT_VARIABLE GCC_VERSION_OUTPUT)
-    string(REGEX REPLACE "([0-9]+\\.[0-9]+).*" "\\1" SFML_GCC_VERSION "${GCC_VERSION_OUTPUT}")
     execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "--version" OUTPUT_VARIABLE GCC_COMPILER_VERSION)
     string(REGEX MATCHALL ".*(tdm[64]*-[1-9]).*" SFML_COMPILER_GCC_TDM "${GCC_COMPILER_VERSION}")
-    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-dumpmachine" OUTPUT_VARIABLE GCC_MACHINE)
-    string(STRIP "${GCC_MACHINE}" GCC_MACHINE)
-
-    if(GCC_MACHINE MATCHES ".*w64.*")
-        set(SFML_COMPILER_GCC_W64 1)
-    endif()
 else()
-    message(FATAL_ERROR "Unsupported compiler")
+    message(WARNING "Unsupported compiler")
     return()
 endif()
 

cmake/Format.cmake

@@ -0,0 +1,27 @@
+# Check executable exists
+if(NOT EXISTS ${CLANG_FORMAT_EXECUTABLE})
+    find_program(CLANG_FORMAT_EXEC_TEMP ${CLANG_FORMAT_EXECUTABLE})
+    if(CLANG_FORMAT_EXEC_TEMP)
+        set(CLANG_FORMAT_EXECUTABLE ${CLANG_FORMAT_EXEC_TEMP})
+        unset(CLANG_FORMAT_EXEC_TEMP)
+    else()
+        message(FATAL_ERROR "Unable to find clang-format executable: \"${CLANG_FORMAT_EXECUTABLE}\"")
+    endif()
+endif()
+
+# Check executable version
+execute_process(COMMAND ${CLANG_FORMAT_EXECUTABLE} --version OUTPUT_VARIABLE CLANG_FORMAT_VERSION)
+string(REGEX MATCH "clang-format version ([0-9]+)" CLANG_FORMAT_VERSION ${CLANG_FORMAT_VERSION})
+unset(CLANG_FORMAT_VERSION)
+if(NOT CMAKE_MATCH_1 EQUAL 17)
+    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 17")
+endif()
+
+# Run
+set(SOURCES "")
+foreach(FOLDER IN ITEMS examples include src test)
+    file(GLOB_RECURSE folder_files "${FOLDER}/*.h" "${FOLDER}/*.hpp" "${FOLDER}/*.c" "${FOLDER}/*.cpp")
+    list(APPEND SOURCES ${folder_files})
+endforeach()
+
+execute_process(COMMAND ${CLANG_FORMAT_EXECUTABLE} -i ${SOURCES})

cmake/Macros.cmake

@@ -17,25 +17,38 @@ macro(csfml_add_library target)
     target_include_directories(${target} PUBLIC ${PROJECT_SOURCE_DIR}/include)
 
     # add warnings
-    set_file_warnings(${THIS_SOURCES})
+    set_target_warnings(${target})
+
+    # require C11 and C++17
+    target_compile_features(${target} PUBLIC c_std_11 cxx_std_17)
 
     # define the export symbol of the module
     string(REPLACE "-" "_" NAME_UPPER "${target}")
     string(TOUPPER "${NAME_UPPER}" NAME_UPPER)
     set_target_properties(${target} PROPERTIES DEFINE_SYMBOL ${NAME_UPPER}_EXPORTS)
 
-    if(SFML_OS_WINDOWS)
+    if(BUILD_SHARED_LIBS)
-        # include the major version number in Windows shared library names (but not import library names)
         set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -d)
-        set_target_properties(${target} PROPERTIES SUFFIX "-${PROJECT_VERSION_MAJOR}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+        if(SFML_OS_WINDOWS)
+            # include the major version number in Windows shared library names (but not import library names)
+            set_target_properties(${target} PROPERTIES SUFFIX "-${PROJECT_VERSION_MAJOR}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+            # on Windows/gcc get rid of "lib" prefix for shared libraries,
+            # and transform the ".dll.a" suffix into ".a" for import libraries
+            if (SFML_COMPILER_GCC OR SFML_COMPILER_CLANG)
+                set_target_properties(${target} PROPERTIES PREFIX "")
+                set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".a")
+            endif()
+        endif()
     else()
-        set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -d)
+        set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -s-d)
-    endif()
+        set_target_properties(${target} PROPERTIES RELEASE_POSTFIX -s)
-    if (SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
+        set_target_properties(${target} PROPERTIES MINSIZEREL_POSTFIX -s)
-        # on Windows/gcc get rid of "lib" prefix for shared libraries,
+        set_target_properties(${target} PROPERTIES RELWITHDEBINFO_POSTFIX -s)
-        # and transform the ".dll.a" suffix into ".a" for import libraries
+
-        set_target_properties(${target} PROPERTIES PREFIX "")
+        if(CSFML_USE_STATIC_STD_LIBS)
-        set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".a")
+            set_property(TARGET ${target} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+        endif()
     endif()
 
     # set the version and soversion of the target (for compatible systems -- mostly Linuxes)
@@ -45,20 +58,17 @@ macro(csfml_add_library target)
     # set the target's folder (for IDEs that support it, e.g. Visual Studio)
     set_target_properties(${target} PROPERTIES FOLDER "CSFML")
 
-    # for gcc >= 4.0 on Windows, apply the SFML_USE_STATIC_STD_LIBS option if it is enabled
+    # apply the CSFML_USE_STATIC_STD_LIBS option if it is enabled
-    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4")
+    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-        if(SFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
+        if(CSFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-        elseif(NOT SFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
+        elseif(NOT CSFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
         endif()
     endif()
 
-    # if using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default
+    # ensure public symbols are hidden by default (exported ones are explicitly marked)
-    # (exported ones are explicitely marked)
+    set_target_properties(${target} PROPERTIES CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
-    if(NOT SFML_OS_WINDOWS AND ((SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4") OR (SFML_COMPILER_CLANG AND NOT SFML_CLANG_VERSION VERSION_LESS "3")))
-        set_target_properties(${target} PROPERTIES COMPILE_FLAGS -fvisibility=hidden)
-    endif()
 
     # link the target to its external dependencies (C++ SFML libraries)
     target_link_libraries(${target} PRIVATE ${THIS_DEPENDS})
@@ -66,9 +76,7 @@ macro(csfml_add_library target)
     # build dylibs
     if(SFML_OS_MACOSX AND BUILD_SHARED_LIBS)
         # adapt install directory to allow distributing dylibs in user’s application bundle
-        set_target_properties(${target} PROPERTIES
+        set_target_properties(${target} PROPERTIES INSTALL_NAME_DIR "@rpath")
-                              BUILD_WITH_INSTALL_RPATH 1
-                              INSTALL_NAME_DIR "@rpath")
     endif()
 
     # add the install rule
@@ -77,4 +85,9 @@ macro(csfml_add_library target)
             LIBRARY DESTINATION lib${LIB_SUFFIX} COMPONENT bin
             ARCHIVE DESTINATION lib${LIB_SUFFIX} COMPONENT devel)
 
+    # define CSFML_STATIC if the build type is not set to 'shared'
+    if(NOT BUILD_SHARED_LIBS)
+        target_compile_definitions(${target} PUBLIC CSFML_STATIC)
+    endif()
+
 endmacro()

cmake/Tidy.cmake

@@ -0,0 +1,34 @@
+# Check executable exists
+if(NOT EXISTS ${CLANG_TIDY_EXECUTABLE})
+    find_program(CLANG_TIDY_EXEC_TEMP ${CLANG_TIDY_EXECUTABLE})
+    if(CLANG_TIDY_EXEC_TEMP)
+        set(CLANG_TIDY_EXECUTABLE ${CLANG_TIDY_EXEC_TEMP})
+        unset(CLANG_TIDY_EXEC_TEMP)
+    else()
+        message(FATAL_ERROR "Unable to find clang-tidy executable: \"${CLANG_TIDY_EXECUTABLE}\"")
+    endif()
+endif()
+
+# Check executable version
+execute_process(COMMAND ${CLANG_TIDY_EXECUTABLE} --version OUTPUT_VARIABLE CLANG_TIDY_VERSION)
+string(REGEX MATCH "version ([0-9]+)" CLANG_TIDY_VERSION ${CLANG_TIDY_VERSION})
+unset(CLANG_TIDY_VERSION)
+if(CMAKE_MATCH_1 GREATER_EQUAL 14)
+    message(STATUS "Using clang-tidy version ${CMAKE_MATCH_1}")
+else()
+    message(FATAL_ERROR "clang-tidy version ${CMAKE_MATCH_1} is too low")
+endif()
+
+# Find Python and run-clang-tidy script
+find_package(Python 3 REQUIRED)
+
+find_program(RUN_CLANG_TIDY run-clang-tidy)
+if(NOT RUN_CLANG_TIDY)
+    message(FATAL_ERROR "Failed to find run-clang-tidy script")
+endif()
+
+# Run
+execute_process(COMMAND ${Python_EXECUTABLE} ${RUN_CLANG_TIDY} -clang-tidy-binary ${CLANG_TIDY_EXECUTABLE} -quiet -p ${PROJECT_BINARY_DIR} RESULTS_VARIABLE EXIT_CODE)
+if(NOT EXIT_CODE STREQUAL 0)
+    message(FATAL_ERROR "Analysis failed")
+endif()

doc/CMakeLists.txt

@@ -1,12 +1,9 @@
-
 # find doxygen
 find_package(Doxygen REQUIRED)
 
-# set the input and output documentation paths
-set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR})
-set(DOXYGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/doc)
-
 # see if we can generate the CHM documentation
+set(DOXYGEN_HHC_PROGRAM)
+set(DOXYGEN_GENERATE_HTMLHELP NO)
 if(SFML_OS_WINDOWS)
     # if HHC is found, we can generate the CHM (compressed HTML) output
     find_program(DOXYGEN_HHC_PROGRAM
@@ -14,35 +11,35 @@ if(SFML_OS_WINDOWS)
                  PATHS "C:/Program Files/HTML Help Workshop" "C:/Program Files (x86)/HTML Help Workshop"
                  DOC "HTML Help Compiler program")
     if(DOXYGEN_HHC_PROGRAM)
-        set(DOXYGEN_GENERATE_HTMLHELP YES)
+        if(DOXYGEN_VERSION VERSION_LESS "1.10.0")
-    else()
+            set(DOXYGEN_GENERATE_HTMLHELP YES)
-        set(DOXYGEN_GENERATE_HTMLHELP NO)
+        else()
+            message("Due to conflicts with the HTML output settings in Doxygen ${DOXYGEN_VERSION}, the HTML Help generation will be disabled")
+        endif()
     endif()
-else()
-    set(DOXYGEN_HHC_PROGRAM)
-    set(DOXYGEN_GENERATE_HTMLHELP NO)
 endif()
 
 # configure the source Doxyfile by copying it and replacing all @variables@
-set(DOXYGEN_CONFIGURED_INPUT ${DOXYGEN_OUTPUT_DIR}/doxyfile)
+configure_file(doxyfile.in doxyfile @ONLY)
-configure_file(${DOXYGEN_INPUT_DIR}/doc/doxyfile.in ${DOXYGEN_CONFIGURED_INPUT} @ONLY)
+configure_file(header.html.in header.html @ONLY)
 
 # copy the files needed by the documentation
-configure_file(${DOXYGEN_INPUT_DIR}/doc/doxygen.css ${DOXYGEN_OUTPUT_DIR}/html/doxygen.css COPYONLY)
+configure_file(doxygen.css html/doxygen.css COPYONLY)
+configure_file(searchOverrides.css html/searchOverrides.css COPYONLY)
 
 # target setup
 add_custom_target(doc ALL
                   COMMAND ${CMAKE_COMMAND} -E echo_append "Building API Documentation..."
-                  COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CONFIGURED_INPUT}
+                  COMMAND Doxygen::doxygen ${CMAKE_CURRENT_BINARY_DIR}/doxyfile
                   COMMAND ${CMAKE_COMMAND} -E echo "Done."
-                  WORKING_DIRECTORY ${DOXYGEN_INPUT_DIR})
+                  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
 
 # setup install rules
-install(DIRECTORY ${DOXYGEN_OUTPUT_DIR}/html
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
         DESTINATION ${INSTALL_MISC_DIR}/doc
         COMPONENT doc)
 if(DOXYGEN_HHC_PROGRAM)
-    install(FILES ${DOXYGEN_OUTPUT_DIR}/CSFML.chm
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/CSFML.chm
             DESTINATION ${INSTALL_MISC_DIR}/doc
             COMPONENT doc)
 endif()

doc/doxygen.css

@@ -147,12 +147,53 @@ div.fragment {
 
     font-family: Consolas, "Liberation Mono", Courier, monospace;
     font-size: 10pt;
+    position: relative;
     padding: 0.5em 1em;
     background-color: #f5f5f5;
     border: 1px solid #bbb;
     border-radius(5px);
 }
 
+.clipboard {
+    width: 24px;
+    height: 24px;
+    right: 5px;
+    top: 5px;
+    opacity: 0;
+    position: absolute;
+    display: inline;
+    overflow: auto;
+    fill: black;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+}
+
+.clipboard.success {
+    border: 1px solid black;
+    border-radius: 4px;
+}
+
+.fragment:hover .clipboard, .clipboard.success {
+    opacity: .28;
+}
+
+.clipboard:hover, .clipboard.success {
+    opacity: 1 !important;
+}
+
+.clipboard:active:not([class~=success]) svg {
+    transform: scale(.91);
+}
+
+.clipboard.success svg {
+    fill: #2EC82E;
+}
+
+.clipboard.success {
+    border-color: #2EC82E;
+}
+
 div.line {
     min-height: 13px;
     text-wrap: unrestricted;
@@ -1062,18 +1103,26 @@ tr.heading h2 {
     display: table;
 }
 
+.tablist {
+    width: 100%;
+}
+
 .tablist li {
     float: left;
     display: table-cell;
     list-style: none;
 }
 
+#navrow1 .tablist li:last-child {
+    float: right;
+}
+
 #navrow1 {
     border-top: 1px solid #999;
     margin-top: 2em;
 }
 
-#navrow1 .tablist a, #navrow2 .tablist a, #navrow3 .tablist a, #navrow4 .tablist a {
+#navrow1 .tablist a:not(#MSearchClose), #navrow2 .tablist a, #navrow3 .tablist a, #navrow4 .tablist a {
     display: block;
     margin: 8px 0;
     padding: 0 8px;
@@ -1246,7 +1295,7 @@ div.contents ul li {
     width: 24px;
     height: 18px;
     margin-bottom: 4px;
-    background-image:url('ftv2folderopen.png');
+    background-image:url('folderopen.svg');
     background-position: 0px -4px;
     background-repeat: repeat-y;
     vertical-align:top;
@@ -1257,7 +1306,7 @@ div.contents ul li {
     width: 24px;
     height: 18px;
     margin-bottom: 4px;
-    background-image:url('ftv2folderclosed.png');
+    background-image:url('folderclosed.svg');
     background-position: 0px -4px;
     background-repeat: repeat-y;
     vertical-align:top;
@@ -1268,7 +1317,7 @@ div.contents ul li {
     width: 24px;
     height: 18px;
     margin-bottom: 4px;
-    background-image:url('ftv2doc.png');
+    background-image:url('doc.svg');
     background-position: 0px -4px;
     background-repeat: repeat-y;
     vertical-align:top;

doc/footer.html

@@ -1,8 +1,9 @@
         </div>
         <div id="footer-container">
             <div id="footer">
-                Copyright © Laurent Gomila &nbsp;::&nbsp;
+                CSFML is licensed under the terms and conditions of the <a href="https://www.sfml-dev.org/license.php">zlib/png license</a>.<br />
-                Documentation generated by <a href="http://www.doxygen.org/" title="doxygen website">doxygen</a> &nbsp;::&nbsp;
+                Copyright &copy; Laurent Gomila &nbsp;::&nbsp;
+                Documentation generated by <a href="https://www.doxygen.nl/" title="doxygen website">doxygen</a> &nbsp;::&nbsp;
             </div>
         </div>
     </body>

doc/header.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-    <head>
-        <title>CSFML - C binding of the Simple and Fast Multimedia Library</title>
-        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
-        <!--<link rel='stylesheet' type='text/css' href="http://fonts.googleapis.com/css?family=Ubuntu:400,700,400italic"/>-->
-        <link rel="stylesheet" type="text/css" href="doxygen.css" title="default" media="screen,print" />
-    </head>
-    <body>
-        <div id="banner-container">
-            <div id="banner">
-                <span id="sfml">CSFML</span>
-            </div>
-        </div>
-        <div id="content">

doc/header.html.in

@@ -0,0 +1,29 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>CSFML - C binding of the Simple and Fast Multimedia Library</title>
+        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
+        <!--<link rel='stylesheet' type='text/css' href="http://fonts.googleapis.com/css?family=Ubuntu:400,700,400italic"/>-->
+        <link rel="stylesheet" type="text/css" href="doxygen.css" title="default" media="screen,print" />
+        <script type="text/javascript" src="jquery.js"></script>
+        <script type="text/javascript" src="dynsections.js"></script>
+        <script type="text/javascript" src="clipboard.js"></script>
+        <script type="text/javascript" src="cookie.js"></script>
+        <link rel="stylesheet" type="text/css" href="search/search.css" />
+        <link rel="stylesheet" type="text/css" href="searchOverrides.css" />
+        <script type="text/javascript" src="search/searchdata.js"></script>
+        <script type="text/javascript" src="search/search.js"></script>
+        <script type="text/javascript">
+        /* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
+          $(document).ready(function() { init_search(); });
+        /* @license-end */
+        </script>
+    </head>
+    <body>
+        <div id="banner-container">
+            <div id="banner">
+                <span id="sfml">CSFML @PROJECT_VERSION@</span>
+            </div>
+        </div>
+        <div id="content">
+            <div>

doc/mainpage.hpp

@@ -3,21 +3,21 @@
 ///
 /// \section welcome Welcome
 /// Welcome to the official SFML documentation for C. Here you will find a detailed
-/// view of all the SFML <a href="./globals_func.htm">functions</a>.<br/>
+/// view of all the SFML <a href="./globals_func.html">functions</a>.<br/>
 /// If you are looking for tutorials, you can visit the official website
-/// at <a href="http://www.sfml-dev.org/">www.sfml-dev.org</a>.
+/// at <a href="https://www.sfml-dev.org/">www.sfml-dev.org</a>.
 ///
 /// \section example Short example
 /// Here is a short example, to show you how simple it is to use SFML in C :
 ///
 /// \code
 ///
-/// #include <SFML/Audio.h>
+/// #include <CSFML/Audio.h>
-/// #include <SFML/Graphics.h>
+/// #include <CSFML/Graphics.h>
-/// 
+///
 /// int main()
 /// {
-///     sfVideoMode mode = {800, 600, 32};
+///     sfVideoMode mode = {{800, 600}, 32};
 ///     sfRenderWindow* window;
 ///     sfTexture* texture;
 ///     sfSprite* sprite;
@@ -36,8 +36,8 @@
 ///     if (!texture)
 ///         return EXIT_FAILURE;
 ///     sprite = sfSprite_create();
-///     sfSprite_setTexture(sprite, texture, sfTrue);
+///     sfSprite_setTexture(sprite, texture, true);
-/// 
+///
 ///     /* Create a graphical text to display */
 ///     font = sfFont_createFromFile("arial.ttf");
 ///     if (!font)
@@ -46,7 +46,7 @@
 ///     sfText_setString(text, "Hello SFML");
 ///     sfText_setFont(text, font);
 ///     sfText_setCharacterSize(text, 50);
-/// 
+///
 ///     /* Load a music to play */
 ///     music = sfMusic_createFromFile("nice_music.ogg");
 ///     if (!music)
@@ -54,7 +54,7 @@
 ///
 ///     /* Play the music */
 ///     sfMusic_play(music);
-/// 
+///
 ///     /* Start the game loop */
 ///     while (sfRenderWindow_isOpen(window))
 ///     {
@@ -65,20 +65,20 @@
 ///             if (event.type == sfEvtClosed)
 ///                 sfRenderWindow_close(window);
 ///         }
-/// 
+///
 ///         /* Clear the screen */
 ///         sfRenderWindow_clear(window, sfBlack);
-/// 
+///
 ///         /* Draw the sprite */
 ///         sfRenderWindow_drawSprite(window, sprite, NULL);
-/// 
+///
 ///         /* Draw the text */
 ///         sfRenderWindow_drawText(window, text, NULL);
-/// 
+///
 ///         /* Update the window */
 ///         sfRenderWindow_display(window);
 ///     }
-/// 
+///
 ///     /* Cleanup resources */
 ///     sfMusic_destroy(music);
 ///     sfText_destroy(text);
@@ -86,7 +86,7 @@
 ///     sfSprite_destroy(sprite);
 ///     sfTexture_destroy(texture);
 ///     sfRenderWindow_destroy(window);
-/// 
+///
 ///     return EXIT_SUCCESS;
 /// }
 /// \endcode

doc/searchOverrides.css

@@ -0,0 +1,45 @@
+/* Override search/search.css rules to adjust seach box placement */
+#MSearchBox {
+    position: relative;
+    display: block;
+    border-radius: 0;
+    box-shadow: none;
+    border-width: 1px;
+    border-color: #BBB;
+    border-style: solid;
+}
+.right #MSearchClose {
+    margin: 0;
+    right: auto;
+}
+#MSearchResultsWindow {
+    background-color: #EAF5DB;
+    border-color: #999;
+}
+#MSearchResults > .SRPage {
+    background-color: #EAF5DB;
+}
+a.SRSymbol {
+    color: rgb(70, 100, 30);
+}
+a.SRSymbol:hover {
+    text-decoration: underline;
+}
+a.SRScope {
+    color: rgb(70, 100, 30);
+}
+a.SRScope:hover {
+    text-decoration: underline;
+}
+#MSearchSelectWindow {
+    background-color: #EAF5DB;
+}
+#MSearchSelectWindow > a.SelectItem {
+    color: #333;
+    text-decoration: none;
+}
+#MSearchSelectWindow > a.SelectItem:hover {
+    color: white;
+    background-color: #8CC841;
+    text-decoration: none;
+}

examples/CMakeLists.txt

@@ -1,5 +1,3 @@
-set(SRC example.c)
+add_executable(example example.c)
-
-add_executable(example ${SRC})
 target_link_libraries(example PRIVATE csfml-graphics csfml-audio)
-set_file_warnings(${SRC})
+set_target_warnings(example)

examples/example.c

@@ -1,30 +1,29 @@
-#include <SFML/Audio.h>
+#include <CSFML/Audio.h>
-#include <SFML/Graphics.h>
+#include <CSFML/Graphics.h>
 
 #include <stdlib.h>
 
 int main(void)
 {
     // Create the main window
-    const sfVideoMode mode = {800, 600, 32};
+    const sfVideoMode mode   = {{800, 600}, 32};
-    sfRenderWindow* window = sfRenderWindow_create(mode, "SFML window", sfResize | sfClose, NULL);
+    sfRenderWindow*   window = sfRenderWindow_create(mode, "SFML window", sfResize | sfClose, sfWindowed, NULL);
     if (!window)
         return EXIT_FAILURE;
 
     // Load a sprite to display
-    sfTexture* texture = sfTexture_createFromFile("sfml_logo.png", NULL);
+    const sfTexture* texture = sfTexture_createFromFile("sfml_logo.png", NULL);
     if (!texture)
     {
         sfRenderWindow_destroy(window);
         return EXIT_FAILURE;
     }
-    sfSprite* sprite = sfSprite_create();
+    sfSprite*        sprite         = sfSprite_create(texture);
-    sfSprite_setTexture(sprite, texture, sfTrue);
     const sfVector2f spritePosition = {200, 200};
     sfSprite_setPosition(sprite, spritePosition);
 
     // Create a graphical text to display
-    sfFont* font = sfFont_createFromFile("tuffy.ttf");
+    const sfFont* font = sfFont_createFromFile("tuffy.ttf");
     if (!font)
     {
         sfSprite_destroy(sprite);
@@ -32,9 +31,8 @@ int main(void)
         sfRenderWindow_destroy(window);
         return EXIT_FAILURE;
     }
-    sfText* text = sfText_create();
+    sfText* text = sfText_create(font);
     sfText_setString(text, "Hello, SFML!");
-    sfText_setFont(text, font);
     sfText_setCharacterSize(text, 50);
 
     // Load a music to play

include/CSFML/Audio.h

@@ -0,0 +1,39 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <CSFML/Audio/Listener.h>
+#include <CSFML/Audio/Music.h>
+#include <CSFML/Audio/Sound.h>
+#include <CSFML/Audio/SoundBuffer.h>
+#include <CSFML/Audio/SoundBufferRecorder.h>
+#include <CSFML/Audio/SoundRecorder.h>
+#include <CSFML/Audio/SoundStatus.h>
+#include <CSFML/Audio/SoundStream.h>
+#include <CSFML/System.h>

include/CSFML/Audio/EffectProcessor.h

@@ -0,0 +1,106 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+/// \brief Callable that is provided with sound data for processing
+///
+/// When the audio engine sources sound data from sound
+/// sources it will pass the data through an effects
+/// processor if one is set. The sound data will already be
+/// converted to the internal floating point format.
+///
+/// Sound data that is processed this way is provided in
+/// frames. Each frame contains 1 floating point sample per
+/// channel. If e.g. the data source provides stereo data,
+/// each frame will contain 2 floats.
+///
+/// The effects processor function takes 4 parameters:
+///   - The input data frames, channels interleaved
+///   - The number of input data frames available
+///   - The buffer to write output data frames to, channels interleaved
+///   - The number of output data frames that the output buffer can hold
+///   - The channel count
+///
+/// The input and output frame counts are in/out parameters.
+///
+/// When this function is called, the input count will
+/// contain the number of frames available in the input
+/// buffer. The output count will contain the size of the
+/// output buffer i.e. the maximum number of frames that
+/// can be written to the output buffer.
+///
+/// Attempting to read more frames than the input frame
+/// count or write more frames than the output frame count
+/// will result in undefined behaviour.
+///
+/// It is important to note that the channel count of the
+/// audio engine currently sourcing data from this sound
+/// will always be provided in `frameChannelCount`. This can
+/// be different from the channel count of the sound source
+/// so make sure to size necessary processing buffers
+/// according to the engine channel count and not the sound
+/// source channel count.
+///
+/// When done processing the frames, the input and output
+/// frame counts must be updated to reflect the actual
+/// number of frames that were read from the input and
+/// written to the output.
+///
+/// The processing function should always try to process as
+/// much sound data as possible i.e. always try to fill the
+/// output buffer to the maximum. In certain situations for
+/// specific effects it can be possible that the input frame
+/// count and output frame count aren't equal. As long as
+/// the frame counts are updated accordingly this is
+/// perfectly valid.
+///
+/// If the audio engine determines that no audio data is
+/// available from the data source, the input data frames
+/// pointer is set to `NULL` and the input frame count is
+/// set to 0. In this case it is up to the function to
+/// decide how to handle the situation. For specific effects
+/// e.g. Echo/Delay buffered data might still be able to be
+/// written to the output buffer even if there is no longer
+/// any input data.
+///
+/// An important thing to remember is that this function is
+/// directly called by the audio engine. Because the audio
+/// engine runs on an internal thread of its own, make sure
+/// access to shared data is synchronized appropriately.
+///
+/// Because this function is stored by the `SoundSource`
+/// object it will be able to be called as long as the
+/// `SoundSource` object hasn't yet been destroyed. Make sure
+/// that any data this function references outlives the
+/// SoundSource object otherwise use-after-free errors will
+/// occur.
+///
+////////////////////////////////////////////////////////////
+typedef void (*sfEffectProcessor)(const float*  inputFrames,
+                                  unsigned int* inputFrameCount,
+                                  float*        outputFrames,
+                                  unsigned int* outputFrameCount,
+                                  unsigned int  frameChannelCount);

include/CSFML/Audio/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_AUDIO_EXPORT_H
+#pragma once
-#define SFML_AUDIO_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,13 +35,10 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_AUDIO_EXPORTS)
 
-    #define CSFML_AUDIO_API CSFML_API_EXPORT
+#define CSFML_AUDIO_API CSFML_API_EXPORT
 
 #else
 
-    #define CSFML_AUDIO_API CSFML_API_IMPORT
+#define CSFML_AUDIO_API CSFML_API_IMPORT
 
 #endif
-
-
-#endif // SFML_AUDIO_EXPORT_H

include/CSFML/Audio/Listener.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,33 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_LISTENER_H
+#pragma once
-#define SFML_LISTENER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/System/Vector3.h>
+
+#include <CSFML/System/Vector3.h>
+
+
+////////////////////////////////////////////////////////////
+/// \brief Structure defining the properties of a directional cone
+///
+/// Sounds will play at gain 1 when they are positioned
+/// within the inner angle of the cone. Sounds will play
+/// at `outerGain` when they are positioned outside the
+/// outer angle of the cone. The gain declines linearly
+/// from 1 to `outerGain` as the sound moves from the inner
+/// angle to the outer angle.
+///
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    float innerAngle; //!< Inner angle, in degrees
+    float outerAngle; //!< Outer angle, in degrees
+    float outerGain;  //!< Outer gain
+} sfListenerCone;
 
 
 ////////////////////////////////////////////////////////////
@@ -93,6 +112,43 @@ CSFML_AUDIO_API void sfListener_setDirection(sfVector3f direction);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfVector3f sfListener_getDirection(void);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the velocity of the listener in the scene
+///
+/// The default listener's velocity is (0, 0, -1).
+///
+/// \param velocity New listener's velocity
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfListener_setVelocity(sfVector3f velocity);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the current forward vector of the listener in the scene
+///
+/// \return Listener's velocity
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfListener_getVelocity(void);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the cone properties of the listener in the audio scene
+///
+/// The cone defines how directional attenuation is applied.
+/// The default cone of a sound is (2 * PI, 2 * PI, 1).
+///
+/// \param cone Cone properties of the listener in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfListener_setCone(sfListenerCone cone);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the cone properties of the listener in the audio scene
+///
+/// \return Cone properties of the listener
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfListenerCone sfListener_getCone(void);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the upward vector of the listener in the scene
 ///
@@ -115,6 +171,3 @@ CSFML_AUDIO_API void sfListener_setUpVector(sfVector3f upVector);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfVector3f sfListener_getUpVector(void);
-
-
-#endif // SFML_LISTENER_H

include/CSFML/Audio/Music.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,18 +22,22 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_MUSIC_H
+#pragma once
-#define SFML_MUSIC_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/Audio/SoundStatus.h>
+
-#include <SFML/Audio/Types.h>
+#include <CSFML/Audio/EffectProcessor.h>
-#include <SFML/System/InputStream.h>
+#include <CSFML/Audio/SoundChannel.h>
-#include <SFML/System/Time.h>
+#include <CSFML/Audio/SoundSourceCone.h>
-#include <SFML/System/Vector3.h>
+#include <CSFML/Audio/SoundStatus.h>
+#include <CSFML/Audio/Types.h>
+#include <CSFML/System/InputStream.h>
+#include <CSFML/System/Time.h>
+#include <CSFML/System/Vector3.h>
+
 #include <stddef.h>
 
 
@@ -103,31 +107,43 @@ CSFML_AUDIO_API sfMusic* sfMusic_createFromStream(sfInputStream* stream);
 /// \param music Music to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_destroy(sfMusic* music);
+CSFML_AUDIO_API void sfMusic_destroy(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set whether or not a music should loop after reaching the end
 ///
 /// If set, the music will restart from beginning after
 /// reaching the end and so on, until it is stopped or
-/// sfMusic_setLoop(music, sfFalse) is called.
+/// sfMusic_setLooping(music, false) is called.
 /// The default looping state for musics is false.
 ///
 /// \param music Music object
-/// \param loop  sfTrue to play in loop, sfFalse to play once
+/// \param loop  true to play in loop, false to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setLoop(sfMusic* music, sfBool loop);
+CSFML_AUDIO_API void sfMusic_setLooping(sfMusic* music, bool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a music is in loop mode
 ///
 /// \param music Music object
 ///
-/// \return sfTrue if the music is looping, sfFalse otherwise
+/// \return true if the music is looping, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfMusic_getLoop(const sfMusic* music);
+CSFML_AUDIO_API bool sfMusic_isLooping(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the effect processor to be applied to the sound
+///
+/// The effect processor is a callable that will be called
+/// with sound data to be processed.
+///
+/// \param music           Music object
+/// \param effectProcessor The effect processor to attach to this sound, attach a null processor to disable processing
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setEffectProcessor(sfMusic* music, sfEffectProcessor effectProcessor);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the total duration of a music
@@ -142,6 +158,8 @@ CSFML_AUDIO_API sfTime sfMusic_getDuration(const sfMusic* music);
 ////////////////////////////////////////////////////////////
 /// \brief Get the positions of the of the sound's looping sequence
 ///
+/// \param music Music object
+///
 /// \return Loop Time position class.
 ///
 /// \warning Since sfMusic_setLoopPoints() performs some adjustments on the
@@ -157,7 +175,7 @@ CSFML_AUDIO_API sfTime sfMusic_getDuration(const sfMusic* music);
 CSFML_AUDIO_API sfTimeSpan sfMusic_getLoopPoints(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
-/// \brief Sets the beginning and end of the sound's looping sequence using sf::Time
+/// \brief Sets the beginning and end of the sound's looping sequence using sfTime
 ///
 /// Loop points allow one to specify a pair of positions such that, when the music
 /// is enabled for looping, it will seamlessly seek to the beginning whenever it
@@ -171,6 +189,7 @@ CSFML_AUDIO_API sfTimeSpan sfMusic_getLoopPoints(const sfMusic* music);
 /// \warning Setting the loop points while the stream's status is Paused
 /// will set its status to Stopped. The playing offset will be unaffected.
 ///
+/// \param music      Music object
 /// \param timePoints The definition of the loop. Can be any time points within the sound's length
 ///
 /// \see getLoopPoints
@@ -240,6 +259,20 @@ CSFML_AUDIO_API unsigned int sfMusic_getChannelCount(const sfMusic* music);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API unsigned int sfMusic_getSampleRate(const sfMusic* music);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the map of position in sample frame to sound channel
+///
+/// This is used to map a sample in the sample stream to a
+/// position during spatialization.
+///
+/// \param music Music object
+/// \param count Pointer to a variable that will be filled with the number of channels in the map
+///
+/// \return Map of position in sample frame to sound channel
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API const sfSoundChannel* sfMusic_getChannelMap(const sfMusic* music, size_t* count);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the current status of a music (stopped, paused, playing)
 ///
@@ -275,6 +308,20 @@ CSFML_AUDIO_API sfTime sfMusic_getPlayingOffset(const sfMusic* music);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfMusic_setPitch(sfMusic* music, float pitch);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the pan of the sound
+///
+/// Using panning, a mono sound can be panned between
+/// stereo channels. When the pan is set to -1, the sound
+/// is played only on the left channel, when the pan is set
+/// to +1, the sound is played only on the right channel.
+///
+/// \param music Music object
+/// \param pan   New pan to apply to the sound [-1, +1]
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setPan(sfMusic* music, float pan);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the volume of a music
 ///
@@ -287,6 +334,20 @@ CSFML_AUDIO_API void sfMusic_setPitch(sfMusic* music, float pitch);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfMusic_setVolume(sfMusic* music, float volume);
 
+////////////////////////////////////////////////////////////
+/// \brief Set whether spatialization of the sound is enabled
+///
+/// Spatialization is the application of various effects to
+/// simulate a sound being emitted at a virtual position in
+/// 3D space and exhibiting various physical phenomena such as
+/// directional attenuation and doppler shift.
+///
+/// \param music   Music object
+/// \param enabled `true` to enable spatialization, `false` to disable
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setSpatializationEnabled(sfMusic* music, bool enabled);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the 3D position of a music in the audio scene
 ///
@@ -300,6 +361,74 @@ CSFML_AUDIO_API void sfMusic_setVolume(sfMusic* music, float volume);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfMusic_setPosition(sfMusic* music, sfVector3f position);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D direction of the sound in the audio scene
+///
+/// The direction defines where the sound source is facing
+/// in 3D space. It will affect how the sound is attenuated
+/// if facing away from the listener.
+/// The default direction of a sound is (0, 0, -1).
+///
+/// \param music     Music object
+/// \param direction Direction of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setDirection(sfMusic* music, sfVector3f direction);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the cone properties of the sound in the audio scene
+///
+/// The cone defines how directional attenuation is applied.
+/// The default cone of a sound is (2 * PI, 2 * PI, 1).
+///
+/// \param music Music object
+/// \param cone  Cone properties of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setCone(sfMusic* music, sfSoundSourceCone cone);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D velocity of the sound in the audio scene
+///
+/// The velocity is used to determine how to doppler shift
+/// the sound. Sounds moving towards the listener will be
+/// perceived to have a higher pitch and sounds moving away
+/// from the listener will be perceived to have a lower pitch.
+///
+/// \param music    Music object
+/// \param velocity Velocity of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setVelocity(sfMusic* music, sfVector3f velocity);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the doppler factor of the sound
+///
+/// The doppler factor determines how strong the doppler
+/// shift will be.
+///
+/// \param music  Music object
+/// \param factor New doppler factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setDopplerFactor(sfMusic* music, float factor);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the directional attenuation factor of the sound
+///
+/// Depending on the virtual position of an output channel
+/// relative to the listener (such as in surround sound
+/// setups), sounds will be attenuated when emitting them
+/// from certain channels. This factor determines how strong
+/// the attenuation based on output channel position
+/// relative to the listener is.
+///
+/// \param music  Music object
+/// \param factor New directional attenuation factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setDirectionalAttenuationFactor(sfMusic* music, float factor);
+
 ////////////////////////////////////////////////////////////
 /// \brief Make a musics's position relative to the listener or absolute
 ///
@@ -310,10 +439,10 @@ CSFML_AUDIO_API void sfMusic_setPosition(sfMusic* music, sfVector3f position);
 /// The default value is false (position is absolute).
 ///
 /// \param music    Music object
-/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
+/// \param relative true to set the position relative, false to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, sfBool relative);
+CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, bool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a music
@@ -331,6 +460,48 @@ CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, sfBool relati
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfMusic_setMinDistance(sfMusic* music, float distance);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum distance of the sound
+///
+/// The "maximum distance" of a sound is the minimum
+/// distance at which it is heard at its minimum volume. Closer
+/// than the maximum distance, it will start to fade in according
+/// to its attenuation factor.
+/// The default value of the maximum distance is the maximum
+/// value a float can represent.
+///
+/// \param music    Music object
+/// \param distance New maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setMaxDistance(sfMusic* music, float distance);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the minimum gain of the sound
+///
+/// When the sound is further away from the listener than
+/// the "maximum distance" the attenuated gain is clamped
+/// so it cannot go below the minimum gain value.
+///
+/// \param music Music object
+/// \param gain  New minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setMinGain(sfMusic* music, float gain);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum gain of the sound
+///
+/// When the sound is closer from the listener than
+/// the "minimum distance" the attenuated gain is clamped
+/// so it cannot go above the maximum gain value.
+///
+/// \param music Music object
+/// \param gain  New maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfMusic_setMaxGain(sfMusic* music, float gain);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the attenuation factor of a music
 ///
@@ -371,6 +542,26 @@ CSFML_AUDIO_API void sfMusic_setPlayingOffset(sfMusic* music, sfTime timeOffset)
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfMusic_getPitch(const sfMusic* music);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the pan of the sound
+///
+/// \param music Music object
+///
+/// \return Pan of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getPan(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Tell whether spatialization of the sound is enabled
+///
+/// \param music Music object
+///
+/// \return `true` if spatialization is enabled, `false` if it's disabled
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API bool sfMusic_isSpatializationEnabled(const sfMusic* music);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the volume of a music
 ///
@@ -391,16 +582,66 @@ CSFML_AUDIO_API float sfMusic_getVolume(const sfMusic* music);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfVector3f sfMusic_getPosition(const sfMusic* music);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D direction of the sound in the audio scene
+///
+/// \param music Music object
+///
+/// \return Direction of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfMusic_getDirection(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the cone properties of the sound in the audio scene
+///
+/// \param music Music object
+///
+/// \return Cone properties of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundSourceCone sfMusic_getCone(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D velocity of the sound in the audio scene
+///
+/// \param music Music object
+///
+/// \return Velocity of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfMusic_getVelocity(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the doppler factor of the sound
+///
+/// \param music Music object
+///
+/// \return Doppler factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getDopplerFactor(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the directional attenuation factor of the sound
+///
+/// \param music Music object
+///
+/// \return Directional attenuation factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getDirectionalAttenuationFactor(const sfMusic* music);
+
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a music's position is relative to the
 ///        listener or is absolute
 ///
 /// \param music Music object
 ///
-/// \return sfTrue if the position is relative, sfFalse if it's absolute
+/// \return true if the position is relative, false if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfMusic_isRelativeToListener(const sfMusic* music);
+CSFML_AUDIO_API bool sfMusic_isRelativeToListener(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a music
@@ -412,6 +653,36 @@ CSFML_AUDIO_API sfBool sfMusic_isRelativeToListener(const sfMusic* music);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfMusic_getMinDistance(const sfMusic* music);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum distance of the sound
+///
+/// \param music Music object
+///
+/// \return Maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getMaxDistance(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the minimum gain of the sound
+///
+/// \param music Music object
+///
+/// \return Minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getMinGain(const sfMusic* music);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum gain of the sound
+///
+/// \param music Music object
+///
+/// \return Maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfMusic_getMaxGain(const sfMusic* music);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the attenuation factor of a music
 ///
@@ -421,6 +692,3 @@ CSFML_AUDIO_API float sfMusic_getMinDistance(const sfMusic* music);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfMusic_getAttenuation(const sfMusic* music);
-
-
-#endif // SFML_MUSIC_H

include/CSFML/Audio/Sound.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,26 +22,30 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUND_H
+#pragma once
-#define SFML_SOUND_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/Audio/SoundStatus.h>
+
-#include <SFML/Audio/Types.h>
+#include <CSFML/Audio/EffectProcessor.h>
-#include <SFML/System/Time.h>
+#include <CSFML/Audio/SoundSourceCone.h>
-#include <SFML/System/Vector3.h>
+#include <CSFML/Audio/SoundStatus.h>
+#include <CSFML/Audio/Types.h>
+#include <CSFML/System/Time.h>
+#include <CSFML/System/Vector3.h>
 
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound
 ///
+/// \param buffer Sound buffer containing the audio data to play with the sound
+///
 /// \return A new sfSound object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfSound* sfSound_create(void);
+CSFML_AUDIO_API sfSound* sfSound_create(const sfSoundBuffer* buffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound by copying an existing one
@@ -59,7 +63,7 @@ CSFML_AUDIO_API sfSound* sfSound_copy(const sfSound* sound);
 /// \param sound Sound to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_destroy(sfSound* sound);
+CSFML_AUDIO_API void sfSound_destroy(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start or resume playing a sound
@@ -126,24 +130,24 @@ CSFML_AUDIO_API const sfSoundBuffer* sfSound_getBuffer(const sfSound* sound);
 ///
 /// If set, the sound will restart from beginning after
 /// reaching the end and so on, until it is stopped or
-/// sfSound_setLoop(sound, sfFalse) is called.
+/// sfSound_setLooping(sound, false) is called.
 /// The default looping state for sounds is false.
 ///
 /// \param sound Sound object
-/// \param loop  sfTrue to play in loop, sfFalse to play once
+/// \param loop  true to play in loop, false to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setLoop(sfSound* sound, sfBool loop);
+CSFML_AUDIO_API void sfSound_setLooping(sfSound* sound, bool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a sound is in loop mode
 ///
 /// \param sound Sound object
 ///
-/// \return sfTrue if the sound is looping, sfFalse otherwise
+/// \return true if the sound is looping, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSound_getLoop(const sfSound* sound);
+CSFML_AUDIO_API bool sfSound_isLooping(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current status of a sound (stopped, paused, playing)
@@ -170,6 +174,21 @@ CSFML_AUDIO_API sfSoundStatus sfSound_getStatus(const sfSound* sound);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfSound_setPitch(sfSound* sound, float pitch);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the pan of the sound
+///
+/// Using panning, a mono sound can be panned between
+/// stereo channels. When the pan is set to -1, the sound
+/// is played only on the left channel, when the pan is set
+/// to +1, the sound is played only on the right channel.
+///
+/// \param sound Sound object
+/// \param pan   New pan to apply to the sound [-1, +1]
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setPan(sfSound* sound, float pan);
+
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the volume of a sound
 ///
@@ -182,6 +201,20 @@ CSFML_AUDIO_API void sfSound_setPitch(sfSound* sound, float pitch);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfSound_setVolume(sfSound* sound, float volume);
 
+////////////////////////////////////////////////////////////
+/// \brief Set whether spatialization of the sound is enabled
+///
+/// Spatialization is the application of various effects to
+/// simulate a sound being emitted at a virtual position in
+/// 3D space and exhibiting various physical phenomena such as
+/// directional attenuation and doppler shift.
+///
+/// \param sound   Sound object
+/// \param enabled `true` to enable spatialization, `false` to disable
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setSpatializationEnabled(sfSound* sound, bool enabled);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the 3D position of a sound in the audio scene
 ///
@@ -195,6 +228,74 @@ CSFML_AUDIO_API void sfSound_setVolume(sfSound* sound, float volume);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfSound_setPosition(sfSound* sound, sfVector3f position);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D direction of the sound in the audio scene
+///
+/// The direction defines where the sound source is facing
+/// in 3D space. It will affect how the sound is attenuated
+/// if facing away from the listener.
+/// The default direction of a sound is (0, 0, -1).
+///
+/// \param sound     Sound object
+/// \param direction Direction of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setDirection(sfSound* sound, sfVector3f direction);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the cone properties of the sound in the audio scene
+///
+/// The cone defines how directional attenuation is applied.
+/// The default cone of a sound is (2 * PI, 2 * PI, 1).
+///
+/// \param sound Sound object
+/// \param cone  Cone properties of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setCone(sfSound* sound, sfSoundSourceCone cone);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D velocity of the sound in the audio scene
+///
+/// The velocity is used to determine how to doppler shift
+/// the sound. Sounds moving towards the listener will be
+/// perceived to have a higher pitch and sounds moving away
+/// from the listener will be perceived to have a lower pitch.
+///
+/// \param sound    Sound object
+/// \param velocity Velocity of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setVelocity(sfSound* sound, sfVector3f velocity);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the doppler factor of the sound
+///
+/// The doppler factor determines how strong the doppler
+/// shift will be.
+///
+/// \param sound  Sound object
+/// \param factor New doppler factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setDopplerFactor(sfSound* sound, float factor);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the directional attenuation factor of the sound
+///
+/// Depending on the virtual position of an output channel
+/// relative to the listener (such as in surround sound
+/// setups), sounds will be attenuated when emitting them
+/// from certain channels. This factor determines how strong
+/// the attenuation based on output channel position
+/// relative to the listener is.
+///
+/// \param sound  Sound object
+/// \param factor New directional attenuation factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setDirectionalAttenuationFactor(sfSound* sound, float factor);
+
 ////////////////////////////////////////////////////////////
 /// \brief Make the sound's position relative to the listener or absolute
 ///
@@ -205,10 +306,10 @@ CSFML_AUDIO_API void sfSound_setPosition(sfSound* sound, sfVector3f position);
 /// The default value is false (position is absolute).
 ///
 /// \param sound    Sound object
-/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
+/// \param relative true to set the position relative, false to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, sfBool relative);
+CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, bool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a sound
@@ -226,6 +327,49 @@ CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, sfBool relati
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfSound_setMinDistance(sfSound* sound, float distance);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum distance of the sound
+///
+/// The "maximum distance" of a sound is the minimum
+/// distance at which it is heard at its minimum volume. Closer
+/// than the maximum distance, it will start to fade in according
+/// to its attenuation factor.
+/// The default value of the maximum distance is the maximum
+/// value a float can represent.
+///
+/// \param sound    Sound object
+/// \param distance New maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setMaxDistance(sfSound* sound, float distance);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the minimum gain of the sound
+///
+/// When the sound is further away from the listener than
+/// the "maximum distance" the attenuated gain is clamped
+/// so it cannot go below the minimum gain value.
+///
+/// \param sound Sound object
+/// \param gain  New minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setMinGain(sfSound* sound, float gain);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum gain of the sound
+///
+/// When the sound is closer from the listener than
+/// the "minimum distance" the attenuated gain is clamped
+/// so it cannot go above the maximum gain value.
+///
+///
+/// \param sound Sound object
+/// \param gain  New maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setMaxGain(sfSound* sound, float gain);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the attenuation factor of a sound
 ///
@@ -256,6 +400,18 @@ CSFML_AUDIO_API void sfSound_setAttenuation(sfSound* sound, float attenuation);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API void sfSound_setPlayingOffset(sfSound* sound, sfTime timeOffset);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the effect processor to be applied to the sound
+///
+/// The effect processor is a callable that will be called
+/// with sound data to be processed.
+///
+/// \param sound           Sound object
+/// \param effectProcessor The effect processor to attach to this sound, attach an empty processor to disable processing
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSound_setEffectProcessor(sfSound* sound, sfEffectProcessor effectProcessor);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the pitch of a sound
 ///
@@ -266,6 +422,16 @@ CSFML_AUDIO_API void sfSound_setPlayingOffset(sfSound* sound, sfTime timeOffset)
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfSound_getPitch(const sfSound* sound);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the pan of the sound
+///
+/// \param sound Sound object
+///
+/// \return Pan of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getPan(const sfSound* sound);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the volume of a sound
 ///
@@ -276,6 +442,16 @@ CSFML_AUDIO_API float sfSound_getPitch(const sfSound* sound);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfSound_getVolume(const sfSound* sound);
 
+////////////////////////////////////////////////////////////
+/// \brief Tell whether spatialization of the sound is enabled
+///
+/// \param sound Sound object
+///
+/// \return `true` if spatialization is enabled, `false` if it's disabled
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API bool sfSound_isSpatializationEnabled(const sfSound* sound);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the 3D position of a sound in the audio scene
 ///
@@ -286,16 +462,66 @@ CSFML_AUDIO_API float sfSound_getVolume(const sfSound* sound);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfVector3f sfSound_getPosition(const sfSound* sound);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D direction of the sound in the audio scene
+///
+/// \param sound Sound object
+///
+/// \return Direction of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfSound_getDirection(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the cone properties of the sound in the audio scene
+///
+/// \param sound Sound object
+///
+/// \return Cone properties of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundSourceCone sfSound_getCone(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D velocity of the sound in the audio scene
+///
+/// \param sound Sound object
+///
+/// \return Velocity of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfSound_getVelocity(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the doppler factor of the sound
+///
+/// \param sound Sound object
+///
+/// \return Doppler factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getDopplerFactor(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the directional attenuation factor of the sound
+///
+/// \param sound Sound object
+///
+/// \return Directional attenuation factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getDirectionalAttenuationFactor(const sfSound* sound);
+
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a sound's position is relative to the
 ///        listener or is absolute
 ///
 /// \param sound Sound object
 ///
-/// \return sfTrue if the position is relative, sfFalse if it's absolute
+/// \return true if the position is relative, false if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSound_isRelativeToListener(const sfSound* sound);
+CSFML_AUDIO_API bool sfSound_isRelativeToListener(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a sound
@@ -307,6 +533,36 @@ CSFML_AUDIO_API sfBool sfSound_isRelativeToListener(const sfSound* sound);
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfSound_getMinDistance(const sfSound* sound);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum distance of the sound
+///
+/// \param sound Sound object
+///
+/// \return Maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getMaxDistance(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the minimum gain of the sound
+///
+/// \param sound Sound object
+///
+/// \return Minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getMinGain(const sfSound* sound);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum gain of the sound
+///
+/// \param sound Sound object
+///
+/// \return Maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSound_getMaxGain(const sfSound* sound);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the attenuation factor of a sound
 ///
@@ -326,6 +582,3 @@ CSFML_AUDIO_API float sfSound_getAttenuation(const sfSound* sound);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfTime sfSound_getPlayingOffset(const sfSound* sound);
-
-
-#endif // SFML_SOUND_H

include/CSFML/Audio/SoundBuffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUNDBUFFER_H
+#pragma once
-#define SFML_SOUNDBUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/Audio/Types.h>
+
-#include <SFML/System/InputStream.h>
+#include <CSFML/Audio/SoundChannel.h>
-#include <SFML/System/Time.h>
+#include <CSFML/Audio/Types.h>
+#include <CSFML/System/InputStream.h>
+#include <CSFML/System/Time.h>
+
 #include <stddef.h>
 
 
@@ -82,17 +84,25 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* str
 /// \brief Create a new sound buffer and load it from an array of samples in memory
 ///
 /// The assumed format of the audio samples is 16 bits signed integer
-/// (sfInt16).
+/// (int16_t).
 ///
-/// \param samples      Pointer to the array of samples in memory
+/// \param samples        Pointer to the array of samples in memory
-/// \param sampleCount  Number of samples in the array
+/// \param sampleCount    Number of samples in the array
-/// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
+/// \param channelCount   Number of channels (1 = mono, 2 = stereo, ...)
-/// \param sampleRate   Sample rate (number of samples to play per second)
+/// \param sampleRate     Sample rate (number of samples to play per second)
+/// \param channelMapData Pointer to the array of channel map data
+/// \param channelMapSize Size of channel map data array
 ///
 /// \return A new sfSoundBuffer object (NULL if failed)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(const sfInt16* samples, sfUint64 sampleCount, unsigned int channelCount, unsigned int sampleRate);
+CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(
+    const int16_t*  samples,
+    uint64_t        sampleCount,
+    unsigned int    channelCount,
+    unsigned int    sampleRate,
+    sfSoundChannel* channelMapData,
+    size_t          channelMapSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound buffer by copying an existing one
@@ -110,7 +120,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_copy(const sfSoundBuffer* soundBuff
 /// \param soundBuffer Sound buffer to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API void sfSoundBuffer_destroy(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save a sound buffer to an audio file
@@ -122,16 +132,16 @@ CSFML_AUDIO_API void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer);
 /// \param soundBuffer Sound buffer object
 /// \param filename    Path of the sound file to write
 ///
-/// \return sfTrue if saving succeeded, sfFalse if it failed
+/// \return true if saving succeeded, false if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
+CSFML_AUDIO_API bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the array of audio samples stored in a sound buffer
 ///
 /// The format of the returned samples is 16 bits signed integer
-/// (sfInt16). The total number of samples in this array
+/// (int16_t). The total number of samples in this array
 /// is given by the sfSoundBuffer_getSampleCount function.
 ///
 /// \param soundBuffer Sound buffer object
@@ -139,7 +149,7 @@ CSFML_AUDIO_API sfBool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer
 /// \return Read-only pointer to the array of sound samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the number of samples stored in a sound buffer
@@ -152,7 +162,7 @@ CSFML_AUDIO_API const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* sou
 /// \return Number of samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfUint64 sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API uint64_t sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the sample rate of a sound buffer
@@ -181,6 +191,20 @@ CSFML_AUDIO_API unsigned int sfSoundBuffer_getSampleRate(const sfSoundBuffer* so
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API unsigned int sfSoundBuffer_getChannelCount(const sfSoundBuffer* soundBuffer);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the map of position in sample frame to sound channel
+///
+/// This is used to map a sample in the sample stream to a
+/// position during spatialization.
+///
+/// \param soundBuffer Sound buffer object
+/// \param count Pointer to a variable that will be filled with the number of channels in the map
+///
+/// \return Map of position in sample frame to sound channel
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundChannel* sfSoundBuffer_getChannelMap(const sfSoundBuffer* soundBuffer, size_t* count);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the total duration of a sound buffer
 ///
@@ -190,6 +214,3 @@ CSFML_AUDIO_API unsigned int sfSoundBuffer_getChannelCount(const sfSoundBuffer*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfTime sfSoundBuffer_getDuration(const sfSoundBuffer* soundBuffer);
-
-
-#endif // SFML_SOUNDBUFFER_H

include/CSFML/Audio/SoundBufferRecorder.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUNDBUFFERRECORDER_H
+#pragma once
-#define SFML_SOUNDBUFFERRECORDER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/Audio/Types.h>
+
+#include <CSFML/Audio/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -46,7 +46,7 @@ CSFML_AUDIO_API sfSoundBufferRecorder* sfSoundBufferRecorder_create(void);
 /// \param soundBufferRecorder Sound buffer recorder to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundBufferRecorder);
+CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(const sfSoundBufferRecorder* soundBufferRecorder);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start the capture of a sound recorder recorder
@@ -61,10 +61,10 @@ CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundB
 /// \param soundBufferRecorder Sound buffer recorder object
 /// \param sampleRate          Desired capture rate, in number of samples per second
 ///
-/// \return sfTrue, if it was able to start recording
+/// \return true, if it was able to start recording
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API bool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Stop the capture of a sound recorder
@@ -114,10 +114,10 @@ CSFML_AUDIO_API const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSou
 /// \param soundBufferRecorder Sound buffer recorder object
 /// \param name                The name of the audio capture device
 ///
-/// \return sfTrue, if it was able to set the requested device
+/// \return true, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
+CSFML_AUDIO_API bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device
@@ -129,5 +129,34 @@ CSFML_AUDIO_API sfBool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* so
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API const char* sfSoundBufferRecorder_getDevice(sfSoundBufferRecorder* soundBufferRecorder);
 
+////////////////////////////////////////////////////////////
+/// \brief Set the channel count of the audio capture device
+///
+/// This method allows you to specify the number of channels
+/// used for recording. Currently only 16-bit mono and
+/// 16-bit stereo are supported.
+///
+/// \param soundBufferRecorder Sound buffer recorder object
+/// \param channelCount Number of channels. Currently only
+///                     mono (1) and stereo (2) are supported.
+///
+/// \see sfSoundBufferRecorder_getChannelCount
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundBufferRecorder_setChannelCount(sfSoundBufferRecorder* soundBufferRecorder,
+                                                           unsigned int           channelCount);
 
-#endif // SFML_SOUNDBUFFERRECORDER_H
+////////////////////////////////////////////////////////////
+/// \brief Get the number of channels used by this recorder
+///
+/// Currently only mono and stereo are supported, so the
+/// value is either 1 (for mono) or 2 (for stereo).
+///
+/// \param soundBufferRecorder Sound buffer recorder object
+///
+/// \return Number of channels
+///
+/// \see sfSoundBufferRecorder_setChannelCount
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API unsigned int sfSoundBufferRecorder_getChannelCount(const sfSoundBufferRecorder* soundBufferRecorder);

include/CSFML/Audio/SoundChannel.h

@@ -0,0 +1,60 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+/// \brief Types of sound channels that can be read/written from sound buffers/files
+///
+/// In multi-channel audio, each sound channel can be
+/// assigned a position. The position of the channel is
+/// used to determine where to place a sound when it
+/// is spatialised. Assigning an incorrect sound channel
+/// will result in multi-channel audio being positioned
+/// incorrectly when using spatialisation.
+///
+////////////////////////////////////////////////////////////
+typedef enum
+{
+    sfSoundChannelUnspecified,
+    sfSoundChannelMono,
+    sfSoundChannelFrontLeft,
+    sfSoundChannelFrontRight,
+    sfSoundChannelFrontCenter,
+    sfSoundChannelFrontLeftOfCenter,
+    sfSoundChannelFrontRightOfCenter,
+    sfSoundChannelLowFrequencyEffects,
+    sfSoundChannelBackLeft,
+    sfSoundChannelBackRight,
+    sfSoundChannelBackCenter,
+    sfSoundChannelSideLeft,
+    sfSoundChannelSideRight,
+    sfSoundChannelTopCenter,
+    sfSoundChannelTopFrontLeft,
+    sfSoundChannelTopFrontRight,
+    sfSoundChannelTopFrontCenter,
+    sfSoundChannelTopBackLeft,
+    sfSoundChannelTopBackRight,
+    sfSoundChannelTopBackCenter
+} sfSoundChannel;

include/CSFML/Audio/SoundRecorder.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,21 +22,23 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUNDRECORDER_H
+#pragma once
-#define SFML_SOUNDRECORDER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
-#include <SFML/Audio/Types.h>
+
-#include <SFML/System/Time.h>
+#include <CSFML/Audio/SoundChannel.h>
+#include <CSFML/Audio/Types.h>
+#include <CSFML/System/Time.h>
+
 #include <stddef.h>
 
 
-typedef sfBool (*sfSoundRecorderStartCallback)(void*);                           ///< Type of the callback used when starting a capture
+typedef bool (*sfSoundRecorderStartCallback)(void*); ///< Type of the callback used when starting a capture
-typedef sfBool (*sfSoundRecorderProcessCallback)(const sfInt16*, size_t, void*); ///< Type of the callback used to process audio data
+typedef bool (*sfSoundRecorderProcessCallback)(const int16_t*, size_t, void*); ///< Type of the callback used to process audio data
-typedef void   (*sfSoundRecorderStopCallback)(void*);                            ///< Type of the callback used when stopping a capture
+typedef void (*sfSoundRecorderStopCallback)(void*); ///< Type of the callback used when stopping a capture
 
 
 ////////////////////////////////////////////////////////////
@@ -61,7 +63,7 @@ CSFML_AUDIO_API sfSoundRecorder* sfSoundRecorder_create(sfSoundRecorderStartCall
 /// \param soundRecorder Sound recorder to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder);
+CSFML_AUDIO_API void sfSoundRecorder_destroy(const sfSoundRecorder* soundRecorder);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start the capture of a sound recorder
@@ -79,7 +81,7 @@ CSFML_AUDIO_API void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder);
 /// \return True, if start of capture was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API bool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Stop the capture of a sound recorder
@@ -110,43 +112,24 @@ CSFML_AUDIO_API unsigned int sfSoundRecorder_getSampleRate(const sfSoundRecorder
 /// the audio capture features. If it returns false, then
 /// any attempt to use sfSoundRecorder will fail.
 ///
-/// \return sfTrue if audio capture is supported, sfFalse otherwise
+/// \return true if audio capture is supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_isAvailable(void);
+CSFML_AUDIO_API bool sfSoundRecorder_isAvailable(void);
 
 ////////////////////////////////////////////////////////////
-/// \brief Set the processing interval
+/// \brief Get a list of the names of all available audio capture devices
-///
-/// The processing interval controls the period
-/// between calls to the onProcessSamples function. You may
-/// want to use a small interval if you want to process the
-/// recorded data in real time, for example.
-///
-/// Note: this is only a hint, the actual period may vary.
-/// So don't rely on this parameter to implement precise timing.
-///
-/// The default processing interval is 100 ms.
-///
-/// \param soundRecorder Sound recorder object
-/// \param interval      Processing interval
-///
-////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundRecorder_setProcessingInterval(sfSoundRecorder* soundRecorder, sfTime interval);
-
-////////////////////////////////////////////////////////////
-/// \brief Get a list of the names of all availabe audio capture devices
 ///
 /// This function returns an array of strings (null terminated),
-/// containing the names of all availabe audio capture devices.
+/// containing the names of all available audio capture devices.
-/// If no devices are available then NULL is returned.
+/// If no devices are available, then NULL is returned.
 ///
 /// \param count Pointer to a variable that will be filled with the number of modes in the array
 ///
 /// \return An array of strings containing the names
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const char** sfSoundRecorder_getAvailableDevices(size_t* count);
+CSFML_AUDIO_API const char* const* sfSoundRecorder_getAvailableDevices(size_t* count);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the default audio capture device
@@ -170,10 +153,10 @@ CSFML_AUDIO_API const char* sfSoundRecorder_getDefaultDevice(void);
 /// \param soundRecorder Sound recorder object
 /// \param name          The name of the audio capture device
 ///
-/// \return sfTrue, if it was able to set the requested device
+/// \return true, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
+CSFML_AUDIO_API bool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device
@@ -192,8 +175,9 @@ CSFML_AUDIO_API const char* sfSoundRecorder_getDevice(sfSoundRecorder* soundReco
 /// used for recording. Currently only 16-bit mono and
 /// 16-bit stereo are supported.
 ///
-/// \param channelCount Number of channels. Currently only
+/// \param soundRecorder Sound recorder object
-///                     mono (1) and stereo (2) are supported.
+/// \param channelCount  Number of channels. Currently only
+///                      mono (1) and stereo (2) are supported.
 ///
 /// \see sfSoundRecorder_getChannelCount
 ///
@@ -213,5 +197,16 @@ CSFML_AUDIO_API void sfSoundRecorder_setChannelCount(sfSoundRecorder* soundRecor
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API unsigned int sfSoundRecorder_getChannelCount(const sfSoundRecorder* soundRecorder);
 
-
+////////////////////////////////////////////////////////////
-#endif // SFML_SOUNDRECORDER_H
+/// \brief Get the map of position in sample frame to sound channel
+///
+/// This is used to map a sample in the sample stream to a
+/// position during spatialization.
+///
+/// \param soundRecorder Sound recorder object
+/// \param count Pointer to a variable that will be filled with the number of channels in the map
+///
+/// \return Map of position in sample frame to sound channel
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundChannel* sfSoundRecorder_getChannelMap(const sfSoundRecorder* soundRecorder, size_t* count);

include/CSFML/Audio/SoundSourceCone.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,25 +22,22 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUNDBUFFERRECORDERSTRUCT_H
+#pragma once
-#define SFML_SOUNDBUFFERRECORDERSTRUCT_H
 
 ////////////////////////////////////////////////////////////
-// Headers
+/// \brief Structure defining the properties of a directional cone
+///
+/// Sounds will play at gain 1 when the listener
+/// is positioned within the inner angle of the cone.
+/// Sounds will play at `outerGain` when the listener is
+/// positioned outside the outer angle of the cone.
+/// The gain declines linearly from 1 to `outerGain` as the
+/// listener moves from the inner angle to the outer angle.
+///
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/SoundBufferRecorder.hpp>
+typedef struct
-#include <SFML/Audio/SoundBufferStruct.h>
-
-
-////////////////////////////////////////////////////////////
-// Internal structure of sfSoundBufferRecorder
-////////////////////////////////////////////////////////////
-struct sfSoundBufferRecorder
 {
-    sf::SoundBufferRecorder This;
+    float innerAngle; //!< Inner angle, in degrees
-    mutable sfSoundBuffer   SoundBuffer;
+    float outerAngle; //!< Outer angle, in degrees
-    std::string             DeviceName;
+    float outerGain;  //!< Outer gain
-};
+} sfSoundSourceCone;
-
-
-#endif // SFML_SOUNDBUFFERRECORDERSTRUCT_H

include/CSFML/Audio/SoundStatus.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOUNDSTATUS_H
+#pragma once
-#define SFML_SOUNDSTATUS_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Audio/Export.h>
+#include <CSFML/Audio/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -41,6 +40,3 @@ typedef enum
     sfPaused,  ///< Sound / music is paused
     sfPlaying  ///< Sound / music is playing
 } sfSoundStatus;
-
-
-#endif // SFML_SOUNDSTATUS_H

include/CSFML/Audio/SoundStream.h

@@ -0,0 +1,618 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <CSFML/Audio/Export.h>
+
+#include <CSFML/Audio/EffectProcessor.h>
+#include <CSFML/Audio/SoundChannel.h>
+#include <CSFML/Audio/SoundSourceCone.h>
+#include <CSFML/Audio/SoundStatus.h>
+#include <CSFML/Audio/Types.h>
+#include <CSFML/System/Time.h>
+#include <CSFML/System/Vector3.h>
+
+#include <stddef.h>
+
+
+////////////////////////////////////////////////////////////
+/// \brief defines the data to fill by the OnGetData callback
+///
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    int16_t*     samples;     ///< Pointer to the audio samples
+    unsigned int sampleCount; ///< Number of samples pointed by Samples
+} sfSoundStreamChunk;
+
+typedef bool (*sfSoundStreamGetDataCallback)(sfSoundStreamChunk*, void*); ///< Type of the callback used to get a sound stream data
+typedef void (*sfSoundStreamSeekCallback)(sfTime, void*); ///< Type of the callback used to seek in a sound stream
+
+
+////////////////////////////////////////////////////////////
+/// \brief Create a new sound stream
+///
+/// \param onGetData      Function called when the stream needs more data (can't be NULL)
+/// \param onSeek         Function called when the stream seeks (can't be NULL)
+/// \param channelCount   Number of channels to use (1 = mono, 2 = stereo)
+/// \param sampleRate     Sample rate of the sound (44100 = CD quality)
+/// \param channelMapData Pointer to the array of channel map data
+/// \param channelMapSize Size of channel map data array
+/// \param userData       Data to pass to the callback functions
+///
+/// \return A new sfSoundStream object
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundStream* sfSoundStream_create(
+    sfSoundStreamGetDataCallback onGetData,
+    sfSoundStreamSeekCallback    onSeek,
+    unsigned int                 channelCount,
+    unsigned int                 sampleRate,
+    sfSoundChannel*              channelMapData,
+    size_t                       channelMapSize,
+    void*                        userData);
+
+////////////////////////////////////////////////////////////
+/// \brief Destroy a sound stream
+///
+/// \param soundStream Sound stream to destroy
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_destroy(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Start or resume playing a sound stream
+///
+/// This function starts the stream if it was stopped, resumes
+/// it if it was paused, and restarts it from beginning if it
+/// was it already playing.
+/// This function uses its own thread so that it doesn't block
+/// the rest of the program while the music is played.
+///
+/// \param soundStream Sound stream object
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_play(sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Pause a sound stream
+///
+/// This function pauses the stream if it was playing,
+/// otherwise (stream already paused or stopped) it has no effect.
+///
+/// \param soundStream Sound stream object
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_pause(sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Stop playing a sound stream
+///
+/// This function stops the stream if it was playing or paused,
+/// and does nothing if it was already stopped.
+/// It also resets the playing position (unlike sfSoundStream_pause).
+///
+/// \param soundStream Sound stream object
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_stop(sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the current status of a sound stream (stopped, paused, playing)
+///
+/// \param soundStream Sound stream object
+///
+/// \return Current status
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundStatus sfSoundStream_getStatus(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Return the number of channels of a sound stream
+///
+/// 1 channel means a mono sound, 2 means stereo, etc.
+///
+/// \param soundStream Sound stream object
+///
+/// \return Number of channels
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API unsigned int sfSoundStream_getChannelCount(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the sample rate of a sound stream
+///
+/// The sample rate is the number of audio samples played per
+/// second. The higher, the better the quality.
+///
+/// \param soundStream Sound stream object
+///
+/// \return Sample rate, in number of samples per second
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API unsigned int sfSoundStream_getSampleRate(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the map of position in sample frame to sound channel
+///
+/// This is used to map a sample in the sample stream to a
+/// position during spatialization.
+///
+/// \param soundStream Sound stream object
+/// \param count       Pointer to a variable that will be filled with the number of channels in the map
+///
+/// \return Map of position in sample frame to sound channel
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundChannel* sfSoundStream_getChannelMap(const sfSoundStream* soundStream, size_t* count);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the pitch of a sound stream
+///
+/// The pitch represents the perceived fundamental frequency
+/// of a sound; thus you can make a stream more acute or grave
+/// by changing its pitch. A side effect of changing the pitch
+/// is to modify the playing speed of the stream as well.
+/// The default value for the pitch is 1.
+///
+/// \param soundStream Sound stream object
+/// \param pitch       New pitch to apply to the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setPitch(sfSoundStream* soundStream, float pitch);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the pan of the sound
+///
+/// Using panning, a mono sound can be panned between
+/// stereo channels. When the pan is set to -1, the sound
+/// is played only on the left channel, when the pan is set
+/// to +1, the sound is played only on the right channel.
+///
+/// \param soundStream Sound stream object
+/// \param pan         New pan to apply to the sound [-1, +1]
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setPan(sfSoundStream* soundStream, float pan);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the volume of a sound stream
+///
+/// The volume is a value between 0 (mute) and 100 (full volume).
+/// The default value for the volume is 100.
+///
+/// \param soundStream Sound stream object
+/// \param volume      Volume of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setVolume(sfSoundStream* soundStream, float volume);
+
+////////////////////////////////////////////////////////////
+/// \brief Set whether spatialization of the sound is enabled
+///
+/// Spatialization is the application of various effects to
+/// simulate a sound being emitted at a virtual position in
+/// 3D space and exhibiting various physical phenomena such as
+/// directional attenuation and doppler shift.
+///
+/// \param soundStream Sound stream object
+/// \param enabled     `true` to enable spatialization, `false` to disable
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setSpatializationEnabled(sfSoundStream* soundStream, bool enabled);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D position of a sound stream in the audio scene
+///
+/// Only streams with one channel (mono streams) can be
+/// spatialized.
+/// The default position of a stream is (0, 0, 0).
+///
+/// \param soundStream Sound stream object
+/// \param position    Position of the stream in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setPosition(sfSoundStream* soundStream, sfVector3f position);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D direction of the sound in the audio scene
+///
+/// The direction defines where the sound source is facing
+/// in 3D space. It will affect how the sound is attenuated
+/// if facing away from the listener.
+/// The default direction of a sound is (0, 0, -1).
+///
+/// \param soundStream Sound stream object
+/// \param direction   Direction of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setDirection(sfSoundStream* soundStream, sfVector3f direction);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the cone properties of the sound in the audio scene
+///
+/// The cone defines how directional attenuation is applied.
+/// The default cone of a sound is (2 * PI, 2 * PI, 1).
+///
+/// \param soundStream Sound stream object
+/// \param cone        Cone properties of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setCone(sfSoundStream* soundStream, sfSoundSourceCone cone);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the 3D velocity of the sound in the audio scene
+///
+/// The velocity is used to determine how to doppler shift
+/// the sound. Sounds moving towards the listener will be
+/// perceived to have a higher pitch and sounds moving away
+/// from the listener will be perceived to have a lower pitch.
+///
+/// \param soundStream Sound stream object
+/// \param velocity    Velocity of the sound in the scene
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setVelocity(sfSoundStream* soundStream, sfVector3f velocity);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the doppler factor of the sound
+///
+/// The doppler factor determines how strong the doppler
+/// shift will be.
+///
+/// \param soundStream Sound stream object
+/// \param factor      New doppler factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setDopplerFactor(sfSoundStream* soundStream, float factor);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the directional attenuation factor of the sound
+///
+/// Depending on the virtual position of an output channel
+/// relative to the listener (such as in surround sound
+/// setups), sounds will be attenuated when emitting them
+/// from certain channels. This factor determines how strong
+/// the attenuation based on output channel position
+/// relative to the listener is.
+///
+/// \param soundStream Sound stream object
+/// \param factor      New directional attenuation factor to apply to the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setDirectionalAttenuationFactor(sfSoundStream* soundStream, float factor);
+
+////////////////////////////////////////////////////////////
+/// \brief Make a sound stream's position relative to the listener or absolute
+///
+/// Making a stream relative to the listener will ensure that it will always
+/// be played the same way regardless the position of the listener.
+/// This can be useful for non-spatialized streams, streams that are
+/// produced by the listener, or streams attached to it.
+/// The default value is false (position is absolute).
+///
+/// \param soundStream Sound stream object
+/// \param relative    true to set the position relative, false to set it absolute
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, bool relative);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the minimum distance of a sound stream
+///
+/// The "minimum distance" of a stream is the maximum
+/// distance at which it is heard at its maximum volume. Further
+/// than the minimum distance, it will start to fade out according
+/// to its attenuation factor. A value of 0 ("inside the head
+/// of the listener") is an invalid value and is forbidden.
+/// The default value of the minimum distance is 1.
+///
+/// \param soundStream Sound stream object
+/// \param distance    New minimum distance of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setMinDistance(sfSoundStream* soundStream, float distance);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum distance of the sound
+///
+/// The "maximum distance" of a sound is the minimum
+/// distance at which it is heard at its minimum volume. Closer
+/// than the maximum distance, it will start to fade in according
+/// to its attenuation factor.
+/// The default value of the maximum distance is the maximum
+/// value a float can represent.
+///
+/// \param soundStream Sound stream object
+/// \param distance    New maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setMaxDistance(sfSoundStream* soundStream, float distance);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the minimum gain of the sound
+///
+/// When the sound is further away from the listener than
+/// the "maximum distance" the attenuated gain is clamped
+/// so it cannot go below the minimum gain value.
+///
+/// \param soundStream Sound stream object
+/// \param gain        New minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setMinGain(sfSoundStream* soundStream, float gain);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the maximum gain of the sound
+///
+/// When the sound is closer from the listener than
+/// the "minimum distance" the attenuated gain is clamped
+/// so it cannot go above the maximum gain value.
+///
+/// \param soundStream Sound stream object
+/// \param gain        New maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setMaxGain(sfSoundStream* soundStream, float gain);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the attenuation factor of a sound stream
+///
+/// The attenuation is a multiplicative factor which makes
+/// the stream more or less loud according to its distance
+/// from the listener. An attenuation of 0 will produce a
+/// non-attenuated stream, i.e. its volume will always be the same
+/// whether it is heard from near or from far. On the other hand,
+/// an attenuation value such as 100 will make the stream fade out
+/// very quickly as it gets further from the listener.
+/// The default value of the attenuation is 1.
+///
+/// \param soundStream Sound stream object
+/// \param attenuation New attenuation factor of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setAttenuation(sfSoundStream* soundStream, float attenuation);
+
+////////////////////////////////////////////////////////////
+/// \brief Change the current playing position of a sound stream
+///
+/// The playing position can be changed when the stream is
+/// either paused or playing.
+///
+/// \param soundStream Sound stream object
+/// \param timeOffset  New playing position
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setPlayingOffset(sfSoundStream* soundStream, sfTime timeOffset);
+
+////////////////////////////////////////////////////////////
+/// \brief Set whether or not a sound stream should loop after reaching the end
+///
+/// If set, the stream will restart from beginning after
+/// reaching the end and so on, until it is stopped or
+/// sfSoundStream_setLooping(stream, false) is called.
+/// The default looping state for sound streams is false.
+///
+/// \param soundStream Sound stream object
+/// \param loop        true to play in loop, false to play once
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setLooping(sfSoundStream* soundStream, bool loop);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the pitch of a sound stream
+///
+/// \param soundStream Sound stream object
+///
+/// \return Pitch of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getPitch(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the pan of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Pan of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getPan(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the volume of a sound stream
+///
+/// \param soundStream Sound stream object
+///
+/// \return Volume of the stream, in the range [0, 100]
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getVolume(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Tell whether spatialization of the sound is enabled
+///
+/// \param soundStream Sound stream object
+///
+/// \return `true` if spatialization is enabled, `false` if it's disabled
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API bool sfSoundStream_isSpatializationEnabled(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D position of a sound stream in the audio scene
+///
+/// \param soundStream Sound stream object
+///
+/// \return Position of the stream in the world
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfSoundStream_getPosition(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D direction of the sound in the audio scene
+///
+/// \param soundStream Sound stream object
+///
+/// \return Direction of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfSoundStream_getDirection(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the cone properties of the sound in the audio scene
+///
+/// \param soundStream Sound stream object
+///
+/// \return Cone properties of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfSoundSourceCone sfSoundStream_getCone(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the 3D velocity of the sound in the audio scene
+///
+/// \param soundStream Sound stream object
+///
+/// \return Velocity of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfVector3f sfSoundStream_getVelocity(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the doppler factor of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Doppler factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getDopplerFactor(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the directional attenuation factor of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Directional attenuation factor of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getDirectionalAttenuationFactor(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Tell whether a sound stream's position is relative to the
+///        listener or is absolute
+///
+/// \param soundStream Sound stream object
+///
+/// \return true if the position is relative, false if it's absolute
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API bool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the minimum distance of a sound stream
+///
+/// \param soundStream Sound stream object
+///
+/// \return Minimum distance of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getMinDistance(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum distance of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Maximum distance of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getMaxDistance(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the minimum gain of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Minimum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getMinGain(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the maximum gain of the sound
+///
+/// \param soundStream Sound stream object
+///
+/// \return Maximum gain of the sound
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getMaxGain(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the attenuation factor of a sound stream
+///
+/// \param soundStream Sound stream object
+///
+/// \return Attenuation factor of the stream
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API float sfSoundStream_getAttenuation(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Tell whether or not a sound stream is in loop mode
+///
+/// \param soundStream Sound stream object
+///
+/// \return true if the music is looping, false otherwise
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API bool sfSoundStream_isLooping(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the effect processor to be applied to the sound
+///
+/// The effect processor is a callable that will be called
+/// with sound data to be processed.
+///
+/// \param soundStream Sound stream object
+/// \param effectProcessor The effect processor to attach to this sound, attach an empty processor to disable processing
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setEffectProcessor(sfSoundStream* soundStream, sfEffectProcessor effectProcessor);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the current playing position of a sound stream
+///
+/// \param soundStream Sound stream object
+///
+/// \return Current playing position
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfTime sfSoundStream_getPlayingOffset(const sfSoundStream* soundStream);

include/CSFML/Audio/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,11 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_AUDIO_TYPES_H
+#pragma once
-#define SFML_AUDIO_TYPES_H
 
-
+typedef struct sfMusic               sfMusic;
-typedef struct sfMusic sfMusic;
+typedef struct sfSound               sfSound;
-typedef struct sfSound sfSound;
+typedef struct sfSoundBuffer         sfSoundBuffer;
-typedef struct sfSoundBuffer sfSoundBuffer;
 typedef struct sfSoundBufferRecorder sfSoundBufferRecorder;
-typedef struct sfSoundRecorder sfSoundRecorder;
+typedef struct sfSoundRecorder       sfSoundRecorder;
-typedef struct sfSoundStream sfSoundStream;
+typedef struct sfSoundStream         sfSoundStream;
-
-
-#endif // SFML_AUDIO_TYPES_H

include/CSFML/Config.h

@@ -0,0 +1,161 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <stdbool.h>
+#include <stdint.h>
+
+
+////////////////////////////////////////////////////////////
+// Define the CSFML version
+////////////////////////////////////////////////////////////
+#define CSFML_VERSION_MAJOR 3
+#define CSFML_VERSION_MINOR 0
+#define CSFML_VERSION_PATCH 0
+
+
+////////////////////////////////////////////////////////////
+// Check if we need to mark functions as extern "C"
+////////////////////////////////////////////////////////////
+#ifdef __cplusplus
+#define CSFML_EXTERN_C extern "C"
+#else
+#define CSFML_EXTERN_C extern
+#endif
+
+
+////////////////////////////////////////////////////////////
+// Identify the operating system
+////////////////////////////////////////////////////////////
+#if defined(_WIN32) || defined(__WIN32__)
+
+// Windows
+#define CSFML_SYSTEM_WINDOWS
+
+#elif defined(linux) || defined(__linux)
+
+// Linux
+#define CSFML_SYSTEM_LINUX
+
+#elif defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh)
+
+// MacOS
+#define CSFML_SYSTEM_MACOS
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+
+// FreeBSD
+#define CSFML_SYSTEM_FREEBSD
+
+#else
+
+// Unsupported system
+#error This operating system is not supported by SFML library
+
+#endif
+
+
+////////////////////////////////////////////////////////////
+// Define helpers to create portable import / export macros for each module
+////////////////////////////////////////////////////////////
+#if !defined(CSFML_STATIC)
+
+#if defined(CSFML_SYSTEM_WINDOWS)
+
+// Windows compilers need specific (and different) keywords for export and import
+#define CSFML_API_EXPORT extern "C" __declspec(dllexport)
+#define CSFML_API_IMPORT CSFML_EXTERN_C __declspec(dllimport)
+
+// For Visual C++ compilers, we also need to turn off this annoying C4251 warning
+#ifdef _MSC_VER
+
+#pragma warning(disable : 4251)
+
+#endif
+
+#else // Linux, FreeBSD, Mac OS X
+
+#define CSFML_API_EXPORT extern "C" __attribute__((__visibility__("default")))
+#define CSFML_API_IMPORT CSFML_EXTERN_C __attribute__((__visibility__("default")))
+
+#endif
+
+#else
+
+// Static build doesn't need import/export macros
+#define CSFML_API_EXPORT extern "C"
+#define CSFML_API_IMPORT CSFML_EXTERN_C
+
+#endif
+
+////////////////////////////////////////////////////////////
+// Cross-platform warning for deprecated functions and classes
+//
+// Usage:
+// struct CSFML_DEPRECATED MyStruct
+// {
+//     ...
+// };
+//
+// CSFML_DEPRECATED void globalFunc(void);
+////////////////////////////////////////////////////////////
+#if defined(CSFML_NO_DEPRECATED_WARNINGS)
+
+// User explicitly requests to disable deprecation warnings
+#define CSFML_DEPRECATED
+
+#elif defined(_MSC_VER)
+
+// Microsoft C++ compiler
+// Note: On newer MSVC versions, using deprecated functions causes a compiler error. In order to
+// trigger a warning instead of an error, the compiler flag /sdl- (instead of /sdl) must be specified.
+#define CSFML_DEPRECATED __declspec(deprecated)
+
+#elif defined(__GNUC__)
+
+// g++ and Clang
+#define CSFML_DEPRECATED __attribute__((deprecated))
+
+#else
+
+// Other compilers are not supported, leave class or function as-is.
+// With a bit of luck, the #pragma directive works, otherwise users get a warning (no error!) for unrecognized #pragma.
+#pragma message("CSFML_DEPRECATED is not supported for your compiler, please contact the CSFML team")
+#define CSFML_DEPRECATED
+
+#endif
+
+
+////////////////////////////////////////////////////////////
+/// Define sfChar32
+///
+/// Work around macOS not providing <uchar.h>
+////////////////////////////////////////////////////////////
+#include <stdint.h>
+typedef uint32_t sfChar32;

include/CSFML/GPUPreference.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_GPUPREFERENCE_H
+#pragma once
-#define SFML_GPUPREFERENCE_H
-
 
 ////////////////////////////////////////////////////////////
 /// Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -60,15 +58,12 @@
 ////////////////////////////////////////////////////////////
 #if defined(SFML_SYSTEM_WINDOWS)
 
-    #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE \
+#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE                                                      \
-                CSFML_EXTERN_C __declspec(dllexport) unsigned long NvOptimusEnablement = 1; \
+    CSFML_EXTERN_C __declspec(dllexport) unsigned long NvOptimusEnablement                  = 1; \
-                CSFML_EXTERN_C __declspec(dllexport) unsigned long AmdPowerXpressRequestHighPerformance = 1;
+    CSFML_EXTERN_C __declspec(dllexport) unsigned long AmdPowerXpressRequestHighPerformance = 1;
 
 #else
 
-    #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
+#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
 
 #endif
-
-
-#endif // SFML_GPUPREFERENCE_H

include/CSFML/Graphics.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,22 +22,35 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_AUDIO_H
+#pragma once
-#define SFML_AUDIO_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
 
-#include <SFML/System.h>
+#include <CSFML/Graphics/BlendMode.h>
-#include <SFML/Audio/Listener.h>
+#include <CSFML/Graphics/CircleShape.h>
-#include <SFML/Audio/Music.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Audio/Sound.h>
+#include <CSFML/Graphics/ConvexShape.h>
-#include <SFML/Audio/SoundBuffer.h>
+#include <CSFML/Graphics/Font.h>
-#include <SFML/Audio/SoundBufferRecorder.h>
+#include <CSFML/Graphics/FontInfo.h>
-#include <SFML/Audio/SoundRecorder.h>
+#include <CSFML/Graphics/Glyph.h>
-#include <SFML/Audio/SoundStatus.h>
+#include <CSFML/Graphics/Image.h>
-#include <SFML/Audio/SoundStream.h>
+#include <CSFML/Graphics/PrimitiveType.h>
-
+#include <CSFML/Graphics/Rect.h>
-
+#include <CSFML/Graphics/RectangleShape.h>
-#endif // SFML_AUDIO_H
+#include <CSFML/Graphics/RenderStates.h>
+#include <CSFML/Graphics/RenderTexture.h>
+#include <CSFML/Graphics/RenderWindow.h>
+#include <CSFML/Graphics/Shader.h>
+#include <CSFML/Graphics/Shape.h>
+#include <CSFML/Graphics/Sprite.h>
+#include <CSFML/Graphics/Text.h>
+#include <CSFML/Graphics/Texture.h>
+#include <CSFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Transformable.h>
+#include <CSFML/Graphics/Vertex.h>
+#include <CSFML/Graphics/VertexArray.h>
+#include <CSFML/Graphics/VertexBuffer.h>
+#include <CSFML/Graphics/View.h>
+#include <CSFML/Window.h>

include/CSFML/Graphics/BlendMode.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_BLENDMODE_H
+#pragma once
-#define SFML_BLENDMODE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -70,12 +69,12 @@ typedef enum
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendFactor colorSrcFactor;  ///< Source blending factor for the color channels
+    sfBlendFactor   colorSrcFactor; ///< Source blending factor for the color channels
-    sfBlendFactor colorDstFactor;  ///< Destination blending factor for the color channels
+    sfBlendFactor   colorDstFactor; ///< Destination blending factor for the color channels
-    sfBlendEquation colorEquation; ///< Blending equation for the color channels
+    sfBlendEquation colorEquation;  ///< Blending equation for the color channels
-    sfBlendFactor alphaSrcFactor;  ///< Source blending factor for the alpha channel
+    sfBlendFactor   alphaSrcFactor; ///< Source blending factor for the alpha channel
-    sfBlendFactor alphaDstFactor;  ///< Destination blending factor for the alpha channel
+    sfBlendFactor   alphaDstFactor; ///< Destination blending factor for the alpha channel
-    sfBlendEquation alphaEquation; ///< Blending equation for the alpha channel
+    sfBlendEquation alphaEquation;  ///< Blending equation for the alpha channel
 } sfBlendMode;
 
 
@@ -85,6 +84,3 @@ CSFML_GRAPHICS_API const sfBlendMode sfBlendMultiply; ///< Multiply source and d
 CSFML_GRAPHICS_API const sfBlendMode sfBlendMin;      ///< Take minimum between source and dest
 CSFML_GRAPHICS_API const sfBlendMode sfBlendMax;      ///< Take maximum between source and dest
 CSFML_GRAPHICS_API const sfBlendMode sfBlendNone;     ///< Overwrite dest with source
-
-
-#endif // SFML_BLENDMODE_H

include/CSFML/Graphics/CircleShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,18 +22,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CIRCLESHAPE_H
+#pragma once
-#define SFML_CIRCLESHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
@@ -61,7 +62,7 @@ CSFML_GRAPHICS_API sfCircleShape* sfCircleShape_copy(const sfCircleShape* shape)
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfCircleShape_destroy(sfCircleShape* shape);
+CSFML_GRAPHICS_API void sfCircleShape_destroy(const sfCircleShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a circle shape
@@ -235,7 +236,7 @@ CSFML_GRAPHICS_API sfTransform sfCircleShape_getInverseTransform(const sfCircleS
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a circle shape will display
@@ -368,6 +369,20 @@ CSFML_GRAPHICS_API size_t sfCircleShape_getPointCount(const sfCircleShape* shape
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2f sfCircleShape_getPoint(const sfCircleShape* shape, size_t index);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the geometric center of the circle
+///
+/// The returned point is in local coordinates, that is,
+/// the shape's transforms (position, rotation, scale) are
+/// not taken into account.
+///
+/// \param shape Shape object
+///
+/// \return The geometric center of the shape
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfCircleShape_getGeometricCenter(const sfCircleShape* shape);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the radius of a circle
 ///
@@ -427,6 +442,3 @@ CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getLocalBounds(const sfCircleShape*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getGlobalBounds(const sfCircleShape* shape);
-
-
-#endif // SFML_CIRCLESHAPE_H

include/CSFML/Graphics/Color.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_COLOR_H
+#pragma once
-#define SFML_COLOR_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -37,22 +36,22 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfUint8 r;
+    uint8_t r;
-    sfUint8 g;
+    uint8_t g;
-    sfUint8 b;
+    uint8_t b;
-    sfUint8 a;
+    uint8_t a;
 } sfColor;
 
 
-CSFML_GRAPHICS_API sfColor sfBlack;       ///< Black predefined color
+CSFML_GRAPHICS_API const sfColor sfBlack;       ///< Black predefined color
-CSFML_GRAPHICS_API sfColor sfWhite;       ///< White predefined color
+CSFML_GRAPHICS_API const sfColor sfWhite;       ///< White predefined color
-CSFML_GRAPHICS_API sfColor sfRed;         ///< Red predefined color
+CSFML_GRAPHICS_API const sfColor sfRed;         ///< Red predefined color
-CSFML_GRAPHICS_API sfColor sfGreen;       ///< Green predefined color
+CSFML_GRAPHICS_API const sfColor sfGreen;       ///< Green predefined color
-CSFML_GRAPHICS_API sfColor sfBlue;        ///< Blue predefined color
+CSFML_GRAPHICS_API const sfColor sfBlue;        ///< Blue predefined color
-CSFML_GRAPHICS_API sfColor sfYellow;      ///< Yellow predefined color
+CSFML_GRAPHICS_API const sfColor sfYellow;      ///< Yellow predefined color
-CSFML_GRAPHICS_API sfColor sfMagenta;     ///< Magenta predefined color
+CSFML_GRAPHICS_API const sfColor sfMagenta;     ///< Magenta predefined color
-CSFML_GRAPHICS_API sfColor sfCyan;        ///< Cyan predefined color
+CSFML_GRAPHICS_API const sfColor sfCyan;        ///< Cyan predefined color
-CSFML_GRAPHICS_API sfColor sfTransparent; ///< Transparent (black) predefined color
+CSFML_GRAPHICS_API const sfColor sfTransparent; ///< Transparent (black) predefined color
 
 
 ////////////////////////////////////////////////////////////
@@ -65,7 +64,7 @@ CSFML_GRAPHICS_API sfColor sfTransparent; ///< Transparent (black) predefined co
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a color from its 4 RGBA components
@@ -78,7 +77,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 b
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct the color from 32-bit unsigned integer
@@ -88,7 +87,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8
 /// \return sfColor constructed from the 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromInteger(sfUint32 color);
+CSFML_GRAPHICS_API sfColor sfColor_fromInteger(uint32_t color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a color to a 32-bit unsigned integer
@@ -96,7 +95,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromInteger(sfUint32 color);
 /// \return Color represented as a 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfUint32 sfColor_toInteger(sfColor color);
+CSFML_GRAPHICS_API uint32_t sfColor_toInteger(sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Add two colors
@@ -130,6 +129,3 @@ CSFML_GRAPHICS_API sfColor sfColor_subtract(sfColor color1, sfColor color2);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfColor sfColor_modulate(sfColor color1, sfColor color2);
-
-
-#endif // SFML_COLOR_H

include/CSFML/Graphics/ConvexShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,18 +22,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CONVEXSHAPE_H
+#pragma once
-#define SFML_CONVEXSHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
@@ -61,7 +62,7 @@ CSFML_GRAPHICS_API sfConvexShape* sfConvexShape_copy(const sfConvexShape* shape)
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfConvexShape_destroy(sfConvexShape* shape);
+CSFML_GRAPHICS_API void sfConvexShape_destroy(const sfConvexShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a convex shape
@@ -235,7 +236,7 @@ CSFML_GRAPHICS_API sfTransform sfConvexShape_getInverseTransform(const sfConvexS
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a convex shape will display
@@ -368,6 +369,20 @@ CSFML_GRAPHICS_API size_t sfConvexShape_getPointCount(const sfConvexShape* shape
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2f sfConvexShape_getPoint(const sfConvexShape* shape, size_t index);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the geometric center of a convex shape
+///
+/// The returned point is in local coordinates, that is,
+/// the shape's transforms (position, rotation, scale) are
+/// not taken into account.
+///
+/// \param shape Shape object
+///
+/// \return The geometric center of the shape
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfConvexShape_getGeometricCenter(const sfConvexShape* shape);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the number of points of a convex shap
 ///
@@ -389,7 +404,7 @@ CSFML_GRAPHICS_API void sfConvexShape_setPointCount(sfConvexShape* shape, size_t
 /// of the valid range.
 ///
 /// \param shape Shape object
-/// \param index Index of the point to change, in range [0 .. GetPointCount() - 1]
+/// \param index Index of the point to change, in range [0 .. getPointCount() - 1]
 /// \param point New point
 ///
 ////////////////////////////////////////////////////////////
@@ -426,6 +441,3 @@ CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getLocalBounds(const sfConvexShape*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getGlobalBounds(const sfConvexShape* shape);
-
-
-#endif // SFML_CONVEXSHAPE_H

include/CSFML/Graphics/CoordinateType.h

@@ -0,0 +1,35 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+/// \brief Types of texture coordinates that can be used for rendering.
+///
+////////////////////////////////////////////////////////////
+typedef enum
+{
+    sfCoordinateTypeNormalized, ///< sfTexture coordinates in range [0 .. 1].
+    sfCoordinateTypePixels      ///< sfTexture coordinates in range [0 .. size].
+} sfCoordinateType;

include/CSFML/Graphics/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_GRAPHICS_EXPORT_H
+#pragma once
-#define SFML_GRAPHICS_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,13 +35,10 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_GRAPHICS_EXPORTS)
 
-    #define CSFML_GRAPHICS_API CSFML_API_EXPORT
+#define CSFML_GRAPHICS_API CSFML_API_EXPORT
 
 #else
 
-    #define CSFML_GRAPHICS_API CSFML_API_IMPORT
+#define CSFML_GRAPHICS_API CSFML_API_IMPORT
 
 #endif
-
-
-#endif // SFML_GRAPHICS_EXPORT_H

include/CSFML/Graphics/Font.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_FONT_H
+#pragma once
-#define SFML_FONT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/FontInfo.h>
+
-#include <SFML/Graphics/Glyph.h>
+#include <CSFML/Graphics/FontInfo.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Glyph.h>
-#include <SFML/System/InputStream.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/InputStream.h>
+
 #include <stddef.h>
 
 
@@ -83,7 +84,7 @@ CSFML_GRAPHICS_API sfFont* sfFont_copy(const sfFont* font);
 /// \param font Font to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_destroy(sfFont* font);
+CSFML_GRAPHICS_API void sfFont_destroy(const sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a glyph in a font
@@ -97,7 +98,27 @@ CSFML_GRAPHICS_API void sfFont_destroy(sfFont* font);
 /// \return The corresponding glyph
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold, float outlineThickness);
+CSFML_GRAPHICS_API sfGlyph
+    sfFont_getGlyph(const sfFont* font, uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness);
+
+////////////////////////////////////////////////////////////
+/// \brief Determine if this font has a glyph representing the requested code point
+///
+/// Most fonts only include a very limited selection of glyphs from
+/// specific Unicode subsets, like Latin, Cyrillic, or Asian characters.
+///
+/// While code points without representation will return a font specific
+/// default character, it might be useful to verify whether specific
+/// code points are included to determine whether a font is suited
+/// to display text in a specific language.
+///
+/// \param font      Source font
+/// \param codePoint Unicode code point to check
+///
+/// \return True if the codepoint has a glyph representation, sfFalse otherwise
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API bool sfFont_hasGlyph(const sfFont* font, uint32_t codePoint);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the kerning value corresponding to a given pair of characters in a font
@@ -110,7 +131,7 @@ CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoin
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the bold kerning value corresponding to a given pair of characters in a font
@@ -123,7 +144,7 @@ CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, sfUint32 first, s
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the line spacing value
@@ -184,24 +205,24 @@ CSFML_GRAPHICS_API const sfTexture* sfFont_getTexture(sfFont* font, unsigned int
 /// The smooth filter is enabled by default.
 ///
 /// \param font          Source font
-/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth        true to enable smoothing, false to disable it
 ///
 /// \see isSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, sfBool smooth);
+CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or disabled
 ///
 /// \param font          Source font
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 /// \see setSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfFont_isSmooth(const sfFont* font);
+CSFML_GRAPHICS_API bool sfFont_isSmooth(const sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font information
@@ -216,6 +237,3 @@ CSFML_GRAPHICS_API sfBool sfFont_isSmooth(const sfFont* font);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFontInfo sfFont_getInfo(const sfFont* font);
-
-
-#endif // SFML_FONT_H

include/CSFML/Graphics/FontInfo.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_FONTINFO_H
+#pragma once
-#define SFML_FONTINFO_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
 
 ////////////////////////////////////////////////////////////
 /// sfFontInfo holds various information about a font
@@ -37,6 +36,3 @@ typedef struct
 {
     const char* family;
 } sfFontInfo;
-
-
-#endif // SFML_FONTINFO_H

include/CSFML/Graphics/Glsl.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_GLSL_H
+#pragma once
-#define SFML_GLSL_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Color.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/System/Vector2.h>
-#include <SFML/System/Vector3.h>
+#include <CSFML/System/Vector3.h>
 
 // 2D vectors
 typedef sfVector2f sfGlslVec2;
@@ -39,8 +38,8 @@ typedef sfVector2i sfGlslIvec2;
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
 } sfGlslBvec2;
 
 // 3D vectors
@@ -55,9 +54,9 @@ typedef struct
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
-    sfBool z;
+    bool z;
 } sfGlslBvec3;
 
 // 4D vectors
@@ -79,10 +78,10 @@ typedef struct
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
-    sfBool z;
+    bool z;
-    sfBool w;
+    bool w;
 } sfGlslBvec4;
 
 // matrices
@@ -95,6 +94,3 @@ typedef struct
 {
     float array[4 * 4];
 } sfGlslMat4;
-
-
-#endif // SFML_GLSL_H

include/CSFML/Graphics/Glyph.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_GLYPH_H
+#pragma once
-#define SFML_GLYPH_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Rect.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -41,6 +40,3 @@ typedef struct
     sfFloatRect bounds;      ///< Bounding rectangle of the glyph, in coordinates relative to the baseline
     sfIntRect   textureRect; ///< Texture coordinates of the glyph inside the font's image
 } sfGlyph;
-
-
-#endif // SFML_GLYPH_H

include/CSFML/Graphics/Image.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,19 +22,20 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_IMAGE_H
+#pragma once
-#define SFML_IMAGE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/System/Buffer.h>
+#include <CSFML/Graphics/Types.h>
-#include <SFML/System/InputStream.h>
+#include <CSFML/System/Buffer.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/System/InputStream.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
@@ -43,25 +44,23 @@
 ///
 /// This image is filled with black pixels.
 ///
-/// \param width  Width of the image
+/// \param size Size of the image
-/// \param height Height of the image
 ///
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_create(unsigned int width, unsigned int height);
+CSFML_GRAPHICS_API sfImage* sfImage_create(sfVector2u size);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image and fill it with a unique color
 ///
-/// \param width  Width of the image
+/// \param size  Size of the image
-/// \param height Height of the image
+/// \param color Fill color
-/// \param color  Fill color
 ///
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(unsigned int width, unsigned int height, sfColor color);
+CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(sfVector2u size, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image from an array of pixels
@@ -71,14 +70,13 @@ CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(unsigned int width, unsigned
 /// an undefined behaviour.
 /// If \a pixels is null, an empty image is created.
 ///
-/// \param width  Width of the image
+/// \param size   Size of the image
-/// \param height Height of the image
 /// \param pixels Array of pixels to copy to the image
 ///
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(sfVector2u size, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image from a file on disk
@@ -142,7 +140,7 @@ CSFML_GRAPHICS_API sfImage* sfImage_copy(const sfImage* image);
 /// \param image Image to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_destroy(sfImage* image);
+CSFML_GRAPHICS_API void sfImage_destroy(const sfImage* image);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save an image to a file on disk
@@ -155,12 +153,12 @@ CSFML_GRAPHICS_API void sfImage_destroy(sfImage* image);
 /// \param image    Image object
 /// \param filename Path of the file to save
 ///
-/// \return sfTrue if saving was successful
+/// \return true if saving was successful
 ///
 /// \see sfImage_saveToMemory
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* filename);
+CSFML_GRAPHICS_API bool sfImage_saveToFile(const sfImage* image, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the image to a buffer in memory
@@ -174,12 +172,12 @@ CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* f
 /// \param output Buffer to fill with encoded data
 /// \param format Encoding format to use
 ///
-/// \return sfTrue if saving was successful
+/// \return true if saving was successful
 ///
 /// \see sfImage_saveToFile
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
+CSFML_GRAPHICS_API bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of an image
@@ -203,7 +201,7 @@ CSFML_GRAPHICS_API sfVector2u sfImage_getSize(const sfImage* image);
 /// \param alpha Alpha value to assign to transparent pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, sfUint8 alpha);
+CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, uint8_t alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy pixels from an image onto another
@@ -220,13 +218,14 @@ CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor colo
 ///
 /// \param image      Image object
 /// \param source     Source image to copy
-/// \param destX      X coordinate of the destination position
+/// \param dest       Coordinates of the destination position
-/// \param destY      Y coordinate of the destination position
 /// \param sourceRect Sub-rectangle of the source image to copy
 /// \param applyAlpha Should the copy take in account the source transparency?
 ///
+/// \return True if the operation was successful, false otherwise
+///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, sfBool applyAlpha);
+CSFML_GRAPHICS_API bool sfImage_copyImage(sfImage* image, const sfImage* source, sfVector2u dest, sfIntRect sourceRect, bool applyAlpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the color of a pixel in an image
@@ -235,13 +234,12 @@ CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source,
 /// coordinates, using out-of-range values will result in
 /// an undefined behaviour.
 ///
-/// \param image Image object
+/// \param image  Image object
-/// \param x     X coordinate of pixel to change
+/// \param coords Coordinates of pixel to change
-/// \param y     Y coordinate of pixel to change
+/// \param color  New color of the pixel
-/// \param color New color of the pixel
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, unsigned int x, unsigned int y, sfColor color);
+CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, sfVector2u coords, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the color of a pixel in an image
@@ -250,14 +248,13 @@ CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, unsigned int x, unsigne
 /// coordinates, using out-of-range values will result in
 /// an undefined behaviour.
 ///
-/// \param image Image object
+/// \param image  Image object
-/// \param x     X coordinate of pixel to get
+/// \param coords Coordinates of pixel to get
-/// \param y     Y coordinate of pixel to get
 ///
 /// \return Color of the pixel at coordinates (x, y)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, sfVector2u coords);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a read-only pointer to the array of pixels of an image
@@ -274,7 +271,7 @@ CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, unsigned int x
 /// \return Read-only pointer to the array of pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfUint8* sfImage_getPixelsPtr(const sfImage* image);
+CSFML_GRAPHICS_API const uint8_t* sfImage_getPixelsPtr(const sfImage* image);
 
 ////////////////////////////////////////////////////////////
 /// \brief Flip an image horizontally (left <-> right)
@@ -291,6 +288,3 @@ CSFML_GRAPHICS_API void sfImage_flipHorizontally(sfImage* image);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfImage_flipVertically(sfImage* image);
-
-
-#endif // SFML_IMAGE_H

include/CSFML/Graphics/PrimitiveType.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_PRIMITIVETYPE_H
+#pragma once
-#define SFML_PRIMITIVETYPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
-/// \brief Types of primitives that a sf::VertexArray can render
+/// \brief Types of primitives that an sfVertexArray can render
 ///
 /// Points and lines have no area, therefore their thickness
 /// will always be 1 pixel, regardless the current transform
@@ -46,13 +45,5 @@ typedef enum
     sfLineStrip,     ///< List of connected lines, a point uses the previous point to form a line
     sfTriangles,     ///< List of individual triangles
     sfTriangleStrip, ///< List of connected triangles, a point uses the two previous points to form a triangle
-    sfTriangleFan,   ///< List of connected triangles, a point uses the common center and the previous point to form a triangle
+    sfTriangleFan, ///< List of connected triangles, a point uses the common center and the previous point to form a triangle
-    sfQuads,         ///< List of individual quads
-
-    sfLinesStrip     = sfLineStrip,     ///< \deprecated Use sfLineStrip instead
-    sfTrianglesStrip = sfTriangleStrip, ///< \deprecated Use sfTriangleStrip instead
-    sfTrianglesFan   = sfTriangleFan    ///< \deprecated Use sfTriangleFan instead
 } sfPrimitiveType;
-
-
-#endif // SFML_BLENDMODE_H

include/CSFML/Graphics/Rect.h

@@ -0,0 +1,74 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <CSFML/Graphics/Export.h>
+
+#include <CSFML/System/Vector2.h>
+
+
+////////////////////////////////////////////////////////////
+/// sfFloatRect and sfIntRect are utility classes for
+/// manipulating rectangles.
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    sfVector2f position;
+    sfVector2f size;
+} sfFloatRect;
+
+typedef struct
+{
+    sfVector2i position;
+    sfVector2i size;
+} sfIntRect;
+
+////////////////////////////////////////////////////////////
+/// \brief Check if a point is inside a rectangle's area
+///
+/// \param rect  Rectangle to test
+/// \param point Coordinates of the point to test
+///
+/// \return true if the point is inside
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API bool sfFloatRect_contains(const sfFloatRect* rect, sfVector2f point);
+CSFML_GRAPHICS_API bool sfIntRect_contains(const sfIntRect* rect, sfVector2i point);
+
+////////////////////////////////////////////////////////////
+/// \brief Check intersection between two rectangles
+///
+/// \param rect1        First rectangle to test
+/// \param rect2        Second rectangle to test
+/// \param intersection Rectangle to be filled with overlapping rect (can be NULL)
+///
+/// \return true if rectangles overlap
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
+CSFML_GRAPHICS_API bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);

include/CSFML/Graphics/RectangleShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,18 +22,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_RECTANGLESHAPE_H
+#pragma once
-#define SFML_RECTANGLESHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
@@ -61,7 +62,7 @@ CSFML_GRAPHICS_API sfRectangleShape* sfRectangleShape_copy(const sfRectangleShap
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRectangleShape_destroy(sfRectangleShape* shape);
+CSFML_GRAPHICS_API void sfRectangleShape_destroy(const sfRectangleShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a rectangle shape
@@ -235,7 +236,7 @@ CSFML_GRAPHICS_API sfTransform sfRectangleShape_getInverseTransform(const sfRect
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a rectangle shape will display
@@ -368,6 +369,20 @@ CSFML_GRAPHICS_API size_t sfRectangleShape_getPointCount(const sfRectangleShape*
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getPoint(const sfRectangleShape* shape, size_t index);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the geometric center of the rectangle
+///
+/// The returned point is in local coordinates, that is,
+/// the shape's transforms (position, rotation, scale) are
+/// not taken into account.
+///
+/// \param shape Shape object
+///
+/// \return The geometric center of the shape
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getGeometricCenter(const sfRectangleShape* shape);
+
 ////////////////////////////////////////////////////////////
 /// \brief Set the size of a rectangle shape
 ///
@@ -418,6 +433,3 @@ CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getLocalBounds(const sfRectangle
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getGlobalBounds(const sfRectangleShape* shape);
-
-
-#endif // SFML_RECTANGLESHAPE_H

include/CSFML/Graphics/RenderStates.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_RENDERSTATES_H
+#pragma once
-#define SFML_RENDERSTATES_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/BlendMode.h>
+
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/BlendMode.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/CoordinateType.h>
+#include <CSFML/Graphics/StencilMode.h>
+#include <CSFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -40,16 +42,16 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendMode      blendMode; ///< Blending mode
+    sfBlendMode      blendMode;      ///< Blending mode
-    sfTransform      transform; ///< Transform
+    sfStencilMode    stencilMode;    //!< Stencil mode
-    const sfTexture* texture;   ///< Texture
+    sfTransform      transform;      ///< Transform
-    const sfShader*  shader;    ///< Shader
+    sfCoordinateType coordinateType; //!< Texture coordinate type
+    const sfTexture* texture;        ///< Texture
+    const sfShader*  shader;         ///< Shader
 } sfRenderStates;
 
 ////////////////////////////////////////////////////////////
 /// \brief Define the default values for a RenderState
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderStates sfRenderStates_default(void);
+CSFML_GRAPHICS_API const sfRenderStates sfRenderStates_default;
-
-#endif // SFML_RENDERSTATES_H

include/CSFML/Graphics/RenderTexture.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,50 +22,36 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_RENDERTEXTURE_H
+#pragma once
-#define SFML_RENDERTEXTURE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/PrimitiveType.h>
-#include <SFML/Graphics/PrimitiveType.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/RenderStates.h>
+#include <CSFML/Graphics/RenderStates.h>
-#include <SFML/Graphics/Vertex.h>
+#include <CSFML/Graphics/StencilMode.h>
-#include <SFML/Window/Window.h>
+#include <CSFML/Graphics/Types.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Vertex.h>
+#include <CSFML/System/Vector2.h>
+#include <CSFML/Window/Window.h>
+
 #include <stddef.h>
 
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render texture
 ///
-/// \param width       Width of the render texture
+/// \param size     Size of the render texture
-/// \param height      Height of the render texture
-/// \param depthBuffer Do you want a depth-buffer attached? (useful only if you're doing 3D OpenGL on the rendertexture)
-///
-/// \return A new sfRenderTexture object, or NULL if it failed
-///
-/// \deprecated
-/// Use sfRenderTexture_createWithSettings instead.
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, sfBool depthBuffer);
-
-////////////////////////////////////////////////////////////
-/// \brief Construct a new render texture
-///
-/// \param width    Width of the render texture
-/// \param height   Height of the render texture
 /// \param settings Settings of the render texture
 ///
 /// \return A new sfRenderTexture object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_createWithSettings(unsigned int width, unsigned int height, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(sfVector2u size, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing render texture
@@ -73,7 +59,7 @@ CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_createWithSettings(unsigned
 /// \param renderTexture Render texture to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_destroy(sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API void sfRenderTexture_destroy(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the size of the rendering region of a render texture
@@ -90,21 +76,21 @@ CSFML_GRAPHICS_API sfVector2u sfRenderTexture_getSize(const sfRenderTexture* ren
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if the render texture use sRGB encoding, sfFalse otherwise
+/// \return true if the render texture use sRGB encoding, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Activate or deactivate a render texture as the current target for rendering
 ///
 /// \param renderTexture Render texture object
-/// \param active        sfTrue to activate, sfFalse to deactivate
+/// \param active        true to activate, false to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active);
+CSFML_GRAPHICS_API bool sfRenderTexture_setActive(sfRenderTexture* renderTexture, bool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update the contents of the target texture
@@ -123,6 +109,33 @@ CSFML_GRAPHICS_API void sfRenderTexture_display(sfRenderTexture* renderTexture);
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfRenderTexture_clear(sfRenderTexture* renderTexture, sfColor color);
 
+////////////////////////////////////////////////////////////
+/// \brief Clear the stencil buffer to a specific value
+///
+/// The specified value is truncated to the bit width of
+/// the current stencil buffer.
+///
+/// \param renderTexture Render texture object
+/// \param stencilValue  Stencil value to clear to
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfRenderTexture_clearStencil(sfRenderTexture* renderTexture, sfStencilValue stencilValue);
+
+////////////////////////////////////////////////////////////
+/// \brief Clear the entire target with a single color and stencil value
+///
+/// The specified stencil value is truncated to the bit
+/// width of the current stencil buffer.
+///
+/// \param renderTexture Render texture object
+/// \param color         Fill color to use to clear the render target
+/// \param stencilValue  Stencil value to clear to
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfRenderTexture_clearColorAndStencil(sfRenderTexture* renderTexture,
+                                                             sfColor          color,
+                                                             sfStencilValue   stencilValue);
+
 ////////////////////////////////////////////////////////////
 /// \brief Change the current active view of a render texture
 ///
@@ -163,6 +176,22 @@ CSFML_GRAPHICS_API const sfView* sfRenderTexture_getDefaultView(const sfRenderTe
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getViewport(const sfRenderTexture* renderTexture, const sfView* view);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the scissor rectangle of a view, applied to this render target
+///
+/// The scissor rectangle is defined in the view as a ratio. This
+/// function simply applies this ratio to the current dimensions
+/// of the render target to calculate the pixels rectangle
+/// that the scissor rectangle actually covers in the target.
+///
+/// \param renderTexture Render texture object
+/// \param view          The view for which we want to compute the scissor rectangle
+///
+/// \return Scissor rectangle, expressed in pixels
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getScissor(const sfRenderTexture* renderTexture, const sfView* view);
+
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from texture coordinates to world coordinates
 ///
@@ -188,7 +217,8 @@ CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getViewport(const sfRenderTexture*
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2f
+    sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to texture coordinates
@@ -214,7 +244,8 @@ CSFML_GRAPHICS_API sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTex
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2i
+    sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -224,28 +255,47 @@ CSFML_GRAPHICS_API sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTex
 /// \param states        Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const sfSprite* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture*      renderTexture,
-CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const sfText* object, const sfRenderStates* states);
+                                                   const sfSprite*       object,
-CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const sfShape* object, const sfRenderStates* states);
+                                                   const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const sfCircleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture*      renderTexture,
-CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const sfConvexShape* object, const sfRenderStates* states);
+                                                 const sfText*         object,
-CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const sfRectangleShape* object, const sfRenderStates* states);
+                                                 const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const sfVertexArray* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture*      renderTexture,
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture* renderTexture, const sfVertexBuffer* object, const sfRenderStates* states);
+                                                  const sfShape*        object,
+                                                  const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture*      renderTexture,
+                                                        const sfCircleShape*  object,
+                                                        const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture*      renderTexture,
+                                                        const sfConvexShape*  object,
+                                                        const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture*        renderTexture,
+                                                           const sfRectangleShape* object,
+                                                           const sfRenderStates*   states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture*      renderTexture,
+                                                        const sfVertexArray*  object,
+                                                        const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture*      renderTexture,
+                                                         const sfVertexBuffer* object,
+                                                         const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by a vertex buffer.
 ///
 /// \param renderTexture render texture object
-/// \param vertexBuffer  Vertex buffer object to draw
+/// \param object        Vertex buffer object to draw
 /// \param firstVertex   Index of the first vertex to render
 /// \param vertexCount   Number of vertices to render
 /// \param states        Render states to use for drawing
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(sfRenderTexture* renderTexture,
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(
-                                                              const sfVertexBuffer* object, size_t firstVertex,
+    sfRenderTexture*      renderTexture,
-                                                              size_t vertexCount, const sfRenderStates* states);
+    const sfVertexBuffer* object,
+    size_t                firstVertex,
+    size_t                vertexCount,
+    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render texture
@@ -257,9 +307,12 @@ CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(sfRenderTexture* r
 /// \param states        Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture,
+CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(
-                                                       const sfVertex* vertices, size_t vertexCount,
+    sfRenderTexture*      renderTexture,
-                                                       sfPrimitiveType type, const sfRenderStates* states);
+    const sfVertex*       vertices,
+    size_t                vertexCount,
+    sfPrimitiveType       type,
+    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -326,45 +379,45 @@ CSFML_GRAPHICS_API const sfTexture* sfRenderTexture_getTexture(const sfRenderTex
 /// \return The maximum anti-aliasing level supported by the system
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API unsigned int sfRenderTexture_getMaximumAntialiasingLevel(void);
+CSFML_GRAPHICS_API unsigned int sfRenderTexture_getMaximumAntiAliasingLevel(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable the smooth filter on a render texture
 ///
 /// \param renderTexture Render texture object
-/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth        true to enable smoothing, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth);
+CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a render texture
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable texture repeating
 ///
 /// \param renderTexture Render texture object
-/// \param repeated      sfTrue to enable repeating, sfFalse to disable it
+/// \param repeated      true to enable repeating, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, sfBool repeated);
+CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, bool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture is repeated or not
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
+/// \return true if repeat mode is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -377,10 +430,7 @@ CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* rend
 /// after subsequent drawing will lead to undefined behavior if a mipmap
 /// had been previously generated.
 ///
-/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
+/// \return true if mipmap generation was successful, false if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
-
-
-#endif // SFML_RENDERTEXTURE_H

include/CSFML/Graphics/RenderWindow.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,24 +22,27 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_RENDERWINDOW_H
+#pragma once
-#define SFML_RENDERWINDOW_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/PrimitiveType.h>
-#include <SFML/Graphics/PrimitiveType.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/RenderStates.h>
+#include <CSFML/Graphics/RenderStates.h>
-#include <SFML/Graphics/Vertex.h>
+#include <CSFML/Graphics/StencilMode.h>
-#include <SFML/Window/Event.h>
+#include <CSFML/Graphics/Types.h>
-#include <SFML/Window/VideoMode.h>
+#include <CSFML/Graphics/Vertex.h>
-#include <SFML/Window/WindowHandle.h>
+#include <CSFML/System/Time.h>
-#include <SFML/Window/Window.h>
+#include <CSFML/System/Vector2.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Window/Event.h>
+#include <CSFML/Window/VideoMode.h>
+#include <CSFML/Window/Window.h>
+#include <CSFML/Window/WindowHandle.h>
+
 #include <stddef.h>
 
 
@@ -49,10 +52,16 @@
 /// \param mode     Video mode to use
 /// \param title    Title of the window
 /// \param style    Window style
+/// \param state    Window state
 /// \param settings Creation settings (pass NULL to use default values)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(
+    sfVideoMode              mode,
+    const char*              title,
+    uint32_t                 style,
+    sfWindowState            state,
+    const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render window (with a UTF-32 title)
@@ -60,10 +69,16 @@ CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const
 /// \param mode     Video mode to use
 /// \param title    Title of the window (UTF-32)
 /// \param style    Window style
+/// \param state    Window state
 /// \param settings Creation settings (pass NULL to use default values)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(
+    sfVideoMode              mode,
+    const sfChar32*          title,
+    uint32_t                 style,
+    sfWindowState            state,
+    const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a render window from an existing control
@@ -80,7 +95,7 @@ CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createFromHandle(sfWindowHandl
 /// \param renderWindow Render window to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_destroy(sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API void sfRenderWindow_destroy(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Close a render window (but doesn't destroy the internal data)
@@ -96,7 +111,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_close(sfRenderWindow* renderWindow);
 /// \param renderWindow Render window object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the creation settings of a render window
@@ -109,26 +124,47 @@ CSFML_GRAPHICS_API sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWind
 CSFML_GRAPHICS_API sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
-/// \brief Get the event on top of event queue of a render window, if any, and pop it
+/// \brief Pop the event on top of event queue, if any, and return it
+///
+/// This function is not blocking: if there's no pending event then
+/// it will return false and leave \a event unmodified.
+/// Note that more than one event may be present in the event queue,
+/// thus you should always call this function in a loop
+/// to make sure that you process every pending event.
 ///
 /// \param renderWindow Render window object
 /// \param event        Event to fill, if any
 ///
-/// \return sfTrue if an event was returned, sfFalse if event queue was empty
+/// \return true if an event was returned, or false if the event queue was empty
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
+CSFML_GRAPHICS_API bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Wait for an event and return it
 ///
-/// \param renderWindow Render window object
+/// This function is blocking: if there's no pending event then
-/// \param event        Event to fill
+/// it will wait until an event is received or until the provided
+/// timeout elapses. Only if an error or a timeout occurs the
+/// function returns `false`.
+/// This function is typically used when you have a thread that is
+/// dedicated to events handling: you want to make this thread sleep
+/// as long as no new event is received.
+/// \code
+/// while (sfRenderWindow_waitEvent(renderWindow, timeout, &event))
+/// {
+///    // process event...
+/// }
+/// \endcode
 ///
-/// \return sfFalse if an error occured
+/// \param renderWindow Render window object
+/// \param timeout      Maximum time to wait (`sfTime_Zero` for infinite)
+/// \param event        Event to fill, if any
+///
+/// \return true if an event was returned, false if event queue was empty or function timed out
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event);
+CSFML_GRAPHICS_API bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfTime timeout, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of a render window
@@ -166,10 +202,10 @@ CSFML_GRAPHICS_API sfVector2u sfRenderWindow_getSize(const sfRenderWindow* rende
 ///
 /// \param renderWindow Render window object
 ///
-/// \return sfTrue if the render window use sRGB encoding, sfFalse otherwise
+/// \return true if the render window use sRGB encoding, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the size of the rendering region of a render window
@@ -196,45 +232,44 @@ CSFML_GRAPHICS_API void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, co
 /// \param title        New title
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfUint32* title);
+CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfChar32* title);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a render window's icon
 ///
 /// \param renderWindow Render window object
-/// \param width        Icon's width, in pixels
+/// \param size         Icon's size, in pixels
-/// \param height       Icon's height, in pixels
 /// \param pixels       Pointer to the pixels in memory, format must be RGBA 32 bits
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, sfVector2u size, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide a render window
 ///
 /// \param renderWindow Render window object
-/// \param visible      sfTrue to show the window, sfFalse to hide it
+/// \param visible      true to show the window, false to hide it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, sfBool visible);
+CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable / disable vertical synchronization on a render window
 ///
 /// \param renderWindow Render window object
-/// \param enabled      sfTrue to enable v-sync, sfFalse to deactivate
+/// \param enabled      true to enable v-sync, false to deactivate
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, sfBool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide the mouse cursor on a render window
 ///
 /// \param renderWindow Render window object
-/// \param show         sfTrue to show, sfFalse to hide
+/// \param show         true to show, false to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, sfBool show);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, bool show);
 
 ////////////////////////////////////////////////////////////
 /// \brief Grab or release the mouse cursor
@@ -246,10 +281,11 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* ren
 /// won't have any effect (fullscreen windows always grab the
 /// cursor).
 ///
-/// \param grabbed sfTrue to enable, sfFalse to disable
+/// \param renderWindow Render window object
+/// \param grabbed      true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, sfBool grabbed);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, bool grabbed);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the displayed cursor to a native system cursor
@@ -262,13 +298,14 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* ren
 /// \warning Features related to Cursor are not supported on
 ///          iOS and Android.
 ///
-/// \param cursor Native system cursor type to display
+/// \param renderWindow Render window object
+/// \param cursor       Native system cursor type to display
 ///
 /// \see sfCursor_createFromSystem
 /// \see sfCursor_createFromPixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* window, const sfCursor* cursor);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* renderWindow, const sfCursor* cursor);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable automatic key-repeat for keydown events
@@ -276,10 +313,10 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* window, co
 /// Automatic key-repeat is enabled by default
 ///
 /// \param renderWindow Render window object
-/// \param enabled      sfTrue to enable, sfFalse to disable
+/// \param enabled      true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, sfBool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Limit the framerate to a maximum fixed frequency for a render window
@@ -303,12 +340,12 @@ CSFML_GRAPHICS_API void sfRenderWindow_setJoystickThreshold(sfRenderWindow* rend
 /// \brief Activate or deactivate a render window as the current target for rendering
 ///
 /// \param renderWindow Render window object
-/// \param active       sfTrue to activate, sfFalse to deactivate
+/// \param active       true to activate, false to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_setActive(sfRenderWindow* renderWindow, sfBool active);
+CSFML_GRAPHICS_API bool sfRenderWindow_setActive(sfRenderWindow* renderWindow, bool active);
 
 ///////////////////////////////////////////////////////////
 /// \brief Request the current render window to be made the active
@@ -334,7 +371,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow
 /// \return True if window has focus, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Display a render window on screen
@@ -352,7 +389,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_display(sfRenderWindow* renderWindow);
 /// \return Window handle
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getSystemHandle(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getNativeHandle(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Clear a render window with the given color
@@ -363,6 +400,31 @@ CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getSystemHandle(const sfRenderW
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfRenderWindow_clear(sfRenderWindow* renderWindow, sfColor color);
 
+////////////////////////////////////////////////////////////
+/// \brief Clear the stencil buffer to a specific value
+///
+/// The specified value is truncated to the bit width of
+/// the current stencil buffer.
+///
+/// \param renderWindow Render window object
+/// \param stencilValue Stencil value to clear to
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfRenderWindow_clearStencil(sfRenderWindow* renderWindow, sfStencilValue stencilValue);
+
+////////////////////////////////////////////////////////////
+/// \brief Clear the entire target with a single color and stencil value
+///
+/// The specified stencil value is truncated to the bit
+/// width of the current stencil buffer.
+///
+/// \param renderWindow Render window object
+/// \param color        Fill color to use to clear the render target
+/// \param stencilValue Stencil value to clear to
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfRenderWindow_clearColorAndStencil(sfRenderWindow* renderWindow, sfColor color, sfStencilValue stencilValue);
+
 ////////////////////////////////////////////////////////////
 /// \brief Change the current active view of a render window
 ///
@@ -403,6 +465,22 @@ CSFML_GRAPHICS_API const sfView* sfRenderWindow_getDefaultView(const sfRenderWin
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getViewport(const sfRenderWindow* renderWindow, const sfView* view);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the scissor rectangle of a view, applied to this render target
+///
+/// The scissor rectangle is defined in the view as a ratio. This
+/// function simply applies this ratio to the current dimensions
+/// of the render target to calculate the pixels rectangle
+/// that the scissor rectangle actually covers in the target.
+///
+/// \param renderWindow Render window object
+/// \param view         The view for which we want to compute the scissor rectangle
+///
+/// \return Scissor rectangle, expressed in pixels
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getScissor(const sfRenderWindow* renderWindow, const sfView* view);
+
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from window coordinates to world coordinates
 ///
@@ -431,7 +509,8 @@ CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getViewport(const sfRenderWindow* re
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2f
+    sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to window coordinates
@@ -457,7 +536,8 @@ CSFML_GRAPHICS_API sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWind
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2i
+    sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -467,28 +547,43 @@ CSFML_GRAPHICS_API sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWind
 /// \param states       Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const sfSprite* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow*       renderWindow,
+                                                  const sfSprite*       object,
+                                                  const sfRenderStates* states);
 CSFML_GRAPHICS_API void sfRenderWindow_drawText(sfRenderWindow* renderWindow, const sfText* object, const sfRenderStates* states);
 CSFML_GRAPHICS_API void sfRenderWindow_drawShape(sfRenderWindow* renderWindow, const sfShape* object, const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const sfCircleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow*       renderWindow,
-CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const sfConvexShape* object, const sfRenderStates* states);
+                                                       const sfCircleShape*  object,
-CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const sfRectangleShape* object, const sfRenderStates* states);
+                                                       const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const sfVertexArray* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow*       renderWindow,
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow* renderWindow, const sfVertexBuffer* object, const sfRenderStates* states);
+                                                       const sfConvexShape*  object,
+                                                       const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow*         renderWindow,
+                                                          const sfRectangleShape* object,
+                                                          const sfRenderStates*   states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow*       renderWindow,
+                                                       const sfVertexArray*  object,
+                                                       const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow*       renderWindow,
+                                                        const sfVertexBuffer* object,
+                                                        const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by a vertex buffer.
 ///
-/// \param renderWindow render window object
+/// \param renderWindow Render window object
-/// \param vertexBuffer Vertex buffer object to draw
+/// \param object       Vertex buffer object to draw
 /// \param firstVertex  Index of the first vertex to render
 /// \param vertexCount  Number of vertices to render
 /// \param states       Render states to use for drawing
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(sfRenderWindow* renderWindow,
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(
-                                                             const sfVertexBuffer* object, size_t firstVertex,
+    sfRenderWindow*       renderWindow,
-                                                             size_t vertexCount, const sfRenderStates* states);
+    const sfVertexBuffer* object,
+    size_t                firstVertex,
+    size_t                vertexCount,
+    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render window
@@ -500,9 +595,12 @@ CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(sfRenderWindow* ren
 /// \param states       Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow,
+CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(
-                                                      const sfVertex* vertices, size_t vertexCount,
+    sfRenderWindow*       renderWindow,
-                                                      sfPrimitiveType type, const sfRenderStates* states);
+    const sfVertex*       vertices,
+    size_t                vertexCount,
+    sfPrimitiveType       type,
+    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -552,33 +650,6 @@ CSFML_GRAPHICS_API void sfRenderWindow_popGLStates(sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfRenderWindow_resetGLStates(sfRenderWindow* renderWindow);
 
-////////////////////////////////////////////////////////////
-/// \brief Copy the current contents of the window to an image
-///
-/// \deprecated
-/// Use a sfTexture and its
-/// sfTexture_updateFromRenderWindow(sfTexture*, const sfRenderWindow*, unsigned int, unsigned int)
-/// function and copy its contents into an sfImage instead.
-/// \code
-/// sfVector2u windowSize = sfRenderWindow_getSize(window);
-/// sfTexture* texture = sfTexture_create(windowSize.x, windowSize.y);
-/// sfTexture_updateFromRenderWindow(texture, window, windowSize.x, windowSize.y);
-/// sfImage* screenshot = sfTexture_copyToImage(texture);
-/// \endcode
-///
-/// This is a slow operation, whose main purpose is to make
-/// screenshots of the application. If you want to update an
-/// image with the contents of the window and then use it for
-/// drawing, you should rather use a sfTexture and the
-/// sfTexture_updateFromWindow(sfTexture*, const sfWindow*, unsigned int, unsigned int) function.
-/// You can also draw things directly to a texture with the
-/// sfRenderTexture class.
-///
-/// \return sfImage containing the captured contents.
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED sfImage* sfRenderWindow_capture(const sfRenderWindow* renderWindow);
-
 ////////////////////////////////////////////////////////////
 /// \brief Get the current position of the mouse relative to a render-window
 ///
@@ -618,5 +689,19 @@ CSFML_GRAPHICS_API void sfMouse_setPositionRenderWindow(sfVector2i position, con
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2i sfTouch_getPositionRenderWindow(unsigned int finger, const sfRenderWindow* relativeTo);
 
-
+////////////////////////////////////////////////////////////
-#endif // SFML_RENDERWINDOW_H
+/// \brief Create a Vulkan rendering surface
+///
+/// \param renderWindow RenderWindow object
+/// \param instance     Vulkan instance
+/// \param surface      Created surface
+/// \param allocator    Allocator to use
+///
+/// \return True if surface creation was successful, false otherwise
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API bool sfRenderWindow_createVulkanSurface(
+    sfRenderWindow*              renderWindow,
+    const VkInstance*            instance,
+    VkSurfaceKHR*                surface,
+    const VkAllocationCallbacks* allocator);

include/CSFML/Graphics/Shader.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,20 +22,21 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SHADER_H
+#pragma once
-#define SFML_SHADER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Glsl.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Glsl.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/InputStream.h>
+#include <CSFML/Graphics/Types.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/System/InputStream.h>
-#include <SFML/System/Vector3.h>
+#include <CSFML/System/Vector2.h>
+#include <CSFML/System/Vector3.h>
+
 #include <stddef.h>
 
 
@@ -57,7 +58,9 @@
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
+                                                     const char* geometryShaderFilename,
+                                                     const char* fragmentShaderFilename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from source code in memory
@@ -77,7 +80,9 @@ CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFil
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader,
+                                                       const char* geometryShader,
+                                                       const char* fragmentShader);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from custom streams
@@ -97,7 +102,9 @@ CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader,
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream,
+                                                       sfInputStream* geometryShaderStream,
+                                                       sfInputStream* fragmentShaderStream);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing shader
@@ -105,7 +112,7 @@ CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShad
 /// \param shader Shader to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_destroy(sfShader* shader);
+CSFML_GRAPHICS_API void sfShader_destroy(const sfShader* shader);
 
 ////////////////////////////////////////////////////////////
 /// \brief Specify value for \p float uniform
@@ -221,7 +228,7 @@ CSFML_GRAPHICS_API void sfShader_setIntColorUniform(sfShader* shader, const char
 /// \param x      Value of the bool scalar
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x);
+CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, bool x);
 
 ////////////////////////////////////////////////////////////
 /// \brief Specify value for \p bvec2 uniform
@@ -398,253 +405,6 @@ CSFML_GRAPHICS_API void sfShader_setMat3UniformArray(sfShader* shader, const cha
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length);
 
-////////////////////////////////////////////////////////////
-/// \brief Change a float parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a float
-/// (float GLSL type).
-///
-/// Example:
-/// \code
-/// uniform float myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setFloatParameter(shader, "myparam", 5.2f);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param x      Value to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloatParameter(sfShader* shader, const char* name, float x);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a 2-components vector parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 2x1 vector
-/// (vec2 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform vec2 myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setFloat2Parameter(shader, "myparam", 5.2f, 6.0f);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param x      First component of the value to assign
-/// \param y      Second component of the value to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a 3-components vector parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 3x1 vector
-/// (vec3 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform vec3 myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setFloat3Parameter(shader, "myparam", 5.2f, 6.0f, -8.1f);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param x      First component of the value to assign
-/// \param y      Second component of the value to assign
-/// \param z      Third component of the value to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a 4-components vector parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 4x1 vector
-/// (vec4 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform vec4 myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setFloat4Parameter(shader, "myparam", 5.2f, 6.0f, -8.1f, 0.4f);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param x      First component of the value to assign
-/// \param y      Second component of the value to assign
-/// \param z      Third component of the value to assign
-/// \param w      Fourth component of the value to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a 2-components vector parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 2x1 vector
-/// (vec2 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform vec2 myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfVector2f vec = {5.2f, 6.0f};
-/// sfShader_setVector2Parameter(shader, "myparam", vec);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param vector Vector to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a 3-components vector parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 3x1 vector
-/// (vec3 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform vec3 myparam; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfVector3f vec = {5.2f, 6.0f, -8.1f};
-/// sfShader_setVector3Parameter(shader, "myparam", vec);
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param vector Vector to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a color parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 4x1 vector
-/// (vec4 GLSL type).
-///
-/// It is important to note that the components of the color are
-/// normalized before being passed to the shader. Therefore,
-/// they are converted from range [0 .. 255] to range [0 .. 1].
-/// For example, a sf::Color(255, 125, 0, 255) will be transformed
-/// to a vec4(1.0, 0.5, 0.0, 1.0) in the shader.
-///
-/// Example:
-/// \code
-/// uniform vec4 color; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setColorParameter(shader, "color", sfColor_fromRGB(255, 128, 0));
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the parameter in the shader
-/// \param color  Color to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a matrix parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 4x4 matrix
-/// (mat4 GLSL type).
-///
-/// Example:
-/// \code
-/// uniform mat4 matrix; // this is the variable in the shader
-/// \endcode
-/// \code
-/// @todo
-/// sfShader_setTransformParameter(shader, "matrix", transform);
-/// \endcode
-///
-/// \param shader    Shader object
-/// \param name      Name of the parameter in the shader
-/// \param transform Transform to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a texture parameter of a shader
-///
-/// \a name is the name of the variable to change in the shader.
-/// The corresponding parameter in the shader must be a 2D texture
-/// (sampler2D GLSL type).
-///
-/// Example:
-/// \code
-/// uniform sampler2D the_texture; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sf::Texture texture;
-/// ...
-/// sfShader_setTextureParameter(shader, "the_texture", texture);
-/// \endcode
-/// It is important to note that \a texture must remain alive as long
-/// as the shader uses it, no copy is made internally.
-///
-/// To use the texture of the object being draw, which cannot be
-/// known in advance, you can use the special function
-/// sfShader_setCurrentTextureParameter:
-/// \code
-/// sfShader_setCurrentTextureParameter(shader, "the_texture").
-/// \endcode
-///
-/// \param shader  Shader object
-/// \param name    Name of the texture in the shader
-/// \param texture Texture to assign
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a texture parameter of a shader
-///
-/// This function maps a shader texture variable to the
-/// texture of the object being drawn, which cannot be
-/// known in advance.
-/// The corresponding parameter in the shader must be a 2D texture
-/// (sampler2D GLSL type).
-///
-/// Example:
-/// \code
-/// uniform sampler2D current; // this is the variable in the shader
-/// \endcode
-/// \code
-/// sfShader_setCurrentTextureParameter(shader, "current");
-/// \endcode
-///
-/// \param shader Shader object
-/// \param name   Name of the texture in the shader
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name);
-
 ////////////////////////////////////////////////////////////
 /// \brief Get the underlying OpenGL handle of the shader.
 ///
@@ -689,10 +449,10 @@ CSFML_GRAPHICS_API void sfShader_bind(const sfShader* shader);
 /// the shader features. If it returns false, then
 /// any attempt to use sfShader will fail.
 ///
-/// \return sfTrue if the system can use shaders, sfFalse otherwise
+/// \return true if the system can use shaders, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void);
+CSFML_GRAPHICS_API bool sfShader_isAvailable(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not the system supports geometry shaders
@@ -711,6 +471,4 @@ CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void);
 /// \return True if geometry shaders are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfShader_isGeometryAvailable(void);
+CSFML_GRAPHICS_API bool sfShader_isGeometryAvailable(void);
-
-#endif // SFML_SHADER_H

include/CSFML/Graphics/Shape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,22 +22,23 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SHAPE_H
+#pragma once
-#define SFML_SHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
-typedef size_t (*sfShapeGetPointCountCallback)(void*);        ///< Type of the callback used to get the number of points in a shape
+typedef size_t (*sfShapeGetPointCountCallback)(void*); ///< Type of the callback used to get the number of points in a shape
 typedef sfVector2f (*sfShapeGetPointCallback)(size_t, void*); ///< Type of the callback used to get a point of a shape
 
 ////////////////////////////////////////////////////////////
@@ -51,8 +52,8 @@ typedef sfVector2f (*sfShapeGetPointCallback)(size_t, void*); ///< Type of the c
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfShape* sfShape_create(sfShapeGetPointCountCallback getPointCount,
-                                           sfShapeGetPointCallback getPoint,
+                                           sfShapeGetPointCallback      getPoint,
-                                           void* userData);
+                                           void*                        userData);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing shape
@@ -60,7 +61,7 @@ CSFML_GRAPHICS_API sfShape* sfShape_create(sfShapeGetPointCountCallback getPoint
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShape_destroy(sfShape* shape);
+CSFML_GRAPHICS_API void sfShape_destroy(const sfShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a shape
@@ -234,7 +235,7 @@ CSFML_GRAPHICS_API sfTransform sfShape_getInverseTransform(const sfShape* shape)
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a shape will display
@@ -367,6 +368,20 @@ CSFML_GRAPHICS_API size_t sfShape_getPointCount(const sfShape* shape);
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2f sfShape_getPoint(const sfShape* shape, size_t index);
 
+////////////////////////////////////////////////////////////
+/// \brief Get the geometric center of the shape
+///
+/// The returned point is in local coordinates, that is,
+/// the shape's transforms (position, rotation, scale) are
+/// not taken into account.
+///
+/// \param shape Shape object
+///
+/// \return The geometric center of the shape
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfShape_getGeometricCenter(const sfShape* shape);
+
 ////////////////////////////////////////////////////////////
 /// \brief Get the local bounding rectangle of a shape
 ///
@@ -403,11 +418,8 @@ CSFML_GRAPHICS_API sfFloatRect sfShape_getGlobalBounds(const sfShape* shape);
 /// \brief Recompute the internal geometry of a shape
 ///
 /// This function must be called by specialized shape objects
-/// everytime their points change (ie. the result of either
+/// every time their points change (ie. the result of either
 /// the getPointCount or getPoint callbacks is different).
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfShape_update(sfShape* shape);
-
-
-#endif // SFML_SHAPE_H

include/CSFML/Graphics/Sprite.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,28 +22,30 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SPRITE_H
+#pragma once
-#define SFML_SPRITE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/BlendMode.h>
+
-#include <SFML/Graphics/Color.h>
+#include <CSFML/Graphics/BlendMode.h>
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sprite
 ///
+/// \param texture Source texture
+///
 /// \return A new sfSprite object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfSprite* sfSprite_create(void);
+CSFML_GRAPHICS_API sfSprite* sfSprite_create(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing sprite
@@ -61,7 +63,7 @@ CSFML_GRAPHICS_API sfSprite* sfSprite_copy(const sfSprite* sprite);
 /// \param sprite Sprite to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfSprite_destroy(sfSprite* sprite);
+CSFML_GRAPHICS_API void sfSprite_destroy(const sfSprite* sprite);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a sprite
@@ -234,7 +236,7 @@ CSFML_GRAPHICS_API sfTransform sfSprite_getInverseTransform(const sfSprite* spri
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a sprite will display
@@ -328,6 +330,3 @@ CSFML_GRAPHICS_API sfFloatRect sfSprite_getLocalBounds(const sfSprite* sprite);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfSprite_getGlobalBounds(const sfSprite* sprite);
-
-
-#endif // SFML_SPRITE_H

include/CSFML/Graphics/StencilMode.h

@@ -0,0 +1,96 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <CSFML/Graphics/Export.h>
+
+
+////////////////////////////////////////////////////////
+/// \brief Enumeration of the stencil test comparisons that can be performed
+///
+/// The comparisons are mapped directly to their OpenGL equivalents,
+/// specified by `glStencilFunc()`.
+////////////////////////////////////////////////////////
+typedef enum
+{
+    sfStencilComparisonNever, //!< The stencil test never passes
+    sfStencilComparisonLess,  //!< The stencil test passes if the new value is less than the value in the stencil buffer
+    sfStencilComparisonLessEqual, //!< The stencil test passes if the new value is less than or equal to the value in the stencil buffer
+    sfStencilComparisonGreater, //!< The stencil test passes if the new value is greater than the value in the stencil buffer
+    sfStencilComparisonGreaterEqual, //!< The stencil test passes if the new value is greater than or equal to the value in the stencil buffer
+    sfStencilComparisonEqual, //!< The stencil test passes if the new value is strictly equal to the value in the stencil buffer
+    sfStencilComparisonNotEqual, //!< The stencil test passes if the new value is strictly unequal to the value in the stencil buffer
+    sfStencilComparisonAlways //!< The stencil test always passes
+} sfStencilComparison;
+
+
+////////////////////////////////////////////////////////
+/// \brief Enumeration of the stencil buffer update operations
+///
+/// The update operations are mapped directly to their OpenGL equivalents,
+/// specified by `glStencilOp()`.
+////////////////////////////////////////////////////////
+typedef enum
+{
+    sfStencilUpdateOperationKeep, //!< If the stencil test passes, the value in the stencil buffer is not modified
+    sfStencilUpdateOperationZero, //!< If the stencil test passes, the value in the stencil buffer is set to zero
+    sfStencilUpdateOperationReplace, //!< If the stencil test passes, the value in the stencil buffer is set to the new value
+    sfStencilUpdateOperationIncrement, //!< If the stencil test passes, the value in the stencil buffer is incremented and if required clamped
+    sfStencilUpdateOperationDecrement, //!< If the stencil test passes, the value in the stencil buffer is decremented and if required clamped
+    sfStencilUpdateOperationInvert, //!< If the stencil test passes, the value in the stencil buffer is bitwise inverted
+} sfStencilUpdateOperation;
+
+
+////////////////////////////////////////////////////////
+/// \brief Stencil value type (also used as a mask)
+///
+////////////////////////////////////////////////////////
+typedef struct
+{
+    unsigned int value; //!< The stored stencil value
+} sfStencilValue;
+
+
+////////////////////////////////////////////////////////////
+/// \brief Stencil modes for drawing
+///
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    sfStencilComparison      stencilComparison;      //!< The comparison we're performing the stencil test with
+    sfStencilUpdateOperation stencilUpdateOperation; //!< The update operation to perform if the stencil test passes
+    sfStencilValue           stencilReference;       //!< The reference value we're performing the stencil test with
+    sfStencilValue stencilMask; //!< The mask to apply to both the reference value and the value in the stencil buffer
+    bool           stencilOnly; //!< Whether we should update the color buffer in addition to the stencil buffer
+} sfStencilMode;
+
+////////////////////////////////////////////////////////////
+/// \brief Define the default values for a StencilMode
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API const sfStencilMode sfStencilMode_default;

include/CSFML/Graphics/Text.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,18 +22,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TEXT_H
+#pragma once
-#define SFML_TEXT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Color.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
+
 #include <stddef.h>
 
 
@@ -53,10 +54,12 @@ typedef enum
 ////////////////////////////////////////////////////////////
 /// \brief Create a new text
 ///
+/// \param font Font used to draw the string
+///
 /// \return A new sfText object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfText* sfText_create(void);
+CSFML_GRAPHICS_API sfText* sfText_create(const sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing text
@@ -74,7 +77,7 @@ CSFML_GRAPHICS_API sfText* sfText_copy(const sfText* text);
 /// \param text Text to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_destroy(sfText* text);
+CSFML_GRAPHICS_API void sfText_destroy(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a text
@@ -247,7 +250,7 @@ CSFML_GRAPHICS_API void sfText_setString(sfText* text, const char* string);
 /// \param string New string
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const sfUint32* string);
+CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const sfChar32* string);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the font of a text
@@ -276,7 +279,7 @@ CSFML_GRAPHICS_API void sfText_setFont(sfText* text, const sfFont* font);
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfText_setCharacterSize(sfText* text, unsigned int size);
 
-    ////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
 /// \brief Set the line spacing factor
 ///
 /// The default spacing between lines is defined by the font.
@@ -322,23 +325,7 @@ CSFML_GRAPHICS_API void sfText_setLetterSpacing(sfText* text, float spacingFacto
 /// \param style New style
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, sfUint32 style);
+CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, uint32_t style);
-
-////////////////////////////////////////////////////////////
-/// \brief Set the fill color of a text
-///
-/// By default, the text's fill color is opaque white.
-/// Setting the fill color to a transparent color with an outline
-/// will cause the outline to be displayed in the fill area of the text.
-///
-/// \param text  Text object
-/// \param color New fill color of the text
-///
-/// \deprecated This function is deprecated and may be removed in future releases.
-/// Use sfText_setFillColor instead.
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setColor(sfText* text, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the fill color of a text
@@ -372,6 +359,7 @@ CSFML_GRAPHICS_API void sfText_setOutlineColor(sfText* text, sfColor color);
 /// Be aware that using a negative value for the outline
 /// thickness will cause distorted rendering.
 ///
+/// \param text      Text object
 /// \param thickness New outline thickness, in pixels
 ///
 /// \see getOutlineThickness
@@ -397,7 +385,7 @@ CSFML_GRAPHICS_API const char* sfText_getString(const sfText* text);
 /// \return String as UTF-32
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfUint32* sfText_getUnicodeString(const sfText* text);
+CSFML_GRAPHICS_API const sfChar32* sfText_getUnicodeString(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font used by a text
@@ -455,20 +443,7 @@ CSFML_GRAPHICS_API float sfText_getLineSpacing(const sfText* text);
 /// \return Current string style (see sfTextStyle enum)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfUint32 sfText_getStyle(const sfText* text);
+CSFML_GRAPHICS_API uint32_t sfText_getStyle(const sfText* text);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the fill color of a text
-///
-/// \param text Text object
-///
-/// \return Fill color of the text
-///
-/// \deprecated This function is deprecated and may be removed in future releases.
-/// Use sfText_getFillColor instead.
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfText_getColor(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the fill color of a text
@@ -549,6 +524,3 @@ CSFML_GRAPHICS_API sfFloatRect sfText_getLocalBounds(const sfText* text);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfText_getGlobalBounds(const sfText* text);
-
-
-#endif // SFML_TEXT_H

include/CSFML/Graphics/Texture.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,40 +22,41 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TEXTURE_H
+#pragma once
-#define SFML_TEXTURE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
-#include <SFML/Window/Types.h>
-#include <SFML/System/InputStream.h>
-#include <SFML/System/Vector2.h>
-#include <stddef.h>
 
-////////////////////////////////////////////////////////////
+#include <CSFML/Graphics/CoordinateType.h>
-/// \brief Types of texture coordinates that can be used for rendering.
+#include <CSFML/Graphics/Rect.h>
-///
+#include <CSFML/Graphics/Types.h>
-////////////////////////////////////////////////////////////
+#include <CSFML/System/InputStream.h>
-typedef enum
+#include <CSFML/System/Vector2.h>
-{
+#include <CSFML/Window/Types.h>
-    sfTextureNormalized, ///< sfTexture coordinates in range [0 .. 1].
+
-    sfTexturePixels      ///< sfTexture coordinates in range [0 .. size].
+#include <stddef.h>
-} sfTextureCoordinateType;
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture
 ///
-/// \param width  Texture width
+/// \param size Texture size
-/// \param height Texture height
 ///
 /// \return A new sfTexture object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_create(unsigned int width, unsigned int height);
+CSFML_GRAPHICS_API sfTexture* sfTexture_create(sfVector2u size);
+
+////////////////////////////////////////////////////////////
+/// \brief Create a new sRGB-enabled texture
+///
+/// \param size Texture size
+///
+/// \return A new sfTexture object, or NULL if it failed
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgb(sfVector2u size);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture from a file
@@ -175,7 +176,7 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_copy(const sfTexture* texture);
 /// \param texture Texture to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_destroy(sfTexture* texture);
+CSFML_GRAPHICS_API void sfTexture_destroy(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of the texture
@@ -202,13 +203,11 @@ CSFML_GRAPHICS_API sfImage* sfTexture_copyToImage(const sfTexture* texture);
 ///
 /// \param texture Texture to update
 /// \param pixels  Array of pixels to copy to the texture
-/// \param width   Width of the pixel region contained in \a pixels
+/// \param size    size of the pixel region contained in \a pixels
-/// \param height  Height of the pixel region contained in \a pixels
+/// \param offset  Offset in the texture where to copy the source pixels
-/// \param x       X offset in the texture where to copy the source pixels
-/// \param y       Y offset in the texture where to copy the source pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, sfVector2u size, sfVector2u offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a part of this texture from another texture
@@ -222,63 +221,59 @@ CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const sfU
 ///
 /// \param destination Destination texture to copy source texture to
 /// \param source      Source texture to copy to destination texture
-/// \param x           X offset in this texture where to copy the source texture
+/// \param offset      Offset in this texture where to copy the source texture
-/// \param y           Y offset in this texture where to copy the source texture
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* source, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* source, sfVector2u offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a texture from an image
 ///
 /// \param texture Texture to update
 /// \param image   Image to copy to the texture
-/// \param x       X offset in the texture where to copy the source pixels
+/// \param offset  Offset in the texture where to copy the source pixels
-/// \param y       Y offset in the texture where to copy the source pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, sfVector2u offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a texture from the contents of a window
 ///
 /// \param texture Texture to update
 /// \param window  Window to copy to the texture
-/// \param x       X offset in the texture where to copy the source pixels
+/// \param offset  Offset in the texture where to copy the source pixels
-/// \param y       Y offset in the texture where to copy the source pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, sfVector2u offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a texture from the contents of a render-window
 ///
 /// \param texture      Texture to update
 /// \param renderWindow Render-window to copy to the texture
-/// \param x            X offset in the texture where to copy the source pixels
+/// \param offset       Offset in the texture where to copy the source pixels
-/// \param y            Y offset in the texture where to copy the source pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, sfVector2u offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable the smooth filter on a texture
 ///
 /// \param texture The texture object
-/// \param smooth  sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth  true to enable smoothing, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, sfBool smooth);
+CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a texture
 ///
 /// \param texture The texture object
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isSmooth(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture source is converted from sRGB or not
@@ -291,7 +286,7 @@ CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture);
 /// \see sfTexture_createSrgbFromImage
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isSrgb(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isSrgb(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable repeating for a texture
@@ -314,17 +309,17 @@ CSFML_GRAPHICS_API sfBool sfTexture_isSrgb(const sfTexture* texture);
 /// \param repeated True to repeat the texture, false to disable repeating
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, sfBool repeated);
+CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, bool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a texture is repeated or not
 ///
 /// \param texture The texture object
 ///
-/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
+/// \return true if repeat mode is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isRepeated(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -346,10 +341,10 @@ CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture);
 /// modified, at which point this function will have to be called again to
 /// regenerate it.
 ///
-/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
+/// \return true if mipmap generation was successful, false if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_generateMipmap(sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_generateMipmap(sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of a texture with those of another
@@ -393,9 +388,10 @@ CSFML_GRAPHICS_API unsigned int sfTexture_getNativeHandle(const sfTexture* textu
 /// \endcode
 ///
 /// \param texture Pointer to the texture to bind, can be null to use no texture
+/// \param type    Type of texture coordinates to use
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type);
+CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfCoordinateType type);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the maximum texture size allowed
@@ -404,6 +400,3 @@ CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfTextureCoordi
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API unsigned int sfTexture_getMaximumSize(void);
-
-
-#endif // SFML_TEXTURE_H

include/CSFML/Graphics/Transform.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TRANSFORM_H
+#pragma once
-#define SFML_TRANSFORM_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Rect.h>
-#include <SFML/Graphics/Types.h>
-#include <SFML/System/Vector2.h>
 
+#include <CSFML/Graphics/Rect.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -67,9 +66,8 @@ CSFML_GRAPHICS_API const sfTransform sfTransform_Identity;
 /// \return A new sfTransform object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTransform sfTransform_fromMatrix(float a00, float a01, float a02,
+CSFML_GRAPHICS_API sfTransform
-                                                      float a10, float a11, float a12,
+    sfTransform_fromMatrix(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22);
-                                                      float a20, float a21, float a22);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the 4x4 matrix of a transform
@@ -148,11 +146,10 @@ CSFML_GRAPHICS_API void sfTransform_combine(sfTransform* transform, const sfTran
 /// \brief Combine a transform with a translation
 ///
 /// \param transform Transform object
-/// \param x         Offset to apply on X axis
+/// \param offset    Offset to apply
-/// \param y         Offset to apply on Y axis
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_translate(sfTransform* transform, float x, float y);
+CSFML_GRAPHICS_API void sfTransform_translate(sfTransform* transform, sfVector2f offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a rotation
@@ -173,21 +170,19 @@ CSFML_GRAPHICS_API void sfTransform_rotate(sfTransform* transform, float angle);
 ///
 /// \param transform Transform object
 /// \param angle     Rotation angle, in degrees
-/// \param centerX   X coordinate of the center of rotation
+/// \param center    Coordinates of the center of rotation
-/// \param centerY   Y coordinate of the center of rotation
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_rotateWithCenter(sfTransform* transform, float angle, float centerX, float centerY);
+CSFML_GRAPHICS_API void sfTransform_rotateWithCenter(sfTransform* transform, float angle, sfVector2f center);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a scaling
 ///
 /// \param transform Transform object
-/// \param scaleX    Scaling factor on the X axis
+/// \param scale     Scaling factor
-/// \param scaleY    Scaling factor on the Y axis
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, float scaleX, float scaleY);
+CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, sfVector2f scale);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a scaling
@@ -198,13 +193,11 @@ CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, float scaleX,
 /// [translate(-center), scale(factors), translate(center)]
 ///
 /// \param transform Transform object
-/// \param scaleX    Scaling factor on X axis
+/// \param scale     Scaling factor
-/// \param scaleY    Scaling factor on Y axis
+/// \param center    Coordinates of the center of scaling
-/// \param centerX   X coordinate of the center of scaling
-/// \param centerY   Y coordinate of the center of scaling
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, float scaleX, float scaleY, float centerX, float centerY);
+CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, sfVector2f scale, sfVector2f center);
 
 ////////////////////////////////////////////////////////////
 /// \brief Compare two transforms for equality
@@ -218,6 +211,4 @@ CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, floa
 /// \return true if the transforms are equal, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTransform_equal(sfTransform* left, sfTransform* right);
+CSFML_GRAPHICS_API bool sfTransform_equal(sfTransform* left, sfTransform* right);
-
-#endif // SFML_TRANSFORM_H

include/CSFML/Graphics/Transformable.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TRANSFORMABLE_H
+#pragma once
-#define SFML_TRANSFORMABLE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Types.h>
+
-#include <SFML/Graphics/Transform.h>
+#include <CSFML/Graphics/Transform.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -58,7 +58,7 @@ CSFML_GRAPHICS_API sfTransformable* sfTransformable_copy(const sfTransformable*
 /// \param transformable Transformable to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransformable_destroy(sfTransformable* transformable);
+CSFML_GRAPHICS_API void sfTransformable_destroy(const sfTransformable* transformable);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a transformable
@@ -212,6 +212,3 @@ CSFML_GRAPHICS_API sfTransform sfTransformable_getTransform(const sfTransformabl
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTransform sfTransformable_getInverseTransform(const sfTransformable* transformable);
-
-
-#endif // SFML_TRANSFORMABLE_H

include/CSFML/Graphics/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,26 +22,22 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_GRAPHICS_TYPES_H
+#pragma once
-#define SFML_GRAPHICS_TYPES_H
 
 
-typedef struct sfCircleShape sfCircleShape;
+typedef struct sfCircleShape    sfCircleShape;
-typedef struct sfConvexShape sfConvexShape;
+typedef struct sfConvexShape    sfConvexShape;
-typedef struct sfFont sfFont;
+typedef struct sfFont           sfFont;
-typedef struct sfImage sfImage;
+typedef struct sfImage          sfImage;
-typedef struct sfShader sfShader;
+typedef struct sfShader         sfShader;
 typedef struct sfRectangleShape sfRectangleShape;
-typedef struct sfRenderTexture sfRenderTexture;
+typedef struct sfRenderTexture  sfRenderTexture;
-typedef struct sfRenderWindow sfRenderWindow;
+typedef struct sfRenderWindow   sfRenderWindow;
-typedef struct sfShape sfShape;
+typedef struct sfShape          sfShape;
-typedef struct sfSprite sfSprite;
+typedef struct sfSprite         sfSprite;
-typedef struct sfText sfText;
+typedef struct sfText           sfText;
-typedef struct sfTexture sfTexture;
+typedef struct sfTexture        sfTexture;
-typedef struct sfTransformable sfTransformable;
+typedef struct sfTransformable  sfTransformable;
-typedef struct sfVertexArray sfVertexArray;
+typedef struct sfVertexArray    sfVertexArray;
-typedef struct sfVertexBuffer sfVertexBuffer;
+typedef struct sfVertexBuffer   sfVertexBuffer;
-typedef struct sfView sfView;
+typedef struct sfView           sfView;
-
-
-#endif // SFML_GRAPHICS_TYPES_H

include/CSFML/Graphics/Vertex.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VERTEX_H
+#pragma once
-#define SFML_VERTEX_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Color.h>
+
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Color.h>
+#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -42,6 +42,3 @@ typedef struct
     sfColor    color;     ///< Color of the vertex
     sfVector2f texCoords; ///< Coordinates of the texture's pixel to map to the vertex
 } sfVertex;
-
-
-#endif // SFML_VERTEX_H

include/CSFML/Graphics/VertexArray.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VERTEXARRAY_H
+#pragma once
-#define SFML_VERTEXARRAY_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/PrimitiveType.h>
+
-#include <SFML/Graphics/Rect.h>
+#include <CSFML/Graphics/PrimitiveType.h>
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/Graphics/Vertex.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/Graphics/Vertex.h>
+
 #include <stddef.h>
 
 
@@ -60,7 +61,7 @@ CSFML_GRAPHICS_API sfVertexArray* sfVertexArray_copy(const sfVertexArray* vertex
 /// \param vertexArray Vertex array to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfVertexArray_destroy(sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API void sfVertexArray_destroy(const sfVertexArray* vertexArray);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the vertex count of a vertex array
@@ -109,7 +110,7 @@ CSFML_GRAPHICS_API void sfVertexArray_clear(sfVertexArray* vertexArray);
 /// If \a vertexCount is less than the current size, existing vertices
 /// are removed from the array.
 ///
-/// \param vertexArray Vertex array objet
+/// \param vertexArray Vertex array object
 /// \param vertexCount New size of the array (number of vertices)
 ///
 ////////////////////////////////////////////////////////////
@@ -118,7 +119,7 @@ CSFML_GRAPHICS_API void sfVertexArray_resize(sfVertexArray* vertexArray, size_t
 ////////////////////////////////////////////////////////////
 /// \brief Add a vertex to a vertex array array
 ///
-/// \param vertexArray Vertex array objet
+/// \param vertexArray Vertex array object
 /// \param vertex      Vertex to add
 ///
 ////////////////////////////////////////////////////////////
@@ -135,7 +136,7 @@ CSFML_GRAPHICS_API void sfVertexArray_append(sfVertexArray* vertexArray, sfVerte
 /// \li As quads
 /// The default primitive type is sfPoints.
 ///
-/// \param vertexArray Vertex array objet
+/// \param vertexArray Vertex array object
 /// \param type        Type of primitive
 ///
 ////////////////////////////////////////////////////////////
@@ -144,12 +145,12 @@ CSFML_GRAPHICS_API void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArra
 ////////////////////////////////////////////////////////////
 /// \brief Get the type of primitives drawn by a vertex array
 ///
-/// \param vertexArray Vertex array objet
+/// \param vertexArray Vertex array object
 ///
 /// \return Primitive type
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(const sfVertexArray* vertexArray);
 
 ////////////////////////////////////////////////////////////
 /// \brief Compute the bounding rectangle of a vertex array
@@ -157,12 +158,9 @@ CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray*
 /// This function returns the axis-aligned rectangle that
 /// contains all the vertices of the array.
 ///
-/// \param vertexArray Vertex array objet
+/// \param vertexArray Vertex array object
 ///
 /// \return Bounding rectangle of the vertex array
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(const sfVertexArray* vertexArray);
-
-
-#endif // SFML_VERTEXARRAY_H

include/CSFML/Graphics/VertexBuffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VERTEXBUFFER_H
+#pragma once
-#define SFML_VERTEXBUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/PrimitiveType.h>
+
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/PrimitiveType.h>
-#include <SFML/Graphics/Vertex.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/Graphics/Vertex.h>
+
 #include <stddef.h>
 
 
@@ -57,7 +58,7 @@ typedef enum
 /// \brief Create a new vertex buffer with a specific
 /// sfPrimitiveType and usage specifier.
 ///
-/// Creates the vertex buffer, allocating enough graphcis
+/// Creates the vertex buffer, allocating enough graphics
 /// memory to hold \p vertexCount vertices, and sets its
 /// primitive type to \p type and usage to \p usage.
 ///
@@ -68,7 +69,7 @@ typedef enum
 /// \return A new sfVertexBuffer object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
+CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing vertex buffer
@@ -86,7 +87,7 @@ CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_copy(const sfVertexBuffer* ver
 /// \param vertexBuffer Vertex buffer to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfVertexBuffer_destroy(sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API void sfVertexBuffer_destroy(const sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the vertex count
@@ -96,7 +97,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_destroy(sfVertexBuffer* vertexBuffer);
 /// \return Number of vertices in the vertex buffer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API size_t sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a part of the buffer from an array of vertices
@@ -122,14 +123,18 @@ CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuff
 /// array, passing invalid arguments will lead to undefined
 /// behavior.
 ///
-/// \param vertices    Array of vertices to copy to the buffer
+/// \param vertexBuffer Vertex buffer object
-/// \param vertexCount Number of vertices to copy
+/// \param vertices     Array of vertices to copy to the buffer
-/// \param offset      Offset in the buffer to copy to
+/// \param vertexCount  Number of vertices to copy
+/// \param offset       Offset in the buffer to copy to
 ///
-/// \return sfTrue if the update was successful
+/// \return true if the update was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset);
+CSFML_GRAPHICS_API bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer,
+                                              const sfVertex* vertices,
+                                              unsigned int    vertexCount,
+                                              unsigned int    offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy the contents of another buffer into this buffer
@@ -137,10 +142,10 @@ CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, co
 /// \param vertexBuffer Vertex buffer object
 /// \param other Vertex buffer whose contents to copy into first vertex buffer
 ///
-/// \return sfTrue if the copy was successful
+/// \return true if the copy was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
+CSFML_GRAPHICS_API bool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of this vertex buffer with those of another
@@ -161,7 +166,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_swap(sfVertexBuffer* left, sfVertexBuffer
 /// \return OpenGL handle of the vertex buffer or 0 if not yet created
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(const sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the type of primitives to draw
@@ -169,7 +174,7 @@ CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* v
 /// This function defines how the vertices must be interpreted
 /// when it's time to draw them.
 ///
-/// The default primitive type is sf::Points.
+/// The default primitive type is sfPoints.
 ///
 /// \param vertexBuffer Vertex buffer object
 /// \param type Type of primitive
@@ -243,12 +248,9 @@ CSFML_GRAPHICS_API void sfVertexBuffer_bind(const sfVertexBuffer* vertexBuffer);
 ///
 /// This function should always be called before using
 /// the vertex buffer features. If it returns false, then
-/// any attempt to use sf::VertexBuffer will fail.
+/// any attempt to use sfVertexBuffer will fail.
 ///
 /// \return True if vertex buffers are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_isAvailable(void);
+CSFML_GRAPHICS_API bool sfVertexBuffer_isAvailable(void);
-
-
-#endif // SFML_VERTEXBUFFER_H

include/CSFML/Graphics/View.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VIEW_H
+#pragma once
-#define SFML_VIEW_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Export.h>
+#include <CSFML/Graphics/Export.h>
-#include <SFML/Graphics/Rect.h>
+
-#include <SFML/Graphics/Types.h>
+#include <CSFML/Graphics/Rect.h>
-#include <SFML/System/Vector2.h>
+#include <CSFML/Graphics/Types.h>
+#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -70,7 +70,7 @@ CSFML_GRAPHICS_API sfView* sfView_copy(const sfView* view);
 /// \param view View to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfView_destroy(sfView* view);
+CSFML_GRAPHICS_API void sfView_destroy(const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the center of a view
@@ -118,15 +118,27 @@ CSFML_GRAPHICS_API void sfView_setRotation(sfView* view, float angle);
 CSFML_GRAPHICS_API void sfView_setViewport(sfView* view, sfFloatRect viewport);
 
 ////////////////////////////////////////////////////////////
-/// \brief Reset a view to the given rectangle
+/// \brief Set the target scissor rectangle
 ///
-/// Note that this function resets the rotation angle to 0.
+/// The scissor rectangle, expressed as a factor (between 0 and 1) of
+/// the RenderTarget, specifies the region of the RenderTarget whose
+/// pixels are able to be modified by draw or clear operations.
+/// Any pixels which lie outside of the scissor rectangle will
+/// not be modified by draw or clear operations.
+/// For example, a scissor rectangle which only allows modifications
+/// to the right side of the target would be defined
+/// with `sfView_setScissor(view, (sfFloatRect){{0.5f, 0.f}, {0.5f, 1.f}})`.
+/// By default, a view has a scissor rectangle which allows
+/// modifications to the entire target. This is equivalent to
+/// disabling the scissor test entirely. Passing the default
+/// scissor rectangle to this function will also disable
+/// scissor testing.
 ///
-/// \param view      View object
+/// \param view    View object
-/// \param rectangle Rectangle defining the zone to display
+/// \param scissor New scissor rectangle
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfView_reset(sfView* view, sfFloatRect rectangle);
+CSFML_GRAPHICS_API void sfView_setScissor(sfView* view, sfFloatRect scissor);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the center of a view
@@ -169,7 +181,17 @@ CSFML_GRAPHICS_API float sfView_getRotation(const sfView* view);
 CSFML_GRAPHICS_API sfFloatRect sfView_getViewport(const sfView* view);
 
 ////////////////////////////////////////////////////////////
-/// \brief Move a view relatively to its current position
+/// \brief Get the scissor rectangle of the view
+///
+/// \param view View object
+///
+/// \return Scissor rectangle, expressed as a factor of the target size
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfFloatRect sfView_getScissor(const sfView* view);
+
+////////////////////////////////////////////////////////////
+/// \brief Move a view relative to its current position
 ///
 /// \param view   View object
 /// \param offset Offset
@@ -178,7 +200,7 @@ CSFML_GRAPHICS_API sfFloatRect sfView_getViewport(const sfView* view);
 CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset);
 
 ////////////////////////////////////////////////////////////
-/// \brief Rotate a view relatively to its current orientation
+/// \brief Rotate a view relative to its current orientation
 ///
 /// \param view  View object
 /// \param angle Angle to rotate, in degrees
@@ -187,7 +209,7 @@ CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset);
 CSFML_GRAPHICS_API void sfView_rotate(sfView* view, float angle);
 
 ////////////////////////////////////////////////////////////
-/// \brief Resize a view rectangle relatively to its current size
+/// \brief Resize a view rectangle relative to its current size
 ///
 /// Resizing the view simulates a zoom, as the zone displayed on
 /// screen grows or shrinks.
@@ -201,6 +223,3 @@ CSFML_GRAPHICS_API void sfView_rotate(sfView* view, float angle);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfView_zoom(sfView* view, float factor);
-
-
-#endif // SFML_VIEW_H

include/CSFML/Network.h

@@ -0,0 +1,40 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <CSFML/Network/Ftp.h>
+#include <CSFML/Network/Http.h>
+#include <CSFML/Network/IpAddress.h>
+#include <CSFML/Network/Packet.h>
+#include <CSFML/Network/SocketSelector.h>
+#include <CSFML/Network/SocketStatus.h>
+#include <CSFML/Network/TcpListener.h>
+#include <CSFML/Network/TcpSocket.h>
+#include <CSFML/Network/UdpSocket.h>
+#include <CSFML/System.h>

include/CSFML/Network/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_NETWORK_EXPORT_H
+#pragma once
-#define SFML_NETWORK_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,13 +35,10 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_NETWORK_EXPORTS)
 
-    #define CSFML_NETWORK_API CSFML_API_EXPORT
+#define CSFML_NETWORK_API CSFML_API_EXPORT
 
 #else
 
-    #define CSFML_NETWORK_API CSFML_API_IMPORT
+#define CSFML_NETWORK_API CSFML_API_IMPORT
 
 #endif
-
-
-#endif // SFML_NETWORK_EXPORT_H

include/CSFML/Network/Ftp.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_FTP_H
+#pragma once
-#define SFML_FTP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/IpAddress.h>
+
-#include <SFML/Network/Types.h>
+#include <CSFML/Network/IpAddress.h>
+#include <CSFML/Network/Types.h>
+
 #include <stddef.h>
 
 
@@ -40,7 +41,7 @@
 ////////////////////////////////////////////////////////////
 typedef enum
 {
-    sfFtpBinary, ///< Binary mode (file is transfered as a sequence of bytes)
+    sfFtpBinary, ///< Binary mode (file is transferred as a sequence of bytes)
     sfFtpAscii,  ///< Text mode using ASCII encoding
     sfFtpEbcdic  ///< Text mode using EBCDIC encoding
 } sfFtpTransferMode;
@@ -60,13 +61,13 @@ typedef enum
     sfFtpOpeningDataConnection       = 150, ///< File status ok, about to open data connection
 
     // 2xx: the requested action has been successfully completed
-    sfFtpOk                    = 200, ///< Command ok
+    sfFtpOk               = 200, ///< Command ok
-    sfFtpPointlessCommand      = 202, ///< Command not implemented
+    sfFtpPointlessCommand = 202, ///< Command not implemented
-    sfFtpSystemStatus          = 211, ///< System status, or system help reply
+    sfFtpSystemStatus     = 211, ///< System status, or system help reply
-    sfFtpDirectoryStatus       = 212, ///< Directory status
+    sfFtpDirectoryStatus  = 212, ///< Directory status
-    sfFtpFileStatus            = 213, ///< File status
+    sfFtpFileStatus       = 213, ///< File status
-    sfFtpHelpMessage           = 214, ///< Help message
+    sfFtpHelpMessage      = 214, ///< Help message
-    sfFtpSystemType            = 215, ///< NAME system type, where NAME is an official system name from the list in the Assigned Numbers document
+    sfFtpSystemType = 215, ///< NAME system type, where NAME is an official system name from the list in the Assigned Numbers document
     sfFtpServiceReady          = 220, ///< Service ready for new user
     sfFtpClosingConnection     = 221, ///< Service closing control connection
     sfFtpDataConnectionOpened  = 225, ///< Data connection open, no transfer in progress
@@ -89,7 +90,7 @@ typedef enum
     sfFtpTransferAborted           = 426, ///< Connection closed, transfer aborted
     sfFtpFileActionAborted         = 450, ///< Requested file action not taken
     sfFtpLocalError                = 451, ///< Requested action aborted, local error in processing
-    sfFtpInsufficientStorageSpace  = 452, ///< Requested action not taken; insufficient storage space in system, file unavailable
+    sfFtpInsufficientStorageSpace = 452, ///< Requested action not taken; insufficient storage space in system, file unavailable
 
     // 5xx: the command was not accepted and
     // the requested action did not take place
@@ -119,7 +120,7 @@ typedef enum
 /// \param ftpListingResponse Ftp listing response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpListingResponse);
+CSFML_NETWORK_API void sfFtpListingResponse_destroy(const sfFtpListingResponse* ftpListingResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP listing response status code means a success
@@ -129,10 +130,10 @@ CSFML_NETWORK_API void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpLis
 ///
 /// \param ftpListingResponse Ftp listing response
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
+CSFML_NETWORK_API bool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP listing response
@@ -168,7 +169,7 @@ CSFML_NETWORK_API size_t sfFtpListingResponse_getCount(const sfFtpListingRespons
 /// \brief Return a directory/file name contained in a FTP listing response
 ///
 /// \param ftpListingResponse Ftp listing response
-/// \param index              Index of the name to get (in range [0 .. getCount])
+/// \param index              Index of the name to get, in range [0 .. getCount() - 1]
 ///
 /// \return The requested name
 ///
@@ -181,7 +182,7 @@ CSFML_NETWORK_API const char* sfFtpListingResponse_getName(const sfFtpListingRes
 /// \param ftpDirectoryResponse Ftp directory response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ftpDirectoryResponse);
+CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(const sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP directory response status code means a success
@@ -191,10 +192,10 @@ CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ft
 ///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
+CSFML_NETWORK_API bool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP directory response
@@ -219,21 +220,38 @@ CSFML_NETWORK_API const char* sfFtpDirectoryResponse_getMessage(const sfFtpDirec
 ////////////////////////////////////////////////////////////
 /// \brief Get the directory returned in a FTP directory response
 ///
+/// The returned const char* owns the string and must be freed to
+/// avoid memory leaks.
+///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return Directory name
+/// \return Directory name or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API const char* sfFtpDirectoryResponse_getDirectory(const sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 
+////////////////////////////////////////////////////////////
+/// \brief Get the directory returned in a FTP directory response
+///
+/// The returned const sfChar32* owns the string and must be freed to
+/// avoid memory leaks.
+///
+/// \param ftpDirectoryResponse Ftp directory response
+///
+/// \return Directory name or NULL if it failed
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API const sfChar32* sfFtpDirectoryResponse_getDirectoryUnicode(const sfFtpDirectoryResponse* ftpDirectoryResponse);
+
+
 ////////////////////////////////////////////////////////////
 /// \brief Destroy a FTP response
 ///
 /// \param ftpResponse Ftp response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtpResponse_destroy(sfFtpResponse* ftpResponse);
+CSFML_NETWORK_API void sfFtpResponse_destroy(const sfFtpResponse* ftpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP response status code means a success
@@ -243,10 +261,10 @@ CSFML_NETWORK_API void sfFtpResponse_destroy(sfFtpResponse* ftpResponse);
 ///
 /// \param ftpResponse Ftp response object
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
+CSFML_NETWORK_API bool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP response
@@ -282,7 +300,7 @@ CSFML_NETWORK_API sfFtp* sfFtp_create(void);
 /// \param ftp Ftp object to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtp_destroy(sfFtp* ftp);
+CSFML_NETWORK_API void sfFtp_destroy(const sfFtp* ftp);
 
 ////////////////////////////////////////////////////////////
 /// \brief Connect to the specified FTP server
@@ -500,12 +518,17 @@ CSFML_NETWORK_API sfFtpResponse* sfFtp_download(sfFtp* ftp, const char* remoteFi
 /// \param localFile  Path of the local file to upload
 /// \param remotePath Where to put to file on the server
 /// \param mode       Transfer mode
-/// \param append     Pass sfTrue to append to or sfFalse to overwrite the remote file if it already exists
+/// \param append     Pass true to append to or false to overwrite the remote file if it already exists
 ///
 /// \return Server response to the request
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, sfBool append);
+CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(
+    sfFtp*            ftp,
+    const char*       localFile,
+    const char*       remotePath,
+    sfFtpTransferMode mode,
+    bool              append);
 
 ////////////////////////////////////////////////////////////
 /// \brief Send a command to the FTP server
@@ -526,6 +549,3 @@ CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile,
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfFtpResponse* sfFtp_sendCommand(sfFtp* ftp, const char* command, const char* parameter);
-
-
-#endif // SFML_FTP_H

include/CSFML/Network/Http.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_HTTP_H
+#pragma once
-#define SFML_HTTP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/Types.h>
+
-#include <SFML/System/Time.h>
+#include <CSFML/Network/Types.h>
+#include <CSFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -54,18 +54,18 @@ typedef enum
 typedef enum
 {
     // 2xx: success
-    sfHttpOk             = 200, ///< Most common code returned when operation was successful
+    sfHttpOk        = 200, ///< Most common code returned when operation was successful
-    sfHttpCreated        = 201, ///< The resource has successfully been created
+    sfHttpCreated   = 201, ///< The resource has successfully been created
-    sfHttpAccepted       = 202, ///< The request has been accepted, but will be processed later by the server
+    sfHttpAccepted  = 202, ///< The request has been accepted, but will be processed later by the server
-    sfHttpNoContent      = 204, ///< Sent when the server didn't send any data in return
+    sfHttpNoContent = 204, ///< Sent when the server didn't send any data in return
-    sfHttpResetContent   = 205, ///< The server informs the client that it should clear the view (form) that caused the request to be sent
+    sfHttpResetContent = 205, ///< The server informs the client that it should clear the view (form) that caused the request to be sent
     sfHttpPartialContent = 206, ///< The server has sent a part of the resource, as a response to a partial GET request
 
     // 3xx: redirection
     sfHttpMultipleChoices  = 300, ///< The requested page can be accessed from several locations
     sfHttpMovedPermanently = 301, ///< The requested page has permanently moved to a new location
     sfHttpMovedTemporarily = 302, ///< The requested page has temporarily moved to a new location
-    sfHttpNotModified      = 304, ///< For conditional requests, means the requested page hasn't changed and doesn't need to be refreshed
+    sfHttpNotModified = 304, ///< For conditional requests, means the requested page hasn't changed and doesn't need to be refreshed
 
     // 4xx: client error
     sfHttpBadRequest          = 400, ///< The server couldn't understand the request (syntax error)
@@ -102,7 +102,7 @@ CSFML_NETWORK_API sfHttpRequest* sfHttpRequest_create(void);
 /// \param httpRequest HTTP request to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfHttpRequest_destroy(sfHttpRequest* httpRequest);
+CSFML_NETWORK_API void sfHttpRequest_destroy(const sfHttpRequest* httpRequest);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the value of a header field of a HTTP request
@@ -124,7 +124,7 @@ CSFML_NETWORK_API void sfHttpRequest_setField(sfHttpRequest* httpRequest, const
 /// \brief Set a HTTP request method
 ///
 /// See the sfHttpMethod enumeration for a complete list of all
-/// the availale methods.
+/// the available methods.
 /// The method is sfHttpGet by default.
 ///
 /// \param httpRequest HTTP request
@@ -177,7 +177,7 @@ CSFML_NETWORK_API void sfHttpRequest_setBody(sfHttpRequest* httpRequest, const c
 /// \param httpResponse HTTP response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfHttpResponse_destroy(sfHttpResponse* httpResponse);
+CSFML_NETWORK_API void sfHttpResponse_destroy(const sfHttpResponse* httpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the value of a field of a HTTP response
@@ -195,7 +195,7 @@ CSFML_NETWORK_API void sfHttpResponse_destroy(sfHttpResponse* httpResponse);
 CSFML_NETWORK_API const char* sfHttpResponse_getField(const sfHttpResponse* httpResponse, const char* field);
 
 ////////////////////////////////////////////////////////////
-/// \brief Get the status code of a HTTP reponse
+/// \brief Get the status code of a HTTP response
 ///
 /// The status code should be the first thing to be checked
 /// after receiving a response, it defines whether it is a
@@ -259,7 +259,7 @@ CSFML_NETWORK_API sfHttp* sfHttp_create(void);
 /// \param http Http object to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfHttp_destroy(sfHttp* http);
+CSFML_NETWORK_API void sfHttp_destroy(const sfHttp* http);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the target host of a HTTP object
@@ -288,7 +288,7 @@ CSFML_NETWORK_API void sfHttp_setHost(sfHttp* http, const char* host, unsigned s
 /// Warning: this function waits for the server's response and may
 /// not return instantly; use a thread if you don't want to block your
 /// application, or use a timeout to limit the time to wait. A value
-/// of 0 means that the client will use the system defaut timeout
+/// of 0 means that the client will use the system default timeout
 /// (which is usually pretty long).
 ///
 /// \param http    Http object
@@ -299,6 +299,3 @@ CSFML_NETWORK_API void sfHttp_setHost(sfHttp* http, const char* host, unsigned s
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfHttpResponse* sfHttp_sendRequest(sfHttp* http, const sfHttpRequest* request, sfTime timeout);
-
-
-#endif // SFML_HTTP_H

include/CSFML/Network/IpAddress.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_IPADDRESS_H
+#pragma once
-#define SFML_IPADDRESS_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/System/Time.h>
+
+#include <CSFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -95,7 +95,7 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_fromString(const char* address);
 /// \return Resulting address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct an address from a 32-bits integer
@@ -103,14 +103,14 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1
 /// This function uses the internal representation of
 /// the address directly. It should be used for optimization
 /// purposes, and only if you got that representation from
-/// sfIpAddress_ToInteger.
+/// sfIpAddress_toInteger.
 ///
 /// \param address 4 bytes of the address packed into a 32-bits integer
 ///
 /// \return Resulting address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfIpAddress sfIpAddress_fromInteger(sfUint32 address);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromInteger(uint32_t address);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a string representation of an address
@@ -132,14 +132,14 @@ CSFML_NETWORK_API void sfIpAddress_toString(sfIpAddress address, char* string);
 /// address, and should be used for optimization purposes only
 /// (like sending the address through a socket).
 /// The integer produced by this function can then be converted
-/// back to a sfIpAddress with sfIpAddress_FromInteger.
+/// back to a sfIpAddress with sfIpAddress_fromInteger.
 ///
 /// \param address Address object
 ///
 /// \return 32-bits unsigned integer representation of the address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfUint32 sfIpAddress_toInteger(sfIpAddress address);
+CSFML_NETWORK_API uint32_t sfIpAddress_toInteger(sfIpAddress address);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the computer's local address
@@ -176,6 +176,3 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_getLocalAddress(void);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfIpAddress sfIpAddress_getPublicAddress(sfTime timeout);
-
-
-#endif // SFML_IPADDRESS_H

include/CSFML/Network/Packet.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_PACKET_H
+#pragma once
-#define SFML_PACKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/Types.h>
+
+#include <CSFML/Network/Types.h>
+
 #include <stddef.h>
 
 
@@ -57,7 +58,7 @@ CSFML_NETWORK_API sfPacket* sfPacket_copy(const sfPacket* packet);
 /// \param packet Packet to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfPacket_destroy(sfPacket* packet);
+CSFML_NETWORK_API void sfPacket_destroy(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Append data to the end of a packet
@@ -74,6 +75,8 @@ CSFML_NETWORK_API void sfPacket_append(sfPacket* packet, const void* data, size_
 ///
 /// The next read operation will read data from this position
 ///
+/// \param packet Packet object
+///
 /// \return The byte offset of the current read position
 ///
 /// \see append
@@ -128,15 +131,15 @@ CSFML_NETWORK_API size_t sfPacket_getDataSize(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return sfTrue if all data was read, sfFalse otherwise
+/// \return true if all data was read, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfPacket_endOfPacket(const sfPacket* packet);
+CSFML_NETWORK_API bool sfPacket_endOfPacket(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test the validity of a packet, for reading
 ///
-/// This function allows to test the packet, to check if
+/// This function allows for testing the packet, to check if
 /// a reading operation was successful.
 ///
 /// A packet will be in an invalid state if it has no more
@@ -144,10 +147,10 @@ CSFML_NETWORK_API sfBool sfPacket_endOfPacket(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return sfTrue if last data extraction from packet was successful
+/// \return true if last data extraction from packet was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfPacket_canRead(const sfPacket* packet);
+CSFML_NETWORK_API bool sfPacket_canRead(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Functions to extract data from a packet
@@ -155,13 +158,15 @@ CSFML_NETWORK_API sfBool sfPacket_canRead(const sfPacket* packet);
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool   sfPacket_readBool(sfPacket* packet);
+CSFML_NETWORK_API bool     sfPacket_readBool(sfPacket* packet);
-CSFML_NETWORK_API sfInt8   sfPacket_readInt8(sfPacket* packet);
+CSFML_NETWORK_API int8_t   sfPacket_readInt8(sfPacket* packet);
-CSFML_NETWORK_API sfUint8  sfPacket_readUint8(sfPacket* packet);
+CSFML_NETWORK_API uint8_t  sfPacket_readUint8(sfPacket* packet);
-CSFML_NETWORK_API sfInt16  sfPacket_readInt16(sfPacket* packet);
+CSFML_NETWORK_API int16_t  sfPacket_readInt16(sfPacket* packet);
-CSFML_NETWORK_API sfUint16 sfPacket_readUint16(sfPacket* packet);
+CSFML_NETWORK_API uint16_t sfPacket_readUint16(sfPacket* packet);
-CSFML_NETWORK_API sfInt32  sfPacket_readInt32(sfPacket* packet);
+CSFML_NETWORK_API int32_t  sfPacket_readInt32(sfPacket* packet);
-CSFML_NETWORK_API sfUint32 sfPacket_readUint32(sfPacket* packet);
+CSFML_NETWORK_API uint32_t sfPacket_readUint32(sfPacket* packet);
+CSFML_NETWORK_API int64_t  sfPacket_readInt64(sfPacket* packet);
+CSFML_NETWORK_API uint64_t sfPacket_readUint64(sfPacket* packet);
 CSFML_NETWORK_API float    sfPacket_readFloat(sfPacket* packet);
 CSFML_NETWORK_API double   sfPacket_readDouble(sfPacket* packet);
 CSFML_NETWORK_API void     sfPacket_readString(sfPacket* packet, char* string);
@@ -173,17 +178,16 @@ CSFML_NETWORK_API void     sfPacket_readWideString(sfPacket* packet, wchar_t* st
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, sfBool);
+CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, bool);
-CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, sfInt8);
+CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, int8_t);
-CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, sfUint8);
+CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, uint8_t);
-CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, sfInt16);
+CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, int16_t);
-CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, sfUint16);
+CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, uint16_t);
-CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, sfInt32);
+CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, int32_t);
-CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, sfUint32);
+CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, uint32_t);
+CSFML_NETWORK_API void sfPacket_writeInt64(sfPacket* packet, int64_t);
+CSFML_NETWORK_API void sfPacket_writeUint64(sfPacket* packet, uint64_t);
 CSFML_NETWORK_API void sfPacket_writeFloat(sfPacket* packet, float);
 CSFML_NETWORK_API void sfPacket_writeDouble(sfPacket* packet, double);
 CSFML_NETWORK_API void sfPacket_writeString(sfPacket* packet, const char* string);
 CSFML_NETWORK_API void sfPacket_writeWideString(sfPacket* packet, const wchar_t* string);
-
-
-#endif // SFML_PACKET_H

include/CSFML/Network/SocketSelector.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOCKETSELECTOR_H
+#pragma once
-#define SFML_SOCKETSELECTOR_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/Types.h>
+
-#include <SFML/System/Time.h>
+#include <CSFML/Network/Types.h>
+#include <CSFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -57,7 +57,7 @@ CSFML_NETWORK_API sfSocketSelector* sfSocketSelector_copy(const sfSocketSelector
 /// \param selector Socket selector to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfSocketSelector_destroy(sfSocketSelector* selector);
+CSFML_NETWORK_API void sfSocketSelector_destroy(const sfSocketSelector* selector);
 
 ////////////////////////////////////////////////////////////
 /// \brief Add a new socket to a socket selector
@@ -81,7 +81,7 @@ CSFML_NETWORK_API void sfSocketSelector_addUdpSocket(sfSocketSelector* selector,
 /// removes the pointer that the selector has to it.
 ///
 /// \param selector Socket selector object
-/// \param socket   POointer to the socket to remove
+/// \param socket   Pointer to the socket to remove
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API void sfSocketSelector_removeTcpListener(sfSocketSelector* selector, sfTcpListener* socket);
@@ -107,15 +107,15 @@ CSFML_NETWORK_API void sfSocketSelector_clear(sfSocketSelector* selector);
 /// some data available to be received. To know which sockets are
 /// ready, use the sfSocketSelector_isXxxReady functions.
 /// If you use a timeout and no socket is ready before the timeout
-/// is over, the function returns sfFalse.
+/// is over, the function returns false.
 ///
 /// \param selector Socket selector object
 /// \param timeout  Maximum time to wait (use sfTimeZero for infinity)
 ///
-/// \return sfTrue if there are sockets ready, sfFalse otherwise
+/// \return true if there are sockets ready, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
+CSFML_NETWORK_API bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test a socket to know if it is ready to receive data
@@ -124,18 +124,15 @@ CSFML_NETWORK_API sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTim
 /// sfSocketSelector_wait, to know which sockets are ready to
 /// receive data. If a socket is ready, a call to Receive will
 /// never block because we know that there is data available to read.
-/// Note that if this function returns sfTrue for a sfTcpListener,
+/// Note that if this function returns true for a sfTcpListener,
 /// this means that it is ready to accept a new connection.
 ///
 /// \param selector Socket selector object
 /// \param socket   Socket to test
 ///
-/// \return sfTrue if the socket is ready to read, sfFalse otherwise
+/// \return true if the socket is ready to read, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
-CSFML_NETWORK_API sfBool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
-CSFML_NETWORK_API sfBool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
-
-
-#endif // SFML_SOCKETSELECTOR_H

include/CSFML/Network/SocketStatus.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,9 +22,7 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SOCKETSTATUS_H
+#pragma once
-#define SFML_SOCKETSTATUS_H
-
 
 ////////////////////////////////////////////////////////////
 /// \brief Define the status that can be returned by the socket functions
@@ -37,8 +35,4 @@ typedef enum
     sfSocketPartial,      ///< The socket sent a part of the data
     sfSocketDisconnected, ///< The TCP socket has been disconnected
     sfSocketError         ///< An unexpected error happened
-
 } sfSocketStatus;
-
-
-#endif // SFML_SOCKETSTATUS_H

include/CSFML/Network/TcpListener.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TCPLISTENER_H
+#pragma once
-#define SFML_TCPLISTENER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/SocketStatus.h>
+
-#include <SFML/Network/IpAddress.h>
+#include <CSFML/Network/IpAddress.h>
-#include <SFML/Network/Types.h>
+#include <CSFML/Network/SocketStatus.h>
+#include <CSFML/Network/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -48,7 +48,7 @@ CSFML_NETWORK_API sfTcpListener* sfTcpListener_create(void);
 /// \param listener TCP listener to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpListener_destroy(sfTcpListener* listener);
+CSFML_NETWORK_API void sfTcpListener_destroy(const sfTcpListener* listener);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a TCP listener
@@ -63,20 +63,20 @@ CSFML_NETWORK_API void sfTcpListener_destroy(sfTcpListener* listener);
 /// By default, all sockets are blocking.
 ///
 /// \param listener TCP listener object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, sfBool blocking);
+CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP listener is in blocking or non-blocking mode
 ///
 /// \param listener TCP listener object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfTcpListener_isBlocking(const sfTcpListener* listener);
+CSFML_NETWORK_API bool sfTcpListener_isBlocking(const sfTcpListener* listener);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP listener is bound locally
@@ -99,6 +99,10 @@ CSFML_NETWORK_API unsigned short sfTcpListener_getLocalPort(const sfTcpListener*
 /// If the socket was previously listening to another port,
 /// it will be stopped first and bound to the new port.
 ///
+/// When providing `sfTcpListener_anyPort()` as port, the listener
+/// will request an available port from the system.
+/// The chosen port can be retrieved by calling `sfTcpListener_getLocalPort()`.
+///
 /// If there is no specific address to listen to, pass sfIpAddress_Any
 ///
 /// \param listener TCP listener object
@@ -110,6 +114,17 @@ CSFML_NETWORK_API unsigned short sfTcpListener_getLocalPort(const sfTcpListener*
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, unsigned short port, sfIpAddress address);
 
+////////////////////////////////////////////////////////////
+/// \brief Stop listening and close the socket
+///
+/// This function gracefully stops the listener. If the
+/// socket is not listening, this function has no effect.
+///
+/// \param listener  TCP listener object
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API void sfTcpListener_close(sfTcpListener* listener);
+
 ////////////////////////////////////////////////////////////
 /// \brief Accept a new connection
 ///
@@ -128,5 +143,11 @@ CSFML_NETWORK_API sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, u
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** connected);
 
-
+////////////////////////////////////////////////////////////
-#endif // SFML_TCPLISTENER_H
+/// \brief Return the special value that tells the system
+///        to pick any available port
+///
+/// \return The value to use for any port
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API unsigned short sfTcpListener_anyPort(void);

include/CSFML/Network/TcpSocket.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TCPSOCKET_H
+#pragma once
-#define SFML_TCPSOCKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/IpAddress.h>
+
-#include <SFML/Network/SocketStatus.h>
+#include <CSFML/Network/IpAddress.h>
-#include <SFML/Network/Types.h>
+#include <CSFML/Network/SocketStatus.h>
-#include <SFML/System/Time.h>
+#include <CSFML/Network/Types.h>
+#include <CSFML/System/Time.h>
+
 #include <stddef.h>
 
 
@@ -50,7 +51,7 @@ CSFML_NETWORK_API sfTcpSocket* sfTcpSocket_create(void);
 /// \param socket TCP socket to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpSocket_destroy(sfTcpSocket* socket);
+CSFML_NETWORK_API void sfTcpSocket_destroy(const sfTcpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a TCP listener
@@ -65,20 +66,20 @@ CSFML_NETWORK_API void sfTcpSocket_destroy(sfTcpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   TCP socket object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, sfBool blocking);
+CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP socket is in blocking or non-blocking mode
 ///
 /// \param socket TCP socket object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
+CSFML_NETWORK_API bool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP socket is bound locally
@@ -95,7 +96,7 @@ CSFML_NETWORK_API unsigned short sfTcpSocket_getLocalPort(const sfTcpSocket* soc
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of the connected peer of a TCP socket
 ///
-/// It the socket is not connected, this function returns
+/// If the socket is not connected, this function returns
 /// sfIpAddress_None.
 ///
 /// \param socket TCP socket object
@@ -134,7 +135,8 @@ CSFML_NETWORK_API unsigned short sfTcpSocket_getRemotePort(const sfTcpSocket* so
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
+CSFML_NETWORK_API sfSocketStatus
+    sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Disconnect a TCP socket from its remote peer
@@ -151,7 +153,7 @@ CSFML_NETWORK_API void sfTcpSocket_disconnect(sfTcpSocket* socket);
 /// \brief Send raw data to the remote peer of a TCP socket
 ///
 /// To be able to handle partial sends over non-blocking
-/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, std::size_t, size_t*)
+/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, size_t, size_t*)
 /// overload instead.
 /// This function will fail if the socket is not connected.
 ///
@@ -227,6 +229,3 @@ CSFML_NETWORK_API sfSocketStatus sfTcpSocket_sendPacket(sfTcpSocket* socket, sfP
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpSocket_receivePacket(sfTcpSocket* socket, sfPacket* packet);
-
-
-#endif // SFML_TCPSOCKET_H

include/CSFML/Network/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,22 +22,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_NETWORK_TYPES_H
+#pragma once
-#define SFML_NETWORK_TYPES_H
 
 
 typedef struct sfFtpDirectoryResponse sfFtpDirectoryResponse;
-typedef struct sfFtpListingResponse sfFtpListingResponse;
+typedef struct sfFtpListingResponse   sfFtpListingResponse;
-typedef struct sfFtpResponse sfFtpResponse;
+typedef struct sfFtpResponse          sfFtpResponse;
-typedef struct sfFtp sfFtp;
+typedef struct sfFtp                  sfFtp;
-typedef struct sfHttpRequest sfHttpRequest;
+typedef struct sfHttpRequest          sfHttpRequest;
-typedef struct sfHttpResponse sfHttpResponse;
+typedef struct sfHttpResponse         sfHttpResponse;
-typedef struct sfHttp sfHttp;
+typedef struct sfHttp                 sfHttp;
-typedef struct sfPacket sfPacket;
+typedef struct sfPacket               sfPacket;
-typedef struct sfSocketSelector sfSocketSelector;
+typedef struct sfSocketSelector       sfSocketSelector;
-typedef struct sfTcpListener sfTcpListener;
+typedef struct sfTcpListener          sfTcpListener;
-typedef struct sfTcpSocket sfTcpSocket;
+typedef struct sfTcpSocket            sfTcpSocket;
-typedef struct sfUdpSocket sfUdpSocket;
+typedef struct sfUdpSocket            sfUdpSocket;
-
-
-#endif // SFML_NETWORK_TYPES_H

include/CSFML/Network/UdpSocket.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,16 +22,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_UDPSOCKET_H
+#pragma once
-#define SFML_UDPSOCKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Export.h>
+#include <CSFML/Network/Export.h>
-#include <SFML/Network/IpAddress.h>
+
-#include <SFML/Network/SocketStatus.h>
+#include <CSFML/Network/IpAddress.h>
-#include <SFML/Network/Types.h>
+#include <CSFML/Network/SocketStatus.h>
+#include <CSFML/Network/Types.h>
+
 #include <stddef.h>
 
 
@@ -49,7 +50,7 @@ CSFML_NETWORK_API sfUdpSocket* sfUdpSocket_create(void);
 /// \param socket UDP socket to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfUdpSocket_destroy(sfUdpSocket* socket);
+CSFML_NETWORK_API void sfUdpSocket_destroy(const sfUdpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a UDP listener
@@ -64,20 +65,20 @@ CSFML_NETWORK_API void sfUdpSocket_destroy(sfUdpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   UDP socket object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, sfBool blocking);
+CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a UDP socket is in blocking or non-blocking mode
 ///
 /// \param socket UDP socket object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
+CSFML_NETWORK_API bool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a UDP socket is bound locally
@@ -101,6 +102,10 @@ CSFML_NETWORK_API unsigned short sfUdpSocket_getLocalPort(const sfUdpSocket* soc
 /// system to automatically pick an available port, and then
 /// call sfUdpSocket_getLocalPort to retrieve the chosen port.
 ///
+/// When providing `sfUdpSocket_anyPort()` as port, the listener
+/// will request an available port from the system.
+/// The chosen port can be retrieved by calling `sfUdpSocket_getLocalPort()`.
+///
 /// If there is no specific address to listen to, pass sfIpAddress_Any
 ///
 /// \param socket  UDP socket object
@@ -140,7 +145,8 @@ CSFML_NETWORK_API void sfUdpSocket_unbind(sfUdpSocket* socket);
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort);
+CSFML_NETWORK_API sfSocketStatus
+    sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Receive raw data from a remote peer with a UDP socket
@@ -162,7 +168,13 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_send(sfUdpSocket* socket, const voi
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(sfUdpSocket* socket, void* data, size_t size, size_t* received, sfIpAddress* remoteAddress, unsigned short* remotePort);
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(
+    sfUdpSocket*    socket,
+    void*           data,
+    size_t          size,
+    size_t*         received,
+    sfIpAddress*    remoteAddress,
+    unsigned short* remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Send a formatted packet of data to a remote peer with a UDP socket
@@ -179,7 +191,8 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(sfUdpSocket* socket, void*
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort);
+CSFML_NETWORK_API sfSocketStatus
+    sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Receive a formatted packet of data from a remote peer with a UDP socket
@@ -187,6 +200,7 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfP
 /// In blocking mode, this function will wait until the whole packet
 /// has been received.
 ///
+/// \param socket        UDP socket object
 /// \param packet        Packet to fill with the received data
 /// \param remoteAddress Address of the peer that sent the data
 /// \param remotePort    Port of the peer that sent the data
@@ -194,7 +208,8 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfP
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
+CSFML_NETWORK_API sfSocketStatus
+    sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the maximum number of bytes that can be
@@ -205,5 +220,11 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket,
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API unsigned int sfUdpSocket_maxDatagramSize(void);
 
-
+////////////////////////////////////////////////////////////
-#endif // SFML_UDPSOCKET_H
+/// \brief Return the special value that tells the system
+///        to pick any available port
+///
+/// \return The value to use for any port
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API unsigned short sfUdpSocket_anyPort(void);

include/CSFML/OpenGL.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_OPENGL_H
+#pragma once
-#define SFML_OPENGL_H
-
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -38,21 +36,18 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_SYSTEM_WINDOWS)
 
-    #include <windows.h>
+#include <GL/gl.h>
-    #include <GL/gl.h>
+#include <GL/glu.h>
-    #include <GL/glu.h>
+#include <windows.h>
 
 #elif defined(CSFML_SYSTEM_LINUX) || defined(CSFML_SYSTEM_FREEBSD)
 
-    #include <GL/gl.h>
+#include <GL/gl.h>
-    #include <GL/glu.h>
+#include <GL/glu.h>
 
 #elif defined(CSFML_SYSTEM_MACOS)
 
-    #include <OpenGL/gl.h>
+#include <OpenGL/gl.h>
-    #include <OpenGL/glu.h>
+#include <OpenGL/glu.h>
 
 #endif
-
-
-#endif // SFML_OPENGL_H

include/CSFML/System.h

@@ -0,0 +1,39 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <CSFML/Config.h>
+
+#include <CSFML/System/Buffer.h>
+#include <CSFML/System/Clock.h>
+#include <CSFML/System/InputStream.h>
+#include <CSFML/System/Sleep.h>
+#include <CSFML/System/Time.h>
+#include <CSFML/System/Vector2.h>
+#include <CSFML/System/Vector3.h>

include/CSFML/System/Alloc.h

@@ -0,0 +1,45 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <CSFML/System/Export.h>
+
+
+////////////////////////////////////////////////////////////
+/// \brief Deallocates memory
+///
+/// This function deallocates the memory being pointed to
+/// using the free function from the C standard library.
+///
+/// The memory must have been previously allocated using a call
+/// to malloc.
+///
+/// \param ptr Pointer to the memory to deallocate
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfFree(void* ptr);

include/CSFML/System/Buffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_BUFFER_H
+#pragma once
-#define SFML_BUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
-#include <SFML/System/Types.h>
+
+#include <CSFML/System/Types.h>
+
 #include <stddef.h>
 
 
@@ -47,7 +48,7 @@ CSFML_SYSTEM_API sfBuffer* sfBuffer_create(void);
 /// \param buffer Buffer to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API void sfBuffer_destroy(sfBuffer* buffer);
+CSFML_SYSTEM_API void sfBuffer_destroy(const sfBuffer* buffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of a buffer
@@ -67,7 +68,4 @@ CSFML_SYSTEM_API size_t sfBuffer_getSize(const sfBuffer* buffer);
 /// \return Read-only pointer to the array of bytes
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API const sfUint8* sfBuffer_getData(const sfBuffer* buffer);
+CSFML_SYSTEM_API const uint8_t* sfBuffer_getData(const sfBuffer* buffer);
-
-
-#endif // SFML_BUFFER_H

include/CSFML/System/Clock.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CLOCK_H
+#pragma once
-#define SFML_CLOCK_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
-#include <SFML/System/Time.h>
+
-#include <SFML/System/Types.h>
+#include <CSFML/System/Time.h>
+#include <CSFML/System/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -57,7 +57,7 @@ CSFML_SYSTEM_API sfClock* sfClock_copy(const sfClock* clock);
 /// \param clock Clock to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API void sfClock_destroy(sfClock* clock);
+CSFML_SYSTEM_API void sfClock_destroy(const sfClock* clock);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the time elapsed in a clock
@@ -73,6 +73,36 @@ CSFML_SYSTEM_API void sfClock_destroy(sfClock* clock);
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API sfTime sfClock_getElapsedTime(const sfClock* clock);
 
+////////////////////////////////////////////////////////////
+/// \brief Check whether the clock is running
+///
+/// \param clock Clock object
+///
+/// \return `true` if the clock is running, `false` otherwise
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API bool sfClock_isRunning(const sfClock* clock);
+
+////////////////////////////////////////////////////////////
+/// \brief Start the clock
+///
+/// \param clock Clock object
+///
+/// \see `stop`
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfClock_start(sfClock* clock);
+
+////////////////////////////////////////////////////////////
+/// \brief Stop the clock
+///
+/// \param clock Clock object
+///
+/// \see `start`
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfClock_stop(sfClock* clock);
+
 ////////////////////////////////////////////////////////////
 /// \brief Restart a clock
 ///
@@ -86,5 +116,17 @@ CSFML_SYSTEM_API sfTime sfClock_getElapsedTime(const sfClock* clock);
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API sfTime sfClock_restart(sfClock* clock);
 
-
+////////////////////////////////////////////////////////////
-#endif // SFML_CLOCK_H
+/// \brief Reset the clock
+///
+/// This function puts the time counter back to zero, returns
+/// the elapsed time, and leaves the clock in a paused state.
+///
+/// \param clock Clock object
+///
+/// \return Time elapsed
+///
+/// \see `restart`
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API sfTime sfClock_reset(sfClock* clock);

include/CSFML/System/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SYSTEM_EXPORT_H
+#pragma once
-#define SFML_SYSTEM_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,13 +35,10 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_SYSTEM_EXPORTS)
 
-    #define CSFML_SYSTEM_API CSFML_API_EXPORT
+#define CSFML_SYSTEM_API CSFML_API_EXPORT
 
 #else
 
-    #define CSFML_SYSTEM_API CSFML_API_IMPORT
+#define CSFML_SYSTEM_API CSFML_API_IMPORT
 
 #endif
-
-
-#endif // SFML_SYSTEM_EXPORT_H

include/CSFML/System/InputStream.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,19 +22,20 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_INPUTSTREAM_H
+#pragma once
-#define SFML_INPUTSTREAM_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
+
+#include <stdlib.h>
 
 
-typedef sfInt64 (*sfInputStreamReadFunc)(void* data, sfInt64 size, void* userData);
+typedef int64_t (*sfInputStreamReadFunc)(void* data, size_t size, void* userData);
-typedef sfInt64 (*sfInputStreamSeekFunc)(sfInt64 position, void* userData);
+typedef int64_t (*sfInputStreamSeekFunc)(size_t position, void* userData);
-typedef sfInt64 (*sfInputStreamTellFunc)(void* userData);
+typedef int64_t (*sfInputStreamTellFunc)(void* userData);
-typedef sfInt64 (*sfInputStreamGetSizeFunc)(void* userData);
+typedef int64_t (*sfInputStreamGetSizeFunc)(void* userData);
 
 
 ////////////////////////////////////////////////////////////
@@ -49,6 +50,3 @@ typedef struct sfInputStream
     sfInputStreamGetSizeFunc getSize;  ///< Function to get the total number of bytes in the stream
     void*                    userData; ///< User data that will be passed to the callbacks
 } sfInputStream;
-
-
-#endif // SFML_INPUTSTREAM_H

include/CSFML/System/Sleep.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SLEEP_H
+#pragma once
-#define SFML_SLEEP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
-#include <SFML/System/Time.h>
+
+#include <CSFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -42,6 +42,3 @@
 ///
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API void sfSleep(sfTime duration);
-
-
-#endif // SFML_SLEEP_H

include/CSFML/System/Time.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_TIME_H
+#pragma once
-#define SFML_TIME_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -37,14 +36,14 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfInt64 microseconds;
+    int64_t microseconds;
 } sfTime;
 
 ////////////////////////////////////////////////////////////
 /// \brief Predefined "zero" time value
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfTime_Zero;
+CSFML_SYSTEM_API const sfTime sfTime_Zero;
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of seconds
@@ -64,7 +63,7 @@ CSFML_SYSTEM_API float sfTime_asSeconds(sfTime time);
 /// \return Time in milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfInt32 sfTime_asMilliseconds(sfTime time);
+CSFML_SYSTEM_API int32_t sfTime_asMilliseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of microseconds
@@ -74,7 +73,7 @@ CSFML_SYSTEM_API sfInt32 sfTime_asMilliseconds(sfTime time);
 /// \return Time in microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfInt64 sfTime_asMicroseconds(sfTime time);
+CSFML_SYSTEM_API int64_t sfTime_asMicroseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of seconds
@@ -94,7 +93,7 @@ CSFML_SYSTEM_API sfTime sfSeconds(float amount);
 /// \return Time value constructed from the amount of milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMilliseconds(sfInt32 amount);
+CSFML_SYSTEM_API sfTime sfMilliseconds(int32_t amount);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of microseconds
@@ -104,7 +103,4 @@ CSFML_SYSTEM_API sfTime sfMilliseconds(sfInt32 amount);
 /// \return Time value constructed from the amount of microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMicroseconds(sfInt64 amount);
+CSFML_SYSTEM_API sfTime sfMicroseconds(int64_t amount);
-
-
-#endif // SFML_TIME_H

include/CSFML/System/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,8 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_SYSTEM_TYPES_H
+#pragma once
-#define SFML_SYSTEM_TYPES_H
 
 
 typedef struct sfBuffer sfBuffer;
-typedef struct sfClock sfClock;
+typedef struct sfClock  sfClock;
-typedef struct sfMutex sfMutex;
-typedef struct sfThread sfThread;
-
-
-#endif // SFML_SYSTEM_TYPES_H

include/CSFML/System/Vector2.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VECTOR2_H
+#pragma once
-#define SFML_VECTOR2_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -62,6 +61,3 @@ typedef struct
     float x;
     float y;
 } sfVector2f;
-
-
-#endif // SFML_VECTOR2_H

include/CSFML/System/Vector3.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_VECTOR3_H
+#pragma once
-#define SFML_VECTOR3_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Export.h>
+#include <CSFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -41,6 +40,3 @@ typedef struct
     float y;
     float z;
 } sfVector3f;
-
-
-#endif // SFML_VECTOR3_H

include/CSFML/Window.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,23 +22,22 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_NETWORK_H
+#pragma once
-#define SFML_NETWORK_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
 
-#include <SFML/System.h>
+#include <CSFML/System.h>
-#include <SFML/Network/Ftp.h>
+#include <CSFML/Window/Clipboard.h>
-#include <SFML/Network/Http.h>
+#include <CSFML/Window/Context.h>
-#include <SFML/Network/IpAddress.h>
+#include <CSFML/Window/Cursor.h>
-#include <SFML/Network/Packet.h>
+#include <CSFML/Window/Event.h>
-#include <SFML/Network/SocketSelector.h>
+#include <CSFML/Window/Joystick.h>
-#include <SFML/Network/SocketStatus.h>
+#include <CSFML/Window/JoystickIdentification.h>
-#include <SFML/Network/TcpListener.h>
+#include <CSFML/Window/Keyboard.h>
-#include <SFML/Network/TcpSocket.h>
+#include <CSFML/Window/Mouse.h>
-#include <SFML/Network/UdpSocket.h>
+#include <CSFML/Window/Sensor.h>
-
+#include <CSFML/Window/Touch.h>
-
+#include <CSFML/Window/VideoMode.h>
-#endif // SFML_NETWORK_H
+#include <CSFML/Window/Window.h>

include/CSFML/Window/Clipboard.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,14 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CLIPBOARD_H
+#pragma once
-#define SFML_CLIPBOARD_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Window/Export.h>
+#include <CSFML/Window/Export.h>
-#include <SFML/Window/Types.h>
+
+#include <CSFML/Window/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -55,7 +55,7 @@ CSFML_WINDOW_API const char* sfClipboard_getString(void);
 /// \return Clipboard contents as UTF-32
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API const sfUint32* sfClipboard_getUnicodeString(void);
+CSFML_WINDOW_API const sfChar32* sfClipboard_getUnicodeString(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the content of the clipboard as ANSI string data
@@ -79,7 +79,4 @@ CSFML_WINDOW_API void sfClipboard_setString(const char* text);
 /// to the clipboard
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfClipboard_setUnicodeString(const sfUint32* text);
+CSFML_WINDOW_API void sfClipboard_setUnicodeString(const sfChar32* text);
-
-
-#endif // SFML_CURSOR_H

include/CSFML/Window/Context.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CONTEXT_H
+#pragma once
-#define SFML_CONTEXT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Window/Export.h>
+#include <CSFML/Window/Export.h>
-#include <SFML/Window/Types.h>
-#include <SFML/Window/Window.h>
 
-typedef void (*GlFunctionPointer)(void);
+#include <CSFML/Window/Types.h>
+#include <CSFML/Window/Window.h>
+
+typedef void (*sfGlFunctionPointer)(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new context
@@ -50,28 +50,28 @@ CSFML_WINDOW_API sfContext* sfContext_create(void);
 /// \param context Context to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfContext_destroy(sfContext* context);
+CSFML_WINDOW_API void sfContext_destroy(const sfContext* context);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check whether a given OpenGL extension is available.
 ///
-/// \param Name of the extension to check for
+/// \param name Name of the extension to check for
 ///
 /// \return True if available, false if unavailable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfContext_isExtensionAvailable(const char* name);
+CSFML_WINDOW_API bool sfContext_isExtensionAvailable(const char* name);
 
 ////////////////////////////////////////////////////////////
-/// \brief Activate or deactivate explicitely a context
+/// \brief Activate or deactivate explicitly a context
 ///
 /// \param context Context object
-/// \param active  sfTrue to activate, sfFalse to deactivate
+/// \param active  true to activate, false to deactivate
 ///
-/// \return sfTrue on success, sfFalse on failure
+/// \return true on success, false on failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfContext_setActive(sfContext* context, sfBool active);
+CSFML_WINDOW_API bool sfContext_setActive(sfContext* context, bool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of an OpenGL function.
@@ -81,11 +81,13 @@ CSFML_WINDOW_API sfBool sfContext_setActive(sfContext* context, sfBool active);
 /// \return Address of the OpenGL function, 0 on failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API GlFunctionPointer sfContext_getFunction(const char* name);
+CSFML_WINDOW_API sfGlFunctionPointer sfContext_getFunction(const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the settings of the context.
 ///
+/// \param context Context object
+///
 /// Note that these settings may be different than the ones passed to the
 /// constructor; they are indeed adjusted if the original settings are not
 /// directly supported by the system.
@@ -104,6 +106,4 @@ CSFML_WINDOW_API sfContextSettings sfContext_getSettings(const sfContext* contex
 /// \return The active context's ID or 0 if no context is currently active
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfUint64 sfContext_getActiveContextId(void);
+CSFML_WINDOW_API uint64_t sfContext_getActiveContextId(void);
-
-#endif // SFML_CONTEXT_H

include/CSFML/Window/Cursor.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,15 +22,15 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_CURSOR_H
+#pragma once
-#define SFML_CURSOR_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/System/Vector2.h>
+#include <CSFML/Window/Export.h>
-#include <SFML/Window/Export.h>
+
-#include <SFML/Window/Types.h>
+#include <CSFML/System/Vector2.h>
+#include <CSFML/Window/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -79,14 +79,14 @@ typedef enum
     sfCursorSizeRight,              ///< Right arrow cursor on Linux, same as SizeHorizontal on other platforms
     sfCursorSizeTop,                ///< Up arrow cursor on Linux, same as SizeVertical on other platforms
     sfCursorSizeBottom,             ///< Down arrow cursor on Linux, same as SizeVertical on other platforms
-    sfCursorSizeTopLeft,            ///< Top-left arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms
+    sfCursorSizeTopLeft,     ///< Top-left arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms
-    sfCursorSizeBottomRight,        ///< Bottom-right arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms
+    sfCursorSizeBottomRight, ///< Bottom-right arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms
-    sfCursorSizeBottomLeft,         ///< Bottom-left arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms
+    sfCursorSizeBottomLeft,  ///< Bottom-left arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms
-    sfCursorSizeTopRight,           ///< Top-right arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms
+    sfCursorSizeTopRight,    ///< Top-right arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms
-    sfCursorSizeAll,                ///< Combination of SizeHorizontal and SizeVertical
+    sfCursorSizeAll,         ///< Combination of SizeHorizontal and SizeVertical
-    sfCursorCross,                  ///< Crosshair cursor
+    sfCursorCross,           ///< Crosshair cursor
-    sfCursorHelp,                   ///< Help cursor
+    sfCursorHelp,            ///< Help cursor
-    sfCursorNotAllowed              ///< Action not allowed cursor
+    sfCursorNotAllowed       ///< Action not allowed cursor
 } sfCursorType;
 
 
@@ -97,8 +97,7 @@ typedef enum
 /// in 32-bit RGBA format. If not, this will cause undefined behavior.
 ///
 /// If \a pixels is null or either \a width or \a height are 0,
-/// the current cursor is left unchanged and the function will
+/// the function will return no new cursor (nullptr).
-/// return false.
 ///
 /// In addition to specifying the pixel data, you can also
 /// specify the location of the hotspot of the cursor. The
@@ -118,7 +117,7 @@ typedef enum
 /// \return A new sfCursor object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfCursor* sfCursor_createFromPixels(const sfUint8* pixels, sfVector2u size, sfVector2u hotspot);
+CSFML_WINDOW_API sfCursor* sfCursor_createFromPixels(const uint8_t* pixels, sfVector2u size, sfVector2u hotspot);
 
 
 ////////////////////////////////////////////////////////////
@@ -142,7 +141,4 @@ CSFML_WINDOW_API sfCursor* sfCursor_createFromSystem(sfCursorType type);
 /// \param cursor Cursor to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfCursor_destroy(sfCursor* cursor);
+CSFML_WINDOW_API void sfCursor_destroy(const sfCursor* cursor);
-
-
-#endif // SFML_CURSOR_H

include/CSFML/Window/Event.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,17 +22,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_EVENT_H
+#pragma once
-#define SFML_EVENT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Window/Export.h>
+#include <CSFML/Window/Export.h>
-#include <SFML/Window/Joystick.h>
+
-#include <SFML/Window/Keyboard.h>
+#include <CSFML/Window/Joystick.h>
-#include <SFML/Window/Mouse.h>
+#include <CSFML/Window/Keyboard.h>
-#include <SFML/Window/Sensor.h>
+#include <CSFML/Window/Mouse.h>
+#include <CSFML/Window/Sensor.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -43,16 +43,16 @@ typedef enum
 {
     sfEvtClosed,                 ///< The window requested to be closed (no data)
     sfEvtResized,                ///< The window was resized (data in event.size)
-    sfEvtLostFocus,              ///< The window lost the focus (no data)
+    sfEvtFocusLost,              ///< The window lost the focus (no data)
-    sfEvtGainedFocus,            ///< The window gained the focus (no data)
+    sfEvtFocusGained,            ///< The window gained the focus (no data)
     sfEvtTextEntered,            ///< A character was entered (data in event.text)
     sfEvtKeyPressed,             ///< A key was pressed (data in event.key)
     sfEvtKeyReleased,            ///< A key was released (data in event.key)
-    sfEvtMouseWheelMoved,        ///< The mouse wheel was scrolled (data in event.mouseWheel) (deprecated)
     sfEvtMouseWheelScrolled,     ///< The mouse wheel was scrolled (data in event.mouseWheelScroll)
     sfEvtMouseButtonPressed,     ///< A mouse button was pressed (data in event.mouseButton)
     sfEvtMouseButtonReleased,    ///< A mouse button was released (data in event.mouseButton)
     sfEvtMouseMoved,             ///< The mouse cursor moved (data in event.mouseMove)
+    sfEvtMouseMovedRaw,          ///< The mouse cursor moved (data in event.mouseMove)
     sfEvtMouseEntered,           ///< The mouse cursor entered the area of the window (no data)
     sfEvtMouseLeft,              ///< The mouse cursor left the area of the window (no data)
     sfEvtJoystickButtonPressed,  ///< A joystick button was pressed (data in event.joystickButton)
@@ -65,7 +65,7 @@ typedef enum
     sfEvtTouchEnded,             ///< A touch event ended (data in event.touch)
     sfEvtSensorChanged,          ///< A sensor value changed (data in event.sensor)
 
-    sfEvtCount                   ///< Keep last -- the total number of event types
+    sfEvtCount ///< Keep last -- the total number of event types
 } sfEventType;
 
 
@@ -78,10 +78,10 @@ typedef struct
     sfEventType type;
     sfKeyCode   code;
     sfScancode  scancode;
-    sfBool      alt;
+    bool        alt;
-    sfBool      control;
+    bool        control;
-    sfBool      shift;
+    bool        shift;
-    sfBool      system;
+    bool        system;
 } sfKeyEvent;
 
 ////////////////////////////////////////////////////////////
@@ -91,7 +91,7 @@ typedef struct
 typedef struct
 {
     sfEventType type;
-    sfUint32    unicode;
+    uint32_t    unicode;
 } sfTextEvent;
 
 ////////////////////////////////////////////////////////////
@@ -101,10 +101,19 @@ typedef struct
 typedef struct
 {
     sfEventType type;
-    int         x;
+    sfVector2i  position;
-    int         y;
 } sfMouseMoveEvent;
 
+////////////////////////////////////////////////////////////
+/// \brief Mouse move raw event parameters
+///
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    sfEventType type;
+    sfVector2i  delta;
+} sfMouseMoveRawEvent;
+
 ////////////////////////////////////////////////////////////
 /// \brief Mouse buttons events parameters
 ///
@@ -113,25 +122,9 @@ typedef struct
 {
     sfEventType   type;
     sfMouseButton button;
-    int           x;
+    sfVector2i    position;
-    int           y;
 } sfMouseButtonEvent;
 
-////////////////////////////////////////////////////////////
-/// \brief Mouse wheel events parameters
-///
-/// \deprecated
-/// Use sfMouseWheelScrollEvent instead.
-///
-////////////////////////////////////////////////////////////
-typedef struct CSFML_DEPRECATED
-{
-    sfEventType type;
-    int         delta;
-    int         x;
-    int         y;
-} sfMouseWheelEvent;
-
 ////////////////////////////////////////////////////////////
 /// \brief Mouse wheel events parameters
 ///
@@ -141,8 +134,7 @@ typedef struct
     sfEventType  type;
     sfMouseWheel wheel;
     float        delta;
-    int          x;
+    sfVector2i   position;
-    int          y;
 } sfMouseWheelScrollEvent;
 
 ////////////////////////////////////////////////////////////
@@ -184,9 +176,8 @@ typedef struct
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfEventType  type;
+    sfEventType type;
-    unsigned int width;
+    sfVector2u  size;
-    unsigned int height;
 } sfSizeEvent;
 
 ////////////////////////////////////////////////////////////
@@ -197,8 +188,7 @@ typedef struct
 {
     sfEventType  type;
     unsigned int finger;
-    int          x;
+    sfVector2i   position;
-    int          y;
 } sfTouchEvent;
 
 ////////////////////////////////////////////////////////////
@@ -209,9 +199,7 @@ typedef struct
 {
     sfEventType  type;
     sfSensorType sensorType;
-    float        x;
+    sfVector3f   value;
-    float        y;
-    float        z;
 } sfSensorEvent;
 
 ////////////////////////////////////////////////////////////
@@ -225,8 +213,8 @@ typedef union
     sfKeyEvent              key;              ///< Key event parameters
     sfTextEvent             text;             ///< Text event parameters
     sfMouseMoveEvent        mouseMove;        ///< Mouse move event parameters
+    sfMouseMoveRawEvent     mouseMoveRaw;     ///< Mouse move raw event parameters
     sfMouseButtonEvent      mouseButton;      ///< Mouse button event parameters
-    sfMouseWheelEvent       mouseWheel;       ///< Mouse wheel event parameters (deprecated)
     sfMouseWheelScrollEvent mouseWheelScroll; ///< Mouse wheel event parameters
     sfJoystickMoveEvent     joystickMove;     ///< Joystick move event parameters
     sfJoystickButtonEvent   joystickButton;   ///< Joystick button event parameters
@@ -234,6 +222,3 @@ typedef union
     sfTouchEvent            touch;            ///< Touch events parameters
     sfSensorEvent           sensor;           ///< Sensor event parameters
 } sfEvent;
-
-
-#endif // SFML_EVENT_H

include/CSFML/Window/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,13 +22,12 @@
 //
 ////////////////////////////////////////////////////////////
 
-#ifndef SFML_WINDOW_EXPORT_H
+#pragma once
-#define SFML_WINDOW_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Config.h>
+#include <CSFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,13 +35,10 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_WINDOW_EXPORTS)
 
-    #define CSFML_WINDOW_API CSFML_API_EXPORT
+#define CSFML_WINDOW_API CSFML_API_EXPORT
 
 #else
 
-    #define CSFML_WINDOW_API CSFML_API_IMPORT
+#define CSFML_WINDOW_API CSFML_API_IMPORT
 
 #endif
-
-
-#endif // SFML_WINDOW_EXPORT_H