Add artifact storage for GitHub Actions

.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

@@ -1,174 +1,84 @@
 name: CI
 
-on: [push, pull_request, workflow_dispatch]
-
-concurrency:
-  group: environment-${{github.ref}}
-  cancel-in-progress: true
-
-env:
-  SFML_VERSION: 3.0.1
-
-defaults:
-  run:
-    shell: bash
+on: [push, pull_request]
 
 jobs:
   build:
-    name: ${{ matrix.platform.name }} ${{ matrix.config.name }} ${{ matrix.type.name }}
+    name: ${{ matrix.platform.name }} ${{ matrix.config.name }}
     runs-on: ${{ matrix.platform.os }}
 
     strategy:
       fail-fast: false
       matrix:
         platform:
-        - { name: Windows VS2022 x86,  os: windows-2025, flags: -AWin32 }
-        - { name: Windows VS2022 x64,  os: windows-2025, flags: -Ax64 }
-        - { name: Windows ClangCL,     os: windows-2025, flags: -T ClangCL }
-        - { name: Windows Clang,       os: windows-2025, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
-        - { name: Linux GCC,           os: ubuntu-22.04, flags: -GNinja }
-        - { name: Linux Clang,         os: ubuntu-22.04, flags: -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ }
-        - { name: MacOS,               os: macos-14,     flags: -GNinja }
-        config:
-        - { name: Shared, flags: -DBUILD_SHARED_LIBS=ON,  csfml_flags: -DCSFML_LINK_SFML_STATICALLY=OFF }
-        - { name: Static, flags: -DBUILD_SHARED_LIBS=OFF, csfml_flags: -DCSFML_LINK_SFML_STATICALLY=ON }
-        type:
-        - { name: Debug }
-        - { name: Release }
-
+          - {
+              name: Windows VS2019,
+              os: windows-2019,
+              sfml-flags: -DBUILD_SHARED_LIBS=FALSE -DSFML_USE_STATIC_STD_LIBS=TRUE,
+              csfml-flags: -DCSFML_LINK_SFML_STATICALLY=TRUE -DSTATIC_STD_LIBS=TRUE,
+            }
+          - {
+              name: Windows VS2022,
+              os: windows-2022,
+              sfml-flags: -DBUILD_SHARED_LIBS=FALSE -DSFML_USE_STATIC_STD_LIBS=TRUE,
+              csfml-flags: -DCSFML_LINK_SFML_STATICALLY=TRUE -DSTATIC_STD_LIBS=TRUE,
+            }
+          - {
+              name: Linux GCC,
+              os: ubuntu-latest,
+              sfml-flags: -DBUILD_SHARED_LIBS=TRUE -DSFML_USE_STATIC_STD_LIBS=FALSE,
+              csfml-flags: -DCSFML_LINK_SFML_STATICALLY=FALSE -DSTATIC_STD_LIBS=FALSE,
+            }
+          - {
+              name: Linux Clang,
+              os: ubuntu-latest,
+              flags: -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++,
+              sfml-flags: -DBUILD_SHARED_LIBS=TRUE -DSFML_USE_STATIC_STD_LIBS=FALSE,
+              csfml-flags: -DCSFML_LINK_SFML_STATICALLY=FALSE -DSTATIC_STD_LIBS=FALSE,
+            }
+          - {
+              name: MacOS XCode,
+              os: macos-latest,
+              prefix: sudo,
+              flags: -DSFML_BUILD_FRAMEWORKS=FALSE,
+              sfml-flags: -DBUILD_SHARED_LIBS=TRUE -DSFML_USE_STATIC_STD_LIBS=FALSE,
+              csfml-flags: -DCSFML_LINK_SFML_STATICALLY=FALSE -DSTATIC_STD_LIBS=FALSE,
+            }
     steps:
-    - name: Get CMake and Ninja
-      uses: lukka/get-cmake@latest
-      with:
-        cmakeVersion: ${{ runner.os == 'Windows' && '3.25' || '3.22' }}
-        ninjaVersion: latest
+      - name: Install Linux Dependencies
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install libxrandr-dev libxcursor-dev libudev-dev libopenal-dev libflac-dev libvorbis-dev libgl1-mesa-dev libegl1-mesa-dev
 
-    - 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
+      - name: Checkout SFML
+        uses: actions/checkout@v3
+        with:
+          repository: SFML/SFML
+          ref: 2.5.1
+          path: SFML
 
-    - name: Checkout SFML
-      uses: actions/checkout@v4
-      with:
-        repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
-        path: SFML
+      - name: Configure SFML CMake
+        shell: bash
+        run: cmake -S $GITHUB_WORKSPACE/SFML -B $GITHUB_WORKSPACE/SFML/build -DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/SFML/install -DBUILD_SHARED_LIBS=FALSE -DSFML_BUILD_EXAMPLES=FALSE -DSFML_BUILD_TEST_SUITE=FALSE -DCMAKE_VERBOSE_MAKEFILE=ON ${{matrix.platform.flags}} ${{matrix.platform.sfml-flags}}
 
-    - name: Configure SFML CMake
-      run: |
-        cmake -S SFML -B SFML/build \
-          -DCMAKE_BUILD_TYPE=${{matrix.type.name}} \
-          -DCMAKE_INSTALL_PREFIX=SFML/install \
-          ${{matrix.platform.flags}} \
-          ${{matrix.config.flags}}
+      - name: Build SFML
+        shell: bash
+        run: ${{matrix.platform.prefix}} cmake --build $GITHUB_WORKSPACE/SFML/build --config Release --target install
 
-    - name: Build SFML
-      run: cmake --build SFML/build --config ${{matrix.type.name}} --target install
+      - name: Checkout CSFML
+        uses: actions/checkout@v3
+        with:
+          path: CSFML
 
-    - name: Checkout CSFML
-      uses: actions/checkout@v4
-      with:
-        path: CSFML
+      - name: Configure CSFML CMake
+        shell: bash
+        run: cmake -S $GITHUB_WORKSPACE/CSFML -B $GITHUB_WORKSPACE/CSFML/build -DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/CSFML/install -DBUILD_SHARED_LIBS=TRUE -DSFML_DIR=$GITHUB_WORKSPACE/SFML/install/lib/cmake/SFML -DCMAKE_VERBOSE_MAKEFILE=ON ${{matrix.platform.flags}} ${{matrix.platform.csfml-flags}}
 
-    - name: Configure CSFML CMake
-      run: |
-        cmake --preset dev -S CSFML -B CSFML/build \
-          -DCMAKE_BUILD_TYPE=${{matrix.type.name}} \
-          -DCMAKE_INSTALL_PREFIX=CSFML/install \
-          -DSFML_ROOT=SFML/install \
-          -DCMAKE_VERBOSE_MAKEFILE=ON \
-          ${{matrix.platform.flags}} \
-          ${{matrix.config.flags}} \
-          ${{matrix.config.csfml_flags}}
+      - name: Build CSFML
+        shell: bash
+        run: cmake --build $GITHUB_WORKSPACE/CSFML/build --config Release --target install
 
-    - name: Build CSFML
-      run: cmake --build CSFML/build --config ${{matrix.type.name}} --target install
-
-    - name: Test
-      run: ctest --test-dir CSFML/build -C ${{matrix.type.name}} --output-on-failure
-
-  format:
-    name: Formatting
-    runs-on: ubuntu-24.04
-
-    steps:
-    - name: Install Clang Format
-      run: sudo apt-get install clang-format-17
-
-    - name: Checkout Code
-      uses: actions/checkout@v4
-
-    - name: Format Code
-      run: cmake -DCLANG_FORMAT_EXECUTABLE=clang-format-17 -P cmake/Format.cmake
-
-    - name: Check Formatting
-      run: git diff --exit-code
-
-  tidy:
-    name: Analyze
-    runs-on: macos-14
-
-    steps:
-    - name: Install Dependencies
-      run: |
-        brew update
-        brew install llvm ninja
-        echo /opt/homebrew/opt/llvm/bin >> $GITHUB_PATH
-
-    - name: Checkout SFML
-      uses: actions/checkout@v4
-      with:
-        repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
-        path: SFML
-
-    - name: Configure SFML CMake
-      run: cmake -S SFML -B SFML/build -GNinja -DCMAKE_INSTALL_PREFIX=SFML/install -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Debug
-
-    - name: Build SFML
-      run: cmake --build SFML/build --target install
-
-    - name: Checkout CSFML
-      uses: actions/checkout@v4
-      with:
-        path: CSFML
-
-    - name: Configure CSFML CMake
-      run: cmake --preset dev -S CSFML -B CSFML/build -DSFML_ROOT=SFML/install -DCMAKE_BUILD_TYPE=Debug
-
-    - name: Tidy
-      run: cmake --build CSFML/build --target tidy
-
-  docs:
-    name: Documentation
-    runs-on: macos-14
-
-    steps:
-    - name: Install Doxygen
-      run: |
-        brew update
-        brew install doxygen ninja || true
-
-    - name: Checkout SFML
-      uses: actions/checkout@v4
-      with:
-        repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
-        path: SFML
-
-    - name: Configure SFML
-      run: cmake -S SFML -B SFML/build -GNinja -DCMAKE_INSTALL_PREFIX=SFML/install
-
-    - name: Build SFML
-      run: cmake --build SFML/build --target install
-
-    - name: Checkout CSFML
-      uses: actions/checkout@v4
-      with:
-        path: CSFML
-
-    - name: Configure CSFML
-      run: cmake -S CSFML -B CSFML/build -GNinja -DSFML_ROOT=SFML/install -DCSFML_BUILD_DOC=ON -DCSFML_LINK_SFML_STATICALLY=ON
-
-    - name: Build Doxygen Site
-      run: cmake --build CSFML/build --target doc
+      - name: Upload CSFML Artefact
+        uses: actions/upload-artifact@v3
+        with:
+          name: CSFML - ${{ matrix.platform.name }}
+          path: ${{ github.workspace }}/CSFML/install

.github/workflows/nuget.yml

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

.github/workflows/release.yml

@@ -1,356 +0,0 @@
-name: Release Builds
-
-on:
-  push:
-    branches:
-      - master
-      - 2.6.x
-    tags:
-      - "**"
-  workflow_dispatch: {}
-
-concurrency:
-  group: release-${{github.ref}}
-  cancel-in-progress: true
-
-env:
-  SFML_VERSION: 3.0.1
-
-jobs:
-  windows-x86:
-    name: Windows x86
-    runs-on: windows-2025
-
-    steps:
-      - name: Cache MinGW x86
-        id: mingw-x86-cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ github.workspace }}/mingw32
-          key: 15.2.0posix-13.0.0-ucrt-r1-x86
-
-      - name: Install MinGW x86
-        if: steps.mingw-x86-cache.outputs.cache-hit != 'true'
-        uses: bwoodsend/setup-winlibs-action@v1
-        id: winlibs-32
-        with:
-          tag: 15.2.0posix-13.0.0-ucrt-r1
-          with_clang: false
-          architecture: 32
-          destination: ${{ github.workspace }}
-          add_to_path: false
-
-      - name: Checkout SFML
-        uses: actions/checkout@v4
-        with:
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v4
-        with:
-          path: CSFML
-
-      - name: Build SFML
-        run: |
-          cmake -S SFML -B SFML-build -A Win32 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build SFML-build --config Release --target install
-
-      - name: Build CSFML
-        run: |
-          cmake -S CSFML -B CSFML-build -A Win32 -G "Visual Studio 17 2022" -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 --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
-        shell: pwsh
-        run: |
-          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"
-
-          Push-Location CSFML-install\lib\gcc
-          & gendef.exe "..\..\bin\csfml-graphics-3.dll"
-          & dlltool.exe -d "csfml-graphics-3.def" -D "..\..\bin\csfml-graphics-3.dll" -l "libcsfml-graphics.a"
-          Remove-Item -Path "csfml-graphics-3.def"
-
-          & gendef.exe "..\..\bin\csfml-window-3.dll"
-          & dlltool.exe -d "csfml-window-3.def" -D "..\..\bin\csfml-window-3.dll" -l "libcsfml-window.a"
-          Remove-Item -Path "csfml-window-3.def"
-
-          & gendef.exe "..\..\bin\csfml-audio-3.dll"
-          & dlltool.exe -d "csfml-audio-3.def" -D "..\..\bin\csfml-audio-3.dll" -l "libcsfml-audio.a"
-          Remove-Item -Path "csfml-audio-3.def"
-
-          & gendef.exe "..\..\bin\csfml-network-3.dll"
-          & dlltool.exe -d "csfml-network-3.def" -D "..\..\bin\csfml-network-3.dll" -l "libcsfml-network.a"
-          Remove-Item -Path "csfml-network-3.def"
-
-          & gendef.exe "..\..\bin\csfml-system-3.dll"
-          & dlltool.exe -d "csfml-system-3.def" -D "..\..\bin\csfml-system-3.dll" -l "libcsfml-system.a"
-          Remove-Item -Path "csfml-system-3.def"
-          Pop-Location
-
-          New-Item -ItemType "directory" -PATH "install\CSFML"
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: CSFML-windows-32-bit
-          path: install/CSFML
-
-  windows-x64:
-    name: Windows x64
-    runs-on: windows-2025
-
-    steps:
-      - name: Cache MinGW x64
-        id: mingw-x64-cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ github.workspace }}/mingw64
-          key: 15.2.0posix-13.0.0-ucrt-r1-x64
-
-      - name: Install MinGW x64
-        if: steps.mingw-x64-cache.outputs.cache-hit != 'true'
-        uses: bwoodsend/setup-winlibs-action@v1
-        id: winlibs-64
-        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
-        uses: actions/checkout@v4
-        with:
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v4
-        with:
-          path: CSFML
-
-      - name: Build SFML
-        run: |
-          cmake -S SFML -B SFML-build -A x64 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build SFML-build --config Release --target install
-
-      - name: Build CSFML
-        run: |
-          cmake -S CSFML -B CSFML-build -A x64 -G "Visual Studio 17 2022" -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 --build CSFML-build --config Release --target install
-
-      - name: Add MinGW to PATH
-        shell: bash
-        run: echo "${{ github.workspace }}\mingw64\bin" >> $GITHUB_PATH
-
-      - name: Generate Import Libs for MinGW
-        shell: pwsh
-        run: |
-          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"
-
-          Push-Location CSFML-install\lib\gcc
-          & gendef.exe "..\..\bin\csfml-graphics-3.dll"
-          & dlltool.exe -d "csfml-graphics-3.def" -D "..\..\bin\csfml-graphics-3.dll" -l "libcsfml-graphics.a"
-          Remove-Item -Path "csfml-graphics-3.def"
-
-          & gendef.exe "..\..\bin\csfml-window-3.dll"
-          & dlltool.exe -d "csfml-window-3.def" -D "..\..\bin\csfml-window-3.dll" -l "libcsfml-window.a"
-          Remove-Item -Path "csfml-window-3.def"
-
-          & gendef.exe "..\..\bin\csfml-audio-3.dll"
-          & dlltool.exe -d "csfml-audio-3.def" -D "..\..\bin\csfml-audio-3.dll" -l "libcsfml-audio.a"
-          Remove-Item -Path "csfml-audio-3.def"
-
-          & gendef.exe "..\..\bin\csfml-network-3.dll"
-          & dlltool.exe -d "csfml-network-3.def" -D "..\..\bin\csfml-network-3.dll" -l "libcsfml-network.a"
-          Remove-Item -Path "csfml-network-3.def"
-
-          & gendef.exe "..\..\bin\csfml-system-3.dll"
-          & dlltool.exe -d "csfml-system-3.def" -D "..\..\bin\csfml-system-3.dll" -l "libcsfml-system.a"
-          Remove-Item -Path "csfml-system-3.def"
-          Pop-Location
-
-          New-Item -ItemType "directory" -PATH "install\CSFML"
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: CSFML-windows-64-bit
-          path: install/CSFML
-
-  windows-arm64:
-    name: Windows ARM64
-    runs-on: windows-2025
-
-    steps:
-      - name: Checkout SFML
-        uses: actions/checkout@v4
-        with:
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v4
-        with:
-          path: CSFML
-
-      - name: Build SFML
-        run: |
-          cmake -S SFML -B SFML-build -A ARM64 -G "Visual Studio 17 2022" -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/SFML-install -DCMAKE_VERBOSE_MAKEFILE=ON
-          cmake --build SFML-build --config Release --target install
-
-      - name: Build CSFML
-        run: |
-          cmake -S CSFML -B CSFML-build -A ARM64 -G "Visual Studio 17 2022" -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 --build CSFML-build --config Release --target install
-
-      - name: Move Files
-        shell: pwsh
-        run: |
-          New-Item -ItemType "directory" -PATH "install\CSFML"
-          Move-Item -Path "CSFML-install\*" -Destination "install\CSFML"
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: CSFML-windows-arm64
-          path: install/CSFML
-
-  macos-x64:
-    name: macOS x64
-    runs-on: macos-13
-
-    steps:
-      - name: Checkout SFML
-        uses: actions/checkout@v4
-        with:
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v4
-        with:
-          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@v4
-        with:
-          name: CSFML-macOS-clang-64-bit
-          path: CSFML-macOS-clang-64-bit.tar.gz
-
-  macos-arm64:
-    name: macOS ARM64
-    runs-on: macos-14
-
-    steps:
-      - name: Checkout SFML
-        uses: actions/checkout@v4
-        with:
-          repository: SFML/SFML
-          ref: ${{ env.SFML_VERSION }}
-          path: SFML
-
-      - name: Checkout CSFML
-        uses: actions/checkout@v4
-        with:
-          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@v4
-        with:
-          name: CSFML-macOS-clang-arm64
-          path: CSFML-macOS-clang-arm64.tar.gz

