Build SFML dynamically for the windows release packages

.clang-format

@@ -1,173 +0,0 @@
----
-# 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

@@ -1,38 +0,0 @@
-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,
-  -cppcoreguidelines-use-enum-class,
-  -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

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

.github/workflows/ci.yml

@@ -2,39 +2,28 @@ name: CI
 
 on: [push, pull_request, workflow_dispatch]
 
-permissions: {}
-
 concurrency:
   group: environment-${{github.ref}}
   cancel-in-progress: true
 
-env:
-  SFML_VERSION: 3.0.2
-
-defaults:
-  run:
-    shell: bash
-
 jobs:
   build:
-    name: ${{ matrix.platform.name }} ${{ matrix.config.name }} ${{ matrix.type.name }}
+    name: ${{ matrix.platform.name }} ${{ matrix.type.name }}
     runs-on: ${{ matrix.platform.os }}
 
     strategy:
       fail-fast: false
       matrix:
         platform:
-        - { name: Windows VS2026 x86,  os: windows-2025-vs2026, flags: -AWin32 }
+        - { name: Windows VS2019 x86,  os: windows-2019, flags: -AWin32 }
-        - { name: Windows VS2026 x64,  os: windows-2025-vs2026, flags: -Ax64 }
+        - { name: Windows VS2019 x64,  os: windows-2019, flags: -Ax64 }
-        # ClangCL is disabled until we build against SFML 3.1, the FLAC version bundled with SFML 3.0 fails to compile with VS2026's ClangCL
+        - { name: Windows VS2022 x86,  os: windows-2022, flags: -AWin32 }
-        # - { name: Windows ClangCL,     os: windows-2025-vs2026, flags: -T ClangCL }
+        - { name: Windows VS2022 x64,  os: windows-2022, flags: -Ax64 }
-        - { name: Windows Clang,       os: windows-2025-vs2026, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
+        - { name: Windows ClangCL,     os: windows-2022, flags: -T ClangCL }
-        - { name: Linux GCC,           os: ubuntu-24.04, flags: -GNinja }
+        - { name: Windows Clang,       os: windows-2022, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
-        - { name: Linux Clang,         os: ubuntu-24.04, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
+        - { name: Linux GCC,           os: ubuntu-22.04, flags: -GNinja }
-        - { name: MacOS,               os: macos-15,     flags: -GNinja }
+        - { name: Linux Clang,         os: ubuntu-22.04, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
-        config:
+        - { name: MacOS,               os: macos-12,     flags: -GNinja }
-        - { 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 }
@@ -43,164 +32,36 @@ jobs:
     - name: Get CMake and Ninja
       uses: lukka/get-cmake@latest
       with:
-        cmakeVersion: ${{ runner.os == 'Windows' && '4.2' || '3.22' }} # Visual Studio 2026 generator requires CMake 4.2 or later
         ninjaVersion: latest
 
     - name: Install Linux Dependencies
       if: runner.os == 'Linux'
-      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
+      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
 
     - name: Checkout SFML
-      uses: actions/checkout@v7
+      uses: actions/checkout@v4
       with:
-        persist-credentials: false
         repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
+        ref: 2.6.1
         path: SFML
 
     - name: Configure SFML CMake
-      env:
+      shell: bash
-        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}}
-        CMAKE_FLAGS: ${{ matrix.platform.flags }} ${{ matrix.config.flags }}
-      run: |
-        cmake -S SFML -B SFML/build \
-          -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
-          -DCMAKE_INSTALL_PREFIX=SFML/install \
-          $CMAKE_FLAGS
 
     - name: Build SFML
-      env:
+      shell: bash
-        BUILD_TYPE: ${{ matrix.type.name }}
+      run: cmake --build $GITHUB_WORKSPACE/SFML/build --config ${{matrix.type.name}} --target install
-      run: cmake --build SFML/build --config "$BUILD_TYPE" --target install
 
     - name: Checkout CSFML
-      uses: actions/checkout@v7
+      uses: actions/checkout@v4
       with:
-        persist-credentials: false
         path: CSFML
 
     - name: Configure CSFML CMake
-      env:
+      shell: bash
-        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}}
-        CMAKE_FLAGS: ${{ matrix.platform.flags }} ${{ matrix.config.flags }} ${{ matrix.config.csfml_flags }}
-      run: |
-        cmake --preset dev -S CSFML -B CSFML/build \
-          -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
-          -DCMAKE_INSTALL_PREFIX=CSFML/install \
-          -DSFML_ROOT=SFML/install \
-          -DCMAKE_VERBOSE_MAKEFILE=ON \
-          $CMAKE_FLAGS
 
     - name: Build CSFML
-      env:
+      shell: bash
-        BUILD_TYPE: ${{ matrix.type.name }}
+      run: cmake --build $GITHUB_WORKSPACE/CSFML/build --config ${{matrix.type.name}} --target install
-      run: cmake --build CSFML/build --config "$BUILD_TYPE" --target install
-
-    - name: Test
-      env:
-        BUILD_TYPE: ${{ matrix.type.name }}
-      run: ctest --test-dir CSFML/build -C "$BUILD_TYPE" --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@v7
-      with:
-        persist-credentials: false
-
-    - 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-15
-
-    steps:
-    - name: Get CMake and Ninja
-      uses: lukka/get-cmake@latest
-      with:
-        cmakeVersion: ${{ runner.os == 'Windows' && '4.2' || '3.22' }} # Visual Studio 2026 generator requires CMake 4.2 or later
-        ninjaVersion: latest
-
-    - name: Install Dependencies
-      run: |
-        brew update
-        brew install llvm@18 ninja
-        echo "$(brew --prefix llvm@18)/bin" >> $GITHUB_PATH
-
-    - name: Checkout SFML
-      uses: actions/checkout@v7
-      with:
-        persist-credentials: false
-        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@v7
-      with:
-        persist-credentials: false
-        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-15
-
-    steps:
-    - name: Get CMake and Ninja
-      uses: lukka/get-cmake@latest
-      with:
-        cmakeVersion: ${{ runner.os == 'Windows' && '4.2' || '3.22' }} # Visual Studio 2026 generator requires CMake 4.2 or later
-        ninjaVersion: latest
-
-    - name: Install Doxygen
-      run: |
-        brew update
-        brew install doxygen ninja || true
-
-    - name: Checkout SFML
-      uses: actions/checkout@v7
-      with:
-        persist-credentials: false
-        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@v7
-      with:
-        persist-credentials: false
-        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

@@ -1,256 +1,249 @@
 name: NuGet Release
 
 on:
-  push:
+    push: {}
-    branches:
+    workflow_dispatch: {}
-      - master
-      - 2.6.x
-    tags:
-      - "**"
-  workflow_dispatch: {}
-
-permissions: {}
 
 concurrency:
-  group: nuget-${{github.ref}}
+    group: nuget-${{github.ref}}
-  cancel-in-progress: true
+    cancel-in-progress: true
 
 env:
-  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+    DOTNET_CLI_TELEMETRY_OPTOUT: 1
 
 jobs:
-  windows-x86-x64:
+    windows:
-    name: Windows x86 x64
+        name: Windows VS2022
-    runs-on: windows-2025-vs2026
+        runs-on: windows-2022
 
-    steps:
+        steps:
-      - name: Checkout CSFML
+            - name: Checkout CSFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  path: CSFML
-          path: CSFML
 
-      - name: Build x86
+            - name: Build x86
-        shell: pwsh
+              shell: pwsh
-        run: |
+              run: |
-          cd CSFML/tools/nuget
+                  cd CSFML/tools/nuget
-          ./build.win.ps1 "win-x86"
+                  ./build.win.ps1 "win-x86"
 
-      - name: Build x64
+            - name: Build x64
-        shell: pwsh
+              shell: pwsh
-        run: |
+              run: |
-          cd CSFML/tools/nuget
+                  cd CSFML/tools/nuget
-          ./build.win.ps1 "win-x64"
+                  ./build.win.ps1 "win-x64"
 
-      - name: Upload Artifact
+            - name: Upload Artifact
-        uses: actions/upload-artifact@v7
+              uses: actions/upload-artifact@v4
-        with:
+              with:
-          name: CSFML-win-x86-x64
+                  name: CSFML-win-x86-x64
-          path: CSFML/tools/nuget/CSFML/runtimes
+                  path: CSFML/tools/nuget/CSFML/runtimes
 
-  windows-arm64:
+    linux-x64:
-    name: Windows ARM64
+        name: Linux x64
-    runs-on: windows-11-vs2026-arm
+        runs-on: ubuntu-22.04
+        container:
+            image: ubuntu:22.04
 
-    steps:
+        steps:
-      - name: Checkout CSFML
+            - name: Checkout CSFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  path: CSFML
-          path: CSFML
 
-      - name: Build ARM64
+            - name: Build
-        shell: pwsh
+              shell: bash
-        run: |
+              run: |
-          cd CSFML/tools/nuget
+                  cd ./CSFML/tools/nuget
-          ./build.win.ps1 "win-arm64"
+                  chmod +x ./docker.linux-x64.sh
+                  ./docker.linux-x64.sh
 
-      - name: Upload Artifact
+            - name: Upload Artifact
-        uses: actions/upload-artifact@v7
+              uses: actions/upload-artifact@v4
-        with:
+              with:
-          name: CSFML-win-arm64
+                  name: CSFML-linux-x64
-          path: CSFML/tools/nuget/CSFML/runtimes
+                  path: CSFML/tools/nuget/CSFML/runtimes
 
-  linux-x64:
+    linux-arm:
-    name: Linux x64
+        name: Linux ARM
-    runs-on: ubuntu-24.04
+        runs-on: ubuntu-22.04
-    container:
-      image: ubuntu:24.04
 
-    steps:
+        steps:
-      - name: Checkout CSFML
+            - name: Checkout CSFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  path: CSFML
-          path: CSFML
 
-      - name: Build
+            - name: Build in an ARM container
-        shell: bash
+              uses: uraimo/run-on-arch-action@v2.7.2
-        run: |
+              with:
-          cd ./CSFML/tools/nuget
+                  arch: armv7
-          chmod +x ./docker.linux-x64.sh
+                  distro: ubuntu22.04
-          ./docker.linux-x64.sh
+                  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 libopenal-dev cmake g++
+                  run: |
+                      cd /CSFML/tools/nuget
+                      chmod +x ./build.linux.sh
+                      ./build.linux.sh linux-arm
 
-      - name: Upload Artifact
+            - name: Upload Artifact
-        uses: actions/upload-artifact@v7
+              uses: actions/upload-artifact@v4
-        with:
+              with:
-          name: CSFML-linux-x64
+                  name: CSFML-linux-arm
-          path: CSFML/tools/nuget/CSFML/runtimes
+                  path: CSFML/tools/nuget/CSFML/runtimes
 
-  linux-arm:
+    linux-arm64:
-    name: Linux ARM
+        name: Linux ARM64
-    runs-on: ubuntu-24.04-arm
+        runs-on: ubuntu-22.04
 
-    steps:
+        steps:
-      - name: Checkout CSFML
+            - name: Checkout CSFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  path: CSFML
-          path: CSFML
 
-      - name: Install dependencies & cross compiler
+            - name: Build in an ARM64 container
-        run: |
+              uses: uraimo/run-on-arch-action@v2.7.2
-          sudo dpkg --add-architecture armhf
+              with:
-          sudo apt-get update
+                  arch: aarch64
-          sudo apt-get install -y git libfreetype6-dev:armhf xorg-dev libxrandr-dev:armhf libxcursor-dev:armhf libxi-dev:armhf libudev-dev:armhf libgl1-mesa-dev:armhf libflac-dev:armhf libogg-dev:armhf libvorbis-dev:armhf cmake g++-arm-linux-gnueabihf gcc-arm-linux-gnueabihf
+                  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 libopenal-dev cmake g++
+                  run: |
+                      cd /CSFML/tools/nuget
+                      chmod +x ./build.linux.sh
+                      ./build.linux.sh linux-arm64
 
-      - name: Build
+            - name: Upload Artifact
-        shell: bash
+              uses: actions/upload-artifact@v4
-        run: |
+              with:
-          cd ./CSFML/tools/nuget
+                  name: CSFML-linux-arm64
-          chmod +x ./build.linux.sh
+                  path: CSFML/tools/nuget/CSFML/runtimes
-          ./build.linux.sh linux-arm arm-linux-gnueabihf-g++ arm-linux-gnueabihf-gcc
 
-      - name: Upload Artifact
+    linux-musl-x64:
-        uses: actions/upload-artifact@v7
+        name: Linux MUSL x64
-        with:
+        runs-on: ubuntu-22.04
-          name: CSFML-linux-arm
+        container:
-          path: CSFML/tools/nuget/CSFML/runtimes
+            image: alpine:3.15
 
-  linux-arm64:
+        steps:
-    name: Linux ARM64
+            - name: Checkout CSFML
-    runs-on: ubuntu-24.04-arm
+              uses: actions/checkout@v4
+              with:
+                  path: CSFML
 
-    steps:
+            - name: Build
-      - name: Checkout CSFML
+              shell: sh
-        uses: actions/checkout@v7
+              run: |
-        with:
+                  cd ./CSFML/tools/nuget
-          persist-credentials: false
+                  chmod +x ./docker.linux-musl-x64.sh
-          path: CSFML
+                  ./docker.linux-musl-x64.sh
 
-      - name: Install dependencies
+            - name: Upload Artifact
-        run: |
+              uses: actions/upload-artifact@v4
-          sudo apt-get update
+              with:
-          sudo 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 gcc g++
+                  name: CSFML-linux-musl-x64
+                  path: CSFML/tools/nuget/CSFML/runtimes
 
-      - name: Build
+    fedora-x64:
-        shell: bash
+        name: Fedora x64
-        run: |
+        runs-on: ubuntu-22.04
-          cd ./CSFML/tools/nuget
+        container:
-          chmod +x ./build.linux.sh
+            image: fedora:37
-          ./build.linux.sh linux-arm64
 
-      - name: Upload Artifact
+        steps:
-        uses: actions/upload-artifact@v7
+            - name: Checkout CSFML
-        with:
+              uses: actions/checkout@v4
-          name: CSFML-linux-arm64
+              with:
-          path: CSFML/tools/nuget/CSFML/runtimes
+                  path: CSFML
 
-  linux-musl-x64:
+            - name: Build
-    name: Linux MUSL x64
+              shell: bash
-    runs-on: ubuntu-24.04
+              run: |
-    container:
+                  cd ./CSFML/tools/nuget
-      image: alpine:3.20.7
+                  chmod +x ./docker.fedora-x64.sh
+                  ./docker.fedora-x64.sh
 
-    steps:
+            - name: Upload Artifact
-      - name: Checkout CSFML
+              uses: actions/upload-artifact@v4
-        uses: actions/checkout@v7
+              with:
-        with:
+                  name: CSFML-fedora-x64
-          persist-credentials: false
+                  path: CSFML/tools/nuget/CSFML/runtimes
-          path: CSFML
 
-      - name: Build
+    macos:
-        shell: sh
+        name: macOS
-        run: |
+        runs-on: macos-14
-          cd ./CSFML/tools/nuget
-          chmod +x ./docker.linux-musl-x64.sh
-          ./docker.linux-musl-x64.sh
 
-      - name: Upload Artifact
+        steps:
-        uses: actions/upload-artifact@v7
+            - name: Checkout CSFML
-        with:
+              uses: actions/checkout@v4
-          name: CSFML-linux-musl-x64
+              with:
-          path: CSFML/tools/nuget/CSFML/runtimes
+                  path: CSFML
 
-  macos-x64-arm64:
+            - name: Install necessary tooling
-    name: macOS x64 and ARM64
+              run: brew install coreutils
-    runs-on: macos-15
 
-    steps:
+            - name: Build x64
-      - name: Checkout CSFML
+              run: |
-        uses: actions/checkout@v7
+                  cd CSFML/tools/nuget
-        with:
+                  ./build.macos.sh "osx-x64"
-          persist-credentials: false
-          path: CSFML
 
-      - name: Install necessary tooling
+            - name: Build ARM64
-        run: brew install coreutils
+              run: |
+                  cd CSFML/tools/nuget
+                  ./build.macos.sh "osx-arm64"
 
-      - name: Build x64
+            - name: Upload Artifact
-        run: |
+              uses: actions/upload-artifact@v4
-          cd CSFML/tools/nuget
+              with:
-          ./build.macos.sh "osx-x64"
+                  name: CSFML-macOS-x64-arm64
+                  path: CSFML/tools/nuget/CSFML/runtimes
 
