pax_global_header00006660000000000000000000000064151430737730014524gustar00rootroot0000000000000052 comment=4afccb62d350388a97cac17b7d0a985ae59c7107 SharpEngine.Core-2.5.1/000077500000000000000000000000001514307377300146235ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.github/000077500000000000000000000000001514307377300161635ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.github/workflows/000077500000000000000000000000001514307377300202205ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.github/workflows/build.yml000066400000000000000000000024631514307377300220470ustar00rootroot00000000000000name: SonarCloud on: push: branches: - master pull_request: types: [opened, synchronize, reopened] jobs: build: name: Build and analyze runs-on: ubuntu-latest steps: - name: Set up JDK 17 uses: actions/setup-java@v4 with: java-version: '17' distribution: 'zulu' # Alternative distribution options are available. - uses: actions/checkout@v4 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Install SonarCloud scanner if: steps.cache-sonar-scanner.outputs.cache-hit != 'true' run: | dotnet tool install --global dotnet-sonarscanner - name: Build and analyze env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} run: | dotnet-sonarscanner begin /k:"SharpEngine_SharpEngine.Core" /o:"sharpengine" /d:sonar.token="${{ secrets.SONAR_TOKEN }}" /d:sonar.host.url="https://sonarcloud.io" dotnet restore dotnet build SharpEngine.Core/SharpEngine.Core.csproj -c Release dotnet-sonarscanner end /d:sonar.token="${{ secrets.SONAR_TOKEN }}"SharpEngine.Core-2.5.1/.github/workflows/dotnet.yml000066400000000000000000000047411514307377300222460ustar00rootroot00000000000000# This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: .NET on: workflow_dispatch: # Allow running the workflow manually from the GitHub UI release: types: - published # Run the workflow when a new GitHub release is published env: DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1 DOTNET_NOLOGO: true NuGetDirectory: ${{ github.workspace}}/nuget defaults: run: shell: pwsh jobs: create_nuget: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Restore run: dotnet restore - name: Build run: dotnet build SharpEngine.Core/SharpEngine.Core.csproj -c Release - name: Pack Nuget run: dotnet pack SharpEngine.Core/SharpEngine.Core.csproj -c Release --no-build --output ${{ env.NuGetDirectory }} - uses: actions/upload-artifact@v4 with: name: nuget if-no-files-found: error retention-days: 7 path: ${{ env.NuGetDirectory }}/*.nupkg validate_nuget: runs-on: ubuntu-latest needs: [ create_nuget ] steps: - name: Setup .NET uses: actions/setup-dotnet@v4 - uses: actions/download-artifact@v4 with: name: nuget path: ${{ env.NuGetDirectory }} - name: Install nuget validator run: dotnet tool update Meziantou.Framework.NuGetPackageValidation.Tool --global - name: Validate package run: meziantou.validate-nuget-package (Get-ChildItem "${{ env.NuGetDirectory }}/*.nupkg") continue-on-error: true run_test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Run tests run: dotnet test --configuration Release deploy: runs-on: ubuntu-latest needs: [ validate_nuget, run_test ] steps: - uses: actions/download-artifact@v4 with: name: nuget path: ${{ env.NuGetDirectory }} - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Publish NuGet package run: | foreach($file in (Get-ChildItem "${{ env.NuGetDirectory }}" -Recurse -Include *.nupkg)) { dotnet nuget push $file --api-key "${{ secrets.NUGET_APIKEY }}" --source https://api.nuget.org/v3/index.json --skip-duplicate } SharpEngine.Core-2.5.1/.gitignore000066400000000000000000000000751514307377300166150ustar00rootroot00000000000000bin/ obj/ /packages/ riderModule.iml /_ReSharper.Caches/ .vs/SharpEngine.Core-2.5.1/.idea/000077500000000000000000000000001514307377300156035ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/000077500000000000000000000000001514307377300216545ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/000077500000000000000000000000001514307377300226345ustar00rootroot00000000000000SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/.gitignore000066400000000000000000000005241514307377300246250ustar00rootroot00000000000000# Default ignored files /shelf/ /workspace.xml # Rider ignored files /projectSettingsUpdater.xml /.idea.SharpEngine.Core.iml /modules.xml /contentModel.xml # Ignored default folder with query files /queries/ # Datasource local storage ignored files /dataSources/ /dataSources.local.xml # Editor-based HTTP Client requests /httpRequests/ SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/.name000066400000000000000000000000201514307377300235450ustar00rootroot00000000000000SharpEngine.CoreSharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/encodings.xml000066400000000000000000000002511514307377300253250ustar00rootroot00000000000000 SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/indexLayout.xml000066400000000000000000000003061514307377300256620ustar00rootroot00000000000000 SharpEngine.Core-2.5.1/.idea/.idea.SharpEngine.Core/.idea/vcs.xml000066400000000000000000000002471514307377300241540ustar00rootroot00000000000000 SharpEngine.Core-2.5.1/CHANGELOG.md000066400000000000000000000150371514307377300164420ustar00rootroot00000000000000# Changelog ### Caption [+] Add
[\~] Modification
[-] Suppression
[#] Bug Fixes
[.] Others ### V 2.5.1 - 11/02/2026 [#] CollisionComponent: Transform scale not applied ### V 2.5.0 - 06/01/2026 [\~] LogLevel: Remove log prefix
[\~] Tween: Tween logs are now debug logs
[.] Full refactor with Rider ### V 2.4.0 - 04/12/2025 [+] Tween System: TweenManager, Tween, TweenStep
[\~] Vec: Is now a class
[\~] Rect: Is now a class ### V 2.3.1 - 02/12/2025 [\~] Components: Private related components are now protected
[#] AutoComponent: Rotation not multiplied by deltaTime ### V 2.3.0 - 17/11/2025 [+] SEImGuiConsole: History navigation with Up and Down arrows
[+] DebugVarCommand: CustomVariables
[.] Net: 10 ### V 2.2.4 - 31/10/2025 [.] Raylib-cs: 7.0.2 ### V 2.2.3 - 17/05/2025 [#] ControlComponent: Reset Direction when no movement ### V 2.2.2 - 11/05/2025 [\~] AutoComponent: Now check CollisionComponent when movements ### V 2.2.1 - 11/05/2025 [+] Window: OpenUrl, SetIcon
[+] ProgressBar, Slider: Horizontal
[#] ControlComponent: Error on position pass to collision CanGo
[#] CollisionComponent: Only one collision by entity is used ### V 2.2.0 - 07/05/2025 [\~] DataTableManager: Get will now get DataTable directly, not an object
[\~] IDataTable / JsonDataTable: Rework complete with Add, Remove and Get
[\~] SERender: Allow float on many render functions
[\~] SERender: Better manage of types
[#] LineInput: Caret is hide when text is empty
[#] MultiLineInput: Caret is hide when text is empty
[#] MultiLineInput: Caret is render outside input frame
[#] MultiLineInput: Fix Y Offset with empty last line (after return line) ### V 2.1.1 - 06/05/2025 [\~] TextureButton: Allow using empty text ### V 2.1.0 - 18/04/2025 [\~] TextureButton: Remove black background ### V 2.0.4 - 02/04/2025 [+] LineInput / MultiLineInput: Secret ### V 2.0.3 - 10/03/2025 [+] Window: Constructor parameters redirectLogs ### V 2.0.2 - 06/02/2025 [.] Raylib-cs: 7.0.1
[.] ImGui.NET: 1.91.6.1 ### V 2.0.1 - 11/01/2025 [#] ControlComponent: Fix using ClassicJump Control Type ### V 2.0.0 - 25/12/2024 [+] Entity: Children, AddChild, RemoveChild, Parent
[+] TransformComponent: LocalPosition, LocalRotation, LocalScale, LocalZLayer
[+] Animation: Loop
[\~] Animation: Indices, Timer are now modifiable
[\~] SpriteSheetComponent: CurrentImage is now publicly readable ### V 1.10.0 - 24/12/2024 [+] SEShader
[\~] ShaderManager: Use SEShader instead of Shader
[\~] SpriteComponent: Use SEShader instead of Shader ### V 1.9.3 - 23/12/2024 [+] SpriteSheetComponent: AnimationEnded
[\~] SpriteSheetComponent: currentAnim, internalTimer, currentImage are protected ### V 1.9.2 - 24/11/2024 [+] SpriteComponent: TintColor
[+] Rect: Intersect ### V 1.9.1 - 21/11/2024 [+] DebugManager: AddConsoleCommand
[#] Fix versions in DebugManager ### V 1.9.0 - 08/11/2024 [+] Manage resizing windows
[.] Raylib-cs: 6.1.1
[.] ImGui.NET: 1.91.0.1 ### V 1.8.7 - 16/04/2024 [#] Widgets: Fix update when not displayed ### V 1.8.6 - 15/04/2024 [#] Fix all 1.8.5 ### V 1.8.5 - 15/04/2024 [+] DataTableManager: HasDataTable, RemoveDataTable
[+] FontManager: HasFont, RemoveFont
[+] ShaderManager: HasShader, RemoveShader
[+] TextureManager: HasTexture, RemoveTexture
[.] Improve comments ### V 1.8.4 - 15/04/2024 [#] Widgets: Fix activation without displaying ### v 1.8.3 - 21/01/2024 [.] Raylib-cs: 6.0.0 ### V 1.8.2 - 29/12/2023 [#] Resize Window doesn't resize imgui and camera render ### V 1.8.1 - 28/12/2023 [\~] Rename DefaultRenderImGui to SeRenderImGui and move it to DebugManager ### V 1.8.0 - 26/12/2023 [+] Console
[\~] Modification of ImGui systems (F7 for Debug Window – F8 for Console)
[.] ImGui.NET: 1.89.9.4 ### V 1.7.3 - 05/12/2023 [+] CameraManager: Position ### V 1.7.2 - 27/11/2023 [#] DebugManager: Other packages versions cannot be added ### V 1.7.1 - 27/11/2023 [#] ControlComponent: Keys inversed between Up and Down ### V 1.7.0 - 25/11/2023 [+] ParticleParameters
[+] ParticleEmitterParameters
[\~] Particle: Constructor uses ParticleParameters
[\~] ParticleEmitter: Constructor uses ParticleEmitterParameters
[-] SpriteSheetComponent: flipX and flipY in Constructor
[.] Refactor with SonarCloud
[.] ImGui.NET: 1.90.0.1 ### V 1.6.0 - 21/11/2023 [.] Net 8 ### V 1.5.2 - 19/11/2023 [#] SoundManager: Can't use functions without throwing exceptions
[#] MusicManager: Can't use functions without throwing exceptions ### V 1.5.1 - 18/11/2023 [.] Update Raylib-cs to 5.0.0
[.] Update ImGui.NET to 1.89.9.3 ### V 1.5.0 - 09/10/2023 [+] TimerManager, Timer
[+] InputManager: UpdateInput
[+] Window: Guard when no scene
[\~] Instructions: Move instructions into records
[#] ControlComponent: Fix MouseFollow
[#] DataTableManager: Remove null warning
[.] Reformat
[.] Refactor ### V 1.4.3 - 20/09/2023 [+] Color: FromVec4
[.] Update ImGui.NET to 1.89.9.1 ### V 1.4.2 - 17/09/2023 [+] Entity: Name
[+] Widget: Name ### V 1.4.1 - 16/09/2023 [+] SeImGui: ImageRenderTexture, ImageRect
[\~] Window: Make SeImGui public ### V 1.4.0 - 10/09/2023 [+] ShaderManager
[+] SERender: ShaderMode
[+] Color: ToVec4
[+] SpriteComponent: Shader ### V 1.3.3 - 04/09/2023 [+] CollisionComponent: Add DebugDraw ### V 1.3.2 - 16/08/2023 [#] Scene: Add Widget or Entity with delay doesn't make loading
[#] Scene: Delay removing or adding lists aren't clear ### V 1.3.1 - 26/08/2023 [+] Scene: delay parameter in AddWidget and AddEntity ### V 1.3.0 - 20/08/2023 [\~] Move some utils to own folder
[-] VecI
[-] RectI
[.] Refactor ### V 1.2.2 - 16/08/2023 [#] CollisionComponent: CanGo doesn't calculate all collisions ### V 1.2.1 - 16/08/2023 [\~] ControlComponent: Slide to collisions ### V 1.2.0 - 15/08/2023 [+] CollisionComponent ### V 1.1.4 - 14/08/2023 [#] JsonSave: Fix deserialization ### V 1.1.3 - 14/08/2023 [#] JsonSave: Fix casting
[#] BinarySave: Fix casting ### V 1.1.2 - 14/08/2023 [+] DebugManager: Versions
[\~] ControlComponent: Allow Moving and Direction modification by children
[-] DebugManager: SeVersion ### V 1.1.1 - 13/08/2023 [+] Scene: GetSceneSystem ### V 1.1.0 - 13/08/2023 [+] Scene: AddSceneSystem
[+] ISceneSystem
[\~] DebugManager: showAssemblyVersion in CreateSeImGuiWindow
[-] Internal
[.] Raylib-cs: Update to 4.5.0.4 ### V 1.0.0 - 13/08/2023 [.] First version (Created from http://github.com/AlexisHuvier/SharpEngine) SharpEngine.Core-2.5.1/CONTRIBUTING.md000066400000000000000000000017661514307377300170660ustar00rootroot00000000000000# How to contribute SharpEngine is a little project and I am happy to see that people want to contribute to it. So thanks ! To contribute efficiently, there is some things that you can do. ## Reporting bugs, proposing features or improvements You can simply make an issue with the template (soon). ## Contributing pull requests If you want to add your own features / bug fixes, please make sure that : - This features is usable in real projets. - You talked with other developer if somebody work on that already. - Your work follows code style and git guidelines If you want to add a feature / bug fixes, you can find some in issues of this projects. ### Git Guidelines - Try to make simple PRs (or issues) which target one specific topic. - Try to keep a clean git history. - Try to keep relevent and short branches names. Use dashes to separate words. - Try you work before pushing. ### Code Style Guidelines - Use CSharpier to format your work. It's already installed in every SharpEngine's Project. SharpEngine.Core-2.5.1/LICENSE.txt000066400000000000000000001044711514307377300164550ustar00rootroot00000000000000GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . SharpEngine.Core-2.5.1/README.md000066400000000000000000000010131514307377300160750ustar00rootroot00000000000000# SharpEngine.Core [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=SharpEngine_SharpEngine.Core&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=SharpEngine_SharpEngine.Core) Core Package for SharpEngine - C# 2D Game Engine ## Installation, Download, Usage See Wiki ## Dependencies - Net 10 - Raylib.cs - ImGui.NET [![SonarCloud](https://sonarcloud.io/images/project_badges/sonarcloud-white.svg)](https://sonarcloud.io/summary/new_code?id=SharpEngine_SharpEngine.Core)SharpEngine.Core-2.5.1/SharpEngine.Core.sln000066400000000000000000000023701514307377300204350ustar00rootroot00000000000000 Microsoft Visual Studio Solution File, Format Version 12.00 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpEngine.Core", "SharpEngine.Core\SharpEngine.Core.csproj", "{66004721-4986-46E2-AD5B-D843D0FD3BE0}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Testing", "Testing\Testing.csproj", "{A656DBCB-6308-4F81-8CCE-A7FA618F2AFA}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {66004721-4986-46E2-AD5B-D843D0FD3BE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {66004721-4986-46E2-AD5B-D843D0FD3BE0}.Debug|Any CPU.Build.0 = Debug|Any CPU {66004721-4986-46E2-AD5B-D843D0FD3BE0}.Release|Any CPU.ActiveCfg = Release|Any CPU {66004721-4986-46E2-AD5B-D843D0FD3BE0}.Release|Any CPU.Build.0 = Release|Any CPU {A656DBCB-6308-4F81-8CCE-A7FA618F2AFA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A656DBCB-6308-4F81-8CCE-A7FA618F2AFA}.Debug|Any CPU.Build.0 = Debug|Any CPU {A656DBCB-6308-4F81-8CCE-A7FA618F2AFA}.Release|Any CPU.ActiveCfg = Release|Any CPU {A656DBCB-6308-4F81-8CCE-A7FA618F2AFA}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection EndGlobal SharpEngine.Core-2.5.1/SharpEngine.Core.sln.DotSettings.user000066400000000000000000000016041514307377300236570ustar00rootroot00000000000000 ForceIncluded TrueSharpEngine.Core-2.5.1/SharpEngine.Core/000077500000000000000000000000001514307377300177155ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Component/000077500000000000000000000000001514307377300216575ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Component/AutoComponent.cs000066400000000000000000000047041514307377300250060ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; namespace SharpEngine.Core.Component; /// /// Component that creates automatic movements /// /// Direction /// Rotation public class AutoComponent(Vec2? direction = null, int rotation = 0) : Component { /// /// Automatic Direction /// [UsedImplicitly] public Vec2 Direction { get; set; } = direction ?? Vec2.Zero; /// /// Automatic Rotation /// [UsedImplicitly] public int Rotation { get; set; } = rotation; /// /// Represents the transform component associated with the current object, if available. /// [UsedImplicitly] protected TransformComponent? Transform; /// /// Represents the underlying physics collision component used for basic collision detection. /// [UsedImplicitly] protected CollisionComponent? BasicPhysics; /// public override void Load() { base.Load(); Transform = Entity?.GetComponentAs(); BasicPhysics = Entity?.GetComponentAs(); } /// public override void Update(float delta) { base.Update(delta); if (Transform == null) return; if (Direction.Length() != 0) { var newPos = new Vec2( Transform.LocalPosition.X + Direction.X * delta, Transform.LocalPosition.Y + Direction.Y * delta ); var newPosX = new Vec2(newPos.X, Transform.LocalPosition.Y); var newPosY = new Vec2(Transform.LocalPosition.X, newPos.Y); if (BasicPhysics == null || BasicPhysics.CanGo(newPos + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) Transform.LocalPosition = newPos; else if (Direction.X != 0 && BasicPhysics.CanGo(newPosX + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) Transform.LocalPosition = newPosX; else if (Direction.Y != 0 && BasicPhysics.CanGo(newPosY + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) Transform.LocalPosition = newPosY; } if (Rotation != 0) Transform.LocalRotation += Rotation * delta; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/CollisionComponent.cs000066400000000000000000000103631514307377300260270ustar00rootroot00000000000000using System; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Component; /// /// Component which adds basic collision functionality. /// /// The size of the collision. /// The offset of the collision (default: Vec2(0)). /// Determines if the collision is solid (default: true). /// The action to be called when a collision occurs (default: null). /// Determines if the collision should be drawn for debugging (default: false). public class CollisionComponent( Vec2 size, Vec2? offset = null, bool solid = true, Action? collisionCallback = null, bool drawDebug = false ) : Component { /// /// Gets or sets the size of the collision. /// [UsedImplicitly] public Vec2 Size { get; set; } = size; /// /// Gets or sets the offset of the collision. /// [UsedImplicitly] public Vec2 Offset { get; set; } = offset ?? Vec2.Zero; /// /// Gets or sets a value indicating whether the collision is solid. /// [UsedImplicitly] public bool Solid { get; set; } = solid; /// /// Gets or sets the collision callback action. /// [UsedImplicitly] public Action? CollisionCallback { get; set; } = collisionCallback; /// /// Gets or sets a value indicating whether the collision should be drawn for debugging. /// [UsedImplicitly] public bool DrawDebug { get; set; } = drawDebug; /// /// Represents the transform component associated with the current object, if available. /// [UsedImplicitly] protected TransformComponent? TransformComponent; /// /// Gets the collision rectangle. /// /// The position (or current position). /// The collision rectangle. [UsedImplicitly] public Rect GetCollisionRect(Vec2? position = null) { position ??= TransformComponent?.Position; var scale = TransformComponent?.Scale ?? Vec2.One; return new Rect( position?.X + Offset.X - Size.X * scale.X / 2 ?? 0, position?.Y + Offset.Y - Size.Y * scale.Y / 2 ?? 0, Size * scale ); } /// /// Checks if the entity can go to the specified position. /// /// The position. /// True if the entity can go to the position; otherwise, false. public bool CanGo(Vec2 position) { var canGo = true; foreach (var entity in Entity?.Scene?.Entities!) { if (entity == Entity) continue; // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator foreach (var entityPhysics in entity.GetComponentsAs()) { var entityRect = entityPhysics.GetCollisionRect(); var selfRect = GetCollisionRect(position); if (!Raylib.CheckCollisionRecs(entityRect, selfRect)) continue; CollisionCallback?.Invoke(Entity, entity); entityPhysics.CollisionCallback?.Invoke(Entity, entity); if (canGo) canGo = !(Solid && entityPhysics.Solid); } } return canGo; } /// public override void Load() { base.Load(); TransformComponent = Entity?.GetComponentAs(); } /// public override void Draw() { base.Draw(); if (TransformComponent == null) return; if (DrawDebug) SERender.DrawRectangleLines( GetCollisionRect(), 2, Color.Red, InstructionSource.Entity, float.MaxValue ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/Component.cs000066400000000000000000000014231514307377300241500ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Component; /// /// Abstract Class for Components /// public abstract class Component { /// /// Entity to which the component is attached /// public Entity.Entity? Entity { get; set; } /// /// Load Component /// public virtual void Load() { } /// /// Unload Component /// [UsedImplicitly] public virtual void Unload() { } /// /// Update Component /// /// Time since last frame public virtual void Update(float delta) { } /// /// Draw Component /// public virtual void Draw() { } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/ControlComponent.cs000066400000000000000000000162331514307377300255160ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; namespace SharpEngine.Core.Component; /// /// Component which represents Controls /// public class ControlComponent : Component { /// /// Type of Control /// [UsedImplicitly] public ControlType ControlType { get; set; } /// /// Speed of Control /// [UsedImplicitly] public int Speed { get; set; } /// /// If Control use GamePad /// [UsedImplicitly] public bool UseGamePad { get; set; } /// /// Index of GamePad /// [UsedImplicitly] public int GamePadIndex { get; set; } /// /// Jump force /// [UsedImplicitly] public float JumpForce { get; set; } /// /// If Entity is moving /// [UsedImplicitly] public bool IsMoving { get; protected set; } /// /// If Entity can jump /// [UsedImplicitly] public bool CanJump { get; protected set; } /// /// Direction of Control /// [UsedImplicitly] public Vec2 Direction { get; protected set; } /// /// Represents the transform component associated with the current object, if available. /// [UsedImplicitly] protected TransformComponent? Transform; /// /// Represents the underlying physics collision component used for basic collision detection. /// [UsedImplicitly] protected CollisionComponent? BasicPhysics; private readonly Dictionary _keys; /// /// Create Control Component /// /// Control Type (FourDirection) /// Speed (300) /// Jump Force (3) /// Use Game Pad (false) /// Game Pad Index (1) public ControlComponent( ControlType controlType = ControlType.FourDirection, int speed = 300, float jumpForce = 2, bool useGamePad = false, int gamePadIndex = 1 ) { ControlType = controlType; Speed = speed; IsMoving = false; UseGamePad = useGamePad; GamePadIndex = gamePadIndex; JumpForce = jumpForce; CanJump = true; _keys = new Dictionary { { ControlKey.Up, Key.Up }, { ControlKey.Down, Key.Down }, { ControlKey.Left, Key.Left }, { ControlKey.Right, Key.Right } }; Direction = Vec2.Zero; } /// /// Get Key for a Control /// /// Key Control /// Key [UsedImplicitly] public Key GetKey(ControlKey controlKey) => _keys[controlKey]; /// /// Set Key for a Control /// /// Key Control /// Key [UsedImplicitly] public void SetKey(ControlKey controlKey, Key key) => _keys[controlKey] = key; /// public override void Load() { base.Load(); Transform = Entity?.GetComponentAs(); BasicPhysics = Entity?.GetComponentAs(); } /// public override void Update(float delta) { base.Update(delta); IsMoving = false; if (Transform == null) return; var move = GetMovement(); if (move.IsZero()) { Direction = Vec2.Zero; return; } IsMoving = true; Direction = move.Normalized(); var newPos = new Vec2( Transform.LocalPosition.X + Direction.X * Speed * delta, Transform.LocalPosition.Y + Direction.Y * Speed * delta ); var newPosX = new Vec2( Transform.LocalPosition.X + Speed * delta * (Direction.X < 0 ? -1 : 1), Transform.LocalPosition.Y ); var newPosY = new Vec2( Transform.LocalPosition.X, Transform.LocalPosition.Y + Speed * delta * (Direction.Y < 0 ? -1 : 1) ); if (BasicPhysics == null || BasicPhysics.CanGo(newPos + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) Transform.LocalPosition = newPos; else if (Direction.X != 0 && BasicPhysics.CanGo(newPosX + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) { Transform.LocalPosition = newPosX; Direction = new Vec2(Direction.X < 0 ? -1 : 1, 0); } else if (Direction.Y != 0 && BasicPhysics.CanGo(newPosY + (Entity?.Parent?.GetComponentAs()?.Position ?? Vec2.Zero))) { Transform.LocalPosition = newPosY; Direction = new Vec2(0, Direction.Y < 0 ? -1 : 1); } else IsMoving = false; } private Vec2 GetMovement() { return ControlType switch { ControlType.MouseFollow => GetMouseFollowMovement(), ControlType.LeftRight => GetLeftRightMovement(), ControlType.UpDown => GetUpDownMovement(), ControlType.FourDirection => GetFourDirectionMovement(), ControlType.ClassicJump => Vec2.Zero, _ => throw new ArgumentException("Unknown Control Type") }; } private Vec2 GetMouseFollowMovement() { var mp = InputManager.GetMousePosition(); return mp - Transform!.Position; } private Vec2 GetFourDirectionMovement() { if (UseGamePad) return new Vec2(InputManager.GetGamePadAxis(GamePadIndex, GamePadAxis.LeftX), InputManager.GetGamePadAxis(GamePadIndex, GamePadAxis.LeftY)); var dirX = 0; var dirY = 0; if (InputManager.IsKeyDown(_keys[ControlKey.Left])) dirX--; if (InputManager.IsKeyDown(_keys[ControlKey.Right])) dirX++; if (InputManager.IsKeyDown(_keys[ControlKey.Up])) dirY--; if (InputManager.IsKeyDown(_keys[ControlKey.Down])) dirY++; return new Vec2(dirX, dirY); } private Vec2 GetLeftRightMovement() { if (UseGamePad) return new Vec2(InputManager.GetGamePadAxis(GamePadIndex, GamePadAxis.LeftX), 0); var dirX = 0; if (InputManager.IsKeyDown(_keys[ControlKey.Left])) dirX--; if (InputManager.IsKeyDown(_keys[ControlKey.Right])) dirX++; return new Vec2(dirX, 0); } private Vec2 GetUpDownMovement() { if (UseGamePad) return new Vec2(0, InputManager.GetGamePadAxis(GamePadIndex, GamePadAxis.LeftY)); var dirY = 0; if (InputManager.IsKeyDown(_keys[ControlKey.Up])) dirY--; if (InputManager.IsKeyDown(_keys[ControlKey.Down])) dirY++; return new Vec2(0, dirY); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/ParticleComponent.cs000066400000000000000000000023561514307377300256420ustar00rootroot00000000000000using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Particle; namespace SharpEngine.Core.Component; /// /// Component which can display particles /// [UsedImplicitly] public class ParticleComponent : Component { /// /// Particle Emitters /// [UsedImplicitly] public List ParticleEmitters { get; } = []; /// /// Represents the associated transform component for the current object, if available. /// [UsedImplicitly] protected TransformComponent? Transform; /// public override void Load() { base.Load(); Transform = Entity?.GetComponentAs(); } /// public override void Update(float delta) { base.Update(delta); if (Transform == null) return; foreach (var emitter in ParticleEmitters) emitter.Update(delta, Transform.Position); } /// public override void Draw() { base.Draw(); if (Transform == null) return; foreach (var emitter in ParticleEmitters) emitter.Draw(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/RectComponent.cs000066400000000000000000000043301514307377300247660ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; namespace SharpEngine.Core.Component; /// /// Component which draw rectangle /// /// Rectangle Color /// Rectangle Size /// If displayed /// Rectangle Offset /// Offset of zLayer public class RectComponent( Utils.Color color, Vec2 size, bool displayed = true, Vec2? offset = null, int zLayerOffset = 0 ) : Component { /// /// Color of Rectangle /// [UsedImplicitly] public Utils.Color Color { get; set; } = color; /// /// Size of Rectangle /// [UsedImplicitly] public Vec2 Size { get; set; } = size; /// /// If Rectangle is displayed /// [UsedImplicitly] public bool Displayed { get; set; } = displayed; /// /// Offset of Rectangle /// [UsedImplicitly] public Vec2 Offset { get; set; } = offset ?? Vec2.Zero; /// /// Offset of ZLayer of Rectangle /// [UsedImplicitly] public int ZLayerOffset { get; set; } = zLayerOffset; /// /// Represents the associated transform component, which defines the position, rotation, and scale of the object in /// the scene. /// [UsedImplicitly] protected TransformComponent? Transform; /// public override void Load() { base.Load(); Transform = Entity?.GetComponentAs(); } /// public override void Draw() { base.Draw(); if (Transform == null || !Displayed) return; var finalSize = Size * Transform.Scale; var position = Transform.GetTransformedPosition(Offset); SERender.DrawRectangle( new Rect(position.X, position.Y, finalSize.X, finalSize.Y), finalSize / 2, Transform.Rotation, Color, InstructionSource.Entity, Transform.ZLayer + ZLayerOffset ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/SpriteComponent.cs000066400000000000000000000100511514307377300253340ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; namespace SharpEngine.Core.Component; /// /// Component which display sprite /// /// Name Texture Displayed /// If Texture is Displayed (true) /// Offset (Vec2(0)) /// If Sprite is Flip Horizontally /// If Sprite is Flip Vertically /// Offset of zLayer /// Sprite Shader ("") [UsedImplicitly] public class SpriteComponent( string texture, bool displayed = true, Vec2? offset = null, bool flipX = false, bool flipY = false, int zLayerOffset = 0, string shader = "" ) : Component { /// /// Name of Texture which be displayed /// [UsedImplicitly] public string Texture { get; set; } = texture; /// /// Define if Sprite is displayed /// [UsedImplicitly] public bool Displayed { get; set; } = displayed; /// /// Offset of Sprite /// [UsedImplicitly] public Vec2 Offset { get; set; } = offset ?? Vec2.Zero; /// /// If Sprite is Flip Horizontally /// [UsedImplicitly] public bool FlipX { get; set; } = flipX; /// /// If Sprite is Flip Vertically /// [UsedImplicitly] public bool FlipY { get; set; } = flipY; /// /// Offset of ZLayer of Sprite /// [UsedImplicitly] public int ZLayerOffset { get; set; } = zLayerOffset; /// /// Shader of Sprite /// [UsedImplicitly] public string Shader { get; set; } = shader; /// /// Tint Color of Sprite /// [UsedImplicitly] public Utils.Color TintColor { get; set; } = Utils.Color.White; /// /// Represents the associated transform component, which provides position, rotation, and scale information for the /// object. /// [UsedImplicitly] protected TransformComponent? TransformComponent; /// public override void Load() { base.Load(); TransformComponent = Entity?.GetComponentAs(); } /// public override void Draw() { base.Draw(); var window = Entity?.Scene?.Window; if (TransformComponent == null || !Displayed || Texture.Length <= 0 || window == null) return; var finalTexture = window.TextureManager.GetTexture(Texture); var position = TransformComponent.GetTransformedPosition(Offset); if (Shader == "") DrawTexture(finalTexture, position); else { SERender.ShaderMode( window.ShaderManager.GetShader(Shader).GetInternalShader(), InstructionSource.Entity, TransformComponent.ZLayer + ZLayerOffset, () => DrawTexture(finalTexture, position) ); } } private void DrawTexture(Texture2D finalTexture, Vec2 position) { SERender.DrawTexture( finalTexture, new Rect( 0, 0, FlipX ? -finalTexture.Width : finalTexture.Width, FlipY ? -finalTexture.Height : finalTexture.Height ), new Rect( position.X, position.Y, finalTexture.Width * TransformComponent!.Scale.X, finalTexture.Height * TransformComponent.Scale.Y ), new Vec2( finalTexture.Width / 2f * TransformComponent.Scale.X, finalTexture.Height / 2f * TransformComponent.Scale.Y ), TransformComponent.Rotation, TintColor, InstructionSource.Entity, TransformComponent.ZLayer + ZLayerOffset ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/SpriteSheetComponent.cs000066400000000000000000000137701514307377300263400ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Component; /// /// Component that draws animations with sprite sheet /// /// Texture Name /// Frame Size /// Animation List /// Current Animation /// If Displayed /// Offset /// Offset of zLayer [UsedImplicitly] public class SpriteSheetComponent( string texture, Vec2 spriteSize, List animations, string currentAnim = "", bool displayed = true, Vec2? offset = null, int zLayerOffset = 0 ) : Component { /// /// Name of Texture /// [UsedImplicitly] public string Texture { get; set; } = texture; /// /// Size of one frame /// [UsedImplicitly] public Vec2 SpriteSize { get; set; } = spriteSize; /// /// List of Animations /// [UsedImplicitly] public List Animations { get; set; } = animations; /// /// If a component is displayed /// [UsedImplicitly] public bool Displayed { get; set; } = displayed; /// /// Offset /// [UsedImplicitly] public Vec2 Offset { get; set; } = offset ?? Vec2.Zero; /// /// If Sprite is Flip Horizontally /// [UsedImplicitly] public bool FlipX { get; set; } /// /// If Sprite is Flip Vertically /// [UsedImplicitly] public bool FlipY { get; set; } /// /// Offset of ZLayer of Sprite Sheet /// [UsedImplicitly] public int ZLayerOffset { get; set; } = zLayerOffset; /// /// Current animation /// [UsedImplicitly] public string Anim { get => CurrentAnim; set { CurrentAnim = value; CurrentImage = 0; InternalTimer = GetAnimation(CurrentAnim)?.Timer ?? 0; } } /// /// Current image index /// [UsedImplicitly] public int CurrentImage { get; protected set; } /// /// Event triggered when animation ends /// [UsedImplicitly] public EventHandler? AnimationEnded; /// /// Current internal animation /// [UsedImplicitly] protected string CurrentAnim = currentAnim; /// /// Current internal timer /// [UsedImplicitly] protected float InternalTimer; /// /// Represents the associated transform component for the current object, if available. /// [UsedImplicitly] protected TransformComponent? Transform; /// /// Return Animation by name /// /// Animation Name /// Animation or null [UsedImplicitly] public Animation? GetAnimation(string name) => Animations.FirstOrDefault(animation => animation.Name == name); /// /// Replay current animation /// [UsedImplicitly] public void Replay() { CurrentImage = 0; InternalTimer = GetAnimation(CurrentAnim)?.Timer ?? 0; } /// public override void Load() { base.Load(); Transform = Entity?.GetComponentAs(); } /// public override void Update(float delta) { var anim = GetAnimation(CurrentAnim); if (anim == null) return; if (InternalTimer <= 0) { if(CurrentImage == -1) return; if (CurrentImage >= anim.Value.Indices.Count - 1) { AnimationEnded?.Invoke(this, EventArgs.Empty); if (anim.Value.Loop) CurrentImage = 0; else CurrentImage = -1; } else CurrentImage++; InternalTimer = anim.Value.Timer; } InternalTimer -= delta; } /// public override void Draw() { base.Draw(); var window = Entity?.Scene?.Window; var anim = GetAnimation(CurrentAnim); if ( Transform == null || !Displayed || Texture.Length <= 0 || SpriteSize == Vec2.Zero || anim == null || window == null ) return; var currentImage = CurrentImage == -1 ? anim.Value.Indices.Count - 1 : CurrentImage; var finalTexture = window.TextureManager.GetTexture(Texture); var position = Transform.GetTransformedPosition(Offset); SERender.DrawTexture( finalTexture, new Rect( SpriteSize.X * (anim.Value.Indices[currentImage] % (finalTexture.Width / SpriteSize.X)), SpriteSize.Y * (int)( anim.Value.Indices[currentImage] / (int)(finalTexture.Width / SpriteSize.X) ), FlipX ? -SpriteSize.X : SpriteSize.X, FlipY ? -SpriteSize.Y : SpriteSize.Y ), new Rect( position.X, position.Y, SpriteSize.X * Transform.Scale.X, SpriteSize.Y * Transform.Scale.Y ), new Vec2( SpriteSize.X / 2f * Transform.Scale.X, SpriteSize.Y / 2f * Transform.Scale.Y ), Transform.Rotation, Color.White, InstructionSource.Entity, Transform.ZLayer + ZLayerOffset ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/TextComponent.cs000066400000000000000000000061301514307377300250150ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; namespace SharpEngine.Core.Component; /// /// Component which display Text /// /// Text /// Font Name (RAYLIB_DEFAULT) /// Color (Color.Black) /// If Text is Displayed (true) /// Font Size (null) /// Offset (Vec2(0)) /// Offset of zLayer [UsedImplicitly] public class TextComponent( string text, string font = "RAYLIB_DEFAULT", Utils.Color? color = null, bool displayed = true, int? fontSize = null, Vec2? offset = null, int zLayerOffset = 0 ) : Component { /// /// Text which be displayed /// [UsedImplicitly] public string Text { get; set; } = text; /// /// Name of Font /// [UsedImplicitly] public string Font { get; set; } = font; /// /// Color of Text /// [UsedImplicitly] public Utils.Color Color { get; set; } = color ?? Utils.Color.Black; /// /// Define if Text is displayed /// [UsedImplicitly] public bool Displayed { get; set; } = displayed; /// /// Offset of Text /// [UsedImplicitly] public Vec2 Offset { get; set; } = offset ?? Vec2.Zero; /// /// Font Size (can be null and use the basic size of Font) /// [UsedImplicitly] public int? FontSize { get; set; } = fontSize; /// /// Offset of ZLayer of Text /// [UsedImplicitly] public int ZLayerOffset { get; set; } = zLayerOffset; /// /// Represents the transform component associated with the current object, if available. /// [UsedImplicitly] protected TransformComponent? TransformComponent; /// public override void Load() { base.Load(); TransformComponent = Entity?.GetComponentAs(); } /// public override void Draw() { base.Draw(); var window = Entity?.Scene?.Window; if ( TransformComponent == null || !Displayed || Text.Length <= 0 || Font.Length <= 0 || window == null ) return; var finalFont = window.FontManager.GetFont(Font); var finalFontSize = FontSize ?? finalFont.BaseSize; var position = TransformComponent.GetTransformedPosition(Offset); var textSize = Raylib.MeasureTextEx(finalFont, Text, finalFontSize, 2); SERender.DrawText( finalFont, Text, position, textSize / 2, TransformComponent.Rotation, finalFontSize, 2, Color, InstructionSource.Entity, TransformComponent.ZLayer + ZLayerOffset ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Component/TransformComponent.cs000066400000000000000000000042351514307377300260500ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; namespace SharpEngine.Core.Component; /// /// Component that defines Transform (Position, Rotation, Scale) /// /// Position (Vec2(0)) /// Scale (Vec2(1)) /// Rotation (0) /// ZLayer (0) public class TransformComponent( Vec2? position = null, Vec2? scale = null, float rotation = 0, int zLayer = 0 ) : Component { /// /// Position of Component /// public Vec2 Position => Entity?.Parent?.GetComponentAs()?.Position is { } parentPosition ? parentPosition + LocalPosition : LocalPosition; /// /// Scale of Component /// public Vec2 Scale => Entity?.Parent?.GetComponentAs()?.Scale is { } parentScale ? parentScale * LocalScale : LocalScale; /// /// Rotation of Component /// public float Rotation => Entity?.Parent?.GetComponentAs()?.Rotation + LocalRotation ?? LocalRotation; /// /// ZLayer of Component /// public int ZLayer => Entity?.Parent?.GetComponentAs()?.ZLayer + LocalZLayer ?? LocalZLayer; /// /// Position of Component /// public Vec2 LocalPosition { get; set; } = position ?? Vec2.Zero; /// /// Scale of Component /// [UsedImplicitly] public Vec2 LocalScale { get; set; } = scale ?? Vec2.One; /// /// Rotation of Component /// public float LocalRotation { get; set; } = rotation; /// /// ZLayer of Component /// [UsedImplicitly] public int LocalZLayer { get; set; } = zLayer; /// /// Get transformed Position /// /// Offset (Vec2(0)) /// Transformed Position public Vec2 GetTransformedPosition(Vec2? offset = null) => new Vec2(Position.X + (offset?.X ?? 0), Position.Y + (offset?.Y ?? 0)); } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/000077500000000000000000000000001514307377300205665ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Data/DataTable/000077500000000000000000000000001514307377300224075ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Data/DataTable/IDataTable.cs000066400000000000000000000013451514307377300246730ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; namespace SharpEngine.Core.Data.DataTable; /// /// Table of Data /// public interface IDataTable where T : class { /// /// Add Object /// /// Object [UsedImplicitly] public void Add(T obj); /// /// Remove Object /// /// Object [UsedImplicitly] public void Remove(T obj); /// /// Get Object /// /// Predicate /// Objects [UsedImplicitly] public IEnumerable Get(Func predicate); } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/DataTable/JsonDataTable.cs000066400000000000000000000021221514307377300254060ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Text.Json; using JetBrains.Annotations; namespace SharpEngine.Core.Data.DataTable; /// /// Json Data Table /// /// JSON File [UsedImplicitly] public class JsonDataTable(string jsonFile) : IDataTable where T : class { private List Objects { get; } = JsonSerializer.Deserialize>(File.ReadAllText(jsonFile))?.ToList() ?? []; /// public void Add(T obj) { ArgumentNullException.ThrowIfNull(obj); Objects.Add(obj); File.WriteAllText(jsonFile, JsonSerializer.Serialize(Objects)); } /// public IEnumerable Get(Func predicate) { ArgumentNullException.ThrowIfNull(predicate); return Objects.Where(predicate); } /// public void Remove(T obj) { ArgumentNullException.ThrowIfNull(obj); Objects.Remove(obj); File.WriteAllText(jsonFile, JsonSerializer.Serialize(Objects)); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Lang/000077500000000000000000000000001514307377300214475ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Lang/ILang.cs000066400000000000000000000012601514307377300227670ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Data.Lang; /// /// Interface which represents Lang File /// public interface ILang { /// /// Get Translation for Key /// /// Translation Key /// Default Translation /// Translation or Default Translation if key not found public string GetTranslation(string key, string defaultTranslation); /// /// Reload Translations from File /// /// File Path [UsedImplicitly] public void Reload(string file); } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Lang/JsonLang.cs000066400000000000000000000015561514307377300235200ustar00rootroot00000000000000using System.Collections.Generic; using System.IO; using System.Text.Json; using JetBrains.Annotations; namespace SharpEngine.Core.Data.Lang; /// /// Class which represents Lang File with Json /// [UsedImplicitly] public class JsonLang : ILang { private Dictionary _translations = []; /// /// Create JsonLang /// /// Json Path public JsonLang(string file) { Reload(file); } /// public string GetTranslation(string key, string defaultTranslation) => _translations.GetValueOrDefault(key, defaultTranslation); /// public void Reload(string file) { _translations = JsonSerializer.Deserialize>(File.ReadAllText(file)) ?? []; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Lang/McLang.cs000066400000000000000000000026231514307377300231420ustar00rootroot00000000000000using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Manager; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Data.Lang; /// /// Class which represents Lang File with Minecraft Format (allow start line comments) /// [UsedImplicitly] public class McLang : ILang { private readonly Dictionary _translations = []; /// /// Create MC Lang /// /// MC Lang Path public McLang(string file) { Reload(file); } /// public string GetTranslation(string key, string defaultTranslation) => _translations.GetValueOrDefault(key, defaultTranslation); /// public void Reload(string file) { _translations.Clear(); foreach (var line in System.IO.File.ReadAllLines(file)) { var finalLine = line.Trim(); if (finalLine.StartsWith('#') || finalLine.Length == 0) continue; if (!finalLine.Contains('=')) { DebugManager.Log( LogLevel.Warning, $"SE_MCLANG: Cannot found '=' between key and value : {line} (Skip line)" ); continue; } _translations.Add(finalLine.Split("=")[0], finalLine.Split("=")[1]); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Save/000077500000000000000000000000001514307377300214645ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Save/BinarySave.cs000066400000000000000000000042461514307377300240640ustar00rootroot00000000000000using System.Collections.Generic; using System.IO; using JetBrains.Annotations; namespace SharpEngine.Core.Data.Save; /// /// Class which represents Save with binary data /// [UsedImplicitly] public class BinarySave : ISave { private readonly Dictionary _data = []; /// public void Read(string file) { _data.Clear(); using var bR = new BinaryReader(File.OpenRead(file)); try { while (bR.ReadString() is { } key) { var type = bR.ReadString(); object value = type switch { "b" => bR.ReadBoolean(), "i" => bR.ReadInt32(), "d" => bR.ReadDouble(), _ => bR.ReadString() }; _data.Add(key, value); } } catch (EndOfStreamException) { // Do nothing } } /// public void Write(string file) { using var bW = new BinaryWriter(File.Open(file, FileMode.Create)); foreach (var data in _data) { bW.Write(data.Key); switch (data.Value) { case bool v: bW.Write("b"); bW.Write(v); break; case int v: bW.Write("i"); bW.Write(v); break; case double v: bW.Write("d"); bW.Write(v); break; default: bW.Write("s"); bW.Write(data.Value.ToString() ?? string.Empty); break; } } } /// public object GetObject(string key, object defaultValue) => _data.GetValueOrDefault(key, defaultValue); /// public T GetObjectAs(string key, T defaultValue) => _data.TryGetValue(key, out var value) ? (T)value : defaultValue; /// public void SetObject(string key, object value) => _data[key] = value; } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Save/ISave.cs000066400000000000000000000025731514307377300230310ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Data.Save; /// /// Interface which represents Save /// public interface ISave { /// /// Read Save /// /// Save File [UsedImplicitly] public void Read(string file); /// /// Write Save /// /// Save File [UsedImplicitly] public void Write(string file); /// /// Get Object from Save /// /// Object Key /// Default Value /// Object or Default value if key not found [UsedImplicitly] public object GetObject(string key, object defaultValue); /// /// Get Object from Save and cast it /// /// Object Key /// Default Value /// Type of Object /// Object or Default value if key not found [UsedImplicitly] public T GetObjectAs(string key, T defaultValue); /// /// Define Object /// /// Object Key /// Object [UsedImplicitly] public void SetObject(string key, object value); } SharpEngine.Core-2.5.1/SharpEngine.Core/Data/Save/JsonSave.cs000066400000000000000000000022051514307377300235420ustar00rootroot00000000000000using System.Collections.Generic; using System.IO; using System.Text.Json; using JetBrains.Annotations; namespace SharpEngine.Core.Data.Save; /// /// Class which represents Save with json data /// [UsedImplicitly] public class JsonSave : ISave { private Dictionary _data = []; /// public void Read(string file) { _data = JsonSerializer.Deserialize>(File.ReadAllText(file)) ?? []; } /// public void Write(string file) => File.WriteAllText(file, JsonSerializer.Serialize(_data)); /// public object GetObject(string key, object defaultValue) => _data.GetValueOrDefault(key, defaultValue); /// public T GetObjectAs(string key, T defaultValue) { if(_data.TryGetValue(key, out var value)) return (value is JsonElement element ? element.Deserialize() : (T) value) ?? defaultValue; return defaultValue; } /// public void SetObject(string key, object value) => _data[key] = value; } SharpEngine.Core-2.5.1/SharpEngine.Core/Entity/000077500000000000000000000000001514307377300211715ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Entity/Entity.cs000066400000000000000000000106141514307377300227760ustar00rootroot00000000000000using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Entity; /// /// Class which represents Entity /// [UsedImplicitly] public class Entity { /// /// How Entity must be updated when paused /// [UsedImplicitly] public PauseState PauseState { get; set; } = PauseState.Normal; /// /// Tag of Entity /// [UsedImplicitly] public string Tag { get; set; } = ""; /// /// Name of Entity /// [UsedImplicitly] public string Name { get; set; } = ""; /// /// Scene of Entity /// public Scene? Scene { get; set; } /// /// Get All Components of Entity /// [UsedImplicitly] public List Components { get; } = []; /// /// Get All Children of Entity /// [UsedImplicitly] public List Children { get; } = []; /// /// Parent of Entity /// [UsedImplicitly] public Entity? Parent { get; set; } /// /// Get All Components of one Type /// /// Type of Component /// Components of type T public List GetComponentsAs() where T : Component.Component => Components.OfType().ToList(); /// /// Get Component of one Type /// /// Type of Component /// Component of type T public T? GetComponentAs() where T : Component.Component => Components.OfType().FirstOrDefault(); /// /// Get Scene as T /// /// Scene Type /// Scene cast as T [UsedImplicitly] public T? GetSceneAs() where T : Scene => (T?)Scene; /// /// Add Child Entity /// /// /// /// [UsedImplicitly] public T AddChild(T entity) where T : Entity { Children.Add(entity); entity.Parent = this; entity.Scene = Scene; return entity; } /// /// Add a Component and return it /// /// Component which be added /// Type of Component /// Component [UsedImplicitly] public T AddComponent(T component) where T : Component.Component { Components.Add(component); component.Entity = this; return component; } /// /// Remove Child /// /// Child [UsedImplicitly] public void RemoveChild(Entity entity) { entity.Parent = null; entity.Scene = null; Children.Remove(entity); } /// /// Remove Component /// /// Component will be removed [UsedImplicitly] public void RemoveComponent(Component.Component component) { component.Entity = null; Components.Remove(component); } /// /// Load Entity /// public virtual void Load() { foreach (var component in Components) component.Load(); foreach (var child in Children) child.Load(); } /// /// Unload Entity /// public virtual void Unload() { foreach (var component in Components) component.Unload(); foreach (var child in Children) child.Unload(); } /// /// Update Entity /// /// Time since last frame public virtual void Update(float delta) { foreach (var component in Components) component.Update(delta); foreach (var child in Children) child.Update(delta); } /// /// Draw Entity /// public virtual void Draw() { foreach (var component in Components) component.Draw(); foreach (var child in Children) child.Draw(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Extensions.cs000066400000000000000000000022431514307377300224040ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Input; using SharpEngine.Core.Utils; namespace SharpEngine.Core; internal static class Extensions { public static Raylib_cs.MouseButton ToRayLib(this Input.MouseButton button) => (Raylib_cs.MouseButton)button; public static KeyboardKey ToRayLib(this Key key) => (KeyboardKey)key; public static GamepadButton ToRayLib(this GamePadButton button) => (GamepadButton)button; public static GamepadAxis ToRayLib(this GamePadAxis axis) => (GamepadAxis)axis; public static TraceLogLevel ToRayLib(this LogLevel logLevel) => (TraceLogLevel)logLevel; [UsedImplicitly] public static Input.MouseButton ToSe(this Raylib_cs.MouseButton button) => (Input.MouseButton)button; [UsedImplicitly] public static Key ToSe(this KeyboardKey key) => (Key)key; [UsedImplicitly] public static GamePadButton ToSe(this GamepadButton button) => (GamePadButton)button; [UsedImplicitly] public static GamePadAxis ToSe(this GamepadAxis axis) => (GamePadAxis)axis; [UsedImplicitly] public static LogLevel ToSe(this TraceLogLevel logLevel) => (LogLevel)logLevel; } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/000077500000000000000000000000001514307377300210145ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Input/ControlKey.cs000066400000000000000000000005571514307377300234430ustar00rootroot00000000000000namespace SharpEngine.Core.Input; /// /// Control Keys /// public enum ControlKey { /// /// Up Key /// Up, /// /// Down Key /// Down, /// /// Left Key /// Left, /// /// Right Key /// Right } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/ControlType.cs000066400000000000000000000010561514307377300236270ustar00rootroot00000000000000namespace SharpEngine.Core.Input; /// /// Type of Controls /// public enum ControlType { /// /// Follow Mouse /// MouseFollow, /// /// Only Left and Right Movements /// LeftRight, /// /// Only Up and Down Movements /// UpDown, /// /// Up, Down, Left and Right Movements /// FourDirection, /// /// Classic Platformer Movements /// ClassicJump } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/GamePadAxis.cs000066400000000000000000000013161514307377300234670ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Input; /// /// Enum which represents Axis of Gamepad /// public enum GamePadAxis { /// /// Left Stick X Axis /// LeftX, /// /// Left Stick Y Axis /// LeftY, /// /// Right Stick X Axis /// [UsedImplicitly] RightX, /// /// Right Stick Y Axis /// [UsedImplicitly] RightY, /// /// Left Trigger Axis /// [UsedImplicitly] LeftTrigger, /// /// Right Trigger Axis /// [UsedImplicitly] RightTrigger, } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/GamePadButton.cs000066400000000000000000000036641514307377300240460ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Input; /// /// Enum which represents Button of Gamepad /// public enum GamePadButton { /// /// Unknown Button /// [UsedImplicitly] Unknown, /// /// Directional Cross Up Button /// [UsedImplicitly] DPadUp, /// /// Directional Cross Right Button /// [UsedImplicitly] DPadRight, /// /// Directional Cross Down Button /// [UsedImplicitly] DPadDown, /// /// Directional Cross Left Button /// [UsedImplicitly] DPadLeft, /// /// Y Button (Xbox) /// [UsedImplicitly] Y, /// /// X Button (Xbox) /// [UsedImplicitly] X, /// /// A Button (Xbox) /// [UsedImplicitly] A, /// /// B Button (Xbox) /// [UsedImplicitly] B, /// /// First Left Trigger /// [UsedImplicitly] LeftTrigger1, /// /// Second Left Trigger /// [UsedImplicitly] LeftTrigger2, /// /// First Right Trigger /// [UsedImplicitly] RightTrigger1, /// /// Second Right Trigger /// [UsedImplicitly] RightTrigger2, /// /// Back Button /// [UsedImplicitly] Back, /// /// Big Central Button /// [UsedImplicitly] BigButton, /// /// Start Button /// [UsedImplicitly] Start, /// /// Left Stick Button /// [UsedImplicitly] LeftStick, /// /// Right Stick Button /// [UsedImplicitly] RightStick, } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/Key.cs000066400000000000000000000065471514307377300221070ustar00rootroot00000000000000namespace SharpEngine.Core.Input; /// /// Enum which represents Keys /// public enum Key { #pragma warning disable CS1591 // ReSharper disable UnusedMember.Global None = 0, Back = 4, VolumeUp = 24, // 0x00000018 VolumeDown = 25, // 0x00000019 Space = 32, // 0x00000020 Apostrophe = 39, // 0x00000027 Comma = 44, // 0x0000002C Minus = 45, // 0x0000002D Period = 46, // 0x0000002E Slash = 47, // 0x0000002F Zero = 48, // 0x00000030 One = 49, // 0x00000031 Two = 50, // 0x00000032 Three = 51, // 0x00000033 Four = 52, // 0x00000034 Five = 53, // 0x00000035 Six = 54, // 0x00000036 Seven = 55, // 0x00000037 Eight = 56, // 0x00000038 Nine = 57, // 0x00000039 Semicolon = 59, // 0x0000003B Equal = 61, // 0x0000003D A = 65, // 0x00000041 B = 66, // 0x00000042 C = 67, // 0x00000043 D = 68, // 0x00000044 E = 69, // 0x00000045 F = 70, // 0x00000046 G = 71, // 0x00000047 H = 72, // 0x00000048 I = 73, // 0x00000049 J = 74, // 0x0000004A K = 75, // 0x0000004B L = 76, // 0x0000004C M = 77, // 0x0000004D N = 78, // 0x0000004E O = 79, // 0x0000004F P = 80, // 0x00000050 Q = 81, // 0x00000051 R = 82, // 0x00000052 S = 83, // 0x00000053 T = 84, // 0x00000054 U = 85, // 0x00000055 V = 86, // 0x00000056 W = 87, // 0x00000057 X = 88, // 0x00000058 Y = 89, // 0x00000059 Z = 90, // 0x0000005A LeftBracket = 91, // 0x0000005B Backslash = 92, // 0x0000005C RightBracket = 93, // 0x0000005D Grave = 96, // 0x00000060 Escape = 256, // 0x00000100 Enter = 257, // 0x00000101 Tab = 258, // 0x00000102 Backspace = 259, // 0x00000103 Insert = 260, // 0x00000104 Delete = 261, // 0x00000105 Right = 262, // 0x00000106 Left = 263, // 0x00000107 Down = 264, // 0x00000108 Up = 265, // 0x00000109 PageUp = 266, // 0x0000010A PageDown = 267, // 0x0000010B Home = 268, // 0x0000010C End = 269, // 0x0000010D CapsLock = 280, // 0x00000118 ScrollLock = 281, // 0x00000119 NumLock = 282, // 0x0000011A PrintScreen = 283, // 0x0000011B Pause = 284, // 0x0000011C F1 = 290, // 0x00000122 F2 = 291, // 0x00000123 F3 = 292, // 0x00000124 F4 = 293, // 0x00000125 F5 = 294, // 0x00000126 F6 = 295, // 0x00000127 F7 = 296, // 0x00000128 F8 = 297, // 0x00000129 F9 = 298, // 0x0000012A F10 = 299, // 0x0000012B F11 = 300, // 0x0000012C F12 = 301, // 0x0000012D Kp0 = 320, // 0x00000140 Kp1 = 321, // 0x00000141 Kp2 = 322, // 0x00000142 Kp3 = 323, // 0x00000143 Kp4 = 324, // 0x00000144 Kp5 = 325, // 0x00000145 Kp6 = 326, // 0x00000146 Kp7 = 327, // 0x00000147 Kp8 = 328, // 0x00000148 Kp9 = 329, // 0x00000149 KpDecimal = 330, // 0x0000014A KpDivide = 331, // 0x0000014B KpMultiply = 332, // 0x0000014C KpSubtract = 333, // 0x0000014D KpAdd = 334, // 0x0000014E KpEnter = 335, // 0x0000014F KpEqual = 336, // 0x00000150 LeftShift = 340, // 0x00000154 LeftControl = 341, // 0x00000155 LeftAlt = 342, // 0x00000156 LeftSuper = 343, // 0x00000157 RightShift = 344, // 0x00000158 RightControl = 345, // 0x00000159 RightAlt = 346, // 0x0000015A RightSuper = 347, // 0x0000015B KbMenu = 348 // 0x0000015C } SharpEngine.Core-2.5.1/SharpEngine.Core/Input/MouseButton.cs000066400000000000000000000014501514307377300236270ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Input; /// /// Enum, which represents Mouse Buttons /// public enum MouseButton { /// /// Left Button /// Left = 0, /// /// Right Button /// [UsedImplicitly] Right = 1, /// /// Middle Button /// [UsedImplicitly] Middle = 2, /// /// Side Button /// [UsedImplicitly] Side = 3, /// /// Extra Button /// [UsedImplicitly] Extra = 4, /// /// Forward Button /// [UsedImplicitly] Forward = 5, /// /// Back Button /// [UsedImplicitly] Back = 6 } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/000077500000000000000000000000001514307377300212675ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/CameraManager.cs000066400000000000000000000063131514307377300243040ustar00rootroot00000000000000using System; using System.Numerics; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Component; using SharpEngine.Core.Math; namespace SharpEngine.Core.Manager; /// /// Class which manager Camera information /// public class CameraManager { /// /// Entity followed on mode Follow and FollowSmooth /// /// [UsedImplicitly] public Entity.Entity? FollowEntity { get; set; } /// /// Camera Mode /// [UsedImplicitly] public Utils.CameraMode Mode { get; set; } /// /// Minimum Speed used when the mode is FollowSmooth /// [UsedImplicitly] public float MinSpeed { get; set; } = 30; /// /// Minimum Effect Length used when the mode is FollowSmooth /// [UsedImplicitly] public float MinEffectLength { get; set; } = 10; /// /// Fraction Speed used when the mode is FollowSmooth /// [UsedImplicitly] public float FractionSpeed { get; set; } = 0.8f; /// /// Rotation of Camera /// [UsedImplicitly] public float Rotation { get => Camera2D.Rotation; set => Camera2D.Rotation = value; } /// /// Zoom of Camera /// [UsedImplicitly] public float Zoom { get => Camera2D.Zoom; set => Camera2D.Zoom = value; } /// /// Position of Camera /// [UsedImplicitly] public Vec2 Position { get => Camera2D.Target; set => Camera2D.Target = value; } internal Camera2D Camera2D; /// /// Create Camera Manager /// public CameraManager() { Camera2D = new Camera2D(Vector2.Zero, Vector2.Zero, 0, 1); Mode = Utils.CameraMode.Basic; } internal void SetScreenSize(Vec2 screenSize) { Camera2D.Offset = screenSize / 2; if (Mode == Utils.CameraMode.Basic) Camera2D.Target = Camera2D.Offset; } /// /// Update Camera Manager /// /// Delta frame public void Update(float delta) { switch (Mode) { case Utils.CameraMode.Follow: if (FollowEntity?.GetComponentAs() is { } transform) Camera2D.Target = transform.Position; break; case Utils.CameraMode.FollowSmooth: if (FollowEntity?.GetComponentAs() is { } transformSmooth) { var diff = transformSmooth.Position - (Vec2)Camera2D.Target; var length = diff.Length(); if (length > MinEffectLength) { var speed = MathF.Max(FractionSpeed * length, MinSpeed); Camera2D.Target += new Vector2( diff.X * (speed * delta / length), diff.Y * (speed * delta / length) ); } } break; } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/DataTableManager.cs000066400000000000000000000051471514307377300247410ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Data.DataTable; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Static Class which manage Data Tables /// public static class DataTableManager { private static readonly Dictionary DataTables = []; /// /// List of known data tables /// public static List DataTableNames => [.. DataTables.Keys]; /// /// Checks if a data table with the specified name exists. /// /// Name of the data table /// True if the data table exists, otherwise false [UsedImplicitly] public static bool HasDataTable(string name) => DataTables.ContainsKey(name); /// /// Removes the specified data table. /// /// Name of the data table [UsedImplicitly] public static void RemoveDataTable(string name) { if (!DataTables.ContainsKey(name)) { DebugManager.Log( LogLevel.Error, $"SE_DATATABLEMANAGER: DataTable not found : {name}" ); throw new ArgumentException($"DataTable not found : {name}"); } DataTables.Remove(name); } /// /// Add a data table to the manager. /// /// Name of the data table /// Data table to add [UsedImplicitly] public static void AddDataTable(string name, IDataTable dataTable) where T : class { if (!DataTables.TryAdd(name, dataTable)) DebugManager.Log( LogLevel.Warning, $"SE_DATATABLEMANAGER: DataTable already exist : {name}" ); } /// /// Get specified data table. /// /// Type of the object /// Name of the data table /// The data table /// Thrown if the data table is not found [UsedImplicitly] public static IDataTable Get(string dataTable) where T : class { if (DataTables.TryGetValue(dataTable, out var dTable)) return (IDataTable)dTable; DebugManager.Log( LogLevel.Error, $"SE_DATATABLEMANAGER: DataTable not found : {dataTable}" ); throw new ArgumentException($"DataTable not found : {dataTable}"); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/DebugManager.cs000066400000000000000000000042361514307377300241440ustar00rootroot00000000000000using System; using System.Collections.Generic; using Raylib_cs; using SharpEngine.Core.Utils; using SharpEngine.Core.Utils.SeImGui; using SharpEngine.Core.Utils.SeImGui.ConsoleCommand; namespace SharpEngine.Core.Manager; /// /// Static class which manage debug information /// public static class DebugManager { /// /// Number of frames per seconds /// public static int FrameRate => Raylib.GetFPS(); /// /// Number of bytes in GC /// public static long GcMemory => GC.GetTotalMemory(false); /// /// Packages Versions /// public static Dictionary Versions { get; } = new() { { "Raylib-cs", "7.0.2" }, { "ImGui.NET", "1.91.6.1" }, { "SharpEngine.Core", "2.5.1" } }; /// /// Default Render ImGui for SharpEngine /// /// Window public static void SeRenderImGui(Window window) { if (window.ImguiDisplayWindow) SeImGuiWindows.CreateSeImGuiWindow(window); if (window.ImguiDisplayConsole) SeImGuiWindows.CreateSeImGuiConsole(window); if (InputManager.IsKeyPressed(Input.Key.F7)) window.ImguiDisplayWindow = !window.ImguiDisplayWindow; if (InputManager.IsKeyPressed(Input.Key.F8)) window.ImguiDisplayConsole = !window.ImguiDisplayConsole; } /// /// Add Console Command /// /// Console Command public static void AddConsoleCommand(ISeImGuiConsoleCommand command) => SeImGuiWindows.Console.Commands.Add(command); /// /// Log Message /// /// Level of Log /// Message public static void Log(LogLevel level, string message) => Raylib.TraceLog(level.ToRayLib(), message); /// /// Set Log Level /// /// Level of Log public static void SetLogLevel(LogLevel level) => Raylib.SetTraceLogLevel(level.ToRayLib()); } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/FontManager.cs000066400000000000000000000057751514307377300240350ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.IO; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Class which manage font /// public class FontManager { private readonly Dictionary _fonts = []; /// /// Get All Fonts /// public List Fonts => [.._fonts.Values]; /// /// Checks if the font with the specified name exists in the manager. /// /// The name of the font. /// true if the font exists; otherwise, false. [UsedImplicitly] public bool HasFont(string name) => _fonts.ContainsKey(name); /// /// Removes the font with the specified name from the manager. /// /// The name of the font to remove. [UsedImplicitly] public void RemoveFont(string name) { if (_fonts.TryGetValue(name, out var font)) { Raylib.UnloadFont(font); _fonts.Remove(name); return; } DebugManager.Log(LogLevel.Error, $"SE_FONTMANAGER: Font not found : {name}"); throw new ArgumentException($"Font not found : {name}"); } /// /// Adds a font to the manager. /// /// The name of the font. /// The path to the font file. /// The size of the font (default is 25). /// Thrown if the font file is not found. [UsedImplicitly] public void AddFont(string name, string file, int fontSize = 25) { if (!File.Exists(file)) { DebugManager.Log(LogLevel.Fatal, $"SE_FONTMANAGER: Font not found : {name}"); throw new FileNotFoundException($"Font not found : {file}"); } if (!_fonts.TryAdd(name, Raylib.LoadFontEx(file, fontSize, null, 250))) DebugManager.Log(LogLevel.Warning, $"SE_FONTMANAGER: Font already exist : {name}"); } /// /// Gets the font with the specified name from the manager. /// /// The name of the font. /// The font. /// Thrown if the font is not found. public Font GetFont(string name) { if (name == "RAYLIB_DEFAULT") return Raylib.GetFontDefault(); if (_fonts.TryGetValue(name, out var font)) return font; DebugManager.Log(LogLevel.Error, $"SE_FONTMANAGER: Font not found : {name}"); throw new ArgumentException($"Font not found : {name}"); } /// /// Unloads all fonts from the manager. /// internal void Unload() { foreach (var font in _fonts.Values) Raylib.UnloadFont(font); _fonts.Clear(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/InputManager.cs000066400000000000000000000175271514307377300242240ustar00rootroot00000000000000using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Input; using SharpEngine.Core.Math; using MouseButton = SharpEngine.Core.Input.MouseButton; namespace SharpEngine.Core.Manager; /// /// Class which manage input interactions /// public static class InputManager { internal static List InternalPressedChars { get; } = []; private static List InternalPressedKeys { get; } = []; internal static Window InternalWindow { get; set; } = null!; /// /// List of Pressed Chars in Frame /// public static List GetPressedChars() => InternalPressedChars.Select(x => (char)x).ToList(); /// /// List of Pressed Keys in Frame /// [UsedImplicitly] public static List GetPressedKeys() => InternalPressedKeys.Cast().ToList(); /// /// Check if key is down /// /// Key /// If Key is down public static bool IsKeyDown(Key key) => Raylib.IsKeyDown(key.ToRayLib()); /// /// Check if key is up /// /// Key /// If Key is up [UsedImplicitly] public static bool IsKeyUp(Key key) => Raylib.IsKeyUp(key.ToRayLib()); /// /// Check if key is pressed /// /// Key /// If Key is pressed public static bool IsKeyPressed(Key key) => Raylib.IsKeyPressed(key.ToRayLib()); /// /// Check if key is released /// /// Key /// If Key is released [UsedImplicitly] public static bool IsKeyReleased(Key key) => Raylib.IsKeyReleased(key.ToRayLib()); /// /// Check if Mouse is in Rect /// /// Rectangle /// If Mouse is in Rect public static bool IsMouseInRectangle(Rect rect) => rect.Contains(GetMousePosition()); /// /// Check if the mouse button is down /// /// Mouse button /// If the mouse button is down public static bool IsMouseButtonDown(MouseButton button) => Raylib.IsMouseButtonDown(button.ToRayLib()); /// /// Check if the mouse button is up /// /// Mouse button /// If the mouse button is up [UsedImplicitly] public static bool IsMouseButtonUp(MouseButton button) => Raylib.IsMouseButtonUp(button.ToRayLib()); /// /// Check if the mouse button is pressed /// /// Mouse button /// If the mouse button is pressed public static bool IsMouseButtonPressed(MouseButton button) => Raylib.IsMouseButtonPressed(button.ToRayLib()); /// /// Check if the mouse button is released /// /// Mouse button /// If the mouse button is released [UsedImplicitly] public static bool IsMouseButtonReleased(MouseButton button) => Raylib.IsMouseButtonReleased(button.ToRayLib()); /// /// Get Mouse position /// /// Position public static Vec2 GetMousePosition() { var realPosition = Raylib.GetMousePosition(); return new Vec2( (realPosition.X - (InternalWindow.ScreenSize.X - (InternalWindow.RenderSize.X * InternalWindow.RenderScale)) * 0.5f) / InternalWindow.RenderScale, (realPosition.Y - (InternalWindow.ScreenSize.Y - (InternalWindow.RenderSize.Y * InternalWindow.RenderScale)) * 0.5f) / InternalWindow.RenderScale ); } /// /// Get Real Mouse position /// /// Position [UsedImplicitly] public static Vec2 GetRealMousePosition() => Raylib.GetMousePosition(); /// /// Set Mouse Position /// /// Position public static void SetMousePosition(Vec2 position) { var x = position.X * InternalWindow.RenderScale + (InternalWindow.ScreenSize.X - (InternalWindow.RenderSize.X * InternalWindow.RenderScale)) * 0.5f; var y = position.Y * InternalWindow.RenderScale + (InternalWindow.ScreenSize.Y - (InternalWindow.RenderSize.Y * InternalWindow.RenderScale)) * 0.5f; Raylib.SetMousePosition((int)x, (int)y); } /// /// Set Real Mouse Position /// /// Position [UsedImplicitly] public static void SetRealMousePosition(Vec2 position) => Raylib.SetMousePosition((int)position.X, (int)position.Y); /// /// Get Mouse Wheel Movement Value /// /// Value public static float GetMouseWheelMove() => Raylib.GetMouseWheelMove(); /// /// Check if the gamepad is connected /// /// Index of Gamepad /// If the gamepad is connected [UsedImplicitly] public static bool IsGamePadConnected(int index) => Raylib.IsGamepadAvailable(index); /// /// Check if the gamepad button is down /// /// Index of Gamepad /// Button of Gamepad /// If the gamepad button is down [UsedImplicitly] public static bool IsGamePadButtonDown(int index, GamePadButton button) => Raylib.IsGamepadButtonDown(index, button.ToRayLib()); /// /// Check if the gamepad button is up /// /// Index of Gamepad /// Button of Gamepad /// If the gamepad button is up [UsedImplicitly] public static bool IsGamePadButtonUp(int index, GamePadButton button) => Raylib.IsGamepadButtonUp(index, button.ToRayLib()); /// /// Check if the gamepad button is pressed /// /// Index of Gamepad /// Button of Gamepad /// If the gamepad button is pressed [UsedImplicitly] public static bool IsGamePadButtonPressed(int index, GamePadButton button) => Raylib.IsGamepadButtonPressed(index, button.ToRayLib()); /// /// Check if the gamepad button is released /// /// Index of Gamepad /// Button of Gamepad /// If the gamepad button is released [UsedImplicitly] public static bool IsGamePadButtonReleased(int index, GamePadButton button) => Raylib.IsGamepadButtonReleased(index, button.ToRayLib()); /// /// Get Gamepad axis value /// /// Index of Gamepad /// Axis of Gamepad /// Value public static float GetGamePadAxis(int index, GamePadAxis axis) => Raylib.GetGamepadAxisMovement(index, axis.ToRayLib()); /// /// Updates the input. /// internal static void UpdateInput() { InternalPressedChars.Clear(); InternalPressedKeys.Clear(); var key = Raylib.GetKeyPressed(); while (key > 0) { InternalPressedKeys.Add(key); key = Raylib.GetKeyPressed(); } var charGot = Raylib.GetCharPressed(); while (charGot > 0) { InternalPressedChars.Add(charGot); charGot = Raylib.GetCharPressed(); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/LangManager.cs000066400000000000000000000044131514307377300237740ustar00rootroot00000000000000using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Data.Lang; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Static Class which manage Langs /// public static class LangManager { /// /// Current Language Used /// [UsedImplicitly] public static string CurrentLang { get; set; } = "default"; /// /// List of known languages /// public static List Langs => [..Languages.Keys]; /// /// Add Language to Manager /// /// Language Name /// Language Object [UsedImplicitly] public static void AddLang(string name, ILang lang) { if (!Languages.TryAdd(name, lang)) DebugManager.Log(LogLevel.Warning, $"SE_LANGMANAGER: Lang already exist : {name}"); } /// /// Get Translation with current language /// /// Translation Key /// Default Translation /// Translation or Default Translation if key or language not found [UsedImplicitly] public static string GetTranslation(string key, string defaultTranslation) => GetTranslation(key, defaultTranslation, CurrentLang); /// /// Get Translation with specified language /// /// Translation Key /// Default Translation /// Language Name /// Translation or Default Translation if key or language not found [UsedImplicitly] public static string GetTranslation(string key, string defaultTranslation, string lang) { if (Languages.TryGetValue(lang, out var translation)) return translation.GetTranslation(key, defaultTranslation); if (lang != "default") DebugManager.Log( LogLevel.Warning, $"SE_LANGMANAGER: Lang not found : {lang} (pass default translation)" ); return defaultTranslation; } private static readonly Dictionary Languages = []; } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/MusicManager.cs000066400000000000000000000124761514307377300242030ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Class which manage Music /// public class MusicManager { private readonly Dictionary _musics = []; /// /// Get All Musics /// public List Musics => [.._musics.Values]; /// /// Add music to the manager /// /// Music Name /// Music File [UsedImplicitly] public void AddMusic(string name, string file) { if (!_musics.TryAdd(name, Raylib.LoadMusicStream(file))) DebugManager.Log(LogLevel.Warning, $"SE_MUSICMANAGER: Music already exist : {name}"); } /// /// Play music /// /// Music Name /// Throws if music not found [UsedImplicitly] public void PlayMusic(string name) { if (_musics.TryGetValue(name, out var music)) { Raylib.PlayMusicStream(music); return; } DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Stop music /// /// Music Name /// Throws if music not found [UsedImplicitly] public void StopMusic(string name) { if (_musics.TryGetValue(name, out var music)) { Raylib.StopMusicStream(music); return; } DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Resume music /// /// Music Name /// Throws if music not found [UsedImplicitly] public void ResumeMusic(string name) { if (_musics.TryGetValue(name, out var music)) { Raylib.ResumeMusicStream(music); return; } DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Pause music /// /// Music Name /// Throws if music not found [UsedImplicitly] public void PauseMusic(string name) { if (_musics.TryGetValue(name, out var music)) { Raylib.PauseMusicStream(music); return; } DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Seek music to position /// /// Music Name /// Position in seconds /// Throws if music not found [UsedImplicitly] public void SeekMusic(string name, float position) { if (_musics.TryGetValue(name, out var music)) { Raylib.SeekMusicStream(music, position); return; } DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Get Music Length /// /// Music Name /// Length in seconds /// Throws if music not found [UsedImplicitly] public float GetMusicLength(string name) { if (_musics.TryGetValue(name, out var music)) return Raylib.GetMusicTimeLength(music); DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Get Music Current Time /// /// Music Name /// Current Time in seconds /// Throws if music not found [UsedImplicitly] public float GetMusicCurrentTime(string name) { if (_musics.TryGetValue(name, out var music)) return Raylib.GetMusicTimePlayed(music); DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } /// /// Check if music is playing /// /// Music Name /// If music is playing /// Throws if music not found [UsedImplicitly] public bool IsMusicPlaying(string name) { if (_musics.TryGetValue(name, out var music)) return Raylib.IsMusicStreamPlaying(music); DebugManager.Log(LogLevel.Error, $"SE_MUSICMANAGER: Music not found : {name}"); throw new ArgumentException($"Music not found : {name}"); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/SaveManager.cs000066400000000000000000000026101514307377300240060ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Data.Save; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Static Class which manage Saves /// public static class SaveManager { /// /// List of known Saves /// public static List Saves => [..InternalSaves.Keys]; /// /// Add Save to Manager /// /// Save Name /// Save Object [UsedImplicitly] public static void AddSave(string name, ISave save) { if (!InternalSaves.TryAdd(name, save)) DebugManager.Log(LogLevel.Warning, $"SE_SAVEMANAGER: Save already exist : {name}"); } /// /// Get Save from Manager /// /// Save Name /// Save /// Throws if save not found [UsedImplicitly] public static ISave GetSave(string name) { if (InternalSaves.TryGetValue(name, out var save)) return save; DebugManager.Log(LogLevel.Error, $"SE_SAVEMANAGER: Save not found : {name}"); throw new ArgumentException($"Save not found : {name}"); } private static readonly Dictionary InternalSaves = []; } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/ShaderManager.cs000066400000000000000000000152201514307377300243170ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.IO; using System.Numerics; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Manager; /// /// Class which manages Shaders /// public class ShaderManager { private readonly Dictionary _shaders = []; /// /// Gets all Shaders /// public List Shaders => [.._shaders.Values]; /// /// Checks if a Shader exists /// /// The name of the Shader /// True if the Shader exists, otherwise false [UsedImplicitly] public bool HasShader(string name) => _shaders.ContainsKey(name); /// /// Removes a Shader from the manager /// /// The name of the Shader to remove /// Thrown if the Shader is not found [UsedImplicitly] public void RemoveShader(string name) { if (_shaders.TryGetValue(name, out var shader)) { Raylib.UnloadShader(shader.GetInternalShader()); _shaders.Remove(name); return; } DebugManager.Log(LogLevel.Error, $"SE_SHADERMANAGER: Shader not found : {name}"); throw new ArgumentException($"Shader not found : {name}"); } /// /// Defines a float value for a Shader /// /// The name of the Shader /// The name of the uniform /// The float value [UsedImplicitly] public void SetShaderValue(string name, string uniform, float value) => SetShaderValue(name, uniform, value, ShaderUniformDataType.Float); /// /// Defines a vec2 value for a Shader /// /// The name of the Shader /// The name of the uniform /// The vec2 value [UsedImplicitly] public void SetShaderValue(string name, string uniform, Vec2 value) => SetShaderValue( name, uniform, new Vector2(value.X, value.Y), ShaderUniformDataType.Vec2 ); /// /// Defines a color value for a Shader /// /// The name of the Shader /// The name of the uniform /// The color value [UsedImplicitly] public void SetShaderValue(string name, string uniform, Color value) => SetShaderValue(name, uniform, value.ToVec4(), ShaderUniformDataType.Vec4); /// /// Defines an int value for a Shader /// /// The name of the Shader /// The name of the uniform /// The int value [UsedImplicitly] public void SetShaderValue(string name, string uniform, int value) => SetShaderValue(name, uniform, value, ShaderUniformDataType.Float); /// /// Defines a value for a Shader /// /// The type of the value /// The name of the Shader /// The name of the uniform /// The value /// The type of the uniform /// Thrown if the Shader is not found [UsedImplicitly] public void SetShaderValue( string name, string uniform, T value, ShaderUniformDataType uniformType ) where T : unmanaged { if (_shaders.TryGetValue(name, out var shader)) Raylib.SetShaderValue( shader.GetInternalShader(), Raylib.GetShaderLocation(shader.GetInternalShader(), uniform), value, uniformType ); else throw new ArgumentException($"Shader not found : {name}"); } /// /// Adds a Shader to the manager /// /// The name of the Shader /// The Shader to add [UsedImplicitly] public void AddShader(string name, SEShader shader) { if (!_shaders.TryAdd(name, shader)) DebugManager.Log( LogLevel.Warning, $"SE_SHADERMANAGER: Shader already exists : {name}" ); } /// /// Adds a Shader to the manager /// /// The name of the Shader /// The path to the vertex shader file /// The path to the fragment shader file [UsedImplicitly] public void AddShader(string name, string vertexFile, string fragmentFile) { if (!_shaders.TryAdd(name, new SEShader(File.ReadAllText(vertexFile), File.ReadAllText(fragmentFile)))) DebugManager.Log( LogLevel.Warning, $"SE_SHADERMANAGER: Shader already exists : {name}" ); } /// /// Adds a Shader to the manager /// /// The name of the Shader /// The code of the vertex shader /// The code of the fragment shader [UsedImplicitly] public void AddShaderFromCode(string name, string vertexCode, string fragmentCode) { if (!_shaders.TryAdd(name, new SEShader(vertexCode, fragmentCode))) DebugManager.Log( LogLevel.Warning, $"SE_SHADERMANAGER: Shader already exists : {name}" ); } /// /// Gets a Shader from the manager /// /// The name of the Shader /// The Shader /// Thrown if the Shader is not found public SEShader GetShader(string name) { if (_shaders.TryGetValue(name, out var shader)) return shader; DebugManager.Log(LogLevel.Error, $"SE_SHADERMANAGER: Shader not found : {name}"); throw new ArgumentException($"Shader not found : {name}"); } internal void Unload() { foreach (var shader in _shaders.Values) Raylib.UnloadShader(shader.GetInternalShader()); _shaders.Clear(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/SoundManager.cs000066400000000000000000000070061514307377300242040ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Class which manage Sound /// public class SoundManager { private readonly Dictionary _sounds = []; /// /// Get All Sounds /// public List Sounds => [.._sounds.Values]; /// /// Add sound to the manager /// /// Sound Name /// Sound File [UsedImplicitly] public void AddSound(string name, string file) { if (!_sounds.TryAdd(name, Raylib.LoadSound(file))) DebugManager.Log(LogLevel.Warning, $"SE_SOUNDMANAGER: Sound already exist : {name}"); } /// /// Play Sound /// /// Sound Name /// Throws if sound not found [UsedImplicitly] public void PlaySound(string name) { if (_sounds.TryGetValue(name, out var sound)) { Raylib.PlaySound(sound); return; } DebugManager.Log(LogLevel.Error, $"SE_SOUNDMANAGER: Sound not found : {name}"); throw new ArgumentException($"Sound not found : {name}"); } /// /// Stop Sound /// /// Sound Name /// Throws if sound not found [UsedImplicitly] public void StopSound(string name) { if (_sounds.TryGetValue(name, out var sound)) { Raylib.StopSound(sound); return; } DebugManager.Log(LogLevel.Error, $"SE_SOUNDMANAGER: Sound not found : {name}"); throw new ArgumentException($"Sound not found : {name}"); } /// /// Resume Sound /// /// Sound Name /// Throws if sound not found [UsedImplicitly] public void ResumeSound(string name) { if (_sounds.TryGetValue(name, out var sound)) { Raylib.ResumeSound(sound); return; } DebugManager.Log(LogLevel.Error, $"SE_SOUNDMANAGER: Sound not found : {name}"); throw new ArgumentException($"Sound not found : {name}"); } /// /// Pause Sound /// /// Sound Name /// Throws if sound not found [UsedImplicitly] public void PauseSound(string name) { if (_sounds.TryGetValue(name, out var sound)) { Raylib.PauseSound(sound); return; } DebugManager.Log(LogLevel.Error, $"SE_SOUNDMANAGER: Sound not found : {name}"); throw new ArgumentException($"Sound not found : {name}"); } /// /// Check if Sound is playing /// /// Sound Name /// If Sound is playing /// Throws if Sound not found [UsedImplicitly] public bool IsSoundPlaying(string name) { if (_sounds.TryGetValue(name, out var sound)) return Raylib.IsSoundPlaying(sound); DebugManager.Log(LogLevel.Error, $"SE_SOUNDMANAGER: Sound not found : {name}"); throw new ArgumentException($"Sound not found : {name}"); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/TextureManager.cs000066400000000000000000000061521514307377300245550ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Class which manage textures /// public class TextureManager { private readonly Dictionary _texture2Ds = []; /// /// Get All Textures /// public List Textures => [.._texture2Ds.Values]; /// /// Checks if the texture with the specified name exists in the manager. /// /// The name of the texture. /// True if the texture exists, otherwise false. [UsedImplicitly] public bool HasTexture(string name) => _texture2Ds.ContainsKey(name); /// /// Removes a texture from the manager. /// /// The name of the texture. /// Thrown if the texture is not found. [UsedImplicitly] public void RemoveTexture(string name) { if (_texture2Ds.TryGetValue(name, out var texture)) { Raylib.UnloadTexture(texture); _texture2Ds.Remove(name); return; } DebugManager.Log(LogLevel.Error, $"SE_TEXTUREMANAGER: Texture not found : {name}"); throw new ArgumentException($"Texture not found : {name}"); } /// /// Adds a texture to the manager. /// /// The name of the texture. /// The texture to add. [UsedImplicitly] public void AddTexture(string name, Texture2D texture2D) { if (!_texture2Ds.TryAdd(name, texture2D)) DebugManager.Log( LogLevel.Warning, $"SE_TEXTUREMANAGER: Texture already exists : {name}" ); } /// /// Adds a texture to the manager. /// /// The name of the texture. /// The file path of the texture. [UsedImplicitly] public void AddTexture(string name, string file) { if (!_texture2Ds.TryAdd(name, Raylib.LoadTexture(file))) DebugManager.Log( LogLevel.Warning, $"SE_TEXTUREMANAGER: Texture already exists : {name}" ); } /// /// Gets a texture from the manager. /// /// The name of the texture. /// The texture. /// Thrown if the texture is not found. public Texture2D GetTexture(string name) { if (_texture2Ds.TryGetValue(name, out var texture)) return texture; DebugManager.Log(LogLevel.Error, $"SE_TEXTUREMANAGER: Texture not found : {name}"); throw new ArgumentException($"Texture not found : {name}"); } internal void Unload() { foreach (var texture in _texture2Ds.Values) Raylib.UnloadTexture(texture); _texture2Ds.Clear(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/TimerManager.cs000066400000000000000000000023751514307377300242000ustar00rootroot00000000000000using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Manager; /// /// Class which manage timer /// public class TimerManager { private readonly Dictionary _timers = []; /// /// Get All Timers /// public List Timers => [.._timers.Values]; /// /// Add Timer to manager /// /// Timer Name /// Timer [UsedImplicitly] public void AddTimer(string name, Timer timer) { if (!_timers.TryAdd(name, timer)) DebugManager.Log(LogLevel.Warning, $"SE_TIMERMANAGER: Timer already exist : {name}"); } /// /// Get Timer from Manager /// /// Timer Name /// Timer [UsedImplicitly] public Timer? GetTimer(string name) => _timers.GetValueOrDefault(name); internal void Update(float delta) { for (var i = _timers.Count - 1; i > -1; i--) { if (_timers.ElementAt(i).Value.Update(delta)) _timers.Remove(_timers.ElementAt(i).Key); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Manager/TweenManager.cs000066400000000000000000000015541514307377300242000ustar00rootroot00000000000000using SharpEngine.Core.Utils.Tween; using System.Collections.Generic; using JetBrains.Annotations; namespace SharpEngine.Core.Manager { /// /// Class which manage tweens /// public class TweenManager { /// /// Gets or sets the collection of active tweens managed by this instance. /// /// The list contains all currently tracked tween animations. Modifying this collection /// directly may affect the behavior of the tween manager. [UsedImplicitly] public List Tweens { get; set; } = []; internal void Update(float delta) { for (var i = Tweens.Count - 1; i > -1; i--) { if (Tweens[i].Update(delta)) Tweens.RemoveAt(i); } } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Math/000077500000000000000000000000001514307377300206065ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Math/MathHelper.cs000066400000000000000000000051251514307377300231710ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Math; /// /// Class with some Math functions and values /// public static class MathHelper { /// /// E Value /// [UsedImplicitly] public const float E = 2.71828175F; /// /// Log10E Value /// [UsedImplicitly] public const float Log10E = 0.4342945F; /// /// Log2E Value /// [UsedImplicitly] public const float Log2E = 1.442695F; /// /// Pi Value /// [UsedImplicitly] public const float Pi = 3.14159274F; /// /// Pi/2 Value /// [UsedImplicitly] public const float PiOver2 = 1.57079637F; /// /// Pi/4 Value /// [UsedImplicitly] public const float PiOver4 = 0.7853982F; /// /// Tau Value /// [UsedImplicitly] public const float Tau = 6.28318548F; /// /// 2*Pi Value /// [UsedImplicitly] public const float TwoPi = 6.28318548F; /// /// Convert Radians to Degrees /// /// Radians Value /// Degrees Value [UsedImplicitly] public static float ToDegrees(float radians) => radians * 180 / Pi; /// /// Convert Degrees to Radians /// /// Degrees Value /// Radians Value [UsedImplicitly] public static float ToRadians(float degrees) => degrees * Pi / 180; /// /// Block value between two values (included) /// /// Current Value /// Min Value (included) /// Max Value (included) /// Clamped Value public static float Clamp(float value, float mini = float.MinValue, float maxi = float.MaxValue) { if (value < mini) return mini; return value > maxi ? maxi : value; } /// /// Block value between two values (included) /// /// Current Value /// Min Value (included) /// Max Value (included) /// Clamped Value public static int Clamp(int value, int mini = int.MinValue, int maxi = int.MaxValue) { if (value < mini) return mini; return value > maxi ? maxi : value; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Math/Rand.cs000066400000000000000000000035061514307377300220250ustar00rootroot00000000000000using System; using JetBrains.Annotations; namespace SharpEngine.Core.Math; /// /// Class for random numbers /// public static class Rand { private static readonly Random Random = new(); /// /// Get random integer between minimum and maximum values /// /// Minimum Value (included) /// Maximum Value (excluded) /// Random Number public static int GetRand(int min, int max) => Random.Next(min, max); /// /// Get random integer between 0 and maximum values /// /// Maximum Value (excluded) /// Random Number [UsedImplicitly] public static int GetRand(int max) => Random.Next(max); /// /// Get random non negative integer /// /// Random Number [UsedImplicitly] public static int GetRand() => Random.Next(); /// /// Get random float between minimum and maximum values /// /// Minimum Value (included) /// Maximum Value (excluded) /// Random Number public static float GetRandF(float min, float max) => Random.NextSingle() * (max - min) + min; /// /// Get random float between 0 and maximum values /// /// Maximum Value (excluded) /// Random Number [UsedImplicitly] public static float GetRandF(float max) => Random.NextSingle() * max; /// /// Get a random float between 0 and 1 /// /// Random Number [UsedImplicitly] public static float GetRandF() => Random.NextSingle(); } SharpEngine.Core-2.5.1/SharpEngine.Core/Math/Rect.cs000066400000000000000000000074051514307377300220400ustar00rootroot00000000000000using System; using JetBrains.Annotations; using Raylib_cs; namespace SharpEngine.Core.Math; /// /// Class which represents Rectangle /// /// X Position /// Y Position /// Width Size /// Height Size public class Rect(float x, float y, float width, float height) { /// /// X Position /// [UsedImplicitly] public float X { get; set; } = x; /// /// Y Position /// [UsedImplicitly] public float Y { get; set; } = y; /// /// Width Size /// [UsedImplicitly] public float Width { get; set; } = width; /// /// Height Size /// [UsedImplicitly] public float Height { get; set; } = height; /// /// Rectangle /// /// Position /// Size public Rect(Vec2 position, Vec2 size) : this(position.X, position.Y, size.X, size.Y) { } /// /// Rectangle /// /// X Position /// Y Position /// Size public Rect(float x, float y, Vec2 size) : this(x, y, size.X, size.Y) { } /// /// Rectangle /// /// Position /// Width Size /// Height Size public Rect(Vec2 position, float width, float height) : this(position.X, position.Y, width, height) { } /// /// Return if the position is in Rect /// /// Position /// if Position is in Rect public bool Contains(Vec2 position) => X <= position.X && position.X <= X + Width && Y <= position.Y && position.Y <= Y + Height; /// /// Return if another Rect is in Rect /// /// Rect /// If intersect public bool Intersect(Rect other) => X <= other.X + other.Width && X + Width >= other.X && Y <= other.Y + other.Height && Y + Height >= other.Y; /// public override bool Equals(object? obj) { if (obj is Rect rect) return this == rect; return obj != null && obj.Equals(this); } /// // ReSharper disable NonReadonlyMemberInGetHashCode public override int GetHashCode() => HashCode.Combine(X, Y, Width, Height); /// public override string ToString() => $"Rect(X={X}, Y={Y}, Width={Width}, Height={Height})"; /// /// Operator inequality /// /// First Rect /// Second Rect /// If first is not equals to second public static bool operator !=(Rect r1, Rect r2) => !(r1 == r2); /// /// Operator equality /// /// First Rect /// Second Rect /// If first is equals to second public static bool operator ==(Rect r1, Rect r2) => System.Math.Abs(r1.X - r2.X) < 0.001f && System.Math.Abs(r1.Y - r2.Y) < 0.001f && System.Math.Abs(r1.Width - r2.Width) < 0.001f && System.Math.Abs(r1.Height - r2.Height) < 0.001f; /// /// Convert Rect to Rectangle /// /// Rect /// Rect public static implicit operator Rectangle(Rect rect) => new(rect.X, rect.Y, rect.Width, rect.Height); } SharpEngine.Core-2.5.1/SharpEngine.Core/Math/Vec2.cs000066400000000000000000000146241514307377300217430ustar00rootroot00000000000000using System; using System.Numerics; using JetBrains.Annotations; namespace SharpEngine.Core.Math; /// /// Class which represents Vector 2D /// public class Vec2 { /// /// Vector 2D with 0 on X and Y /// public static Vec2 Zero => new(0); /// /// Vector 2D with 1 on X and Y /// public static Vec2 One => new(1); /// /// X Position /// [UsedImplicitly] public float X { get; set; } /// /// Y Position /// [UsedImplicitly] public float Y { get; set; } /// /// Vector 2D /// /// Value which be X and Y Positions public Vec2(float xy) { X = xy; Y = xy; } /// /// Vector 2D /// /// X Position /// Y Position public Vec2(float x, float y) { X = x; Y = y; } /// /// If Vector 2D is Zero /// /// If is Zero public bool IsZero() => X == 0 && Y == 0; /// /// Length of Vector 2D /// /// Length public float Length() => MathF.Sqrt(X * X + Y * Y); /// /// Squared Length of Vector 2D /// /// Squared Length [UsedImplicitly] public float LengthSquared() => X * X + Y * Y; /// /// Normalized Vector 2D /// /// Normalized Vector public Vec2 Normalized() { var length = MathF.Sqrt(X * X + Y * Y); return length == 0 ? Zero : new Vec2(X / length, Y / length); } /// /// Get Distance to go to Vector 2D /// /// Target /// Distance [UsedImplicitly] public float DistanceTo(Vec2 vec2) { var x = vec2.X - X; var y = vec2.Y - Y; return MathF.Sqrt(x * x + y * y); } /// public override bool Equals(object? obj) { if (obj is Vec2 vec) return this == vec; return obj != null && obj.Equals(this); } /// // ReSharper disable NonReadonlyMemberInGetHashCode public override int GetHashCode() => HashCode.Combine(X, Y); /// public override string ToString() => $"Vec2(X={X}, Y={Y})"; /// /// Operator inequality /// /// First Vector 2D /// Second Vector 2D /// If first is not equals to second public static bool operator !=(Vec2 vec1, Vec2 vec2) => !(vec1 == vec2); /// /// Operator equality /// /// First Vector 2D /// Second Vector 2D /// If first is equals to second public static bool operator ==(Vec2 vec1, Vec2 vec2) => System.Math.Abs(vec1.X - vec2.X) < 0.001f && System.Math.Abs(vec1.Y - vec2.Y) < 0.001f; /// /// Operator Negation /// /// Vector 2D /// Negative Vector 2D public static Vec2 operator -(Vec2 vec) => new(-vec.X, -vec.Y); /// /// Operator Subtraction /// /// First Vector 2D /// Second Vector 2D /// Vector 2D with first values subtracted by second values public static Vec2 operator -(Vec2 vec, Vec2 vec2) => new(vec.X - vec2.X, vec.Y - vec2.Y); /// /// Operator Subtraction /// /// Vector 2D /// /// Vector 2D with values subtracted by factor public static Vec2 operator -(Vec2 vec, float factor) => new(vec.X - factor, vec.Y - factor); /// /// Operator Addition /// /// First Vector 2D /// Second Vector 2D /// Vector 2D with first values added with second values public static Vec2 operator +(Vec2 vec, Vec2 vec2) => new(vec.X + vec2.X, vec.Y + vec2.Y); /// /// Operator Addition /// /// Vector 2D /// /// Vector 2D with values added with factor public static Vec2 operator +(Vec2 vec, float factor) => new(vec.X + factor, vec.Y + factor); /// /// Operator Multiplication /// /// First Vector 2D /// Second Vector 2D /// Vector 2D with first values multiplied by second values public static Vec2 operator *(Vec2 vec, Vec2 vec2) => new(vec.X * vec2.X, vec.Y * vec2.Y); /// /// Operator Multiplication /// /// Vector 2D /// /// Vector 2D with values multiplied by factor public static Vec2 operator *(Vec2 vec, float factor) => new(vec.X * factor, vec.Y * factor); /// /// Operator Division /// /// First Vector 2D /// Second Vector 2D /// Vector 2D with first values divided by second values public static Vec2 operator /(Vec2 vec, Vec2 vec2) => new(vec.X / vec2.X, vec.Y / vec2.Y); /// /// Operator Division /// /// Vector 2D /// /// Vector 2D with values divided by factor public static Vec2 operator /(Vec2 vec, float factor) => new(vec.X / factor, vec.Y / factor); /// /// Convert Vector2 to Vec2 /// /// Vector2 /// Vec2 public static implicit operator Vec2(Vector2 vec) => new(vec.X, vec.Y); /// /// Convert Vec2 to Vector2 /// /// Vec2 /// Vector2 public static implicit operator Vector2(Vec2 vec) => new(vec.X, vec.Y); } SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/000077500000000000000000000000001514307377300214605ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/Particle.cs000066400000000000000000000110421514307377300235500ustar00rootroot00000000000000using System; using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Particle; /// /// CLass which represents Particle /// /// Particle Parameters public class Particle(ParticleParameters parameters) { /// /// Position of Particle /// [UsedImplicitly] public Vec2 Position { get; set; } = parameters.Position; /// /// Velocity of Particle /// [UsedImplicitly] public Vec2 Velocity { get; set; } = parameters.Velocity; /// /// Acceleration of Particle /// [UsedImplicitly] public Vec2 Acceleration { get; set; } = parameters.Acceleration; /// /// Lifetime of Particle /// [UsedImplicitly] public float Lifetime { get; set; } = parameters.Lifetime; /// /// Time Since Start of Particle /// [UsedImplicitly] public float TimeSinceStart { get; set; } /// /// Size of Particle /// [UsedImplicitly] public float Size { get; set; } = parameters.SizeFunction == ParticleParametersFunction.Increase ? 0 : parameters.Size; /// /// Max Size of Particle /// [UsedImplicitly] public float MaxSize { get; set; } = parameters.Size; /// /// Rotation of Particle /// [UsedImplicitly] public float Rotation { get; set; } = parameters.Rotation; /// /// Rotation Speed of Particle /// [UsedImplicitly] public float RotationSpeed { get; set; } = parameters.RotationSpeed; /// /// Begin Color of Particle /// [UsedImplicitly] public Color BeginColor { get; set; } = parameters.BeginColor; /// /// Current Color of Particle /// [UsedImplicitly] public Color CurrentColor { get; set; } = parameters.BeginColor; /// /// End Color of Particle /// [UsedImplicitly] public Color EndColor { get; set; } = parameters.EndColor; /// /// Size Function of Particle /// [UsedImplicitly] public ParticleParametersFunction SizeFunction { get; set; } = parameters.SizeFunction; /// /// Size Function Value of Particle /// [UsedImplicitly] public float SizeFunctionValue { get; set; } = parameters.SizeFunctionValue; /// /// ZLayer of Particle /// [UsedImplicitly] public int ZLayer { get; set; } = parameters.ZLayer; /// /// Update Particle /// /// Frame Time /// throws if SizeFunction is unknown public void Update(float delta) { Velocity = new Vec2( Velocity.X + Acceleration.X * delta, Velocity.Y + Acceleration.Y * delta ); Position = new Vec2(Position.X + Velocity.X * delta, Position.Y + Velocity.Y * delta); Rotation += RotationSpeed * delta; switch (SizeFunction) { case ParticleParametersFunction.Increase when SizeFunctionValue == 0: Size = MaxSize * TimeSinceStart / Lifetime; break; case ParticleParametersFunction.Increase: Size += SizeFunctionValue; break; case ParticleParametersFunction.Decrease when SizeFunctionValue == 0: Size = MaxSize * (Lifetime - TimeSinceStart) / Lifetime; break; case ParticleParametersFunction.Decrease: Size -= SizeFunctionValue; break; case ParticleParametersFunction.Normal: break; default: throw new ArgumentException("Unknown Size Function"); } if (EndColor != BeginColor) CurrentColor = BeginColor.TranslateTo(EndColor, TimeSinceStart, Lifetime); TimeSinceStart += delta; } /// /// Draw Particle /// public void Draw() { if (Size == 0) return; SERender.DrawRectangle( new Rect(Position.X, Position.Y, Size, Size), new Vec2(Size / 2, Size / 2), Rotation, CurrentColor, InstructionSource.Entity, ZLayer ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/ParticleEmitter.cs000066400000000000000000000212051514307377300251040ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Particle; /// /// Class which represents Particle Emitter /// /// Particle Emitter Parameters [UsedImplicitly] public class ParticleEmitter(ParticleEmitterParameters parameters) { /// /// new() of Particle Emitter /// [UsedImplicitly] public List Particles { get; } = []; /// /// BeginColors of Particle Emitter /// [UsedImplicitly] public Color[] BeginColors { get; set; } = parameters.BeginColors; /// /// EndColors of Particle Emitter /// [UsedImplicitly] public Color[]? EndColors { get; set; } = parameters.EndColors; /// /// Offset of Particle Emitter /// [UsedImplicitly] public Vec2 Offset { get; set; } = parameters.Offset; /// /// MinVelocity of Particle Emitter /// [UsedImplicitly] public float MinVelocity { get; set; } = parameters.MinVelocity; /// /// MaxVelocity of Particle Emitter /// [UsedImplicitly] public float MaxVelocity { get; set; } = parameters.MaxVelocity; /// /// MinAcceleration of Particle Emitter /// [UsedImplicitly] public float MinAcceleration { get; set; } = parameters.MinAcceleration; /// /// MaxAcceleration of Particle Emitter /// [UsedImplicitly] public float MaxAcceleration { get; set; } = parameters.MaxAcceleration; /// /// MinRotationSpeed of Particle Emitter /// [UsedImplicitly] public float MinRotationSpeed { get; set; } = parameters.MinRotationSpeed; /// /// MaxRotationSpeed of Particle Emitter /// [UsedImplicitly] public float MaxRotationSpeed { get; set; } = parameters.MaxRotationSpeed; /// /// MinRotation of Particle Emitter /// [UsedImplicitly] public float MinRotation { get; set; } = parameters.MinRotation; /// /// MaxRotation of Particle Emitter /// [UsedImplicitly] public float MaxRotation { get; set; } = parameters.MaxRotation; /// /// MinLifetime of Particle Emitter /// [UsedImplicitly] public float MinLifetime { get; set; } = parameters.MinLifetime; /// /// MaxLifetime of Particle Emitter /// [UsedImplicitly] public float MaxLifetime { get; set; } = parameters.MaxLifetime; /// /// MinDirection of Particle Emitter /// [UsedImplicitly] public float MinDirection { get; set; } = parameters.MinDirection; /// /// MaxDirection of Particle Emitter /// [UsedImplicitly] public float MaxDirection { get; set; } = parameters.MaxDirection; /// /// MinTimerBeforeSpawn of Particle Emitter /// [UsedImplicitly] public float MinTimerBeforeSpawn { get; set; } = parameters.MinTimerBeforeSpawn; /// /// MaxTimerBeforeSpawn of Particle Emitter /// [UsedImplicitly] public float MaxTimerBeforeSpawn { get; set; } = parameters.MaxTimerBeforeSpawn; /// /// MinNbParticlesPerSpawn of Particle Emitter /// [UsedImplicitly] public int MinNbParticlesPerSpawn { get; set; } = parameters.MinNbParticlesPerSpawn; /// /// MaxNbParticlesPerSpawn of Particle Emitter /// [UsedImplicitly] public int MaxNbParticlesPerSpawn { get; set; } = parameters.MaxNbParticlesPerSpawn; /// /// MinSize of Particle Emitter /// [UsedImplicitly] public float MinSize { get; set; } = parameters.MinSize; /// /// MaxSize of Particle Emitter /// [UsedImplicitly] public float MaxSize { get; set; } = parameters.MaxSize; /// /// SizeFunction of Particle Emitter /// [UsedImplicitly] public ParticleParametersFunction SizeFunction { get; set; } = parameters.SizeFunction; /// /// SizeFunctionValue of Particle Emitter /// [UsedImplicitly] public float SizeFunctionValue { get; set; } = parameters.SizeFunctionValue; /// /// SpawnSize of Particle Emitter /// [UsedImplicitly] public Vec2 SpawnSize { get; set; } = parameters.SpawnSize; /// /// MaxParticles of Particle Emitter /// [UsedImplicitly] public int MaxParticles { get; set; } = parameters.MaxParticles; /// /// Active of Particle Emitter /// [UsedImplicitly] public bool Active { get; set; } = parameters.Active; /// /// ZLayer of Particle Emitter /// [UsedImplicitly] public int ZLayer { get; set; } = parameters.ZLayer; private float _timerBeforeSpawn; /// /// Number of Particles /// [UsedImplicitly] public int ParticlesCount => Particles.Count; /// /// Spawn Particle /// /// Particle Position [UsedImplicitly] public void SpawnParticle(Vec2 objectPosition) { Vec2 position; if (SpawnSize == Vec2.Zero) position = new Vec2(Offset.X + objectPosition.X, Offset.Y + objectPosition.Y); else position = new Vec2( Rand.GetRandF(-SpawnSize.X / 2, SpawnSize.X / 2) + Offset.X + objectPosition.X, Rand.GetRandF(-SpawnSize.Y / 2, SpawnSize.Y / 2) + Offset.Y + objectPosition.Y ); var angle = Rand.GetRandF(MinDirection, MaxDirection); var velocity = new Vec2(MathF.Cos(MathHelper.ToRadians(angle)), MathF.Sin(MathHelper.ToRadians(angle))) * Rand.GetRandF(MinVelocity, MaxVelocity); var acceleration = new Vec2(MathF.Cos(MathHelper.ToRadians(angle)), MathF.Sin(MathHelper.ToRadians(angle))) * Rand.GetRandF(MinAcceleration, MaxAcceleration); var rotation = Rand.GetRandF(MinRotation, MaxRotation); var rotationSpeed = Rand.GetRandF(MinRotationSpeed, MaxRotationSpeed); var lifetime = Rand.GetRandF(MinLifetime, MaxLifetime); var size = Rand.GetRandF(MinSize, MaxSize); var beginColor = BeginColors[Rand.GetRand(0, BeginColors.Length - 1)]; var endColor = beginColor; if (EndColors != null) endColor = EndColors[Rand.GetRand(0, EndColors.Length - 1)]; var particle = new Particle( new ParticleParameters { Position = position, Velocity = velocity, Acceleration = acceleration, Lifetime = lifetime, Size = size, Rotation = rotation, RotationSpeed = rotationSpeed, BeginColor = beginColor, EndColor = endColor, SizeFunction = SizeFunction, SizeFunctionValue = SizeFunctionValue, ZLayer = ZLayer } ); Particles.Add(particle); } /// /// Update Emitter /// /// Frame Time /// Emitter Position public void Update(float delta, Vec2 objectPosition) { List mustBeDeleted = []; foreach (var particle in Particles) { particle.Update(delta); if (particle.TimeSinceStart >= particle.Lifetime) mustBeDeleted.Add(particle); } foreach (var particle in mustBeDeleted) Particles.Remove(particle); mustBeDeleted.Clear(); if (!Active) return; if (_timerBeforeSpawn <= 0) { if (MaxParticles == -1 || MaxParticles > Particles.Count) { var nbParticles = Rand.GetRand(MinNbParticlesPerSpawn, MaxNbParticlesPerSpawn); for (var i = 0; i < nbParticles; i++) SpawnParticle(objectPosition); } _timerBeforeSpawn = Rand.GetRandF(MinTimerBeforeSpawn, MaxTimerBeforeSpawn); } _timerBeforeSpawn -= delta; } /// /// Draw Particles of Emitter /// public void Draw() { foreach (var particle in Particles) particle.Draw(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/ParticleEmitterParameters.cs000066400000000000000000000106571514307377300271410ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Particle; /// /// Struct which represents parameters to create Particle Emitter /// public struct ParticleEmitterParameters { /// /// Create Particle Emitter Parameters /// public ParticleEmitterParameters() { } /// /// BeginColors of Particle Emitter /// [UsedImplicitly] public Color[] BeginColors { get; set; } = []; /// /// EndColors of Particle Emitter /// [UsedImplicitly] public Color[]? EndColors { get; set; } = null; /// /// Offset of Particle Emitter /// [UsedImplicitly] public Vec2 Offset { get; set; } = Vec2.Zero; /// /// MinVelocity of Particle Emitter /// [UsedImplicitly] public float MinVelocity { get; set; } = 20; /// /// MaxVelocity of Particle Emitter /// [UsedImplicitly] public float MaxVelocity { get; set; } = 20; /// /// MinAcceleration of Particle Emitter /// [UsedImplicitly] public float MinAcceleration { get; set; } = 0; /// /// MaxAcceleration of Particle Emitter /// [UsedImplicitly] public float MaxAcceleration { get; set; } = 0; /// /// MinRotationSpeed of Particle Emitter /// [UsedImplicitly] public float MinRotationSpeed { get; set; } = 0; /// /// MaxRotationSpeed of Particle Emitter /// [UsedImplicitly] public float MaxRotationSpeed { get; set; } = 0; /// /// MinRotation of Particle Emitter /// [UsedImplicitly] public float MinRotation { get; set; } = 0; /// /// MaxRotation of Particle Emitter /// [UsedImplicitly] public float MaxRotation { get; set; } = 0; /// /// MinLifetime of Particle Emitter /// [UsedImplicitly] public float MinLifetime { get; set; } = 2; /// /// MaxLifetime of Particle Emitter /// [UsedImplicitly] public float MaxLifetime { get; set; } = 2; /// /// MinDirection of Particle Emitter /// [UsedImplicitly] public float MinDirection { get; set; } = 0; /// /// MaxDirection of Particle Emitter /// [UsedImplicitly] public float MaxDirection { get; set; } = 0; /// /// MinTimerBeforeSpawn of Particle Emitter /// [UsedImplicitly] public float MinTimerBeforeSpawn { get; set; } = 0.3f; /// /// MaxTimerBeforeSpawn of Particle Emitter /// [UsedImplicitly] public float MaxTimerBeforeSpawn { get; set; } = 0.3f; /// /// MinNbParticlesPerSpawn of Particle Emitter /// [UsedImplicitly] public int MinNbParticlesPerSpawn { get; set; } = 4; /// /// MaxNbParticlesPerSpawn of Particle Emitter /// [UsedImplicitly] public int MaxNbParticlesPerSpawn { get; set; } = 4; /// /// MinSize of Particle Emitter /// [UsedImplicitly] public float MinSize { get; set; } = 5; /// /// MaxSize of Particle Emitter /// [UsedImplicitly] public float MaxSize { get; set; } = 5; /// /// SizeFunction of Particle Emitter /// [UsedImplicitly] public ParticleParametersFunction SizeFunction { get; set; } = ParticleParametersFunction.Normal; /// /// SizeFunctionValue of Particle Emitter /// [UsedImplicitly] public float SizeFunctionValue { get; set; } = 0; /// /// SpawnSize of Particle Emitter /// [UsedImplicitly] public Vec2 SpawnSize { get; set; } = Vec2.Zero; /// /// MaxParticles of Particle Emitter /// [UsedImplicitly] public int MaxParticles { get; set; } = -1; /// /// Active of Particle Emitter /// [UsedImplicitly] public bool Active { get; set; } = false; /// /// ZLayer of Particle Emitter /// [UsedImplicitly] public int ZLayer { get; set; } = 0; } SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/ParticleParameters.cs000066400000000000000000000034671514307377300256100ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Particle; /// /// Struct which represents parameters to create Particle /// public struct ParticleParameters { /// /// Position of Particle /// [UsedImplicitly] public Vec2 Position { get; set; } /// /// Velocity of Particle /// [UsedImplicitly] public Vec2 Velocity { get; set; } /// /// Acceleration of Particle /// [UsedImplicitly] public Vec2 Acceleration { get; set; } /// /// Lifetime of Particle /// [UsedImplicitly] public float Lifetime { get; set; } /// /// Size of Particle /// [UsedImplicitly] public float Size { get; set; } /// /// Rotation of Particle /// [UsedImplicitly] public float Rotation { get; set; } /// /// Rotation Speed of Particle /// [UsedImplicitly] public float RotationSpeed { get; set; } /// /// Begin Color of Particle /// [UsedImplicitly] public Color BeginColor { get; set; } /// /// End Color of Particle /// [UsedImplicitly] public Color EndColor { get; set; } /// /// Size Function of Particle /// [UsedImplicitly] public ParticleParametersFunction SizeFunction { get; set; } /// /// Size Function Value of Particle /// [UsedImplicitly] public float SizeFunctionValue { get; set; } /// /// ZLayer of Particle /// [UsedImplicitly] public int ZLayer { get; set; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Particle/ParticleParametersFunction.cs000066400000000000000000000006101514307377300273010ustar00rootroot00000000000000namespace SharpEngine.Core.Particle; /// /// Enum, which represents functions for particles /// public enum ParticleParametersFunction { /// /// Decrease function /// Decrease, /// /// Increase function /// Increase, /// /// Normal function /// Normal } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/000077500000000000000000000000001514307377300214635ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instruction.cs000066400000000000000000000011751514307377300243370ustar00rootroot00000000000000using System.Collections.Generic; namespace SharpEngine.Core.Renderer; /// /// Struct which represents renderer instruction /// internal abstract record Instruction { /// /// if Instruction is for entities or ui /// public InstructionSource Source; /// /// Z Layer of Instruction /// public float ZLayer; /// /// Parameters of Instruction /// public required List Parameters; /// /// Executes the instruction. /// internal virtual void Execute() { } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/InstructionSource.cs000066400000000000000000000005051514307377300255140ustar00rootroot00000000000000namespace SharpEngine.Core.Renderer; /// /// Enum, which represents from what instruction comes /// public enum InstructionSource { /// /// Instruction created by Entity /// Entity, /// /// Instruction created by UI /// Ui } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/000077500000000000000000000000001514307377300241675ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawCircleLines.cs000066400000000000000000000007621514307377300275350ustar00rootroot00000000000000using Raylib_cs; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws circle lines. /// internal record DrawCircleLines : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawCircleLines( Convert.ToInt32(Parameters[0]), Convert.ToInt32(Parameters[1]), Convert.ToSingle(Parameters[2]), (Utils.Color)Parameters[3] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawRectangle.cs000066400000000000000000000010661514307377300272430ustar00rootroot00000000000000using Raylib_cs; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws a rectangle. /// internal record DrawRectangle : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawRectangle( Convert.ToInt32(Parameters[0]), // X Convert.ToInt32(Parameters[1]), // Y Convert.ToInt32(Parameters[2]), // Width Convert.ToInt32(Parameters[3]), // Height (Utils.Color)Parameters[4] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawRectangleLinesEx.cs000066400000000000000000000007551514307377300305370ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core.Math; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws rectangle lines extended. /// internal record DrawRectangleLinesEx : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawRectangleLinesEx( (Rect)Parameters[0], Convert.ToInt32(Parameters[1]), (Utils.Color)Parameters[2] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawRectanglePro.cs000066400000000000000000000010171514307377300277200ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core.Math; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws a rectangle with pro-parameters. /// internal record DrawRectanglePro : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawRectanglePro( (Rect)Parameters[0], (Vec2)Parameters[1], Convert.ToSingle(Parameters[2]), (Utils.Color)Parameters[3] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawTextEx.cs000066400000000000000000000011331514307377300265530ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core.Math; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws text with extended parameters. /// internal record DrawTextEx : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawTextEx( (Font)Parameters[0], Convert.ToString(Parameters[1]), (Vec2)Parameters[2], Convert.ToInt32(Parameters[3]), Convert.ToInt32(Parameters[4]), (Utils.Color)Parameters[5] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawTextPro.cs000066400000000000000000000012501514307377300267370ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core.Math; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws text with pro-parameters. /// internal record DrawTextPro : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawTextPro( (Font)Parameters[0], Convert.ToString(Parameters[1]), (Vec2)Parameters[2], (Vec2)Parameters[3], Convert.ToSingle(Parameters[4]), Convert.ToInt32(Parameters[5]), Convert.ToInt32(Parameters[6]), (Utils.Color)Parameters[7] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/DrawTexturePro.cs000066400000000000000000000011221514307377300274510ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core.Math; using System; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws a texture with pro-parameters. /// internal record DrawTexturePro : Instruction { internal override void Execute() { base.Execute(); Raylib.DrawTexturePro( (Texture2D)Parameters[0], (Rect)Parameters[1], (Rect)Parameters[2], (Vec2)Parameters[3], Convert.ToSingle(Parameters[4]), (Utils.Color)Parameters[5] ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/ScissorMode.cs000066400000000000000000000012741514307377300267540ustar00rootroot00000000000000using System; using System.Linq; using Raylib_cs; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws in scissored mode. /// internal record ScissorMode : Instruction { internal override void Execute() { base.Execute(); Raylib.BeginScissorMode( Convert.ToInt32(Parameters[0]), Convert.ToInt32(Parameters[1]), Convert.ToInt32(Parameters[2]), Convert.ToInt32(Parameters[3]) ); SERender.DrawInstructions( Parameters.GetRange(4, Parameters.Count - 4).Select(x => (Instruction)x).ToList() ); Raylib.EndScissorMode(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/Instructions/ShaderMode.cs000066400000000000000000000010261514307377300265300ustar00rootroot00000000000000using System.Linq; using Raylib_cs; namespace SharpEngine.Core.Renderer.Instructions; /// /// Draws in shader mode. /// internal record ShaderMode : Instruction { /// internal override void Execute() { base.Execute(); Raylib.BeginShaderMode((Shader)Parameters[0]); SERender.DrawInstructions( Parameters.GetRange(1, Parameters.Count - 1).Select(x => (Instruction)x).ToList() ); Raylib.EndShaderMode(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Renderer/SERender.cs000066400000000000000000000253741514307377300234740ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer.Instructions; namespace SharpEngine.Core.Renderer; /// /// Static class which used to render textures, texts or rectangles /// // ReSharper disable once InconsistentNaming public static class SERender { /// /// Number of Last Instructions /// public static int LastInstructionsNumber { get; set; } /// /// Number of Last Entity Instructions /// public static int LastEntityInstructionsNumber { get; set; } /// /// Number of Last UI Instructions /// public static int LastUiInstructionsNumber { get; set; } /// /// Current Instructions to be rendered /// private static List _instructions = []; internal static void DrawInstructions(List instructions) { foreach (var instruction in instructions) { LastInstructionsNumber++; if (instruction.Source == InstructionSource.Entity) LastEntityInstructionsNumber++; else LastUiInstructionsNumber++; instruction.Execute(); } } /// /// Draw all instructions in the Window /// /// Window public static void Draw(Window window) { LastInstructionsNumber = 0; LastEntityInstructionsNumber = 0; LastUiInstructionsNumber = 0; List entityInstructions = []; List uiInstructions = []; foreach (var instruction in _instructions) { switch (instruction.Source) { case InstructionSource.Entity: entityInstructions.Add(instruction); break; case InstructionSource.Ui: uiInstructions.Add(instruction); break; default: throw new ArgumentException("Unknown instruction source"); } } entityInstructions.Sort((i1, i2) => i1.ZLayer.CompareTo(i2.ZLayer)); uiInstructions.Sort((i1, i2) => i1.ZLayer.CompareTo(i2.ZLayer)); Raylib.BeginMode2D(window.CameraManager.Camera2D); DrawInstructions(entityInstructions); Raylib.EndMode2D(); DrawInstructions(uiInstructions); _instructions.Clear(); } /// /// Add Shader Mode Instructions /// /// Shader /// Instruction Source /// Z Layer /// Function that renders in shader mode public static void ShaderMode( Shader shader, InstructionSource source, float zLayer, Action shaderAction ) { var instructions = new List(_instructions); _instructions.Clear(); shaderAction(); var instruction = new ShaderMode { Source = source, ZLayer = zLayer, Parameters = [shader] }; instruction.Parameters.AddRange(_instructions.Select(x => (object)x)); _instructions = instructions; _instructions.Add(instruction); } /// /// Add Scissor Mode Instructions /// /// Position X /// Position Y /// Width /// Height /// Instruction Source /// Z Layer /// Function that renders in scissored mode public static void ScissorMode( float posX, float posY, float width, float height, InstructionSource source, float zLayer, Action scissorAction ) { var instructions = new List(_instructions); _instructions.Clear(); scissorAction(); var instruction = new ScissorMode { Source = source, ZLayer = zLayer, Parameters = [posX, posY, width, height] }; instruction.Parameters.AddRange(_instructions.Select(x => (object)x)); _instructions = instructions; _instructions.Add(instruction); } /// /// Add Draw Rectangle Pro Instruction /// /// Rectangle /// Origin /// Rotation /// Color /// Instruction Source /// Z Layer public static void DrawRectangle( Rect rectangle, Vec2 origin, float rotation, Utils.Color color, InstructionSource source, float zLayer ) { _instructions.Add( new DrawRectanglePro { Source = source, ZLayer = zLayer, Parameters = [rectangle, origin, rotation, color] } ); } /// /// Add Draw Rectangle Instruction /// /// Position X /// Position Y /// Width /// Height /// Color /// Instruction Source /// Z Layer public static void DrawRectangle( float posX, float posY, float width, float height, Utils.Color color, InstructionSource source, float zLayer ) { _instructions.Add( new DrawRectangle { Source = source, ZLayer = zLayer, Parameters = [posX, posY, width, height, color] } ); } /// /// Add Draw Rectangle Lines Ex Instruction /// /// Rectangle /// Border Size /// Border Color /// Instruction Source /// Z Layer public static void DrawRectangleLines( Rect rect, float borderSize, Utils.Color borderColor, InstructionSource source, float zLayer ) { _instructions.Add( new DrawRectangleLinesEx { Source = source, ZLayer = zLayer, Parameters = [rect, borderSize, borderColor] } ); } /// /// Add Draw Circle Lines Instruction /// /// Position X /// Position Y /// Radius /// Border Color /// Instruction Source /// Z Layer [UsedImplicitly] public static void DrawCircleLines( float posX, float posY, float radius, Utils.Color borderColor, InstructionSource source, float zLayer ) { _instructions.Add( new DrawCircleLines { Source = source, ZLayer = zLayer, Parameters = [posX, posY, radius, borderColor] } ); } /// /// Add Draw Texture Pro Instruction /// /// Texture /// Rectangle Source /// Rectangle Destination /// Origin /// Rotation /// Color Tint /// Instruction Source /// Z Layer public static void DrawTexture( Texture2D texture, Rect src, Rect dest, Vec2 origin, float rotation, Utils.Color tint, InstructionSource source, float zLayer ) { _instructions.Add( new DrawTexturePro { Source = source, ZLayer = zLayer, Parameters = [texture, src, dest, origin, rotation, tint] } ); } /// /// Add Draw Text Pro Instruction /// /// Font /// Text /// Position /// Origin /// Rotation /// Font Size /// Spacing /// Color /// Instruction Source /// Z Layer public static void DrawText( Font font, string text, Vec2 position, Vec2 origin, float rotation, float fontSize, float spacing, Utils.Color color, InstructionSource source, float zLayer ) { _instructions.Add( new DrawTextPro { Source = source, ZLayer = zLayer, Parameters = [ font, text, position, origin, rotation, fontSize, spacing, color ] } ); } /// /// Add Draw Text Ex Instruction /// /// Font /// Text /// Position /// Font Size /// Spacing /// Color /// Instruction Source /// Z Layer public static void DrawText( Font font, string text, Vec2 position, float fontSize, float spacing, Utils.Color color, InstructionSource source, float zLayer ) { _instructions.Add( new DrawTextEx { Source = source, ZLayer = zLayer, Parameters = [font, text, position, fontSize, spacing, color] } ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Scene.cs000066400000000000000000000163401514307377300213050ustar00rootroot00000000000000using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using SharpEngine.Core.Utils; namespace SharpEngine.Core; /// /// Class which represents a Scene /// public class Scene { /// /// Define if Scene is paused /// [UsedImplicitly] public bool Paused { get; set; } /// /// Window that has this scene /// public Window? Window { get; set; } /// /// All Widgets of Scene /// public List Widgets { get; } = []; /// /// All Entities of Scene /// public List Entities { get; } = []; private readonly List _addEntities = []; private readonly List _addWidgets = []; private readonly List _removeEntities = []; private readonly List _removeWidgets = []; private readonly List _sceneSystems = []; /// /// Create Scene /// public Scene() { } /// /// Add Scene System /// /// Scene System [UsedImplicitly] public void AddSceneSystem(ISceneSystem system) => _sceneSystems.Add(system); /// /// Get Scene System /// /// Type of System /// System or null [UsedImplicitly] public T? GetSceneSystem() where T : ISceneSystem => _sceneSystems.OfType().FirstOrDefault(); /// /// Add Widget to Scene /// /// Widget which be added /// If adding must be delayed /// Type of Widget /// Widget [UsedImplicitly] public T AddWidget(T widget, bool delay = false) where T : Widget.Widget { if (delay) _addWidgets.Add(widget); else { widget.Scene = this; Widgets.Add(widget); } return widget; } /// /// Get All Widgets of one Type /// /// Type of Widgets /// Widgets [UsedImplicitly] public List GetWidgetsAs() where T : Widget.Widget => Widgets.OfType().ToList(); /// /// Remove Widget /// /// Widget which be removed /// If remove must be delayed [UsedImplicitly] public void RemoveWidget(Widget.Widget widget, bool delay = false) { if (delay) _removeWidgets.Add(widget); else { widget.Scene = null; Widgets.Remove(widget); } } /// /// Remove All Widgets /// [UsedImplicitly] public void RemoveAllWidgets() { foreach (var widget in Widgets) widget.Scene = null; Widgets.Clear(); } /// /// Add Entity To Scene /// /// Entity to be added /// If adding must be delayed /// Type of Widgets /// Entity [UsedImplicitly] public T AddEntity(T entity, bool delay = false) where T : Entity.Entity { if (delay) _addEntities.Add(entity); else { entity.Scene = this; Entities.Add(entity); } return entity; } /// /// Remove Entity From Scene /// /// Entity to be removed /// If remove must be delayed [UsedImplicitly] public void RemoveEntity(Entity.Entity entity, bool delay = false) { if (delay) _removeEntities.Add(entity); else { entity.Scene = null; Entities.Remove(entity); } } /// /// Remove all Entities /// [UsedImplicitly] public void RemoveAllEntities() { foreach (var entity in Entities) entity.Scene = null; Entities.Clear(); } /// /// Load Scene /// [UsedImplicitly] public virtual void Load() { foreach (var system in _sceneSystems) system.Load(); foreach (var entity in Entities) entity.Load(); foreach (var widget in Widgets) widget.Load(); } /// /// Unload Scene /// [UsedImplicitly] public virtual void Unload() { foreach (var entity in Entities) entity.Unload(); foreach (var widget in Widgets) widget.Unload(); foreach (var system in _sceneSystems) system.Unload(); } /// /// Update Scene /// /// Time since last update [UsedImplicitly] public virtual void Update(float delta) { foreach (var system in _sceneSystems) system.Update(delta); ProcessAddingAndRemoving(); for (var i = Entities.Count - 1; i > -1; i--) if ( Entities[i].PauseState is PauseState.Enabled || !Paused && Entities[i].PauseState is PauseState.Normal || Paused && Entities[i].PauseState is PauseState.WhenPaused ) Entities[i].Update(delta); for (var i = Widgets.Count - 1; i > -1; i--) if ( Widgets[i].PauseState is PauseState.Enabled || !Paused && Widgets[i].PauseState is PauseState.Normal || Paused && Widgets[i].PauseState is PauseState.WhenPaused ) Widgets[i].Update(delta); } private void ProcessAddingAndRemoving() { foreach (var removeEntity in _removeEntities) RemoveEntity(removeEntity); foreach (var removeWidget in _removeWidgets) RemoveWidget(removeWidget); foreach (var addEntity in _addEntities) AddEntity(addEntity).Load(); foreach (var addWidget in _addWidgets) AddWidget(addWidget).Load(); _removeEntities.Clear(); _removeWidgets.Clear(); _addEntities.Clear(); _addWidgets.Clear(); } /// /// Draw Scene /// [UsedImplicitly] public virtual void Draw() { foreach (var system in _sceneSystems) system.Draw(); foreach (var ent in Entities) ent.Draw(); foreach (var widget in Widgets) widget.Draw(); } /// /// Function call when Scene is opened /// public virtual void OpenScene() { foreach (var system in _sceneSystems) system.OpenScene(); } /// /// Function call when Scene is closed /// [UsedImplicitly] public virtual void CloseScene() { foreach (var system in _sceneSystems) system.CloseScene(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/SharpEngine.Core.csproj000066400000000000000000000026461514307377300242410ustar00rootroot00000000000000 net10.0 true Core Package of SharpEngine - 2D Game Engine LavaPower LavaPower Copyright (c) LavaPower 2021-2023 MIT https://github.com/SharpEngine/SharpEngine.Core 2.5.1 true README.md true true https://github.com/SharpEngine/SharpEngine.Core git Raylib,SharpEngine,Game,Engine enable SharpEngine.Core-2.5.1/SharpEngine.Core/SharpEngine.Core.csproj.user000066400000000000000000000002451514307377300252070ustar00rootroot00000000000000 SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/000077500000000000000000000000001514307377300210155ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Animation.cs000066400000000000000000000017161514307377300232700ustar00rootroot00000000000000using System.Collections.Generic; using JetBrains.Annotations; namespace SharpEngine.Core.Utils; /// /// Struct which represents animation used by SpriteSheetComponent /// /// Animation /// Frame Indices /// Frame Timer /// If Animation Loop public struct Animation(string name, List indices, float timer, bool loop = true) { /// /// Name of Animation /// public string Name { get; } = name; /// /// Indices of frames /// [UsedImplicitly] public List Indices { get; set; } = indices; /// /// Timer between frames /// [UsedImplicitly] public float Timer { get; set; } = timer; /// /// Loop Animation /// [UsedImplicitly] public bool Loop { get; set; } = loop; } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/CameraMode.cs000066400000000000000000000006161514307377300233440ustar00rootroot00000000000000namespace SharpEngine.Core.Utils; /// /// Working mode of Camera Manager /// public enum CameraMode { /// /// Basic Camera /// Basic, /// /// Camera that follows entity /// Follow, /// /// Camera that follows an entity with smooth movements /// FollowSmooth } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Color.cs000066400000000000000000000360021514307377300224230ustar00rootroot00000000000000using System; using System.Numerics; using JetBrains.Annotations; using SharpEngine.Core.Math; namespace SharpEngine.Core.Utils; /// /// Struct which represents Color /// [UsedImplicitly] public struct Color : IEquatable { private int _r; private int _g; private int _b; private int _a; /// /// Get Red Component of Color /// [UsedImplicitly] public int R { readonly get => _r; set => _r = MathHelper.Clamp(value, 0, 255); } /// /// Get Green Component of Color /// [UsedImplicitly] public int G { readonly get => _g; set => _g = MathHelper.Clamp(value, 0, 255); } /// /// Get Blue Component of Color /// [UsedImplicitly] public int B { readonly get => _b; set => _b = MathHelper.Clamp(value, 0, 255); } /// /// Get Alpha Component of Color /// [UsedImplicitly] public int A { readonly get => _a; set => _a = MathHelper.Clamp(value, 0, 255); } /// /// Create Color with full opacity /// /// Red Component /// Green Component /// Blue Component public Color(int r, int g, int b) { R = r; G = g; B = b; A = 255; } /// /// Create Color /// /// Red Component /// Green Component /// Blue Component /// Alpha Component public Color(int r, int g, int b, int a) { R = r; G = g; B = b; A = a; } /// /// Return Vec4 /// /// Vec4 format public readonly Vector4 ToVec4() => new(_r / 255f, _g / 255f, _b / 255f, _a / 255f); /// /// Return Color from Vec4 /// /// Vector 4 /// Color [UsedImplicitly] public static Color FromVec4(Vector4 vector4) => new( (int)(vector4.X * 255), (int)(vector4.Y * 255), (int)(vector4.Z * 255), (int)(vector4.W * 255) ); /// /// Return Darker Color /// /// Force of Darker Color /// Darker Color [UsedImplicitly] public readonly Color Darker(int force = 1) => new(_r - 10 * force, _g - 10 * force, _b - 10 * force, _a); /// /// Return Lighter Color /// /// Force of Lighter Color /// Lighter Color [UsedImplicitly] public readonly Color Lighter(int force = 1) => new(_r + 10 * force, _g + 10 * force, _b + 10 * force, _a); /// /// Transition Color to target color /// /// Target Color /// Current Elapsed Time of Transition /// Duration of Transition /// Transited Color public readonly Color TranslateTo(Color endColor, float currentTime, float maxTime) { var stepR = (endColor.R - _r) * currentTime / maxTime; var stepG = (endColor.G - _g) * currentTime / maxTime; var stepA = (endColor.A - _a) * currentTime / maxTime; var stepB = (endColor.B - _b) * currentTime / maxTime; return new Color( _r + Convert.ToInt32(stepR), _g + Convert.ToInt32(stepG), _b + Convert.ToInt32(stepB), _a + Convert.ToInt32(stepA) ); } /// public readonly override bool Equals(object? obj) { if (obj is Color color) return this == color; return obj != null && obj.Equals(this); } /// public override int GetHashCode() => HashCode.Combine(_r, _g, _b, _a); /// public readonly override string ToString() => $"Color(R={R}, G={G}, B={B}, A={A})"; /// public bool Equals(Color other) => _r == other._r && _g == other._g && _b == other._b && _a == other._a; /// /// Operator Inequality /// /// First Color /// Second Color /// If first is not equals to second public static bool operator !=(Color color, Color color2) => !(color == color2); /// /// Operator Equality /// /// First Color /// Second Color /// If first is equals to second public static bool operator ==(Color color, Color color2) => color.R == color2.R && color.G == color2.G && color.B == color2.B && color.A == color2.A; /// /// Convert SharpEngine.Core Color to Raylib Color /// /// SharpEngine.Core Color /// Raylib public static implicit operator Raylib_cs.Color(Color color) => new(color.R, color.G, color.B, color.A); // ReSharper disable UnusedMember.Global #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member public static readonly Color MediumAquamarine = new(102, 205, 170, 255); public static readonly Color MediumBlue = new(0, 0, 205, 255); public static readonly Color MediumOrquid = new(186, 85, 211, 255); public static readonly Color MediumPurple = new(147, 112, 219, 255); public static readonly Color MediumSeaGreen = new(60, 179, 113, 255); public static readonly Color MediumSlateBlue = new(123, 104, 238, 255); public static readonly Color MediumSpringGreen = new(0, 250, 154, 255); public static readonly Color MediumTurquoise = new(72, 209, 204, 255); public static readonly Color Moccasin = new(255, 228, 181, 255); public static readonly Color MidnightBlue = new(25, 25, 112, 255); public static readonly Color MintCream = new(245, 255, 250, 255); public static readonly Color MistyRose = new(255, 228, 225, 255); public static readonly Color Maroon = new(128, 0, 0, 255); public static readonly Color Theme = new(231, 60, 0, 255); public static readonly Color NavajoWhite = new(255, 222, 173, 255); public static readonly Color Navy = new(0, 0, 128, 255); public static readonly Color OldLace = new(253, 245, 230, 255); public static readonly Color MediumVioletRed = new(199, 21, 133, 255); public static readonly Color Magenta = new(255, 0, 255, 255); public static readonly Color LightSteelBlue = new(176, 196, 222, 255); public static readonly Color LimeGreen = new(50, 205, 50, 255); public static readonly Color LavenderBlush = new(255, 240, 245, 255); public static readonly Color LawnGreen = new(124, 252, 0, 255); public static readonly Color LemonChiffon = new(255, 250, 205, 255); public static readonly Color LightBlue = new(173, 216, 230, 255); public static readonly Color LightCoral = new(240, 128, 128, 255); public static readonly Color LightCyan = new(224, 255, 255, 255); public static readonly Color LightGoldenrodYellow = new(250, 250, 210, 255); public static readonly Color LightGray = new(211, 211, 211, 255); public static readonly Color LightGreen = new(144, 238, 144, 255); public static readonly Color LightPink = new(255, 182, 193, 255); public static readonly Color LightSalmon = new(255, 160, 122, 255); public static readonly Color LightSeaGreen = new(32, 178, 170, 255); public static readonly Color LightSkyBlue = new(135, 206, 250, 255); public static readonly Color LightSlateGray = new(119, 136, 153, 255); public static readonly Color Olive = new(128, 128, 0, 255); public static readonly Color LightYellow = new(255, 255, 224, 255); public static readonly Color Lime = new(0, 255, 0, 255); public static readonly Color Linen = new(250, 240, 230, 255); public static readonly Color OliveDrab = new(107, 142, 35, 255); public static readonly Color PaleGreen = new(152, 251, 152, 255); public static readonly Color OrangeRed = new(255, 69, 0, 255); public static readonly Color Silver = new(192, 192, 192, 255); public static readonly Color SkyBlue = new(135, 206, 235, 255); public static readonly Color SlateBlue = new(106, 90, 205, 255); public static readonly Color SlateGray = new(112, 128, 144, 255); public static readonly Color Snow = new(255, 250, 250, 255); public static readonly Color SpringGreen = new(0, 255, 127, 255); public static readonly Color SteelBlue = new(70, 130, 180, 255); public static readonly Color Tan = new(210, 180, 140, 255); public static readonly Color Teal = new(0, 128, 128, 255); public static readonly Color Thistle = new(216, 191, 216, 255); public static readonly Color Tomato = new(255, 99, 71, 255); public static readonly Color Turquoise = new(64, 224, 208, 255); public static readonly Color Violet = new(238, 130, 238, 255); public static readonly Color Wheat = new(245, 222, 179, 255); public static readonly Color White = new(255, 255, 255, 255); public static readonly Color WhiteSmoke = new(245, 245, 245, 255); public static readonly Color Yellow = new(255, 255, 0, 255); public static readonly Color Sienna = new(160, 82, 45, 255); public static readonly Color Orange = new(255, 165, 0, 255); public static readonly Color SeaShell = new(255, 245, 238, 255); public static readonly Color SandyBrown = new(244, 164, 96, 255); public static readonly Color Orchid = new(218, 112, 214, 255); public static readonly Color PaleGoldenrod = new(238, 232, 170, 255); public static readonly Color Lavender = new(230, 230, 250, 255); public static readonly Color PaleTurquoise = new(175, 238, 238, 255); public static readonly Color PaleVioletRed = new(219, 112, 147, 255); public static readonly Color PapayaWhip = new(255, 239, 213, 255); public static readonly Color PeachPuff = new(255, 218, 185, 255); public static readonly Color Peru = new(205, 133, 63, 255); public static readonly Color Pink = new(255, 192, 203, 255); public static readonly Color Plum = new(221, 160, 221, 255); public static readonly Color PowderBlue = new(176, 224, 230, 255); public static readonly Color Purple = new(128, 0, 128, 255); public static readonly Color Red = new(255, 0, 0, 255); public static readonly Color RosyBrown = new(188, 143, 143, 255); public static readonly Color RoyalBlue = new(65, 105, 225, 255); public static readonly Color SaddleBrown = new(139, 69, 19, 255); public static readonly Color Salmon = new(250, 128, 114, 255); public static readonly Color SeaGreen = new(46, 139, 87, 255); public static readonly Color Khaki = new(240, 230, 140, 255); public static readonly Color Honeydew = new(240, 255, 240, 255); public static readonly Color Indigo = new(75, 0, 130, 255); public static readonly Color DarkGray = new(169, 169, 169, 255); public static readonly Color DarkGoldenrod = new(184, 134, 11, 255); public static readonly Color DarkCyan = new(0, 139, 139, 255); public static readonly Color DarkBlue = new(0, 0, 139, 255); public static readonly Color Cyan = new(0, 255, 255, 255); public static readonly Color Crimson = new(220, 20, 60, 255); public static readonly Color Cornsilk = new(255, 248, 220, 255); public static readonly Color CornflowerBlue = new(100, 149, 237, 255); public static readonly Color Coral = new(255, 127, 80, 255); public static readonly Color Ivory = new(255, 255, 240, 255); public static readonly Color Chartreuse = new(127, 255, 0, 255); public static readonly Color CadetBlue = new(95, 158, 160, 255); public static readonly Color BurlyWood = new(222, 184, 135, 255); public static readonly Color Brown = new(165, 42, 42, 255); public static readonly Color BlueViolet = new(138, 43, 226, 255); public static readonly Color Blue = new(0, 0, 255, 255); public static readonly Color BlanchedAlmond = new(255, 235, 205, 255); public static readonly Color Black = new(0, 0, 0, 255); public static readonly Color Bisque = new(255, 228, 196, 255); public static readonly Color Beige = new(245, 245, 220, 255); public static readonly Color Azure = new(240, 255, 255, 255); public static readonly Color Aquamarine = new(127, 255, 212, 255); public static readonly Color Aqua = new(0, 255, 255, 255); public static readonly Color AntiqueWhite = new(250, 235, 215, 255); public static readonly Color AliceBlue = new(240, 248, 255, 255); public static readonly Color Transparent = new(0, 0, 0, 0); public static readonly Color DarkGreen = new(0, 100, 0, 255); public static readonly Color DarkKhaki = new(189, 183, 107, 255); public static readonly Color Chocolate = new(210, 105, 30, 255); public static readonly Color DarkOliveGreen = new(85, 107, 47, 255); public static readonly Color IndianRed = new(205, 92, 92, 255); public static readonly Color DarkMagenta = new(139, 0, 139, 255); public static readonly Color YellowGreen = new(154, 205, 50, 255); public static readonly Color GreenYellow = new(173, 255, 47, 255); public static readonly Color Green = new(0, 128, 0, 255); public static readonly Color Gray = new(128, 128, 128, 255); public static readonly Color Goldenrod = new(218, 165, 32, 255); public static readonly Color Gold = new(255, 215, 0, 255); public static readonly Color GhostWhite = new(248, 248, 255, 255); public static readonly Color Gainsboro = new(220, 220, 220, 255); public static readonly Color Fuchsia = new(255, 0, 255, 255); public static readonly Color ForestGreen = new(34, 139, 34, 255); public static readonly Color FloralWhite = new(255, 250, 240, 255); public static readonly Color HotPink = new(255, 105, 180, 255); public static readonly Color DodgerBlue = new(30, 144, 255, 255); public static readonly Color DimGray = new(105, 105, 105, 255); public static readonly Color DeepSkyBlue = new(0, 191, 255, 255); public static readonly Color DeepPink = new(255, 20, 147, 255); public static readonly Color DarkViolet = new(148, 0, 211, 255); public static readonly Color DarkTurquoise = new(0, 206, 209, 255); public static readonly Color DarkSlateGray = new(47, 79, 79, 255); public static readonly Color DarkSlateBlue = new(72, 61, 139, 255); public static readonly Color DarkSeaGreen = new(143, 188, 139, 255); public static readonly Color DarkSalmon = new(233, 150, 122, 255); public static readonly Color DarkRed = new(139, 0, 0, 255); public static readonly Color DarkOrchid = new(153, 50, 204, 255); public static readonly Color DarkOrange = new(255, 140, 0, 255); public static readonly Color Firebrick = new(178, 34, 34, 255); } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/EventArgs/000077500000000000000000000000001514307377300227135ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/EventArgs/BoolEventArgs.cs000066400000000000000000000005071514307377300257560ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Utils.EventArgs; /// /// Event Args which have a boolean result /// public class BoolEventArgs : System.EventArgs { /// /// Result of Event /// [UsedImplicitly] public bool Result { get; set; } = true; } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/EventArgs/ValueEventArgs.cs000066400000000000000000000007641514307377300261440ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Utils.EventArgs; /// /// Event Args which have old and new value /// /// Type of Value public class ValueEventArgs : System.EventArgs { /// /// Old Value /// [UsedImplicitly] public required T OldValue { get; init; } /// /// New Value /// [UsedImplicitly] public required T NewValue { get; init; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/LogLevel.cs000066400000000000000000000017401514307377300230570ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Utils; /// /// Enum, which represents Log Levels /// public enum LogLevel { /// /// Display all logs /// All, /// /// Trace logging, intended for internal use only /// Trace, /// /// Debug logging, used for internal debugging, it should be disabled on release builds /// Debug, /// /// Info logging, used for program execution info /// Info, /// /// Warning logging, used on recoverable failures /// Warning, /// /// Error logging, used on unrecoverable failures /// Error, /// /// Fatal logging, used to abort program: exit(EXIT_FAILURE) /// Fatal, /// /// Disable logging /// [UsedImplicitly] None, } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/PauseState.cs000066400000000000000000000010751514307377300234250ustar00rootroot00000000000000using JetBrains.Annotations; namespace SharpEngine.Core.Utils; /// /// Enum, which represents how Entity or Widget must be updated when paused /// public enum PauseState { /// /// Will be updated only when not paused /// Normal, /// /// Will never be updated /// [UsedImplicitly] Disabled, /// /// Will always be updated /// Enabled, /// /// Will be updated only when paused /// WhenPaused } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SEShader.cs000066400000000000000000000023611514307377300230040ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; namespace SharpEngine.Core.Utils { /// /// Base Class which represents Shader /// // ReSharper disable once InconsistentNaming public class SEShader { /// /// Internal Raylib Shader /// [UsedImplicitly] protected Shader InternalShader; /// /// Create Shader from Vertex and Fragment Shader /// /// Vertex Shader /// Fragment Shader public SEShader(string? vertexShader, string? fragmentShader) { InternalShader = Raylib.LoadShaderFromMemory(vertexShader, fragmentShader); } /// /// Create Shader from Raylib Shader /// /// Raylib Shader public SEShader(Shader internalShader) { InternalShader = internalShader; } /// /// Get Internal Raylib Shader /// /// Raylib Shader public Shader GetInternalShader() => InternalShader; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SceneSystem.cs000066400000000000000000000016151514307377300236110ustar00rootroot00000000000000namespace SharpEngine.Core.Utils; /// /// System which can be added to a scene (useful for optional packages) /// public interface ISceneSystem { /// /// Function call when a system is loaded /// public void Load(); /// /// Function call when the system is unloaded /// public void Unload(); /// /// Function call when the system is updated /// /// Time since last update public void Update(float delta); /// /// Function call when a system draws /// public void Draw(); /// /// Function call when the system is opened /// public void OpenScene(); /// /// Function call when the system is closed /// public void CloseScene(); } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/000077500000000000000000000000001514307377300223175ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/ConsoleCommand/000077500000000000000000000000001514307377300252205ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/ConsoleCommand/DebugVarCommand.cs000066400000000000000000000044661514307377300305570ustar00rootroot00000000000000using SharpEngine.Core.Manager; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using JetBrains.Annotations; namespace SharpEngine.Core.Utils.SeImGui.ConsoleCommand; /// /// Represents a console command that displays or manages debug variables for the application. /// /// The DebugVarCommand allows users to query specific debug-related variables, such as frame /// rate (fps) and version information, through the console interface. It can also be extended with custom variables /// via the CustomVariables dictionary. This command is typically used for diagnostic or development purposes within /// the application's debug console. public class DebugVarCommand : ISeImGuiConsoleCommand { /// /// A dictionary to hold custom debug variables. /// [UsedImplicitly] [SuppressMessage("Usage", "CA2211:Les champs non constants ne doivent pas être visibles")] public static Dictionary CustomVariables = []; /// /// Gets the command name. /// public string Command => "debugvar"; /// /// Processes the debug variable command. /// /// The command arguments. /// The console instance. /// The window instance. public void Process(string[] args, SeImGuiConsole console, Window window) { if (args.Length == 0) console.AddText("Liste des variables disponible : fps, versions" + (CustomVariables.Keys.Count != 0 ? ", " + string.Join(", ", CustomVariables.Keys) : "")); else if(CustomVariables.TryGetValue(args[0], out var value)) console.AddText($"{args[0]} : {value}"); else switch (args[0]) { case "fps": console.AddText($"FPS : {DebugManager.FrameRate}"); break; case "versions": { foreach (var version in DebugManager.Versions) console.AddText($"{version.Key} Version : {version.Value}"); break; } default: console.AddText("Liste des variables disponible : fps, versions"); break; } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/ConsoleCommand/HelpCommand.cs000066400000000000000000000006051514307377300277370ustar00rootroot00000000000000using System.Linq; namespace SharpEngine.Core.Utils.SeImGui.ConsoleCommand; internal class HelpCommand : ISeImGuiConsoleCommand { public string Command => "help"; public void Process(string[] args, SeImGuiConsole console, Window window) { console.AddText("Liste des commandes disponibles : " + string.Join(", ", console.Commands.Select(x => x.Command))); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/ConsoleCommand/SayCommand.cs000066400000000000000000000004441514307377300276040ustar00rootroot00000000000000namespace SharpEngine.Core.Utils.SeImGui.ConsoleCommand; internal class SayCommand : ISeImGuiConsoleCommand { public string Command => "say"; public void Process(string[] args, SeImGuiConsole console, Window window) { console.AddText(string.Join(" ", args)); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/ConsoleCommand/SeImGuiConsoleCommand.cs000066400000000000000000000010461514307377300316740ustar00rootroot00000000000000namespace SharpEngine.Core.Utils.SeImGui.ConsoleCommand; /// /// Interface for console command /// public interface ISeImGuiConsoleCommand { /// /// Command Name /// public string Command { get; } /// /// Process command /// /// Console Arguments /// Console /// Game Window public void Process(string[] args, SeImGuiConsole console, Window window); } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/SEImGui.cs000066400000000000000000000411131514307377300241100ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Linq; using System.Numerics; using ImGuiNET; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; namespace SharpEngine.Core.Utils.SeImGui; /// /// Class which control ImGui /// [UsedImplicitly] public class SeImGui : IDisposable { private readonly nint _context; private Texture2D _fontTexture; private readonly Vector2 _scaleFactor = Vector2.One; private static readonly Dictionary KeyMap = []; internal SeImGui() { _context = ImGui.CreateContext(); ImGui.SetCurrentContext(_context); } /// public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// protected virtual void Dispose(bool disposing) { if (!disposing) return; ImGui.DestroyContext(_context); Raylib.UnloadTexture(_fontTexture); } /// /// Creates a texture and loads the font data from ImGui. /// public void Load(int width, int height) { Resize(width, height); LoadFontTexture(); SetupInput(); ImGui.NewFrame(); } private unsafe void LoadFontTexture() { var io = ImGui.GetIO(); // Load as RGBA 32-bit (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. // If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory. io.Fonts.GetTexDataAsRGBA32(out byte* pixels, out var width, out var height); // Upload texture to graphics system var data = new nint(pixels); var image = new Image { Data = (void*)data, Width = width, Height = height, Mipmaps = 1, Format = PixelFormat.UncompressedR8G8B8A8, }; _fontTexture = Raylib.LoadTextureFromImage(image); // Store texture id in imgui font io.Fonts.SetTexID(new nint(_fontTexture.Id)); // Clears font data on the CPU side io.Fonts.ClearTexData(); } private static void SetupInput() { var io = ImGui.GetIO(); // Setup config flags io.ConfigFlags |= ImGuiConfigFlags.NavEnableKeyboard; io.ConfigFlags |= ImGuiConfigFlags.DockingEnable; // Setup back-end capabilities flags io.BackendFlags |= ImGuiBackendFlags.HasMouseCursors; io.BackendFlags |= ImGuiBackendFlags.HasSetMousePos; KeyMap.Add(KeyboardKey.Apostrophe, ImGuiKey.Apostrophe); KeyMap.Add(KeyboardKey.Comma, ImGuiKey.Comma); KeyMap.Add(KeyboardKey.Minus, ImGuiKey.Minus); KeyMap.Add(KeyboardKey.Period, ImGuiKey.Period); KeyMap.Add(KeyboardKey.Slash, ImGuiKey.Slash); KeyMap.Add(KeyboardKey.Zero, ImGuiKey._0); KeyMap.Add(KeyboardKey.One, ImGuiKey._1); KeyMap.Add(KeyboardKey.Two, ImGuiKey._2); KeyMap.Add(KeyboardKey.Three, ImGuiKey._3); KeyMap.Add(KeyboardKey.Four, ImGuiKey._4); KeyMap.Add(KeyboardKey.Five, ImGuiKey._5); KeyMap.Add(KeyboardKey.Six, ImGuiKey._6); KeyMap.Add(KeyboardKey.Seven, ImGuiKey._7); KeyMap.Add(KeyboardKey.Eight, ImGuiKey._8); KeyMap.Add(KeyboardKey.Nine, ImGuiKey._9); KeyMap.Add(KeyboardKey.Semicolon, ImGuiKey.Semicolon); KeyMap.Add(KeyboardKey.Equal, ImGuiKey.Equal); KeyMap.Add(KeyboardKey.A, ImGuiKey.A); KeyMap.Add(KeyboardKey.B, ImGuiKey.B); KeyMap.Add(KeyboardKey.C, ImGuiKey.C); KeyMap.Add(KeyboardKey.D, ImGuiKey.D); KeyMap.Add(KeyboardKey.E, ImGuiKey.E); KeyMap.Add(KeyboardKey.F, ImGuiKey.F); KeyMap.Add(KeyboardKey.G, ImGuiKey.G); KeyMap.Add(KeyboardKey.H, ImGuiKey.H); KeyMap.Add(KeyboardKey.I, ImGuiKey.I); KeyMap.Add(KeyboardKey.J, ImGuiKey.J); KeyMap.Add(KeyboardKey.K, ImGuiKey.K); KeyMap.Add(KeyboardKey.L, ImGuiKey.L); KeyMap.Add(KeyboardKey.M, ImGuiKey.M); KeyMap.Add(KeyboardKey.N, ImGuiKey.N); KeyMap.Add(KeyboardKey.O, ImGuiKey.O); KeyMap.Add(KeyboardKey.P, ImGuiKey.P); KeyMap.Add(KeyboardKey.Q, ImGuiKey.Q); KeyMap.Add(KeyboardKey.R, ImGuiKey.R); KeyMap.Add(KeyboardKey.S, ImGuiKey.S); KeyMap.Add(KeyboardKey.T, ImGuiKey.T); KeyMap.Add(KeyboardKey.U, ImGuiKey.U); KeyMap.Add(KeyboardKey.V, ImGuiKey.V); KeyMap.Add(KeyboardKey.W, ImGuiKey.W); KeyMap.Add(KeyboardKey.X, ImGuiKey.X); KeyMap.Add(KeyboardKey.Y, ImGuiKey.Y); KeyMap.Add(KeyboardKey.Z, ImGuiKey.Z); KeyMap.Add(KeyboardKey.Space, ImGuiKey.Space); KeyMap.Add(KeyboardKey.Escape, ImGuiKey.Escape); KeyMap.Add(KeyboardKey.Enter, ImGuiKey.Enter); KeyMap.Add(KeyboardKey.Tab, ImGuiKey.Tab); KeyMap.Add(KeyboardKey.Backspace, ImGuiKey.Backspace); KeyMap.Add(KeyboardKey.Insert, ImGuiKey.Insert); KeyMap.Add(KeyboardKey.Delete, ImGuiKey.Delete); KeyMap.Add(KeyboardKey.Right, ImGuiKey.RightArrow); KeyMap.Add(KeyboardKey.Left, ImGuiKey.LeftArrow); KeyMap.Add(KeyboardKey.Down, ImGuiKey.DownArrow); KeyMap.Add(KeyboardKey.Up, ImGuiKey.UpArrow); KeyMap.Add(KeyboardKey.PageUp, ImGuiKey.PageUp); KeyMap.Add(KeyboardKey.PageDown, ImGuiKey.PageDown); KeyMap.Add(KeyboardKey.Home, ImGuiKey.Home); KeyMap.Add(KeyboardKey.End, ImGuiKey.End); KeyMap.Add(KeyboardKey.CapsLock, ImGuiKey.CapsLock); KeyMap.Add(KeyboardKey.ScrollLock, ImGuiKey.ScrollLock); KeyMap.Add(KeyboardKey.NumLock, ImGuiKey.NumLock); KeyMap.Add(KeyboardKey.PrintScreen, ImGuiKey.PrintScreen); KeyMap.Add(KeyboardKey.Pause, ImGuiKey.Pause); KeyMap.Add(KeyboardKey.F1, ImGuiKey.F1); KeyMap.Add(KeyboardKey.F2, ImGuiKey.F2); KeyMap.Add(KeyboardKey.F3, ImGuiKey.F3); KeyMap.Add(KeyboardKey.F4, ImGuiKey.F4); KeyMap.Add(KeyboardKey.F5, ImGuiKey.F5); KeyMap.Add(KeyboardKey.F6, ImGuiKey.F6); KeyMap.Add(KeyboardKey.F7, ImGuiKey.F7); KeyMap.Add(KeyboardKey.F8, ImGuiKey.F8); KeyMap.Add(KeyboardKey.F9, ImGuiKey.F9); KeyMap.Add(KeyboardKey.F10, ImGuiKey.F10); KeyMap.Add(KeyboardKey.F11, ImGuiKey.F11); KeyMap.Add(KeyboardKey.F12, ImGuiKey.F12); KeyMap.Add(KeyboardKey.LeftShift, ImGuiKey.LeftShift); KeyMap.Add(KeyboardKey.LeftControl, ImGuiKey.LeftCtrl); KeyMap.Add(KeyboardKey.LeftAlt, ImGuiKey.LeftAlt); KeyMap.Add(KeyboardKey.LeftSuper, ImGuiKey.LeftSuper); KeyMap.Add(KeyboardKey.RightShift, ImGuiKey.RightShift); KeyMap.Add(KeyboardKey.RightControl, ImGuiKey.RightCtrl); KeyMap.Add(KeyboardKey.RightAlt, ImGuiKey.RightAlt); KeyMap.Add(KeyboardKey.RightSuper, ImGuiKey.RightSuper); KeyMap.Add(KeyboardKey.KeyboardMenu, ImGuiKey.Menu); KeyMap.Add(KeyboardKey.LeftBracket, ImGuiKey.LeftBracket); KeyMap.Add(KeyboardKey.Backslash, ImGuiKey.Backslash); KeyMap.Add(KeyboardKey.RightBracket, ImGuiKey.RightBracket); KeyMap.Add(KeyboardKey.Grave, ImGuiKey.GraveAccent); KeyMap.Add(KeyboardKey.Kp0, ImGuiKey.Keypad0); KeyMap.Add(KeyboardKey.Kp1, ImGuiKey.Keypad1); KeyMap.Add(KeyboardKey.Kp2, ImGuiKey.Keypad2); KeyMap.Add(KeyboardKey.Kp3, ImGuiKey.Keypad3); KeyMap.Add(KeyboardKey.Kp4, ImGuiKey.Keypad4); KeyMap.Add(KeyboardKey.Kp5, ImGuiKey.Keypad5); KeyMap.Add(KeyboardKey.Kp6, ImGuiKey.Keypad6); KeyMap.Add(KeyboardKey.Kp7, ImGuiKey.Keypad7); KeyMap.Add(KeyboardKey.Kp8, ImGuiKey.Keypad8); KeyMap.Add(KeyboardKey.Kp9, ImGuiKey.Keypad9); KeyMap.Add(KeyboardKey.KpDecimal, ImGuiKey.KeypadDecimal); KeyMap.Add(KeyboardKey.KpDivide, ImGuiKey.KeypadDivide); KeyMap.Add(KeyboardKey.KpMultiply, ImGuiKey.KeypadMultiply); KeyMap.Add(KeyboardKey.KpSubtract, ImGuiKey.KeypadSubtract); KeyMap.Add(KeyboardKey.KpAdd, ImGuiKey.KeypadAdd); KeyMap.Add(KeyboardKey.KpEnter, ImGuiKey.KeypadEnter); KeyMap.Add(KeyboardKey.KpEqual, ImGuiKey.KeypadEqual); } /// /// Update imgui internals(input, frameData) /// /// public static void Update(float dt) { var io = ImGui.GetIO(); io.DisplayFramebufferScale = Vector2.One; io.DeltaTime = dt; UpdateKeyboard(); UpdateMouse(); ImGui.NewFrame(); } /// /// Resize imgui display /// public void Resize(int width, int height) { var io = ImGui.GetIO(); io.DisplaySize = new Vector2(width, height) / _scaleFactor; } private static void UpdateKeyboard() { var io = ImGui.GetIO(); // Key states foreach(var keys in KeyMap) { if(Raylib.IsKeyPressed(keys.Key)) io.AddKeyEvent(keys.Value, true); if (Raylib.IsKeyReleased(keys.Key)) io.AddKeyEvent(keys.Value, false); } // Key input foreach (var charGot in InputManager.InternalPressedChars.Where(charGot => charGot != 0)) io.AddInputCharacter((uint)charGot); } private static void UpdateMouse() { var io = ImGui.GetIO(); // Store button states for (var i = 0; i < io.MouseDown.Count; i++) io.MouseDown[i] = Raylib.IsMouseButtonDown((MouseButton)i); // Mouse scroll io.MouseWheel += Raylib.GetMouseWheelMove(); // Mouse position var mousePosition = io.MousePos; bool focused = Raylib.IsWindowFocused(); if (focused) { if (io.WantSetMousePos) InputManager.SetMousePosition(mousePosition); else io.MousePos = InputManager.GetMousePosition(); } // Mouse cursor state if ((io.ConfigFlags & ImGuiConfigFlags.NoMouseCursorChange) != 0 && !Raylib.IsCursorHidden()) return; var cursor = ImGui.GetMouseCursor(); if (cursor == ImGuiMouseCursor.None || io.MouseDrawCursor) Raylib.HideCursor(); else Raylib.ShowCursor(); } /// /// Gets the geometry as set up by ImGui and sends it to the graphics device /// public static void Draw() { ImGui.Render(); RenderCommandLists(ImGui.GetDrawData()); } // Returns a Color struct from hexadecimal value private static Raylib_cs.Color GetColor(uint hexValue) { Raylib_cs.Color color = new( (byte)(hexValue & 0xFF), (byte)(hexValue >> 8 & 0xFF), (byte)(hexValue >> 16 & 0xFF), (byte)(hexValue >> 24 & 0xFF) ); return color; } private static void DrawTriangleVertex(ImDrawVertPtr idxVert) { var c = GetColor(idxVert.col); Rlgl.Color4ub(c.R, c.G, c.B, c.A); Rlgl.TexCoord2f(idxVert.uv.X, idxVert.uv.Y); Rlgl.Vertex2f(idxVert.pos.X, idxVert.pos.Y); } // Draw the imgui triangle data private static void DrawTriangles( uint count, int idxOffset, int vtxOffset, ImVector idxBuffer, ImPtrVector idxVert, nint textureId ) { if (Rlgl.CheckRenderBatchLimit((int)count * 3)) Rlgl.DrawRenderBatchActive(); Rlgl.Begin(DrawMode.Triangles); // RL_TRIANGLES Rlgl.SetTexture((uint)textureId); for (var i = 0; i <= count - 3; i += 3) { var index = idxBuffer[idxOffset + i]; var vertex = idxVert[vtxOffset + index]; DrawTriangleVertex(vertex); index = idxBuffer[idxOffset + i + 1]; vertex = idxVert[vtxOffset + index]; DrawTriangleVertex(vertex); index = idxBuffer[idxOffset + i + 2]; vertex = idxVert[vtxOffset + index]; DrawTriangleVertex(vertex); } Rlgl.End(); } private static void RenderCommandLists(ImDrawDataPtr data) { // Scale coordinates for retina displays (screen coordinates != framebuffer coordinates) var fbWidth = (int)(data.DisplaySize.X * data.FramebufferScale.X); var fbHeight = (int)(data.DisplaySize.Y * data.FramebufferScale.Y); // Avoid rendering if display is minimized or if the command list is empty if (fbWidth <= 0 || fbHeight <= 0 || data.CmdListsCount == 0) return; Rlgl.DrawRenderBatchActive(); Rlgl.DisableBackfaceCulling(); Rlgl.EnableScissorTest(); data.ScaleClipRects(ImGui.GetIO().DisplayFramebufferScale); for (var n = 0; n < data.CmdListsCount; n++) { var idxOffset = 0; var cmdList = data.CmdLists[n]; // Vertex buffer and index buffer generated by DearImGui var vtxBuffer = cmdList.VtxBuffer; var idxBuffer = cmdList.IdxBuffer; for (var cmdi = 0; cmdi < cmdList.CmdBuffer.Size; cmdi++) { var pcmd = cmdList.CmdBuffer[cmdi]; // Scissor rect var pos = data.DisplayPos; var rectX = (int)((pcmd.ClipRect.X - pos.X) * data.FramebufferScale.X); var rectY = (int)((pcmd.ClipRect.Y - pos.Y) * data.FramebufferScale.Y); var rectW = (int)((pcmd.ClipRect.Z - rectX) * data.FramebufferScale.Y); var rectH = (int)((pcmd.ClipRect.W - rectY) * data.FramebufferScale.Y); Rlgl.Scissor(rectX, (int)InputManager.InternalWindow.RenderSize.Y - (rectY + rectH), rectW, rectH); if (pcmd.UserCallback != nint.Zero) idxOffset += (int)pcmd.ElemCount; else { DrawTriangles( pcmd.ElemCount, idxOffset, (int)pcmd.VtxOffset, idxBuffer, vtxBuffer, pcmd.TextureId ); idxOffset += (int)pcmd.ElemCount; Rlgl.DrawRenderBatchActive(); } } } Rlgl.SetTexture(0); Rlgl.DisableScissorTest(); Rlgl.EnableBackfaceCulling(); } /// /// Render Raylib Texture2D to ImGui /// /// Raylib Texture2D /// Destination Width /// Destination Height /// Source Rectangle private static void ImageRect(Texture2D image, int width, int height, Rect source) { var uv0 = new Vector2(); var uv1 = new Vector2(); if (source.Width < 0) { uv0.X = -(source.X / image.Width); uv1.X = uv0.X - MathF.Abs(source.Width) / image.Width; } else { uv0.X = source.X / image.Width; uv1.X = uv0.X + source.Width / image.Width; } if (source.Height < 0) { uv0.Y = -(source.Y / image.Height); uv1.Y = uv0.Y - MathF.Abs(source.Height) / image.Height; } else { uv0.Y = source.Y / image.Height; uv1.Y = uv0.Y + source.Height / image.Height; } ImGui.Image(new nint(image.Id), new Vector2(width, height), uv0, uv1); } /// /// Render Raylib RenderTexture2D to ImGui /// /// Raylib RenderTexture2D /// Center RenderTexture2D [UsedImplicitly] public static void ImageRenderTexture(RenderTexture2D image, bool center = true) { var area = ImGui.GetContentRegionAvail(); var scale = area.X / image.Texture.Width; var y = image.Texture.Height * scale; if (y > area.Y) scale = area.Y / image.Texture.Height; var sizeX = (int)(image.Texture.Width * scale); var sizeY = (int)(image.Texture.Height * scale); if (center) { ImGui.SetCursorPosX(0); ImGui.SetCursorPosX(area.X / 2 - sizeX / 2f); ImGui.SetCursorPosY(ImGui.GetCursorPosY() + (area.Y / 2 - sizeY / 2f)); } ImageRect( image.Texture, sizeX, sizeY, new Rect(0, 0, image.Texture.Width, -image.Texture.Height) ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/SEImGuiConsole.cs000066400000000000000000000101301514307377300254260ustar00rootroot00000000000000using ImGuiNET; using SharpEngine.Core.Utils.SeImGui.ConsoleCommand; using System; using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; namespace SharpEngine.Core.Utils.SeImGui; /// /// Class which represents Console for SharpEngine /// public class SeImGuiConsole { /// /// Texts of Console /// [UsedImplicitly] public List ConsoleTexts { get; } = []; /// /// History of Console /// [UsedImplicitly] public List History { get; } = []; /// /// Gets or sets the current position within the history sequence. /// /// A value of -1 typically indicates that there is no current history entry selected. /// The valid range and meaning of this property may depend on the context in which it is used. [UsedImplicitly] public int HistoryIndex { get; set; } = -1; /// /// Commands of Console /// public List Commands { get; } = [ new SayCommand(), new HelpCommand(), new DebugVarCommand() ]; /// /// Input of Console /// private string _consoleInput = ""; /// /// Add Text to Console /// /// public void AddText(string text) => ConsoleTexts.Add(text); /// /// Display ImGui Console for SharpEngine /// public void Display(Window window) { ImGui.Begin("SharpEngine Console"); // Log Window var reserve = ImGui.GetStyle().ItemSpacing.Y + ImGui.GetFrameHeightWithSpacing(); if (ImGui.BeginChild("Console", new System.Numerics.Vector2(0, -reserve), ImGuiChildFlags.None, ImGuiWindowFlags.None)) { ImGui.PushTextWrapPos(); foreach (var command in ConsoleTexts) ImGui.TextUnformatted(command); ImGui.PopTextWrapPos(); ImGui.SetScrollHereY(1.0f); ImGui.EndChild(); } ImGui.Separator(); unsafe { if (ImGui.InputText("Input", ref _consoleInput, 100, ImGuiInputTextFlags.EnterReturnsTrue | ImGuiInputTextFlags.CallbackHistory, (evt) => { if (!ImGui.IsItemActive() || History.Count <= 0) return 0; ImGuiInputTextCallbackDataPtr evtPtr = evt; if (ImGui.IsKeyPressed(ImGuiKey.UpArrow)) { if (HistoryIndex < History.Count - 1) HistoryIndex++; evtPtr.DeleteChars(0, evtPtr.BufTextLen); evtPtr.InsertChars(0, History[HistoryIndex]); } else if (ImGui.IsKeyPressed(ImGuiKey.DownArrow)) { if (HistoryIndex >= 0) HistoryIndex--; if (HistoryIndex == -1) evtPtr.DeleteChars(0, evtPtr.BufTextLen); else { evtPtr.DeleteChars(0, evtPtr.BufTextLen); evtPtr.InsertChars(0, History[HistoryIndex]); } } return 0; })) { if (_consoleInput.Length > 0) ProcessCommand(window); _consoleInput = ""; ImGui.SetKeyboardFocusHere(-1); } } ImGui.End(); } private void ProcessCommand(Window window) { AddText("> " + _consoleInput); History.Insert(0, _consoleInput); HistoryIndex = -1; var command = _consoleInput.Split(" "); var commandName = command[0]; var commandArgs = Array.Empty(); if (command.Length > 1) commandArgs = command[1..]; if(Commands.FirstOrDefault(commandObject => commandObject.Command == commandName) is { } cmd) cmd.Process(commandArgs, this, window); else AddText("Unknown command."); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/SeImGui/SeImGuiWindows.cs000066400000000000000000000063401514307377300255260ustar00rootroot00000000000000using ImGuiNET; using SharpEngine.Core.Manager; using SharpEngine.Core.Renderer; using System.Linq; namespace SharpEngine.Core.Utils.SeImGui; /// /// Class which have imgui windows /// public static class SeImGuiWindows { internal static SeImGuiConsole Console { get; } = new(); /// /// Display ImGui Console for SharpEngine /// public static void CreateSeImGuiConsole(Window window) { Console.Display(window); } /// /// Create ImGui Window for SharpEngine /// public static void CreateSeImGuiWindow(Window window) { ImGui.Begin("SharpEngine Debug"); foreach (var version in DebugManager.Versions) ImGui.Text($"{version.Key} Version : {version.Value}"); ImGui.Separator(); ImGui.Text( $"FPS (from ImGui) : {1000.0 / ImGui.GetIO().Framerate:.000}ms/frame ({ImGui.GetIO().Framerate} FPS)" ); ImGui.Text($"FPS (from SE) : {1000.0 / DebugManager.FrameRate:.000}ms/frame ({DebugManager.FrameRate} FPS)"); ImGui.Text($"GC Memory : {DebugManager.GcMemory / 1000000.0:.000} mo"); ImGui.Separator(); ImGui.Text($"Screen Size : {window.ScreenSize}"); ImGui.Text($"Render Size : {window.RenderSize}"); ImGui.Text($"Render Scale : {window.RenderScale}"); ImGui.Separator(); ImGui.Text($"Textures Number : {window.TextureManager.Textures.Count}"); ImGui.Text($"Shaders Number : {window.ShaderManager.Shaders.Count}"); ImGui.Text($"Fonts Number : {window.FontManager.Fonts.Count}"); ImGui.Text($"Sounds Number : {window.SoundManager.Sounds.Count}"); ImGui.Text($"Musics Number : {window.MusicManager.Musics.Count}"); ImGui.Text($"Timers Number : {window.TimerManager.Timers.Count}"); ImGui.Text($"Tweens Number : {window.TweenManager.Tweens.Count}"); ImGui.Text($"Langs Number : {LangManager.Langs.Count}"); ImGui.Text($"Saves Number : {SaveManager.Saves.Count}"); ImGui.Text($"DataTable Number : {DataTableManager.DataTableNames.Count}"); ImGui.Text($"Scenes Number : {window.Scenes.Count}"); ImGui.Text($"Entities Number : {window.Scenes.Select(x => x.Entities.Count).Sum()}"); ImGui.Text( $"Widgets (Without Child) Number : {window.Scenes.Select(x => x.Widgets.Count).Sum()}" ); ImGui.Text( $"Widgets (With Child) Number : {window.Scenes.Select(x => x.Widgets.Count).Sum() + window.Scenes.Select(x => x.Widgets).SelectMany(x => x).Select(x => x.GetAllChildren()).SelectMany(x => x).Count()}" ); ImGui.Separator(); ImGui.Text($"Camera Mode : {window.CameraManager.Mode}"); ImGui.Text($"Camera Position : {window.CameraManager.Camera2D.Target}"); ImGui.Text($"Camera Rotation : {window.CameraManager.Rotation}"); ImGui.Separator(); ImGui.Text($"Number of Render Instructions : {SERender.LastInstructionsNumber}"); ImGui.Text( $"Number of Entity Render Instructions : {SERender.LastEntityInstructionsNumber}" ); ImGui.Text($"Number of UI Render Instructions : {SERender.LastUiInstructionsNumber}"); ImGui.End(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Timer.cs000066400000000000000000000026241514307377300224300ustar00rootroot00000000000000using System; using JetBrains.Annotations; namespace SharpEngine.Core.Utils; /// /// Class which represents Timer /// /// Time of Timer /// Function which be called at the end /// True if timer will loop [UsedImplicitly] public class Timer(float startTime, Action endFunction, bool loop = false) { /// /// Start Time of Timer /// [UsedImplicitly] public float StartTime { get; set; } = startTime; /// /// Current Time of Timer /// [UsedImplicitly] public float CurrentTime { get; set; } = startTime; /// /// Function which be called when time is ended /// [UsedImplicitly] public Action EndFunction { get; set; } = endFunction; /// /// True if timer will loop /// [UsedImplicitly] public bool Loop { get; set; } = loop; /// /// Update Timer with Time /// /// Passed Time /// True if ended, else false public bool Update(float delta) { CurrentTime -= delta; if (!(CurrentTime <= 0)) return false; EndFunction(); if (!Loop) return true; CurrentTime = StartTime; return false; } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Tween/000077500000000000000000000000001514307377300220775ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Tween/ColorStep.cs000066400000000000000000000002151514307377300243360ustar00rootroot00000000000000namespace SharpEngine.Core.Utils.Tween; internal record ColorStep( short RStep, short GStep, short BStep, short AStep ); SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Tween/Tween.cs000066400000000000000000000040721514307377300235130ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; namespace SharpEngine.Core.Utils.Tween; /// /// Represents an animation or value interpolation that transitions smoothly between states over time. /// /// A Tween is typically used to animate properties or values gradually, such as moving /// an object, fading colors, or scaling elements. The specific behavior and configuration of the tween depend on /// the implementation and usage context. public class Tween { /// /// Steps of Tween /// [UsedImplicitly] public List Steps { get; set; } /// /// Function which be called when Tween ends /// [UsedImplicitly] public Action? EndFunction { get; set; } /// /// Gets or sets the zero-based index of the current step in the workflow. /// [UsedImplicitly] public int CurrentStepIndex { get; set; } /// /// Initializes a new instance of the Tween class with the specified steps and an optional end function. /// /// Steps /// End Function public Tween(List steps, Action? endFunction = null) { Steps = steps; EndFunction = endFunction; if (Steps.Count > 0) Steps[0].Launch(); } /// /// Updates the tween based on the elapsed time since the last update. /// /// Delta Time /// If the tween has completed public bool Update(float deltaTime) { if (Steps.Count == 0) return true; var currentStep = Steps[CurrentStepIndex]; if (!currentStep.Update(deltaTime)) return false; CurrentStepIndex++; if (CurrentStepIndex >= Steps.Count) { EndFunction?.Invoke(); return true; } Steps[CurrentStepIndex].Launch(); return false; } }SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Tween/TweenData.cs000066400000000000000000000056631514307377300243140ustar00rootroot00000000000000using SharpEngine.Core.Manager; using System; using System.Linq.Expressions; using System.Reflection; using JetBrains.Annotations; namespace SharpEngine.Core.Utils.Tween { internal class TweenData( object obj, Expression> property, TD from, TD to, float duration, bool useFrom = true) where TD : notnull { [UsedImplicitly] public object Obj { get; set; } = obj; [UsedImplicitly] public Expression> Property { get; set; } = property; [UsedImplicitly] public TD From { get; set; } = from; [UsedImplicitly] public TD To { get; set; } = to; [UsedImplicitly] public float Duration { get; set; } = duration; [UsedImplicitly] public TD CurrentValue { get; set; } = default!; [UsedImplicitly] public TDStep Step { get; set; } = default!; [UsedImplicitly] public bool UseFrom { get; set; } = useFrom; public void Launch() { CurrentValue = UseFrom ? From : Property.Compile()(Obj); Step = CurrentValue switch { float fFrom when To is float fTo => (TDStep)(object)((fTo - fFrom) / Duration), int iFrom when To is int iTo => (TDStep)(object)((iTo - iFrom) / Duration), Color cFrom when To is Color cTo => (TDStep)(object)new ColorStep( (short)((cTo.R - cFrom.R) / Duration), (short)((cTo.G - cFrom.G) / Duration), (short)((cTo.B - cFrom.B) / Duration), (short)((cTo.A - cFrom.A) / Duration) ), _ => throw new NotSupportedException("Unsupported type for tweening.") }; DebugManager.Log(LogLevel.Debug, $"Tween Launched: From = {From}, To = {To}, Duration = {Duration}, Step = {Step}"); } public void Update(float deltaTime) { if (Duration <= 0) { ((PropertyInfo)((MemberExpression)Property.Body).Member).SetValue(Obj, To); return; } CurrentValue = CurrentValue switch { float cVal when Step is float step => (TD)(object)(cVal + step * deltaTime), int cVal when Step is int step => (TD)(object)(cVal + (int)(step * deltaTime)), Color cVal when Step is ColorStep step => (TD)(object)new Color( (byte)(cVal.R + step.RStep * deltaTime), (byte)(cVal.G + step.GStep * deltaTime), (byte)(cVal.B + step.BStep * deltaTime), (byte)(cVal.A + step.AStep * deltaTime) ), _ => CurrentValue }; ((PropertyInfo)((MemberExpression)Property.Body).Member).SetValue(Obj, CurrentValue); Duration -= deltaTime; } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Utils/Tween/TweenStep.cs000066400000000000000000000105661514307377300243540ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Linq.Expressions; using JetBrains.Annotations; namespace SharpEngine.Core.Utils.Tween; /// /// Represents a single step in a tween animation sequence. /// /// A TweenStep typically encapsulates the logic for updating a portion of an animation over /// time. Instances of this class are commonly used within tweening frameworks to manage incremental changes to /// animated properties. public class TweenStep { /// /// Duration of the step /// [UsedImplicitly] public float CurrentDuration { get; set; } private readonly List> _floatTweens = []; private readonly List> _intTweens = []; private readonly List> _colorTweens = []; /// /// Initializes a new instance of the TweenStep class with the specified duration. /// /// The duration, in seconds, for this tween step. Must be greater than or equal to zero. public TweenStep(float duration) { CurrentDuration = duration; } /// /// Add a float tween to the step /// /// Entity /// Property which be modified /// Target Value /// Duration of the tween /// Source Value /// Tween Step public TweenStep Float(object entity, Expression> property, float to, float duration, float? from = null) { _floatTweens.Add(new TweenData(entity, property, from ?? 0, to, duration, from is not null)); return this; } /// /// Add an int tween to the step /// /// Entity /// Property which be modified /// Target Value /// Duration of the tween /// Source Value /// Tween Steps [UsedImplicitly] public TweenStep Int(object entity, Expression> property, int to, float duration, int? from = null) { _intTweens.Add(new TweenData(entity, property, from ?? 0, to, duration, from is not null)); return this; } /// /// Animates a color property of the specified entity from a starting value to a target value over the given /// duration. /// /// The entity whose color property will be animated. /// An expression that selects the color property of the entity to animate. /// The target color value to animate to. /// The duration, in seconds, over which the animation occurs. Must be greater than zero. /// The initial color value to animate from. If null, the current value of the property is used. /// The current instance, allowing for method chaining. [UsedImplicitly] public TweenStep Color(object entity, Expression> property, Color to, float duration, Color? from = null) { _colorTweens.Add(new TweenData(entity, property, from ?? Utils.Color.White, to, duration, from is not null)); return this; } /// /// Update the tween step /// /// Delta time /// If a step ended public bool Update(float deltaTime) { CurrentDuration -= deltaTime; foreach (var floatTween in _floatTweens) floatTween.Update(deltaTime); foreach (var intTween in _intTweens) intTween.Update(deltaTime); foreach (var colorTween in _colorTweens) colorTween.Update(deltaTime); return CurrentDuration <= 0f; } internal void Launch() { foreach (var floatTween in _floatTweens) floatTween.Launch(); foreach (var intTween in _intTweens) intTween.Launch(); foreach (var colorTween in _colorTweens) colorTween.Launch(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/000077500000000000000000000000001514307377300211405ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Button.cs000066400000000000000000000113661514307377300227510ustar00rootroot00000000000000using System; using Raylib_cs; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using Color = SharpEngine.Core.Utils.Color; using MouseButton = SharpEngine.Core.Input.MouseButton; namespace SharpEngine.Core.Widget; /// /// Class which display Button /// /// Button Position /// Button Text /// Button Font /// Button Size /// Button Font Color /// Button Background Color /// Button Font Size /// Z Layer public class Button( Vec2 position, string text = "", string font = "", Vec2? size = null, Color? fontColor = null, Color? backgroundColor = null, int? fontSize = null, int zLayer = 0 ) : Widget(position, zLayer) { /// /// State of Button /// protected enum ButtonState { /// /// Waiting /// Idle, /// /// Pressed /// Down, /// /// Hover /// Hover } /// /// Text of Button /// public string Text { get; set; } = text; /// /// Font of Button /// public string Font { get; set; } = font; /// /// Size of Button /// public Vec2 Size { get; set; } = size ?? new Vec2(200, 40); /// /// Color of Button Font /// public Color FontColor { get; set; } = fontColor ?? Color.Black; /// /// Color of Button Background /// public Color BackgroundColor { get; set; } = backgroundColor ?? Color.Gray; /// /// Font Size of Button (or Null) /// public int? FontSize { get; set; } = fontSize; /// /// Event that triggers when a button is clicked /// public event EventHandler? Clicked; /// /// State of Button /// protected ButtonState State = ButtonState.Idle; /// public override void Update(float delta) { base.Update(delta); if (!RealDisplayed || !Active) return; if (InputManager.IsMouseInRectangle(new Rect(RealPosition - Size / 2, Size))) { State = ButtonState.Hover; if (InputManager.IsMouseButtonPressed(MouseButton.Left)) Clicked?.Invoke(this, EventArgs.Empty); if (InputManager.IsMouseButtonDown(MouseButton.Left)) State = ButtonState.Down; } else State = ButtonState.Idle; } /// public override void Draw() { base.Draw(); var finalFont = Scene?.Window?.FontManager.GetFont(Font); if (!Displayed || Scene == null || Text.Length <= 0 || Font.Length <= 0 || finalFont == null) return; if (State == ButtonState.Hover && Active) SERender.DrawRectangle( RealPosition.X - (Size.X + 4) / 2, RealPosition.Y - (Size.Y + 4) / 2, Size.X + 4, Size.Y + 4, Color.White, InstructionSource.Ui, ZLayer ); SERender.DrawRectangle( RealPosition.X - Size.X / 2, RealPosition.Y - Size.Y / 2, Size.X, Size.Y, Color.Black, InstructionSource.Ui, ZLayer + 0.00001f ); SERender.DrawRectangle( RealPosition.X - (Size.X - 4) / 2, RealPosition.Y - (Size.Y - 4) / 2, Size.X - 4, Size.Y - 4, BackgroundColor, InstructionSource.Ui, ZLayer + 0.00002f ); var finalFontSize = FontSize ?? finalFont.Value.BaseSize; var textSize = Raylib.MeasureTextEx(finalFont.Value, Text, finalFontSize, 2); SERender.DrawText( finalFont.Value, Text, RealPosition, textSize / 2, 0, finalFontSize, 2, FontColor, InstructionSource.Ui, ZLayer + 0.00003f ); if (State == ButtonState.Down || !Active) SERender.DrawRectangle( RealPosition.X - Size.X / 2, RealPosition.Y - Size.Y / 2, Size.X, Size.Y, new Color(0, 0, 0, 128), InstructionSource.Ui, ZLayer + 0.00004f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Checkbox.cs000066400000000000000000000051271514307377300232220ustar00rootroot00000000000000using System; using JetBrains.Annotations; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils.EventArgs; using SharpEngine.Core.Utils; using SharpEngine.Core.Input; namespace SharpEngine.Core.Widget; /// /// Class which display Checkbox /// /// Checkbox Position /// Checkbox Size /// If Checkbox is Checked /// Z Layer [UsedImplicitly] public class Checkbox(Vec2 position, Vec2? size = null, bool isChecked = false, int zLayer = 0) : Widget(position, zLayer) { /// /// Size of Checkbox /// [UsedImplicitly] public Vec2 Size { get; set; } = size ?? new Vec2(20); /// /// If Checkbox is Checked /// [UsedImplicitly] public bool IsChecked { get; set; } = isChecked; /// /// Event trigger when value is changed /// [UsedImplicitly] public event EventHandler>? ValueChanged; /// public override void Update(float delta) { base.Update(delta); if (!RealDisplayed || !Active) return; if ( InputManager.IsMouseButtonPressed(MouseButton.Left) && InputManager.IsMouseInRectangle(new Rect(RealPosition - Size / 2, Size)) ) { IsChecked = !IsChecked; ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = !IsChecked, NewValue = IsChecked } ); } } /// public override void Draw() { base.Draw(); if (!Displayed || Size == Vec2.Zero) return; SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, 0, Color.Black, InstructionSource.Ui, ZLayer ); SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X - 4, Size.Y - 4), (Size - 4) / 2, 0, Color.White, InstructionSource.Ui, ZLayer + 0.00001f ); if (IsChecked) SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X - 6, Size.Y - 6), (Size - 6) / 2, 0, Color.Black, InstructionSource.Ui, ZLayer + 0.00002f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/ColorRect.cs000066400000000000000000000026531514307377300233710ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Class which display colored Rect /// /// Color Rect Position /// Color Rect Size /// Color Rect Color /// Color Rect Rotation /// Z Layer [UsedImplicitly] public class ColorRect( Vec2 position, Vec2? size = null, Color? color = null, int rotation = 0, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Color of Rect /// [UsedImplicitly] public Color Color { get; set; } = color ?? Color.Black; /// /// Size of Rect /// [UsedImplicitly] public Vec2 Size { get; set; } = size ?? Vec2.One; /// /// Rotation of Rect /// [UsedImplicitly] public int Rotation { get; set; } = rotation; /// public override void Draw() { base.Draw(); if (!Displayed || Size == Vec2.Zero) return; SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, Rotation, Color, InstructionSource.Ui, ZLayer ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Frame.cs000066400000000000000000000040121514307377300225160ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Class which display frame /// /// Frame Position /// Frame Size /// Frame Border Size (3) /// Frame Border Color (Color.Black) /// Frame Background Color (null) /// Z Layer public class Frame( Vec2 position, Vec2 size, int borderSize = 3, Color? borderColor = null, Color? backgroundColor = null, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Color of Frame Border /// [UsedImplicitly] public Color BorderColor { get; set; } = borderColor ?? Color.Black; /// /// Size of Frame /// [UsedImplicitly] public Vec2 Size { get; set; } = size; /// /// Size of Frame Border /// [UsedImplicitly] public int BorderSize { get; set; } = borderSize; /// /// Color of Frame Background /// [UsedImplicitly] public Color? BackgroundColor { get; set; } = backgroundColor; /// public override void Draw() { base.Draw(); if (!Displayed || Size == Vec2.Zero) return; if (BackgroundColor != null) SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, 0, BackgroundColor.Value, InstructionSource.Ui, ZLayer ); SERender.DrawRectangleLines( new Rect(RealPosition.X - Size.X / 2, RealPosition.Y - Size.Y / 2, Size.X, Size.Y), BorderSize, BorderColor, InstructionSource.Ui, ZLayer + 0.00001f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Image.cs000066400000000000000000000033731514307377300225170ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Class which display Image /// /// Image Position /// Image Texture ("") /// Image Scale (Vec2(1)) /// Image Rotation (0) /// Z Layer public class Image( Vec2 position, string texture = "", Vec2? scale = null, int rotation = 0, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Name of Texture which be displayed /// [UsedImplicitly] public string Texture { get; set; } = texture; /// /// Scale of Image /// [UsedImplicitly] public Vec2 Scale { get; set; } = scale ?? Vec2.One; /// /// Rotation of Image /// [UsedImplicitly] public int Rotation { get; set; } = rotation; /// public override void Draw() { base.Draw(); var window = Scene?.Window; if (!Displayed || Texture.Length <= 0 || window == null) return; var finalTexture = window.TextureManager.GetTexture(Texture); SERender.DrawTexture( finalTexture, new Rect(0, 0, finalTexture.Width, finalTexture.Height), new Rect(RealPosition.X, RealPosition.Y, finalTexture.Width * Scale.X, finalTexture.Height * Scale.Y), new Vec2(finalTexture.Width / 2f * Scale.X, finalTexture.Height / 2f * Scale.Y), Rotation, Color.White, InstructionSource.Ui, ZLayer ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Label.cs000066400000000000000000000074411514307377300225140ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Widget.Utils; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Widget; /// /// Class which display Label /// /// Label Position /// Label Text /// Label Font /// Label Color /// Label Style /// Label Rotation /// If Label Lines is Centered /// Label Font Size (or null) /// Z Layer public class Label( Vec2 position, string text = "", string font = "", Color? color = null, LabelStyles style = LabelStyles.None, int rotation = 0, bool centerAllLines = false, int? fontSize = null, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Text of Label /// public string Text { get; set; } = text; /// /// Font of Label /// [UsedImplicitly] public string Font { get; set; } = font; /// /// Color of Label /// [UsedImplicitly] public Color Color { get; set; } = color ?? Color.Black; /// /// If Lines is Centered /// [UsedImplicitly] public bool CenterAllLines { get; set; } = centerAllLines; /// /// Rotation of Label /// [UsedImplicitly] public int Rotation { get; set; } = rotation; /// /// Font Size of Label (or Null) /// [UsedImplicitly] public int? FontSize { get; set; } = fontSize; /// /// Style of Label /// [UsedImplicitly] public LabelStyles Style { get; set; } = style; /// public override void Draw() { base.Draw(); var finalFont = Scene?.Window?.FontManager.GetFont(Font); if (!Displayed || Scene == null || Text.Length <= 0 || Font.Length <= 0 || finalFont == null) return; var finalFontSize = FontSize ?? finalFont.Value.BaseSize; var textSize = Raylib.MeasureTextEx(finalFont.Value, Text, finalFontSize, 2); var lines = Text.Split("\n"); for (var i = 0; i < lines.Length; i++) { var lineSize = Raylib.MeasureTextEx(finalFont.Value, lines[i], finalFontSize, 2); var finalPosition = new Vec2( CenterAllLines ? RealPosition.X - lineSize.X / 2 : RealPosition.X - textSize.X / 2, RealPosition.Y - textSize.Y / 2 + i * lineSize.Y ); SERender.DrawText( finalFont.Value, lines[i], finalPosition, Vec2.Zero, Rotation, finalFontSize, 2, Color, InstructionSource.Ui, ZLayer ); if (Style.HasFlag(LabelStyles.Strike)) SERender.DrawRectangle( finalPosition.X, (finalPosition.Y + lineSize.Y / 2), lineSize.X, 2, Color.Black, InstructionSource.Ui, ZLayer + 0.00001f ); if (Style.HasFlag(LabelStyles.Underline)) SERender.DrawRectangle( finalPosition.X, (finalPosition.Y + lineSize.Y), lineSize.X, 2, Color.Black, InstructionSource.Ui, ZLayer + 0.00001f ); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/LineInput.cs000066400000000000000000000137521514307377300234060ustar00rootroot00000000000000using System; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils.EventArgs; using Color = SharpEngine.Core.Utils.Color; using MouseButton = SharpEngine.Core.Input.MouseButton; namespace SharpEngine.Core.Widget; /// /// Class which represents Line Input /// /// Line Edit Position /// Line Edit Text ("") /// Line Edit Font ("") /// Line Edit Size (Vec2(300, 50)) /// Line Edit Font Size (null) /// If Line Edit is Secret (false) /// Z Layer public class LineInput( Vec2 position, string text = "", string font = "", Vec2? size = null, int? fontSize = null, bool secret = false, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Current Text of Line Input /// [UsedImplicitly] public string Text { get; set; } = text; /// /// Font of Line Input /// [UsedImplicitly] public string Font { get; set; } = font; /// /// Size of Line Input /// [UsedImplicitly] public Vec2 Size { get; set; } = size ?? new Vec2(300, 50); /// /// If Line Input is Focused /// [UsedImplicitly] public bool Focused { get; private set; } /// /// Font Size of Line Input (or null) /// [UsedImplicitly] public int? FontSize { get; set; } = fontSize; /// /// If Line Input is Secret /// [UsedImplicitly] public bool Secret { get; set; } = secret; /// /// Event trigger when the value is changed /// [UsedImplicitly] public event EventHandler>? ValueChanged; /// /// Invoke ValueChanged Event /// /// Event Args protected void InvokeValueChanged(ValueEventArgs args) => ValueChanged?.Invoke(this, args); /// public override void Update(float delta) { if (!RealDisplayed || !Active) { Focused = false; return; } if (InputManager.IsMouseButtonPressed(MouseButton.Left)) Focused = InputManager.IsMouseInRectangle(new Rect(RealPosition - Size / 2, Size)); if (!Focused) return; #region Text Processing if (InputManager.IsKeyPressed(Key.Backspace) && Text.Length >= 1) { var old = Text; Text = Text[..^1]; ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = old, NewValue = Text } ); } var finalFont = Scene?.Window?.FontManager.GetFont(Font); if (finalFont != null) { foreach (var pressedChar in InputManager.GetPressedChars()) { if ( char.IsSymbol(pressedChar) || char.IsWhiteSpace(pressedChar) || char.IsLetterOrDigit(pressedChar) || char.IsPunctuation(pressedChar) ) { Text += pressedChar; ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = Text, NewValue = Text[..^1] } ); } } } #endregion } /// public override void Draw() { base.Draw(); if (!Displayed || Scene == null) return; SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, 0, Color.Black, InstructionSource.Ui, ZLayer ); SERender.DrawRectangle( new Rect(RealPosition.X + 2, RealPosition.Y + 2, Size.X - 4, Size.Y - 4), Size / 2, 0, Color.White, InstructionSource.Ui, ZLayer + 0.00001f ); var finalFont = Scene?.Window?.FontManager.GetFont(Font); if (Font.Length <= 0 || finalFont == null) return; var text = Secret ? new string('*', Text.Length) : Text; var finalFontSize = FontSize ?? finalFont.Value.BaseSize; var textSize = Raylib.MeasureTextEx(finalFont.Value, text, finalFontSize, 2); var offset = textSize.X - (Size.X - 20); if (text.Length > 0) { var finalPosition = new Vec2(RealPosition.X - Size.X / 2 + 4, RealPosition.Y - textSize.Y / 2); SERender.ScissorMode( finalPosition.X, finalPosition.Y, Size.X - 8, textSize.Y, InstructionSource.Ui, ZLayer + 0.00002f, () => { SERender.DrawText( finalFont.Value, text, new Vec2(finalPosition.X - (offset > 0 ? offset : 0), finalPosition.Y), finalFontSize, 2, Color.Black, InstructionSource.Ui, 0 ); } ); } if (!Focused) return; var potentielSize = Raylib.MeasureTextEx(finalFont.Value, "A", finalFontSize, 2); SERender.DrawRectangle( (RealPosition.X - Size.X / 2 + 10 + textSize.X - (offset > 0 ? offset : 0)), (RealPosition.Y - potentielSize.Y / 2 + 2), 5, potentielSize.Y - 4, Color.Black, InstructionSource.Ui, ZLayer + 0.00003f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/MultiLineInput.cs000066400000000000000000000106351514307377300244160ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils.EventArgs; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Widget; /// /// Class which represents Multi Line Input /// /// Multi Line Edit Position /// Multi Line Edit Text ("") /// Multi Line Edit Font ("") /// Multi Line Edit Size (Vec2(500, 200)) /// Multi Line Edit Font Size (null) /// If Multi Line Edit is Secret (false) /// Z Layer [UsedImplicitly] public class MultiLineInput( Vec2 position, string text = "", string font = "", Vec2? size = null, int? fontSize = null, bool secret = false, int zLayer = 0 ) : LineInput(position, text, font, size, fontSize, secret, zLayer) { /// public override void Update(float delta) { base.Update(delta); #region Text Processing if (InputManager.IsKeyPressed(Key.Enter)) { Text += '\n'; InvokeValueChanged(new ValueEventArgs { OldValue = Text[..^1], NewValue = Text }); } #endregion } /// public override void Draw() { if (!Displayed) return; foreach (var child in Children) child.Draw(); if (Scene == null) return; SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, 0, Color.Black, InstructionSource.Ui, ZLayer ); SERender.DrawRectangle( new Rect(RealPosition.X + 2, RealPosition.Y + 2, Size.X - 4, Size.Y - 4), Size / 2, 0, Color.White, InstructionSource.Ui, ZLayer + 0.00001f ); var finalFont = Scene?.Window?.FontManager.GetFont(Font); if (Font.Length <= 0 || finalFont == null) return; var finalFontSize = FontSize ?? finalFont.Value.BaseSize; var textSize = Raylib.MeasureTextEx(finalFont.Value, Text.Split("\n")[^1], finalFontSize, 2); var realTextSize = Raylib.MeasureTextEx(finalFont.Value, "A", finalFontSize, 2); var finalPosition = new Vec2(RealPosition.X - Size.X / 2 + 4, RealPosition.Y - Size.Y / 2 + 4); var lines = Text.Split("\n"); var offsetX = textSize.X - (Size.X - 20); var offsetY = realTextSize.Y * lines.Length - (Size.Y - 8); SERender.ScissorMode( finalPosition.X, finalPosition.Y, Size.X - 8, Size.Y - 8, InstructionSource.Ui, ZLayer + 0.00002f, () => { DrawLines(finalFont.Value, finalFontSize, finalPosition, lines, offsetX, offsetY); if (Focused) { SERender.DrawRectangle( finalPosition.X + 6 + textSize.X - (offsetX > 0 ? offsetX : 0), finalPosition.Y + realTextSize.Y * (lines.Length == 0 ? 1 : lines.Length - 1) - (offsetY > 0 ? offsetY : 0), 5, realTextSize.Y, Color.Black, InstructionSource.Ui, ZLayer + 0.00003f ); } } ); } private void DrawLines(Font finalFont, int finalFontSize, Vec2 finalPosition, string[] lines, float offsetX, float offsetY) { for (var i = 0; i < lines.Length; i++) { var text = Secret ? new string('*', lines[i].Length) : lines[i]; var lineSize = Raylib.MeasureTextEx(finalFont, text, finalFontSize, 2); var pos = new Vec2( finalPosition.X - (offsetX > 0 ? offsetX : 0), finalPosition.Y + i * lineSize.Y - (offsetY > 0 ? offsetY : 0) ); SERender.DrawText( finalFont, text, pos, finalFontSize, 2, Color.Black, InstructionSource.Ui, 0 ); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/ProgressBar.cs000066400000000000000000000046471514307377300237330ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Class which represents ProgressBar /// public class ProgressBar : Widget { /// /// Value of Bar (0 to 100) /// [UsedImplicitly] public float Value { get; set => field = MathHelper.Clamp(value, 0, 100); } /// /// Size of Bar /// [UsedImplicitly] public Vec2 Size { get; set; } /// /// Color of Bar /// [UsedImplicitly] public Color Color { get; set; } /// /// If Bar is Horizontal /// [UsedImplicitly] public bool Horizontal { get; set; } /// /// Create a ProgressBar /// /// Position /// Size (Vec2(150, 60)) /// Color (Color.Green) /// Value (0) /// Horizontal (true) /// ZLayer (0) public ProgressBar( Vec2 position, Vec2? size = null, Color? color = null, float value = 0, bool horizontal = true, int zLayer = 0 ) : base(position, zLayer) { Size = size ?? new Vec2(150, 60); Color = color ?? Color.Green; Value = value; Horizontal = horizontal; } /// public override void Draw() { base.Draw(); if (!Displayed || Size == Vec2.Zero) return; SERender.DrawRectangle( new Rect(RealPosition, Size), Size / 2, 0, Color.Black, InstructionSource.Ui, ZLayer ); SERender.DrawRectangle( new Rect(RealPosition, Size - 4), (Size - 4) / 2, 0, Color.White, InstructionSource.Ui, ZLayer + 0.00001f ); SERender.DrawRectangle( Horizontal ? new Rect(RealPosition, (Size.X - 8) * Value / 100, Size.Y - 8) : new Rect(RealPosition, Size.X - 8, (Size.Y - 8) * Value / 100), (Size - 8) / 2, 0, Color, InstructionSource.Ui, ZLayer + 0.00002f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/ScrollFrame.cs000066400000000000000000000060521514307377300237030ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Class which represents Scroll Frame /// /// Scroll Frame Position /// Scroll Frame Size /// Scroll Frame Scroll Frame (5) /// Scroll Frame Border Size (3) /// Scroll Frame Border Color (Color.Black) /// Scroll Frame Background Color (null) /// Z Layer [UsedImplicitly] public class ScrollFrame( Vec2 position, Vec2 size, int scrollFactor = 5, int borderSize = 3, Color? borderColor = null, Color? backgroundColor = null, int zLayer = 0 ) : Widget(position, zLayer) { /// /// Color of Scroll Frame Border /// [UsedImplicitly] public Color BorderColor { get; set; } = borderColor ?? Color.Black; /// /// Size of Scroll Frame /// [UsedImplicitly] public Vec2 Size { get; set; } = size; /// /// Size of Scroll Frame Border /// [UsedImplicitly] public int BorderSize { get; set; } = borderSize; /// /// Color of Scroll Frame Background /// [UsedImplicitly] public Color? BackgroundColor { get; set; } = backgroundColor; /// /// Scroll Factor of Scroll Frame /// [UsedImplicitly] public int ScrollFactor { get; set; } = scrollFactor; /// public override void Update(float delta) { base.Update(delta); if(!RealDisplayed) return; var move = InputManager.GetMouseWheelMove(); if (move == 0) return; foreach (var child in Children) child.Position = new Vec2(child.Position.X, child.Position.Y + move * ScrollFactor); } /// public override void Draw() { if (!Displayed || Scene == null) return; if (BackgroundColor != null) SERender.DrawRectangle( new Rect(RealPosition.X, RealPosition.Y, Size.X, Size.Y), Size / 2, 0, BackgroundColor.Value, InstructionSource.Ui, ZLayer ); SERender.DrawRectangleLines( new Rect(RealPosition.X - Size.X / 2, RealPosition.Y - Size.Y / 2, Size.X, Size.Y), BorderSize, BorderColor, InstructionSource.Ui, ZLayer + 0.00001f ); SERender.ScissorMode( (RealPosition.X - Size.X / 2), (RealPosition.Y - Size.Y / 2), Size.X, Size.Y, InstructionSource.Ui, ZLayer + 0.00002f, () => { base.Draw(); } ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Selector.cs000066400000000000000000000103711514307377300232510ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Utils.EventArgs; namespace SharpEngine.Core.Widget; /// /// Class, which display a selector /// [UsedImplicitly] public class Selector : Widget { /// /// Values of Selector /// [UsedImplicitly] public List Values { get; } /// /// Selected Index of Selector /// [UsedImplicitly] public int SelectedIndex { get; set; } /// /// Left Button of Selector /// [UsedImplicitly] public Button LeftButton { get; } /// /// Right Button of Selector /// [UsedImplicitly] public Button RightButton { get; } /// /// Label of Selector /// [UsedImplicitly] public Label LabelValue { get; } /// /// Font of Selector /// [UsedImplicitly] public string Font { get; set; } /// /// Font Size of Selector /// [UsedImplicitly] public int? FontSize { get; set; } /// /// Event trigger when the value is changed /// [UsedImplicitly] public event EventHandler>? ValueChanged; /// /// Selected Value /// [UsedImplicitly] public string Selected => Values[SelectedIndex]; /// /// Create Selector /// /// Position /// Values of Selector /// Font of Selector /// Current Index of Selector /// Font Size of Selector /// Z Layer public Selector( Vec2 position, List? values = null, string font = "", int currentIndex = 0, int? fontSize = null, int zLayer = 0 ) : base(position, zLayer) { Values = values ?? []; SelectedIndex = currentIndex; Font = font; FontSize = fontSize; LabelValue = new Label(Vec2.Zero, Selected, font, fontSize: fontSize, zLayer: zLayer); LeftButton = new Button( Vec2.Zero, "<", font, new Vec2(30), fontSize: fontSize, zLayer: zLayer ); RightButton = new Button( Vec2.Zero, ">", font, new Vec2(30), fontSize: fontSize, zLayer: zLayer ); AddChild(LabelValue); AddChild(LeftButton).Clicked += LeftButtonClick; AddChild(RightButton).Clicked += RightButtonClick; } private void LeftButtonClick(object? sender, EventArgs e) { var old = Selected; if (SelectedIndex == 0) SelectedIndex = Values.Count - 1; else SelectedIndex--; LabelValue.Text = Selected; ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = old, NewValue = Selected } ); } private void RightButtonClick(object? sender, EventArgs e) { var old = Selected; if (SelectedIndex == Values.Count - 1) SelectedIndex = 0; else SelectedIndex++; LabelValue.Text = Selected; ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = old, NewValue = Selected } ); } /// public override void Load() { base.Load(); var font = Scene?.Window?.FontManager.GetFont(Font); if (font != null) { var fontSize = FontSize ?? font.Value.BaseSize; var maxSizeX = 0f; foreach (var value in Values) { var size = Raylib.MeasureTextEx(font.Value, value, fontSize, 2); if (maxSizeX < size.X) maxSizeX = size.X; } LeftButton.Position = new Vec2(-maxSizeX / 2 - 30, 0); RightButton.Position = new Vec2(maxSizeX / 2 + 30, 0); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Slider.cs000066400000000000000000000035671514307377300227240ustar00rootroot00000000000000using System; using JetBrains.Annotations; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using SharpEngine.Core.Utils.EventArgs; namespace SharpEngine.Core.Widget; /// /// Class which represents Slider /// /// Position /// Size (Vec2(150, 60)) /// Color (Color.Green) /// Value (0) /// Horizontal (true) /// ZLayer (0) [UsedImplicitly] public class Slider( Vec2 position, Vec2? size = null, Color? color = null, float value = 0, bool horizontal = true, int zLayer = 0 ) : ProgressBar(position, size, color, value, horizontal, zLayer) { /// /// Event trigger when the value is changed /// [UsedImplicitly] public event EventHandler>? ValueChanged; /// public override void Update(float delta) { base.Update(delta); if (!RealDisplayed || !InputManager.IsMouseButtonDown(MouseButton.Left)) return; var finalPosition = RealPosition - Size / 2; if (!InputManager.IsMouseInRectangle(new Rect(finalPosition, Size))) return; var barSize = Horizontal ? Size.X : Size.Y; var point = Horizontal ? InputManager.GetMousePosition().X - finalPosition.X : InputManager.GetMousePosition().Y - finalPosition.Y; var temp = Value; Value = (int)System.Math.Round(point * 100 / barSize, MidpointRounding.AwayFromZero); if (System.Math.Abs(temp - Value) > 0.001f) { ValueChanged?.Invoke( this, new ValueEventArgs { OldValue = temp, NewValue = Value } ); } } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/TextureButton.cs000066400000000000000000000072451514307377300243330ustar00rootroot00000000000000using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core.Widget; /// /// Class which display Texture Button /// /// Texture Button Position /// Texture Button Text /// Texture Button Font /// Texture Button Texture /// Texture Button Size /// Texture Button Font Color /// Texture Button Font Size /// Z Layer [UsedImplicitly] public class TextureButton( Vec2 position, string texture = "", string text = "", string font = "RAYLIB_DEFAULT", Vec2? size = null, Color? fontColor = null, int? fontSize = null, int zLayer = 0 ) : Button(position, text, font, size, fontColor, null, fontSize, zLayer) { /// /// Texture of Texture Button /// [UsedImplicitly] public string Texture { get; set; } = texture; /// public override void Update(float delta) { if (Size == Vec2.Zero) { var finalTexture = Scene?.Window?.TextureManager.GetTexture(Texture); if (finalTexture != null) Size = new Vec2(finalTexture.Value.Width, finalTexture.Value.Height); } base.Update(delta); } /// public override void Draw() { if (!Displayed) return; foreach (var child in Children) child.Draw(); var finalFont = Scene?.Window?.FontManager.GetFont(Font); var finalTexture = Scene?.Window?.TextureManager.GetTexture(Texture); if (Size == Vec2.Zero && finalTexture != null) Size = new Vec2(finalTexture.Value.Width, finalTexture.Value.Height); if ( Scene == null || Font.Length <= 0 || finalFont == null || finalTexture == null ) return; if (State == ButtonState.Hover && Active) SERender.DrawRectangle( (RealPosition.X - (Size.X + 4) / 2), (RealPosition.Y - (Size.Y + 4) / 2), (Size.X + 4), (Size.Y + 4), Color.White, InstructionSource.Ui, ZLayer ); SERender.DrawTexture( finalTexture.Value, new Rect(0, 0, finalTexture.Value.Width, finalTexture.Value.Height), new Rect(RealPosition.X + 2, RealPosition.Y + 2, Size.X - 4, Size.Y - 4), Size / 2, 0, Color.White, InstructionSource.Ui, ZLayer + 0.00002f ); var finalFontSize = FontSize ?? finalFont.Value.BaseSize; var textSize = Raylib.MeasureTextEx(finalFont.Value, Text, finalFontSize, 2); if(Text.Length > 0) SERender.DrawText( finalFont.Value, Text, RealPosition, textSize / 2, 0, finalFontSize, 2, FontColor, InstructionSource.Ui, ZLayer + 0.00003f ); if (State == ButtonState.Down || !Active) SERender.DrawRectangle( (RealPosition.X - Size.X / 2), (RealPosition.Y - Size.Y / 2), Size.X, Size.Y, new Color(0, 0, 0, 128), InstructionSource.Ui, ZLayer + 0.00004f ); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Utils/000077500000000000000000000000001514307377300222405ustar00rootroot00000000000000SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Utils/LabelStyles.cs000066400000000000000000000005631514307377300250160ustar00rootroot00000000000000using System; namespace SharpEngine.Core.Widget.Utils; /// /// Style for Label /// [Flags] public enum LabelStyles { /// /// None Style /// None = 0, /// /// Underline Style /// Underline = 1, /// /// Strike Style /// Strike = 2, } SharpEngine.Core-2.5.1/SharpEngine.Core/Widget/Widget.cs000066400000000000000000000121001514307377300227040ustar00rootroot00000000000000using System.Collections.Generic; using System.Linq; using JetBrains.Annotations; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; namespace SharpEngine.Core.Widget; /// /// Abstract Class which represents Widget /// public abstract class Widget { /// /// Position of Widget /// public Vec2 Position { get; set; } /// /// Z Layer of Widget /// [UsedImplicitly] public int ZLayer { get; set; } /// /// If Widget is Displayed /// [UsedImplicitly] public bool Displayed { get; set; } = true; /// /// If Widget is Active /// [UsedImplicitly] public bool Active { get; set; } = true; /// /// Parent of Widget (can be null) /// [UsedImplicitly] public Widget? Parent { get; set; } /// /// How Widget must be updated when paused /// [UsedImplicitly] public PauseState PauseState { get; set; } = PauseState.Normal; /// /// Name of Widget /// [UsedImplicitly] public string Name { get; set; } = ""; /// /// Get Real Position (Position + Parent RealPosition if widget has Parent) /// [UsedImplicitly] public Vec2 RealPosition => Parent != null ? Position + Parent.RealPosition : Position; /// /// If Widget is really displayed (considering parent's display state) /// [UsedImplicitly] public bool RealDisplayed => Displayed && (Parent == null || Parent.RealDisplayed); /// /// Get All Direct Children of Widget /// [UsedImplicitly] public List Children { get; } = []; /// /// Scene of Widget /// public Scene? Scene { get => _scene; set { _scene = value; foreach (var child in Children) child.Scene = value; } } private Scene? _scene; /// /// Initializes a new instance of the class. /// /// The position of the widget. /// The Z layer of the widget. protected Widget(Vec2 position, int zLayer = 0) { Position = position; ZLayer = zLayer; } /// /// Get All Direct Children of one Type /// /// Type of Children /// Children of type T [UsedImplicitly] public List GetChildrenAs() where T : Widget => Children.FindAll(w => w.GetType() == typeof(T)).Cast().ToList(); /// /// Get All Recursive Children /// /// All Children public List GetAllChildren() { var children = new List(Children); foreach (var child in Children) children.AddRange(child.GetAllChildren()); return children; } /// /// Get Scene as T /// /// Scene Type /// Scene cast as T [UsedImplicitly] public T? GetSceneAs() where T : Scene => (T?)Scene; /// /// Add Child and return it /// /// Widget, which will be added /// Type of Widget /// Child [UsedImplicitly] public T AddChild(T widget) where T : Widget { if (_scene != null) widget.Scene = _scene; widget.Parent = this; Children.Add(widget); return widget; } /// /// Remove Child /// /// Child that will be removed [UsedImplicitly] public void RemoveChild(Widget widget) { widget.Scene = null; Children.Remove(widget); } /// /// Remove All Children /// [UsedImplicitly] public void RemoveAllChildren() { foreach (var child in Children) child.Scene = null; Children.Clear(); } /// /// Load Widget /// public virtual void Load() { foreach (var child in Children) child.Load(); } /// /// Unload Widget /// [UsedImplicitly] public virtual void Unload() { foreach (var child in Children) child.Unload(); } /// /// Update Widget /// /// Time since last frame [UsedImplicitly] public virtual void Update(float delta) { foreach (var child in Children) child.Update(delta); } /// /// Draw Widget /// public virtual void Draw() { if (!Displayed) return; foreach (var child in Children) child.Draw(); } } SharpEngine.Core-2.5.1/SharpEngine.Core/Window.cs000066400000000000000000000406161514307377300215220ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using ImGuiNET; using JetBrains.Annotations; using Raylib_cs; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; using SharpEngine.Core.Utils.EventArgs; using SharpEngine.Core.Utils.SeImGui; using Color = SharpEngine.Core.Utils.Color; namespace SharpEngine.Core; /// /// Class which represents and create Window /// public class Window { /// /// Title of Window /// public string Title { get => _title; set { _title = value; Raylib.SetWindowTitle(value); } } /// /// Size of Window /// public Vec2 ScreenSize { get => _screenSize; set { _screenSize = value; Raylib.SetWindowSize((int)value.X, (int)value.Y); RenderScale = MathF.Min(_screenSize.X / _renderSize.X, _screenSize.Y / _renderSize.Y); } } /// /// Size of Render /// public Vec2 RenderSize { get => _renderSize; set { _renderSize = value; UpdateRenderSize(); } } /// /// Position of Window /// [UsedImplicitly] public static Vec2 Position { get => Raylib.GetWindowPosition(); set => Raylib.SetWindowPosition((int)value.X, (int)value.Y); } /// /// Background Color used in Window /// [UsedImplicitly] public Color BackgroundColor { get; set; } /// /// Event which be called in Start of Window (can be canceled by set result to false) /// [UsedImplicitly] public event EventHandler? StartCallback; /// /// Event which be called in Stop of Window (can be canceled by set result to false) /// [UsedImplicitly] public event EventHandler? StopCallback; /// /// Function which be called to render something in ImGui /// [UsedImplicitly] public Action? RenderImGui { get; set; } /// /// Manage Debug Mode of Window /// [UsedImplicitly] public bool Debug { get; set { field = value; DebugManager.SetLogLevel(value ? LogLevel.All : LogLevel.Info); } } /// /// Camera Manager of Window /// public CameraManager CameraManager { get; } /// /// Texture Manager of Window /// public TextureManager TextureManager { get; } /// /// Shader Manager of Window /// public ShaderManager ShaderManager { get; } /// /// Font Manager of Window /// public FontManager FontManager { get; } /// /// Sound Manager of Window /// public SoundManager SoundManager { get; } /// /// Music Manager of Window /// public MusicManager MusicManager { get; } /// ///Timer Manager of Window /// public TimerManager TimerManager { get; } /// /// Tween Manager of Window /// public TweenManager TweenManager { get; } /// /// ImGui Management of Window /// [UsedImplicitly] public SeImGui SeImGui { get; } /// /// Scale of Render /// public float RenderScale { get; private set; } /// /// Index of Current Scene /// public int IndexCurrentScene { get => _internalIndexCurrentScene; set { if (_internalIndexCurrentScene != -1) Scenes[_internalIndexCurrentScene].CloseScene(); _internalIndexCurrentScene = value; Scenes[_internalIndexCurrentScene].OpenScene(); } } /// /// Current Scene /// public Scene CurrentScene { get => Scenes[_internalIndexCurrentScene]; set { if (_internalIndexCurrentScene != 1) Scenes[_internalIndexCurrentScene].CloseScene(); _internalIndexCurrentScene = Scenes.IndexOf(value); Scenes[_internalIndexCurrentScene].OpenScene(); } } /// /// Get All Scenes /// public List Scenes { get; } = []; private Vec2 _screenSize; private Vec2 _renderSize; private string _title; private bool _closeWindow; private int _internalIndexCurrentScene = -1; private readonly RenderTexture2D _targetTexture; internal bool ImguiDisplayWindow = false; internal bool ImguiDisplayConsole = false; private static bool ConsoleLog { get; set; } = true; private static bool FileLog { get; set; } /// /// Create and Init Window /// /// Width of Window /// Height of Window /// Title of Window /// Background Color of Window (Black) /// Number of FPS (60) /// Debug Mode (false) /// Log in Console /// Log in File (log.txt) /// Redirect Logs public Window( int width, int height, string title, Color? backgroundColor = null, int? fps = 60, bool debug = false, bool consoleLog = true, bool fileLog = false, bool redirectLogs = true ) : this(new Vec2(width, height), title, backgroundColor, fps, debug, consoleLog, fileLog, redirectLogs) { } /// /// Create and Init Window /// /// Size of Window /// Title of Window /// Background Color of Window (Black) /// Number of FPS (60) /// Debug Mode (false) /// Log in Console /// Log in File (log.txt) /// Redirect Logs public Window( Vec2 screenSize, string title, Color? backgroundColor = null, int? fps = 60, bool debug = false, bool consoleLog = true, bool fileLog = false, bool redirectLogs = true ) { InputManager.InternalWindow = this; RenderImGui = DebugManager.SeRenderImGui; ConsoleLog = consoleLog; FileLog = fileLog; _title = title; _screenSize = screenSize; _renderSize = screenSize; BackgroundColor = backgroundColor ?? Color.Black; Debug = debug; if (FileLog && File.Exists("log.txt")) File.Delete("log.txt"); if (redirectLogs) { unsafe { Raylib.SetTraceLogCallback(&LogCustom); } } Raylib.InitWindow((int)screenSize.X, (int)screenSize.Y, title); Raylib.InitAudioDevice(); SeImGui = new SeImGui(); SeImGui.Load((int)screenSize.X, (int)screenSize.Y); TextureManager = new TextureManager(); ShaderManager = new ShaderManager(); FontManager = new FontManager(); CameraManager = new CameraManager(); SoundManager = new SoundManager(); MusicManager = new MusicManager(); TimerManager = new TimerManager(); TweenManager = new TweenManager(); CameraManager.SetScreenSize(screenSize); if (fps != null) Raylib.SetTargetFPS(fps.Value); _targetTexture = Raylib.LoadRenderTexture((int)screenSize.X, (int)screenSize.Y); RenderScale = MathF.Min(_screenSize.X / _renderSize.X, _screenSize.Y / _renderSize.Y); } /// /// Take a screenshot and save it /// /// Path of saved screenshot [UsedImplicitly] public static void TakeScreenshot(string path) => Raylib.TakeScreenshot(path); /// /// Open URL in default browser /// /// Url [UsedImplicitly] public static void OpenUrl(string url) { try { Process.Start(url); } catch { try { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { url = url.Replace("&", "^&"); Process.Start(new ProcessStartInfo(url) { UseShellExecute = true }); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Process.Start("xdg-open", url); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Process.Start("open", url); } } catch (Exception ex) { DebugManager.Log(LogLevel.Error, $"SE: Failed to open URL {url} - {ex.Message}"); } } } /// /// Set master volume /// /// Volume (0 to 1) [UsedImplicitly] public static void SetMasterVolume(float volume) => Raylib.SetMasterVolume(volume); /// /// Set Icon of Window /// /// Image Path [UsedImplicitly] public static void SetIcon(string path) { var icon = Raylib.LoadImage(path); Raylib.SetWindowIcon(icon); Raylib.UnloadImage(icon); } /// /// Add Scene to Window and Set Current Scene to it /// /// Scene which be added public void AddScene(Scene scene) { scene.Window = this; Scenes.Add(scene); _internalIndexCurrentScene = Scenes.Count - 1; } /// /// Get Scene by Index /// /// Index of Scene /// Scene [UsedImplicitly] public Scene GetScene(int index) => Scenes[index]; /// /// Get Scene cast as T /// /// Index of Scene /// Type as Scene /// Scene cast as T [UsedImplicitly] public T GetScene(int index) where T : Scene => (T)Scenes[index]; /// /// Get Current Scene cast as T /// /// Type as Scene /// Current Scene cast as T [UsedImplicitly] public T GetCurrentScene() where T : Scene => (T)Scenes[_internalIndexCurrentScene]; /// /// Run Window /// public void Run() { var args = new BoolEventArgs(); StartCallback?.Invoke(this, args); if (!args.Result) return; if (Scenes.Count == 0) { DebugManager.Log(LogLevel.Error, "SE: There are no scenes in window."); return; } #region Load DebugManager.Log(LogLevel.Info, "SE: Loading Scenes..."); foreach (var scene in Scenes) scene.Load(); DebugManager.Log(LogLevel.Info, "SE: Scenes loaded !"); #endregion CurrentScene.OpenScene(); var firstFrame = true; while (!Raylib.WindowShouldClose() && !_closeWindow) { #region Update Input and ScreenSize InputManager.UpdateInput(); if (System.Math.Abs(_screenSize.X - Raylib.GetScreenWidth()) > 0.01f || System.Math.Abs(_screenSize.Y - Raylib.GetScreenHeight()) > 0.01f) { _screenSize = new Vec2(Raylib.GetScreenWidth(), Raylib.GetScreenHeight()); RenderScale = MathF.Min(_screenSize.X / _renderSize.X, _screenSize.Y / _renderSize.Y); } #endregion #region Update var delta = Raylib.GetFrameTime(); // This is a hack to fix ImGui assertions on the first frame if (firstFrame) { delta = 0.000001f; ImGui.Render(); firstFrame = false; } SeImGui.Update(delta); CurrentScene.Update(delta); CameraManager.Update(delta); TimerManager.Update(delta); TweenManager.Update(delta); #endregion #region Draw if (Debug) RenderImGui?.Invoke(this); CurrentScene.Draw(); { Raylib.BeginTextureMode(_targetTexture); Raylib.ClearBackground(BackgroundColor); SERender.Draw(this); if (Debug) SeImGui.Draw(); Raylib.EndTextureMode(); } { Raylib.BeginDrawing(); Raylib.ClearBackground(Color.Black); var dest = new Rectangle( (_screenSize.X - (_renderSize.X * RenderScale)) * 0.5f, (_screenSize.Y - (_renderSize.Y * RenderScale)) * 0.5f, _renderSize.X * RenderScale, _renderSize.Y * RenderScale ); Raylib.DrawTexturePro(_targetTexture.Texture, new Rectangle(0, 0, _targetTexture.Texture.Width, -_targetTexture.Texture.Height), dest, new Vector2(0, 0), 0, Color.White); Raylib.EndDrawing(); } #endregion } #region Unload DebugManager.Log(LogLevel.Info, "SE: Unloading Scenes..."); foreach (var scene in Scenes) scene.Unload(); DebugManager.Log(LogLevel.Info, "SE: Scenes unloaded !"); DebugManager.Log(LogLevel.Info, "SE: Unloading Textures..."); Raylib.UnloadRenderTexture(_targetTexture); TextureManager.Unload(); DebugManager.Log(LogLevel.Info, "SE: Textures unloaded !"); DebugManager.Log(LogLevel.Info, "SE: Unloading Fonts..."); FontManager.Unload(); DebugManager.Log(LogLevel.Info, "SE: Fonts unloaded !"); DebugManager.Log(LogLevel.Info, "SE: Unloading Shaders..."); ShaderManager.Unload(); DebugManager.Log(LogLevel.Info, "SE: Shaders unloaded !"); DebugManager.Log(LogLevel.Info, "SE: Unloading SeImGui..."); SeImGui.Dispose(); DebugManager.Log(LogLevel.Info, "SE: SeImGui unloaded !"); DebugManager.Log(LogLevel.Info, "SE: Closing Window."); Raylib.CloseAudioDevice(); Raylib.CloseWindow(); #endregion } /// /// Stop Window /// public void Stop() { var args = new BoolEventArgs(); StopCallback?.Invoke(this, args); if (args.Result) _closeWindow = true; } private void UpdateRenderSize() { CameraManager.SetScreenSize(_renderSize); SeImGui.Resize((int)_renderSize.X, (int)_renderSize.Y); RenderScale = MathF.Min(_screenSize.X / _renderSize.X, _screenSize.Y / _renderSize.Y); } [UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])] private static unsafe void LogCustom(int logLevel, sbyte* text, sbyte* args) { var message = Logging.GetLogMessage(new IntPtr(text), new IntPtr(args)); message = (LogLevel)logLevel switch { LogLevel.Trace => $"TRACE: {message}", LogLevel.All => $"ALL: {message}", LogLevel.Debug => $"DEBUG: {message}", LogLevel.Info => $"INFO: {message}", LogLevel.Warning => $"WARNING: {message}", LogLevel.Error => $"ERROR: {message}", LogLevel.Fatal => $"FATAL: {message}", _ => message }; message = $"{DateTime.Now:dd/MM/yyyy HH:mm:ss} - {message}"; if (ConsoleLog) Console.WriteLine(message); if (FileLog) File.AppendAllText("log.txt", message + "\n"); } } SharpEngine.Core-2.5.1/Testing/000077500000000000000000000000001514307377300162405ustar00rootroot00000000000000SharpEngine.Core-2.5.1/Testing/MyScene.cs000066400000000000000000000054071514307377300201400ustar00rootroot00000000000000using SharpEngine.Core; using SharpEngine.Core.Component; using SharpEngine.Core.Entity; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using SharpEngine.Core.Utils.Tween; namespace Testing; public class MyScene : Scene { public MyScene() { var e = new Entity(); e.AddComponent(new TransformComponent(Vec2.Zero, new Vec2(2))); e.AddComponent(new RectComponent(Color.AliceBlue, new Vec2(50))); e.AddComponent(new ControlComponent()); e.AddComponent(new CollisionComponent(new Vec2(50), drawDebug: true)); AddEntity(e); var en = new Entity(); en.AddComponent(new TransformComponent(new Vec2(100, 0), Vec2.One)); en.AddComponent(new RectComponent(Color.AliceBlue, new Vec2(50))); en.AddComponent(new CollisionComponent(new Vec2(50), drawDebug: true)); AddEntity(en); var e2 = new Entity(); e2.AddComponent(new TransformComponent(new Vec2(300), Vec2.One)); e2.AddComponent(new RectComponent(Color.Gray, new Vec2(100))); e2.AddComponent(new CollisionComponent(new Vec2(25), new Vec2(-25), drawDebug: true)); e2.AddComponent(new CollisionComponent(new Vec2(25), new Vec2(25), drawDebug: true)); e2.AddComponent(new CollisionComponent(new Vec2(25), new Vec2(-25, 25), drawDebug: true)); e2.AddComponent(new CollisionComponent(new Vec2(25), new Vec2(25, -25), drawDebug: true)); AddEntity(e2); var e3 = new Entity(); e3.AddComponent(new TransformComponent(new Vec2(800, 300), Vec2.One)); e3.AddComponent(new RectComponent(Color.AliceBlue, new Vec2(50))); e3.AddComponent(new AutoComponent(new Vec2(-20, 0))); e3.AddComponent(new CollisionComponent(new Vec2(50), drawDebug: true)); AddEntity(e3); } public override void OpenScene() { base.OpenScene(); Window?.TweenManager.Tweens.Add(new Tween([ new TweenStep(5) .Float(Entities[0].GetComponentAs()!, x => ((TransformComponent)x).LocalRotation, 360, 5) .Float(Entities[0].GetComponentAs()!.LocalPosition, x => ((Vec2)x).X, 100, 5) .Float(Entities[0].GetComponentAs()!.LocalPosition, x => ((Vec2)x).Y, 100, 5), new TweenStep(10) .Float(Entities[0].GetComponentAs()!, x => ((TransformComponent)x).LocalRotation, 720, 5) .Float(Entities[0].GetComponentAs()!.LocalPosition, x => ((Vec2)x).X, 0, 5) .Float(Entities[0].GetComponentAs()!.LocalPosition, x => ((Vec2)x).Y, 0, 5), ], () => DebugManager.Log(LogLevel.Info, "FIN DU TWEEN"))); } } SharpEngine.Core-2.5.1/Testing/Program.cs000066400000000000000000000012701514307377300201760ustar00rootroot00000000000000using Raylib_cs; using SharpEngine.Core; using SharpEngine.Core.Manager; using Color = SharpEngine.Core.Utils.Color; namespace Testing; internal static class Program { private static void Main() { Raylib.SetConfigFlags(ConfigFlags.ResizableWindow); var window = new Window( 1280, 920, "SE Raylib", Color.CornflowerBlue, null, true, true, true ); window.TextureManager.AddTexture("portal", "resources/portal.png"); window.AddScene(new MyScene()); DebugManager.AddConsoleCommand(new TestConsoleCommand()); window.Run(); } } SharpEngine.Core-2.5.1/Testing/TestConsoleCommand.cs000066400000000000000000000011331514307377300223260ustar00rootroot00000000000000using SharpEngine.Core; using SharpEngine.Core.Utils.SeImGui; using SharpEngine.Core.Utils.SeImGui.ConsoleCommand; namespace Testing { internal class TestConsoleCommand : ISeImGuiConsoleCommand { public string Command => "test"; public void Process(string[] args, SeImGuiConsole console, Window window) { DebugVarCommand.CustomVariables.TryAdd("testvar", 0); DebugVarCommand.CustomVariables["testvar"] = (int)DebugVarCommand.CustomVariables["testvar"] + 1; console.AddText(window.IndexCurrentScene.ToString()); } } } SharpEngine.Core-2.5.1/Testing/Testing.csproj000066400000000000000000000013271514307377300211020ustar00rootroot00000000000000 Exe net10.0 enable enable Always Always Always SharpEngine.Core-2.5.1/Testing/resources/000077500000000000000000000000001514307377300202525ustar00rootroot00000000000000SharpEngine.Core-2.5.1/Testing/resources/portal.png000066400000000000000000001032451514307377300222660ustar00rootroot00000000000000PNG  IHDR lC IDATxoם/oy "殷*d9;!DKmC`F4i]Ip/!X4m5f($MEM`t^GF%woe^bv ó/UNs|? ,os~%AM@nhe"`}p9q%\%J񃚤?Ίp!~aNj6t_d?ĝ@%N țmcl?銈Eڼґ@uV42+VҔ[>\""*.u= :g/TUoufr&pSnN_k^M|>탲b~hkm. XYm.^o?] k u>0⡬'uneTSyU.UҶ5=fM}OQ9ԱMr ~- "e7&5:&!zg.|љmQGǪ8UUBY,4reddh4}نB{J=n.$%RK_or6޿p 2v>CS߻``&5 QsɚZf9_EŮ2dLI׵| ImLߗ_E ]]LxmT$7 ~^TDz ~Jn/5|wWco1yx} `ꏲHOHS?-tg_(gW cWH.iE>?j /|mjnU9x&(Z\} @3d@/+ Qߐ)t(U٨+視L˭ȬSIU,:ܺڊvtߊd(6>`w{hIHqN>ڮ;ҩPdWGסN>3NMBX<l @T'o_kY;(\XmCLVulIVۘ<#9K1|Ie,Ҷ Z. VV72MxƑ;XZ$X3a,q:dIƆ3b76K,҈7-BC/~G:n/*Z\ry(+ FV4oܙq&)pU\[ś!6=eWe*BdB$e&,z2`($MWVlqr`d*vm}VʅlcH"I<^2r^t-;HR+l$f (`&e*vfYZY%% ⥚xfi )G'N_x͋GLX\(JvTs }nL|n(.VK˄Eojb\eh,zZ,®,%fRezcebW EQ~409ܨFi@/Gd!frvL6b-_c/)mgS>6H^>|?Co> ^ cw{8SI< xy_B{ ,; ᔊڇLױ TYY^}?muO13)bސH\i/{0[!g"VtC`5X`-aRH#ԖRO9)xcOW\>i'5W:r!3:$n/M89&J! N\A`3|'|\ 0=&5v:01W!^RV.ԗ}w{lfv^8ɇظ7ʦퟋ%Q]Ŧ _>>N>_<bI˧AO/|z,~vNBڜE.Ljx0BbW5 h>~4^-Y _|m'PabnϽd o^m!#,|@w> bR XlnY0U4H|z+fB4|=4xz^ 5:ӣBAm_qL>6;-GV'4:yΕ ,m/k΃+cHBۇq Wj9@p` 1LӽX\M?|X. Y*K־5:N@ZٍWyO?2s,2MFVyk?rR&T9Lurb*Ե債PWw[On[]ڂ Ww'+Bv1!'oۋZd4)/6Qg.+QG+7ǖ?>6IWUykÇ0v,*z EEWIEyy?b+% j&~Z?;UINӺ"5,P5TGCVwIw{v.6 pj܏'z7{pG'ܺT"U^YȪoIHL&s }Vs5KSŮf[˲ɍ$]8)@ｿԌT BRW dZ l/ ":J϶A/~w>qyTGP=&NȽxqs ,FRLLPF'tXW1qy$5ɓyOߋ-X+[UvBX&%UGfᇸ(T6q5_6-hegyv-ORq2)ᱯ(c,xׯ܌^xkX]Ll]^gBpu5&+NsrWKbާW}G_WDUR;|^xk_BcxWG"K;5aj?8E̓9$k X7x޿긪^H:yU*8px@x{2xXUAw©Uo6zN^}=u-vE@!^_;MMM^eX\-߫qX7;"7_Y+ 7a=u?'d"|r%pH\W^|E'Vde>{Sn ,2ca&3 k \PV__;"5`K})Qn.nvY(+!ĸ-F{'!*|: G{bi|Ovy82.c}py5f[^mio}ܐd\8pQB+7+ﻸ!?r7<{W{"GxSQ:ׯ܌lAz)Q1=YUt:3S\M&DDTqq)ǯuX,xZL][?-#7Â,fE_Q^t,zR~+\u'"""*ɗNEn/Og{"";)䞐 '!XZX$Ĉyw޿q4q cn/:efia%?rvJ́yQȊ ~,_2ۆV_sqL ^8  "\{5pߨ{U.'Eܟ "JtKCۋVx15ͭ±^Gș;U1`tn$gm ^k("WCYTxA$J ^gs*=lPRpL򸴺XpϷ=3 ly} ^_;eBo#K +ŮIEo<6bswO>"$ _51"<6?Tdz.nۇ:)NB6?]l`dSCi 5/><Svu}> ?VSe跗!)2٬[$~FN}TGP6 frRP,/ zack#1(_觛?|wgoW+57)zbgS%_<23Vg6~}+ >iG>:Ç2=ڙ%>[v3OH@|ګ꣸A\eʃVM,GLBOgi"^ew{H}gf _{o8 ^ {gQTW/tly'!j&eaB隦30ms?}ϝp'iN=HdP$Y"YBWgMډ9}LxDEĹ~l@1ėGOZ)P4Q2u\r:`tYK +|LBtdRfUMg}`[N}mRdP,-D?YHl+c5 ^#ҙ21W.M /tVDUsOBDݶ&sa+p21-Ji*a@ƏU+J,t moyLSiPm[>w IYe C4_\ՒRUլ*vm/} ,\u#w1t<]}uU'!'9tm"JBD=Rp<7Xu0YzYK+Y?Wy8}!U0kˋ^ocE"aݴG.$bpq%êC$$U[bP?,{극-v!1uuk\'h.}OɏR8u7) <cћו\=iϔPG Mp2?{)yGc :iVvg,ȗ+n }H[WcOi<LH4K-vǸ*!!^ ]`u!$ ~%&8)xOӖ+襔{K@Ț+7#SVX1ڇ"˺[Az= v0WVJ{^}Hlf(BNnq3'!Vx]ʥD.2iC<$!uBXic8oSHk}b]ݸ;;W9kE )uDC˸ଢ଼eח0\In,y={ I-Uc}rG,R'!L{[-_luI}60`3bF]O>j/xc 9O~I ҇{N%kTDk}ps©䠊:(}>ƚyoqVyFi7nOެ\*O76*g+a{yWwj;HTUU˾q IDAT6NU[Kj*D$>BwWtέ[|/iMci_c/d- ܻNE4DicYb3W%\vWtB*vu. ]6mgYZrִ 8ʛ Zߓ! gZ: !g?F4q.ޯ[\-*>%XFP/0"&q1Ǐ<] /x 1s ,>| {fw{HOMM ydֻ_yƗ/N ug|| v1ւWBRqՄ\bbL!b""g 4B7/.Zu97AȃH v)9#2lipx`"+13|ȤE  "U4]+Z,mۏzWEVNzv<^t@jzeaX>7_#ZV,RlO@LCn#qTh(v}Y׽%.GH%EVL}zjJUq4-TY} D;gY7nGǪ}Uy&<\Cڙ<,;fo}\neG6F_(XEo IvȘ޴qk7SQu\XH#aȮE$ĴJY0> kCUF!Tg 3`B=Z,űg}ܺ cmt$Mb% d[Xq71>X]r3e8y<ףSX1ny>R^ '_يߤ3d=d:k+_OS㵍ڂϟ{xv.L`N3Y=}yAR\puv( ?ᤣ<dk#,tӱ oEnsФ=rYzw{y/zpz<6^`vP3I*xM䲴x~|=,aIrlL[<{&8IO>mWOV2ԕ_Og`ř˕.xV̳^I4Sԇ$Ǩ5ln]ϧZk73X\yOmǕ:)vY3z6~3'1C/eRvDƍZ ޥߙ5:p!YBzƦYk^5* |` Qv%#gJ33yܫuKݥoGlhy?κ*WY4zLWsE?%ODDya6Rۓ/-D/?ߧz:`-×miaeNZmu ['=IP}.FzmL{G?H=!)Y-xz[R}i+)}{3C+|!L>|SGEChe"A_rM-7dTV no3:kKCSt~ږŮ[1).)v]]cm5|wW!W?4I9w_yy[2d=YMhLmAU6a)zUjޗqDCLӟ8 ASEYoE 2+7#)|$YGS_{+<{Nu|ج,_ &S;\<4VLݿm{:?> Y_{-N_Bjٸ7ߞ,|2|';O=~(dq>ｽ<1|nDqK5N7XX{_N_>,Gxᅯ9X(i.; CV/S3_O{"*ݥo'^ C,x-_[^C.D/7nL2r_/H*a.~ kJӈ~+w:꬞9oE_/,j-Hr;4"ʇ+w~NG/ȝ;zohǟBspADT~%m0 ?|Qx2""""""""""""""""""""""""""""""""""""""""""""""""""""""""""*O """"JSǪy9DDDDWnFjE^"""OIe%ʗwU^"""Sy """ps)/ׯ܌_~DDD4@w{,ب5d5Qo6Bbwi<^=k%XY%Ё~IP9/xR|^89{TǓL?(`䣬I(E+|}gG9w~ri3ln]DmPDln]{R3aH[1 d>ɓ p+^t2> cBw{lY:TyQ2۞*2 ckn/o6~,^v5?,ʖeRO@y'mT$m UWSH%ȇu#j}U Rrk˄: [ OQRߤS$gLY^uO܂i >):)k,9yZc*[-k}Cп&?|a#zȗdIћ',n,+m佼Bϥ]q'U?oTz\itjd]g@<;k "]^>ysńi$V2ɠH[䪤 dŋPɛ[n =C}ULPd3]vV\g-64 yL3zv84yHUE?F}<з/qBȞ2[&;^ =g[L2\4"/mgog+y.:?|h|Mo|=4-P;dZ=} xgm W?Rg%Bn߸uP,nw{ "Y0W uLI~v=,0$\d>ˑ31J߭(V5׷Kzz*=a̅mx]-T@UĤ,!_po:+Sm{/΀@dвJH։`lbgW_=,Dzb7ÄHETY?L&މ.0:+uAKG%/Q/PTCIC[iۣOLzd˂>c2dmw!lܛ!ab폱-Bdn9H5|^YZ4fݼmLwz.} 㶘-sWT[/;_}:1]X?1e\9}mB%텬'qgh'XEm/F׷1^Rs }vøTe,_ƽvUu:oQIau z+{I>T1p=VʦXO:`hg{g|Z8qRӕrT>pS^BI'zSS)osf&5'3ϪOmɇ9|*t© :*cc|Gj/xMv\፹zVOOXZX 9yJ2LG[/ "f2R{>F|;$Z՝r;Ã~Kݧ~|xG|Dv\~9}c2#'{ ՙs2.'lfnCV7Þ~w˹qw0nMypRO&ۈ[/aJZP|@D#/dFi)'Kl䩠 ^6,nipW={kĂ[_~Y*S > }חN+NG|iN KUy'g^gˠ$߯tT4=a uN޾eݟ^E(C'BƉ_y_q>E->9C Y5T 'brRV7*o-yXVw}j .I.Vyôj0ԫ\ݝpL9+g+Y 2kMZa>@}7^*/PK侈-zYig&Ӯ_,_| 'E ]^gXߜxno"Kѥs Zqdqk;aS+Y)C{OG8oOFbHgǍe>Vn8~*|h b>')K.]rs8st'o_íMIm Mo#>m(Iߕ!;O==<͛Eg:, D}S!yi DI*i03m,)2Wؙ,bj'Sr \MG8_9NcTWSRJSvko:w{sP ~wo~+!5KY$:5`ZXdc/͉Yۋ~3{o`s-| YX# jq ACmW}_k `B&nDJRX^VWKRrMʖd"̲Ά4U3sπ}),~kП+/MԾE>\Zݘ=Hࠞl<0D=e_6]$73?2sQٸ73'9>d]QW-Kև0C_Yg4 Qk)}0ea G vjfvV7ƫWIo7j.=g{Xj[M˔i^2>πH=v3ɣS>^έ[;~/өlYyCۚ, |w۩~Ǭm+MxMӊYNj ɗNE,lcXb YfϨ3,-D?vFE\0]FE/69e9 <>=ŕCR4F~AM|_d*zAU"UL IDATSg.r27x޿w\ZX`s{cc;u܄AL'_:ݧe}eBXWFR0g;&\/O=iWdA])P,]Q8styʲ.}Llw^ʐ]U," vP8eg8LZ0rDٱ&Q;2NUݹ華Y4+BI@p,dYHs_M l ]&Wuo!FWDS;^S>^iQVg.ܺ:kF!)^Gʄs=gBrS2=)sX F9uQ.zk2hNu^8)zfί)t_IۣUjV$ %3M@lm”L2!l $i;F"SR5 ITF䙄d6az,NȿG>4;Њu"y9_5%y2~6ɻJ7)1ѿvVy-/>PS/ T,WY]RklEWé鍟{Qt0g&Uo|!> IӮLwSBהBC- mb+pCk-xa7ĶߤЊ*IEVY&򽫧}aH溴y5MgŐsQوOqCKŕ-ʮ& YYojfmi>; -|U,g$k&Y&;Hh*S.`H&XeL("<~vJwT̚P-tu7bVUl 5ee!vl 2Uy{|kA b0HRaxl Th q&Y-Lb%`IIGNm*k7T]\s<*@.;{TPy\xb}eWk e=ttP`F|VlxLj/x{;j9U@OԭE3m,|;mbX }T-{D3r=vP{E1||lN4ݸ;[sR}q򒁃I$E]4z̅ju|,\0Q*/bȪ2KI#_)e<_]r3e`uuXn/,j}b-Y⨪dQEm\UU/QUUFu:sQd{ȫxeY_Bߛiߎ?`ΰUŐVZpFäFm1YםGmDr?CeUjyւח%?U4tug/ȟ:/-͚.ON,B:3j#pA[ZXVJ/A-Džř jTR&a?>6뜽pJˋu+1\cp>"ED B=66~j{ y<)(nߋ+-aggC6׍ǼHNyBDTVEH}I!8hƛD p m816sRzfdEH^H%^U 5 @߲0){K|FM_y%āë=DLM() 8~O.6l\ vuWx}P;Q翷ZY}.CVz5,9Ag,Y_Wf*y88jM:—0v> ~ʃSg!mpy L@ +!G$c= `Q:zwq\\'1 RTjC/oQ<qU;N@Y,Lj}qZ@$qj;Tj^m CmDֱͥܐzEQ5Bm:V`quwqx^wniUbqKe]d4zHrET&U Z,_E5V~ְR3[^㗵byL}_auLUV>UEuRXF&)-)BBƍ_dE+?(j'yH+C=b~GT4C*z WLL@:g1E&Gq6n/ZZ<зς)Vԕ6g!$`4ϼ?˜XW3.!dar*L>] :<_A ^Dև`rҋ^ Vjk7qbw{XC'o_˔EVQl>A^i*Z\ֻ[M)LUeaWSC?%fj^gs*.}k70lmЋ<}Wm>6>TNU$ sx_< 2B\`Mu`y.Z,+ISO׿zMe)y ln]]v>œd%Rb ?|nw(0d)vCqo=c^pf``V/:rP\E 9lnL&l$=<22,ǔ~zyTJ"/KL\UIX<|4wy*о6K.GI3I\]*[ƿvÇ̝WYpYqLV]ڍjC. ӀQ ›^d#oK&Ϯj"o0uU; :Ϯ:3)l fFS8yZtsSǰ·-]xbF >\6Vč Ϯ:{<iq㹚=1}z:. q0Hj8I3Bo]/5 vyVV/at1C\.\ s> :'ʪMTZƷJ2}/G ,]TiLcu޲Cȭ.^SS_Ui\v.о~-Bj4‚7#v^TSq4;~IAS(Df\u Xfx<{{K z[ǿt,Sg,xZD._10 V7^46EDDDDDDDDDDDDDDDDDDDDDDDDDTWn6@DDDX\yb4 ""lN#Q^mp"ADT]>0bXTP0r8stykљSy0 "jyhj`7 SR5 Ç՟c.ũmAa؟yh*#Ʌg$-fA!{G|;a_|y?~kr NBA6>'HaL Z&BoQ.̤}xR~RmxO7@_?/g.H/5Ŧٮ` 퀮JVqjUf_Yv>b&I_us㯙p䥞lgwxQ }!H_g}\rmEKܺjhh+&??Y=iJ0u[ )rc&d3(fVaN}V$|G~dn?d³QZ *w婱YcFm/P-x_nܝYȲe8*Vթ=Y;'@ޙ4u5 u ץɆ$^\+eLVGz%`: ݴ&$$Mk/x_Li3LVSXe0> )3 IvIn,D\<}WypO>Y'wz?3&iUwn,|a]cƍ&Nj qjr0uы+ ÖhX` `;IEڍS_O,t} "*=˚G0ȳ=Tyi/>Νf`SLR@ h껓tm tW=~5o~`b7K&1.ِnR.A6ɪ{y-+-`O4x;lbݔ"eJ޴<񰪲:&jGNWx³SJ/ 3yTH5EGsH#ڀ |0yj2~ؑ#{ާXZ<ߪ|,fQGNVxhY\w.7^Df|Ϋ}˩º,atWwx}ɠU>xj X-mnRM,|8Y~PFṂ,#mCtErK4߹uu6>v~69u=--oenէK3ם?9v *_:6Lyg+D&!&SpZr "=+i ]G g?>V*coŕk^Kʷ{|o.}h&G\4^@nܭvPϴqoͭ?!6SjSa !+YlYVbVvٗ@Z&dj⒚L[aq( wv>yj6fV^+_' _Lۋn|nob{țŷ$77}4T.yHqWu{ PR;IDˢEkМÇJBDWOڍ^"uH2GJHfR+X}ǝνGSw 9q#s 5:%W>Q JSHE*W0ݥ_d Le&!H@Lrt&}s `ݥ3Mj`k#1,|H|y?,؝ہN@5s 8kY:mխm!6d";8ZGދnfH`44;yC@d 9(1cr0,!Q-8r1 Ρ]]]o~UNy~]Uz`$͕7䎐c<_i'#gb7uFY ]ƍ>c޲?=iKo~3CsmM9⑖͘8eJgs0x𑼲8F͌p}YM[yOO; I(xK^yϤw]|_؏o4<"2\yy8Usyi@<}ODohJ Te8Dƅޕ7Z+=7|iij%k@("Ϗҹ5rf*ȜXksD(E%eU ŕ?=i㇏F1KkkX?wzoF:^f%8`2kdt\&2}wyn$3gE[9k"8 ⬱PiK}5"^o{GUaђȬ̘ 2Yͻad*x\ 3.[,Les7sp++W׃:$v҂H)yՒgMb)LUW)W.}VvqU6.:[7o,g竪[{.s+R]qz,RҶ\Z^ꊗO"R>k49\#j7zLi#b1Q)eYg "1):\"lm&'ẕ-絶/<7{x,,W;ngKxJ(k8PL³Sܸ~6ZܢDz쟞4z3fks`\uvLezkW67~E?U\9 w3/yy_b0l U98k؃<|t6 /l ~tڷƗTCׯvE]Um\WEi ӿ|yt,w.u10B_b޵ _3oCS?_|"g2go*̟:%-Ec>߼l VO<}K>et0g(B0͢YE@]X 4zx|A@hnݼ=?k}duۃv5~4LbYw yc ߴ2 >!zmOpqAd?nˢlQdB ^s6Ax-.韞4x5߇CHW>ߎvd=蟞DnΖqّĚ̀óۖЊ,C<*9 qZ؂<,t$0zmϾǦ}w%|uF@е7#Nx> !m=kxhp__~߿ߛx^e /-Eec "'U ,nmϟ㇏?S-{8̗<&bQ=QġEg|rMDm >˓j{J;ćtaE(fYMٸbR6Bk6n ٳH)vmfK!∍c]%Y($wae6,) 7[RLfMxg$3v{10$Ř+ȢͯP+'91ID$cJ~8*~ U)tmFʯLIr3 ́x,v+nU*b*Yb ,EA>90[rz^'c/?G,r;ڮƒeZm9MHY얉>ϢOI祋]}W?|M2y+x]wTXR^.v˲k>}ZjB/SE/p3ue BǴDtDi)7n8fu+\6,gxkD,vUBK#JL". ȴb* 1m5)$}3I(zi#uZ쪄qۉ5$HqH̳!yLs`H-26LxM!6Ӟ\%Dgx'Ԕ8LIl -vŕ$8L%yKtcLUV*" }w9 5ăȫ7Ǽ%4_|SVQ7 Ğu"7yH&x]kkkl!>^f=Layj 5xn`럞4z۲ێjDfwM/?'kW6Ex+rw(.-;hgw'Î0񾤡K95zX+NgĢF1Ōe~\ &?{tID>-fk:I -gHqq2B%(zp/wޑOJl.oް]}C۽_ȾoB1&&l ֮l_Bu9ӓ~?&]k,챰;bjm)hbf[(Kq4H U"2x, fxmc~ojgƅv3Ge \?7އ>7X#(X[.#hz17ٷϿp˹51`8c|G?\7JD7K&3|6daH;OOҋm^3J,<8&/G%tȽ= fbG d@n%^W̄N,a ,beI"`1YS{Zi[yhJ,מQŒ{S7tgERKqQwԚ.R`!nJܖyvgւY0B)Mc<utZ sRImCy rm$ߟ+m.& %kYPs1J<2xǜ;R'<#a bICy%H0N+9xQd=UxW&/9d"754cbvT4e tVIn;6 ׎>վ q6V,ot$:kvu6 $C1I(vIcXh#|ŃݱW2H1۱' 7̵uicU$uH 2;Rzm1!AOOyGDj*0>6x^j(hCfkveSmb$b4fGjR@̘}i#nCd3s[?Pb6/vČIb[ǥsƸz_8FRDk/\MQ\_Y}W@ו8,D Q_>Wybk:&8G$Y+M䮢WCm1Cd׮lNUNWeGqE"Ofҝ3e*y,eH?=iNs?֢}ŎKo?=itն9IE|J1wXlӓƾ"I>OǕ{G}YYmG3V#;,8͘^ȌEb$>'gE||o/x~4`Ů>.sԯ{60O`pʎI㫄va*"ؤ$yb7 ?:&:0V?Ftx(It;[""sa[dn%uWc,D,xuu>I"\s0;ve35_~}.J~39qR1WLpMlMĈ^i9&onW{k벷eZ@F@*HܽS5ZkIs Yb!2ݬ|2^&bN"·aV\m$h*zx>DHzrv"^FPNPK:% zrז;l4kq%Ixٙ˵ʍ}>8w9R~7:vb !EWJSA9 惓t9NYI>v5O?>YzݻL(ڏz.76EYPdaZ}ӖKs/njs<"k$^?4fkͯ~9ɾ35iŕw׾-eXsjow.w׾=ﳞ?f,\H{f.+7a=ЛDdTy-*xهWdl/]z^DY $ݻȥKݻ8Wqpm~88l%󳽬˾ڕ %2,xv[*}I>3h """.Zk'P ^ŏγ&s@d8sSOP`e蟞4z3UX,WN<<yO= ԍ}VZ`<_LQ5wru\I7}—Dg- <7~)csy^oY3g*QW5ǃ>lz"2+U" gk h08v88kߎk|oIݍk0&%&% 6-zϳ^(6BRe/4eF$I> DoeP`üѬ5E}v5[_Nma>c<Ne4FEW^<ƃX --U@eۃ[7o|6fko ~[W{΅#X ==">|o4&p_ $A~=(EC=d]^n }\1"ْ0[dNB,xq2PKqCP4f,=ks10 `1]:op˵,˓O=!DD/س|jF[jwٷ-D($|z뎟| ߇=G0m",i(}9i_xa˃\C7?8-T0/ .ް7_fk3WG zÃ[7oO?n``ICAI.wDg["\|37z!BbA[-(qf=LۣXƃ8T,z)#sJC|IENDB`SharpEngine.Core-2.5.1/qodana.yaml000066400000000000000000000033471514307377300167610ustar00rootroot00000000000000#-------------------------------------------------------------------------------# # Qodana analysis is configured by qodana.yaml file # # https://www.jetbrains.com/help/qodana/qodana-yaml.html # #-------------------------------------------------------------------------------# ################################################################################# # WARNING: Do not store sensitive information in this file, # # as its contents will be included in the Qodana report. # ################################################################################# version: "1.0" #Specify IDE code to run analysis without container (Applied in CI/CD pipeline) ide: QDNET #Specify inspection profile for code analysis profile: name: qodana.starter #Enable inspections #include: # - name: #Disable inspections #exclude: # - name: # paths: # - #Execute shell command before Qodana execution (Applied in CI/CD pipeline) #bootstrap: sh ./prepare-qodana.sh #Install IDE plugins before Qodana execution (Applied in CI/CD pipeline) #plugins: # - id: #(plugin id can be found at https://plugins.jetbrains.com) # Quality gate. Will fail the CI/CD pipeline if any condition is not met # severityThresholds - configures maximum thresholds for different problem severities # testCoverageThresholds - configures minimum code coverage on a whole project and newly added code # Code Coverage is available in Ultimate and Ultimate Plus plans #failureConditions: # severityThresholds: # any: 15 # critical: 5 # testCoverageThresholds: # fresh: 70 # total: 50