.gitignore

@@ -1,7 +0,0 @@
-.cache/
-.idea/
-.vs/
-.vscode/
-build/
-cmake-build-*/
-CMakeUserPresets.json

CMakeLists.txt

@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 3.22)
+
+cmake_minimum_required(VERSION 2.8.3)
 
 # define a macro that helps defining an option
 macro(csfml_set_option var default type docstring)
@@ -13,120 +14,63 @@ 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)
-
-# we use the paths from the cmake GNUInstallDirs module as defaults
-# you can override these if you like
-# https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
-include(GNUInstallDirs)
+project(CSFML)
 
 # include the configuration file
-include(${PROJECT_SOURCE_DIR}/cmake/Config.cmake)
+include(${CMAKE_SOURCE_DIR}/cmake/Config.cmake)
 
-# add options to select which modules to build
-csfml_set_option(CSFML_BUILD_WINDOW ON BOOL "ON to build CSFML's Window module. This setting is ignored, if the graphics module is built.")
-csfml_set_option(CSFML_BUILD_GRAPHICS ON BOOL "ON to build CSFML's Graphics module.")
-csfml_set_option(CSFML_BUILD_AUDIO ON BOOL "ON to build CSFML's Audio module.")
-csfml_set_option(CSFML_BUILD_NETWORK ON BOOL "ON to build CSFML's Network module.")
+# setup version numbers
+set(VERSION_MAJOR 2)
+set(VERSION_MINOR 5)
+set(VERSION_PATCH 1)
+
+# add the CSFML header path
+include_directories(${CMAKE_SOURCE_DIR}/include)
 
 # 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")
-endif()
+    set(STATIC_STD_LIBS FALSE CACHE BOOL "TRUE to statically link to the standard libraries, FALSE to use them as DLLs")
 