-      - name: Build ARM64
+    package:
-        run: |
+        name: Package Builds
-          cd CSFML/tools/nuget
+        runs-on: ubuntu-22.04
-          ./build.macos.sh "osx-arm64"
+        needs:
-
+            - windows
-      - name: Upload Artifact
+            - linux-x64
-        uses: actions/upload-artifact@v7
+            - linux-arm
-        with:
+            - linux-arm64
-          name: CSFML-macOS-x64-arm64
+            - linux-musl-x64
-          path: CSFML/tools/nuget/CSFML/runtimes
+            - fedora-x64
-
+            - macos
-  package:
+        steps:
-    name: Package Builds
+            - name: Checkout CSFML
-    runs-on: ubuntu-24.04
+              uses: actions/checkout@v4
-    needs:
+              with:
-      - windows-x86-x64
+                  path: CSFML
-      - windows-arm64
+            - name: Download Artifacts
-      - linux-x64
+              uses: actions/download-artifact@v4
-      - linux-arm
+              with:
-      - linux-arm64
+                  path: CSFML/tools/nuget/CSFML/runtimes
-      - linux-musl-x64
+                  merge-multiple: true
-      - macos-x64-arm64
+            - name: Setup .NET 8 SDK
-    steps:
+              id: setup-dotnet
-      - name: Checkout CSFML
+              uses: actions/setup-dotnet@v4
-        uses: actions/checkout@v7
+              with:
-        with:
+                  dotnet-version: 8.0.x
-          persist-credentials: false
+            - name: Enforce SDK Version
-          path: CSFML
+              run: dotnet new globaljson --sdk-version ${{ steps.setup-dotnet.outputs.dotnet-version }} --force
-      - name: Download Artifacts
+            - name: Verify SDK Installation
-        uses: actions/download-artifact@v8
+              run: dotnet --info
-        with:
+            - name: Build NuGet Package
-          path: CSFML/tools/nuget/CSFML/runtimes
+              run: |
-          merge-multiple: true
+                  cd CSFML/tools/nuget
-      - name: Setup .NET 10 SDK
+                  dotnet build --configuration Release --verbosity detailed
-        id: setup-dotnet
+            - name: Upload NuGet Package
-        uses: actions/setup-dotnet@v5
+              uses: actions/upload-artifact@v4
-        with:
+              with:
-          dotnet-version: 10.0.x
+                  name: CSFML-NuGet-Package
-      - name: Enforce SDK Version
+                  path: CSFML/tools/nuget/CSFML/bin/Release/*.nupkg
-        env:
-          DOTNET_VERSION: ${{ steps.setup-dotnet.outputs.dotnet-version }}
-        run: dotnet new globaljson --sdk-version "$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@v7
-        with:
-          name: CSFML-NuGet-Package
-          path: CSFML/tools/nuget/CSFML/bin/Release/*.nupkg

.github/workflows/release.yml

@@ -1,356 +1,313 @@
 name: Release Builds
 
 on:
-  push:
+    push: {}
-    branches:
+    workflow_dispatch: {}
-      - master
-      - 2.6.x
-    tags:
-      - "**"
-  workflow_dispatch: {}
-
-permissions: {}
 
 concurrency:
-  group: release-${{github.ref}}
+    group: release-${{github.ref}}
-  cancel-in-progress: true
+    cancel-in-progress: true
-
-env:
-  SFML_VERSION: 3.0.2
-
-defaults:
-  run:
-    shell: bash
 
 jobs:
-  windows-x86:
+    windows-x86:
-    name: Windows x86
+        name: Windows x86
-    runs-on: windows-2025-vs2026
+        runs-on: windows-2022
 
-    steps:
+        steps:
-      - name: Install MinGW x86
+            - name: Cache MinGW x86
-        uses: bwoodsend/setup-winlibs-action@v1
+              id: mingw-x86-cache
-        id: winlibs-32
+              uses: actions/cache@v4
-        with:
+              with:
-          tag: 15.2.0posix-13.0.0-ucrt-r1
+                  path: ${{ github.workspace }}/mingw32
-          with_clang: false
+                  key: 14.1.0posix-18.1.5-11.0.1-msvcrt-r1-x86
-          architecture: 32
-          destination: ${{ github.workspace }}
-          add_to_path: false
 
-      - name: Checkout SFML
+            - name: Install MinGW x86
-        uses: actions/checkout@v7
+              if: steps.mingw-x86-cache.outputs.cache-hit != 'true'
-        with:
+              uses: bwoodsend/setup-winlibs-action@v1
-          persist-credentials: false
+              id: winlibs-32
-          repository: SFML/SFML
+              with:
-          ref: ${{ env.SFML_VERSION }}
+                  tag: 14.1.0posix-18.1.5-11.0.1-msvcrt-r1
-          path: SFML
+                  with_clang: false
+                  architecture: 32
+                  destination: ${{ github.workspace }}
+                  add_to_path: false
 
-      - name: Checkout CSFML
+            - name: Checkout SFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  repository: SFML/SFML
-          path: CSFML
+                  ref: 2.6.1
+                  path: SFML
 
-      - name: Build SFML
+            - name: Checkout CSFML
-        run: |
+              uses: actions/checkout@v4
-          cmake -S SFML -B SFML-build -A Win32 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+              with:
-          cmake --build SFML-build --config Release --target install
+                  path: CSFML
 
-      - name: Build CSFML
+            - name: Build SFML
-        run: |
+              run: |
-          cmake -S CSFML -B CSFML-build -A Win32 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCSFML_LINK_SFML_STATICALLY=OFF -DCMAKE_BUILD_TYPE=Release "-DSFML_ROOT=$GITHUB_WORKSPACE/SFML-install" "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake -S SFML -B SFML-build -A Win32 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=TRUE -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build CSFML-build --config Release --target install
+                  cmake --build SFML-build --config Release --target install
 
-      - name: Add MinGW to PATH
+            - name: Build CSFML
-        shell: bash
+              run: |
-        run: echo "$GITHUB_WORKSPACE\mingw32\bin" >> "$GITHUB_PATH"
+                  cmake -S CSFML -B CSFML-build -A Win32 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=TRUE -DCSFML_LINK_SFML_STATICALLY=FALSE -DCMAKE_BUILD_TYPE=Release -DSFML_DIR=${{ github.workspace }}/SFML-install/lib/cmake/SFML -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/CSFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake --build CSFML-build --config Release --target install
+            
+            - name: Add MinGW to PATH
+              shell: bash
+              run: echo "${{ github.workspace }}\mingw32\bin" >> $GITHUB_PATH
 
-      - name: Generate Import Libs for MinGW
+            - name: Generate Import Libs for MinGW
-        shell: pwsh
+              shell: pwsh
-        run: |
+              run: |
-          New-Item -ItemType "directory" -PATH "CSFML-install\lib\gcc"
+                  New-Item -ItemType "directory" -PATH "CSFML-install\lib\gcc"
-          New-Item -ItemType "directory" -PATH "CSFML-install\lib\msvc"
+                  New-Item -ItemType "directory" -PATH "CSFML-install\lib\msvc"
-          Move-Item -Path "CSFML-install\lib\*.lib" -Destination "CSFML-install\lib\msvc"
+                  Move-Item -Path "CSFML-install\lib\*.lib" -Destination "CSFML-install\lib\msvc"
 
-          Push-Location CSFML-install\lib\gcc
+                  Push-Location CSFML-install\lib\gcc
-          & gendef.exe "..\..\bin\csfml-graphics-3.dll"
+                  & gendef.exe "..\..\bin\csfml-graphics-2.dll"
-          & dlltool.exe -d "csfml-graphics-3.def" -D "..\..\bin\csfml-graphics-3.dll" -l "libcsfml-graphics.a"
+                  & dlltool.exe -d "csfml-graphics-2.def" -D "..\..\bin\csfml-graphics-2.dll" -l "libcsfml-graphics.a"
-          Remove-Item -Path "csfml-graphics-3.def"
+                  Remove-Item -Path "csfml-graphics-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-window-2.dll"
+                  & dlltool.exe -d "csfml-window-2.def" -D "..\..\bin\bin\csfml-window-2.dll" -l "libcsfml-window.a"
+                  Remove-Item -Path "csfml-window-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-audio-2.dll"
+                  & dlltool.exe -d "csfml-audio-2.def" -D "..\..\bin\bin\csfml-audio-2.dll" -l "libcsfml-audio.a"
+                  Remove-Item -Path "csfml-audio-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-network-2.dll"
+                  & dlltool.exe -d "csfml-network-2.def" -D "..\..\bin\bin\csfml-network-2.dll" -l "libcsfml-network.a"
+                  Remove-Item -Path "csfml-network-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-system-2.dll"
+                  & dlltool.exe -d "csfml-system-2.def" -D "..\..\bin\bin\csfml-system-2.dll" -l "libcsfml-system.a"
+                  Remove-Item -Path "csfml-system-2.def"
+                  Pop-Location
 
-          & gendef.exe "..\..\bin\csfml-window-3.dll"
+                  New-Item -ItemType "directory" -PATH "install"
-          & dlltool.exe -d "csfml-window-3.def" -D "..\..\bin\csfml-window-3.dll" -l "libcsfml-window.a"
+                  Move-Item -Path "SFML-install\bin\*" -Destination "install\CSFML"
-          Remove-Item -Path "csfml-window-3.def"
+                  Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
 
-          & gendef.exe "..\..\bin\csfml-audio-3.dll"
+            - name: Upload Artifact
-          & dlltool.exe -d "csfml-audio-3.def" -D "..\..\bin\csfml-audio-3.dll" -l "libcsfml-audio.a"
+              uses: actions/upload-artifact@v4
-          Remove-Item -Path "csfml-audio-3.def"
+              with:
+                  name: CSFML-windows-32-bit
+                  path: install/CSFML
 
-          & gendef.exe "..\..\bin\csfml-network-3.dll"
+    windows-x64:
-          & dlltool.exe -d "csfml-network-3.def" -D "..\..\bin\csfml-network-3.dll" -l "libcsfml-network.a"
+        name: Windows x64
-          Remove-Item -Path "csfml-network-3.def"
+        runs-on: windows-2022
 
-          & gendef.exe "..\..\bin\csfml-system-3.dll"
+        steps:
-          & dlltool.exe -d "csfml-system-3.def" -D "..\..\bin\csfml-system-3.dll" -l "libcsfml-system.a"
+            - name: Cache MinGW x64
-          Remove-Item -Path "csfml-system-3.def"
+              id: mingw-x64-cache
-          Pop-Location
+              uses: actions/cache@v4
+              with:
+                  path: ${{ github.workspace }}/mingw64
+                  key: 14.1.0posix-18.1.5-11.0.1-msvcrt-r1-x64
 
-          New-Item -ItemType "directory" -PATH "install\CSFML"
+            - name: Install MinGW x64
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
+              if: steps.mingw-x64-cache.outputs.cache-hit != 'true'
+              uses: bwoodsend/setup-winlibs-action@v1
+              id: winlibs-64
+              with:
+                  tag: 14.1.0posix-18.1.5-11.0.1-msvcrt-r1
+                  with_clang: false
+                  architecture: 64
+                  destination: ${{ github.workspace }}
+                  add_to_path: false
 
-      - name: Upload Artifact
+            - name: Checkout SFML
-        uses: actions/upload-artifact@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          name: CSFML-windows-32-bit
+                  repository: SFML/SFML
-          path: install/CSFML
+                  ref: 2.6.1
+                  path: SFML
 
-  windows-x64:
+            - name: Checkout CSFML
-    name: Windows x64
+              uses: actions/checkout@v4
-    runs-on: windows-2025-vs2026
+              with:
+                  path: CSFML
 
-    steps:
+            - name: Build SFML
-      - name: Install MinGW x64
+              run: |
-        uses: bwoodsend/setup-winlibs-action@v1
+                  cmake -S SFML -B SFML-build -A x64 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=TRUE -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-        id: winlibs-64
+                  cmake --build SFML-build --config Release --target install
-        with:
-          tag: 15.2.0posix-13.0.0-ucrt-r1
-          with_clang: false
-          architecture: 64
-          destination: ${{ github.workspace }}
-          add_to_path: false
 
-      - name: Checkout SFML
+            - name: Build CSFML
-        uses: actions/checkout@v7
+              run: |
-        with:
+                  cmake -S CSFML -B CSFML-build -A x64 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=TRUE -DCSFML_LINK_SFML_STATICALLY=FALSE -DCMAKE_BUILD_TYPE=Release -DSFML_DIR=${{ github.workspace }}/SFML-install/lib/cmake/SFML -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/CSFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-          persist-credentials: false
+                  cmake --build CSFML-build --config Release --target install
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
 
-      - name: Checkout CSFML
+            - name: Add MinGW to PATH
-        uses: actions/checkout@v7
+              shell: bash
-        with:
+              run: echo "${{ github.workspace }}\mingw64\bin" >> $GITHUB_PATH
-          persist-credentials: false
-          path: CSFML
 
-      - name: Build SFML
+            - name: Generate Import Libs for MinGW
-        run: |
+              shell: pwsh
-          cmake -S SFML -B SFML-build -A x64 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+              run: |
-          cmake --build SFML-build --config Release --target install
+                  New-Item -ItemType "directory" -PATH "CSFML-install\lib\gcc"
+                  New-Item -ItemType "directory" -PATH "CSFML-install\lib\msvc"
+                  Move-Item -Path "CSFML-install\lib\*.lib" -Destination "CSFML-install\lib\msvc"
 
-      - name: Build CSFML
+                  Push-Location CSFML-install\lib\gcc
-        run: |
+                  & gendef.exe "..\..\bin\csfml-graphics-2.dll"
-          cmake -S CSFML -B CSFML-build -A x64 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCSFML_LINK_SFML_STATICALLY=OFF -DCMAKE_BUILD_TYPE=Release "-DSFML_ROOT=$GITHUB_WORKSPACE/SFML-install" "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+                  & dlltool.exe -d "csfml-graphics-2.def" -D "..\..\bin\csfml-graphics-2.dll" -l "libcsfml-graphics.a"
-          cmake --build CSFML-build --config Release --target install
+                  Remove-Item -Path "csfml-graphics-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-window-2.dll"
+                  & dlltool.exe -d "csfml-window-2.def" -D "..\..\bin\bin\csfml-window-2.dll" -l "libcsfml-window.a"
+                  Remove-Item -Path "csfml-window-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-audio-2.dll"
+                  & dlltool.exe -d "csfml-audio-2.def" -D "..\..\bin\bin\csfml-audio-2.dll" -l "libcsfml-audio.a"
+                  Remove-Item -Path "csfml-audio-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-network-2.dll"
+                  & dlltool.exe -d "csfml-network-2.def" -D "..\..\bin\bin\csfml-network-2.dll" -l "libcsfml-network.a"
+                  Remove-Item -Path "csfml-network-2.def"
+                  
+                  & gendef.exe "..\..\bin\csfml-system-2.dll"
+                  & dlltool.exe -d "csfml-system-2.def" -D "..\..\bin\bin\csfml-system-2.dll" -l "libcsfml-system.a"
+                  Remove-Item -Path "csfml-system-2.def"
+                  Pop-Location
 
-      - name: Add MinGW to PATH
+                  New-Item -ItemType "directory" -PATH "install"
-        shell: bash
+                  Move-Item -Path "SFML-install\bin\*" -Destination "install\CSFML"
-        run: echo "$GITHUB_WORKSPACE\mingw64\bin" >> "$GITHUB_PATH"
+                  Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
 
-      - name: Generate Import Libs for MinGW
+            - name: Upload Artifact
-        shell: pwsh
+              uses: actions/upload-artifact@v4
-        run: |
+              with:
-          New-Item -ItemType "directory" -PATH "CSFML-install\lib\gcc"
+                  name: CSFML-windows-64-bit
-          New-Item -ItemType "directory" -PATH "CSFML-install\lib\msvc"
+                  path: install/CSFML
-          Move-Item -Path "CSFML-install\lib\*.lib" -Destination "CSFML-install\lib\msvc"
 
-          Push-Location CSFML-install\lib\gcc
+    macos-x64:
-          & gendef.exe "..\..\bin\csfml-graphics-3.dll"
+        name: macOS x64
-          & dlltool.exe -d "csfml-graphics-3.def" -D "..\..\bin\csfml-graphics-3.dll" -l "libcsfml-graphics.a"
+        runs-on: macos-12
-          Remove-Item -Path "csfml-graphics-3.def"
 
-          & gendef.exe "..\..\bin\csfml-window-3.dll"
+        steps:
-          & dlltool.exe -d "csfml-window-3.def" -D "..\..\bin\csfml-window-3.dll" -l "libcsfml-window.a"
+            - name: Checkout SFML
-          Remove-Item -Path "csfml-window-3.def"
+              uses: actions/checkout@v4
+              with:
+                  repository: SFML/SFML
+                  ref: 2.6.1
+                  path: SFML
 
-          & gendef.exe "..\..\bin\csfml-audio-3.dll"
+            - name: Checkout CSFML
-          & dlltool.exe -d "csfml-audio-3.def" -D "..\..\bin\csfml-audio-3.dll" -l "libcsfml-audio.a"
+              uses: actions/checkout@v4
-          Remove-Item -Path "csfml-audio-3.def"
+              with:
+                  path: CSFML
 
-          & gendef.exe "..\..\bin\csfml-network-3.dll"
+            - name: Build SFML
-          & dlltool.exe -d "csfml-network-3.def" -D "..\..\bin\csfml-network-3.dll" -l "libcsfml-network.a"
+              run: |
-          Remove-Item -Path "csfml-network-3.def"
+                  cmake -S SFML -B SFML-build -G "Unix Makefiles" \
+                        -DCMAKE_C_COMPILER="/usr/bin/clang" \
+                        -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
+                        -DCMAKE_C_FLAGS="-stdlib=libc++" \
+                        -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+                        -DBUILD_SHARED_LIBS=TRUE \
+                        -DCMAKE_BUILD_TYPE=Release \
+                        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install/Library/Frameworks \
+                        -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+                        -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
+                        -DSFML_BUILD_FRAMEWORKS=TRUE \
+                        -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake --build SFML-build --config Release --target install
 
-          & gendef.exe "..\..\bin\csfml-system-3.dll"
+            - name: Build CSFML
-          & dlltool.exe -d "csfml-system-3.def" -D "..\..\bin\csfml-system-3.dll" -l "libcsfml-system.a"
+              run: |
-          Remove-Item -Path "csfml-system-3.def"
+                  cmake -S CSFML -B CSFML-build -G "Unix Makefiles" \
-          Pop-Location
+                        -DCMAKE_C_COMPILER="/usr/bin/clang" \
+                        -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
+                        -DCMAKE_C_FLAGS="-stdlib=libc++" \
+                        -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+                        -DBUILD_SHARED_LIBS=TRUE \
+                        -DCSFML_LINK_SFML_STATICALLY=FALSE \
+                        -DCMAKE_BUILD_TYPE=Release \
+                        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/CSFML-install \
+                        -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+                        -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
+                        -DSFML_DIR=${{ github.workspace }}/SFML-install/Library/Frameworks/SFML.framework/Resources/CMake \
+                        -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake --build CSFML-build --config Release --target install
 
-          New-Item -ItemType "directory" -PATH "install\CSFML"
+            - name: Create Archive
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
+              run: |
+                  mkdir CSFML-macOS-clang-64-bit
+                  cp -R CSFML-install/include CSFML-macOS-clang-64-bit
+                  cp -R CSFML-install/lib CSFML-macOS-clang-64-bit
+                  cp CSFML-install/share/CSFML/* CSFML-macOS-clang-64-bit
+                  tar -zcvf CSFML-macOS-clang-64-bit.tar.gz CSFML-macOS-clang-64-bit
 
-      - name: Upload Artifact
+            - name: Upload Artifact
-        uses: actions/upload-artifact@v7
+              uses: actions/upload-artifact@v4
-        with:
+              with:
-          name: CSFML-windows-64-bit
+                  name: CSFML-macOS-clang-64-bit
-          path: install/CSFML
+                  path: CSFML-macOS-clang-64-bit.tar.gz
 
-  windows-arm64:
+    macos-arm64:
-    name: Windows ARM64
+        name: macOS ARM64
-    runs-on: windows-2025-vs2026
+        runs-on: macos-14
 
-    steps:
+        steps:
-      - name: Checkout SFML
+            - name: Checkout SFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  repository: SFML/SFML
-          repository: SFML/SFML
+                  ref: 2.6.1
-          ref: ${{ env.SFML_VERSION }}
+                  path: SFML
-          path: SFML
 
-      - name: Checkout CSFML
+            - name: Checkout CSFML
-        uses: actions/checkout@v7
+              uses: actions/checkout@v4
-        with:
+              with:
-          persist-credentials: false
+                  path: CSFML
-          path: CSFML
+            - name: Build SFML
+              run: |
+                  cmake -S SFML -B SFML-build -G "Unix Makefiles" \
+                        -DCMAKE_C_COMPILER="/usr/bin/clang" \
+                        -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
+                        -DCMAKE_C_FLAGS="-stdlib=libc++" \
+                        -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+                        -DBUILD_SHARED_LIBS=TRUE \
+                        -DCMAKE_BUILD_TYPE=Release \
+                        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install/Library/Frameworks \
+                        -DCMAKE_OSX_ARCHITECTURES=arm64 \
+                        -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 \
+                        -DSFML_BUILD_FRAMEWORKS=TRUE \
+                        -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake --build SFML-build --config Release --target install
 
-      - name: Build SFML
+            - name: Build CSFML
-        run: |
+              run: |
-          cmake -S SFML -B SFML-build -A ARM64 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake -S CSFML -B CSFML-build -G "Unix Makefiles" \
-          cmake --build SFML-build --config Release --target install
+                        -DCMAKE_C_COMPILER="/usr/bin/clang" \
+                        -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
+                        -DCMAKE_C_FLAGS="-stdlib=libc++" \
+                        -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+                        -DBUILD_SHARED_LIBS=TRUE \
+                        -DCSFML_LINK_SFML_STATICALLY=FALSE \
+                        -DCMAKE_BUILD_TYPE=Release \
+                        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/CSFML-install \
+                        -DCMAKE_OSX_ARCHITECTURES=arm64 \
+                        -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 \
+                        -DSFML_DIR=${{ github.workspace }}/SFML-install/Library/Frameworks/SFML.framework/Resources/CMake \
+                        -DCMAKE_VERBOSE_MAKEFILE=ON
+                  cmake --build CSFML-build --config Release --target install
 
-      - name: Build CSFML
+            - name: Create Archive
-        run: |
+              run: |
-          cmake -S CSFML -B CSFML-build -A ARM64 -G "Visual Studio 18 2026" -DBUILD_SHARED_LIBS=ON -DCSFML_LINK_SFML_STATICALLY=OFF -DCMAKE_BUILD_TYPE=Release "-DSFML_ROOT=$GITHUB_WORKSPACE/SFML-install" "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML-install" -DCMAKE_VERBOSE_MAKEFILE=ON
+                  mkdir CSFML-macOS-clang-arm64
-          cmake --build CSFML-build --config Release --target install
+                  cp -R CSFML-install/include CSFML-macOS-clang-arm64
+                  cp -R CSFML-install/lib CSFML-macOS-clang-arm64
+                  cp CSFML-install/share/CSFML/* CSFML-macOS-clang-arm64
+                  tar -zcvf CSFML-macOS-clang-arm64.tar.gz CSFML-macOS-clang-arm64
 
-      - name: Move Files
+            - name: Upload Artifact
-        shell: pwsh
+              uses: actions/upload-artifact@v4
-        run: |
+              with:
-          New-Item -ItemType "directory" -PATH "install\CSFML"
+                  name: CSFML-macOS-clang-arm64
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
+                  path: CSFML-macOS-clang-arm64.tar.gz
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: CSFML-windows-arm64
-          path: install/CSFML
-
-  macos-x64:
-    name: macOS x64
-    runs-on: macos-15
-
-    steps:
-      - name: Checkout SFML
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-          path: CSFML
-
-      - name: Build SFML
-        run: |
-          cmake -S SFML -B SFML-build -G "Unix Makefiles" \
-                -DCMAKE_C_COMPILER="/usr/bin/clang" \
-                -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
-                -DCMAKE_C_FLAGS="-stdlib=libc++" \
-                -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
-                -DBUILD_SHARED_LIBS=ON \
-                -DCMAKE_BUILD_TYPE=Release \
-                "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML-install" \
-                -DCMAKE_OSX_ARCHITECTURES=x86_64 \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
-                -DSFML_BUILD_FRAMEWORKS=OFF \
-                -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build SFML-build --config Release --target install
-
-      - name: Build CSFML
-        run: |
-          cmake -S CSFML -B CSFML-build -G "Unix Makefiles" \
-                -DCMAKE_C_COMPILER="/usr/bin/clang" \
-                -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
-                -DCMAKE_C_FLAGS="-stdlib=libc++" \
-                -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
-                -DBUILD_SHARED_LIBS=ON \
-                -DCMAKE_BUILD_TYPE=Release \
-                "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML-install" \
-                -DCMAKE_OSX_ARCHITECTURES=x86_64 \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
-                "-DSFML_ROOT=$GITHUB_WORKSPACE/SFML-install" \
-                -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build CSFML-build --config Release --target install
-
-      - name: Create Archive
-        run: |
-          mkdir CSFML-macOS-clang-64-bit
-          cp -R CSFML-install/include CSFML-macOS-clang-64-bit
-          cp -R CSFML-install/lib CSFML-macOS-clang-64-bit
-          cp CSFML-install/share/CSFML/* CSFML-macOS-clang-64-bit
-          tar -zcvf CSFML-macOS-clang-64-bit.tar.gz CSFML-macOS-clang-64-bit
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: CSFML-macOS-clang-64-bit
-          path: CSFML-macOS-clang-64-bit.tar.gz
-
-  macos-arm64:
-    name: macOS ARM64
-    runs-on: macos-15
-
-    steps:
-      - name: Checkout SFML
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-          path: CSFML
-      - name: Build SFML
-        run: |
-          cmake -S SFML -B SFML-build -G "Unix Makefiles" \
-                -DCMAKE_C_COMPILER="/usr/bin/clang" \
-                -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
-                -DCMAKE_C_FLAGS="-stdlib=libc++" \
-                -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
-                -DBUILD_SHARED_LIBS=ON \
-                -DCMAKE_BUILD_TYPE=Release \
-                "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML-install" \
-                -DCMAKE_OSX_ARCHITECTURES=arm64 \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 \
-                -DSFML_BUILD_FRAMEWORKS=OFF \
-                -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build SFML-build --config Release --target install
-
-      - name: Build CSFML
-        run: |
-          cmake -S CSFML -B CSFML-build -G "Unix Makefiles" \
-                -DCMAKE_C_COMPILER="/usr/bin/clang" \
-                -DCMAKE_CXX_COMPILER="/usr/bin/clang++" \
-                -DCMAKE_C_FLAGS="-stdlib=libc++" \
-                -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
-                -DBUILD_SHARED_LIBS=ON \
-                -DCMAKE_BUILD_TYPE=Release \
-                "-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML-install" \
-                -DCMAKE_OSX_ARCHITECTURES=arm64 \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 \
-                "-DSFML_ROOT=$GITHUB_WORKSPACE/SFML-install" \
-                -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build CSFML-build --config Release --target install
-
-      - name: Create Archive
-        run: |
-          mkdir CSFML-macOS-clang-arm64
-          cp -R CSFML-install/include CSFML-macOS-clang-arm64
-          cp -R CSFML-install/lib CSFML-macOS-clang-arm64
-          cp CSFML-install/share/CSFML/* CSFML-macOS-clang-arm64
-          tar -zcvf CSFML-macOS-clang-arm64.tar.gz CSFML-macOS-clang-arm64
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: CSFML-macOS-clang-arm64
-          path: CSFML-macOS-clang-arm64.tar.gz

.gitignore

@@ -1,7 +1,45 @@
-.cache/
+# Prerequisites
-.idea/
+*.d
-.vs/
+
-.vscode/
+# 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-*/
-CMakeUserPresets.json
+
+# Cache/IDE folders
+.cache/
+.vscode/
+.idea/
+.vs/
+
+# System files
+.DS_Store

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.22)
+cmake_minimum_required(VERSION 3.7.2)
 
 # define a macro that helps defining an option
 macro(csfml_set_option var default type docstring)
