

This function will create standard machine screw righthanded threading.
It accepts major diameter and thread count as arguments, and it should
work for both USA and metric sizes. (The geometry has been standardized
internationally.) The shaft is oriented vertically. In order to
minimize square root calculations within the runtime loop, a constant is
declared outside the function.
[BEGIN CODE]
#include "functions.inc"
#local HTRI2 = sqrt(3);
#declare fn_Screw = function (x, y, z, P0_Dmajor, P1_Thread_count)
{ max
( min
( f_helix1
( x, y, z, 1, 2*pi * P1_Thread_count,
HTRI2 / (2 * P1_Thread_count),
P0_Dmajor / 2  0.4375 * HTRI2 / P1_Thread_count,
1 / HTRI2, 2, 0
),
f_sphere (x, 0, z, P0_Dmajor / 2  0.3125 * HTRI2 / P1_Thread_count)
),
f_sphere (x, 0, z, P0_Dmajor / 2)
)
}
[END CODE]
To get lefthanded threading, replace the x with x.
As a sanity check, I compared my function to Robert Munyer's post from
last June. Despite the differences in form, the numbers turn out to be
the same.
This next function is less straightforward, because it entails twisting
a square and the rescaling that entails, but it renders slightly
faster. I saved about 7% in tests.
[BEGIN CODE]
#include "functions.inc"
#local HTRI2 = sqrt(3);
#local P2FACTOR = sqrt(3/8);
#declare fn_Screw = function (x, y, z, P0_Dmajor, P1_Thread_count)
{ max
( min
( f_helix1
( x, y, z, 1, 2*pi * P1_Thread_count,
P2FACTOR / P1_Thread_count,
P0_Dmajor / 2  0.4375 * HTRI2 / P1_Thread_count,
1 / HTRI2, 0, 45
),
f_sphere (x, 0, z, P0_Dmajor / 2  0.3125 * HTRI2 / P1_Thread_count)
),
f_sphere (x, 0, z, P0_Dmajor / 2)
)
}
[END CODE]
The one disadvantage of the above functions is that they are too
perfect. With the sharp angles, it is difficult to get good highlights
and avoid that "raytraced look." I'm sure there's some normals trick
or proximity macro that can improve the look, and I'm even
halfconsidering writing a tedious function for a softer version of
those hills and valleys; but if there's no need for a closeup of the
screws, this next function can get you some shiny screws of a reasonable
form.
[BEGIN CODE]
#include "functions.inc"
#local HTRI = sqrt (3/4);
#declare fn_Screw = function
( x, y, z, P0_Dmajor, P1_Thread_count
)
{ f_sphere
( x, 0, z,
P0_Dmajor / 2
 (1  cos (y * 2*pi * P1_Thread_count + atan2 (x, z)))
* 0.3125 * HTRI / P1_Thread_count
)
}
[END CODE]
If you wish to model screw holes but don't want to bother modeling the
internal threads, this function will give you the proper internal
radius. Since it's likely use is at parse time, not in isosurfaces, I
have not bothered to predeclare any constants. Note that, as written,
it accepts a diameter but returns a radius.
[BEGIN CODE]
#declare fn_Screw_hole_radius = function (P0_Dmajor, P1_Thread_count)
{ P0_Dmajor / 2  5 * sqrt(3) / (16 * P1_Thread_count)
}
[END CODE]
Post a reply to this message

