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 needs
Kagain 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 out and represent the concepts in a way that works well for the common needs
KI 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>.Distance returns a Point2<T>, which represents the per dimension steppingwhich then allows you to do the correct and efficient thing for integers
and for floating-point, you can convert to
Vector2<T> to get it in terms of length (at the same total cost)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
Ai can't say on a global scale but
Kyeah and that was the thing being worked on hours ago
KRight, but if Point2<T>.Distance returns Point2 again, then we can't really say Point is the absolute type, since that returned point is meaningless without the source it came from
Kit'll find us some point on the grid that just doesn't have any meaning at all
Kbefore the argument started on whether vector3<int> should be permissable out of almost nowhere
Ahave we considered that we may be overthinking this
Kyeah im with just continuing as is, allowing vector3<int> is easy within the framework as proposed and anything more involved is probably overthinking imo
Tdivision isn't often used for things like computing averages, at least not for integers
you typically use floating/fixed point (user facing apps, they expect fractional results)
in practice it gets used for things like bucketing and finding the relevant offset in an array
which includes using the remainder to get the actual final offset
you typically use floating/fixed point (user facing apps, they expect fractional results)
in practice it gets used for things like bucketing and finding the relevant offset in an array
which includes using the remainder to get the actual final offset
Tthere ends up having to be some allowances in the type system, in a way that makes sense
nothing is going to be perfect, it's more a question of can you separate the two core needs enough
so that you aren't ending up with a type that can do 10% of the functionality if you have an integer and 100% with a float
nothing is going to be perfect, it's more a question of can you separate the two core needs enough
so that you aren't ending up with a type that can do 10% of the functionality if you have an integer and 100% with a float
Tbecause having a type where the user doesn't have access to 90% of the functionality, isn't good design
Tespecially if that is expected/common functionality
Ki feel like you might be overestimating how much gamedevs expect a vector-ish type to have length
Kis that because gamedev has bad conventions? yes
Kbut still
Kidk for sure
Tmaybe I'm contrasting AAA vs indie development too much
but, length is a core need for using vectors correctly and efficiently
but, length is a core need for using vectors correctly and efficiently
Pthis is the closing remark on which my brain has shut off here
Pbut these are all important discussion points, as it's bad to have a preconceived conlusion without considering all relevant factors
Tas is normalization, if you aren't normalizing your vectors and local coordinate space
then you're likely losing precision and introducing physics and rendering bugs/quirks
then you're likely losing precision and introducing physics and rendering bugs/quirks
T(and lots of rubber banding/jitter)
KYeah I mean this I fully agree with. I'm just not sure separating into multiple types is the way I want out of this.
I like the 2.X idea of allowing anything on anything, but obviously "try it and see what happens" isn't great.
The current 3.0 design IMO goes too much into having too many things unavailable.
Having more types is of course a solution, but then we have to somehow get the user to choose the correct types.
I like the 2.X idea of allowing anything on anything, but obviously "try it and see what happens" isn't great.
The current 3.0 design IMO goes too much into having too many things unavailable.
Having more types is of course a solution, but then we have to somehow get the user to choose the correct types.
TAnother alternative is to force users to use floating-point (it's better/more appropriate anyways)
and provide some specialized functions for creating a
and provide some specialized functions for creating a
Vector2/3/4<T> from integer typesKseparate types would actually make my reflection-based vertex attribute stuff easyer tbh, it just feels awkward and the integer one doesnt have a natural name imo since point overlooks a bunch of uses for integer tuples supporting some basic vector ops
KThis is true IMO, but I like the rational for
Half a lot. If you choose the type you likely know of the trade offs and putting further barriers in place just to confirm you actually know what you're doing is unecessary. Similar for VectorN<byte> etc.K(also - ignoring any arguments around naming here, idk if I would feel good about Point either, given we also have line and other geometry but that's irrelevant right now)
