daily

GitHub C# Trending

The latest build: 2024-06-20Source of data: GitHubTrendingRSS

Game Launcher for miHoYo -


v0.10.7 | English | | Ting Vit | | |

The PC game launcher of HoYoverse is one of the worst commercial software I have ever seen. The overall user experience is passable, but it performs terribly in certain details:

  • Lacks support for high scaling ratios, resulting in a hazy aesthetic across the entire interface.
  • Resource verification utilizes a single thread, unable to effectively utilize multiple cores, leading to a significant waste of time.
  • Despite having a built-in browser engine, the interface design has remained unchanged for years, failing to capitalize on the flexibility of web pages and, instead, adding unnecessary bulk.

Starward

Starward comes from the slogan of Star Rail: May This Journey Lead Us Starward, which is very suitable to be used as an app name.

Starward is an open-source third-party launcher developed to address the aforementioned shortcomings. It supports all PC games on of HoYoverse and aims to completely replace the official launcher. In addition to the basic functions of a launcher, I will also incorporate some additional features based on individual needs, such as:

  • Record game time
  • Switch game accounts
  • View game screenshots
  • Save gacha records

More features are left for you to explore...

Install

First, your device needs to meet the following requirements:

  • Windows 10 1809 (17763) and above.
  • WebView2 Runtime installed.
  • For better experience, please enable Transparency effects and Animation effects in the system settings.

Next, download the package for your CPU architecture from GitHub Release. Extract it, then run Starward.exe and follow the prompts.

Localization

de-DE translationen-US translationit-IT translationja-JP translationko-KR translationru-RU translationth-TH translationvi-VN translationzh-CN translationzh-TW translation

Starward uses Crowdin for in-app text localization work. You can contribute by helping us translate and proofread content in your local language. We look forward to having more people join us.

Localization Guide

Development

To compile the project locally, you need to install Visual Studio 2022 and select the following workloads:

  • .NET Desktop Development
  • C++ Desktop Development
  • Universal Windows Platform Development

Donation

Development is not easy. If you think Starward useful, you cloud donate me at https://donate.scighost.com.

Thanks

First of all, I would like to express my sincerest thanks to all the contributors and translators of this project. Starward can only become better because of you.

Then, I want to express my special thanks to @neon-nyan. The inspiration and design for this project come directly from his project Collapse. I have gained a lot of knowledge from the Collapse code, and with such a valuable reference, my development process has been much smoother.

Next, a big thanks to the main developer of Snap Hutao, @Lightczx. His assistance has been invaluable during the development of Starward.

Additionally, thanks CloudFlare for providing free CDN services, contributing to a great update experience for everyone.

cloudflare

And the third-party libraries used in this project include:

Screenshot

Background image is from Pixiv@

Render particle effect in UnityUI(uGUI). Maskable, sortable, and no extra Camera/RenderTexture/Canvas.


Particle Effect For UGUI (UI Particle)

This package provides a component to render particle effects for uGUI in Unity 2018.2 or later.
The particle rendering is maskable and sortable, without the need for an extra Camera, RenderTexture, or Canvas.


PRs Welcome

<< Description | Demo | Installation | Usage | Development Note | Contributing >>



Description

This package utilizes the new APIs MeshBake/MashTrailBake (introduced with Unity 2018.2) to render particles through CanvasRenderer.
You can render, mask, and sort your ParticleSystems for UI without the necessity of an additional Camera, RenderTexture, or Canvas.

Features

  • Easy to use: The package is ready to use out of the box.
  • Sort particle effects and other UI by sibling index.
  • No extra Camera, RenderTexture, or Canvas required.
  • Masking options for Mask or RectMask2D.
  • Support for the Trail module.
  • Support for CanvasGroup alpha.
  • No allocations needed to render particles.
  • Compatibility with overlay, camera space, and world space.
  • Support for Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP).
  • Support for disabling Enter Play Mode Options > Reload Domain.
  • Support for changing material property with AnimationClip (AnimatableProperty).
    AnimatableProperty.gif
  • [4.0.0+] Support for 8+ materials.
  • [4.0.0+] Correct world space particle position adjustment when changing window size for standalone platforms (Windows, MacOSX, and Linux).
  • [4.0.0+] Adaptive scaling for UI.
  • [4.0.0+] Mesh sharing group to improve performance.
    MeshSharing.gif
  • [4.0.0+] Particle attractor component.
    ParticleAttractor.gif
  • [4.1.0+] Relative/Absolute particle position mode.
    AbsolutePosition.gif