-# find SFML libraries (C++)
-if(CSFML_LINK_SFML_STATICALLY)
-    set(SFML_STATIC_LIBRARIES ON)
+    # for VC++, we can apply it globally by modifying the compiler flags
+    if(SFML_COMPILER_MSVC AND STATIC_STD_LIBS)
+        foreach(flag
+                CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+            if(${flag} MATCHES "/MD")
+                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
+            endif()
+        endforeach()
+    endif()
 endif()
-set(SFML_MODULES "System")
-if(CSFML_BUILD_AUDIO)
-    list(PREPEND SFML_MODULES "Audio")
-endif()
-if(CSFML_BUILD_GRAPHICS)
-    list(PREPEND SFML_MODULES "Graphics")
-endif()
-if(CSFML_BUILD_WINDOW)
-    list(PREPEND SFML_MODULES "Window")
-endif()
-if(CSFML_BUILD_NETWORK)
-    list(PREPEND SFML_MODULES "Network")
-endif()
-find_package(SFML 3.0.0 COMPONENTS ${SFML_MODULES} REQUIRED)
 
 # add the subdirectories
-add_subdirectory(src/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)
-
-if(SFML_OS_LINUX OR SFML_OS_FREEBSD OR SFML_OS_OPENBSD OR SFML_OS_NETBSD)
-    set(CSFML_INSTALL_PKGCONFIG_DEFAULT ON)
-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")
-
-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")
-
-    foreach(csfml_module IN ITEMS all system window graphics audio network)
-        configure_file(
-            "tools/pkg-config/csfml-${csfml_module}.pc.in"
-            "tools/pkg-config/csfml-${csfml_module}.pc"
-            @ONLY)
-        install(FILES "${CMAKE_CURRENT_BINARY_DIR}/tools/pkg-config/csfml-${csfml_module}.pc"
-            DESTINATION "${CSFML_PKGCONFIG_INSTALL_DIR}")
-    endforeach()
-endif()
-
 # setup the install rules
-install(DIRECTORY include/
-        DESTINATION include
-        COMPONENT devel)
+install(DIRECTORY include
+        DESTINATION .
+        COMPONENT devel
+        PATTERN ".svn" EXCLUDE)
 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")
-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

@@ -1,98 +0,0 @@
-# from here:
-#
-# https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
-
-# Helper function to enable compiler warnings for a specific target
-function(set_target_warnings target)
-    option(CSFML_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
-
-    set(MSVC_WARNINGS
-        /W4 # Baseline reasonable warnings
-        /w14242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
-        /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /w14263 # 'function': member function does not override any base class virtual member function
-        /w14265 # 'classname': class has virtual functions, but destructor is not virtual instances of this class may not be destructed correctly
-        /w14287 # 'operator': unsigned/negative constant mismatch
-        /we4289 # nonstandard extension used: 'variable': loop control variable declared in the for-loop is used outside the for-loop scope
-        /w14296 # 'operator': expression is always 'boolean_value'
-        /w14311 # 'variable': pointer truncation from 'type1' to 'type2'
-        /w14545 # expression before comma evaluates to a function which is missing an argument list
-        /w14546 # function call before comma missing argument list
-        /w14547 # 'operator': operator before comma has no effect; expected operator with side-effect
-        /w14549 # 'operator': operator before comma has no effect; did you intend 'operator'?
-        /w14555 # expression has no effect; expected expression with side- effect
-        /w14619 # pragma warning: there is no warning number 'number'
-        /w14640 # Enable warning on thread un-safe static member initialization
-        /w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may cause unexpected runtime behavior.
-        /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
-
-        # Disables, remove when appropriate
-        /wd4996 # disable warnings about deprecated functions
-        /wd5105 # disable warning about expansion of 'defined' keyword
-    )
-
-    set(CLANG_AND_GCC_WARNINGS
-        -Wall
-        -Wextra # reasonable and standard
-        $<$<COMPILE_LANGUAGE:CXX>:-Wnon-virtual-dtor> # warn the user if a class with virtual functions has a non-virtual destructor. This helps catch hard to track down memory errors
-        -Wcast-align # warn for potential performance problem casts
-        -Wunused # warn on anything being unused
-        $<$<COMPILE_LANGUAGE:CXX>:-Woverloaded-virtual> # warn if you overload (not override) a virtual function
-        -Wconversion # warn on type conversions that may lose data
-        -Wsign-conversion # warn on sign conversions
-        -Wdouble-promotion # warn if float is implicit promoted to double
-        -Wformat=2 # warn on security issues around functions that format output (ie printf)
-        # -Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement (disabled until better compiler support for explicit fallthrough is available)
-        -Wnull-dereference # warn if a null dereference is detected
-        $<$<COMPILE_LANGUAGE:CXX>:-Wold-style-cast> # warn for c-style casts
-        -Wpedantic # warn if non-standard C++ is used
-        -Wno-deprecated-declarations # do not warning about deprecated declarations
-        -Wno-language-extension-token # ignore use of __int64 compiler extension
-    )
-
-    # 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)
-    endif()
-
-    if(CSFML_WARNINGS_AS_ERRORS)
-        list(APPEND CLANG_AND_GCC_WARNINGS -Werror)
-        list(APPEND MSVC_WARNINGS /WX)
-    endif()
-
-    set(CLANG_WARNINGS
-        ${CLANG_AND_GCC_WARNINGS}
-        -Wno-unknown-warning-option # do not warn on GCC-specific warning diagnostic pragmas
-    )
-
-    set(GCC_WARNINGS
-        ${CLANG_AND_GCC_WARNINGS}
-        -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
-        -Wduplicated-cond # warn if if / else chain has duplicated conditions
-        -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
-        # -Wuseless-cast # warn if you perform a cast to the same type (disabled because it is not portable as some typedefs might vary between platforms)
-    )
-
-    # 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
-            -Wduplicated-branches # warn if if / else branches have duplicated code
-        )
-    endif()
-
-    if(MSVC)
-        set(FILE_WARNINGS ${MSVC_WARNINGS})
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
-        set(FILE_WARNINGS ${CLANG_WARNINGS})
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        set(FILE_WARNINGS ${GCC_WARNINGS})
-    else()
-        message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
-    endif()
-
-    target_compile_options(${target} PRIVATE ${FILE_WARNINGS})
-endfunction()

cmake/Config.cmake

@@ -1,44 +1,78 @@
 # 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()
 endif()
 
-# set pkgconfig install directory
-# this could be e.g. macports on mac or msys2 on windows etc.
-set(CSFML_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-
-if(SFML_OS_FREEBSD OR SFML_OS_OPENBSD OR SFML_OS_NETBSD)
-    set(CSFML_PKGCONFIG_DIR "libdata/pkgconfig")
-endif()
-
 # detect the compiler and its version
-# Note: The detection is order is important because:
-# - Visual Studio can both use MSVC and Clang
-# - GNUCXX can still be set on macOS when using Clang
-if(MSVC)
-    set(SFML_COMPILER_MSVC 1)
-
-    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        set(SFML_COMPILER_CLANG_CL 1)
-    endif()
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(SFML_COMPILER_CLANG 1)
+# Note: on some platforms (OS X), CMAKE_COMPILER_IS_GNUCXX is true
+# even when CLANG is used, therefore the Clang test is done first
+if(CMAKE_CXX_COMPILER MATCHES ".*clang[+][+]" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+   # CMAKE_CXX_COMPILER_ID is an internal CMake variable subject to change,
+   # but there is no other way to detect CLang at the moment
+   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()
+elseif(MSVC)
+    set(SFML_COMPILER_MSVC 1)
+    if(MSVC_VERSION EQUAL 1400)
+        set(SFML_MSVC_VERSION 8)
+    elseif(MSVC_VERSION EQUAL 1500)
+        set(SFML_MSVC_VERSION 9)
+    elseif(MSVC_VERSION EQUAL 1600)
+        set(SFML_MSVC_VERSION 10)
+    elseif(MSVC_VERSION EQUAL 1700)
+        set(SFML_MSVC_VERSION 11)
+    elseif(MSVC_VERSION EQUAL 1800)
+        set(SFML_MSVC_VERSION 12)
+    elseif(MSVC_VERSION EQUAL 1900)
+        set(SFML_MSVC_VERSION 14)
+    elseif(MSVC_VERSION LESS_EQUAL 1919)
+        set(SFML_MSVC_VERSION 15)
+    elseif(MSVC_VERSION LESS_EQUAL 1929)
+        set(SFML_MSVC_VERSION 16)
+    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

@@ -1,5 +1,4 @@
 include(CMakeParseArguments)
-include(${PROJECT_SOURCE_DIR}/cmake/CompilerWarnings.cmake)
 
 # add a new target which is a CSFML library
 # ex: csfml_add_library(csfml-graphics
@@ -13,81 +12,62 @@ macro(csfml_add_library target)
     # create the target
     add_library(${target} ${THIS_SOURCES})
 
-    # add the CSFML header path
-    target_include_directories(${target} PUBLIC ${PROJECT_SOURCE_DIR}/include)
-
-    # add warnings
-    set_target_warnings(${target})
-
-    # require C11 and C++17
-    target_compile_features(${target} PUBLIC c_std_11 cxx_std_17)
-
     # define the export symbol of the module
     string(REPLACE "-" "_" NAME_UPPER "${target}")
     string(TOUPPER "${NAME_UPPER}" NAME_UPPER)
     set_target_properties(${target} PROPERTIES DEFINE_SYMBOL ${NAME_UPPER}_EXPORTS)
 
-    if(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)
-            # 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()
+        set_target_properties(${target} PROPERTIES SUFFIX "-${VERSION_MAJOR}${CMAKE_SHARED_LIBRARY_SUFFIX}")
     else()
-        set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -s-d)
-        set_target_properties(${target} PROPERTIES RELEASE_POSTFIX -s)
-        set_target_properties(${target} PROPERTIES MINSIZEREL_POSTFIX -s)
-        set_target_properties(${target} PROPERTIES RELWITHDEBINFO_POSTFIX -s)
-
-        if(CSFML_USE_STATIC_STD_LIBS)
-            set_property(TARGET ${target} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-        endif()
+        set_target_properties(${target} PROPERTIES DEBUG_POSTFIX -d)
+    endif()
+    if (SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
+        # on Windows/gcc get rid of "lib" prefix for shared libraries,
+        # and transform the ".dll.a" suffix into ".a" for import libraries
+        set_target_properties(${target} PROPERTIES PREFIX "")
+        set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".a")
     endif()
 
     # set the version and soversion of the target (for compatible systems -- mostly Linuxes)
-    set_target_properties(${target} PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR})
-    set_target_properties(${target} PROPERTIES VERSION ${PROJECT_VERSION})
+    set_target_properties(${target} PROPERTIES SOVERSION ${VERSION_MAJOR}.${VERSION_MINOR})
+    set_target_properties(${target} PROPERTIES VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
 
     # 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
-    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-        if(CSFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
+    # 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 AND NOT SFML_GCC_VERSION VERSION_LESS "4")
+        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)
-    set_target_properties(${target} PROPERTIES CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
+    # if using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default
+    # (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})
+    target_link_libraries(${target} ${THIS_DEPENDS})
 
     # 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
     install(TARGETS ${target}
             RUNTIME DESTINATION bin COMPONENT bin
-            LIBRARY DESTINATION lib${LIB_SUFFIX} COMPONENT bin
+            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 ${CMAKE_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
@@ -11,34 +14,34 @@ if(SFML_OS_WINDOWS)
                  PATHS "C:/Program Files/HTML Help Workshop" "C:/Program Files (x86)/HTML Help Workshop"
                  DOC "HTML Help Compiler program")
     if(DOXYGEN_HHC_PROGRAM)
-        if(DOXYGEN_VERSION VERSION_LESS "1.10.0")
-            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")
-        endif()
+        set(DOXYGEN_GENERATE_HTMLHELP YES)
+    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)
-configure_file(header.html.in header.html @ONLY)
+set(DOXYGEN_CONFIGURED_INPUT ${DOXYGEN_OUTPUT_DIR}/doxyfile)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/doxyfile.in ${DOXYGEN_CONFIGURED_INPUT} @ONLY)
 
 # copy the files needed by the documentation
-configure_file(doxygen.css html/doxygen.css COPYONLY)
-configure_file(searchOverrides.css html/searchOverrides.css COPYONLY)
+configure_file(${DOXYGEN_INPUT_DIR}/doc/doxygen.css ${DOXYGEN_OUTPUT_DIR}/html/doxygen.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/doxygen.css

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

doc/footer.html

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

doc/header.html

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

doc/header.html.in

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

doc/mainpage.hpp

@@ -3,21 +3,21 @@
 ///
 /// \section welcome Welcome
 /// Welcome to the official SFML documentation for C. Here you will find a detailed
-/// view of all the SFML <a href="./globals_func.html">functions</a>.<br/>
+/// view of all the SFML <a href="./globals_func.htm">functions</a>.<br/>
 /// If you are looking for tutorials, you can visit the official website
-/// at <a href="https://www.sfml-dev.org/">www.sfml-dev.org</a>.
+/// at <a href="http://www.sfml-dev.org/">www.sfml-dev.org</a>.
 ///
 /// \section example Short example
 /// Here is a short example, to show you how simple it is to use SFML in C :
 ///
 /// \code
 ///
-/// #include <CSFML/Audio.h>
-/// #include <CSFML/Graphics.h>
-///
+/// #include <SFML/Audio.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

doc/searchOverrides.css

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

examples/CMakeLists.txt

@@ -1,3 +0,0 @@
-add_executable(example example.c)
-target_link_libraries(example PRIVATE csfml-graphics csfml-audio)
-set_target_warnings(example)

examples/example.c

@@ -1,87 +0,0 @@
-#include <CSFML/Audio.h>
-#include <CSFML/Graphics.h>
-
-#include <stdlib.h>
-
-int main(void)
-{
-    // Create the main window
-    const sfVideoMode mode   = {{800, 600}, 32};
-    sfRenderWindow*   window = sfRenderWindow_create(mode, "SFML window", sfResize | sfClose, sfWindowed, NULL);
-    if (!window)
-        return EXIT_FAILURE;
-
-    // Load a sprite to display
-    const sfTexture* texture = sfTexture_createFromFile("sfml_logo.png", NULL);
-    if (!texture)
-    {
-        sfRenderWindow_destroy(window);
-        return EXIT_FAILURE;
-    }
-    sfSprite*        sprite         = sfSprite_create(texture);
-    const sfVector2f spritePosition = {200, 200};
-    sfSprite_setPosition(sprite, spritePosition);
-
-    // Create a graphical text to display
-    const sfFont* font = sfFont_createFromFile("tuffy.ttf");
-    if (!font)
-    {
-        sfSprite_destroy(sprite);
-        sfTexture_destroy(texture);
-        sfRenderWindow_destroy(window);
-        return EXIT_FAILURE;
-    }
-    sfText* text = sfText_create(font);
-    sfText_setString(text, "Hello, SFML!");
-    sfText_setCharacterSize(text, 50);
-
-    // Load a music to play
-    sfMusic* music = sfMusic_createFromFile("doodle_pop.ogg");
-    if (!music)
-    {
-        sfText_destroy(text);
-        sfFont_destroy(font);
-        sfSprite_destroy(sprite);
-        sfTexture_destroy(texture);
-        sfRenderWindow_destroy(window);
-        return EXIT_FAILURE;
-    }
-
-    // Play the music
-    sfMusic_play(music);
-
-    // Start the game loop
-    sfEvent event;
-    while (sfRenderWindow_isOpen(window))
-    {
-        // Process events
-        while (sfRenderWindow_pollEvent(window, &event))
-        {
-            // Close window : exit
-            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);
-    sfFont_destroy(font);
-    sfSprite_destroy(sprite);
-    sfTexture_destroy(texture);
-    sfRenderWindow_destroy(window);
-
-    return EXIT_SUCCESS;
-}

include/CSFML/Audio.h

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

include/CSFML/Audio/EffectProcessor.h

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

include/CSFML/Audio/SoundChannel.h

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

include/CSFML/Audio/SoundSourceCone.h

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

include/CSFML/Config.h

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

include/CSFML/Graphics.h

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

include/CSFML/Graphics/RenderStates.h

@@ -1,57 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#pragma once
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
-
-#include <CSFML/Graphics/BlendMode.h>
-#include <CSFML/Graphics/CoordinateType.h>
-#include <CSFML/Graphics/StencilMode.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-
-
-////////////////////////////////////////////////////////////
-/// \brief Define the states used for drawing to a RenderTarget
-///
-////////////////////////////////////////////////////////////
-typedef struct
-{
-    sfBlendMode      blendMode;      ///< Blending mode
-    sfStencilMode    stencilMode;    //!< Stencil mode
-    sfTransform      transform;      ///< Transform
-    sfCoordinateType coordinateType; //!< Texture coordinate type
-    const sfTexture* texture;        ///< Texture
-    const sfShader*  shader;         ///< Shader
-} sfRenderStates;
-
-////////////////////////////////////////////////////////////
-/// \brief Define the default values for a RenderState
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfRenderStates sfRenderStates_default;

include/CSFML/Graphics/StencilMode.h

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

include/CSFML/Network.h

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

include/CSFML/System.h

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

include/CSFML/Window/Keyboard.h

@@ -1,414 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#pragma once
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <CSFML/Window/Export.h>
-
-
-////////////////////////////////////////////////////////////
-/// \brief Key codes
-///
-/// The enumerators refer to the "localized" key; i.e. depending
-/// on the layout set by the operating system, a key can be mapped
-/// to `Y` or `Z`.
-///
-////////////////////////////////////////////////////////////
-typedef enum
-{
-    sfKeyUnknown = -1, ///< Unhandled key
-    sfKeyA,            ///< The A key
-    sfKeyB,            ///< The B key
-    sfKeyC,            ///< The C key
-    sfKeyD,            ///< The D key
-    sfKeyE,            ///< The E key
-    sfKeyF,            ///< The F key
-    sfKeyG,            ///< The G key
-    sfKeyH,            ///< The H key
-    sfKeyI,            ///< The I key
-    sfKeyJ,            ///< The J key
-    sfKeyK,            ///< The K key
-    sfKeyL,            ///< The L key
-    sfKeyM,            ///< The M key
-    sfKeyN,            ///< The N key
-    sfKeyO,            ///< The O key
-    sfKeyP,            ///< The P key
-    sfKeyQ,            ///< The Q key
-    sfKeyR,            ///< The R key
-    sfKeyS,            ///< The S key
-    sfKeyT,            ///< The T key
-    sfKeyU,            ///< The U key
-    sfKeyV,            ///< The V key
-    sfKeyW,            ///< The W key
-    sfKeyX,            ///< The X key
-    sfKeyY,            ///< The Y key
-    sfKeyZ,            ///< The Z key
-    sfKeyNum0,         ///< The 0 key
-    sfKeyNum1,         ///< The 1 key
-    sfKeyNum2,         ///< The 2 key
-    sfKeyNum3,         ///< The 3 key
-    sfKeyNum4,         ///< The 4 key
-    sfKeyNum5,         ///< The 5 key
-    sfKeyNum6,         ///< The 6 key
-    sfKeyNum7,         ///< The 7 key
-    sfKeyNum8,         ///< The 8 key
-    sfKeyNum9,         ///< The 9 key
-    sfKeyEscape,       ///< The Escape key
-    sfKeyLControl,     ///< The left Control key
-    sfKeyLShift,       ///< The left Shift key
-    sfKeyLAlt,         ///< The left Alt key
-    sfKeyLSystem,      ///< The left OS specific key: window (Windows and Linux), apple (macOS), ...
-    sfKeyRControl,     ///< The right Control key
-    sfKeyRShift,       ///< The right Shift key
-    sfKeyRAlt,         ///< The right Alt key
-    sfKeyRSystem,      ///< The right OS specific key: window (Windows and Linux), apple (macOS), ...
-    sfKeyMenu,         ///< The Menu key
-    sfKeyLBracket,     ///< The [ key
-    sfKeyRBracket,     ///< The ] key
-    sfKeySemicolon,    ///< The ; key
-    sfKeyComma,        ///< The , key
-    sfKeyPeriod,       ///< The . key
-    sfKeyApostrophe,   ///< The ' key
-    sfKeySlash,        ///< The / key
-    sfKeyBackslash,    ///< The \ key
-    sfKeyGrave,        ///< The ` key
-    sfKeyEqual,        ///< The = key
-    sfKeyHyphen,       ///< The - key (hyphen)
-    sfKeySpace,        ///< The Space key
-    sfKeyEnter,        ///< The Enter/Return key
-    sfKeyBackspace,    ///< The Backspace key
-    sfKeyTab,          ///< The Tabulation key
-    sfKeyPageUp,       ///< The Page up key
-    sfKeyPageDown,     ///< The Page down key
-    sfKeyEnd,          ///< The End key
-    sfKeyHome,         ///< The Home key
-    sfKeyInsert,       ///< The Insert key
-    sfKeyDelete,       ///< The Delete key
-    sfKeyAdd,          ///< The + key
-    sfKeySubtract,     ///< The - key (minus, usually from numpad)
-    sfKeyMultiply,     ///< The * key
-    sfKeyDivide,       ///< The / key
-    sfKeyLeft,         ///< Left arrow
-    sfKeyRight,        ///< Right arrow
-    sfKeyUp,           ///< Up arrow
-    sfKeyDown,         ///< Down arrow
-    sfKeyNumpad0,      ///< The numpad 0 key
-    sfKeyNumpad1,      ///< The numpad 1 key
-    sfKeyNumpad2,      ///< The numpad 2 key
-    sfKeyNumpad3,      ///< The numpad 3 key
-    sfKeyNumpad4,      ///< The numpad 4 key
-    sfKeyNumpad5,      ///< The numpad 5 key
-    sfKeyNumpad6,      ///< The numpad 6 key
-    sfKeyNumpad7,      ///< The numpad 7 key
-    sfKeyNumpad8,      ///< The numpad 8 key
-    sfKeyNumpad9,      ///< The numpad 9 key
-    sfKeyF1,           ///< The F1 key
-    sfKeyF2,           ///< The F2 key
-    sfKeyF3,           ///< The F3 key
-    sfKeyF4,           ///< The F4 key
-    sfKeyF5,           ///< The F5 key
-    sfKeyF6,           ///< The F6 key
-    sfKeyF7,           ///< The F7 key
-    sfKeyF8,           ///< The F8 key
-    sfKeyF9,           ///< The F8 key
-    sfKeyF10,          ///< The F10 key
-    sfKeyF11,          ///< The F11 key
-    sfKeyF12,          ///< The F12 key
-    sfKeyF13,          ///< The F13 key
-    sfKeyF14,          ///< The F14 key
-    sfKeyF15,          ///< The F15 key
-    sfKeyPause,        ///< The Pause key
-} sfKeyCode;
-
-enum
-{
-    sfKeyCount = sfKeyPause + 1 ///< The total number of keyboard keys
-};
-
-////////////////////////////////////////////////////////////
-/// \brief Scancodes
-///
-/// The enumerators are bound to a physical key and do not depend on
-/// the keyboard layout used by the operating system. Usually, the AT-101
-/// keyboard can be used as reference for the physical position of the keys.
-///
-////////////////////////////////////////////////////////////
-typedef enum
-{
-    sfScanUnknown = -1, //!< Represents any scancode not present in this enum
-    sfScanA       = 0,  //!< Keyboard a and A key
-    sfScanB,            //!< Keyboard b and B key
-    sfScanC,            //!< Keyboard c and C key
-    sfScanD,            //!< Keyboard d and D key
-    sfScanE,            //!< Keyboard e and E key
-    sfScanF,            //!< Keyboard f and F key
-    sfScanG,            //!< Keyboard g and G key
-    sfScanH,            //!< Keyboard h and H key
-    sfScanI,            //!< Keyboard i and I key
-    sfScanJ,            //!< Keyboard j and J key
-    sfScanK,            //!< Keyboard k and K key
-    sfScanL,            //!< Keyboard l and L key
-    sfScanM,            //!< Keyboard m and M key
-    sfScanN,            //!< Keyboard n and N key
-    sfScanO,            //!< Keyboard o and O key
-    sfScanP,            //!< Keyboard p and P key
-    sfScanQ,            //!< Keyboard q and Q key
-    sfScanR,            //!< Keyboard r and R key
-    sfScanS,            //!< Keyboard s and S key
-    sfScanT,            //!< Keyboard t and T key
-    sfScanU,            //!< Keyboard u and U key
-    sfScanV,            //!< Keyboard v and V key
-    sfScanW,            //!< Keyboard w and W key
-    sfScanX,            //!< Keyboard x and X key
-    sfScanY,            //!< Keyboard y and Y key
-    sfScanZ,            //!< Keyboard z and Z key
-    sfScanNum1,         //!< Keyboard 1 and ! key
-    sfScanNum2,         //!< Keyboard 2 and @ key
-    sfScanNum3,         //!< Keyboard 3 and # key
-    sfScanNum4,         //!< Keyboard 4 and $ key
-    sfScanNum5,         //!< Keyboard 5 and % key
-    sfScanNum6,         //!< Keyboard 6 and ^ key
-    sfScanNum7,         //!< Keyboard 7 and & key
-    sfScanNum8,         //!< Keyboard 8 and * key
-    sfScanNum9,         //!< Keyboard 9 and ) key
-    sfScanNum0,         //!< Keyboard 0 and ) key
-    sfScanEnter,        //!< Keyboard Enter/Return key
-    sfScanEscape,       //!< Keyboard Escape key
-    sfScanBackspace,    //!< Keyboard Backspace key
-    sfScanTab,          //!< Keyboard Tab key
-    sfScanSpace,        //!< Keyboard Space key
-    sfScanHyphen,       //!< Keyboard - and _ key
-    sfScanEqual,        //!< Keyboard = and +
-    sfScanLBracket,     //!< Keyboard [ and { key
-    sfScanRBracket,     //!< Keyboard ] and } key
-    // For US keyboards mapped to key 29 (Microsoft Keyboard Scan Code Specification)
-    // For Non-US keyboards mapped to key 42 (Microsoft Keyboard Scan Code Specification)
-    // Typical language mappings: Belg:£µ` FrCa:<>} Dan:*' Dutch:`´ Fren:µ* Ger:'# Ital:§ù LatAm:[}` Nor:*@ Span:ç} Swed:*' Swiss:$£} UK:~# Brazil:}]
-    sfScanBackslash,      //!< Keyboard \ and | key OR various keys for Non-US keyboards
-    sfScanSemicolon,      //!< Keyboard ; and : key
-    sfScanApostrophe,     //!< Keyboard ' and " key
-    sfScanGrave,          //!< Keyboard ` and ~ key
-    sfScanComma,          //!< Keyboard , and < key
-    sfScanPeriod,         //!< Keyboard . and > key
-    sfScanSlash,          //!< Keyboard / and ? key
-    sfScanF1,             //!< Keyboard F1 key
-    sfScanF2,             //!< Keyboard F2 key
-    sfScanF3,             //!< Keyboard F3 key
-    sfScanF4,             //!< Keyboard F4 key
-    sfScanF5,             //!< Keyboard F5 key
-    sfScanF6,             //!< Keyboard F6 key
-    sfScanF7,             //!< Keyboard F7 key
-    sfScanF8,             //!< Keyboard F8 key
-    sfScanF9,             //!< Keyboard F9 key
-    sfScanF10,            //!< Keyboard F10 key
-    sfScanF11,            //!< Keyboard F11 key
-    sfScanF12,            //!< Keyboard F12 key
-    sfScanF13,            //!< Keyboard F13 key
-    sfScanF14,            //!< Keyboard F14 key
-    sfScanF15,            //!< Keyboard F15 key
-    sfScanF16,            //!< Keyboard F16 key
-    sfScanF17,            //!< Keyboard F17 key
-    sfScanF18,            //!< Keyboard F18 key
-    sfScanF19,            //!< Keyboard F19 key
-    sfScanF20,            //!< Keyboard F20 key
-    sfScanF21,            //!< Keyboard F21 key
-    sfScanF22,            //!< Keyboard F22 key
-    sfScanF23,            //!< Keyboard F23 key
-    sfScanF24,            //!< Keyboard F24 key
-    sfScanCapsLock,       //!< Keyboard Caps %Lock key
-    sfScanPrintScreen,    //!< Keyboard Print Screen key
-    sfScanScrollLock,     //!< Keyboard Scroll %Lock key
-    sfScanPause,          //!< Keyboard Pause key
-    sfScanInsert,         //!< Keyboard Insert key
-    sfScanHome,           //!< Keyboard Home key
-    sfScanPageUp,         //!< Keyboard Page Up key
-    sfScanDelete,         //!< Keyboard Delete Forward key
-    sfScanEnd,            //!< Keyboard End key
-    sfScanPageDown,       //!< Keyboard Page Down key
-    sfScanRight,          //!< Keyboard Right Arrow key
-    sfScanLeft,           //!< Keyboard Left Arrow key
-    sfScanDown,           //!< Keyboard Down Arrow key
-    sfScanUp,             //!< Keyboard Up Arrow key
-    sfScanNumLock,        //!< Keypad Num %Lock and Clear key
-    sfScanNumpadDivide,   //!< Keypad / key
-    sfScanNumpadMultiply, //!< Keypad * key
-    sfScanNumpadMinus,    //!< Keypad - key
-    sfScanNumpadPlus,     //!< Keypad + key
-    sfScanNumpadEqual,    //!< keypad = key
-    sfScanNumpadEnter,    //!< Keypad Enter/Return key
-    sfScanNumpadDecimal,  //!< Keypad . and Delete key
-    sfScanNumpad1,        //!< Keypad 1 and End key
-    sfScanNumpad2,        //!< Keypad 2 and Down Arrow key
-    sfScanNumpad3,        //!< Keypad 3 and Page Down key
-    sfScanNumpad4,        //!< Keypad 4 and Left Arrow key
-    sfScanNumpad5,        //!< Keypad 5 key
-    sfScanNumpad6,        //!< Keypad 6 and Right Arrow key
-    sfScanNumpad7,        //!< Keypad 7 and Home key
-    sfScanNumpad8,        //!< Keypad 8 and Up Arrow key
-    sfScanNumpad9,        //!< Keypad 9 and Page Up key
-    sfScanNumpad0,        //!< Keypad 0 and Insert key
-    // For US keyboards doesn't exist
-    // For Non-US keyboards mapped to key 45 (Microsoft Keyboard Scan Code Specification)
-    // Typical language mappings: Belg:<\> FrCa:«°» Dan:<\> Dutch:]|[ Fren:<> Ger:<|> Ital:<> LatAm:<> Nor:<> Span:<> Swed:<|> Swiss:<\> UK:\| Brazil: \|.
-    sfScanNonUsBackslash,     //!< Keyboard Non-US \ and | key
-    sfScanApplication,        //!< Keyboard Application key
-    sfScanExecute,            //!< Keyboard Execute key
-    sfScanModeChange,         //!< Keyboard Mode Change key
-    sfScanHelp,               //!< Keyboard Help key
-    sfScanMenu,               //!< Keyboard Menu key
-    sfScanSelect,             //!< Keyboard Select key
-    sfScanRedo,               //!< Keyboard Redo key
-    sfScanUndo,               //!< Keyboard Undo key
-    sfScanCut,                //!< Keyboard Cut key
-    sfScanCopy,               //!< Keyboard Copy key
-    sfScanPaste,              //!< Keyboard Paste key
-    sfScanVolumeMute,         //!< Keyboard Volume Mute key
-    sfScanVolumeUp,           //!< Keyboard Volume Up key
-    sfScanVolumeDown,         //!< Keyboard Volume Down key
-    sfScanMediaPlayPause,     //!< Keyboard Media Play Pause key
-    sfScanMediaStop,          //!< Keyboard Media Stop key
-    sfScanMediaNextTrack,     //!< Keyboard Media Next Track key
-    sfScanMediaPreviousTrack, //!< Keyboard Media Previous Track key
-    sfScanLControl,           //!< Keyboard Left Control key
-    sfScanLShift,             //!< Keyboard Left Shift key
-    sfScanLAlt,               //!< Keyboard Left Alt key
-    sfScanLSystem,            //!< Keyboard Left System key
-    sfScanRControl,           //!< Keyboard Right Control key
-    sfScanRShift,             //!< Keyboard Right Shift key
-    sfScanRAlt,               //!< Keyboard Right Alt key
-    sfScanRSystem,            //!< Keyboard Right System key
-    sfScanBack,               //!< Keyboard Back key
-    sfScanForward,            //!< Keyboard Forward key
-    sfScanRefresh,            //!< Keyboard Refresh key
-    sfScanStop,               //!< Keyboard Stop key
-    sfScanSearch,             //!< Keyboard Search key
-    sfScanFavorites,          //!< Keyboard Favorites key
-    sfScanHomePage,           //!< Keyboard Home Page key
-    sfScanLaunchApplication1, //!< Keyboard Launch Application 1 key
-    sfScanLaunchApplication2, //!< Keyboard Launch Application 2 key
-    sfScanLaunchMail,         //!< Keyboard Launch Mail key
-    sfScanLaunchMediaSelect,  //!< Keyboard Launch Media Select key
-} sfScancode;
-
-enum
-{
-    sfScancodeCount = sfScanLaunchMediaSelect + 1 //!< The total number of scancodes
-};
-
-////////////////////////////////////////////////////////////
-/// \brief Check if a key is pressed
-///
-/// \param key Key to check
-///
-/// \return true if the key is pressed, false otherwise
-///
-/// \see sfKeyboard_isScancodePressed
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfKeyboard_isKeyPressed(sfKeyCode key);
-
-////////////////////////////////////////////////////////////
-/// \brief Check if a key is pressed
-///
-/// \param code Scancode to check
-///
-/// \return true if the physical key is pressed, false otherwise
-///
-/// \see sfKeyboard_isKeyPressed
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfKeyboard_isScancodePressed(sfScancode code);
-
-////////////////////////////////////////////////////////////
-/// \brief Localize a physical key to a logical one
-///
-/// \param code Scancode to localize
-///
-/// \return The key corresponding to the scancode under the current
-///         keyboard layout used by the operating system, or
-///         sfKeyUnknown when the scancode cannot be mapped
-///         to a Key.
-///
-/// \see sfKeyboard_delocalize
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfKeyCode sfKeyboard_localize(sfScancode code);
-
-////////////////////////////////////////////////////////////
-/// \brief Identify the physical key corresponding to a logical one
-///
-/// \param key Key to "delocalize"
-///
-/// \return The scancode corresponding to the key under the current
-///         keyboard layout used by the operating system, or
-///         sfScanUnknown when the key cannot be mapped
-///         to a sfScancode.
-///
-/// \see sfKeyboard_localize
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfScancode sfKeyboard_delocalize(sfKeyCode key);
-
-////////////////////////////////////////////////////////////
-/// \brief Provide a string representation for a given scancode
-///
-/// The returned string is a short, non-technical description of
-/// the key represented with the given scancode. Most effectively
-/// used in user interfaces, as the description for the key takes
-/// the users keyboard layout into consideration.
-///
-/// \warning The result is OS-dependent: for example, sfScanLSystem
-///          is "Left Meta" on Linux, "Left Windows" on Windows and
-///          "Left Command" on macOS.
-///
-/// The current keyboard layout set by the operating system is used to
-/// interpret the scancode: for example, sfKeySemicolon is
-/// mapped to ";" for layout and to "é" for others.
-///
-/// The returned const char* owns the string and must be freed to
-/// avoid memory leaks.
-///
-/// \param code Scancode to describe
-///
-/// \return The localized description of the code
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API const char* sfKeyboard_getDescription(sfScancode code);
-
-////////////////////////////////////////////////////////////
-/// \brief Show or hide the virtual keyboard.
-///
-/// \warning The virtual keyboard is not supported on all
-///          systems. It will typically be implemented on mobile OSes
-///          (Android, iOS) but not on desktop OSes (Windows, Linux, ...).
-///
-/// If the virtual keyboard is not available, this function does nothing.
-///
-/// \param visible True to show, false to hide
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfKeyboard_setVirtualKeyboardVisible(bool visible);

include/CSFML/Window/Vulkan.h

@@ -1,87 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// 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.
-//
-////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <CSFML/Window/Export.h>
-
-#include <stddef.h>
-
-
-typedef struct VkInstance_T* VkInstance;
-
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
-    defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-
-typedef struct VkSurfaceKHR_T* VkSurfaceKHR;
-
-#else
-
-typedef uint64_t VkSurfaceKHR;
-
-#endif
-
-typedef struct VkAllocationCallbacks VkAllocationCallbacks;
-
-
-typedef void (*sfVulkanFunctionPointer)(void);
-
-////////////////////////////////////////////////////////////
-/// \brief Tell whether or not the system supports Vulkan
-///
-/// This function should always be called before using
-/// the Vulkan features. If it returns false, then
-/// any attempt to use Vulkan will fail.
-///
-/// If only compute is required, set \a requireGraphics
-/// to false to skip checking for the extensions necessary
-/// for graphics rendering.
-///
-/// \param requireGraphics
-///
-/// \return True if Vulkan is supported, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfVulkan_isAvailable(bool requireGraphics);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the address of a Vulkan function
-///
-/// \param name Name of the function to get the address of
-///
-/// \return Address of the Vulkan function, 0 on failure
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfVulkanFunctionPointer sfVulkan_getFunction(const char* name);
-
-////////////////////////////////////////////////////////////
-/// \brief Get Vulkan instance extensions required for graphics
-///
-/// \param count Pointer to a variable that will be filled with the number of instance extensions in the array
-///
-/// \return Vulkan instance extensions required for graphics
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API const char* const* sfVulkan_getGraphicsRequiredInstanceExtensions(size_t* count);

include/CSFML/Window/WindowBase.h

@@ -1,428 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#pragma once
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <CSFML/Window/Export.h>
-
-#include <CSFML/System/Time.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Event.h>
-#include <CSFML/Window/Types.h>
-#include <CSFML/Window/VideoMode.h>
-#include <CSFML/Window/Vulkan.h>
-#include <CSFML/Window/WindowHandle.h>
-
-
-////////////////////////////////////////////////////////////
-/// \brief Enumeration of window creation styles
-///
-////////////////////////////////////////////////////////////
-typedef enum
-{
-    sfNone     = 0,      ///< No border / title bar (this flag and all others are mutually exclusive)
-    sfTitlebar = 1 << 0, ///< Title bar + fixed border
-    sfResize   = 1 << 1, ///< Titlebar + resizable border + maximize button
-    sfClose    = 1 << 2, ///< Titlebar + close button
-
-    sfDefaultStyle = sfTitlebar | sfResize | sfClose ///< Default window style
-} sfWindowStyle;
-
-
-////////////////////////////////////////////////////////////
-/// \brief Enumeration of the window states
-///
-////////////////////////////////////////////////////////////
-typedef enum
-{
-    sfWindowed,  //!< Floating window
-    sfFullscreen //!< Fullscreen window
-} sfWindowState;
-
-
-////////////////////////////////////////////////////////////
-/// \brief Construct a new window
-///
-/// This function creates the window with the size and pixel
-/// depth defined in \a mode. An optional style can be passed to
-/// customize the look and behaviour of the window (borders,
-/// title bar, resizable, closable, ...). If \a style contains
-/// sfFullscreen, then \a mode must be a valid video mode.
-///
-/// \param mode     Video mode to use (defines the width, height and depth of the rendering area of the windowBase)
-/// \param title    Title of the window
-/// \param style    Window style
-/// \param state    Window state
-///
-/// \return A new sfWindow object
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, uint32_t style, sfWindowState state);
-
-////////////////////////////////////////////////////////////
-/// \brief Construct a new window (with a UTF-32 title)
-///
-/// This function creates the window with the size and pixel
-/// depth defined in \a mode. An optional style can be passed to
-/// customize the look and behaviour of the window (borders,
-/// title bar, resizable, closable, ...). If \a style contains
-/// sfFullscreen, then \a mode must be a valid video mode.
-///
-/// \param mode     Video mode to use (defines the width, height and depth of the rendering area of the windowBase)
-/// \param title    Title of the window (UTF-32)
-/// \param style    Window style
-/// \param state    Window state
-///
-/// \return A new sfWindow object
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowBase* sfWindowBase_createUnicode(sfVideoMode mode, const sfChar32* title, uint32_t style, sfWindowState state);
-
-////////////////////////////////////////////////////////////
-/// \brief Construct a window from an existing control
-///
-/// \param handle   Platform-specific handle of the control
-///
-/// \return A new sfWindow object
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowBase* sfWindowBase_createFromHandle(sfWindowHandle handle);
-
-////////////////////////////////////////////////////////////
-/// \brief Destroy a window
-///
-/// \param windowBase Window to destroy
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_destroy(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Close a window and destroy all the attached resources
-///
-/// After calling this function, the sfWindow object remains
-/// valid, you must call sfWindowBase_destroy to actually delete it.
-/// All other functions such as sfWindowBase_pollEvent or sfWindowBase_display
-/// will still work (i.e. you don't have to test sfWindowBase_isOpen
-/// every time), and will have no effect on closed windows.
-///
-/// \param windowBase Window object
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_close(sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Tell whether or not a window is opened
-///
-/// This function returns whether or not the window exists.
-/// Note that a hidden window (sfWindowBase_setVisible(false)) will return
-/// true.
-///
-/// \param windowBase Window object
-///
-/// \return true if the window is opened, false if it has been closed
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfWindowBase_isOpen(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Pop the event on top of event queue, if any, and return it
-///
-/// This function is not blocking: if there's no pending event then
-/// it will return false and leave \a event unmodified.
-/// Note that more than one event may be present in the event queue,
-/// thus you should always call this function in a loop
-/// to make sure that you process every pending event.
-///
-/// \param windowBase Window object
-/// \param event      Event to fill, if any
-///
-/// \return true if an event was returned, or false if the event queue was empty
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfWindowBase_pollEvent(sfWindowBase* windowBase, 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 (sfWindowBase_waitEvent(windowBase, timeout, &event))
-/// {
-///    // process event...
-/// }
-/// \endcode
-///
-/// \param windowBase Window base object
-/// \param timeout    Maximum time to wait (`sfTime_Zero` for infinite)
-/// \param event      Event to fill, if any
-///
-/// \return true if an event was returned, false if event queue was empty or function timed out
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfTime timeout, sfEvent* event);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the position of a window
-///
-/// \param windowBase Window object
-///
-/// \return Position in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfVector2i sfWindowBase_getPosition(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Change the position of a window on screen
-///
-/// This function only works for top-level windows
-/// (i.e. it will be ignored for windows created from
-/// the handle of a child window/control).
-///
-/// \param windowBase Window object
-/// \param position   New position of the windowBase, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setPosition(sfWindowBase* windowBase, sfVector2i position);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the size of the rendering region of a window
-///
-/// The size doesn't include the titlebar and borders
-/// of the window.
-///
-/// \param windowBase Window object
-///
-/// \return Size in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfVector2u sfWindowBase_getSize(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Change the size of the rendering region of a window
-///
-/// \param windowBase Window object
-/// \param size       New size, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setSize(sfWindowBase* windowBase, sfVector2u size);
-
-////////////////////////////////////////////////////////////
-/// \brief Set the minimum window rendering region size
-///
-/// Pass a `NULL` vector to unset the minimum size
-///
-/// \param windowBase  Window object
-/// \param minimumSize New minimum size, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMinimumSize(sfWindowBase* windowBase, const sfVector2u* minimumSize);
-
-////////////////////////////////////////////////////////////
-/// \brief Set the maximum window rendering region size
-///
-/// Pass a `NULL` vector to unset the maximum size
-///
-/// \param windowBase  Window object
-/// \param maximumSize New maximum size, in pixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMaximumSize(sfWindowBase* windowBase, const sfVector2u* maximumSize);
-
-////////////////////////////////////////////////////////////
-/// \brief Change the title of a window
-///
-/// \param windowBase Window object
-/// \param title      New title
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setTitle(sfWindowBase* windowBase, const char* title);
-
-////////////////////////////////////////////////////////////
-/// \brief Change the title of a window (with a UTF-32 string)
-///
-/// \param windowBase Window object
-/// \param title      New title
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const sfChar32* title);
-
-////////////////////////////////////////////////////////////
-/// \brief Change a window's icon
-///
-/// \a pixels must be an array of \a width x \a height pixels
-/// in 32-bits RGBA format.
-///
-/// \param windowBase Window object
-/// \param size       Icon's size, in pixels
-/// \param pixels     Pointer to the array of pixels in memory
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setIcon(sfWindowBase* windowBase, sfVector2u size, const uint8_t* pixels);
-
-////////////////////////////////////////////////////////////
-/// \brief Show or hide a window
-///
-/// \param windowBase Window object
-/// \param visible    true to show the windowBase, false to hide it
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setVisible(sfWindowBase* windowBase, bool visible);
-
-////////////////////////////////////////////////////////////
-/// \brief Show or hide the mouse cursor
-///
-/// \param windowBase Window object
-/// \param visible    true to show, false to hide
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, bool visible);
-
-////////////////////////////////////////////////////////////
-/// \brief Grab or release the mouse cursor
-///
-/// If set, grabs the mouse cursor inside this window's client
-/// area so it may no longer be moved outside its bounds.
-/// Note that grabbing is only active while the window has
-/// focus and calling this function for fullscreen windows
-/// won't have any effect (fullscreen windows always grab the
-/// cursor).
-///
-/// \param windowBase Window object
-/// \param grabbed    true to enable, false to disable
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, bool grabbed);
-
-////////////////////////////////////////////////////////////
-/// \brief Set the displayed cursor to a native system cursor
-///
-/// Upon window creation, the arrow cursor is used by default.
-///
-/// \warning The cursor must not be destroyed while in use by
-///          the window.
-///
-/// \warning Features related to Cursor are not supported on
-///          iOS and Android.
-///
-/// \param windowBase Window object
-/// \param cursor     Native system cursor type to display
-///
-/// \see sfCursor_createFromSystem
-/// \see sfCursor_createFromPixels
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMouseCursor(sfWindowBase* windowBase, const sfCursor* cursor);
-
-////////////////////////////////////////////////////////////
-/// \brief Enable or disable automatic key-repeat
-///
-/// If key repeat is enabled, you will receive repeated
-/// KeyPress events while keeping a key pressed. If it is disabled,
-/// you will only get a single event when the key is pressed.
-///
-/// Key repeat is enabled by default.
-///
-/// \param windowBase Window object
-/// \param enabled    true to enable, false to disable
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, bool enabled);
-
-////////////////////////////////////////////////////////////
-/// \brief Change the joystick threshold
-///
-/// The joystick threshold is the value below which
-/// no JoystickMoved event will be generated.
-///
-/// \param windowBase Window object
-/// \param threshold  New threshold, in the range [0, 100]
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setJoystickThreshold(sfWindowBase* windowBase, float threshold);
-
-////////////////////////////////////////////////////////////
-/// \brief Request the current window to be made the active
-/// foreground window
-///
-/// At any given time, only one window may have the input focus
-/// to receive input events such as keystrokes or mouse events.
-/// If a window requests focus, it only hints to the operating
-/// system, that it would like to be focused. The operating system
-/// is free to deny the request.
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_requestFocus(sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Check whether the window has the input focus
-///
-/// At any given time, only one window may have the input focus
-/// to receive input events such as keystrokes or most mouse
-/// events.
-///
-/// \return True if window has focus, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfWindowBase_hasFocus(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the OS-specific handle of the window
-///
-/// The type of the returned handle is sfWindowHandle,
-/// which is a typedef to the handle type defined by the OS.
-/// You shouldn't need to use this function, unless you have
-/// very specific stuff to implement that SFML doesn't support,
-/// or implement a temporary workaround until a bug is fixed.
-///
-/// \param windowBase Window object
-///
-/// \return System handle of the window
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowHandle sfWindowBase_getNativeHandle(const sfWindowBase* windowBase);
-
-////////////////////////////////////////////////////////////
-/// \brief Create a Vulkan rendering surface
-///
-/// \param windowBase Window object
-/// \param instance  Vulkan instance
-/// \param surface   Created surface
-/// \param allocator Allocator to use
-///
-/// \return True if surface creation was successful, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_WINDOW_API bool sfWindowBase_createVulkanSurface(sfWindowBase*                windowBase,
-                                                       const VkInstance*            instance,
-                                                       VkSurfaceKHR*                surface,
-                                                       const VkAllocationCallbacks* allocator);

include/SFML/Audio.h

@@ -0,0 +1,43 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <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;
+#include <SFML/Audio/Export.h>
+#include <SFML/System/Vector3.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -87,7 +68,7 @@ CSFML_AUDIO_API void sfListener_setPosition(sfVector3f position);
 /// \return The listener's position
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfVector3f sfListener_getPosition(void);
+CSFML_AUDIO_API sfVector3f sfListener_getPosition();
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the orientation of the forward vector in the scene
@@ -110,44 +91,7 @@ CSFML_AUDIO_API void sfListener_setDirection(sfVector3f direction);
 /// \return Listener's forward vector (not normalized)
 ///
 ////////////////////////////////////////////////////////////
-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);
+CSFML_AUDIO_API sfVector3f sfListener_getDirection();
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the upward vector of the listener in the scene
@@ -170,4 +114,7 @@ CSFML_AUDIO_API void sfListener_setUpVector(sfVector3f upVector);
 /// \return Listener's upward vector (not normalized)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfVector3f sfListener_getUpVector(void);
+CSFML_AUDIO_API sfVector3f sfListener_getUpVector();
+
+
+#endif // SFML_LISTENER_H

include/SFML/Audio/Music.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <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/InputStream.h>
-#include <CSFML/System/Time.h>
-#include <CSFML/System/Vector3.h>
-
+#include <SFML/Audio/Export.h>
+#include <SFML/Audio/SoundStatus.h>
+#include <SFML/Audio/Types.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Time.h>
+#include <SFML/System/Vector3.h>
 #include <stddef.h>
 
 
@@ -58,7 +54,7 @@ typedef struct
 /// This function doesn't start playing the music (call
 /// sfMusic_play to do so).
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param filename Path of the music file to open
@@ -74,7 +70,7 @@ CSFML_AUDIO_API sfMusic* sfMusic_createFromFile(const char* filename);
 /// This function doesn't start playing the music (call
 /// sfMusic_play to do so).
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param data        Pointer to the file data in memory
@@ -91,7 +87,7 @@ CSFML_AUDIO_API sfMusic* sfMusic_createFromMemory(const void* data, size_t sizeI
 /// This function doesn't start playing the music (call
 /// sfMusic_play to do so).
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param stream Source stream to read from
@@ -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);
-
-////////////////////////////////////////////////////////////
-/// \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);
+CSFML_AUDIO_API sfBool sfMusic_getLoop(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Audio/EffectProcessor.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 <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 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Audio/SoundChannel.h>
-#include <CSFML/Audio/Types.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Time.h>
-
+#include <SFML/Audio/Export.h>
+#include <SFML/Audio/Types.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Time.h>
 #include <stddef.h>
 
 
@@ -41,7 +39,7 @@
 /// \brief Create a new sound buffer and load it from a file
 ///
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param filename Path of the sound file to load
@@ -55,7 +53,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromFile(const char* filename
 /// \brief Create a new sound buffer and load it from a file in memory
 ///
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param data        Pointer to the file data in memory
@@ -70,7 +68,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromMemory(const void* data,
 /// \brief Create a new sound buffer and load it from a custom stream
 ///
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \param stream Source stream to read from
@@ -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 sampleCount    Number of samples in the array
-/// \param channelCount   Number of channels (1 = mono, 2 = stereo, ...)
-/// \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
+/// \param samples      Pointer to the array of samples in memory
+/// \param sampleCount  Number of samples in the array
+/// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
+/// \param sampleRate   Sample rate (number of samples to play per second)
 ///
 /// \return A new sfSoundBuffer object (NULL if failed)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(
-    const int16_t*  samples,
-    uint64_t        sampleCount,
-    unsigned int    channelCount,
-    unsigned int    sampleRate,
-    sfSoundChannel* channelMapData,
-    size_t          channelMapSize);
+CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(const sfInt16* samples, sfUint64 sampleCount, unsigned int channelCount, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound buffer by copying an existing one
@@ -120,28 +110,28 @@ 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
 ///
 /// Here is a complete list of all the supported audio formats:
-/// ogg, wav, flac, mp3, aiff, au, raw, paf, svx, nist, voc, ircam,
+/// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
 /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
 ///
 /// \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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Audio/Types.h>
+#include <SFML/Audio/Export.h>
+#include <SFML/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);
 
-////////////////////////////////////////////////////////////
-/// \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);
+#endif // SFML_SOUNDBUFFERRECORDER_H

include/SFML/Audio/SoundRecorder.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Audio/SoundChannel.h>
-#include <CSFML/Audio/Types.h>
-#include <CSFML/System/Time.h>
-
+#include <SFML/Audio/Export.h>
+#include <SFML/Audio/Types.h>
+#include <SFML/System/Time.h>
 #include <stddef.h>
 
 
-typedef bool (*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 void (*sfSoundRecorderStopCallback)(void*); ///< Type of the callback used when stopping a capture
+typedef sfBool (*sfSoundRecorderStartCallback)(void*);                           ///< Type of the callback used when starting a capture
+typedef sfBool (*sfSoundRecorderProcessCallback)(const sfInt16*, size_t, void*); ///< Type of the callback used to process audio data
+typedef 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,24 +110,43 @@ 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 Get a list of the names of all available audio capture devices
+/// \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 availabe audio capture devices
 ///
 /// This function returns an array of strings (null terminated),
-/// containing the names of all available audio capture devices.
-/// If no devices are available, then NULL is returned.
+/// containing the names of all availabe audio capture devices.
+/// If no devices are available then NULL is returned.
 ///
 /// \param count Pointer to a variable that will be filled with the number of modes in the array
 ///
 /// \return An array of strings containing the names
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const char* 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
@@ -140,7 +157,7 @@ CSFML_AUDIO_API const char* const* sfSoundRecorder_getAvailableDevices(size_t* c
 /// \return The name of the default audio capture device (null terminated)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const char* sfSoundRecorder_getDefaultDevice(void);
+CSFML_AUDIO_API const char* sfSoundRecorder_getDefaultDevice();
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the 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
-///                      mono (1) and stereo (2) are supported.
+/// \param channelCount Number of channels. Currently only
+///                     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
-///
-/// 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);
+
+#endif // SFML_SOUNDRECORDER_H

include/SFML/Audio/SoundStatus.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 sfSoundBuffer         sfSoundBuffer;
+
+typedef struct sfMusic sfMusic;
+typedef struct sfSound sfSound;
+typedef struct sfSoundBuffer sfSoundBuffer;
 typedef struct sfSoundBufferRecorder sfSoundBufferRecorder;
-typedef struct sfSoundRecorder       sfSoundRecorder;
-typedef struct sfSoundStream         sfSoundStream;
+typedef struct sfSoundRecorder sfSoundRecorder;
+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-2018 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 5
+#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();
+////////////////////////////////////////////////////////////
+#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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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                                                      \
-    CSFML_EXTERN_C __declspec(dllexport) unsigned long NvOptimusEnablement                  = 1; \
-    CSFML_EXTERN_C __declspec(dllexport) unsigned long AmdPowerXpressRequestHighPerformance = 1;
+    #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE \
+                CSFML_EXTERN_C __declspec(dllexport) unsigned long NvOptimusEnablement = 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Window/Clipboard.h>
-#include <CSFML/Window/Context.h>
-#include <CSFML/Window/Cursor.h>
-#include <CSFML/Window/Event.h>
-#include <CSFML/Window/Joystick.h>
-#include <CSFML/Window/JoystickIdentification.h>
-#include <CSFML/Window/Keyboard.h>
-#include <CSFML/Window/Mouse.h>
-#include <CSFML/Window/Sensor.h>
-#include <CSFML/Window/Touch.h>
-#include <CSFML/Window/VideoMode.h>
-#include <CSFML/Window/Window.h>
+#include <SFML/Window.h>
+#include <SFML/Graphics/BlendMode.h>
+#include <SFML/Graphics/CircleShape.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/ConvexShape.h>
+#include <SFML/Graphics/Font.h>
+#include <SFML/Graphics/FontInfo.h>
+#include <SFML/Graphics/Glyph.h>
+#include <SFML/Graphics/Image.h>
+#include <SFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/RectangleShape.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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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>
 
 
 ////////////////////////////////////////////////////////////
@@ -55,11 +56,9 @@ typedef enum
 ////////////////////////////////////////////////////////////
 typedef enum
 {
-    sfBlendEquationAdd,             ///< Pixel = Src * SrcFactor + Dst * DstFactor
-    sfBlendEquationSubtract,        ///< Pixel = Src * SrcFactor - Dst * DstFactor
-    sfBlendEquationReverseSubtract, ///< Pixel = Dst * DstFactor - Src * SrcFactor
-    sfBlendEquationMin,             ///< Pixel = min(Dst, Src)
-    sfBlendEquationMax              ///< Pixel = max(Dst, Src)
+    sfBlendEquationAdd,            ///< Pixel = Src * SrcFactor + Dst * DstFactor
+    sfBlendEquationSubtract,       ///< Pixel = Src * SrcFactor - Dst * DstFactor
+    sfBlendEquationReverseSubtract ///< Pixel = Dst * DstFactor - Src * SrcFactor
 } sfBlendEquation;
 
 
@@ -69,18 +68,19 @@ typedef enum
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendFactor   colorSrcFactor; ///< Source blending factor for the color channels
-    sfBlendFactor   colorDstFactor; ///< Destination blending factor for the color channels
-    sfBlendEquation colorEquation;  ///< Blending equation for the color channels
-    sfBlendFactor   alphaSrcFactor; ///< Source blending factor for the alpha channel
-    sfBlendFactor   alphaDstFactor; ///< Destination blending factor for the alpha channel
-    sfBlendEquation alphaEquation;  ///< Blending equation for the alpha channel
+    sfBlendFactor colorSrcFactor;  ///< Source blending factor for the color channels
+    sfBlendFactor colorDstFactor;  ///< Destination blending factor for the color channels
+    sfBlendEquation colorEquation; ///< Blending equation for the color channels
+    sfBlendFactor alphaSrcFactor;  ///< Source blending factor for the alpha channel
+    sfBlendFactor alphaDstFactor;  ///< Destination blending factor for the alpha channel
+    sfBlendEquation alphaEquation; ///< Blending equation for the alpha channel
 } sfBlendMode;
 
 
 CSFML_GRAPHICS_API const sfBlendMode sfBlendAlpha;    ///< Blend source and dest according to dest alpha
 CSFML_GRAPHICS_API const sfBlendMode sfBlendAdd;      ///< Add source to dest
 CSFML_GRAPHICS_API const sfBlendMode sfBlendMultiply; ///< Multiply source and dest
-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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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;
-    uint8_t g;
-    uint8_t b;
-    uint8_t a;
+    sfUint8 r;
+    sfUint8 g;
+    sfUint8 b;
+    sfUint8 a;
 } sfColor;
 
 
-CSFML_GRAPHICS_API const sfColor sfBlack;       ///< Black predefined color
-CSFML_GRAPHICS_API const sfColor sfWhite;       ///< White predefined color
-CSFML_GRAPHICS_API const sfColor sfRed;         ///< Red predefined color
-CSFML_GRAPHICS_API const sfColor sfGreen;       ///< Green predefined color
-CSFML_GRAPHICS_API const sfColor sfBlue;        ///< Blue predefined color
-CSFML_GRAPHICS_API const sfColor sfYellow;      ///< Yellow predefined color
-CSFML_GRAPHICS_API const sfColor sfMagenta;     ///< Magenta predefined color
-CSFML_GRAPHICS_API const sfColor sfCyan;        ///< Cyan predefined color
-CSFML_GRAPHICS_API const sfColor sfTransparent; ///< Transparent (black) predefined color
+CSFML_GRAPHICS_API sfColor sfBlack;       ///< Black predefined color
+CSFML_GRAPHICS_API sfColor sfWhite;       ///< White predefined color
+CSFML_GRAPHICS_API sfColor sfRed;         ///< Red predefined color
+CSFML_GRAPHICS_API sfColor sfGreen;       ///< Green predefined color
+CSFML_GRAPHICS_API sfColor sfBlue;        ///< Blue predefined color
+CSFML_GRAPHICS_API sfColor sfYellow;      ///< Yellow predefined color
+CSFML_GRAPHICS_API sfColor sfMagenta;     ///< Magenta predefined color
+CSFML_GRAPHICS_API sfColor sfCyan;        ///< Cyan 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/FontInfo.h>
-#include <CSFML/Graphics/Glyph.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/InputStream.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/FontInfo.h>
+#include <SFML/Graphics/Glyph.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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,27 +97,7 @@ CSFML_GRAPHICS_API void sfFont_destroy(const sfFont* font);
 /// \return The corresponding glyph
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfGlyph
-    sfFont_getGlyph(const sfFont* font, uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness);
-
-////////////////////////////////////////////////////////////
-/// \brief Determine if this font has a glyph representing the requested code point
-///
-/// Most fonts only include a very limited selection of glyphs from
-/// specific Unicode subsets, like Latin, Cyrillic, or Asian characters.
-///
-/// While code points without representation will return a font specific
-/// default character, it might be useful to verify whether specific
-/// code points are included to determine whether a font is suited
-/// to display text in a specific language.
-///
-/// \param font      Source font
-/// \param codePoint Unicode code point to check
-///
-/// \return True if the codepoint has a glyph representation, sfFalse otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFont_hasGlyph(const sfFont* font, uint32_t codePoint);
+CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold, float outlineThickness);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the kerning value corresponding to a given pair of characters in a font
@@ -131,20 +110,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);
-
-////////////////////////////////////////////////////////////
-/// \brief Get the bold kerning value corresponding to a given pair of characters in a font
-///
-/// \param font          Source font
-/// \param first         Unicode code point of the first character
-/// \param second        Unicode code point of the second character
-/// \param characterSize Character size, in pixels
-///
-/// \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_getKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the line spacing value
@@ -195,35 +161,6 @@ CSFML_GRAPHICS_API float sfFont_getUnderlineThickness(const sfFont* font, unsign
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API const sfTexture* sfFont_getTexture(sfFont* font, unsigned int characterSize);
 
-////////////////////////////////////////////////////////////
-/// \brief Enable or disable the smooth filter
-///
-/// When the filter is activated, the font appears smoother
-/// so that pixels are less noticeable. However if you want
-/// the font to look exactly the same as its source file,
-/// you should disable it.
-/// The smooth filter is enabled by default.
-///
-/// \param font          Source font
-/// \param smooth        true to enable smoothing, false to disable it
-///
-/// \see isSmooth
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, bool smooth);
-
-////////////////////////////////////////////////////////////
-/// \brief Tell whether the smooth filter is enabled or disabled
-///
-/// \param font          Source font
-///
-/// \return true if smoothing is enabled, false if it is disabled
-///
-/// \see setSmooth
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfFont_isSmooth(const sfFont* font);
-
 ////////////////////////////////////////////////////////////
 /// \brief Get the font information
 ///
@@ -237,3 +174,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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Transform.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/System/Vector3.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/System/Vector2.h>
+#include <SFML/System/Vector3.h>
 
 // 2D vectors
 typedef sfVector2f sfGlslVec2;
@@ -38,8 +39,8 @@ typedef sfVector2i sfGlslIvec2;
 
 typedef struct
 {
-    bool x;
-    bool y;
+    sfBool x;
+    sfBool y;
 } sfGlslBvec2;
 
 // 3D vectors
@@ -54,9 +55,9 @@ typedef struct
 
 typedef struct
 {
-    bool x;
-    bool y;
-    bool z;
+    sfBool x;
+    sfBool y;
+    sfBool z;
 } sfGlslBvec3;
 
 // 4D vectors
@@ -78,10 +79,10 @@ typedef struct
 
 typedef struct
 {
-    bool x;
-    bool y;
-    bool z;
-    bool w;
+    sfBool x;
+    sfBool y;
+    sfBool z;
+    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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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,18 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_IMAGE_H
+#define SFML_IMAGE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
-
-#include <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Buffer.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
 #include <stddef.h>
 
 
@@ -44,23 +42,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 color Fill color
+/// \param width  Width of the image
+/// \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 +70,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 +141,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,31 +154,10 @@ 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
-///
-/// \see sfImage_saveToMemory
+/// \return sfTrue if saving was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfImage_saveToFile(const sfImage* image, const char* filename);
-
-////////////////////////////////////////////////////////////
-/// \brief Save the image to a buffer in memory
-///
-/// The format of the image must be specified.
-/// The supported image formats are bmp, png, tga and jpg.
-/// This function fails if the image is empty, or if
-/// the format was invalid.
-///
-/// \param image  Image object
-/// \param output Buffer to fill with encoded data
-/// \param format Encoding format to use
-///
-/// \return true 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_saveToFile(const sfImage* image, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of an image
@@ -201,7 +181,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 +198,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 +213,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 coords Coordinates of pixel to change
-/// \param color  New color of the pixel
+/// \param image Image object
+/// \param x     X coordinate of pixel to change
+/// \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 +228,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 coords Coordinates of pixel to get
+/// \param image Image object
+/// \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 +252,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 +269,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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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,13 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RECT_H
+#define SFML_RECT_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
-
-#include <CSFML/System/Vector2.h>
+#include <SFML/Graphics/Export.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -38,27 +37,32 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfVector2f position;
-    sfVector2f size;
+    float left;
+    float top;
+    float width;
+    float height;
 } sfFloatRect;
 
 typedef struct
 {
-    sfVector2i position;
-    sfVector2i size;
+    int left;
+    int top;
+    int width;
+    int height;
 } sfIntRect;
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a point is inside a rectangle's area
 ///
-/// \param rect  Rectangle to test
-/// \param point Coordinates of the point to test
+/// \param rect Rectangle 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 bool sfIntRect_contains(const sfIntRect* rect, sfVector2i point);
+CSFML_GRAPHICS_API sfBool sfFloatRect_contains(const sfFloatRect* rect, float x, float y);
+CSFML_GRAPHICS_API sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check intersection between two rectangles
@@ -67,8 +71,11 @@ 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 bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
+CSFML_GRAPHICS_API sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
+CSFML_GRAPHICS_API sfBool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
+
+
+#endif // SFML_RECT_H

include/SFML/Graphics/RectangleShape.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,24 +22,29 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_RENDERSTATES_H
+#define SFML_RENDERSTATES_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/System/Export.h>
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/BlendMode.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
 
 
 ////////////////////////////////////////////////////////////
-/// \brief Deallocates memory
-///
-/// This function deallocates the memory being pointed to
-/// using the free function from the C standard library.
-///
-/// The memory must have been previously allocated using a call
-/// to malloc.
-///
-/// \param ptr Pointer to the memory to deallocate
+/// \brief Define the states used for drawing to a RenderTarget
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API void sfFree(void* ptr);
+typedef struct
+{
+    sfBlendMode      blendMode; ///< Blending mode
+    sfTransform      transform; ///< Transform
+    const sfTexture* texture;   ///< Texture
+    const sfShader*  shader;    ///< Shader
+} sfRenderStates;
+
+
+#endif // SFML_RENDERSTATES_H

include/SFML/Graphics/RenderTexture.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/RenderStates.h>
-#include <CSFML/Graphics/StencilMode.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/Graphics/Vertex.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Window.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/RenderStates.h>
+#include <SFML/Graphics/Vertex.h>
+#include <SFML/Window/Window.h>
+#include <SFML/System/Vector2.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
@@ -71,26 +85,16 @@ CSFML_GRAPHICS_API void sfRenderTexture_destroy(const sfRenderTexture* renderTex
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2u sfRenderTexture_getSize(const sfRenderTexture* renderTexture);
 
-////////////////////////////////////////////////////////////
-/// \brief Tell if the render texture will use sRGB encoding when drawing on it
-///
-/// \param renderTexture Render texture object
-///
-/// \return true if the render texture use sRGB encoding, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
-
 ////////////////////////////////////////////////////////////
 /// \brief Activate or deactivate a render texture as the current target for rendering
 ///
 /// \param renderTexture Render texture object
-/// \param active        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 +113,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 +153,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 +178,7 @@ CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getScissor(const sfRenderTexture* r
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f
-    sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to texture coordinates
@@ -244,8 +204,7 @@ CSFML_GRAPHICS_API sfVector2f
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i
-    sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -255,47 +214,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,
-                                                   const sfSprite*       object,
-                                                   const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture*      renderTexture,
-                                                 const sfText*         object,
-                                                 const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture*      renderTexture,
-                                                  const sfShape*        object,
-                                                  const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture*      renderTexture,
-                                                        const sfCircleShape*  object,
-                                                        const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture*      renderTexture,
-                                                        const sfConvexShape*  object,
-                                                        const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture*        renderTexture,
-                                                           const sfRectangleShape* object,
-                                                           const sfRenderStates*   states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture*      renderTexture,
-                                                        const sfVertexArray*  object,
-                                                        const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture*      renderTexture,
-                                                         const sfVertexBuffer* object,
-                                                         const sfRenderStates* states);
-
-////////////////////////////////////////////////////////////
-/// \brief Draw primitives defined by a vertex buffer.
-///
-/// \param renderTexture render texture object
-/// \param object        Vertex buffer object to draw
-/// \param firstVertex   Index of the first vertex to render
-/// \param vertexCount   Number of vertices to render
-/// \param states        Render states to use for drawing
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBufferRange(
-    sfRenderTexture*      renderTexture,
-    const sfVertexBuffer* object,
-    size_t                firstVertex,
-    size_t                vertexCount,
-    const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const sfSprite* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const sfText* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const sfShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const sfCircleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const sfConvexShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const sfRectangleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const sfVertexArray* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawVertexBuffer(sfRenderTexture* renderTexture, const sfVertexBuffer* object, const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render texture
@@ -307,12 +233,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(
-    sfRenderTexture*      renderTexture,
-    const sfVertex*       vertices,
-    size_t                vertexCount,
-    sfPrimitiveType       type,
-    const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture,
+                                                       const sfVertex* vertices, size_t vertexCount,
+                                                       sfPrimitiveType type, const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -379,45 +302,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();
 
 ////////////////////////////////////////////////////////////
 /// \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 +353,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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/RenderStates.h>
-#include <CSFML/Graphics/StencilMode.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/Graphics/Vertex.h>
-#include <CSFML/System/Time.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Event.h>
-#include <CSFML/Window/VideoMode.h>
-#include <CSFML/Window/Window.h>
-#include <CSFML/Window/WindowHandle.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/RenderStates.h>
+#include <SFML/Graphics/Vertex.h>
+#include <SFML/Window/Event.h>
+#include <SFML/Window/VideoMode.h>
+#include <SFML/Window/WindowHandle.h>
+#include <SFML/Window/Window.h>
+#include <SFML/System/Vector2.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(
-    sfVideoMode              mode,
-    const char*              title,
-    uint32_t                 style,
-    sfWindowState            state,
-    const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, 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(
-    sfVideoMode              mode,
-    const sfChar32*          title,
-    uint32_t                 style,
-    sfWindowState            state,
-    const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, 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
-///
-/// 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.
+/// \brief Get the event on top of event queue of a render window, if any, and pop it
 ///
 /// \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, if any
+/// \param event        Event to fill
 ///
-/// \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
@@ -197,16 +161,6 @@ CSFML_GRAPHICS_API void sfRenderWindow_setPosition(sfRenderWindow* renderWindow,
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2u sfRenderWindow_getSize(const sfRenderWindow* renderWindow);
 
-////////////////////////////////////////////////////////////
-/// \brief Tell if the render window will use sRGB encoding when drawing on it
-///
-/// \param renderWindow Render window object
-///
-/// \return true if the render window use sRGB encoding, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
-
 ////////////////////////////////////////////////////////////
 /// \brief Change the size of the rendering region of a render window
 ///
@@ -216,28 +170,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 +186,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 +236,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      true to enable, false to disable
+/// \param grabbed sfTrue to enable, sfFalse 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 +252,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 +266,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 +293,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 +324,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 +342,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 +353,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 +393,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 +421,7 @@ CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getScissor(const sfRenderWindow* ren
 /// \return The converted point, in "world" units
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2f
-    sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a point from world coordinates to window coordinates
@@ -558,8 +447,7 @@ CSFML_GRAPHICS_API sfVector2f
 /// \return The converted point, in target coordinates (pixels)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVector2i
-    sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
+CSFML_GRAPHICS_API sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw a drawable object to the render-target
@@ -569,43 +457,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,
-                                                  const sfSprite*       object,
-                                                  const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const sfSprite* object, const sfRenderStates* states);
 CSFML_GRAPHICS_API void sfRenderWindow_drawText(sfRenderWindow* renderWindow, const sfText* object, const sfRenderStates* states);
 CSFML_GRAPHICS_API void sfRenderWindow_drawShape(sfRenderWindow* renderWindow, const sfShape* object, const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow*       renderWindow,
-                                                       const sfCircleShape*  object,
-                                                       const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow*       renderWindow,
-                                                       const sfConvexShape*  object,
-                                                       const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow*         renderWindow,
-                                                          const sfRectangleShape* object,
-                                                          const sfRenderStates*   states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow*       renderWindow,
-                                                       const sfVertexArray*  object,
-                                                       const sfRenderStates* states);
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow*       renderWindow,
-                                                        const sfVertexBuffer* object,
-                                                        const sfRenderStates* states);
-
-////////////////////////////////////////////////////////////
-/// \brief Draw primitives defined by a vertex buffer.
-///
-/// \param renderWindow Render window object
-/// \param object       Vertex buffer object to draw
-/// \param firstVertex  Index of the first vertex to render
-/// \param vertexCount  Number of vertices to render
-/// \param states       Render states to use for drawing
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBufferRange(
-    sfRenderWindow*       renderWindow,
-    const sfVertexBuffer* object,
-    size_t                firstVertex,
-    size_t                vertexCount,
-    const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const sfCircleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const sfConvexShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const sfRectangleShape* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const sfVertexArray* object, const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawVertexBuffer(sfRenderWindow* renderWindow, const sfVertexBuffer* object, const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Draw primitives defined by an array of vertices to a render window
@@ -617,12 +476,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(
-    sfRenderWindow*       renderWindow,
-    const sfVertex*       vertices,
-    size_t                vertexCount,
-    sfPrimitiveType       type,
-    const sfRenderStates* states);
+CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow,
+                                                      const sfVertex* vertices, size_t vertexCount,
+                                                      sfPrimitiveType type, const sfRenderStates* states);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the current OpenGL render states and matrices
@@ -672,6 +528,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
 ///
@@ -711,19 +594,5 @@ CSFML_GRAPHICS_API void sfMouse_setPositionRenderWindow(sfVector2i position, con
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfVector2i sfTouch_getPositionRenderWindow(unsigned int finger, const sfRenderWindow* relativeTo);
 
-////////////////////////////////////////////////////////////
-/// \brief Create a Vulkan rendering surface
-///
-/// \param renderWindow RenderWindow object
-/// \param instance     Vulkan instance
-/// \param surface      Created surface
-/// \param allocator    Allocator to use
-///
-/// \return True if surface creation was successful, false otherwise
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfRenderWindow_createVulkanSurface(
-    sfRenderWindow*              renderWindow,
-    const VkInstance*            instance,
-    VkSurfaceKHR*                surface,
-    const VkAllocationCallbacks* allocator);
+
+#endif // SFML_RENDERWINDOW_H

include/SFML/Graphics/Shader.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Glsl.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/System/Vector3.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Glsl.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
+#include <SFML/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,
-                                                     const char* geometryShaderFilename,
-                                                     const char* fragmentShaderFilename);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from source code in memory
@@ -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,
-                                                       const char* geometryShader,
-                                                       const char* fragmentShader);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader);
 
 ////////////////////////////////////////////////////////////
 /// \brief Load the vertex, geometry and fragment shaders from custom streams
@@ -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,
-                                                       sfInputStream* geometryShaderStream,
-                                                       sfInputStream* fragmentShaderStream);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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,
-                                           void*                        userData);
+                                           sfShapeGetPointCallback getPoint,
+                                           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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/BlendMode.h>
-#include <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/BlendMode.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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,31 @@
 //
 ////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef SFML_TEXTURE_H
+#define SFML_TEXTURE_H
 
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Graphics/Export.h>
-
-#include <CSFML/Graphics/CoordinateType.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/InputStream.h>
-#include <CSFML/System/Vector2.h>
-#include <CSFML/Window/Types.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/Window/Types.h>
+#include <SFML/System/InputStream.h>
+#include <SFML/System/Vector2.h>
 #include <stddef.h>
 
+
 ////////////////////////////////////////////////////////////
 /// \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);
-
-////////////////////////////////////////////////////////////
-/// \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);
+CSFML_GRAPHICS_API sfTexture* sfTexture_create(unsigned int width, unsigned int height);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture from a file
@@ -69,29 +59,6 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgb(sfVector2u size);
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTexture* sfTexture_createFromFile(const char* filename, const sfIntRect* area);
 
-////////////////////////////////////////////////////////////
-/// \brief Create a new sRGB-enabled texture from a file
-///
-/// When providing texture data from an image file or memory, it can
-/// either be stored in a linear color space or an sRGB color space.
-/// Most digital images account for gamma correction already, so they
-/// would need to be "uncorrected" back to linear color space before
-/// being processed by the hardware. The hardware can automatically
-/// convert it from the sRGB color space to a linear color space when
-/// it gets sampled. When the rendered image gets output to the final
-/// framebuffer, it gets converted back to sRGB.
-///
-/// This load option is only useful in conjunction with an sRGB capable
-/// framebuffer. This can be requested during window creation.
-///
-/// \param filename Path of the image file to load
-/// \param area     Area of the source image to load (NULL to load the entire image)
-///
-/// \return A new sfTexture object, or NULL if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromFile(const char* filename, const sfIntRect* area);
-
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture from a file in memory
 ///
@@ -104,18 +71,6 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromFile(const char* filename,
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTexture* sfTexture_createFromMemory(const void* data, size_t sizeInBytes, const sfIntRect* area);
 
-////////////////////////////////////////////////////////////
-/// \brief Create a new sRGB-enabled texture from a file in memory
-///
-/// \param data        Pointer to the file data in memory
-/// \param sizeInBytes Size of the data to load, in bytes
-/// \param area        Area of the source image to load (NULL to load the entire image)
-///
-/// \return A new sfTexture object, or NULL if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromMemory(const void* data, size_t sizeInBytes, const sfIntRect* area);
-
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture from a custom stream
 ///
@@ -127,17 +82,6 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromMemory(const void* data, s
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTexture* sfTexture_createFromStream(sfInputStream* stream, const sfIntRect* area);
 
-////////////////////////////////////////////////////////////
-/// \brief Create a new sRGB-enabled texture from a custom stream
-///
-/// \param stream Source stream to read from
-/// \param area   Area of the source image to load (NULL to load the entire image)
-///
-/// \return A new sfTexture object, or NULL if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromStream(sfInputStream* stream, const sfIntRect* area);
-
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture from an image
 ///
@@ -149,17 +93,6 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromStream(sfInputStream* stre
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API sfTexture* sfTexture_createFromImage(const sfImage* image, const sfIntRect* area);
 
-////////////////////////////////////////////////////////////
-/// \brief Create a new sRGB-enabled texture from an image
-///
-/// \param image Image to upload to the texture
-/// \param area  Area of the source image to load (NULL to load the entire image)
-///
-/// \return A new sfTexture object, or NULL if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfTexture* sfTexture_createSrgbFromImage(const sfImage* image, const sfIntRect* area);
-
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing texture
 ///
@@ -176,21 +109,7 @@ CSFML_GRAPHICS_API sfTexture* sfTexture_copy(const sfTexture* texture);
 /// \param texture Texture to delete
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_destroy(const 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
-/// \param sRgb `true` to enable sRGB conversion, `false` to disable it
-///
-/// \return `true` if resizing was successful, `false` if it failed
-///
-////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API bool sfTexture_resize(sfTexture* texture, sfVector2u size, bool sRgb);
+CSFML_GRAPHICS_API void sfTexture_destroy(sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of the texture
@@ -217,11 +136,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 offset  Offset in the texture where to copy the source pixels
+/// \param width   Width of the pixel region contained in \a 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
@@ -235,72 +156,98 @@ 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 Enable or disable conversion from sRGB
+///
+/// When providing texture data from an image file or memory, it can
+/// either be stored in a linear color space or an sRGB color space.
+/// Most digital images account for gamma correction already, so they
+/// would need to be "uncorrected" back to linear color space before
+/// being processed by the hardware. The hardware can automatically
+/// convert it from the sRGB color space to a linear color space when
+/// it gets sampled. When the rendered image gets output to the final
+/// framebuffer, it gets converted back to sRGB.
+///
+/// After enabling or disabling sRGB conversion, make sure to reload
+/// the texture data in order for the setting to take effect.
+///
+/// This option is only useful in conjunction with an sRGB capable
+/// framebuffer. This can be requested during window creation.
+///
+/// \param sRgb True to enable sRGB conversion, false to disable it
+///
+/// \see sfTexture_isSrgb
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfTexture_setSrgb(sfTexture* texture, sfBool sRgb);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture source is converted from sRGB or not
 ///
 /// \return True if the texture source is converted from sRGB, false if not
 ///
-/// \see sfTexture_createSrgbFromFile
-/// \see sfTexture_createSrgbFromMemory
-/// \see sfTexture_createSrgbFromStream
-/// \see sfTexture_createSrgbFromImage
+/// \see sfTexture_setSrgb
 ///
 ////////////////////////////////////////////////////////////
-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
@@ -323,17 +270,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
@@ -355,10 +302,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
@@ -402,10 +349,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);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the maximum texture size allowed
@@ -413,4 +359,7 @@ CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfCoordinateTyp
 /// \return Maximum size allowed for textures, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API unsigned int sfTexture_getMaximumSize(void);
+CSFML_GRAPHICS_API unsigned int sfTexture_getMaximumSize();
+
+
+#endif // SFML_TEXTURE_H

include/SFML/Graphics/Transform.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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
-    sfTransform_fromMatrix(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22);
+CSFML_GRAPHICS_API sfTransform sfTransform_fromMatrix(float a00, float a01, float a02,
+                                                      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 center    Coordinates of the center of scaling
+/// \param scaleX    Scaling factor on X axis
+/// \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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Transform.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/Graphics/Transform.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 sfConvexShape    sfConvexShape;
-typedef struct sfFont           sfFont;
-typedef struct sfImage          sfImage;
-typedef struct sfShader         sfShader;
+typedef struct sfCircleShape sfCircleShape;
+typedef struct sfConvexShape sfConvexShape;
+typedef struct sfFont sfFont;
+typedef struct sfImage sfImage;
+typedef struct sfShader sfShader;
 typedef struct sfRectangleShape sfRectangleShape;
-typedef struct sfRenderTexture  sfRenderTexture;
-typedef struct sfRenderWindow   sfRenderWindow;
-typedef struct sfShape          sfShape;
-typedef struct sfSprite         sfSprite;
-typedef struct sfText           sfText;
-typedef struct sfTexture        sfTexture;
-typedef struct sfTransformable  sfTransformable;
-typedef struct sfVertexArray    sfVertexArray;
-typedef struct sfVertexBuffer   sfVertexBuffer;
-typedef struct sfView           sfView;
+typedef struct sfRenderTexture sfRenderTexture;
+typedef struct sfRenderWindow sfRenderWindow;
+typedef struct sfShape sfShape;
+typedef struct sfSprite sfSprite;
+typedef struct sfText sfText;
+typedef struct sfTexture sfTexture;
+typedef struct sfTransformable sfTransformable;
+typedef struct sfVertexArray sfVertexArray;
+typedef struct sfVertexBuffer sfVertexBuffer;
+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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Color.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Color.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/Graphics/Vertex.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/PrimitiveType.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/Graphics/Vertex.h>
-
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/PrimitiveType.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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 vertexCount  Number of vertices to copy
-/// \param offset       Offset in the buffer to copy to
+/// \param vertices    Array of vertices to copy to the buffer
+/// \param vertexCount Number of vertices to copy
+/// \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,
-                                              const sfVertex* vertices,
-                                              unsigned int    vertexCount,
-                                              unsigned int    offset);
+CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, 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();
+
+
+#endif // SFML_VERTEXBUFFER_H

include/SFML/Graphics/View.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Graphics/Rect.h>
-#include <CSFML/Graphics/Types.h>
-#include <CSFML/System/Vector2.h>
+#include <SFML/Graphics/Export.h>
+#include <SFML/Graphics/Rect.h>
+#include <SFML/Graphics/Types.h>
+#include <SFML/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
-/// 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.
+/// Note that this function resets the rotation angle to 0.
 ///
-/// \param view    View object
-/// \param scissor New scissor rectangle
+/// \param view      View object
+/// \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
-///
-/// \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
+/// \brief Move a view relatively 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-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/IpAddress.h>
-#include <CSFML/Network/Types.h>
-
+#include <SFML/Network/Export.h>
+#include <SFML/Network/IpAddress.h>
+#include <SFML/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
-    sfFtpPointlessCommand = 202, ///< Command not implemented
-    sfFtpSystemStatus     = 211, ///< System status, or system help reply
-    sfFtpDirectoryStatus  = 212, ///< Directory status
-    sfFtpFileStatus       = 213, ///< File status
-    sfFtpHelpMessage      = 214, ///< Help message
-    sfFtpSystemType = 215, ///< NAME system type, where NAME is an official system name from the list in the Assigned Numbers document
+    sfFtpOk                    = 200, ///< Command ok
+    sfFtpPointlessCommand      = 202, ///< Command not implemented
+    sfFtpSystemStatus          = 211, ///< System status, or system help reply
+    sfFtpDirectoryStatus       = 212, ///< Directory status
+    sfFtpFileStatus            = 213, ///< File status
+    sfFtpHelpMessage           = 214, ///< Help message
+    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(
-    sfFtp*            ftp,
-    const char*       localFile,
-    const char*       remotePath,
-    sfFtpTransferMode mode,
-    bool              append);
+CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, sfBool 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/Types.h>
-#include <CSFML/System/Time.h>
+#include <SFML/Network/Export.h>
+#include <SFML/Network/Types.h>
+#include <SFML/System/Time.h>
 
 
 ////////////////////////////////////////////////////////////
@@ -54,18 +54,18 @@ typedef enum
 typedef enum
 {
     // 2xx: success
-    sfHttpOk        = 200, ///< Most common code returned when operation was successful
-    sfHttpCreated   = 201, ///< The resource has successfully been created
-    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
-    sfHttpResetContent = 205, ///< The server informs the client that it should clear the view (form) that caused the request to be sent
+    sfHttpOk             = 200, ///< Most common code returned when operation was successful
+    sfHttpCreated        = 201, ///< The resource has successfully been created
+    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
+    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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/System/Time.h>
+#include <SFML/Network/Export.h>
+#include <SFML/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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/Types.h>
-
+#include <SFML/Network/Export.h>
+#include <SFML/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
@@ -70,20 +69,6 @@ CSFML_NETWORK_API void sfPacket_destroy(const sfPacket* packet);
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API void sfPacket_append(sfPacket* packet, const void* data, size_t sizeInBytes);
 
-////////////////////////////////////////////////////////////
-/// \brief Get the current reading position in the packet
-///
-/// 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
-///
-////////////////////////////////////////////////////////////
-CSFML_NETWORK_API size_t sfPacket_getReadPosition(const sfPacket* packet);
-
 ////////////////////////////////////////////////////////////
 /// \brief Clear a packet
 ///
@@ -131,15 +116,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 +132,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 +143,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 int8_t   sfPacket_readInt8(sfPacket* packet);
-CSFML_NETWORK_API uint8_t  sfPacket_readUint8(sfPacket* packet);
-CSFML_NETWORK_API int16_t  sfPacket_readInt16(sfPacket* packet);
-CSFML_NETWORK_API uint16_t sfPacket_readUint16(sfPacket* packet);
-CSFML_NETWORK_API int32_t  sfPacket_readInt32(sfPacket* packet);
-CSFML_NETWORK_API uint32_t sfPacket_readUint32(sfPacket* packet);
-CSFML_NETWORK_API int64_t  sfPacket_readInt64(sfPacket* packet);
-CSFML_NETWORK_API uint64_t sfPacket_readUint64(sfPacket* packet);
+CSFML_NETWORK_API sfBool   sfPacket_readBool(sfPacket* packet);
+CSFML_NETWORK_API sfInt8   sfPacket_readInt8(sfPacket* packet);
+CSFML_NETWORK_API sfUint8  sfPacket_readUint8(sfPacket* packet);
+CSFML_NETWORK_API sfInt16  sfPacket_readInt16(sfPacket* packet);
+CSFML_NETWORK_API sfUint16 sfPacket_readUint16(sfPacket* packet);
+CSFML_NETWORK_API sfInt32  sfPacket_readInt32(sfPacket* packet);
+CSFML_NETWORK_API sfUint32 sfPacket_readUint32(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 +161,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_writeInt8(sfPacket* packet, int8_t);
-CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, uint8_t);
-CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, int16_t);
-CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, uint16_t);
-CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, int32_t);
-CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, uint32_t);
-CSFML_NETWORK_API void sfPacket_writeInt64(sfPacket* packet, int64_t);
-CSFML_NETWORK_API void sfPacket_writeUint64(sfPacket* packet, uint64_t);
+CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, sfBool);
+CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, sfInt8);
+CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, sfUint8);
+CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, sfInt16);
+CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, sfUint16);
+CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, sfInt32);
+CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, sfUint32);
 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/Types.h>
