
Shapes is a real-time vector graphics library for Unity - Impossible
https://acegikmo.com/shapes/
======
klmadfejno
It's a shame that the conversation here is dominated by Unity's failings. This
looks interesting, but the way the author seems to be hoping for support seems
improbable to work imo.

I'm a hobbyist game dev who played in Unity for a few years and recently
switched to Unreal. I'm not so well versed that I can speak the merits of this
under the hood rendering pipeline or the other. A few general comments as an
onlooker though on the engines themselves:

* Unity's interface is pretty simple. Mostly things stay on one screen, whereas Unreal has many nested submenus and its easy to get lost. The editor itself also requires a pretty decent computer to run, whereas Unity will run fine on most setups.

* Unreal has substantially better free content and pre-made stuff available than Unity. It's not even close.

* Unreal's blueprint system is easier to dive into and helps create a sense of one idiomatic way to do things, whereas Unity is more free form and has a lot of possible ways to do things which are, as you would eventually hopefully learn, bad.

* Unreal feels like its evolving into a better product. Unity feels like its falling apart.

------
fxtentacle
It's the tragedy of Unity again. The built-in render pipeline is buggy, and to
fix that you're supposed to switch to URP / HDRP. But then you lose access to
all those cool 3rd-party plugins, such as this one.

~~~
HugoDaniel
could you expand on this? what is the problem with the defaults on Unity?

~~~
fxtentacle
They are literally closing bugs as won't fix if you report them against the
built-in render pipeline. The reason is that they've been working on the other
render pipelines for years and they plan to deprecate the old one soon. But as
long as the community of users doesn't switch, they cannot.

And the plugin linked here only works with the old render pipeline. The one
with known bugs. So there's no way for me to directly use this. I would have
to fix and port it first, to make it compatible with Unity's new pipeline.

And that beaviour of Unity stopping to support the working old stuff as soon
as a new technology grabs their fancy has been going on for long enough that
by now they're famous for it. Plus since they don't give source code access to
the C++ part, you have no chance of fixing it yourself.

~~~
lux
Add to that the fact that there's no easy upgrade path since shaders don't
work between the old and new pipelines, and it doesn't appear to be possible
to support both in the same app (enabling one while disabling the other,
depending on the scene).

We're in an awkward position where we'd love to support the new features
coming in URP/HDRP, but beyond plugin support we would also have to break
compatibility with all of the asset bundles our users have contributed.

We managed to write scripts that fixed most (but not all) compatibility issues
between Unity 2017 bundles running in 2019, but it's just not feasible to do
the same for bundles between the old and new pipelines.

Really, it feels like Unity isn't supporting the developers who've been with
them the longest and is instead chasing shiny new tech at our expense.

~~~
setr
Following it from the outside looking in, it seems like the main issue is that
Unity doesn't actually understand the work involved in maintaining an engine
-- they're viewing it as a "the tech is better, so people will naturally
switch" situation, versus a "the tech is better, but mountains of effort
exists based on the previous tech, so changing tech _requires_ an upgrade
path, or no change at all" situation

akin to the MSDN Magazine camp of joel's portrayal of microsoft (Chen vs
MSDN): [https://www.joelonsoftware.com/2004/06/13/how-microsoft-
lost...](https://www.joelonsoftware.com/2004/06/13/how-microsoft-lost-the-api-
war/)

So they end up building parallel implementations, rewriting from scratch, not
realizing that they'll eventually have to maintain both implementations or
lose a large chunk of their userbase (unless they're so well-embedded that the
userbase _has no other option_ , which I don't think is the case). When they
finally realize it, its too late... and probably even leads to a drop in
assigned resources furthering the delay till release of the implementation

~~~
kbenson
My guess it's more along the lines of the problem of marketing the new shiny
to new users or new projects vs supporting the existing users. In a perfect
world, they would build the new shiny and their existing users would switch
(which it sounds like they keep pushing for) and their hopeful new users would
be happy seeing the new shiny stuff.

The real world means you have to support both for some long period of time,
because your existing users won't and many times _can 't_ switch because of
myriad reasons you didn't think of, and if you can't both support the old and
build the new, you have problems. Like this.

------
analognoise
Does anyone have a book or library recommendation that would cover a canvas,
and operations on it that draws vector primitives?

I made a hell of a lot of progress with Tkinter because it's so simple. Is
there anything that simple and vector based?

It seems like the only options are "ugly" and "pretty but really complicated".

~~~
gtm1260
Paper.js seems perfect, not too difficult to get started (although it is a bit
more overhead than Tkinter).

For something simpler (although raster based), I would check out p5.js.

------
hu3
A friend wants to start developing a hobby multiplayer 2D game. He's gonna be
the only developer. Would Unity be a good choice? Any other recommended
alternatives?

~~~
Peckingjay
I'd recommend Godot.

Unity is also a valid choice, but networking is in a weird state right now
with the official APIs, so he'd have to use third-party solutions that
integrate with Unity (such as Photon, MLAPI or Mirror). It's not the biggest
obstacle, but still an annoyance.

------
stephc_int13
It would be better if that library was available outside of the Unity
ecosystem.

~~~
kroltan
It is heavily based on shaders, so it's kind of hard to decouple from the
renderer, especially when considering the multiplatform-ness.

There are existing vector libraries for other environments, but none so far
for Unity, so I think it is valid.

~~~
Const-me
It's relatively straightforward even for multi-platform:
[https://github.com/Const-
me/Vrmac/blob/master/README.md#2d-g...](https://github.com/Const-
me/Vrmac/blob/master/README.md#2d-graphics)

------
datagreed
Kinda useless without official URP/HDRP support since Unity fully migrated to
these pipelines.

~~~
jay_kyburz
Also useless without source.

