The Number One Resource For Stereoscopic 3D Excitement!
https://www.mtbs3d.com/phpbb/
Code: Select all
#version 120
uniform sampler2D Texture;
uniform vec2 LensCenter;
uniform vec2 ScreenCenter;
uniform vec2 Scale;
uniform vec2 ScaleIn;
uniform vec4 HmdWarpParam;
varying vec2 oTexCoord;
// Scales input texture coordinates for distortion.
vec2 HmdWarp(vec2 in01)
{
vec2 theta = (in01 - LensCenter) * ScaleIn; // Scales to [-1, 1]
float rSq = theta.x * theta.x + theta.y * theta.y;
vec2 rvector = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq +
HmdWarpParam.z * rSq * rSq +
HmdWarpParam.w * rSq * rSq * rSq);
return LensCenter + Scale * rvector;
}
void main()
{
vec2 tc = HmdWarp(oTexCoord);
if (any(bvec2(clamp(tc,ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)) - tc)))
{
gl_FragColor = vec4(vec3(0.0), 1.0);
return;
}
gl_FragColor = texture2D(Texture, tc);
}
Code: Select all
if (any(bvec2(clamp(tc,ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)) - tc)))
I've just been using the default values from the Tuscany demo. If you're not worried about calculating everything based on different IPDs and panel sizes yet then these values should be fine.eshan wrote:Now I just need to figure out all the stuff I need to supply at the top!
Code: Select all
// left
vec2 LensCenter = vec2(0.2863248, 0.5);
vec2 ScreenCenter = vec2(0.25, 0.5);
vec2 Scale = vec2(0.1469278, 0.2350845);
vec2 ScaleIn = vec2(4, 2.5);
vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
// right
vec2 LensCenter = vec2(0.7136753, 0.5);
vec2 ScreenCenter = vec2(0.75, 0.5);Code: Select all
uniform sampler2D bgl_RenderedTexture;
void main(void)
{
vec4 texcolor = texture2D(bgl_RenderedTexture, gl_TexCoord[0].st);
float gray = dot(texcolor.rgb, vec3(0.299, 0.587, 0.114));
gl_FragColor = vec4(gray * vec3(0.8, 1.0, 1.2), texcolor.a);
}
I have not found a way to pass uniforms to 2D filter shaders, so they need to be replaced with const variables. Also, the built-in gl_TexCoord[0] variable should be used. The following shader should work, provided you apply it per frame.eshan wrote:fredrik,
I actually never got the stereo camera working. I currently have two cameras Parented, each with a viewport taking half the screen. In this configuration, do you seen any issues using the distortion shader? If not, any tips on getting it working?
Code: Select all
#version 120
uniform sampler2D bgl_RenderTexture;
const vec2 LeftLensCenter = vec2(0.2863248, 0.5);
const vec2 RightLensCenter = vec2(0.7136753, 0.5);
const vec2 LeftScreenCenter = vec2(0.25, 0.5);
const vec2 RightScreenCenter = vec2(0.75, 0.5);
const vec2 Scale = vec2(0.1469278, 0.2350845);
const vec2 ScaleIn = vec2(4, 2.5);
const vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
// Scales input texture coordinates for distortion.
vec2 HmdWarp(vec2 in01, vec2 LensCenter)
{
vec2 theta = (in01 - LensCenter) * ScaleIn; // Scales to [-1, 1]
float rSq = theta.x * theta.x + theta.y * theta.y;
vec2 rvector = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq +
HmdWarpParam.z * rSq * rSq +
HmdWarpParam.w * rSq * rSq * rSq);
return LensCenter + Scale * rvector;
}
void main()
{
// The following two variables need to be set per eye
vec2 LensCenter = gl_FragCoord.x < 640 ? LeftLensCenter : RightLensCenter;
vec2 ScreenCenter = gl_FragCoord.x < 640 ? LeftScreenCenter : RightScreenCenter;
vec2 oTexCoord = gl_TexCoord[0].xy;
//vec2 oTexCoord = (gl_FragCoord.xy + vec2(0.5, 0.5)) / vec2(1280, 800); //Uncomment if using BGE's built-in stereo rendering
vec2 tc = HmdWarp(oTexCoord, LensCenter);
if (any(bvec2(clamp(tc,ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)) - tc)))
{
gl_FragColor = vec4(vec3(0.0), 1.0);
return;
}
//tc.x = gl_FragCoord.x < 640 ? (2.0 * tc.x) : (2.0 * (tc.x - 0.5)); //Uncomment if using BGE's built-in stereo rendering
gl_FragColor = texture2D(bgl_RenderTexture, tc);
}
Small world, indeed! I hope you found it interesting/amusing. With this recent progress, there may be more videos forthcoming!Ben wrote:I also just realized you're the guy who did the Hydra video with the evil monkey that I stumbled upon while experimenting with input methods last year. Small world.
Code: Select all
float rSq = theta.x * theta.x + theta.y * theta.y;Code: Select all
float rSq = length(theta);Code: Select all
#version 120
#define highp
Adding context to my reply hereMrGreen wrote:Out of context that code change doesn't make much sense to me but then again, most discussions here don't either.
The line I changed basically uses the built-in length function in GLSL instead of calculating it manually. By doing this we have a chance to use some hardware optimization that may not be available if we just do the calculation manually as it is unlikely the GLSL compiler would catch that we could use the length function here.Code: Select all
gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);Code: Select all
gl_FragColor = vec4(vec3(0.0), 1.0);length(theta) is not functionally equivalent though.druidsbane wrote:Quick tip. The current shader with the code I have is making my program run at half the speed on my MacBook Air but I was able to eke out an extra 6fps by changing this line:toCode: Select all
float rSq = theta.x * theta.x + theta.y * theta.y;and adding at the top:Code: Select all
float rSq = length(theta);
I think the glsl version on the Mac is a bit old and not very optimized. You're right about length(theta) being wrong though from the docs they didn't mention they were taking the square root which is what one would have expected from length (http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml, maybe my browser isn't rendering some math characters rightshakesoda wrote: length(theta) is not functionally equivalent though.
for it to be functionally the same you'd have to do pow(length(theta), 2). I personally saw no performance difference when switching these lines to different things (using an nvidia gt 330 + 313.30 drivers on linux). precision highp is the default in glsl, too, so I wonder what's going on.
as for expanding the vec4 initialization, I find it a little hard to believe there's a compiler that might not expand that by itself.
as I just see blanks where the math symbols should be). Switching to dot(theta,theta) yielded the same performance as the unrolling in the code above. Also, in terms of performance differences, my code is now running at 30fps so any small change can have an effect it would seem Code: Select all
// left
vec2 leftLensCenter = vec2(0.2863248 * 2.0, 0.5);
vec2 Scale = vec2(0.1469278, 0.2350845);
vec2 ScaleIn = vec2(2.5, 2.5);
vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
// right
vec2 rightLensCenter = vec2((0.7136753 - 0.5) * 2.0, 0.5);
vec2 screenCenter = vec2(0.5, 0.5);
Code: Select all
vec2 Scale = vec2(0.2938556, 0.2350845);
vec2 ScaleIn = vec2(2, 2.5);I'll post the shader for people convinience. In textures are variable, for Rift it's normally set to 640x800. Shader is applied on 1280x800 texture.Ben wrote:I'm not positive, but I think the scale values should be:Everything else looks right, but I haven't actually tried it.Code: Select all
vec2 Scale = vec2(0.2938556, 0.2350845); vec2 ScaleIn = vec2(2, 2.5);
Edit: Actually I'm not sure I interpreted the question properly. Are you trying to apply the distortion to each eye in two separate shaders, or applying it to each eye individually within the same shader?
The scale values I've included above should work for a 640x800 texture which is being drawn to a 640x800 viewport, but if you're sampling the 640x800 textures for both eyes and drawing them to their respective halves of a 1280x800 viewport then you need to use the shader provided by shakesoda.
The SDK overview document from the developer center does a good job of explaining everything.
Code: Select all
uniform sampler2D passedTextureLeft;
uniform sampler2D passedTextureRight;
// left
float as = 1.0;
float w = 1.0;
float h = 1.0;
float scaleFactor = 1.0;
vec2 leftLensCenter = vec2((w + 0.25 * 0.5)*0.5, h*0.5);
vec2 Scale = vec2((w/2.0) * scaleFactor, (h/2.0) * scaleFactor * as);
vec2 ScaleIn = vec2((1.6), (1.6) / as);
vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
// right
vec2 rightLensCenter = vec2((w + -0.25 * 0.5)*0.5, h*0.5);
vec2 screenCenter = vec2(0.5, 0.5);
vec2 HmdWarp(vec2 in01, vec2 lensCenter)
{
vec2 theta = (in01 - lensCenter) * ScaleIn; // Scales to [-1, 1]
float rSq = theta.x * theta.x + theta.y * theta.y;
vec2 rvector = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq +
HmdWarpParam.z * rSq * rSq +
HmdWarpParam.w * rSq * rSq * rSq);
return lensCenter + Scale * rvector;
}
// In the main; far too many if statements I know..
vec4 texcoord = gl_TexCoord[0];
if (texcoord.x > 0.5) {
texcoord.x -= 0.5;
}
texcoord.x *= 2.0;
if (gl_TexCoord[0].x > 0.5) {
vec2 texcoord = HmdWarp(texcoord, rightLensCenter);
if (any(bvec2(clamp(texcoord,screenCenter-vec2(0.5,0.5), screenCenter+vec2(0.5,0.5)) - texcoord)))
{
gl_FragColor = vec4(vec3(0.0), 1.0);
return;
}
vec3 Reye;
Reye = switchEyes == 1 ? texture2D(passedTextureLeft, texcoord.xy).rgb : texture2D(passedTextureRight, texcoord.xy).rgb;
gl_FragColor.rgb = Reye;
gl_FragColor.a = 1.0;
} else {
vec2 texcoord = HmdWarp(texcoord, leftLensCenter);
if (any(bvec2(clamp(texcoord,screenCenter-vec2(0.5,0.5), screenCenter+vec2(0.5,0.5)) - texcoord)))
{
gl_FragColor = vec4(vec3(0.0), 1.0);
return;
}
vec3 Leye;
Leye = switchEyes == 1 ? texture2D(passedTextureRight, texcoord.xy).rgb : texture2D(passedTextureLeft, texcoord.xy).rgb;
gl_FragColor.rgb = Leye;
gl_FragColor.a = 1.0;
}
Code: Select all
// Projection matrix for the "center eye", which the left/right matrices are based on.
glm::mat4 projCenter = glm::perspective<float>(yfov, aspectRatio, 0.3f, 1000.0f);
glm::mat4 projLeft(1.0);
projLeft[0][3] = projectionCenterOffset;
projLeft *= projCenter;
glm::mat4 projRight(1.0);
projRight[0][3] = -projectionCenterOffset;
projRight *= projCenter;
// View transformation translation in world units.
float halfIPD = hmd.InterpupillaryDistance * 0.5f;
glm::mat4 viewCenter(1.0);
glm::mat4 viewLeft(1.0);
viewLeft[0][3] = halfIPD;
viewLeft *= viewCenter;
glm::mat4 viewRight(1.0);
viewRight[0][3] = -halfIPD;
viewRight *= viewCenter;I had to switch all the [0][3]'s with [3][0], but otherwise it seems to be correct now. I can't try it on my Rift until tonight, but thanks a bunch for the help!Ben wrote:shakesoda, I took another look at your code, and I think this is the problem.
Try this instead:There's probably a better way of doing it, but I'm not familiar with GLM.Code: Select all
// Projection matrix for the "center eye", which the left/right matrices are based on. glm::mat4 projCenter = glm::perspective<float>(yfov, aspectRatio, 0.3f, 1000.0f); glm::mat4 projLeft(1.0); projLeft[0][3] = projectionCenterOffset; projLeft *= projCenter; glm::mat4 projRight(1.0); projRight[0][3] = -projectionCenterOffset; projRight *= projCenter; // View transformation translation in world units. float halfIPD = hmd.InterpupillaryDistance * 0.5f; glm::mat4 viewCenter(1.0); glm::mat4 viewLeft(1.0); viewLeft[0][3] = halfIPD; viewLeft *= viewCenter; glm::mat4 viewRight(1.0); viewRight[0][3] = -halfIPD; viewRight *= viewCenter;
I should also mention that I haven't actually tried this on my Rift, I just grabbed GLM and looked at what it outputs, so I may have the multiplications the wrong way round.
It only took a moment, I already knew GLM's matrices were column major (as GL expects) so it was the first thing I tried when I saw that my views got wonky.Ben wrote:Ah, that actually explains some of the extra weirdness I was experiencing with GLM. I really should have thought to check the order was the same as in my matrix class before reusing all my output stuff. Apologies. I hope it didn't take long to notice I had it backwards.
Optimize all the shaders!
That's what struck me as weird, the matrices I use are column major too, but comparing the values to GLM's showed them to be transposed. Turns out I'm just an idiot and wrote the print method thinking m01 would be the same as m[0][1]. Note to self: just because it works doesn't mean it's right.shakesoda wrote:It only took a moment, I already knew GLM's matrices were column major (as GL expects) so it was the first thing I tried when I saw that my views got wonky.
That was a great read, thanks. Kind of looking forward to doing another optimization pass on all my shaders now.geekmaster wrote:Low-Level Thinking in High-Level Shading Languages (from GDC 2013):
I am using the Riftup! screen upgrade with 1920*1080 5.9" screen.Ben wrote:I've just been using the default values from the Tuscany demo. If you're not worried about calculating everything based on different IPDs and panel sizes yet then these values should be fine.eshan wrote:Now I just need to figure out all the stuff I need to supply at the top!
Code: Select all
// left vec2 LensCenter = vec2(0.2863248, 0.5); vec2 ScreenCenter = vec2(0.25, 0.5); vec2 Scale = vec2(0.1469278, 0.2350845); vec2 ScaleIn = vec2(4, 2.5); vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0); // right vec2 LensCenter = vec2(0.7136753, 0.5); vec2 ScreenCenter = vec2(0.75, 0.5);