@@ -13,7 +13,7 @@ endmacro()
 csfml_set_option(CMAKE_BUILD_TYPE Release STRING "Choose the type of build (Debug or Release)")
 
 # project name
-project(CSFML VERSION 3.0.0)
+project(CSFML VERSION 2.6.1)
 
 # we use the paths from the cmake GNUInstallDirs module as defaults
 # you can override these if you like
@@ -24,64 +24,59 @@ include(GNUInstallDirs)
 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_WINDOW TRUE BOOL "TRUE 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_GRAPHICS TRUE BOOL "TRUE 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_AUDIO TRUE BOOL "TRUE to build CSFML's Audio module.")
-csfml_set_option(CSFML_BUILD_NETWORK ON BOOL "ON to build CSFML's Network module.")
+csfml_set_option(CSFML_BUILD_NETWORK TRUE BOOL "TRUE to build CSFML's Network module.")
 
 # add an option for choosing the build type (shared or static)
-csfml_set_option(BUILD_SHARED_LIBS ON BOOL "ON to build CSFML as shared libraries, OFF to build it as static libraries")
+csfml_set_option(BUILD_SHARED_LIBS TRUE BOOL "TRUE to build CSFML as shared libraries, FALSE to build it as static libraries")
 
 # add an option for building the API documentation
-csfml_set_option(CSFML_BUILD_DOC OFF BOOL "ON to generate the API documentation, OFF to ignore it")
+csfml_set_option(CSFML_BUILD_DOC FALSE BOOL "TRUE to generate the API documentation, FALSE 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 ON)
+    set(LINK_STATICALLY_DEFAULT TRUE)
 else()
-    set(LINK_STATICALLY_DEFAULT OFF)
+    set(LINK_STATICALLY_DEFAULT FALSE)
 endif()
-csfml_set_option(CSFML_LINK_SFML_STATICALLY ${LINK_STATICALLY_DEFAULT} BOOL "ON to link to a static version of SFML, OFF to link dynamically")
+csfml_set_option(CSFML_LINK_SFML_STATICALLY ${LINK_STATICALLY_DEFAULT} BOOL "TRUE to link to a static version of SFML, FALSE 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)
-    csfml_set_option(CSFML_USE_STATIC_STD_LIBS OFF BOOL "ON to statically link to the standard libraries, OFF to use them as DLLs")
+    set(STATIC_STD_LIBS FALSE CACHE BOOL "TRUE to statically link to the standard libraries, FALSE to use them as DLLs")
-endif()
 
-# find SFML libraries (C++)
+    # for VC++, we can apply it globally by modifying the compiler flags
-if(CSFML_LINK_SFML_STATICALLY)
+    if(SFML_COMPILER_MSVC AND STATIC_STD_LIBS)
-    set(SFML_STATIC_LIBRARIES ON)
+        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()
-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 COMPONENTS ${SFML_MODULES} REQUIRED)
 
 # add the subdirectories
-add_subdirectory(src/CSFML)
+add_subdirectory(src/SFML)
 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 OFF)
+set(CSFML_INSTALL_PKGCONFIG_DEFAULT FALSE)
 
 if(SFML_OS_LINUX OR SFML_OS_FREEBSD OR SFML_OS_OPENBSD OR SFML_OS_NETBSD)
-    set(CSFML_INSTALL_PKGCONFIG_DEFAULT ON)
+    set(CSFML_INSTALL_PKGCONFIG_DEFAULT TRUE)
 endif()
 
-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")
+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")
 
 if(CSFML_INSTALL_PKGCONFIG_FILES)
     csfml_set_option(CSFML_PKGCONFIG_INSTALL_DIR "${CSFML_PKGCONFIG_DIR}" PATH "Install directory for CSFML's pkg-config .pc files")
