I was asked to improve the quality of the sphere shader, so I did a bit of work on the version I already edited. It's a bit more complicated, so it takes a lot more instructions compared to the original, but it's worth it.
If someone can help a bit with the old cinema film grain effect shader with colorimetry data of silver grains, sepia toning and such, or with documented methods that could help (that don't use external textures), I would appreciate it. I'm a bit stuck at getting significantly better results from prototype shaders compared to the already available shaders unfortunately. I had to guess a lot of variables, so that's one of the problems. Another problem is getting multiple grain sizes on screen, with decent randomness.// (C) 2011-2014 Jan-Willem Krans (janwillem32 <at> hotmail.com)
// This file is part of Video pixel shader pack.
// This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
// sphere, Catmull-Rom spline4×4 interpolated
// This shader should be run as a screen space pixel shader if you are up-scaling.
// This shader should not be run as a screen space pixel shader if you are down-scaling.
// This shader requires compiling with ps_2_a, but higher is better, see http://en.wikipedia.org/wiki/Pixel_shader to look up what PS version your video card supports.
// This shader is meant to work with linear RGB input and output. Regular R'G'B' with a video gamma encoding will have to be converted with the linear gamma shaders to work properly.
// Use this shader to apply an effect that looks like projecting the video from a rotating sphere.
// fractions, either decimal or not, are allowed
// rotation speed, in rotations per second
#define rs .125
// border canvas size
#define bs 7.75
// border gamma factor
#define bf 128.
// light position
#define pl float3(6., -6., -7.)
// light intensity
#define cl .5
// light size
#define sl 64.
// camera position
#define pc float3(0., 0., -1.)
// sphere position
#define ps float3(0., 0., .75)
// sphere radius
#define ra acos(-1.)*.25
// base size constant
#define Ai 1.
sampler s0;
float4 c0 : register(c0);
float2 c1 : register(c1);
#define sp(a, b, c) float3 a; {float2 tmp = tex+c1*float2(b, c); a = tex2D(s0, frac(abs(float2(tmp.x, abs(tmp.y)*-1.+1.)))).rgb;}
float4 main(float2 tex : TEXCOORD0) : COLOR
{
float ar = c0.x*c1.y;// aspect ratio
tex.x = tex.x*ar+.5-.5*ar;// surface rectangle to square
// relate the sphere to the camera position
float3 pd = normalize(float3(tex.xy-.5, 0.)-pc);
float B = dot(pd, 2.*(pc-ps));
float C = dot(pc-ps, pc-ps)-pow(ra, 2);
float D = B*B-4.*Ai*C;// calculate the sphere
if(D < 0.) return 0.;// output black borders, only map if things are inside the sphere
// intersection data
float3 p = pc+pd*(-sqrt(D)-B)*.5/Ai;
float3 n = normalize(p-ps);
float3 l = normalize(pl-p);
float2 cd = .75*(.5-tex);// measure the distance to the image center
tex = acos(-n.xy)/acos(-1.);// mapping the image onto the sphere
tex.x = frac(tex.x+c0.w*rs);// rotation
tex.y = (tex.y-.5)*ar-.5;// aspect ratio correction
tex *= c0.xy;// normalize to texture size in pixels
float2 t = frac(tex);// calculate the difference between the output pixel and the original surrounding two pixels
tex = (tex-t+.5)*c1+float2(1., 0.);// make the sampling position line up with an exact pixel coordinate for L1, normalized to the interval (1, 2), not (0, 1) as we want texture wrapping in this case
// weights
float2 t2 = t*t, t3 = t2*t;
float4 w13 = t3.xyxy*float2(1.5, .5).xxyy+t2.xyxy*float2(-2.5, -.5).xxyy;
float4 w02 = t3.xyxy*float2(-.5, -1.5).xxyy+t2.xyxy*float2(1., 2.).xxyy+t.xyxy*float2(-.5, .5).xxyy;
w13.xw += 1.;
// original pixels
sp(L0, -1., -1.) sp(L1, -1., 0.) sp(L2, -1., 1.) sp(L3, -1., 2.)
sp(K0, 0., -1.) sp(K1, 0., 0.) sp(K2, 0., 1.) sp(K3, 0., 2.)
sp(J0, 1., -1.) sp(J1, 1., 0.) sp(J2, 1., 1.) sp(J3, 1., 2.)
sp(I0, 2., -1.) sp(I1, 2., 0.) sp(I2, 2., 1.) sp(I3, 2., 2.)
// vertical interpolation
float3 Q0 = L0*w02.y+L1*w13.y+L2*w02.w+L3*w13.w;
float3 Q1 = K0*w02.y+K1*w13.y+K2*w02.w+K3*w13.w;
float3 Q2 = J0*w02.y+J1*w13.y+J2*w02.w+J3*w13.w;
float3 Q3 = I0*w02.y+I1*w13.y+I2*w02.w+I3*w13.w;
float3 P0 = Q0*w02.x+Q1*w13.x+Q2*w02.z+Q3*w13.z;// horizontal interpolation
return ((P0+cl*pow(max(dot(l, reflect(pd, n)), 0.), sl))*min(pow(bs*dot(cd, cd), -bf), 1.)*dot(n, l)).rgbb;// add specular mapping, sphere edges, diffuse mapping and then output
}// (C) 2011-2014 Jan-Willem Krans (janwillem32 <at> hotmail.com)
// This file is part of Video pixel shader pack.
// This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
// sphere, Catmull-Rom spline4×4 interpolated on 16-bit integer surfaces
// This shader should be run as a screen space pixel shader if you are up-scaling.
// This shader should not be run as a screen space pixel shader if you are down-scaling.
// This shader requires compiling with ps_2_a, but higher is better, see http://en.wikipedia.org/wiki/Pixel_shader to look up what PS version your video card supports.
// This shader is meant to work with linear RGB input and output. Regular R'G'B' with a video gamma encoding will have to be converted with the linear gamma shaders to work properly.
// Use this shader to apply an effect that looks like projecting the video from a rotating sphere.
// fractions, either decimal or not, are allowed
// rotation speed, in rotations per second
#define rs .125
// border canvas size
#define bs 7.75
// border gamma factor
#define bf 128.
// light position
#define pl float3(6., -6., -7.)
// light intensity
#define cl .5
// light size
#define sl 64.
// camera position
#define pc float3(0., 0., -1.)
// sphere position
#define ps float3(0., 0., .75)
// sphere radius
#define ra acos(-1.)*.25
// base size constant
#define Ai 1.
sampler s0;
float4 c0 : register(c0);
float2 c1 : register(c1);
#define sp(a, b, c) float3 a; {float2 tmp = tex+c1*float2(b, c); a = tex2D(s0, frac(abs(float2(tmp.x, abs(tmp.y)*-1.+1.)))).rgb;}
float4 main(float2 tex : TEXCOORD0) : COLOR
{
float ar = c0.x*c1.y;// aspect ratio
tex.x = tex.x*ar+.5-.5*ar;// surface rectangle to square
// relate the sphere to the camera position
float3 pd = normalize(float3(tex.xy-.5, 0.)-pc);
float B = dot(pd, 2.*(pc-ps));
float C = dot(pc-ps, pc-ps)-pow(ra, 2);
float D = B*B-4.*Ai*C;// calculate the sphere
if(D < 0.) return 0.;// output black borders, only map if things are inside the sphere
// intersection data
float3 p = pc+pd*(-sqrt(D)-B)*.5/Ai;
float3 n = normalize(p-ps);
float3 l = normalize(pl-p);
float2 cd = .75*(.5-tex);// measure the distance to the image center
tex = acos(-n.xy)/acos(-1.);// mapping the image onto the sphere
tex.x = frac(tex.x+c0.w*rs);// rotation
tex.y = (tex.y-.5)*ar-.5;// aspect ratio correction
tex *= c0.xy;// normalize to texture size in pixels
float2 t = frac(tex);// calculate the difference between the output pixel and the original surrounding two pixels
tex = (tex-t+.5)*c1+float2(1., 0.);// make the sampling position line up with an exact pixel coordinate for L1, normalized to the interval (1, 2), not (0, 1) as we want texture wrapping in this case
// weights
float2 t2 = t*t, t3 = t2*t;
float4 w13 = t3.xyxy*float2(1.5, .5).xxyy+t2.xyxy*float2(-2.5, -.5).xxyy;
float4 w02 = t3.xyxy*float2(-.5, -1.5).xxyy+t2.xyxy*float2(1., 2.).xxyy+t.xyxy*float2(-.5, .5).xxyy;
w13.xw += 1.;
// original pixels
sp(L0, -1., -1.) sp(L1, -1., 0.) sp(L2, -1., 1.) sp(L3, -1., 2.)
sp(K0, 0., -1.) sp(K1, 0., 0.) sp(K2, 0., 1.) sp(K3, 0., 2.)
sp(J0, 1., -1.) sp(J1, 1., 0.) sp(J2, 1., 1.) sp(J3, 1., 2.)
sp(I0, 2., -1.) sp(I1, 2., 0.) sp(I2, 2., 1.) sp(I3, 2., 2.)
// vertical interpolation
float3 Q0 = L0*w02.y+L1*w13.y+L2*w02.w+L3*w13.w;
float3 Q1 = K0*w02.y+K1*w13.y+K2*w02.w+K3*w13.w;
float3 Q2 = J0*w02.y+J1*w13.y+J2*w02.w+J3*w13.w;
float3 Q3 = I0*w02.y+I1*w13.y+I2*w02.w+I3*w13.w;
float3 P0 = Q0*w02.x+Q1*w13.x+Q2*w02.z+Q3*w13.z;// horizontal interpolation
return ((P0*65535./32767.-16384./32767.+cl*pow(max(dot(l, reflect(pd, n)), 0.), sl))*min(pow(bs*dot(cd, cd), -bf), 1.)*dot(n, l)*32767./65535.+16384./65535.).rgbb;// add specular mapping, sphere edges, diffuse mapping and then output
}