Blender is pretty nice. But, its a bit large.
Anyway, matter not in a sense. Its a tool. And it fun to program in
Python for it.
On 8/13/2026 2:37 AM, BGB wrote:
[...]
Fwiw, I made this in OpenSCAD, its pretty nice. openscad Almost reminds
me of povray...
https://skfb.ly/oqQEV
On Thu, 13 Aug 2026 18:50:05 -0700, Chris M. Thomasson wrote:
Blender is pretty nice. But, its a bit large.
It?s a lot smaller download than Autodesk Maya or proprietary
alternatives like that.
Anyway, matter not in a sense. Its a tool. And it fun to program in
Python for it.
I would say it caters to both sides of the brain -- artistic and
technical. Skill in CG depends on a lot on developing capacity in
both.
On 8/11/2026 8:17 AM, James Kuyper wrote:
On 2026-08-10 21:44, BGB wrote:
On 8/10/2026 7:03 PM, James Kuyper wrote:
On 2026-08-10 18:31, BGB wrote:
Snipped section included my epic fail at trying to use traditional >>>> style
mathematical notation in a Usenet post...
It was bugging me, by implying the conjugate was a scalar, where
no, the
conjugate is not a scalar...
I'm not sure what you're saying. As far as C is concerned. complex
types
are floating types (6.2.5p15), and therefore arithmetic types
(6.2.5p23), and therefore scalar types (6.2.5p26) Therefore, a function >>>> that returns the conjugate of its argument would return a scalar type.
I wrote:
ÿÿÿ R^-1 = (R.r-R.i-R.j-R.k) / (R.r*R.r + R.i*R.i + R.j*R.j + R.k*R.k)
The problem:
ÿÿÿ (R.r-R.i-R.j-R.k)
Should have been, say:
ÿÿÿ (R.r - R.i*I - R.j*J - R.k*K)
Which was bugging me, because either the former would be interpreted as
meaning a scalar (or real-valued) result, or "R.i*R.i" as being
negative, neither of which was true in the intended expression...
I was confused because you were writing about complex numbers, mentioned
that you had snipped some material, and then made a comment that I
assumed, from context, was also about complex numbers. I did not realize
that there was a context switch to quaternions inside the snipped
material.
In the unlikely event that that were added to C, quaternions would
almost certainly be added as a new arithmetic (and therefore, scalar)
type, by analogy with the complex types. I was unaware, until just now
when I looked it up, that the real part of a quaternion is often
referred to as it's scalar part.
That's a little odd, because I'm one of the probably very few people
here who've actually made practical use of quaternions. I had to deal
with data about spacecraft orientation that was stored as a quaternion,
and convert between quaternions and corresponding Euler angles and
Rotation matrices. However, a quaternion library was part of the
standard toolkit for that project, which makes sense.
quaternion are very useful for such things. Avoiding gimbal lock?
On 8/13/2026 9:41 PM, Lawrence D?Oliveiro wrote:
On Thu, 13 Aug 2026 18:50:05 -0700, Chris M. Thomasson wrote:
Blender is pretty nice. But, its a bit large.
It?s a lot smaller download than Autodesk Maya or proprietary
alternatives like that.
Better not to poke those with a stick IMO.
They are specially designed to try to create vendor lock-in and then
trick people into paying subscriptions to keep using the software;
not worth it.
Anyway, matter not in a sense. Its a tool. And it fun to program in
Python for it.
I would say it caters to both sides of the brain -- artistic and
technical. Skill in CG depends on a lot on developing capacity in
both.
Yes, but still doesn't mean one wants to create a hard dependency on
Blender or Python...
Sometimes, one just wants a few tools:
A tool that converts a language to a 3D model in a specified format
via a command-like or text-script so that it can be packaged up in
some asset format (or output geometry as STL or "Wavefront OBJ" or
similar); Another tool that allows viewing the 3D model, and
launches quickly and doesn't require dealing with some cumbersome
file selector dialog and import UI and similar; ...
SLERP'ing between identity and a given rotation allows scaling the
rotation;
On Thu, 13 Aug 2026 23:50:16 -0500, BGB wrote:
SLERP'ing between identity and a given rotation allows scaling the
rotation;
You can?t linearly interpolate the sines and cosines, though. If you
want to do linear interpolation of the rotation angle, don?t you have
to compute inverse sines/cosines, calculate new angles and then back
again?
On 8/14/2026 12:59 AM, Lawrence D?Oliveiro wrote:
On Thu, 13 Aug 2026 23:50:16 -0500, BGB wrote:
SLERP'ing between identity and a given rotation allows scaling the
rotation;
You can?t linearly interpolate the sines and cosines, though. If
you want to do linear interpolation of the rotation angle, don?t
you have to compute inverse sines/cosines, calculate new angles and
then back again?
This is where it can get funny:
While naive interpolation goes off the unit-sphere, re-normalizing
the quaternion generally puts it back at around the position it
would have been had one followed an arc over the surface of the
hyper-sphere between these points (at least within +/- 180 degrees,
and not necessarily at a uniform velocity if the distance is large).
This is both more convenient and cheaper than using sines or cosines
or trying to follow an arc. One can use them, but don't need to.
As can be noted, multiplying rotations also effectively concatenates
them.
Can't really explain how it works...
On 8/11/2026 3:47 PM, Chris M. Thomasson wrote:
On 8/11/2026 8:17 AM, James Kuyper wrote:
On 2026-08-10 21:44, BGB wrote:
On 8/10/2026 7:03 PM, James Kuyper wrote:
On 2026-08-10 18:31, BGB wrote:I wrote:
Snipped section included my epic fail at trying to usetraditional
style
mathematical notation in a Usenet post...
It was bugging me, by implying the conjugate was a scalar, where
no, the
conjugate is not a scalar...
I'm not sure what you're saying. As far as C is concerned. complex
types
are floating types (6.2.5p15), and therefore arithmetic types
(6.2.5p23), and therefore scalar types (6.2.5p26) Therefore, a
function
that returns the conjugate of its argument would return a scalar type. >>>>
ÿÿÿ R^-1 = (R.r-R.i-R.j-R.k) / (R.r*R.r + R.i*R.i + R.j*R.j + R.k*R.k) >>>>
The problem:
ÿÿÿ (R.r-R.i-R.j-R.k)
Should have been, say:
ÿÿÿ (R.r - R.i*I - R.j*J - R.k*K)
Which was bugging me, because either the former would be interpreted as >>>> meaning a scalar (or real-valued) result, or "R.i*R.i" as being
negative, neither of which was true in the intended expression...
I was confused because you were writing about complex numbers, mentioned >>> that you had snipped some material, and then made a comment that I
assumed, from context, was also about complex numbers. I did not realize >>> that there was a context switch to quaternions inside the snipped
material.
In the unlikely event that that were added to C, quaternions would
almost certainly be added as a new arithmetic (and therefore, scalar)
type, by analogy with the complex types. I was unaware, until just now
when I looked it up, that the real part of a quaternion is often
referred to as it's scalar part.
That's a little odd, because I'm one of the probably very few people
here who've actually made practical use of quaternions. I had to deal
with data about spacecraft orientation that was stored as a quaternion,
and convert between quaternions and corresponding Euler angles and
Rotation matrices. However, a quaternion library was part of the
standard toolkit for that project, which makes sense.
quaternion are very useful for such things. Avoiding gimbal lock?
Among other things:
No gimbal lock;
Can LERP/SLERP;
SLERP'ing between identity and a given rotation allows scaling the
rotation;
Can be used as a vector for angular velocity or angular inertia math;
Can be multiplied for compound rotations (like with matrix math);
Try to SLERP a matrix, and it may "rubber band" or have other weird glitches;
Try to LERP Euler angles and the motion may end up going in some totally weird direction;
...
If you use two of them (a "dual quaternion"), it is possible to express fairly arbitrary transforms (translation + rotation).
Like, were pretty useful for doing something like a rigid-body physics engine, even if the physics engine itself turned out to not be very useful.
On Thu, 13 Aug 2026 23:50:16 -0500, BGB wrote:
SLERP'ing between identity and a given rotation allows scaling the
rotation;
You can?t linearly interpolate the sines and cosines, though. If you
want to do linear interpolation of the rotation angle, don?t you have
to compute inverse sines/cosines, calculate new angles and then back
again?
float angle_min = 0;
float angle_max = PI/2;
float angle_dif = angle_max - angle_min;
float normal_base = 1.f/n
for (unsigned long i = 0; i < n; ++i)
{
float normal = normal_base * i;
float angle = angle_min + angle_dif * normal;
float x0 = cos(angle);
float y0 = sin(angle);
// (x0, y0) as normalized here
// render line from (0, 0) to (x0, y0)...
}
On Fri, 14 Aug 2026 12:36:25 -0700, Chris M. Thomasson wrote:
float angle_min = 0;
float angle_max = PI/2;
float angle_dif = angle_max - angle_min;
float normal_base = 1.f/n
for (unsigned long i = 0; i < n; ++i)
{
float normal = normal_base * i;
float angle = angle_min + angle_dif * normal;
float x0 = cos(angle);
float y0 = sin(angle);
// (x0, y0) as normalized here
// render line from (0, 0) to (x0, y0)...
}
But the quaternion doesn?t directly give you the angle to begin with,
you will need to do an inverse trig computation to get it. And then do
the above trig calls for every segment.
I just wondered if there was a way to go straight from cos/sin of an
angle to cos/sin of fractions of that angle ... I think there is.
Or start from the angles and create a quat?
Depends on what angles you are looking for?
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 9 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 245:21:40 |
| Calls: | 220 |
| Files: | 21,513 |
| Messages: | 83,782 |