我目前正在 GLSL 中进行一些光线投射，效果很好。无论如何，我现在想从正交投影到透视投影，但我不知道如何正确地这样做。有没有关于如何使用带有光线投射的投影矩阵的好的链接？我什至不确定我必须将矩阵应用于什么（可能以某种方式应用于光线方向？）。现在我这样做（伪代码）：
vec3 rayDir = (0.0, 0.0, -1.0); //down the negative -z axis in parallel;
但现在我想使用一个类似于 gluPerspective 函数的 projMatrix，这样我就可以简单地定义纵横比、fov 以及近平面和远平面。所以基本上，任何人都可以为我提供一大块代码来设置类似于 do 的 proj 矩阵gluProjection吗？其次告诉我将它与 rayDirection 相乘是否正确？
要将光线射入场景，您首先要在应用投影矩阵后将自己（精神上）置身于世界中。这意味着视锥现在是一个 2x2x1 的盒子——这被称为规范视图体积。（盒子的对角是 (-1, -1, 0) 和 (1, 1, -1)。）您生成的光线将（在投影后变换的世界中）从原点开始并射到后面剪裁平面（位于 z=-1）。您的第一条光线的“目标”应该是 (-1, 1, -1) - 远裁剪平面的左上角。（后续光线“目的地”是根据视口的分辨率计算的。）
现在您在规范视图体积中拥有了这条射线，您需要将其放入标准世界坐标中。你怎么做到这一点？简单 - 只需乘以投影矩阵的逆矩阵，通常称为查看变换。这会将您的光线置于与场景中的对象相同的坐标系中，从而使光线碰撞测试变得简单而轻松。
对于与标准渲染在同一场景中进行光线跟踪，我发现以下方法可用于从屏幕坐标获取场景空间光线：（例如，将全屏四边形从 [-1,-1] 渲染到 [1,1 ]，或该范围内的某个子区域）
uniform mat4 invprojview;
uniform float near;
uniform float far;
attribute vec2 pos; // from [-1,-1] to [1,1]
varying lowp vec3 origin;
varying lowp vec3 ray;
void main() {
gl_Position = vec4(pos, 0.0, 1.0);
origin = (invprojview * vec4(pos, -1.0, 1.0) * near).xyz;
ray = (invprojview * vec4(pos * (far - near), far + near, far - near)).xyz;
// equivalent calculation:
// ray = (invprojview * (vec4(pos, 1.0, 1.0) * far - vec4(pos, -1.0, 1.0) * near)).xyz
}
varying lowp vec3 origin;
varying lowp vec3 ray;
void main() {
lowp vec3 rayDir = normalize(ray);
// Do raytracing from origin in direction rayDir
}
请注意，您需要提供倒置的投影视图矩阵，以及近距和远距剪裁距离。我确信有一种方法可以从矩阵中获取这些剪裁距离，但我还没有弄清楚如何。
这将定义一条从近平面开始的光线，而不是相机的位置。这提供了在 OpenGL 将剪切三角形的相同位置进行剪切的优势，使您的光线追踪对象与场景匹配。由于ray变量将是到达远平面的正确长度，因此您也可以在那里剪辑。
至于首先获得透视矩阵（并理解其背后的数学），我总是使用这个参考页面：
http://www.songho.ca/opengl/gl_projectionmatrix.html
我建议查看该站点上的推导，但如果它变得不可用，这里是最终的投影矩阵定义：
2n/(r-l) 0 (r+l)/(r-l) 0
0 2n/(t-b) (t+b)/(t-b) 0
0 0 -(f+n)/(f-n) -2fn/(f-n)
0 0 -1 0
在透视投影中，投影矩阵描述了从针孔相机看到的世界中的 3D 点到视口的 2D 点的映射。
相机平截头体（截断的金字塔）中的眼睛空间坐标映射到立方体（标准化设备坐标）。
透视投影矩阵如下所示：
r = right, l = left, b = bottom, t = top, n = near, f = far
2*n/(r-l) 0 0 0
0 2*n/(t-b) 0 0
(r+l)/(r-l) (t+b)/(t-b) -(f+n)/(f-n) -1
0 0 -2*f*n/(f-n) 0
哪里：
r = w / h
t = tan( fov_y / 2 );
2 * n / (r-l) = 1 / (t * a)
2 * n / (t-b) = 1 / t
如果投影是对称的，即视线在视口中心且视场没有位移，则矩阵可以简化为：
1/(t*a) 0 0 0
0 1/t 0 0
0 0 -(f+n)/(f-n) -1
0 0 -2*f*n/(f-n) 0
以下函数将计算相同的投影矩阵gluPerspective：
#include <array>
const float cPI = 3.14159265f;
float ToRad( float deg ) { return deg * cPI / 180.0f; }
using TVec4 = std::array< float, 4 >;
using TMat44 = std::array< TVec4, 4 >;
TMat44 Perspective( float fov_y, float aspect )
{
float fn = far + near
float f_n = far - near;
float r = aspect;
float t = 1.0f / tan( ToRad( fov_y ) / 2.0f );
return TMat44{
TVec4{ t / r, 0.0f, 0.0f, 0.0f },
TVec4{ 0.0f, t, 0.0f, 0.0f },
TVec4{ 0.0f, 0.0f, -fn / f_n, -1.0f },
TVec4{ 0.0f, 0.0f, -2.0f*far*near / f_n, 0.0f }
};
}
进一步看：
WebGL 示例：
<script type="text/javascript">
camera_vert =
"precision mediump float; \n" +
"attribute vec3 inPos; \n" +
"attribute vec3 inCol; \n" +
"varying vec3 vertCol;" +
"uniform mat4 u_projectionMat44;" +
"uniform mat4 u_viewMat44;" +
"uniform mat4 u_modelMat44;" +
"void main()" +
"{" +
" vertCol = inCol;" +
" vec4 modolPos = u_modelMat44 * vec4( inPos, 1.0 );" +
" vec4 viewPos = u_viewMat44 * modolPos;" +
" gl_Position = u_projectionMat44 * viewPos;" +
"}";
camera_frag =
"precision mediump float; \n" +
"varying vec3 vertCol;" +
"void main()" +
"{" +
" gl_FragColor = vec4( vertCol, 1.0 );" +
"}";
glArrayType = typeof Float32Array !="undefined" ? Float32Array : ( typeof WebGLFloatArray != "undefined" ? WebGLFloatArray : Array );
function IdentityMat44() {
var a=new glArrayType(16);
a[0]=1;a[1]=0;a[2]=0;a[3]=0;a[4]=0;a[5]=1;a[6]=0;a[7]=0;a[8]=0;a[9]=0;a[10]=1;a[11]=0;a[12]=0;a[13]=0;a[14]=0;a[15]=1;
return a;
};
function Cross( a, b ) { return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], 0.0 ]; }
function Dot( a, b ) { return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]; }
function Normalize( v ) {
var len = Math.sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );
return [ v[0] / len, v[1] / len, v[2] / len ];
}
var Camera = {};
Camera.create = function() {
this.pos = [0, 8, 0.5];
this.target = [0, 0, 0];
this.up = [0, 0, 1];
this.fov_y = 90;
this.vp = [800, 600];
this.near = 0.5;
this.far = 100.0;
}
Camera.Perspective = function() {
var fn = this.far + this.near;
var f_n = this.far - this.near;
var r = this.vp[0] / this.vp[1];
var t = 1 / Math.tan( Math.PI * this.fov_y / 360 );
var m = IdentityMat44();
m[0] = t/r; m[1] = 0; m[2] = 0; m[3] = 0;
m[4] = 0; m[5] = t; m[6] = 0; m[7] = 0;
m[8] = 0; m[9] = 0; m[10] = -fn / f_n; m[11] = -1;
m[12] = 0; m[13] = 0; m[14] = -2 * this.far * this.near / f_n; m[15] = 0;
return m;
}
function ToVP( v ) { return [ v[1], v[2], -v[0] ] }
Camera.LookAt = function() {
var p = ToVP( this.pos ); t = ToVP( this.target ); u = ToVP( this.up );
var mx = Normalize( [ t[0]-p[0], t[1]-p[1], t[2]-p[2] ] );
var my = Normalize( Cross( u, mx ) );
var mz = Normalize( Cross( mx, my ) );
var eyeInv = [ -this.pos[0], -this.pos[1], -this.pos[2] ];
var tx = Dot( eyeInv, [mx[0], my[0], mz[0]] );
var ty = Dot( eyeInv, [mx[1], my[1], mz[1]] );
var tz = Dot( eyeInv, [mx[2], my[2], mz[2]] );
var m = IdentityMat44();
m[0] = mx[0]; m[1] = mx[1]; m[2] = mx[2]; m[3] = 0;
m[4] = my[0]; m[5] = my[1]; m[6] = my[2]; m[7] = 0;
m[8] = mz[0]; m[9] = mz[1]; m[10] = mz[2]; m[11] = 0;
m[12] = tx; m[13] = ty; m[14] = tz; m[15] = 1;
return m;
}
// shader program object
var ShaderProgram = {};
ShaderProgram.Create = function( shaderList, uniformNames ) {
var shaderObjs = [];
for ( var i_sh = 0; i_sh < shaderList.length; ++ i_sh ) {
var shderObj = this.CompileShader( shaderList[i_sh].source, shaderList[i_sh].stage );
if ( shderObj == 0 )
return 0;
shaderObjs.push( shderObj );
}
if ( !this.LinkProgram( shaderObjs ) )
return 0;
this.unifomLocation = {};
for ( var i_n = 0; i_n < uniformNames.length; ++ i_n ) {
var name = uniformNames[i_n];
this.unifomLocation[name] = gl.getUniformLocation( this.prog, name );
}
return this.prog;
}
ShaderProgram.Use = function() { gl.useProgram( this.prog ); }
ShaderProgram.SetUniformMat44 = function( name, mat ) { gl.uniformMatrix4fv( this.unifomLocation[name], false, mat ); }
ShaderProgram.CompileShader = function( source, shaderStage ) {
var shaderObj = gl.createShader( shaderStage );
gl.shaderSource( shaderObj, source );
gl.compileShader( shaderObj );
return gl.getShaderParameter( shaderObj, gl.COMPILE_STATUS ) ? shaderObj : 0;
}
ShaderProgram.LinkProgram = function( shaderObjs ) {
this.prog = gl.createProgram();
for ( var i_sh = 0; i_sh < shaderObjs.length; ++ i_sh )
gl.attachShader( this.prog, shaderObjs[i_sh] );
gl.linkProgram( this.prog );
return gl.getProgramParameter( this.prog, gl.LINK_STATUS ) ? true : false;
}
function drawScene(){
var canvas = document.getElementById( "camera-canvas" );
Camera.create();
Camera.vp = [canvas.width, canvas.height];
var currentTime = Date.now();
var deltaMS = currentTime - startTime;
Camera.pos = EllipticalPosition( 7, 4, CalcAng( currentTime, 10.0 ) );
gl.viewport( 0, 0, canvas.width, canvas.height );
gl.enable( gl.DEPTH_TEST );
gl.clearColor( 0.0, 0.0, 0.0, 1.0 );
gl.clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
ShaderProgram.Use();
ShaderProgram.SetUniformMat44( "u_projectionMat44", Camera.Perspective() );
ShaderProgram.SetUniformMat44( "u_viewMat44", Camera.LookAt() );
ShaderProgram.SetUniformMat44( "u_modelMat44", IdentityMat44() );
gl.enableVertexAttribArray( prog.inPos );
gl.bindBuffer( gl.ARRAY_BUFFER, buf.pos );
gl.vertexAttribPointer( prog.inPos, 3, gl.FLOAT, false, 0, 0 );
gl.enableVertexAttribArray( prog.inCol );
gl.bindBuffer( gl.ARRAY_BUFFER, buf.col );
gl.vertexAttribPointer( prog.inCol, 3, gl.FLOAT, false, 0, 0 );
gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, buf.inx );
gl.drawElements( gl.TRIANGLES, 12, gl.UNSIGNED_SHORT, 0 );
gl.disableVertexAttribArray( buf.pos );
gl.disableVertexAttribArray( buf.col );
}
var startTime;
function Fract( val ) {
return val - Math.trunc( val );
}
function CalcAng( currentTime, intervall ) {
return Fract( (currentTime - startTime) / (1000*intervall) ) * 2.0 * Math.PI;
}
function CalcMove( currentTime, intervall, range ) {
var pos = self.Fract( (currentTime - startTime) / (1000*intervall) ) * 2.0
var pos = pos < 1.0 ? pos : (2.0-pos)
return range[0] + (range[1] - range[0]) * pos;
}
function EllipticalPosition( a, b, angRag ) {
var a_b = a * a - b * b
var ea = (a_b <= 0) ? 0 : Math.sqrt( a_b );
var eb = (a_b >= 0) ? 0 : Math.sqrt( -a_b );
return [ a * Math.sin( angRag ) - ea, b * Math.cos( angRag ) - eb, 0 ];
}
var gl;
var prog;
var buf = {};
function cameraStart() {
var canvas = document.getElementById( "camera-canvas");
gl = canvas.getContext( "experimental-webgl" );
if ( !gl )
return;
prog = ShaderProgram.Create(
[ { source : camera_vert, stage : gl.VERTEX_SHADER },
{ source : camera_frag, stage : gl.FRAGMENT_SHADER }
],
[ "u_projectionMat44", "u_viewMat44", "u_modelMat44"] );
prog.inPos = gl.getAttribLocation( prog, "inPos" );
prog.inCol = gl.getAttribLocation( prog, "inCol" );
if ( prog == 0 )
return;
var sin120 = 0.8660254
var pos = [ 0.0, 0.0, 1.0, 0.0, -sin120, -0.5, sin120 * sin120, 0.5 * sin120, -0.5, -sin120 * sin120, 0.5 * sin120, -0.5 ];
var col = [ 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0 ];
var inx = [ 0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2 ];
buf.pos = gl.createBuffer();
gl.bindBuffer( gl.ARRAY_BUFFER, buf.pos );
gl.bufferData( gl.ARRAY_BUFFER, new Float32Array( pos ), gl.STATIC_DRAW );
buf.col = gl.createBuffer();
gl.bindBuffer( gl.ARRAY_BUFFER, buf.col );
gl.bufferData( gl.ARRAY_BUFFER, new Float32Array( col ), gl.STATIC_DRAW );
buf.inx = gl.createBuffer();
gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, buf.inx );
gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, new Uint16Array( inx ), gl.STATIC_DRAW );
startTime = Date.now();
setInterval(drawScene, 50);
}
</script>
<body onload="cameraStart();">
<canvas id="camera-canvas" style="border: none;" width="512" height="256"></canvas>
</body>不要试图修改你的光线。而是这样做：
a）使用相机的位置/旋转创建矩阵。b) 反转矩阵 c) 将其应用于场景中的所有模型 d) 使用常规方法渲染它。
这实际上也是 OpenGL 的做法。向右旋转相机与向左旋转世界相同。
我从谷歌搜索到达这里后回答了这个问题。
现有的答案似乎忽略了原始问题中缺乏理解。
光线投射时需要应用投影矩阵的想法是无稽之谈
我们通过从视图平面开始并为每个像素跟踪相同方向来创建正交光线投射。光线的原点每像素变化
我们通过从眼睛位置开始，在视图平面后面并为每个像素跟踪一个独特的方向来创建透视光线投射。即射线的原点是固定的，并且对于每个像素都是相同的。
了解投影矩阵本身，以及它们通常涉及的过程来自光线投射。透视矩阵对我描述的那种光线投射进行编码。
在屏幕上投射一个点就是将一条光线从眼睛/视图平面投射到该点并找到与视图平面的交点......