what if we added colour APIs, these are typically done with """vector""" types (see unity)
what if we added colour APIs, these are typically done with """vector""" types (see unity)
Pthese are very much not a euclidean vector
Kpoint and vector arent fundamentally different concepts theyre different representations of the same concept
Tsee reasons why the BCL designed and approved a separate type for
Color in System.NumericsKwhich is a rank-1 dimension-N list of scalars
Aas in a version replacing system.drawing.color?
Apersonally i can recommend writing your own color type as well. its what i did
KI'm really trying to think where separating is more convenient for the user but I'm having a hard time.
Seems like it's just very difficult to choose which type to use (similar to datetime and timespan...)
Seems like it's just very difficult to choose which type to use (similar to datetime and timespan...)
Ki have too
Ksystem.drawing.color is honestly kinda bad for graphics programming lmao, for representation reasons
Aits just bad
Kalso requires bringing in all of system.drawing.common
Ait does not
Kdoes it not? thought it did
Aits there by default
Tthe consideration is that Vector has some core concepts that are basically a requirement for core usage
including things like
a Point doesn't have those issues, because it doesn't need those features, and so by providing a separate type you help users achieve success
and still don't restrict usability because they can explicitly convert where required
including things like
Normalize, which trends towards 0a Point doesn't have those issues, because it doesn't need those features, and so by providing a separate type you help users achieve success
and still don't restrict usability because they can explicitly convert where required
Kthen why could i never reference it without that dependency
Amy
Color class doesn't use a packed value, it stores float R, G, B, and A values
Aidk, i've heard others say that you need to include common too, but i've literally never had to
Kalso
Mwell this is annoying
Kcalling both int and float versions vectors is in keeping with the industry convention established by multiple even most graphics apis which silk intends to bind to
Panyway i didn't mean to derail the discussion, just wanted to make sure that there are use cases being considered should we generalise to "N-length array of Ts"
Khmm... Normalize really doesn't make much sense, but I think all the others do - Length makes total sense.
Of course we could make
).
But idk, that seems hard
Of course we could make
Point(2<int>, idk) return a Vector on subtraction, and then that way the difference is clear (like DateTime and Timespan ).But idk, that seems hard
Tyes, but at the same time most people writing games don't use DirectX or OGL or Vulkan
they use a higher level engine which abstracts those, and often introduces its own different concepts and such
they use a higher level engine which abstracts those, and often introduces its own different concepts and such
Kin which case why are they using silk
Ksilk is low level bindings
Pthis is a bad take for maths specifically
Pmaths is the only namespace we provide that is truly standalone and generally applicable
e.g. these guys use it quite extensively https://github.com/asc-community
e.g. these guys use it quite extensively https://github.com/asc-community
Kok yeah fair hadnt considered that
Ai can see tanner's point (haha)
in math, a point represents a point in space, whereas a vector represents a distance from something else
a point does not have a magnitude, a vector does
in math, a point represents a point in space, whereas a vector represents a distance from something else
a point does not have a magnitude, a vector does
Aand quite often the use of an integer vector is as a point in space
TYou can't really compute a "usable" length for
it's like division, in that it is implicitly lossy and needs a pair (remainder) so that you can recover the lost information
Vector2<int> because it loses datait's like division, in that it is implicitly lossy and needs a pair (remainder) so that you can recover the lost information
Tit's also the same reason we don't expose
Pow for integers, it is fundamentally lossy and ill suited for most needsKagain I wouldn't know where to make the difference there also - like, I fully agree that for an int type it can make sense to have some alternative "distance" think with manhattan distance etc.
But then that either returns (int, int) which is super annoying if I want to compare / find the max / min etc, since then I get to manually stuff that into
Or it returns Vector2<int> leading back to the original problem
or it returns Vector2<float>, but that makes the case of getting each individual integer stupid (and might drop some precision)
Or it returns another point, but then I think the relative vs absolute idea is super muddied
But then that either returns (int, int) which is super annoying if I want to compare / find the max / min etc, since then I get to manually stuff that into
Vector2<float> and do the conversionsOr it returns Vector2<int> leading back to the original problem
or it returns Vector2<float>, but that makes the case of getting each individual integer stupid (and might drop some precision)
Or it returns another point, but then I think the relative vs absolute idea is super muddied
Ktheyre the same thing though, a point does have a magnitude insofar as it is also a 3-array in euclidean space. maybe its just me but im fundamentally incapable of describing an actual difference between points and vectors
Kmaybe its because im an abstract math person
Kbut the two are just fundamentally the same to me
Tright, which is why you separate the types
so you have things that can do
so you have things that can do
T in, T outI mean yes, but we still have integer division and remainder separately and I would think the number of users that frequently use the combined function for that are low. Most people still expect to be able to divide integers like normal, ignoring the loss
Tusing it combined is the number one way to do it
Knot sure I get this - if I have a separate point type what does - return?
Kalso we cant even define length for vector2<int> rn because int doesnt implement IRootFunctions
Kand we cant conditionally use static virtuals
Aextension methods
Kwhich brings us right back to the start
KThat is a bit surprising. Not sure but I have used the combined integer division maybe once. (ignoring things in algorithms I didn't come up with)
like finding the average of integers I think is super common to just do integer division cause the precision isn't that important
like finding the average of integers I think is super common to just do integer division cause the precision isn't that important
TPoint2<T>.DistancePoint2<T>which then allows you to do the correct and efficient thing for integers
and for floating-point, you can convert to
Vector2<T>or to do per dimension stepping, which is incredibly useful for interpolation (especially with physics)
Kwhere we have a loosely constrained type with few members and a bunch of extensions as we have been considering the whole time
Athat's how my math library works
Aand it works well for me