-#include <CSFML/System/Time.h>
+#include <SFML/Network/Export.h>
+#include <SFML/Network/Types.h>
+#include <SFML/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 bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
-CSFML_NETWORK_API bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
+CSFML_NETWORK_API sfBool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
+CSFML_NETWORK_API sfBool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/IpAddress.h>
-#include <CSFML/Network/SocketStatus.h>
-#include <CSFML/Network/Types.h>
+#include <SFML/Network/Export.h>
+#include <SFML/Network/SocketStatus.h>
+#include <SFML/Network/IpAddress.h>
+#include <SFML/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
-///        to pick any available port
-///
-/// \return The value to use for any port
-///
-////////////////////////////////////////////////////////////
-CSFML_NETWORK_API unsigned short sfTcpListener_anyPort(void);
+
+#endif // SFML_TCPLISTENER_H

include/SFML/Network/TcpSocket.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/IpAddress.h>
-#include <CSFML/Network/SocketStatus.h>
-#include <CSFML/Network/Types.h>
-#include <CSFML/System/Time.h>
-
+#include <SFML/Network/Export.h>
+#include <SFML/Network/IpAddress.h>
+#include <SFML/Network/SocketStatus.h>
+#include <SFML/Network/Types.h>
+#include <SFML/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
-    sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
+CSFML_NETWORK_API sfSocketStatus sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddress, unsigned short remotePort, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Disconnect a TCP socket from its remote peer
@@ -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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 sfFtpResponse          sfFtpResponse;
-typedef struct sfFtp                  sfFtp;
-typedef struct sfHttpRequest          sfHttpRequest;
-typedef struct sfHttpResponse         sfHttpResponse;
-typedef struct sfHttp                 sfHttp;
-typedef struct sfPacket               sfPacket;
-typedef struct sfSocketSelector       sfSocketSelector;
-typedef struct sfTcpListener          sfTcpListener;
-typedef struct sfTcpSocket            sfTcpSocket;
-typedef struct sfUdpSocket            sfUdpSocket;
+typedef struct sfFtpListingResponse sfFtpListingResponse;
+typedef struct sfFtpResponse sfFtpResponse;
+typedef struct sfFtp sfFtp;
+typedef struct sfHttpRequest sfHttpRequest;
+typedef struct sfHttpResponse sfHttpResponse;
+typedef struct sfHttp sfHttp;
+typedef struct sfPacket sfPacket;
+typedef struct sfSocketSelector sfSocketSelector;
+typedef struct sfTcpListener sfTcpListener;
+typedef struct sfTcpSocket sfTcpSocket;
+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-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/Network/IpAddress.h>
-#include <CSFML/Network/SocketStatus.h>
-#include <CSFML/Network/Types.h>
-
+#include <SFML/Network/Export.h>
+#include <SFML/Network/IpAddress.h>
+#include <SFML/Network/SocketStatus.h>
+#include <SFML/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
-    sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort);
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Receive raw data from a remote peer with a UDP socket
@@ -168,13 +162,7 @@ CSFML_NETWORK_API sfSocketStatus
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(
-    sfUdpSocket*    socket,
-    void*           data,
-    size_t          size,
-    size_t*         received,
-    sfIpAddress*    remoteAddress,
-    unsigned short* remotePort);
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(sfUdpSocket* socket, void* data, size_t size, size_t* received, sfIpAddress* remoteAddress, unsigned short* remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Send a formatted packet of data to a remote peer with a UDP socket
@@ -191,8 +179,7 @@ CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receive(
 /// \return Status code
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfSocketStatus
-    sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort);
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Receive a formatted packet of data from a remote peer with a UDP socket
@@ -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
-    sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
+CSFML_NETWORK_API sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the maximum number of bytes that can be
@@ -218,13 +203,7 @@ CSFML_NETWORK_API sfSocketStatus
 /// \return The maximum size of a UDP datagram (message)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API unsigned int sfUdpSocket_maxDatagramSize(void);
+CSFML_NETWORK_API unsigned int sfUdpSocket_maxDatagramSize();
 
-////////////////////////////////////////////////////////////
-/// \brief Return the special value that tells the system
-///        to pick any available port
-///
-/// \return The value to use for any port
-///
-////////////////////////////////////////////////////////////
-CSFML_NETWORK_API unsigned short sfUdpSocket_anyPort(void);
+
+#endif // SFML_UDPSOCKET_H

include/SFML/OpenGL.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <GL/glu.h>
-#include <windows.h>
+    #include <windows.h>
+    #include <GL/gl.h>
+    #include <GL/glu.h>
 
 #elif defined(CSFML_SYSTEM_LINUX) || defined(CSFML_SYSTEM_FREEBSD)
 
-#include <GL/gl.h>
-#include <GL/glu.h>
+    #include <GL/gl.h>
+    #include <GL/glu.h>
 
 #elif defined(CSFML_SYSTEM_MACOS)
 
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
+    #include <OpenGL/gl.h>
+    #include <OpenGL/glu.h>
 
 #endif
+
+
+#endif // SFML_OPENGL_H

include/SFML/System.h

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

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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 <CSFML/System/Time.h>
-#include <CSFML/System/Types.h>
+#include <SFML/System/Export.h>
+#include <SFML/System/Time.h>
+#include <SFML/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
-///
-/// 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);
+
+#endif // SFML_CLOCK_H

include/SFML/System/Export.h

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+// Copyright (C) 2007-2018 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