Unity Digest: Ropes and Wires

https://80.lv/articles/unity-digest-ropes-and-wires

#rope #wire

3 Options for Getting User’s Location in Unity (or any mobile app)

https://medium.com/@nosuchstudio/3-options-for-getting-users-location-in-unity-5a29faf88a50

#location #gps

Dependency Injection - XRLO — eXtended Reality Lowdown

https://medium.com/xrlo-extended-reality-lowdown/dependency-injection-7fd263b0609e

#di #ioc

Unity 2D Techniques: Build a 2D Pinball Game

https://www.raywenderlich.com/8094424-unity-2d-techniques-build-a-2d-pinball-game

#pinball

Distributing points on a sphere

https://medium.com/@vagnerseibert/distributing-points-on-a-sphere-6b593cc05b42

#sphere #distribution

Как разрабатываются моды для игр, которые не поддерживают моды (на примере Beat Saber) — часть 1: внедряемся в код игры

An in-depth article about how to inject game modes/plugins into a unity game that doesn't support mods. Beat Saber is used as an example.

https://dtf.ru/gamedev/113167-kak-razrabatyvayutsya-mody-dlya-igr-kotorye-ne-podderzhivayut-mody-na-primere-beat-saber-chast-1-vnedryaemsya-v-kod-igry

https://dtf.ru/gamedev/134128-kak-razrabatyvayutsya-mody-dlya-igr-kotorye-ne-podderzhivayut-mody-na-primere-beat-saber-chast-2-pishem-svoy-mod

Repo: https://github.com/binary-machinery/BeatSaberTimeTracker/tree/11dd356415a6e91c1f5a010029fc231c6ef1ab3c

#mods #injector #cecil

UNITY GAME ARCHITECTURES

The first part describes simple architecture, not the best but still better than nothing. The second gives overview of basic approaches to architecture.

https://medium.com/@sam_16930/unity-game-architectures-part-1-dc53b3c7307d

https://medium.com/@sam_16930/unity-game-architectures-part-2-672958fcb33a

#architecture

Enable the Prebake Collision Meshes option in Player Settings, where possible, to
generate the runtime physics mesh data at build time. Otherwise, this data is generated
at runtime when an asset is loaded, and content with many physics meshes can incur a
high CPU cost on Unity’s Main thread during generation.

#physics #tips

Mesh colliders can be expensive, so substitute more complex mesh colliders with one
or more simpler primitive types, as required, to approximate the original shape.

#physics #tips

Consider disabling the Auto Sync Transforms option,
which was enabled by default after its introduction in
Unity 2017, in order to preserve backward compatibility.
It ensures that any modification of any transform will
be automatically and immediately synchronized to its
underlying Physics object. However, in many cases
it is not essential that this be done until the point at
which the Physics simulation is stepped, yet may take
noticeable CPU time during a frame. Disabling the
option will defer synchronization to a later point but may
well save CPU time overall.

#physics #tips

If you are using collision callbacks, enable the Reuse
Collision Callbacks option. This will avoid managed
allocations on each callback by reusing a single internal
Collision object during callbacks, rather than creating
a new one for each callback. As well, when using
callbacks, be mindful of doing complex work during
them, as this can really add up in heavy scenes with a
lot of collision events. Adding Unity Profiler markers to
your callbacks will make them visible and easier to track
down should they become a performance problem.

#physics #tips

Be careful if you are manually updating Animators because they normally use
Unity’s Job System to process in parallel but manual updates force them to process on
the Main thread.

#animation #tips

Animators are primarily intended for humanoid characters, but are often used to
animate single values (e.g., the alpha channel of a UI element). Although Animators
are convenient to use for their state machine flow, this is a relatively inefficient use
case. Internal benchmarks show that on a device such as a low-end iPhone 4S, the
performance of Animators beats that of Legacy Animation only when around 400 curves
are being animated.

#animation #tips

Avoid relying on more Unity Camera components than
you really need to achieve your rendering. For example,
it is not uncommon to find projects that use several
cameras to build up UI layers. Each Camera component
incurs overhead whether it does any meaningful work
or not. On more powerful target platforms this might be
negligible, but on lower-end or mobile platforms this can
be up to 1 ms of CPU time each.

#rendering #tips

Avoid too many dynamic lights when you use forward
rendering. Every dynamic light adds a new render pass
for every illuminated object.

#rendering #tips #lighting

Try to avoid Layout Groups where possible, especially
if your content isn’t really dynamic. In cases where
Layout Groups are only used to perform the initial layout
of content, which subsequently doesn’t change, then
consider adding some custom code to disable those
Layout Group component(s) after the content has
been initialized.

#ui #tips #layout

List and Grid views are another common UI pattern (e.g.,
inventory or shop screens). In such cases, where there
may be hundreds of items with only a small number
visible at once, don’t create UI elements for them all, as
it will be very expensive. Instead, implement a pattern
to reuse elements and bring them into view on one side
as they move off the other side. A Unity engineer has
provided an example in this GitHub project.

Repo: https://github.com/boonyifei/ScrollList

#ui #tips #scrollrect

It is common to see UIs with areas constructed of many
overlaid elements. A good example of this might be a
card Prefab in a card-battler game. While this approach
allows for a lot of customization in designs, it can
greatly impact performance with lots of pixel overdraw.
Furthermore, it may result in more draw batches.
Determine if you can merge many layered elements into
fewer (or even one) elements.

#ui #tips #overdraw

Mask and RectMask2D components are commonly
found in UI. Mask utilizes the render target’s stencil
buffer to draw or reject the pixels being drawn, bearing
the cost almost entirely on the GPU. In contrast,
RectMask2D performs bounds-checking on the CPU
to reject elements outside of the mask. Complex UIs
with lots of RectMask2D components, especially when
nested, can incur significant CPU costs in performing
the bounds checks. Take care not to use excessive
numbers of RectMask2D components, or if GPU load is
less than CPU load, consider whether it is preferable to
switch to Mask components to balance the overall load.

#ui #tips #mask #rectmask2d

In most cases, mipmaps are not required on UI textures,
so ensure that this Import Setting is disabled on them
unless you specifically require it (for world-space UI,
for instance).

#ui #tips #mipmaps

Be sure to disable the Raycast Target option on UI
Graphic elements that don’t need to receive input
events. Many UI elements don’t need to receive input
events, such as the text on a button or non-interactive
images. However, UI Graphic components have the
Raycast Target option enabled by default. Complex UIs
could potentially have a large number of unnecessary
Raycast Targets, so disabling them can save significant
amounts of CPU processing.

#ui #tips #raycasttarget