Demo



Installation

This package requires Unity 2018.3 or later.

Install via OpenUPM

This package is available on OpenUPM package registry. This is the preferred method of installation, as you can easily receive updates as they're released.

If you have openupm-cli installed, then run the following command in your project's directory:

openupm add com.coffee.ui-particle

Install via UPM (using Git URL)

Navigate to your project's Packages folder and open the manifest.json file. Then add this package somewhere in the dependencies block:

{ "dependencies": { "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git", ... }}

To update the package, change suffix #{version} to the target version.

  • e.g. "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.6.0",

Or, use UpmGitExtension to install and update the package.



Usage

UIParticle Component

UIParticle controls the ParticleSystems that are attached to its own game objects and child game objects.

  • Maskable: Does this graphic allow masking.
  • Scale: Scale the rendering. When the 3D toggle is enabled, 3D scale (x, y, z) is supported.
  • Animatable Properties: If you want to update material properties (e.g., _MainTex_ST, _Color) in AnimationClip, use this to mark the changes.
  • Mesh Sharing: Particle simulation results are shared within the same group. A large number of the same effects can be displayed with a small load. When the Random toggle is enabled, it will be grouped randomly.
  • Position Mode: Emission position mode.
    • Absolute: Emit from the world position of the ParticleSystem.
    • Relative: Emit from the scaled position of the ParticleSystem.
  • Auto Scaling: Transform.lossyScale (=world scale) will be set to (1, 1, 1) on update. It prevents the root-Canvas scale from affecting the hierarchy-scaled ParticleSystem.
  • Rendering Order: The ParticleSystem list to be rendered. You can change the order and the materials.

NOTE: Press the Refresh button to reconstruct the rendering order based on children ParticleSystem's sorting order and z-position.



Basic Usage

  1. Select GameObject/UI/ParticleSystem to create UIParticle with a ParticleSystem. particle
  2. Adjust the ParticleSystem as you like. particle1

With Your Existing ParticleSystem Prefab

  1. Select GameObject/UI/ParticleSystem (Empty) to create UIParticle. empty
  2. Drag and drop your ParticleSystem prefab onto UIParticle. particle3

With Mask or RectMask2D Component

If you want to mask particles, set a stencil-supported shader (such as UI/UIAdditive) to the material for ParticleSystem. If you use some custom shaders, see the How to Make a Custom Shader to Support Mask/RectMask2D Component section.



Script usage

// Instant ParticleSystem prefab with UIParticle on runtime.var go = GameObject.Instantiate(prefab);var uiParticle = go.AddComponent<UIParticle>();// Control by ParticleSystem.particleSystem.Play();particleSystem.Emit(10);// Control by UIParticle.uiParticle.Play();uiParticle.Stop();



UIParticleAttractor component

UIParticleAttractor attracts particles generated by the specified ParticleSystem.


  • Particle System: Attracts particles generated by the specified particle system.
  • Destination Radius: Once the particle is within the radius, the particle lifetime will become 0, and OnAttracted will be called.
  • Delay Rate: Delay to start attracting. It is a percentage of the particle's start lifetime.
  • Max Speed: Maximum speed of attracting. If this value is too small, attracting may not be completed by the end of the lifetime, and OnAttracted may not be called.
  • Movement: Attracting movement type. (Linear, Smooth, Sphere)
  • Update Mode: Update mode.
    • Normal: Update with scaled delta time.
    • Unscaled Time: Update with unscaled delta time.
  • OnAttracted: An event called when attracting is complete (per particle).



Development Note

Compares the Baking mesh approach with the conventional approach

  • Baking mesh approach (=UIParticle)

    • Rendered as is.
    • Maskable.
    • Sortable.
    • Less objects.
  • Do nothing (=Plain ParticleSystem)

    • Rendered as is.
    • Looks like a glitch.
    • Not maskable.
    • Not sortable.
  • Convert particle to UIVertex (=UIParticleSystem)

    • Maskable.
    • Sortable.
    • Adjustment is difficult.
    • Requires UI shaders.
    • Difficult to adjust scale.
    • Force hierarchy scalling.
    • Simulation results are incorrect.
    • Trail, rotation of transform, time scaling are not supported.
    • Generate heavy GC every frame.
  • Use Canvas to sort (Sorting By Canvas )

    • Rendered as is.
    • Sortable.
    • You must to manage sorting orders.
    • Not maskable.
    • More batches.
    • Requires Canvas.
  • Use RenderTexture

    • Maskable.
    • Sortable.
    • Requires Camera and RenderTexture.
    • Difficult to adjust position and size.
    • Quality depends on the RenderTexture's setting.

