Scripting a Rotatable Gradient Sphere

I was able to get pretty far working with a Refraction based mapping to a rotatable sphere. Unfortunately, it's only fooling the eye; there's still unwanted distortion and not-quite full range of motion. A proper sphere mapping will take a bit of pseudo 3d scripting. Lua can do it, but most of the methods I've come across require external libraries. For what amounts to a sphere primitive, I don't think I would need to go that far.

Anyway, here's the ffxml for my rotatable sphere snippet:

Rotatable Sphere Snippet V3.ffxml

I succeeded in accomplishing half of the gradients needed to create a Rotatable Sphere Script -- a gradient from the north to south pole (is that the y-axis?). To complete my script I need some help with the math to produce the x-axis, basically an angle gradient from the far east to the far west. There's an example of this above. I have tried finding an example of cartesian to polar mapping for lua, but have had no luck. I'm hoping that is the solution I'm looking for.

Code

-- 3d sphere    -- produces rgb gradient mapped to a 3d sphere, but not correctly.    -- how would one map x:red and y:green gradients instead?    -- this is basically missing an angle gradient in the y-axis... function prepare()    -- tilt & rotation precalc       -- it would be nice to know how this works!    toRad = 180/math.pi    radius = get_slider_input(RADIUS)    angle = get_angle_input(ROTATION)/toRad    cosa = math.cos(angle)    sina = math.sin(angle)    tilt = get_angle_input(TILT)/toRad    cosa2 = math.cos(tilt)    sina2 = math.sin(tilt) end; function get_sample(x, y)    local r, g, b, a = get_sample_map(x, y, SOURCE)    -- color gradient example    --    local r = x    --    local g = y    --    local b = (x + y) / 2    --    local a = 1    -- image generation    local px = (x*2.0) - 1.0    local py = (y*2.0) - 1.0    px = px/radius    py = py/radius    local len = math.sqrt((px*px)+(py*py))    if len > 1.0 then return 0,0,0,0 end    local z = -math.sqrt(1.0 - ((px*px)+(py*py)))    local tz = (cosa2 * z) - (sina2 * py)    local ty = (sina2 * z) + (cosa2 * py)    z = tz    py = ty    local tx = (cosa * px) - (sina * z)    local tz = (sina * px) + (cosa * z)    px = tx    z = tz    return px/2+.5,px/2+.5,px/2+.5,a -- r, g, b, a end;

Here are a couple examples from other scripting languages...

Code

--  cartesian to polar (reference)    --   example 1    --    r = math.sqrt((cart.x * cart.x + cart.y * cart.y + cart.z * cart.z));    --    long = math.acos(cart.x / math.sqrt(cart.x * cart.x + cart.y * cart.y)) * (cart.y < 0 ? -1 : 1);    --    lat = math.acos(cart.z / radius) * (cart.z < 0 ? -1 : 1);    --   example 2    --   r = sqrt(x * x + y * y + z * z)    --    long = acos(x / sqrt(x * x + y * y)) * (y < 0 ? -1 : 1)    --    lat = acos(z / r)

After several days of poking around I have only found one working example in which the x and y gradients can only be generated along their respective axes. I just can't puzzle out a method of generating a gradient around an axis using polar-to-cartesian and cartesian-to-polar coordinate conversions. Does that seem right? I may just be failing to do the cartesian-to-polar correctly, most likely due to the boolean operation inside the examples I found for other coding languages. I still have to say that the apparent logic of those equations makes it seem like longitude variable contains a circumferential gradient. You just can't pull it out using polar-to-cartesian equations. If I could, then a sampling of source images would be possible in a map script. Maybe that requires some form of computational uv mapping?

Any kind of feedback would be welcome here...

Well, the long and the short of it is that the process I've been working with is in the wrong coordinate system. The gradient sphere I have is based on the polar-to-cartesian coordinate system. That gives me x, y, z gradients in the three axes. What I want is gradients for theta and phi, or longitude and latitude. I'm actually getting values for theta and phi from my control sliders, which rotate the generated sphere. I'll try to see if I can sample those values, and if they (somehow) produce the correct gradients, but a little help would be appreciated, since I don't have any examples to work with like that.

I managed to solve the problem of scripting a rotatable sphere with the proper remapping gradients sometime last month, but am still tweaking and experimenting with the next logical steps. I never bothered to update this thread with my progress, and now there are too many different script versions; I can't decide which one to share. However, there's a good chance a few of them will find their way into filters. I have a number of planetary filters in the works, so you can expect to see some there. I'll probably submit one as a 3d rotatable sphere snippet (or even effect filter, since I can now map the input to a sphere, assuming it's prepared for spherical mapping). If I do, I'll come back and post the code that goes with it, for anyone who might just want to look at the script but doesn't need a working copy.

TTFN