@@ -103,30 +98,8 @@ 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 OFF BOOL "ON to build the CSFML examples, OFF to ignore them")
+csfml_set_option(CSFML_BUILD_EXAMPLES FALSE BOOL "TRUE to build the CSFML examples, FALSE 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

@@ -1,19 +0,0 @@
-{
-  "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 target
+# Helper function to enable compiler warnings for a specific set of files
-function(set_target_warnings target)
+function(set_file_warnings)
-    option(CSFML_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
+    option(WARNINGS_AS_ERRORS "Treat compiler warnings as errors" FALSE)
 
     set(MSVC_WARNINGS
         /W4 # Baseline reasonable warnings
@@ -27,11 +27,13 @@ function(set_target_warnings target)
         /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
+        # /permissive- # standards conformance mode for MSVC compiler. Disabled until all out-of-the-box Windows SDKs can successfully build with it.
 
         # Disables, remove when appropriate
         /wd4996 # disable warnings about deprecated functions
-        /wd5105 # disable warning about expansion of 'defined' keyword
+        /wd4068 # disable warnings about unknown pragmas (e.g. #pragma GCC)
+        /wd4505 # disable warnings about unused functions that might be platform-specific
+        /wd4800 # disable warnings regarding implicit conversions to bool
     )
 
     set(CLANG_AND_GCC_WARNINGS
@@ -55,17 +57,18 @@ function(set_target_warnings target)
 
     # 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(CSFML_WARNINGS_AS_ERRORS OFF)
+        set(WARNINGS_AS_ERRORS FALSE)
     endif()
 
-    if(CSFML_WARNINGS_AS_ERRORS)
+    if(WARNINGS_AS_ERRORS)
-        list(APPEND CLANG_AND_GCC_WARNINGS -Werror)
+        set(CLANG_AND_GCC_WARNINGS ${CLANG_AND_GCC_WARNINGS} -Werror)
-        list(APPEND MSVC_WARNINGS /WX)
+        set(MSVC_WARNINGS ${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
@@ -79,7 +82,8 @@ function(set_target_warnings target)
     # 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)
-        list(APPEND GCC_WARNINGS
+        set(GCC_WARNINGS
+            ${GCC_WARNINGS}
             -Wduplicated-branches # warn if if / else branches have duplicated code
         )
     endif()
@@ -94,5 +98,7 @@ function(set_target_warnings target)
         message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
     endif()
 
-    target_compile_options(${target} PRIVATE ${FILE_WARNINGS})
+    foreach(WARNING ${FILE_WARNINGS})
+        set_property(SOURCE ${ARGV} APPEND_STRING PROPERTY COMPILE_FLAGS " ${WARNING}")
+    endforeach()
 endfunction()

cmake/Config.cmake

@@ -1,12 +1,32 @@
 # 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()
@@ -32,13 +52,24 @@ 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(WARNING "Unsupported compiler")
+    message(FATAL_ERROR "Unsupported compiler")
     return()
 endif()
 

cmake/Format.cmake

@@ -1,27 +0,0 @@
-# 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,38 +17,25 @@ macro(csfml_add_library target)
     target_include_directories(${target} PUBLIC ${PROJECT_SOURCE_DIR}/include)
 
     # add warnings
-    set_target_warnings(${target})
+    set_file_warnings(${THIS_SOURCES})
-
-    # 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(BUILD_SHARED_LIBS)
+    if(SFML_OS_WINDOWS)
+        # include the major version number in Windows shared library names (but not import library names)
         set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -d)
-        if(SFML_OS_WINDOWS)
+        set_target_properties(${target} PROPERTIES SUFFIX "-${PROJECT_VERSION_MAJOR}${CMAKE_SHARED_LIBRARY_SUFFIX}")
-            # 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 -s-d)
+        set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -d)
-        set_target_properties(${target} PROPERTIES RELEASE_POSTFIX -s)
+    endif()
-        set_target_properties(${target} PROPERTIES MINSIZEREL_POSTFIX -s)
+    if (SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-        set_target_properties(${target} PROPERTIES RELWITHDEBINFO_POSTFIX -s)
+        # on Windows/gcc get rid of "lib" prefix for shared libraries,
-
+        # and transform the ".dll.a" suffix into ".a" for import libraries
-        if(CSFML_USE_STATIC_STD_LIBS)
+        set_target_properties(${target} PROPERTIES PREFIX "")
-            set_property(TARGET ${target} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+        set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".a")
-        endif()
     endif()
 
     # set the version and soversion of the target (for compatible systems -- mostly Linuxes)
@@ -58,17 +45,20 @@ 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")
 
-    # apply the CSFML_USE_STATIC_STD_LIBS option if it is enabled
+    # for gcc >= 4.0 on Windows, apply the SFML_USE_STATIC_STD_LIBS option if it is enabled
-    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
+    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4")
-        if(CSFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
+        if(SFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-        elseif(NOT CSFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
+        elseif(NOT SFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
         endif()
     endif()
 
-    # ensure public symbols are hidden by default (exported ones are explicitly marked)
+    # if using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default
-    set_target_properties(${target} PROPERTIES CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
+    # (exported ones are explicitely marked)
+    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})
@@ -76,7 +66,9 @@ 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 INSTALL_NAME_DIR "@rpath")
+        set_target_properties(${target} PROPERTIES
+                              BUILD_WITH_INSTALL_RPATH 1
+                              INSTALL_NAME_DIR "@rpath")
     endif()
 
     # add the install rule
@@ -85,9 +77,4 @@ 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

@@ -1,34 +0,0 @@
-# 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,9 +1,12 @@
+
 # 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
@@ -15,30 +18,37 @@ if(SFML_OS_WINDOWS)
             set(DOXYGEN_GENERATE_HTMLHELP YES)
         else()
             message("Due to conflicts with the HTML output settings in Doxygen ${DOXYGEN_VERSION}, the HTML Help generation will be disabled")
+            set(DOXYGEN_GENERATE_HTMLHELP NO)
         endif()
+    else()
+        set(DOXYGEN_GENERATE_HTMLHELP NO)
     endif()
+else()
+    set(DOXYGEN_HHC_PROGRAM)
+    set(DOXYGEN_GENERATE_HTMLHELP NO)
 endif()
 
 # configure the source Doxyfile by copying it and replacing all @variables@
-configure_file(doxyfile.in doxyfile @ONLY)
+set(DOXYGEN_CONFIGURED_INPUT ${DOXYGEN_OUTPUT_DIR}/doxyfile)
-configure_file(header.html.in header.html @ONLY)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/doxyfile.in ${DOXYGEN_CONFIGURED_INPUT} @ONLY)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/header.html.in ${DOXYGEN_OUTPUT_DIR}/header.html @ONLY)
 
 # copy the files needed by the documentation
-configure_file(doxygen.css html/doxygen.css COPYONLY)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/doxygen.css ${DOXYGEN_OUTPUT_DIR}/html/doxygen.css COPYONLY)
-configure_file(searchOverrides.css html/searchOverrides.css COPYONLY)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/searchOverrides.css ${DOXYGEN_OUTPUT_DIR}/html/searchOverrides.css COPYONLY)
 
 # target setup
 add_custom_target(doc ALL
                   COMMAND ${CMAKE_COMMAND} -E echo_append "Building API Documentation..."
-                  COMMAND Doxygen::doxygen ${CMAKE_CURRENT_BINARY_DIR}/doxyfile
+                  COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CONFIGURED_INPUT}
                   COMMAND ${CMAKE_COMMAND} -E echo "Done."
-                  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
+                  WORKING_DIRECTORY ${DOXYGEN_INPUT_DIR})
 
 # setup install rules
-install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
+install(DIRECTORY ${DOXYGEN_OUTPUT_DIR}/html
         DESTINATION ${INSTALL_MISC_DIR}/doc
         COMPONENT doc)
-if(DOXYGEN_GENERATE_HTMLHELP)
+if(DOXYGEN_HHC_PROGRAM)
     install(FILES ${DOXYGEN_OUTPUT_DIR}/CSFML.chm
             DESTINATION ${INSTALL_MISC_DIR}/doc
             COMPONENT doc)

doc/doxyfile.in

@@ -74,7 +74,7 @@ PROJECT_ICON           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = "@CMAKE_CURRENT_BINARY_DIR@"
+OUTPUT_DIRECTORY       = "@DOXYGEN_OUTPUT_DIR@"
 
 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096
 # sub-directories (in 2 levels) under the output directory of each output format
@@ -199,7 +199,7 @@ STRIP_FROM_PATH        =
 # specify the list of include paths that are normally passed to the compiler
 # using the -I flag.
 
-STRIP_FROM_INC_PATH    = "@PROJECT_SOURCE_DIR@/include"
+STRIP_FROM_INC_PATH    = "@DOXYGEN_INPUT_DIR@/include"
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
 # less readable) file names. This can be useful is your file systems doesn't
@@ -924,7 +924,7 @@ WARN_IF_UNDOC_ENUM_VAL = NO
 # Possible values are: NO, YES, FAIL_ON_WARNINGS and FAIL_ON_WARNINGS_PRINT.
 # The default value is: NO.
 
-WARN_AS_ERROR          = YES
+WARN_AS_ERROR          = NO
 
 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
 # can produce. The string should contain the $file, $line, and $text tags, which
@@ -966,8 +966,8 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = "@PROJECT_SOURCE_DIR@/include/CSFML" \
+INPUT                  = "@DOXYGEN_INPUT_DIR@/include/SFML" \
-                         "@PROJECT_SOURCE_DIR@/doc/mainpage.hpp"
+                         "@DOXYGEN_INPUT_DIR@/doc/mainpage.hpp"
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -1341,7 +1341,7 @@ HTML_FILE_EXTENSION    = .html
 # of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_HEADER            = "@CMAKE_CURRENT_BINARY_DIR@/header.html"
+HTML_HEADER            = "@DOXYGEN_OUTPUT_DIR@/header.html"
 
 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
 # generated HTML page. If the tag is left blank doxygen will generate a standard
@@ -1351,7 +1351,7 @@ HTML_HEADER            = "@CMAKE_CURRENT_BINARY_DIR@/header.html"
 # that doxygen normally uses.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_FOOTER            = "@PROJECT_SOURCE_DIR@/doc/footer.html"
+HTML_FOOTER            = "@DOXYGEN_INPUT_DIR@/doc/footer.html"
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
 # sheet that is used by each HTML page. It can be used to fine-tune the look of
@@ -1363,7 +1363,7 @@ HTML_FOOTER            = "@PROJECT_SOURCE_DIR@/doc/footer.html"
 # obsolete.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_STYLESHEET        = "@PROJECT_SOURCE_DIR@/doc/doxygen.css"
+HTML_STYLESHEET        = "@DOXYGEN_INPUT_DIR@/doc/doxygen.css"
 
 # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
 # cascading style sheets that are included after the standard style sheets
@@ -2491,7 +2491,7 @@ TAGFILES               =
 # tag file that is based on the input files it reads. See section "Linking to
 # external documentation" for more information about the usage of tag files.
 
-GENERATE_TAGFILE       = @CMAKE_CURRENT_BINARY_DIR@/CSFML.tag
+GENERATE_TAGFILE       = @DOXYGEN_OUTPUT_DIR@/CSFML.tag
 
 # If the ALLEXTERNALS tag is set to YES, all external classes and namespaces
 # will be listed in the class and namespace index. If set to NO, only the

doc/mainpage.hpp

@@ -12,12 +12,12 @@
 ///
 /// \code
 ///
-/// #include <CSFML/Audio.h>
+/// #include <SFML/Audio.h>
-/// #include <CSFML/Graphics.h>
+/// #include <SFML/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, true);
+///     sfSprite_setTexture(sprite, texture, sfTrue);
-///
+/// 
 ///     /* 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

examples/CMakeLists.txt

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

examples/example.c

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

include/CSFML/Audio.h

@@ -1,39 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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

@@ -1,106 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/SoundChannel.h

@@ -1,60 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/SoundSourceCone.h

@@ -1,43 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 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.
-///
-////////////////////////////////////////////////////////////
-typedef struct
-{
-    float innerAngle; //!< Inner angle, in degrees
-    float outerAngle; //!< Outer angle, in degrees
-    float outerGain;  //!< Outer gain
-} sfSoundSourceCone;

include/CSFML/Audio/SoundStream.h

@@ -1,618 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/Config.h

@@ -1,161 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/Graphics.h

@@ -1,56 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/BlendMode.h>
-#include <CSFML/Graphics/CircleShape.h>
-#include <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/ConvexShape.h>
-#include <CSFML/Graphics/Font.h>
-#include <CSFML/Graphics/FontInfo.h>
-#include <CSFML/Graphics/Glyph.h>
-#include <CSFML/Graphics/Image.h>
-#include <CSFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/RectangleShape.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/CoordinateType.h

@@ -1,35 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/StencilMode.h

@@ -1,96 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/Network.h

@@ -1,40 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/System.h

@@ -1,39 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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/SFML/Audio.h

@@ -0,0 +1,43 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_AUDIO_H
+#define SFML_AUDIO_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <SFML/System.h>
+#include <SFML/Audio/Listener.h>
+#include <SFML/Audio/Music.h>
+#include <SFML/Audio/Sound.h>
+#include <SFML/Audio/SoundBuffer.h>
+#include <SFML/Audio/SoundBufferRecorder.h>
+#include <SFML/Audio/SoundRecorder.h>
+#include <SFML/Audio/SoundStatus.h>
+#include <SFML/Audio/SoundStream.h>
+
+
+#endif // SFML_AUDIO_H

include/SFML/Audio/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_AUDIO_EXPORT_H
+#define SFML_AUDIO_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -35,10 +36,13 @@
 ////////////////////////////////////////////////////////////
 #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/SFML/Audio/Listener.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,33 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_LISTENER_H
+#define SFML_LISTENER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/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;
 
 
 ////////////////////////////////////////////////////////////
@@ -112,43 +93,6 @@ 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
 ///
@@ -171,3 +115,6 @@ CSFML_AUDIO_API void sfListener_setUpVector(sfVector3f upVector);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfVector3f sfListener_getUpVector(void);
+
+
+#endif // SFML_LISTENER_H

include/SFML/Audio/Music.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_MUSIC_H
+#define SFML_MUSIC_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/Audio/Export.h>
-
+#include <SFML/Audio/SoundStatus.h>
-#include <CSFML/Audio/EffectProcessor.h>
+#include <SFML/Audio/Types.h>
-#include <CSFML/Audio/SoundChannel.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/Audio/SoundSourceCone.h>
+#include <SFML/System/Time.h>
-#include <CSFML/Audio/SoundStatus.h>
+#include <SFML/System/Vector3.h>
-#include <CSFML/Audio/Types.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Time.h>
-#include <CSFML/System/Vector3.h>
-
 #include <stddef.h>
 
 
@@ -107,43 +103,31 @@ CSFML_AUDIO_API sfMusic* sfMusic_createFromStream(sfInputStream* stream);
 /// \param music Music to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_destroy(const sfMusic* music);
+CSFML_AUDIO_API void sfMusic_destroy(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_setLooping(music, false) is called.
+/// sfMusic_setLoop(music, sfFalse) is called.
 /// The default looping state for musics is false.
 ///
 /// \param music Music object
-/// \param loop  true to play in loop, false to play once
+/// \param loop  sfTrue to play in loop, sfFalse to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setLooping(sfMusic* music, bool loop);
+CSFML_AUDIO_API void sfMusic_setLoop(sfMusic* music, sfBool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a music is in loop mode
 ///
 /// \param music Music object
 ///
-/// \return true if the music is looping, false otherwise
+/// \return sfTrue if the music is looping, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfMusic_isLooping(const sfMusic* music);
+CSFML_AUDIO_API sfBool sfMusic_getLoop(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
@@ -158,8 +142,6 @@ 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
@@ -175,7 +157,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 sfTime
+/// \brief Sets the beginning and end of the sound's looping sequence using sf::Time
 ///
 /// 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
@@ -189,7 +171,6 @@ 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
@@ -259,20 +240,6 @@ 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)
 ///
@@ -308,20 +275,6 @@ 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
 ///
@@ -334,20 +287,6 @@ CSFML_AUDIO_API void sfMusic_setPan(sfMusic* music, float pan);
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -361,74 +300,6 @@ CSFML_AUDIO_API void sfMusic_setSpatializationEnabled(sfMusic* music, bool enabl
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -439,10 +310,10 @@ CSFML_AUDIO_API void sfMusic_setDirectionalAttenuationFactor(sfMusic* music, flo
 /// The default value is false (position is absolute).
 ///
 /// \param music    Music object
-/// \param relative true to set the position relative, false to set it absolute
+/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, bool relative);
+CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, sfBool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a music
@@ -460,48 +331,6 @@ CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, bool relative
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -542,26 +371,6 @@ 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
 ///
@@ -582,66 +391,16 @@ 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 true if the position is relative, false if it's absolute
+/// \return sfTrue if the position is relative, sfFalse if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfMusic_isRelativeToListener(const sfMusic* music);
+CSFML_AUDIO_API sfBool sfMusic_isRelativeToListener(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a music
@@ -653,36 +412,6 @@ CSFML_AUDIO_API bool 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
 ///
@@ -692,3 +421,6 @@ CSFML_AUDIO_API float sfMusic_getMaxGain(const sfMusic* music);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API float sfMusic_getAttenuation(const sfMusic* music);
+
+
+#endif // SFML_MUSIC_H

include/SFML/Audio/Sound.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,30 +22,26 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOUND_H
+#define SFML_SOUND_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/Audio/Export.h>
-
+#include <SFML/Audio/SoundStatus.h>
-#include <CSFML/Audio/EffectProcessor.h>
+#include <SFML/Audio/Types.h>
-#include <CSFML/Audio/SoundSourceCone.h>
+#include <SFML/System/Time.h>
-#include <CSFML/Audio/SoundStatus.h>
+#include <SFML/System/Vector3.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(const sfSoundBuffer* buffer);
+CSFML_AUDIO_API sfSound* sfSound_create(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound by copying an existing one
@@ -63,7 +59,7 @@ CSFML_AUDIO_API sfSound* sfSound_copy(const sfSound* sound);
 /// \param sound Sound to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_destroy(const sfSound* sound);
+CSFML_AUDIO_API void sfSound_destroy(sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start or resume playing a sound
@@ -130,24 +126,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_setLooping(sound, false) is called.
+/// sfSound_setLoop(sound, sfFalse) is called.
 /// The default looping state for sounds is false.
 ///
 /// \param sound Sound object
-/// \param loop  true to play in loop, false to play once
+/// \param loop  sfTrue to play in loop, sfFalse to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setLooping(sfSound* sound, bool loop);
+CSFML_AUDIO_API void sfSound_setLoop(sfSound* sound, sfBool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a sound is in loop mode
 ///
 /// \param sound Sound object
 ///
-/// \return true if the sound is looping, false otherwise
+/// \return sfTrue if the sound is looping, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSound_isLooping(const sfSound* sound);
+CSFML_AUDIO_API sfBool sfSound_getLoop(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current status of a sound (stopped, paused, playing)
@@ -174,21 +170,6 @@ 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
 ///
@@ -201,20 +182,6 @@ CSFML_AUDIO_API void sfSound_setPan(sfSound* sound, float pan);
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -228,74 +195,6 @@ CSFML_AUDIO_API void sfSound_setSpatializationEnabled(sfSound* sound, bool enabl
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -306,10 +205,10 @@ CSFML_AUDIO_API void sfSound_setDirectionalAttenuationFactor(sfSound* sound, flo
 /// The default value is false (position is absolute).
 ///
 /// \param sound    Sound object
-/// \param relative true to set the position relative, false to set it absolute
+/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, bool relative);
+CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, sfBool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a sound
@@ -327,49 +226,6 @@ CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, bool relative
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -400,18 +256,6 @@ 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
 ///
@@ -422,16 +266,6 @@ CSFML_AUDIO_API void sfSound_setEffectProcessor(sfSound* sound, sfEffectProcesso
 ////////////////////////////////////////////////////////////
 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
 ///
@@ -442,16 +276,6 @@ CSFML_AUDIO_API float sfSound_getPan(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
 ///
@@ -462,66 +286,16 @@ CSFML_AUDIO_API bool sfSound_isSpatializationEnabled(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 true if the position is relative, false if it's absolute
+/// \return sfTrue if the position is relative, sfFalse if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSound_isRelativeToListener(const sfSound* sound);
+CSFML_AUDIO_API sfBool sfSound_isRelativeToListener(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a sound
@@ -533,36 +307,6 @@ CSFML_AUDIO_API bool 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
 ///
@@ -582,3 +326,6 @@ CSFML_AUDIO_API float sfSound_getAttenuation(const sfSound* sound);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfTime sfSound_getPlayingOffset(const sfSound* sound);
+
+
+#endif // SFML_SOUND_H

include/SFML/Audio/SoundBuffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOUNDBUFFER_H
+#define SFML_SOUNDBUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/Audio/Export.h>
-
+#include <SFML/Audio/Types.h>
-#include <CSFML/Audio/SoundChannel.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/Audio/Types.h>
+#include <SFML/System/Time.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Time.h>
-
 #include <stddef.h>
 
 
@@ -84,25 +82,17 @@ 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
-/// (int16_t).
+/// (sfInt16).
 ///
-/// \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(
+CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(const sfInt16* samples, sfUint64 sampleCount, unsigned int channelCount, unsigned int sampleRate);
-    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
@@ -120,7 +110,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_copy(const sfSoundBuffer* soundBuff
 /// \param soundBuffer Sound buffer to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundBuffer_destroy(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save a sound buffer to an audio file
@@ -132,16 +122,16 @@ CSFML_AUDIO_API void sfSoundBuffer_destroy(const sfSoundBuffer* soundBuffer);
 /// \param soundBuffer Sound buffer object
 /// \param filename    Path of the sound file to write
 ///
-/// \return true if saving succeeded, false if it failed
+/// \return sfTrue if saving succeeded, sfFalse if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
+CSFML_AUDIO_API sfBool 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
-/// (int16_t). The total number of samples in this array
+/// (sfInt16). The total number of samples in this array
 /// is given by the sfSoundBuffer_getSampleCount function.
 ///
 /// \param soundBuffer Sound buffer object
@@ -149,7 +139,7 @@ CSFML_AUDIO_API bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer,
 /// \return Read-only pointer to the array of sound samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the number of samples stored in a sound buffer
@@ -162,7 +152,7 @@ CSFML_AUDIO_API const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* sou
 /// \return Number of samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API uint64_t sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API sfUint64 sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the sample rate of a sound buffer
@@ -191,20 +181,6 @@ 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
 ///
@@ -214,3 +190,6 @@ CSFML_AUDIO_API sfSoundChannel* sfSoundBuffer_getChannelMap(const sfSoundBuffer*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API sfTime sfSoundBuffer_getDuration(const sfSoundBuffer* soundBuffer);
+
+
+#endif // SFML_SOUNDBUFFER_H

include/SFML/Audio/SoundBufferRecorder.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOUNDBUFFERRECORDER_H
+#define SFML_SOUNDBUFFERRECORDER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/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(const sfSoundBufferRecorder* soundBufferRecorder);
+CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundBufferRecorder);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start the capture of a sound recorder recorder
@@ -61,10 +61,10 @@ CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(const sfSoundBufferRecorder*
 /// \param soundBufferRecorder Sound buffer recorder object
 /// \param sampleRate          Desired capture rate, in number of samples per second
 ///
-/// \return true, if it was able to start recording
+/// \return sfTrue, if it was able to start recording
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API sfBool 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 true, if it was able to set the requested device
+/// \return sfTrue, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
+CSFML_AUDIO_API sfBool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device
@@ -129,34 +129,5 @@ CSFML_AUDIO_API bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soun
 ////////////////////////////////////////////////////////////
 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/SFML/Audio/SoundRecorder.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,21 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOUNDRECORDER_H
+#define SFML_SOUNDRECORDER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/Audio/Export.h>
-
+#include <SFML/Audio/Types.h>
-#include <CSFML/Audio/SoundChannel.h>
+#include <SFML/System/Time.h>
-#include <CSFML/Audio/Types.h>
-#include <CSFML/System/Time.h>
-
 #include <stddef.h>
 
 
-typedef bool (*sfSoundRecorderStartCallback)(void*); ///< Type of the callback used when starting a capture
+typedef sfBool (*sfSoundRecorderStartCallback)(void*);                           ///< Type of the callback used when starting a capture
-typedef bool (*sfSoundRecorderProcessCallback)(const int16_t*, size_t, void*); ///< Type of the callback used to process audio data
+typedef sfBool (*sfSoundRecorderProcessCallback)(const sfInt16*, 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
 
 
 ////////////////////////////////////////////////////////////
@@ -63,7 +61,7 @@ CSFML_AUDIO_API sfSoundRecorder* sfSoundRecorder_create(sfSoundRecorderStartCall
 /// \param soundRecorder Sound recorder to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundRecorder_destroy(const sfSoundRecorder* soundRecorder);
+CSFML_AUDIO_API void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder);
 
 ////////////////////////////////////////////////////////////
 /// \brief Start the capture of a sound recorder
@@ -81,7 +79,7 @@ CSFML_AUDIO_API void sfSoundRecorder_destroy(const sfSoundRecorder* soundRecorde
 /// \return True, if start of capture was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API sfBool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Stop the capture of a sound recorder
@@ -112,10 +110,29 @@ 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 true if audio capture is supported, false otherwise
+/// \return sfTrue if audio capture is supported, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundRecorder_isAvailable(void);
+CSFML_AUDIO_API sfBool sfSoundRecorder_isAvailable(void);
+
+////////////////////////////////////////////////////////////
+/// \brief Set the processing interval
+///
+/// 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 available audio capture devices
@@ -129,7 +146,7 @@ CSFML_AUDIO_API bool sfSoundRecorder_isAvailable(void);
 /// \return An array of strings containing the names
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const char* const* sfSoundRecorder_getAvailableDevices(size_t* count);
+CSFML_AUDIO_API const char** sfSoundRecorder_getAvailableDevices(size_t* count);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the default audio capture device
@@ -153,10 +170,10 @@ CSFML_AUDIO_API const char* sfSoundRecorder_getDefaultDevice(void);
 /// \param soundRecorder Sound recorder object
 /// \param name          The name of the audio capture device
 ///
-/// \return true, if it was able to set the requested device
+/// \return sfTrue, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API bool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
+CSFML_AUDIO_API sfBool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device
@@ -175,9 +192,8 @@ CSFML_AUDIO_API const char* sfSoundRecorder_getDevice(sfSoundRecorder* soundReco
 /// used for recording. Currently only 16-bit mono and
 /// 16-bit stereo are supported.
 ///
-/// \param soundRecorder Sound recorder object
+/// \param channelCount Number of channels. Currently only
-/// \param channelCount  Number of channels. Currently only
+///                     mono (1) and stereo (2) are supported.
-///                      mono (1) and stereo (2) are supported.
 ///
 /// \see sfSoundRecorder_getChannelCount
 ///
@@ -197,16 +213,5 @@ CSFML_AUDIO_API void sfSoundRecorder_setChannelCount(sfSoundRecorder* soundRecor
 ////////////////////////////////////////////////////////////
 CSFML_AUDIO_API unsigned int sfSoundRecorder_getChannelCount(const sfSoundRecorder* soundRecorder);
 
-////////////////////////////////////////////////////////////
+
-/// \brief Get the map of position in sample frame to sound channel
+#endif // SFML_SOUNDRECORDER_H
-///
-/// 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/SFML/Audio/SoundStatus.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOUNDSTATUS_H
+#define SFML_SOUNDSTATUS_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Audio/Export.h>
+#include <SFML/Audio/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -40,3 +41,6 @@ typedef enum
     sfPaused,  ///< Sound / music is paused
     sfPlaying  ///< Sound / music is playing
 } sfSoundStatus;
+
+
+#endif // SFML_SOUNDSTATUS_H

include/SFML/Audio/SoundStream.h

@@ -0,0 +1,347 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SOUNDSTREAM_H
+#define SFML_SOUNDSTREAM_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Audio/Export.h>
+#include <SFML/Audio/SoundStatus.h>
+#include <SFML/Audio/Types.h>
+#include <SFML/System/Time.h>
+#include <SFML/System/Vector3.h>
+
+
+////////////////////////////////////////////////////////////
+/// \brief defines the data to fill by the OnGetData callback
+///
+////////////////////////////////////////////////////////////
+typedef struct
+{
+    sfInt16*     samples;     ///< Pointer to the audio samples
+    unsigned int sampleCount; ///< Number of samples pointed by Samples
+} sfSoundStreamChunk;
+
+typedef sfBool (*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 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,
+                                              void*                        userData);
+
+////////////////////////////////////////////////////////////
+/// \brief Destroy a sound stream
+///
+/// \param soundStream Sound stream to destroy
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_destroy(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 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 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 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 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    sfTrue to set the position relative, sfFalse to set it absolute
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, sfBool 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 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_setLoop(stream, sfFalse) is called.
+/// The default looping state for sound streams is false.
+///
+/// \param soundStream Sound stream object
+/// \param loop        sfTrue to play in loop, sfFalse to play once
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API void sfSoundStream_setLoop(sfSoundStream* soundStream, sfBool 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 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 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 Tell whether a sound stream's position is relative to the
+///        listener or is absolute
+///
+/// \param soundStream Sound stream object
+///
+/// \return sfTrue if the position is relative, sfFalse if it's absolute
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfBool 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 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 sfTrue if the music is looping, sfFalse otherwise
+///
+////////////////////////////////////////////////////////////
+CSFML_AUDIO_API sfBool sfSoundStream_getLoop(const sfSoundStream* soundStream);
+
+////////////////////////////////////////////////////////////
+/// \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);
+
+
+#endif // SFML_SOUNDSTREAM_H

include/SFML/Audio/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,11 +22,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_AUDIO_TYPES_H
+#define SFML_AUDIO_TYPES_H
 
-typedef struct sfMusic               sfMusic;
+
-typedef struct sfSound               sfSound;
+typedef struct sfMusic sfMusic;
-typedef struct sfSoundBuffer         sfSoundBuffer;
+typedef struct sfSound sfSound;
+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/SFML/Config.h

@@ -0,0 +1,188 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_CONFIG_H
+#define SFML_CONFIG_H
+
+
+////////////////////////////////////////////////////////////
+// Define the CSFML version
+////////////////////////////////////////////////////////////
+#define CSFML_VERSION_MAJOR 2
+#define CSFML_VERSION_MINOR 6
+#define CSFML_VERSION_PATCH 1
+
+
+////////////////////////////////////////////////////////////
+// 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_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
+
+    #if __GNUC__ >= 4
+
+        // GCC 4 has special keywords for showing/hidding symbols,
+        // the same keyword is used for both importing and exporting
+        #define CSFML_API_EXPORT extern "C" __attribute__ ((__visibility__ ("default")))
+        #define CSFML_API_IMPORT CSFML_EXTERN_C __attribute__ ((__visibility__ ("default")))
+
+    #else
+
+        // GCC < 4 has no mechanism to explicitely hide symbols, everything's exported
+        #define CSFML_API_EXPORT extern "C"
+        #define CSFML_API_IMPORT CSFML_EXTERN_C
+
+    #endif
+
+#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 a portable boolean type
+////////////////////////////////////////////////////////////
+typedef int sfBool;
+#define sfFalse 0
+#define sfTrue  1
+
+
+////////////////////////////////////////////////////////////
+// Define portable fixed-size types
+////////////////////////////////////////////////////////////
+
+// All "common" platforms use the same size for char, short and int
+// (basically there are 3 types for 3 sizes, so no other match is possible),
+// we can use them without doing any kind of check
+
+// 8 bits integer types
+typedef signed   char sfInt8;
+typedef unsigned char sfUint8;
+
+// 16 bits integer types
+typedef signed   short sfInt16;
+typedef unsigned short sfUint16;
+
+// 32 bits integer types
+typedef signed   int sfInt32;
+typedef unsigned int sfUint32;
+
+// 64 bits integer types
+#if defined(_MSC_VER)
+    typedef signed   __int64 sfInt64;
+    typedef unsigned __int64 sfUint64;
+#else
+    typedef signed   long long sfInt64;
+    typedef unsigned long long sfUint64;
+#endif
+
+
+#endif // SFML_CONFIG_H

include/SFML/GPUPreference.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GPUPREFERENCE_H
+#define SFML_GPUPREFERENCE_H
+
 
 ////////////////////////////////////////////////////////////
 /// Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -58,12 +60,15 @@
 ////////////////////////////////////////////////////////////
 #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/SFML/Graphics.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,39 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GRAPHICS_H
+#define SFML_GRAPHICS_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
 
-#include <CSFML/System.h>
+#include <SFML/Window.h>
-#include <CSFML/Window/Clipboard.h>
+#include <SFML/Graphics/BlendMode.h>
-#include <CSFML/Window/Context.h>
+#include <SFML/Graphics/CircleShape.h>
-#include <CSFML/Window/Cursor.h>
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Window/Event.h>
+#include <SFML/Graphics/ConvexShape.h>
-#include <CSFML/Window/Joystick.h>
+#include <SFML/Graphics/Font.h>
-#include <CSFML/Window/JoystickIdentification.h>
+#include <SFML/Graphics/FontInfo.h>
-#include <CSFML/Window/Keyboard.h>
+#include <SFML/Graphics/Glyph.h>
-#include <CSFML/Window/Mouse.h>
+#include <SFML/Graphics/Image.h>
-#include <CSFML/Window/Sensor.h>
+#include <SFML/Graphics/PrimitiveType.h>
-#include <CSFML/Window/Touch.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Window/VideoMode.h>
+#include <SFML/Graphics/RectangleShape.h>
-#include <CSFML/Window/Window.h>
+#include <SFML/Graphics/RenderStates.h>
+#include <SFML/Graphics/RenderTexture.h>
+#include <SFML/Graphics/RenderWindow.h>
+#include <SFML/Graphics/Shader.h>
+#include <SFML/Graphics/Shape.h>
+#include <SFML/Graphics/Sprite.h>
+#include <SFML/Graphics/Text.h>
+#include <SFML/Graphics/Texture.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Transformable.h>
+#include <SFML/Graphics/Vertex.h>
+#include <SFML/Graphics/VertexArray.h>
+#include <SFML/Graphics/VertexBuffer.h>
+#include <SFML/Graphics/View.h>
+
+
+#endif // SFML_GRAPHICS_H

include/SFML/Graphics/BlendMode.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_BLENDMODE_H
+#define SFML_BLENDMODE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -69,12 +70,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;
 
 
@@ -84,3 +85,6 @@ 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/SFML/Graphics/CircleShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_CIRCLESHAPE_H
+#define SFML_CIRCLESHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-
 #include <stddef.h>
 
 
@@ -62,7 +61,7 @@ CSFML_GRAPHICS_API sfCircleShape* sfCircleShape_copy(const sfCircleShape* shape)
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfCircleShape_destroy(const sfCircleShape* shape);
+CSFML_GRAPHICS_API void sfCircleShape_destroy(sfCircleShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a circle shape
@@ -236,7 +235,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, bool resetRect);
+CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, sfBool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a circle shape will display
@@ -369,20 +368,6 @@ 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
 ///
@@ -442,3 +427,6 @@ CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getLocalBounds(const sfCircleShape*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getGlobalBounds(const sfCircleShape* shape);
+
+
+#endif // SFML_CIRCLESHAPE_H

include/SFML/Graphics/Color.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_COLOR_H
+#define SFML_COLOR_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,22 +37,22 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    uint8_t r;
+    sfUint8 r;
-    uint8_t g;
+    sfUint8 g;
-    uint8_t b;
+    sfUint8 b;
-    uint8_t a;
+    sfUint8 a;
 } sfColor;
 
 
-CSFML_GRAPHICS_API const sfColor sfBlack;       ///< Black predefined color
+CSFML_GRAPHICS_API sfColor sfBlack;       ///< Black predefined color
-CSFML_GRAPHICS_API const sfColor sfWhite;       ///< White predefined color
+CSFML_GRAPHICS_API sfColor sfWhite;       ///< White predefined color
-CSFML_GRAPHICS_API const sfColor sfRed;         ///< Red predefined color
+CSFML_GRAPHICS_API sfColor sfRed;         ///< Red predefined color
-CSFML_GRAPHICS_API const sfColor sfGreen;       ///< Green predefined color
+CSFML_GRAPHICS_API sfColor sfGreen;       ///< Green predefined color
-CSFML_GRAPHICS_API const sfColor sfBlue;        ///< Blue predefined color
+CSFML_GRAPHICS_API sfColor sfBlue;        ///< Blue predefined color
-CSFML_GRAPHICS_API const sfColor sfYellow;      ///< Yellow predefined color
+CSFML_GRAPHICS_API sfColor sfYellow;      ///< Yellow predefined color
-CSFML_GRAPHICS_API const sfColor sfMagenta;     ///< Magenta predefined color
+CSFML_GRAPHICS_API sfColor sfMagenta;     ///< Magenta predefined color
-CSFML_GRAPHICS_API const sfColor sfCyan;        ///< Cyan predefined color
+CSFML_GRAPHICS_API sfColor sfCyan;        ///< Cyan predefined color
-CSFML_GRAPHICS_API const sfColor sfTransparent; ///< Transparent (black) predefined color
+CSFML_GRAPHICS_API sfColor sfTransparent; ///< Transparent (black) predefined color
 
 
 ////////////////////////////////////////////////////////////
@@ -64,7 +65,7 @@ CSFML_GRAPHICS_API const sfColor sfTransparent; ///< Transparent (black) predefi
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a color from its 4 RGBA components
@@ -77,7 +78,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t b
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct the color from 32-bit unsigned integer
@@ -87,7 +88,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t
 /// \return sfColor constructed from the 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromInteger(uint32_t color);
+CSFML_GRAPHICS_API sfColor sfColor_fromInteger(sfUint32 color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a color to a 32-bit unsigned integer
@@ -95,7 +96,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromInteger(uint32_t color);
 /// \return Color represented as a 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API uint32_t sfColor_toInteger(sfColor color);
+CSFML_GRAPHICS_API sfUint32 sfColor_toInteger(sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Add two colors
@@ -129,3 +130,6 @@ 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/SFML/Graphics/ConvexShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_CONVEXSHAPE_H
+#define SFML_CONVEXSHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-
 #include <stddef.h>
 
 
@@ -62,7 +61,7 @@ CSFML_GRAPHICS_API sfConvexShape* sfConvexShape_copy(const sfConvexShape* shape)
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfConvexShape_destroy(const sfConvexShape* shape);
+CSFML_GRAPHICS_API void sfConvexShape_destroy(sfConvexShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a convex shape
@@ -236,7 +235,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, bool resetRect);
+CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, sfBool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a convex shape will display
@@ -369,20 +368,6 @@ 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
 ///
@@ -404,7 +389,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
 ///
 ////////////////////////////////////////////////////////////
@@ -441,3 +426,6 @@ CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getLocalBounds(const sfConvexShape*
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getGlobalBounds(const sfConvexShape* shape);
+
+
+#endif // SFML_CONVEXSHAPE_H

include/SFML/Graphics/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GRAPHICS_EXPORT_H
+#define SFML_GRAPHICS_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -35,10 +36,13 @@
 ////////////////////////////////////////////////////////////
 #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/SFML/Graphics/Font.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_FONT_H
+#define SFML_FONT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/FontInfo.h>
-#include <CSFML/Graphics/FontInfo.h>
+#include <SFML/Graphics/Glyph.h>
-#include <CSFML/Graphics/Glyph.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/System/InputStream.h>
-
 #include <stddef.h>
 
 
@@ -84,7 +83,7 @@ CSFML_GRAPHICS_API sfFont* sfFont_copy(const sfFont* font);
 /// \param font Font to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_destroy(const sfFont* font);
+CSFML_GRAPHICS_API void sfFont_destroy(sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a glyph in a font
@@ -98,8 +97,7 @@ CSFML_GRAPHICS_API void sfFont_destroy(const sfFont* font);
 /// \return The corresponding glyph
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfGlyph
+CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold, float outlineThickness);
-    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
@@ -115,10 +113,10 @@ CSFML_GRAPHICS_API sfGlyph
 /// \param font      Source font
 /// \param codePoint Unicode code point to check
 ///
-/// \return True if the codepoint has a glyph representation, sfFalse otherwise
+/// \return sfTrue if the codepoint has a glyph representation, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFont_hasGlyph(const sfFont* font, uint32_t codePoint);
+CSFML_GRAPHICS_API sfBool sfFont_hasGlyph(const sfFont* font, sfUint32 codePoint);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the kerning value corresponding to a given pair of characters in a font
@@ -131,7 +129,7 @@ CSFML_GRAPHICS_API bool sfFont_hasGlyph(const sfFont* font, uint32_t codePoint);
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the bold kerning value corresponding to a given pair of characters in a font
@@ -144,7 +142,7 @@ CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, uint32_t first, u
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the line spacing value
@@ -205,24 +203,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        true to enable smoothing, false to disable it
+/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
 ///
 /// \see isSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, bool smooth);
+CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, sfBool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or disabled
 ///
 /// \param font          Source font
 ///
-/// \return true if smoothing is enabled, false if it is disabled
+/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
 ///
 /// \see setSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFont_isSmooth(const sfFont* font);
+CSFML_GRAPHICS_API sfBool sfFont_isSmooth(const sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font information
@@ -237,3 +235,6 @@ CSFML_GRAPHICS_API bool sfFont_isSmooth(const sfFont* font);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFontInfo sfFont_getInfo(const sfFont* font);
+
+
+#endif // SFML_FONT_H

include/SFML/Graphics/FontInfo.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_FONTINFO_H
+#define SFML_FONTINFO_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
 
 ////////////////////////////////////////////////////////////
 /// sfFontInfo holds various information about a font
@@ -36,3 +37,6 @@ typedef struct
 {
     const char* family;
 } sfFontInfo;
+
+
+#endif // SFML_FONTINFO_H

include/SFML/Graphics/Glsl.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GLSL_H
+#define SFML_GLSL_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Color.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector3.h>
+#include <SFML/System/Vector3.h>
 
 // 2D vectors
 typedef sfVector2f sfGlslVec2;
@@ -38,8 +39,8 @@ typedef sfVector2i sfGlslIvec2;
 
 typedef struct
 {
-    bool x;
+    sfBool x;
-    bool y;
+    sfBool y;
 } sfGlslBvec2;
 
 // 3D vectors
@@ -54,9 +55,9 @@ typedef struct
 
 typedef struct
 {
-    bool x;
+    sfBool x;
-    bool y;
+    sfBool y;
-    bool z;
+    sfBool z;
 } sfGlslBvec3;
 
 // 4D vectors
@@ -78,10 +79,10 @@ typedef struct
 
 typedef struct
 {
-    bool x;
+    sfBool x;
-    bool y;
+    sfBool y;
-    bool z;
+    sfBool z;
-    bool w;
+    sfBool w;
 } sfGlslBvec4;
 
 // matrices
@@ -94,3 +95,6 @@ typedef struct
 {
     float array[4 * 4];
 } sfGlslMat4;
+
+
+#endif // SFML_GLSL_H

include/SFML/Graphics/Glyph.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GLYPH_H
+#define SFML_GLYPH_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Rect.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -40,3 +41,6 @@ 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/SFML/Graphics/Image.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_IMAGE_H
+#define SFML_IMAGE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Buffer.h>
-#include <CSFML/System/Buffer.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-
 #include <stddef.h>
 
 
@@ -44,23 +43,25 @@
 ///
 /// This image is filled with black pixels.
 ///
-/// \param size Size of the image
+/// \param width  Width of the image
+/// \param height Height of the image
 ///
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_create(sfVector2u size);
+CSFML_GRAPHICS_API sfImage* sfImage_create(unsigned int width, unsigned int height);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image and fill it with a unique color
 ///
-/// \param size  Size of the image
+/// \param width  Width of the image
-/// \param color Fill color
+/// \param height Height of the image
+/// \param color  Fill color
 ///
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(sfVector2u size, sfColor color);
+CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(unsigned int width, unsigned int height, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image from an array of pixels
@@ -70,13 +71,14 @@ CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(sfVector2u size, sfColor col
 /// an undefined behaviour.
 /// If \a pixels is null, an empty image is created.
 ///
-/// \param size   Size of the image
+/// \param width  Width 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(sfVector2u size, const uint8_t* pixels);
+CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const sfUint8* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image from a file on disk
@@ -140,7 +142,7 @@ CSFML_GRAPHICS_API sfImage* sfImage_copy(const sfImage* image);
 /// \param image Image to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_destroy(const sfImage* image);
+CSFML_GRAPHICS_API void sfImage_destroy(sfImage* image);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save an image to a file on disk
@@ -153,12 +155,12 @@ CSFML_GRAPHICS_API void sfImage_destroy(const sfImage* image);
 /// \param image    Image object
 /// \param filename Path of the file to save
 ///
-/// \return true if saving was successful
+/// \return sfTrue if saving was successful
 ///
 /// \see sfImage_saveToMemory
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfImage_saveToFile(const sfImage* image, const char* filename);
+CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the image to a buffer in memory
@@ -172,12 +174,12 @@ CSFML_GRAPHICS_API bool sfImage_saveToFile(const sfImage* image, const char* fil
 /// \param output Buffer to fill with encoded data
 /// \param format Encoding format to use
 ///
-/// \return true if saving was successful
+/// \return sfTrue if saving was successful
 ///
 /// \see sfImage_saveToFile
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
+CSFML_GRAPHICS_API sfBool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of an image
@@ -201,7 +203,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, uint8_t alpha);
+CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, sfUint8 alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy pixels from an image onto another
@@ -218,14 +220,13 @@ CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor colo
 ///
 /// \param image      Image object
 /// \param source     Source image to copy
-/// \param dest       Coordinates of the destination position
+/// \param destX      X coordinate 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 bool sfImage_copyImage(sfImage* image, const sfImage* source, sfVector2u dest, sfIntRect sourceRect, bool applyAlpha);
+CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, sfBool applyAlpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the color of a pixel in an image
@@ -234,12 +235,13 @@ CSFML_GRAPHICS_API bool 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 coords Coordinates of pixel to change
+/// \param x     X coordinate of pixel to change
-/// \param color  New color of the pixel
+/// \param y     Y coordinate of pixel to change
+/// \param color New color of the pixel
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, sfVector2u coords, sfColor color);
+CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, unsigned int x, unsigned int y, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the color of a pixel in an image
@@ -248,13 +250,14 @@ CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, sfVector2u coords, sfCo
 /// coordinates, using out-of-range values will result in
 /// an undefined behaviour.
 ///
-/// \param image  Image object
+/// \param image Image object
-/// \param coords Coordinates of pixel to get
+/// \param x     X coordinate 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, sfVector2u coords);
+CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a read-only pointer to the array of pixels of an image
@@ -271,7 +274,7 @@ CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, sfVector2u coo
 /// \return Read-only pointer to the array of pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const uint8_t* sfImage_getPixelsPtr(const sfImage* image);
+CSFML_GRAPHICS_API const sfUint8* sfImage_getPixelsPtr(const sfImage* image);
 
 ////////////////////////////////////////////////////////////
 /// \brief Flip an image horizontally (left <-> right)
@@ -288,3 +291,6 @@ CSFML_GRAPHICS_API void sfImage_flipHorizontally(sfImage* image);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfImage_flipVertically(sfImage* image);
+
+
+#endif // SFML_IMAGE_H

include/SFML/Graphics/PrimitiveType.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_PRIMITIVETYPE_H
+#define SFML_PRIMITIVETYPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
-/// \brief Types of primitives that an sfVertexArray can render
+/// \brief Types of primitives that a sf::VertexArray can render
 ///
 /// Points and lines have no area, therefore their thickness
 /// will always be 1 pixel, regardless the current transform
@@ -45,5 +46,13 @@ 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/SFML/Graphics/Rect.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RECT_H
+#define SFML_RECT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
 
-#include <CSFML/System/Vector2.h>
+#include <SFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -38,27 +39,32 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfVector2f position;
+    float left;
-    sfVector2f size;
+    float top;
+    float width;
+    float height;
 } sfFloatRect;
 
 typedef struct
 {
-    sfVector2i position;
+    int left;
-    sfVector2i size;
+    int top;
+    int width;
+    int height;
 } sfIntRect;
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a point is inside a rectangle's area
 ///
-/// \param rect  Rectangle to test
+/// \param rect Rectangle to test
-/// \param point Coordinates of the point to test
+/// \param x    X coordinate of the point to test
+/// \param y    Y coordinate of the point to test
 ///
-/// \return true if the point is inside
+/// \return sfTrue if the point is inside
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFloatRect_contains(const sfFloatRect* rect, sfVector2f point);
+CSFML_GRAPHICS_API sfBool sfFloatRect_contains(const sfFloatRect* rect, float x, float y);
-CSFML_GRAPHICS_API bool sfIntRect_contains(const sfIntRect* rect, sfVector2i point);
+CSFML_GRAPHICS_API sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check intersection between two rectangles
@@ -67,8 +73,33 @@ CSFML_GRAPHICS_API bool sfIntRect_contains(const sfIntRect* rect, sfVector2i poi
 /// \param rect2        Second rectangle to test
 /// \param intersection Rectangle to be filled with overlapping rect (can be NULL)
 ///
-/// \return true if rectangles overlap
+/// \return sfTrue if rectangles overlap
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
+CSFML_GRAPHICS_API sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
-CSFML_GRAPHICS_API bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
+CSFML_GRAPHICS_API sfBool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the position of the rectangle's top-left corner
+///
+/// \return Position of rectangle
+///
+/// \see getSize
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfFloatRect_getPosition(const sfFloatRect* rect);
+CSFML_GRAPHICS_API sfVector2i sfIntRect_getPosition(const sfIntRect* rect);
+
+////////////////////////////////////////////////////////////
+/// \brief Get the size of the rectangle
+///
+/// \return Size of rectangle
+///
+/// \see getPosition
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API sfVector2f sfFloatRect_getSize(const sfFloatRect* rect);
+CSFML_GRAPHICS_API sfVector2i sfIntRect_getSize(const sfIntRect* rect);
+
+
+#endif // SFML_RECT_H

include/SFML/Graphics/RectangleShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RECTANGLESHAPE_H
+#define SFML_RECTANGLESHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-
 #include <stddef.h>
 
 
@@ -62,7 +61,7 @@ CSFML_GRAPHICS_API sfRectangleShape* sfRectangleShape_copy(const sfRectangleShap
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRectangleShape_destroy(const sfRectangleShape* shape);
+CSFML_GRAPHICS_API void sfRectangleShape_destroy(sfRectangleShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a rectangle shape
@@ -236,7 +235,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, bool resetRect);
+CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, sfBool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a rectangle shape will display
@@ -369,20 +368,6 @@ 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
 ///
@@ -433,3 +418,6 @@ CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getLocalBounds(const sfRectangle
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getGlobalBounds(const sfRectangleShape* shape);
+
+
+#endif // SFML_RECTANGLESHAPE_H

include/SFML/Graphics/RenderStates.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,16 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RENDERSTATES_H
+#define SFML_RENDERSTATES_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/BlendMode.h>
-#include <CSFML/Graphics/BlendMode.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/CoordinateType.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/StencilMode.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -42,16 +40,16 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendMode      blendMode;      ///< Blending mode
+    sfBlendMode      blendMode; ///< Blending mode
-    sfStencilMode    stencilMode;    //!< Stencil mode
+    sfTransform      transform; ///< Transform
-    sfTransform      transform;      ///< Transform
+    const sfTexture* texture;   ///< Texture
-    sfCoordinateType coordinateType; //!< Texture coordinate type
+    const sfShader*  shader;    ///< Shader
-    const sfTexture* texture;        ///< Texture
-    const sfShader*  shader;         ///< Shader
 } sfRenderStates;
 
 ////////////////////////////////////////////////////////////
 /// \brief Define the default values for a RenderState
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfRenderStates sfRenderStates_default;
+CSFML_GRAPHICS_API sfRenderStates sfRenderStates_default(void);
+
+#endif // SFML_RENDERSTATES_H

include/SFML/Graphics/RenderTexture.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,36 +22,50 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RENDERTEXTURE_H
+#define SFML_RENDERTEXTURE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/RenderStates.h>
+#include <SFML/Graphics/RenderStates.h>
-#include <CSFML/Graphics/StencilMode.h>
+#include <SFML/Graphics/Vertex.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/Window/Window.h>
-#include <CSFML/Graphics/Vertex.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Window.h>
-
 #include <stddef.h>
 
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render texture
 ///
-/// \param size     Size of the render texture
+/// \param width       Width 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_create(sfVector2u size, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_createWithSettings(unsigned int width, unsigned int height, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing render texture
@@ -59,7 +73,7 @@ CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(sfVector2u size, cons
 /// \param renderTexture Render texture to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_destroy(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API void sfRenderTexture_destroy(sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the size of the rendering region of a render texture
@@ -76,21 +90,21 @@ CSFML_GRAPHICS_API sfVector2u sfRenderTexture_getSize(const sfRenderTexture* ren
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return true if the render texture use sRGB encoding, false otherwise
+/// \return sfTrue if the render texture use sRGB encoding, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API sfBool 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        true to activate, false to deactivate
+/// \param active        sfTrue to activate, sfFalse to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_setActive(sfRenderTexture* renderTexture, bool active);
+CSFML_GRAPHICS_API sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update the contents of the target texture
@@ -109,33 +123,6 @@ 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
 ///
@@ -176,22 +163,6 @@ 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
 ///
@@ -217,8 +188,7 @@ CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getScissor(const sfRenderTexture* r
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f
+CSFML_GRAPHICS_API sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
-    sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to texture coordinates
@@ -244,8 +214,7 @@ CSFML_GRAPHICS_API sfVector2f
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i
+CSFML_GRAPHICS_API sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
-    sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -255,30 +224,14 @@ CSFML_GRAPHICS_API sfVector2i
 /// \param states        Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture*      renderTexture,
+CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const sfSprite* object, const sfRenderStates* states);
-                                                   const sfSprite*       object,
+CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const sfText* object, const sfRenderStates* states);
-                                                   const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const sfShape* object, const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture*      renderTexture,
+CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const sfCircleShape* object, const sfRenderStates* states);
-                                                 const sfText*         object,
+CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const sfConvexShape* object, const sfRenderStates* states);
-                                                 const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const sfRectangleShape* object, const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture*      renderTexture,
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const sfVertexArray* object, const sfRenderStates* states);
-                                                  const sfShape*        object,
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture* renderTexture, const sfVertexBuffer* 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_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.
@@ -290,12 +243,9 @@ CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture*      r
 /// \param states        Render states to use for drawing
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(sfRenderTexture* renderTexture,
-    sfRenderTexture*      renderTexture,
+                                                              const sfVertexBuffer* object, size_t firstVertex,
-    const sfVertexBuffer* object,
+                                                              size_t vertexCount, const sfRenderStates* states);
-    size_t                firstVertex,
-    size_t                vertexCount,
-    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render texture
@@ -307,12 +257,9 @@ CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(
 /// \param states        Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(
+CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture,
-    sfRenderTexture*      renderTexture,
+                                                       const sfVertex* vertices, size_t vertexCount,
-    const sfVertex*       vertices,
+                                                       sfPrimitiveType type, const sfRenderStates* states);
-    size_t                vertexCount,
-    sfPrimitiveType       type,
-    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -379,45 +326,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        true to enable smoothing, false to disable it
+/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, bool smooth);
+CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a render texture
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return true if smoothing is enabled, false if it is disabled
+/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API sfBool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable texture repeating
 ///
 /// \param renderTexture Render texture object
-/// \param repeated      true to enable repeating, false to disable it
+/// \param repeated      sfTrue to enable repeating, sfFalse to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, bool repeated);
+CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, sfBool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture is repeated or not
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return true if repeat mode is enabled, false if it is disabled
+/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -430,7 +377,10 @@ CSFML_GRAPHICS_API bool sfRenderTexture_isRepeated(const sfRenderTexture* render
 /// after subsequent drawing will lead to undefined behavior if a mipmap
 /// had been previously generated.
 ///
-/// \return true if mipmap generation was successful, false if unsuccessful
+/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API sfBool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
+
+
+#endif // SFML_RENDERTEXTURE_H

include/SFML/Graphics/RenderWindow.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,27 +22,24 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RENDERWINDOW_H
+#define SFML_RENDERWINDOW_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/RenderStates.h>
+#include <SFML/Graphics/RenderStates.h>
-#include <CSFML/Graphics/StencilMode.h>
+#include <SFML/Graphics/Vertex.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/Window/Event.h>
-#include <CSFML/Graphics/Vertex.h>
+#include <SFML/Window/VideoMode.h>
-#include <CSFML/System/Time.h>
+#include <SFML/Window/WindowHandle.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/Window/Window.h>
-#include <CSFML/Window/Event.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/Window/VideoMode.h>
-#include <CSFML/Window/Window.h>
-#include <CSFML/Window/WindowHandle.h>
-
 #include <stddef.h>
 
 
@@ -52,16 +49,10 @@
 /// \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(
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings);
-    sfVideoMode              mode,
-    const char*              title,
-    uint32_t                 style,
-    sfWindowState            state,
-    const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render window (with a UTF-32 title)
@@ -69,16 +60,10 @@ CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(
 /// \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(
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings);
-    sfVideoMode              mode,
-    const sfChar32*          title,
-    uint32_t                 style,
-    sfWindowState            state,
-    const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a render window from an existing control
@@ -95,7 +80,7 @@ CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createFromHandle(sfWindowHandl
 /// \param renderWindow Render window to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_destroy(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API void sfRenderWindow_destroy(sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Close a render window (but doesn't destroy the internal data)
@@ -111,7 +96,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_close(sfRenderWindow* renderWindow);
 /// \param renderWindow Render window object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the creation settings of a render window
@@ -124,47 +109,26 @@ CSFML_GRAPHICS_API bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow
 CSFML_GRAPHICS_API sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
-/// \brief Pop the event on top of event queue, if any, and return it
+/// \brief Get the event on top of event queue of a render window, if any, and pop 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 true if an event was returned, or false if the event queue was empty
+/// \return sfTrue if an event was returned, sfFalse if event queue was empty
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Wait for an event and return it
 ///
-/// This function is blocking: if there's no pending event then
-/// 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
-///
 /// \param renderWindow Render window object
-/// \param timeout      Maximum time to wait (`sfTime_Zero` for infinite)
+/// \param event        Event to fill
-/// \param event        Event to fill, if any
 ///
-/// \return true if an event was returned, false if event queue was empty or function timed out
+/// \return sfFalse if an error occured
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfTime timeout, sfEvent* event);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of a render window
@@ -202,10 +166,10 @@ CSFML_GRAPHICS_API sfVector2u sfRenderWindow_getSize(const sfRenderWindow* rende
 ///
 /// \param renderWindow Render window object
 ///
-/// \return true if the render window use sRGB encoding, false otherwise
+/// \return sfTrue if the render window use sRGB encoding, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the size of the rendering region of a render window
@@ -216,28 +180,6 @@ CSFML_GRAPHICS_API bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfRenderWindow_setSize(sfRenderWindow* renderWindow, sfVector2u size);
 
-////////////////////////////////////////////////////////////
-/// \brief Set the minimum window rendering region size
-///
-/// Pass a `NULL` vector to unset the minimum size
-///
-/// \param renderWindow Render window object
-/// \param minimumSize  New minimum size, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMinimumSize(sfRenderWindow* renderWindow, const sfVector2u* minimumSize);
-
-////////////////////////////////////////////////////////////
-/// \brief Set the maximum window rendering region size
-///
-/// Pass a `NULL` vector to unset the maximum size
-///
-/// \param renderWindow Render window object
-/// \param maximumSize  New maximum size, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMaximumSize(sfRenderWindow* renderWindow, const sfVector2u* maximumSize);
-
 ////////////////////////////////////////////////////////////
 /// \brief Change the title of a render window
 ///
@@ -254,44 +196,45 @@ CSFML_GRAPHICS_API void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, co
 /// \param title        New title
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfChar32* title);
+CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfUint32* title);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a render window's icon
 ///
 /// \param renderWindow Render window object
-/// \param size         Icon's size, in pixels
+/// \param width        Icon's width, 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, sfVector2u size, const uint8_t* pixels);
+CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide a render window
 ///
 /// \param renderWindow Render window object
-/// \param visible      true to show the window, false to hide it
+/// \param visible      sfTrue to show the window, sfFalse to hide it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, bool visible);
+CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, sfBool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable / disable vertical synchronization on a render window
 ///
 /// \param renderWindow Render window object
-/// \param enabled      true to enable v-sync, false to deactivate
+/// \param enabled      sfTrue to enable v-sync, sfFalse to deactivate
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, bool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, sfBool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide the mouse cursor on a render window
 ///
 /// \param renderWindow Render window object
-/// \param show         true to show, false to hide
+/// \param show         sfTrue to show, sfFalse to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, bool show);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, sfBool show);
 
 ////////////////////////////////////////////////////////////
 /// \brief Grab or release the mouse cursor
@@ -303,11 +246,10 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* ren
 /// won't have any effect (fullscreen windows always grab the
 /// cursor).
 ///
-/// \param renderWindow Render window object
+/// \param grabbed sfTrue to enable, sfFalse to disable
-/// \param grabbed      true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, bool grabbed);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, sfBool grabbed);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the displayed cursor to a native system cursor
@@ -320,14 +262,13 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* ren
 /// \warning Features related to Cursor are not supported on
 ///          iOS and Android.
 ///
-/// \param renderWindow Render window object
+/// \param cursor Native system cursor type to display
-/// \param cursor       Native system cursor type to display
 ///
 /// \see sfCursor_createFromSystem
 /// \see sfCursor_createFromPixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* renderWindow, const sfCursor* cursor);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* window, const sfCursor* cursor);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable automatic key-repeat for keydown events
@@ -335,10 +276,10 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* renderWind
 /// Automatic key-repeat is enabled by default
 ///
 /// \param renderWindow Render window object
-/// \param enabled      true to enable, false to disable
+/// \param enabled      sfTrue to enable, sfFalse to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, bool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, sfBool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Limit the framerate to a maximum fixed frequency for a render window
@@ -362,12 +303,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       true to activate, false to deactivate
+/// \param active       sfTrue to activate, sfFalse to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_setActive(sfRenderWindow* renderWindow, bool active);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_setActive(sfRenderWindow* renderWindow, sfBool active);
 
 ///////////////////////////////////////////////////////////
 /// \brief Request the current render window to be made the active
@@ -393,7 +334,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow
 /// \return True if window has focus, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API sfBool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Display a render window on screen
@@ -411,7 +352,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_display(sfRenderWindow* renderWindow);
 /// \return Window handle
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getNativeHandle(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getSystemHandle(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Clear a render window with the given color
@@ -422,31 +363,6 @@ CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getNativeHandle(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
 ///
@@ -487,22 +403,6 @@ 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
 ///
@@ -531,8 +431,7 @@ CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getScissor(const sfRenderWindow* ren
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f
+CSFML_GRAPHICS_API sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
-    sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to window coordinates
@@ -558,8 +457,7 @@ CSFML_GRAPHICS_API sfVector2f
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i
+CSFML_GRAPHICS_API sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
-    sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -569,26 +467,14 @@ CSFML_GRAPHICS_API sfVector2i
 /// \param states       Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow*       renderWindow,
+CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const sfSprite* object, const sfRenderStates* states);
-                                                  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,
+CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const sfCircleShape* object, const sfRenderStates* states);
-                                                       const sfCircleShape*  object,
+CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const sfConvexShape* object, const sfRenderStates* states);
-                                                       const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const sfRectangleShape* object, const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow*       renderWindow,
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const sfVertexArray* object, const sfRenderStates* states);
-                                                       const sfConvexShape*  object,
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow* renderWindow, const sfVertexBuffer* object, const sfRenderStates* states);
-                                                       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.
@@ -600,12 +486,9 @@ CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow*       re
 /// \param states       Render states to use for drawing
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(sfRenderWindow* renderWindow,
-    sfRenderWindow*       renderWindow,
+                                                             const sfVertexBuffer* object, size_t firstVertex,
-    const sfVertexBuffer* object,
+                                                             size_t vertexCount, const sfRenderStates* states);
-    size_t                firstVertex,
-    size_t                vertexCount,
-    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render window
@@ -617,12 +500,9 @@ CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(
 /// \param states       Render states to use for drawing (NULL to use the default states)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(
+CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow,
-    sfRenderWindow*       renderWindow,
+                                                      const sfVertex* vertices, size_t vertexCount,
-    const sfVertex*       vertices,
+                                                      sfPrimitiveType type, const sfRenderStates* states);
-    size_t                vertexCount,
-    sfPrimitiveType       type,
-    const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -672,6 +552,33 @@ 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
 ///
@@ -722,8 +629,7 @@ CSFML_GRAPHICS_API sfVector2i sfTouch_getPositionRenderWindow(unsigned int finge
 /// \return True if surface creation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_createVulkanSurface(
+CSFML_GRAPHICS_API sfBool sfRenderWindow_createVulkanSurface(sfRenderWindow* renderWindow, const VkInstance* instance, VkSurfaceKHR* surface, const VkAllocationCallbacks* allocator);
-    sfRenderWindow*              renderWindow,
+
-    const VkInstance*            instance,
+
-    VkSurfaceKHR*                surface,
+#endif // SFML_RENDERWINDOW_H
-    const VkAllocationCallbacks* allocator);

include/SFML/Graphics/Shader.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,20 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SHADER_H
+#define SFML_SHADER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Glsl.h>
-#include <CSFML/Graphics/Glsl.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/System/Vector3.h>
-#include <CSFML/System/Vector3.h>
-
 #include <stddef.h>
 
 
@@ -58,9 +57,7 @@
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
+CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename);
-                                                     const char* geometryShaderFilename,
-                                                     const char* fragmentShaderFilename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from source code in memory
@@ -80,9 +77,7 @@ 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,
+CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader);
-                                                       const char* geometryShader,
-                                                       const char* fragmentShader);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from custom streams
@@ -102,9 +97,7 @@ 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,
+CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream);
-                                                       sfInputStream* geometryShaderStream,
-                                                       sfInputStream* fragmentShaderStream);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing shader
@@ -112,7 +105,7 @@ CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShad
 /// \param shader Shader to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_destroy(const sfShader* shader);
+CSFML_GRAPHICS_API void sfShader_destroy(sfShader* shader);
 
 ////////////////////////////////////////////////////////////
 /// \brief Specify value for \p float uniform
@@ -228,7 +221,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, bool x);
+CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x);
 
 ////////////////////////////////////////////////////////////
 /// \brief Specify value for \p bvec2 uniform
@@ -405,6 +398,253 @@ 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.
 ///
@@ -449,10 +689,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 true if the system can use shaders, false otherwise
+/// \return sfTrue if the system can use shaders, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfShader_isAvailable(void);
+CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not the system supports geometry shaders
@@ -471,4 +711,6 @@ CSFML_GRAPHICS_API bool sfShader_isAvailable(void);
 /// \return True if geometry shaders are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfShader_isGeometryAvailable(void);
+CSFML_GRAPHICS_API sfBool sfShader_isGeometryAvailable(void);
+
+#endif // SFML_SHADER_H

include/SFML/Graphics/Shape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SHAPE_H
+#define SFML_SHAPE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.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
 
 ////////////////////////////////////////////////////////////
@@ -52,8 +51,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
@@ -61,7 +60,7 @@ CSFML_GRAPHICS_API sfShape* sfShape_create(sfShapeGetPointCountCallback getPoint
 /// \param shape Shape to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShape_destroy(const sfShape* shape);
+CSFML_GRAPHICS_API void sfShape_destroy(sfShape* shape);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a shape
@@ -235,7 +234,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, bool resetRect);
+CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, sfBool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a shape will display
@@ -368,20 +367,6 @@ 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
 ///
@@ -418,8 +403,11 @@ 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
-/// every time their points change (ie. the result of either
+/// everytime 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/SFML/Graphics/Sprite.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,30 +22,28 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SPRITE_H
+#define SFML_SPRITE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/BlendMode.h>
-#include <CSFML/Graphics/BlendMode.h>
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.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(const sfTexture* texture);
+CSFML_GRAPHICS_API sfSprite* sfSprite_create(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing sprite
@@ -63,7 +61,7 @@ CSFML_GRAPHICS_API sfSprite* sfSprite_copy(const sfSprite* sprite);
 /// \param sprite Sprite to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfSprite_destroy(const sfSprite* sprite);
+CSFML_GRAPHICS_API void sfSprite_destroy(sfSprite* sprite);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a sprite
@@ -236,7 +234,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, bool resetRect);
+CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, sfBool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a sprite will display
@@ -330,3 +328,6 @@ CSFML_GRAPHICS_API sfFloatRect sfSprite_getLocalBounds(const sfSprite* sprite);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfSprite_getGlobalBounds(const sfSprite* sprite);
+
+
+#endif // SFML_SPRITE_H

include/SFML/Graphics/Text.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TEXT_H
+#define SFML_TEXT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-
 #include <stddef.h>
 
 
@@ -54,12 +53,10 @@ 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(const sfFont* font);
+CSFML_GRAPHICS_API sfText* sfText_create(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing text
@@ -77,7 +74,7 @@ CSFML_GRAPHICS_API sfText* sfText_copy(const sfText* text);
 /// \param text Text to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_destroy(const sfText* text);
+CSFML_GRAPHICS_API void sfText_destroy(sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a text
@@ -250,7 +247,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 sfChar32* string);
+CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const sfUint32* string);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the font of a text
@@ -279,7 +276,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.
@@ -325,7 +322,23 @@ CSFML_GRAPHICS_API void sfText_setLetterSpacing(sfText* text, float spacingFacto
 /// \param style New style
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, uint32_t style);
+CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, sfUint32 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
@@ -359,7 +372,6 @@ 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
@@ -385,7 +397,7 @@ CSFML_GRAPHICS_API const char* sfText_getString(const sfText* text);
 /// \return String as UTF-32
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfChar32* sfText_getUnicodeString(const sfText* text);
+CSFML_GRAPHICS_API const sfUint32* sfText_getUnicodeString(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font used by a text
@@ -443,7 +455,20 @@ CSFML_GRAPHICS_API float sfText_getLineSpacing(const sfText* text);
 /// \return Current string style (see sfTextStyle enum)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API uint32_t sfText_getStyle(const sfText* text);
+CSFML_GRAPHICS_API sfUint32 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
@@ -524,3 +549,6 @@ CSFML_GRAPHICS_API sfFloatRect sfText_getLocalBounds(const sfText* text);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfFloatRect sfText_getGlobalBounds(const sfText* text);
+
+
+#endif // SFML_TEXT_H

include/SFML/Graphics/Texture.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,41 +22,40 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TEXTURE_H
+#define SFML_TEXTURE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/CoordinateType.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Window/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/InputStream.h>
-#include <CSFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Types.h>
-
 #include <stddef.h>
 
+////////////////////////////////////////////////////////////
+/// \brief Types of texture coordinates that can be used for rendering.
+///
+////////////////////////////////////////////////////////////
+typedef enum
+{
+    sfTextureNormalized, ///< sfTexture coordinates in range [0 .. 1].
+    sfTexturePixels      ///< sfTexture coordinates in range [0 .. size].
+} sfTextureCoordinateType;
+
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture
 ///
-/// \param size Texture size
+/// \param width  Texture width
+/// \param height Texture height
 ///
 /// \return A new sfTexture object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_create(sfVector2u size);
+CSFML_GRAPHICS_API sfTexture* sfTexture_create(unsigned int width, unsigned int height);
-
-////////////////////////////////////////////////////////////
-/// \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
@@ -176,33 +175,7 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_copy(const sfTexture* texture);
 /// \param texture Texture to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_destroy(const sfTexture* texture);
+CSFML_GRAPHICS_API void sfTexture_destroy(sfTexture* texture);
-
-////////////////////////////////////////////////////////////
-/// \brief Resize the texture
-///
-/// If this function fails, the texture is left unchanged.
-///
-/// \param texture Texture to resize
-/// \param size Width and height of the texture
-///
-/// \return `true` if resizing was successful, `false` if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_resize(sfTexture* texture, sfVector2u size);
-
-////////////////////////////////////////////////////////////
-/// \brief Resize the texture with sRGB-enabled
-///
-/// If this function fails, the texture is left unchanged.
-///
-/// \param texture Texture to resize
-/// \param size Width and height of the texture
-///
-/// \return `true` if resizing was successful, `false` if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_resizeSrgb(sfTexture* texture, sfVector2u size);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of the texture
@@ -229,11 +202,13 @@ 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 size    size of the pixel region contained in \a pixels
+/// \param width   Width of the pixel region contained in \a pixels
-/// \param offset  Offset in the texture where to copy the source pixels
+/// \param height  Height of the pixel region contained in \a 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 uint8_t* pixels, sfVector2u size, sfVector2u offset);
+CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a part of this texture from another texture
@@ -247,59 +222,63 @@ CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const uin
 ///
 /// \param destination Destination texture to copy source texture to
 /// \param source      Source texture to copy to destination texture
-/// \param offset      Offset in this texture where to copy the source texture
+/// \param x           X 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, sfVector2u offset);
+CSFML_GRAPHICS_API void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* source, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a texture from an image
 ///
 /// \param texture Texture to update
 /// \param image   Image to copy to the texture
-/// \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_updateFromImage(sfTexture* texture, const sfImage* image, sfVector2u offset);
+CSFML_GRAPHICS_API void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a texture from the contents of a window
 ///
 /// \param texture Texture to update
 /// \param window  Window to copy to the texture
-/// \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_updateFromWindow(sfTexture* texture, const sfWindow* window, sfVector2u offset);
+CSFML_GRAPHICS_API void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \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 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_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, sfVector2u offset);
+CSFML_GRAPHICS_API void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable the smooth filter on a texture
 ///
 /// \param texture The texture object
-/// \param smooth  true to enable smoothing, false to disable it
+/// \param smooth  sfTrue to enable smoothing, sfFalse to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, bool smooth);
+CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, sfBool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a texture
 ///
 /// \param texture The texture object
 ///
-/// \return true if smoothing is enabled, false if it is disabled
+/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_isSmooth(const sfTexture* texture);
+CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture source is converted from sRGB or not
@@ -312,7 +291,7 @@ CSFML_GRAPHICS_API bool sfTexture_isSmooth(const sfTexture* texture);
 /// \see sfTexture_createSrgbFromImage
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_isSrgb(const sfTexture* texture);
+CSFML_GRAPHICS_API sfBool sfTexture_isSrgb(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable repeating for a texture
@@ -335,17 +314,17 @@ CSFML_GRAPHICS_API bool sfTexture_isSrgb(const sfTexture* texture);
 /// \param repeated True to repeat the texture, false to disable repeating
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, bool repeated);
+CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, sfBool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a texture is repeated or not
 ///
 /// \param texture The texture object
 ///
-/// \return true if repeat mode is enabled, false if it is disabled
+/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_isRepeated(const sfTexture* texture);
+CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -367,10 +346,10 @@ CSFML_GRAPHICS_API bool sfTexture_isRepeated(const sfTexture* texture);
 /// modified, at which point this function will have to be called again to
 /// regenerate it.
 ///
-/// \return true if mipmap generation was successful, false if unsuccessful
+/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_generateMipmap(sfTexture* texture);
+CSFML_GRAPHICS_API sfBool sfTexture_generateMipmap(sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of a texture with those of another
@@ -414,10 +393,9 @@ 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, sfCoordinateType type);
+CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the maximum texture size allowed
@@ -426,3 +404,6 @@ CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfCoordinateTyp
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API unsigned int sfTexture_getMaximumSize(void);
+
+
+#endif // SFML_TEXTURE_H

include/SFML/Graphics/Transform.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TRANSFORM_H
+#define SFML_TRANSFORM_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/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>
 
 
 ////////////////////////////////////////////////////////////
@@ -66,8 +67,9 @@ CSFML_GRAPHICS_API const sfTransform sfTransform_Identity;
 /// \return A new sfTransform object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTransform
+CSFML_GRAPHICS_API sfTransform sfTransform_fromMatrix(float a00, float a01, float a02,
-    sfTransform_fromMatrix(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22);
+                                                      float a10, float a11, float a12,
+                                                      float a20, float a21, float a22);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the 4x4 matrix of a transform
@@ -146,10 +148,11 @@ CSFML_GRAPHICS_API void sfTransform_combine(sfTransform* transform, const sfTran
 /// \brief Combine a transform with a translation
 ///
 /// \param transform Transform object
-/// \param offset    Offset to apply
+/// \param x         Offset to apply on X axis
+/// \param y         Offset to apply on Y axis
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_translate(sfTransform* transform, sfVector2f offset);
+CSFML_GRAPHICS_API void sfTransform_translate(sfTransform* transform, float x, float y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a rotation
@@ -170,19 +173,21 @@ CSFML_GRAPHICS_API void sfTransform_rotate(sfTransform* transform, float angle);
 ///
 /// \param transform Transform object
 /// \param angle     Rotation angle, in degrees
-/// \param center    Coordinates of the center of rotation
+/// \param centerX   X coordinate of the center of rotation
+/// \param centerY   Y coordinate of the center of rotation
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_rotateWithCenter(sfTransform* transform, float angle, sfVector2f center);
+CSFML_GRAPHICS_API void sfTransform_rotateWithCenter(sfTransform* transform, float angle, float centerX, float centerY);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a scaling
 ///
 /// \param transform Transform object
-/// \param scale     Scaling factor
+/// \param scaleX    Scaling factor on the X axis
+/// \param scaleY    Scaling factor on the Y axis
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, sfVector2f scale);
+CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, float scaleX, float scaleY);
 
 ////////////////////////////////////////////////////////////
 /// \brief Combine the current transform with a scaling
@@ -193,11 +198,13 @@ CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, sfVector2f sca
 /// [translate(-center), scale(factors), translate(center)]
 ///
 /// \param transform Transform object
-/// \param scale     Scaling factor
+/// \param scaleX    Scaling factor on X axis
-/// \param center    Coordinates of the center of scaling
+/// \param scaleY    Scaling factor on Y axis
+/// \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, sfVector2f scale, sfVector2f center);
+CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, float scaleX, float scaleY, float centerX, float centerY);
 
 ////////////////////////////////////////////////////////////
 /// \brief Compare two transforms for equality
@@ -211,4 +218,6 @@ CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, sfVe
 /// \return true if the transforms are equal, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTransform_equal(sfTransform* left, sfTransform* right);
+CSFML_GRAPHICS_API sfBool sfTransform_equal(sfTransform* left, sfTransform* right);
+
+#endif // SFML_TRANSFORM_H

include/SFML/Graphics/Transformable.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TRANSFORMABLE_H
+#define SFML_TRANSFORMABLE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Transform.h>
+#include <SFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.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(const sfTransformable* transformable);
+CSFML_GRAPHICS_API void sfTransformable_destroy(sfTransformable* transformable);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the position of a transformable
@@ -212,3 +212,6 @@ CSFML_GRAPHICS_API sfTransform sfTransformable_getTransform(const sfTransformabl
 ///
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTransform sfTransformable_getInverseTransform(const sfTransformable* transformable);
+
+
+#endif // SFML_TRANSFORMABLE_H

include/SFML/Graphics/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,26 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_GRAPHICS_TYPES_H
+#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/SFML/Graphics/Vertex.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VERTEX_H
+#define SFML_VERTEX_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Color.h>
-#include <CSFML/Graphics/Color.h>
+#include <SFML/System/Vector2.h>
-#include <CSFML/System/Vector2.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -42,3 +42,6 @@ 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/SFML/Graphics/VertexArray.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VERTEXARRAY_H
+#define SFML_VERTEXARRAY_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/Graphics/Vertex.h>
-#include <CSFML/Graphics/Vertex.h>
-
 #include <stddef.h>
 
 
@@ -61,7 +60,7 @@ CSFML_GRAPHICS_API sfVertexArray* sfVertexArray_copy(const sfVertexArray* vertex
 /// \param vertexArray Vertex array to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfVertexArray_destroy(const sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API void sfVertexArray_destroy(sfVertexArray* vertexArray);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the vertex count of a vertex array
@@ -110,7 +109,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 object
+/// \param vertexArray Vertex array objet
 /// \param vertexCount New size of the array (number of vertices)
 ///
 ////////////////////////////////////////////////////////////
@@ -119,7 +118,7 @@ CSFML_GRAPHICS_API void sfVertexArray_resize(sfVertexArray* vertexArray, size_t
 ////////////////////////////////////////////////////////////
 /// \brief Add a vertex to a vertex array array
 ///
-/// \param vertexArray Vertex array object
+/// \param vertexArray Vertex array objet
 /// \param vertex      Vertex to add
 ///
 ////////////////////////////////////////////////////////////
@@ -136,7 +135,7 @@ CSFML_GRAPHICS_API void sfVertexArray_append(sfVertexArray* vertexArray, sfVerte
 /// \li As quads
 /// The default primitive type is sfPoints.
 ///
-/// \param vertexArray Vertex array object
+/// \param vertexArray Vertex array objet
 /// \param type        Type of primitive
 ///
 ////////////////////////////////////////////////////////////
@@ -145,12 +144,12 @@ CSFML_GRAPHICS_API void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArra
 ////////////////////////////////////////////////////////////
 /// \brief Get the type of primitives drawn by a vertex array
 ///
-/// \param vertexArray Vertex array object
+/// \param vertexArray Vertex array objet
 ///
 /// \return Primitive type
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(const sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray);
 
 ////////////////////////////////////////////////////////////
 /// \brief Compute the bounding rectangle of a vertex array
@@ -158,9 +157,12 @@ CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(const sfVertex
 /// This function returns the axis-aligned rectangle that
 /// contains all the vertices of the array.
 ///
-/// \param vertexArray Vertex array object
+/// \param vertexArray Vertex array objet
 ///
 /// \return Bounding rectangle of the vertex array
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(const sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray);
+
+
+#endif // SFML_VERTEXARRAY_H

include/SFML/Graphics/VertexBuffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VERTEXBUFFER_H
+#define SFML_VERTEXBUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/Graphics/Vertex.h>
-#include <CSFML/Graphics/Vertex.h>
-
 #include <stddef.h>
 
 
@@ -58,7 +57,7 @@ typedef enum
 /// \brief Create a new vertex buffer with a specific
 /// sfPrimitiveType and usage specifier.
 ///
-/// Creates the vertex buffer, allocating enough graphics
+/// Creates the vertex buffer, allocating enough graphcis
 /// memory to hold \p vertexCount vertices, and sets its
 /// primitive type to \p type and usage to \p usage.
 ///
@@ -69,7 +68,7 @@ typedef enum
 /// \return A new sfVertexBuffer object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
+CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing vertex buffer
@@ -87,7 +86,7 @@ CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_copy(const sfVertexBuffer* ver
 /// \param vertexBuffer Vertex buffer to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfVertexBuffer_destroy(const sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API void sfVertexBuffer_destroy(sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the vertex count
@@ -97,7 +96,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_destroy(const sfVertexBuffer* vertexBuffe
 /// \return Number of vertices in the vertex buffer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API size_t sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a part of the buffer from an array of vertices
@@ -123,18 +122,14 @@ CSFML_GRAPHICS_API size_t sfVertexBuffer_getVertexCount(const sfVertexBuffer* ve
 /// array, passing invalid arguments will lead to undefined
 /// behavior.
 ///
-/// \param vertexBuffer Vertex buffer object
+/// \param vertices    Array of vertices to copy to the buffer
-/// \param vertices     Array of vertices to copy to the buffer
+/// \param vertexCount Number of vertices to copy
-/// \param vertexCount  Number of vertices to copy
+/// \param offset      Offset in the buffer to copy to
-/// \param offset       Offset in the buffer to copy to
 ///
-/// \return true if the update was successful
+/// \return sfTrue if the update was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer,
+CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset);
-                                              const sfVertex* vertices,
-                                              unsigned int    vertexCount,
-                                              unsigned int    offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy the contents of another buffer into this buffer
@@ -142,10 +137,10 @@ CSFML_GRAPHICS_API bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer,
 /// \param vertexBuffer Vertex buffer object
 /// \param other Vertex buffer whose contents to copy into first vertex buffer
 ///
-/// \return true if the copy was successful
+/// \return sfTrue if the copy was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
+CSFML_GRAPHICS_API sfBool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of this vertex buffer with those of another
@@ -166,7 +161,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(const sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the type of primitives to draw
@@ -174,7 +169,7 @@ CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(const sfVertexBuf
 /// This function defines how the vertices must be interpreted
 /// when it's time to draw them.
 ///
-/// The default primitive type is sfPoints.
+/// The default primitive type is sf::Points.
 ///
 /// \param vertexBuffer Vertex buffer object
 /// \param type Type of primitive
@@ -248,9 +243,12 @@ 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 sfVertexBuffer will fail.
+/// any attempt to use sf::VertexBuffer will fail.
 ///
 /// \return True if vertex buffers are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfVertexBuffer_isAvailable(void);
+CSFML_GRAPHICS_API sfBool sfVertexBuffer_isAvailable(void);
+
+
+#endif // SFML_VERTEXBUFFER_H

include/SFML/Graphics/View.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VIEW_H
+#define SFML_VIEW_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
+#include <SFML/Graphics/Export.h>
-
+#include <SFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
-#include <CSFML/Graphics/Types.h>
+#include <SFML/System/Vector2.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(const sfView* view);
+CSFML_GRAPHICS_API void sfView_destroy(sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the center of a view
@@ -118,27 +118,15 @@ CSFML_GRAPHICS_API void sfView_setRotation(sfView* view, float angle);
 CSFML_GRAPHICS_API void sfView_setViewport(sfView* view, sfFloatRect viewport);
 
 ////////////////////////////////////////////////////////////
-/// \brief Set the target scissor rectangle
+/// \brief Reset a view to the given rectangle
 ///
-/// The scissor rectangle, expressed as a factor (between 0 and 1) of
+/// Note that this function resets the rotation angle to 0.
-/// 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 scissor New scissor rectangle
+/// \param rectangle Rectangle defining the zone to display
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfView_setScissor(sfView* view, sfFloatRect scissor);
+CSFML_GRAPHICS_API void sfView_reset(sfView* view, sfFloatRect rectangle);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the center of a view
@@ -181,17 +169,7 @@ CSFML_GRAPHICS_API float sfView_getRotation(const sfView* view);
 CSFML_GRAPHICS_API sfFloatRect sfView_getViewport(const sfView* view);
 
 ////////////////////////////////////////////////////////////
-/// \brief Get the scissor rectangle of the view
+/// \brief Move a view relatively to its current position
-///
-/// \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
@@ -200,7 +178,7 @@ CSFML_GRAPHICS_API sfFloatRect sfView_getScissor(const sfView* view);
 CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset);
 
 ////////////////////////////////////////////////////////////
-/// \brief Rotate a view relative to its current orientation
+/// \brief Rotate a view relatively to its current orientation
 ///
 /// \param view  View object
 /// \param angle Angle to rotate, in degrees
@@ -209,7 +187,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 relative to its current size
+/// \brief Resize a view rectangle relatively to its current size
 ///
 /// Resizing the view simulates a zoom, as the zone displayed on
 /// screen grows or shrinks.
@@ -223,3 +201,6 @@ 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/SFML/Network.h

@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_NETWORK_H
+#define SFML_NETWORK_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <SFML/System.h>
+#include <SFML/Network/Ftp.h>
+#include <SFML/Network/Http.h>
+#include <SFML/Network/IpAddress.h>
+#include <SFML/Network/Packet.h>
+#include <SFML/Network/SocketSelector.h>
+#include <SFML/Network/SocketStatus.h>
+#include <SFML/Network/TcpListener.h>
+#include <SFML/Network/TcpSocket.h>
+#include <SFML/Network/UdpSocket.h>
+
+
+#endif // SFML_NETWORK_H

include/SFML/Network/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_NETWORK_EXPORT_H
+#define SFML_NETWORK_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -35,10 +36,13 @@
 ////////////////////////////////////////////////////////////
 #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/SFML/Network/Ftp.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_FTP_H
+#define SFML_FTP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/IpAddress.h>
-#include <CSFML/Network/IpAddress.h>
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
-
 #include <stddef.h>
 
 
@@ -41,7 +40,7 @@
 ////////////////////////////////////////////////////////////
 typedef enum
 {
-    sfFtpBinary, ///< Binary mode (file is transferred as a sequence of bytes)
+    sfFtpBinary, ///< Binary mode (file is transfered as a sequence of bytes)
     sfFtpAscii,  ///< Text mode using ASCII encoding
     sfFtpEbcdic  ///< Text mode using EBCDIC encoding
 } sfFtpTransferMode;
@@ -61,13 +60,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
@@ -90,7 +89,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
@@ -120,7 +119,7 @@ typedef enum
 /// \param ftpListingResponse Ftp listing response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtpListingResponse_destroy(const sfFtpListingResponse* ftpListingResponse);
+CSFML_NETWORK_API void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpListingResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP listing response status code means a success
@@ -130,10 +129,10 @@ CSFML_NETWORK_API void sfFtpListingResponse_destroy(const sfFtpListingResponse*
 ///
 /// \param ftpListingResponse Ftp listing response
 ///
-/// \return true if the status is a success, false if it is a failure
+/// \return sfTrue if the status is a success, sfFalse if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
+CSFML_NETWORK_API sfBool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP listing response
@@ -169,7 +168,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() - 1]
+/// \param index              Index of the name to get (in range [0 .. getCount])
 ///
 /// \return The requested name
 ///
@@ -182,7 +181,7 @@ CSFML_NETWORK_API const char* sfFtpListingResponse_getName(const sfFtpListingRes
 /// \param ftpDirectoryResponse Ftp directory response to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(const sfFtpDirectoryResponse* ftpDirectoryResponse);
+CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP directory response status code means a success
@@ -192,10 +191,10 @@ CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(const sfFtpDirectoryRespon
 ///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return true if the status is a success, false if it is a failure
+/// \return sfTrue if the status is a success, sfFalse if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
+CSFML_NETWORK_API sfBool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP directory response
@@ -220,38 +219,21 @@ 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 or NULL if it failed
+/// \return Directory name
 ///
 ////////////////////////////////////////////////////////////
 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(const sfFtpResponse* ftpResponse);
+CSFML_NETWORK_API void sfFtpResponse_destroy(sfFtpResponse* ftpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a FTP response status code means a success
@@ -261,10 +243,10 @@ CSFML_NETWORK_API void sfFtpResponse_destroy(const sfFtpResponse* ftpResponse);
 ///
 /// \param ftpResponse Ftp response object
 ///
-/// \return true if the status is a success, false if it is a failure
+/// \return sfTrue if the status is a success, sfFalse if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
+CSFML_NETWORK_API sfBool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP response
@@ -300,7 +282,7 @@ CSFML_NETWORK_API sfFtp* sfFtp_create(void);
 /// \param ftp Ftp object to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfFtp_destroy(const sfFtp* ftp);
+CSFML_NETWORK_API void sfFtp_destroy(sfFtp* ftp);
 
 ////////////////////////////////////////////////////////////
 /// \brief Connect to the specified FTP server
@@ -518,17 +500,12 @@ 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 true to append to or false to overwrite the remote file if it already exists
+/// \param append     Pass sfTrue to append to or sfFalse to overwrite the remote file if it already exists
 ///
 /// \return Server response to the request
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(
+CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, sfBool append);
-    sfFtp*            ftp,
-    const char*       localFile,
-    const char*       remotePath,
-    sfFtpTransferMode mode,
-    bool              append);
 
 ////////////////////////////////////////////////////////////
 /// \brief Send a command to the FTP server
@@ -549,3 +526,6 @@ CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfFtpResponse* sfFtp_sendCommand(sfFtp* ftp, const char* command, const char* parameter);
+
+
+#endif // SFML_FTP_H

include/SFML/Network/Http.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_HTTP_H
+#define SFML_HTTP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
+#include <SFML/System/Time.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(const sfHttpRequest* httpRequest);
+CSFML_NETWORK_API void sfHttpRequest_destroy(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 available methods.
+/// the availale 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(const sfHttpResponse* httpResponse);
+CSFML_NETWORK_API void sfHttpResponse_destroy(sfHttpResponse* httpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the value of a field of a HTTP response
@@ -195,7 +195,7 @@ CSFML_NETWORK_API void sfHttpResponse_destroy(const sfHttpResponse* httpResponse
 CSFML_NETWORK_API const char* sfHttpResponse_getField(const sfHttpResponse* httpResponse, const char* field);
 
 ////////////////////////////////////////////////////////////
-/// \brief Get the status code of a HTTP response
+/// \brief Get the status code of a HTTP reponse
 ///
 /// 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(const sfHttp* http);
+CSFML_NETWORK_API void sfHttp_destroy(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 default timeout
+/// of 0 means that the client will use the system defaut timeout
 /// (which is usually pretty long).
 ///
 /// \param http    Http object
@@ -299,3 +299,6 @@ 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/SFML/Network/IpAddress.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_IPADDRESS_H
+#define SFML_IPADDRESS_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/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(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct an address from a 32-bits integer
@@ -103,14 +103,14 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(uint8_t byte0, uint8_t 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(uint32_t address);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromInteger(sfUint32 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 uint32_t sfIpAddress_toInteger(sfIpAddress address);
+CSFML_NETWORK_API sfUint32 sfIpAddress_toInteger(sfIpAddress address);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the computer's local address
@@ -176,3 +176,6 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_getLocalAddress(void);
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfIpAddress sfIpAddress_getPublicAddress(sfTime timeout);
+
+
+#endif // SFML_IPADDRESS_H

include/SFML/Network/Packet.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_PACKET_H
+#define SFML_PACKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
-
 #include <stddef.h>
 
 
@@ -58,7 +57,7 @@ CSFML_NETWORK_API sfPacket* sfPacket_copy(const sfPacket* packet);
 /// \param packet Packet to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfPacket_destroy(const sfPacket* packet);
+CSFML_NETWORK_API void sfPacket_destroy(sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Append data to the end of a packet
@@ -75,8 +74,6 @@ 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
@@ -131,15 +128,15 @@ CSFML_NETWORK_API size_t sfPacket_getDataSize(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return true if all data was read, false otherwise
+/// \return sfTrue if all data was read, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfPacket_endOfPacket(const sfPacket* packet);
+CSFML_NETWORK_API sfBool sfPacket_endOfPacket(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test the validity of a packet, for reading
 ///
-/// This function allows for testing the packet, to check if
+/// This function allows to test the packet, to check if
 /// a reading operation was successful.
 ///
 /// A packet will be in an invalid state if it has no more
@@ -147,10 +144,10 @@ CSFML_NETWORK_API bool sfPacket_endOfPacket(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return true if last data extraction from packet was successful
+/// \return sfTrue if last data extraction from packet was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfPacket_canRead(const sfPacket* packet);
+CSFML_NETWORK_API sfBool sfPacket_canRead(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Functions to extract data from a packet
@@ -158,15 +155,13 @@ CSFML_NETWORK_API bool sfPacket_canRead(const sfPacket* packet);
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool     sfPacket_readBool(sfPacket* packet);
+CSFML_NETWORK_API sfBool   sfPacket_readBool(sfPacket* packet);
-CSFML_NETWORK_API int8_t   sfPacket_readInt8(sfPacket* packet);
+CSFML_NETWORK_API sfInt8   sfPacket_readInt8(sfPacket* packet);
-CSFML_NETWORK_API uint8_t  sfPacket_readUint8(sfPacket* packet);
+CSFML_NETWORK_API sfUint8  sfPacket_readUint8(sfPacket* packet);
-CSFML_NETWORK_API int16_t  sfPacket_readInt16(sfPacket* packet);
+CSFML_NETWORK_API sfInt16  sfPacket_readInt16(sfPacket* packet);
-CSFML_NETWORK_API uint16_t sfPacket_readUint16(sfPacket* packet);
+CSFML_NETWORK_API sfUint16 sfPacket_readUint16(sfPacket* packet);
-CSFML_NETWORK_API int32_t  sfPacket_readInt32(sfPacket* packet);
+CSFML_NETWORK_API sfInt32  sfPacket_readInt32(sfPacket* packet);
-CSFML_NETWORK_API uint32_t sfPacket_readUint32(sfPacket* packet);
+CSFML_NETWORK_API sfUint32 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);
@@ -178,16 +173,17 @@ CSFML_NETWORK_API void     sfPacket_readWideString(sfPacket* packet, wchar_t* st
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, bool);
+CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, sfBool);
-CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, int8_t);
+CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, sfInt8);
-CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, uint8_t);
+CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, sfUint8);
-CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, int16_t);
+CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, sfInt16);
-CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, uint16_t);
+CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, sfUint16);
-CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, int32_t);
+CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, sfInt32);
-CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, uint32_t);
+CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, sfUint32);
-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/SFML/Network/SocketSelector.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOCKETSELECTOR_H
+#define SFML_SOCKETSELECTOR_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
+#include <SFML/System/Time.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(const sfSocketSelector* selector);
+CSFML_NETWORK_API void sfSocketSelector_destroy(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   Pointer to the socket to remove
+/// \param socket   POointer 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 false.
+/// is over, the function returns sfFalse.
 ///
 /// \param selector Socket selector object
 /// \param timeout  Maximum time to wait (use sfTimeZero for infinity)
 ///
-/// \return true if there are sockets ready, false otherwise
+/// \return sfTrue if there are sockets ready, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
+CSFML_NETWORK_API sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test a socket to know if it is ready to receive data
@@ -124,15 +124,18 @@ CSFML_NETWORK_API bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime
 /// 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 true for a sfTcpListener,
+/// Note that if this function returns sfTrue 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 true if the socket is ready to read, false otherwise
+/// \return sfTrue if the socket is ready to read, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
+CSFML_NETWORK_API sfBool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
-CSFML_NETWORK_API bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
+CSFML_NETWORK_API sfBool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
-CSFML_NETWORK_API bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
+CSFML_NETWORK_API sfBool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
+
+
+#endif // SFML_SOCKETSELECTOR_H

include/SFML/Network/SocketStatus.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,7 +22,9 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SOCKETSTATUS_H
+#define SFML_SOCKETSTATUS_H
+
 
 ////////////////////////////////////////////////////////////
 /// \brief Define the status that can be returned by the socket functions
@@ -35,4 +37,8 @@ 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/SFML/Network/TcpListener.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TCPLISTENER_H
+#define SFML_TCPLISTENER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/SocketStatus.h>
-#include <CSFML/Network/IpAddress.h>
+#include <SFML/Network/IpAddress.h>
-#include <CSFML/Network/SocketStatus.h>
+#include <SFML/Network/Types.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(const sfTcpListener* listener);
+CSFML_NETWORK_API void sfTcpListener_destroy(sfTcpListener* listener);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a TCP listener
@@ -63,20 +63,20 @@ CSFML_NETWORK_API void sfTcpListener_destroy(const sfTcpListener* listener);
 /// By default, all sockets are blocking.
 ///
 /// \param listener TCP listener object
-/// \param blocking true to set the socket as blocking, false for non-blocking
+/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, bool blocking);
+CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, sfBool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP listener is in blocking or non-blocking mode
 ///
 /// \param listener TCP listener object
 ///
-/// \return true if the socket is blocking, false otherwise
+/// \return sfTrue if the socket is blocking, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfTcpListener_isBlocking(const sfTcpListener* listener);
+CSFML_NETWORK_API sfBool sfTcpListener_isBlocking(const sfTcpListener* listener);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP listener is bound locally
@@ -99,10 +99,6 @@ 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
@@ -114,17 +110,6 @@ 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
 ///
@@ -143,11 +128,5 @@ CSFML_NETWORK_API void sfTcpListener_close(sfTcpListener* listener);
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** connected);
 
-////////////////////////////////////////////////////////////
+
-/// \brief Return the special value that tells the system
+#endif // SFML_TCPLISTENER_H
-///        to pick any available port
-///
-/// \return The value to use for any port
-///
-////////////////////////////////////////////////////////////
-CSFML_NETWORK_API unsigned short sfTcpListener_anyPort(void);

include/SFML/Network/TcpSocket.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,17 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TCPSOCKET_H
+#define SFML_TCPSOCKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/IpAddress.h>
-#include <CSFML/Network/IpAddress.h>
+#include <SFML/Network/SocketStatus.h>
-#include <CSFML/Network/SocketStatus.h>
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
+#include <SFML/System/Time.h>
-#include <CSFML/System/Time.h>
-
 #include <stddef.h>
 
 
@@ -51,7 +50,7 @@ CSFML_NETWORK_API sfTcpSocket* sfTcpSocket_create(void);
 /// \param socket TCP socket to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpSocket_destroy(const sfTcpSocket* socket);
+CSFML_NETWORK_API void sfTcpSocket_destroy(sfTcpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a TCP listener
@@ -66,20 +65,20 @@ CSFML_NETWORK_API void sfTcpSocket_destroy(const sfTcpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   TCP socket object
-/// \param blocking true to set the socket as blocking, false for non-blocking
+/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, bool blocking);
+CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, sfBool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP socket is in blocking or non-blocking mode
 ///
 /// \param socket TCP socket object
 ///
-/// \return true if the socket is blocking, false otherwise
+/// \return sfTrue if the socket is blocking, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
+CSFML_NETWORK_API sfBool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP socket is bound locally
@@ -96,7 +95,7 @@ CSFML_NETWORK_API unsigned short sfTcpSocket_getLocalPort(const sfTcpSocket* soc
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of the connected peer of a TCP socket
 ///
-/// If the socket is not connected, this function returns
+/// It the socket is not connected, this function returns
 /// sfIpAddress_None.
 ///
 /// \param socket TCP socket object
@@ -135,8 +134,7 @@ CSFML_NETWORK_API unsigned short sfTcpSocket_getRemotePort(const sfTcpSocket* so
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus
+CSFML_NETWORK_API sfSocketStatus sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
-    sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Disconnect a TCP socket from its remote peer
@@ -153,7 +151,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*, size_t, size_t*)
+/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, std::size_t, size_t*)
 /// overload instead.
 /// This function will fail if the socket is not connected.
 ///
@@ -229,3 +227,6 @@ CSFML_NETWORK_API sfSocketStatus sfTcpSocket_sendPacket(sfTcpSocket* socket, sfP
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpSocket_receivePacket(sfTcpSocket* socket, sfPacket* packet);
+
+
+#endif // SFML_TCPSOCKET_H

include/SFML/Network/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_NETWORK_TYPES_H
+#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/SFML/Network/UdpSocket.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_UDPSOCKET_H
+#define SFML_UDPSOCKET_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Network/Export.h>
+#include <SFML/Network/Export.h>
-
+#include <SFML/Network/IpAddress.h>
-#include <CSFML/Network/IpAddress.h>
+#include <SFML/Network/SocketStatus.h>
-#include <CSFML/Network/SocketStatus.h>
+#include <SFML/Network/Types.h>
-#include <CSFML/Network/Types.h>
-
 #include <stddef.h>
 
 
@@ -50,7 +49,7 @@ CSFML_NETWORK_API sfUdpSocket* sfUdpSocket_create(void);
 /// \param socket UDP socket to destroy
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfUdpSocket_destroy(const sfUdpSocket* socket);
+CSFML_NETWORK_API void sfUdpSocket_destroy(sfUdpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the blocking state of a UDP listener
@@ -65,20 +64,20 @@ CSFML_NETWORK_API void sfUdpSocket_destroy(const sfUdpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   UDP socket object
-/// \param blocking true to set the socket as blocking, false for non-blocking
+/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, bool blocking);
+CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, sfBool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a UDP socket is in blocking or non-blocking mode
 ///
 /// \param socket UDP socket object
 ///
-/// \return true if the socket is blocking, false otherwise
+/// \return sfTrue if the socket is blocking, sfFalse otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API bool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
+CSFML_NETWORK_API sfBool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a UDP socket is bound locally
@@ -102,10 +101,6 @@ 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
@@ -145,8 +140,7 @@ CSFML_NETWORK_API void sfUdpSocket_unbind(sfUdpSocket* socket);
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort);
-    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
@@ -168,13 +162,7 @@ CSFML_NETWORK_API sfSocketStatus
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(sfUdpSocket* socket, void* data, size_t size, size_t* received, sfIpAddress* remoteAddress, unsigned short* remotePort);
-    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
@@ -191,8 +179,7 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort);
-    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
@@ -200,7 +187,6 @@ CSFML_NETWORK_API sfSocketStatus
 /// 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
@@ -208,8 +194,7 @@ CSFML_NETWORK_API sfSocketStatus
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
-    sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the maximum number of bytes that can be
@@ -220,11 +205,5 @@ CSFML_NETWORK_API sfSocketStatus
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API unsigned int sfUdpSocket_maxDatagramSize(void);
 
-////////////////////////////////////////////////////////////
+
-/// \brief Return the special value that tells the system
+#endif // SFML_UDPSOCKET_H
-///        to pick any available port
-///
-/// \return The value to use for any port
-///
-////////////////////////////////////////////////////////////
-CSFML_NETWORK_API unsigned short sfUdpSocket_anyPort(void);

include/SFML/OpenGL.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_OPENGL_H
+#define SFML_OPENGL_H
+
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,18 +38,21 @@
 ////////////////////////////////////////////////////////////
 #if defined(CSFML_SYSTEM_WINDOWS)
 
-#include <GL/gl.h>
+    #include <windows.h>
-#include <GL/glu.h>
+    #include <GL/gl.h>
-#include <windows.h>
+    #include <GL/glu.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/SFML/System.h

@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SYSTEM_H
+#define SFML_SYSTEM_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <SFML/Config.h>
+#include <SFML/System/Buffer.h>
+#include <SFML/System/Clock.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Mutex.h>
+#include <SFML/System/Sleep.h>
+#include <SFML/System/Thread.h>
+#include <SFML/System/Time.h>
+#include <SFML/System/Vector2.h>
+#include <SFML/System/Vector3.h>
+
+
+#endif // SFML_SYSTEM_H

include/SFML/System/Alloc.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_ALLOC_H
+#define SFML_ALLOC_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -35,11 +36,14 @@
 ///
 /// 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
+/// \param ptr Pointer to the memory to deallocate 
 ///
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API void sfFree(void* ptr);
+
+
+#endif // SFML_ALLOC_H

include/SFML/System/Buffer.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_BUFFER_H
+#define SFML_BUFFER_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
-
+#include <SFML/System/Types.h>
-#include <CSFML/System/Types.h>
-
 #include <stddef.h>
 
 
@@ -48,7 +47,7 @@ CSFML_SYSTEM_API sfBuffer* sfBuffer_create(void);
 /// \param buffer Buffer to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API void sfBuffer_destroy(const sfBuffer* buffer);
+CSFML_SYSTEM_API void sfBuffer_destroy(sfBuffer* buffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of a buffer
@@ -68,4 +67,7 @@ CSFML_SYSTEM_API size_t sfBuffer_getSize(const sfBuffer* buffer);
 /// \return Read-only pointer to the array of bytes
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API const uint8_t* sfBuffer_getData(const sfBuffer* buffer);
+CSFML_SYSTEM_API const sfUint8* sfBuffer_getData(const sfBuffer* buffer);
+
+
+#endif // SFML_BUFFER_H

include/SFML/System/Clock.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_CLOCK_H
+#define SFML_CLOCK_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
-
+#include <SFML/System/Time.h>
-#include <CSFML/System/Time.h>
+#include <SFML/System/Types.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(const sfClock* clock);
+CSFML_SYSTEM_API void sfClock_destroy(sfClock* clock);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the time elapsed in a clock
@@ -73,36 +73,6 @@ CSFML_SYSTEM_API void sfClock_destroy(const 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
 ///
@@ -116,17 +86,5 @@ CSFML_SYSTEM_API void sfClock_stop(sfClock* clock);
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API sfTime sfClock_restart(sfClock* clock);
 
-////////////////////////////////////////////////////////////
+
-/// \brief Reset the clock
+#endif // SFML_CLOCK_H
-///
-/// 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/SFML/System/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SYSTEM_EXPORT_H
+#define SFML_SYSTEM_EXPORT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
+#include <SFML/Config.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -35,10 +36,13 @@
 ////////////////////////////////////////////////////////////
 #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/SFML/System/InputStream.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,19 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_INPUTSTREAM_H
+#define SFML_INPUTSTREAM_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
-
-#include <stdlib.h>
 
 
-typedef int64_t (*sfInputStreamReadFunc)(void* data, size_t size, void* userData);
+typedef sfInt64 (*sfInputStreamReadFunc)(void* data, sfInt64 size, void* userData);
-typedef int64_t (*sfInputStreamSeekFunc)(size_t position, void* userData);
+typedef sfInt64 (*sfInputStreamSeekFunc)(sfInt64 position, void* userData);
-typedef int64_t (*sfInputStreamTellFunc)(void* userData);
+typedef sfInt64 (*sfInputStreamTellFunc)(void* userData);
-typedef int64_t (*sfInputStreamGetSizeFunc)(void* userData);
+typedef sfInt64 (*sfInputStreamGetSizeFunc)(void* userData);
 
 
 ////////////////////////////////////////////////////////////
@@ -50,3 +49,6 @@ 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/SFML/System/Mutex.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,41 +22,47 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_MUTEX_H
+#define SFML_MUTEX_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <SFML/Network/Ftp.hpp>
+#include <SFML/System/Export.h>
+#include <SFML/System/Types.h>
 
 
 ////////////////////////////////////////////////////////////
-// Internal structure of sfFtp
+/// \brief Create a new mutex
+///
+/// \return A new sfMutex object
+///
 ////////////////////////////////////////////////////////////
-struct sfFtp : sf::Ftp
+CSFML_SYSTEM_API sfMutex* sfMutex_create(void);
-{
-};
-
 
 ////////////////////////////////////////////////////////////
-// Internal structure of sfFtpResponse
+/// \brief Destroy a mutex
+///
+/// \param mutex Mutex to destroy
+///
 ////////////////////////////////////////////////////////////
-struct sfFtpResponse : sf::Ftp::Response
+CSFML_SYSTEM_API void sfMutex_destroy(sfMutex* mutex);
-{
-};
-
 
 ////////////////////////////////////////////////////////////
-// Internal structure of sfFtpDirectoryResponse
+/// \brief Lock a mutex
+///
+/// \param mutex Mutex object
+///
 ////////////////////////////////////////////////////////////
-struct sfFtpDirectoryResponse : sf::Ftp::DirectoryResponse
+CSFML_SYSTEM_API void sfMutex_lock(sfMutex* mutex);
-{
-};
-
 
 ////////////////////////////////////////////////////////////
-// Internal structure of sfFtpListingResponse
+/// \brief Unlock a mutex
+///
+/// \param mutex Mutex object
+///
 ////////////////////////////////////////////////////////////
-struct sfFtpListingResponse : sf::Ftp::ListingResponse
+CSFML_SYSTEM_API void sfMutex_unlock(sfMutex* mutex);
-{
+
-};
+
+#endif // SFML_MUTEX_H

include/SFML/System/Sleep.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SLEEP_H
+#define SFML_SLEEP_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
-
+#include <SFML/System/Time.h>
-#include <CSFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -42,3 +42,6 @@
 ///
 ////////////////////////////////////////////////////////////
 CSFML_SYSTEM_API void sfSleep(sfTime duration);
+
+
+#endif // SFML_SLEEP_H

include/SFML/System/Thread.h

@@ -0,0 +1,103 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_THREAD_H
+#define SFML_THREAD_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Export.h>
+#include <SFML/System/Types.h>
+
+
+////////////////////////////////////////////////////////////
+/// \brief Create a new thread from a function pointer
+///
+/// Note: this does *not* run the thread, use sfThread_launch.
+///
+/// \param function Entry point of the thread
+/// \param userData Custom data to pass to the thread function
+///
+/// \return A new sfThread object
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API sfThread* sfThread_create(void (*function)(void*), void* userData);
+
+////////////////////////////////////////////////////////////
+/// \brief Destroy a thread
+///
+/// This function calls sfThread_wait, so that the internal thread
+/// cannot survive after the sfThread object is destroyed.
+///
+/// \param thread Thread to destroy
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfThread_destroy(sfThread* thread);
+
+////////////////////////////////////////////////////////////
+/// \brief Run a thread
+///
+/// This function starts the entry point passed to the
+/// thread's constructor, and returns immediately.
+/// After this function returns, the thread's function is
+/// running in parallel to the calling code.
+///
+/// \param thread Thread object
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfThread_launch(sfThread* thread);
+
+////////////////////////////////////////////////////////////
+/// \brief Wait until a thread finishes
+///
+/// This function will block the execution until the
+/// thread's function ends.
+/// Warning: if the thread function never ends, the calling
+/// thread will block forever.
+/// If this function is called from its owner thread, it
+/// returns without doing anything.
+///
+/// \param thread Thread object
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfThread_wait(sfThread* thread);
+
+////////////////////////////////////////////////////////////
+/// \brief Terminate a thread
+///
+/// This function immediately stops the thread, without waiting
+/// for its function to finish.
+/// Terminating a thread with this function is not safe,
+/// and can lead to local variables not being destroyed
+/// on some operating systems. You should rather try to make
+/// the thread function terminate by itself.
+///
+/// \param thread Thread object
+///
+////////////////////////////////////////////////////////////
+CSFML_SYSTEM_API void sfThread_terminate(sfThread* thread);
+
+
+#endif // SFML_THREAD_H

include/SFML/System/Time.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TIME_H
+#define SFML_TIME_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -36,14 +37,14 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    int64_t microseconds;
+    sfInt64 microseconds;
 } sfTime;
 
 ////////////////////////////////////////////////////////////
 /// \brief Predefined "zero" time value
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API const sfTime sfTime_Zero;
+CSFML_SYSTEM_API sfTime sfTime_Zero;
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of seconds
@@ -63,7 +64,7 @@ CSFML_SYSTEM_API float sfTime_asSeconds(sfTime time);
 /// \return Time in milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API int32_t sfTime_asMilliseconds(sfTime time);
+CSFML_SYSTEM_API sfInt32 sfTime_asMilliseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of microseconds
@@ -73,7 +74,7 @@ CSFML_SYSTEM_API int32_t sfTime_asMilliseconds(sfTime time);
 /// \return Time in microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API int64_t sfTime_asMicroseconds(sfTime time);
+CSFML_SYSTEM_API sfInt64 sfTime_asMicroseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of seconds
@@ -93,7 +94,7 @@ CSFML_SYSTEM_API sfTime sfSeconds(float amount);
 /// \return Time value constructed from the amount of milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMilliseconds(int32_t amount);
+CSFML_SYSTEM_API sfTime sfMilliseconds(sfInt32 amount);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of microseconds
@@ -103,4 +104,7 @@ CSFML_SYSTEM_API sfTime sfMilliseconds(int32_t amount);
 /// \return Time value constructed from the amount of microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMicroseconds(int64_t amount);
+CSFML_SYSTEM_API sfTime sfMicroseconds(sfInt64 amount);
+
+
+#endif // SFML_TIME_H

include/SFML/System/Types.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,8 +22,14 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_SYSTEM_TYPES_H
+#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/SFML/System/Vector2.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VECTOR2_H
+#define SFML_VECTOR2_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -61,3 +62,6 @@ typedef struct
     float x;
     float y;
 } sfVector2f;
+
+
+#endif // SFML_VECTOR2_H

include/SFML/System/Vector3.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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,12 +22,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_VECTOR3_H
+#define SFML_VECTOR3_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/System/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -40,3 +41,6 @@ typedef struct
     float y;
     float z;
 } sfVector3f;
+
+
+#endif // SFML_VECTOR3_H

include/SFML/Window.h

@@ -0,0 +1,47 @@
+////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SFML_WINDOW_H
+#define SFML_SFML_WINDOW_H
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <SFML/System.h>
+#include <SFML/Window/Clipboard.h>
+#include <SFML/Window/Context.h>
+#include <SFML/Window/Cursor.h>
+#include <SFML/Window/Event.h>
+#include <SFML/Window/Joystick.h>
+#include <SFML/Window/JoystickIdentification.h>
+#include <SFML/Window/Keyboard.h>
+#include <SFML/Window/Mouse.h>
+#include <SFML/Window/Sensor.h>
+#include <SFML/Window/Touch.h>
+#include <SFML/Window/VideoMode.h>
+#include <SFML/Window/Window.h>
+
+
+#endif // SFML_SFML_WINDOW_H

include/SFML/Window/Clipboard.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2026 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 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_CLIPBOARD_H
+#define SFML_CLIPBOARD_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Window/Export.h>
+#include <SFML/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 sfChar32* sfClipboard_getUnicodeString(void);
+CSFML_WINDOW_API const sfUint32* sfClipboard_getUnicodeString(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the content of the clipboard as ANSI string data
@@ -79,4 +79,7 @@ CSFML_WINDOW_API void sfClipboard_setString(const char* text);
 /// to the clipboard
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfClipboard_setUnicodeString(const sfChar32* text);
+CSFML_WINDOW_API void sfClipboard_setUnicodeString(const sfUint32* text);
+
+
+#endif // SFML_CURSOR_H