Performance test results

ApproachFPS on EditorFPS on iPhone6FPS on Xperia XZ
Particle System435722
UIParticleSystem430 (unmeasurable)
Sorting By Canvas434418
UIParticle17124
UIParticle with MeshSharing444530

FAQ: Why Are My UIParticles Not Displayed Correctly?

If ParticleSystem alone displays particles correctly but UIParticle does not, please check the following points:

  • Shader Limitation
    • UIParticle does not support all built-in shaders except for UI/Default.
    • Most cases can be solved by using UI/Additive or UI/Default.
  • Particles are not masked
  • Particles are too small
    • If particles are small enough, they will not appear on the screen.
    • Increase the Scale value.
    • If you don't want to change the apparent size depending on the resolution, try the Auto Scaling option.
  • Particles are too many
    • No more than 65535 vertices can be displayed (for mesh combination limitations).
    • Please set Emission module and Max Particles of ParticleSystem properly.
  • Particles are emitted off-screen.
    • When Position Mode = Relative, particles are emitted from the scaled position of the ParticleSystem, not from the screen point of the ParticleSystem.
    • Place the ParticleSystem in the proper position or try Position Mode = Absolute.
  • Attaching UIParticle to the same object as ParticleSystem
    • Transform.localScale will be overridden by the Auto Scaling option.
    • It is recommended to place ParticleSystem under UIParticle.
  • If Transform.localScale contains 0, rendering will be skipped.
  • Displayed particles are in the correct position but too large/too small
    • Adjust ParticleSystem.renderer.Min/MaxParticleSize.

Shader Limitation

The use of UI shaders is recommended.

  • If you need a simple Additive shader, use the UI/Additive shader instead.
  • If you need a simple alpha-blend shader, use the UI/Default shader instead.
  • If your custom shader does not work properly with UIParticle, consider creating a custom UI shader.

Built-in shaders are not supported

UIParticle does not support all built-in shaders except for UI/Default.
If their use is detected, an error is displayed in the inspector.
Use UI shaders instead.

(Unity 2018 or 2019) UV.zw components will be discarded

UIParticleRenderer renders the particles based on UIVertex.
Therefore, only the xy components are available for each UV in the shader. (zw components will be discarded).
So unfortunately, UIParticles will not work well with some shaders.

(Unity 2018 or 2019) Custom vertex streams

When using custom vertex streams, you can fill zw components with "unnecessary" data.
Refer to this issue for more information.


Overheads

UIParticle has some overheads, and the batching depends on uGUI.
When improving performance, keep the following in mind:

  • If you are displaying a large number of the same effect, consider the Mesh Sharing feature in the UIParticle Component.
    • If you don't like the uniform output, consider the Random Group feature.
  • If you are using multiple materials, you will have more draw calls.
    • Consider a single material, atlasing the sprites, and using Sprite mode in the Texture Sheet Animation module in the ParticleSystem.

How to Make a Custom Shader to Support Mask/RectMask2D Component

Shader tips
Shader "Your/Custom/Shader"{ Properties { // ... // #### required for Mask #### _StencilComp ("Stencil Comparison", Float) = 8 _Stencil ("Stencil ID", Float) = 0 _StencilOp ("Stencil Operation", Float) = 0 _StencilWriteMask ("Stencil Write Mask", Float) = 255 _StencilReadMask ("Stencil Read Mask", Float) = 255 _ColorMask ("Color Mask", Float) = 15 [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 } SubShader { Tags { // ... } // #### required for Mask #### Stencil { Ref [_Stencil] Comp [_StencilComp] Pass [_StencilOp] ReadMask [_StencilReadMask] WriteMask [_StencilWriteMask] } ColorMask [_ColorMask] // ... Pass { // ... // #### required for RectMask2D #### #include "UnityUI.cginc" #pragma multi_compile __ UNITY_UI_CLIP_RECT float4 _ClipRect; // #### required for Mask #### #pragma multi_compile __ UNITY_UI_ALPHACLIP struct appdata_t { // ... }; struct v2f { // ... // #### required for RectMask2D #### float4 worldPosition : TEXCOORD1; }; v2f vert(appdata_t v) { v2f OUT; // ... // #### required for RectMask2D #### OUT.worldPosition = v.vertex; return OUT; } fixed4 frag(v2f IN) : SV_Target { // ... // #### required for RectMask2D #### #ifdef UNITY_UI_CLIP_RECT color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect); #endif // #### required for Mask #### #ifdef UNITY_UI_ALPHACLIP clip (color.a - 0.001); #endif return color; } ENDCG } }}



Contributing

Issues

Issues are incredibly valuable to this project:

  • Ideas provide a valuable source of contributions that others can make.
  • Problems help identify areas where this project needs improvement.
  • Questions indicate where contributors can enhance the user experience.

Pull Requests

Pull requests offer a fantastic way to contribute your ideas to this repository.
Please refer to CONTRIBUTING.md and develop branch for guidelines.

Support

This is an open-source project developed during my spare time.
If you appreciate it, consider supporting me.
Your support allows me to dedicate more time to development.




License

  • MIT

Author

See Also

Develop Desktop, Embedded, Mobile and WebAssembly apps with C# and XAML. The most popular .NET UI client technology


Star BannerHeader

TelegramBuild StatusBackers on Open CollectiveSponsors on Open CollectiveGitHub SponsorsLicense
NuGetdownloadsSize

About

Avalonia is a cross-platform UI framework for dotnet, providing a flexible styling system and supporting a wide range of platforms such as Windows, macOS, Linux, iOS, Android and WebAssembly. Avalonia is mature and production ready and is used by companies, including Schneider Electric, Unity, JetBrains and GitHub.

Considered by many to be the spiritual successor to WPF, Avalonia UI provides a familiar, modern development experience for XAML developers creating cross-platform applications. While Avalonia UI is similar to WPF, it isn't a 1:1 copy, and you'll find plenty of improvements.

For those seeking a cross-platform WPF, we have created Avalonia XPF, enabling WPF applications to run on macOS and Linux with little to no code changes. Avalonia XPF is a commercial product and is licensed per-app, per-platform.

Blog

To see the latest announcements and read about the state of Avalonia, check out the Avalonia UI Blog.

Breaking Changes

You can also see what breaking changes we have planned and what our past breaking changes have been.

Awesome Avalonia

Awesome Avalonia is community-curated list of awesome Avalonia UI tools, libraries, projects and resources. Go and see what people are building with Avalonia!

Getting Started

See our Get Started guide to begin developing apps with Avalonia UI.

Visual Studio

The Avalonia Visual Studio Extension contains project and control templates that will help you get started, or you can use the .NET Core CLI. For a starter guide see our documentation.

JetBrains Rider

JetBrains Rider now has official support for Avalonia.

Code completion, inspections and refactorings are supported out of the box, for XAML previewer add https://plugins.jetbrains.com/plugins/dev/14839 to plugin repositories and install AvaloniaRider plugin.

Avalonia Packages

Avalonia is delivered via NuGet package manager. You can find the packages here: https://www.nuget.org/packages/Avalonia/

Use these commands in the Package Manager console to install Avalonia manually:

Install-Package AvaloniaInstall-Package Avalonia.Desktop

Showcase

Showcase_Banner@3x

See what others have built with Avalonia UI on our Showcase. We welcome submissions!

Bleeding Edge Builds

We also have a nightly build which tracks the current state of master. Although these packages are less stable than the release on NuGet.org, you'll get all the latest features and bugfixes right away and many of our users actually prefer this feed!

Learning

Documentation

Documentation can be found at https://docs.avaloniaui.net.

Tutorials

We also have a tutorial over there for newcomers.

Samples

We have a range of samples to help you get started.

Building and Using

See the build instructions here.

Contributing

This project exists thanks to all the people who contribute.

Please read the contribution guidelines before submitting a pull request.

Code of Conduct

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information see the Code of Conduct.

Licence

Avalonia is licenced under the MIT licence.

Donate

Donating to the project is a fantastic way to thank our valued contributors for their hard work. Your donations are shared among our community and awarded for significant contributions.

If you need support see Commercial Support section below.

Donate with BTC or use Open Collective.

BTC: bc1q05wx78qemgy9x6ytl5ljk2xrt00yqargyjm8gx

Backers

Thank you to all our backers! [Become a backer]

Commercial Support

We have a range of support plans available for those looking to partner with the creators of Avalonia, enabling access to the best support at every step of the development process.

Please note that donations are not considered payment for commercial support agreements. Please contact us to discuss your needs first. [email protected]

Avalonia XPF

Unleash the full potential of your existing WPF apps with our cross-platform UI framework, enabling WPF apps to run on macOS and Linux without requiring expensive and risky rewrites.

GH_Banner