iphone - una - Problemas con la matriz de rotación del eje Z en sombreador glsl

rotacion de ejes xyz

Question

Recientemente comencé a armar una tubería 2D opengl es 1.1 / 2.0 desde cero (solo iPhone). Esta tubería está destinada a ser utilizada por ingenieros sin experiencia matemática en 3D.

Comentadas son las matrices de rotación del eje X e Y que producen los resultados exactos que deberían . La matriz de rotación Z parece no hacer nada.

VERTEX SHADER

//THESE WORK
/*
highp mat4 rotationMatrix = mat4(1.0, 0.0, 0.0, 0.0,
0.0, cos(angle), -sin(angle), 0.0,
0.0, sin(angle), cos(angle), 0.0,
0.0, 0.0, 0.0, 1.0);
highp mat4 rotationMatrix = mat4(cos(angle), 0.0, sin(angle), 0.0,
0.0, 1.0, 0.0, 0.0,
-sin(angle), 0.0, cos(angle), 0.0,
0.0, 0.0, 0.0, 1.0);
*/
//THIS DOESN''T WORK >:(
highp mat4 rotationMatrix = mat4(cos(angle), -sin(angle), 0.0, 0.0,
sin(angle), cos(angle), 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0);
gl_Position = a_position;
gl_Position *= rotationMatrix;

Dado que esto será para renderizado 2D y entregado a ingenieros sin experiencia en 3D, preferiría evitar pasar una matriz MVP y simplemente presionar las variables básicas de escala, rotación y traducción (y omitir la escritura de una matriz parcial lib por décima vez )

Ha pasado un tiempo desde que me enredé con la matriz matemática y los sombreadores, así que espero que sea un pequeño error.

¡Gracias por tu ayuda!

EDITAR / ACTUALIZAR:

Descubrí que un pase de posprocesamiento estaba golpeando el ángulo.

Ahora descubro que la rotación Z parece escalar el cuádruple. Recuerdo que esto es un problema n00b y estoy investigando ...

Olvidé mencionar que tengo una matriz de proyección temporal económica

//s_scalefactor is for retina vs non-retina display
highp mat4 projectionMatrix = mat4( 2.0/(320.0 * s_scalefactor), 0.0, 0.0, -1.0,
0.0, 2.0/(480.0 * s_scalefactor), 0.0, -1.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0);
gl_Position *= projectionMatrix;

Es un truco barato, pero no estoy seguro de que ponga rígida una rotación Z.

EDIT # 2:

Tampoco he conseguido usar un triturador en lugar de orto y calcular la matriz fuera del sombreador.

Answer 1

Tuve el mismo problema y fue muy, muy extraño. Pude resolverlo poblando la estructura mat4 mediante el uso de operadores de acceso en lugar de utilizar el constructor:

mat4 rotateZ;
rotateZ[0].x = cosAngle;
rotateZ[0].y = negSinAngle;
rotateZ[0].z = 0.0;
rotateZ[0].w = 0.0;
rotateZ[1].x = sinAngle;
rotateZ[1].y = cosAngle;
rotateZ[1].z = 0.0;
rotateZ[1].w = 0.0;
rotateZ[2].x = 0.0;
rotateZ[2].y = 0.0;
rotateZ[2].z = 1.0;
rotateZ[2].w = 0.0;
rotateZ[3].x = 0.0;
rotateZ[3].y = 0.0;
rotateZ[3].z = 0.0;
rotateZ[3].w = 1.0;

Answer 2

El siguiente código realiza una traducción de la matriz de entrada, moviéndose a lo largo de los ejes X, Y y Z de la matriz de entrada.

typedef float TVec3[3];
typedef float TMat4[16];
void Translate(
TMat4 &mat, // input matrix
const TVec3 &trans ) // translation vector
{
for ( int i = 0; i < 3; ++ i ) {
mat[i*4+3] = mat[i*4] * trans[0] + mat[i*4+1] * trans[1] + mat[i*4+2] * trans[2] + mat[i*4+3];
}
}

La siguiente función muestra cómo realizar una rotación en la matriz de entrada, alrededor de un eje X, Y o Z de la matriz de entrada. La dirección de rotación es en el sentido de las agujas del reloj cuando se mira en la dirección del eje de rotación.

typedef float TMat4[16];
void RotateAxis(
TMat4 &mat, // input matrix
float angRad, // roatation angle (radians)
int axis ) // rotation axis: 0 - X; 1 - Y; 2 - Z
{
const int a0map[3] = { 1, 2, 0 };
const int a1map[3] = { 2, 0, 1 };
const int a0 = a0map[axis];
const int a1 = a1map[axis];
const float sinAng = sin(angRad);
const float cosAng = cos(angRad);
// rotate the matrix
TMat4 tempM;
memcpy( tempM, mat, sizeof(TMat4) );
for ( int i = 0; i < 3; ++ i ) {
mat[a0*4+i] = tempM[a0*4+i] * cosAng + tempM[a1*4+i] * sinAng;
mat[a1*4+i] = tempM[a0*4+i] * -sinAng + tempM[a1*4+i] * cosAng;
}
}

En aras de la integridad, la función para escalar la matriz de entrada.

typedef float TVec3[3];
typedef float TMat4[16];
void Scale(
TMat4 &mat, // input matrix
const TVec3 &scale ) // scale factors
{
for ( int a = 0; a < 4; ++ a ) {
for ( int i = 0; i < 3; ++ i ) {
mat[a*4+i] = mat[a*4+i] * scale[i];
}
}
}

Mire el siguiente ejemplo para ver cómo la traducción y la rotación interactúan juntas (probadas con Firefox, Chrome, Edge, Opera):

<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 RotateAxis(matA, angRad, axis) {
var aMap = [ [1, 2], [2, 0], [0, 1] ];
var a0 = aMap[axis][0], a1 = aMap[axis][1];
var sinAng = Math.sin(angRad), cosAng = Math.cos(angRad);
var matB = new glArrayType(16);
for ( var i = 0; i < 16; ++ i ) matB[i] = matA[i];
for ( var i = 0; i < 3; ++ i ) {
matB[a0*4+i] = matA[a0*4+i] * cosAng + matA[a1*4+i] * sinAng;
matB[a1*4+i] = matA[a0*4+i] * -sinAng + matA[a1*4+i] * cosAng;
}
return matB;
}
function Translate( matA, trans ) {
var matB = new glArrayType(16);
for ( var i = 0; i < 16; ++ i ) matB[i] = matA[i];
for ( var i = 0; i < 3; ++ i )
matB[12+i] = matA[i] * trans[0] + matA[4+i] * trans[1] + matA[8+i] * trans[2] + matA[12+i];
return matB;
}
function IdentityMat44() {
var m = new glArrayType(16);
m[0] = 1; m[1] = 0; m[2] = 0; m[3] = 0;
m[4] = 0; m[5] = 1; m[6] = 0; m[7] = 0;
m[8] = 0; m[9] = 0; m[10] = 1; m[11] = 0;
m[12] = 0; m[13] = 0; m[14] = 0; m[15] = 1;
return m;
};
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, 5, 0.0];
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 );
}
var progObj = this.LinkProgram( shaderObjs )
if ( progObj != 0 ) {
progObj.unifomLocation = {};
for ( var i_n = 0; i_n < uniformNames.length; ++ i_n ) {
var name = uniformNames[i_n];
progObj.unifomLocation[name] = gl.getUniformLocation( progObj, name );
}
}
return progObj;
}
ShaderProgram.Use = function( progObj ) { gl.useProgram( progObj ); }
ShaderProgram.SetUniformInt = function( progObj, name, val ) { gl.uniform1i( progObj.unifomLocation[name], val ); }
ShaderProgram.SetUniform2f = function( progObj, name, arr ) { gl.uniform2fv( progObj.unifomLocation[name], arr ); }
ShaderProgram.SetUniformMat44 = function( progObj, name, mat ) { gl.uniformMatrix4fv( progObj.unifomLocation[name], false, mat ); }
ShaderProgram.CompileShader = function( source, shaderStage ) {
var shaderObj = gl.createShader( shaderStage );
gl.shaderSource( shaderObj, source );
gl.compileShader( shaderObj );
var status = gl.getShaderParameter( shaderObj, gl.COMPILE_STATUS );
if ( !status ) alert(gl.getShaderInfoLog(shaderObj));
return status ? shaderObj : 0;
}
ShaderProgram.LinkProgram = function( shaderObjs ) {
var prog = gl.createProgram();
for ( var i_sh = 0; i_sh < shaderObjs.length; ++ i_sh )
gl.attachShader( prog, shaderObjs[i_sh] );
gl.linkProgram( prog );
status = gl.getProgramParameter( prog, gl.LINK_STATUS );
if ( !status ) alert("Could not initialise shaders");
gl.useProgram( null );
return status ? prog : 0;
}
function drawScene(){
syncFromDocument();
var canvas = document.getElementById( "camera-canvas" );
Camera.create();
Camera.vp = [canvas.width, canvas.height];
var currentTime = Date.now();
var deltaMS = currentTime - startTime;
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( progDraw );
ShaderProgram.SetUniformMat44( progDraw, "u_projectionMat44", Camera.Perspective() );
ShaderProgram.SetUniformMat44( progDraw, "u_viewMat44", Camera.LookAt() );
var modelMat = Translate( IdentityMat44(), preTrans );
modelMat = RotateAxis( modelMat, CalcAng( currentTime, 10.0 ), axisOfRotation );
var modelMat = Translate( modelMat, postTrans );
ShaderProgram.SetUniformMat44( progDraw, "u_modelMat44", modelMat );
gl.enableVertexAttribArray( progDraw.inPos );
gl.bindBuffer( gl.ARRAY_BUFFER, bufObj.pos );
gl.vertexAttribPointer( progDraw.inPos, 3, gl.FLOAT, false, 0, 0 );
gl.enableVertexAttribArray( progDraw.inCol );
gl.bindBuffer( gl.ARRAY_BUFFER, bufObj.col );
gl.vertexAttribPointer( progDraw.inCol, 3, gl.FLOAT, false, 0, 0 );
gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, bufObj.inx );
gl.drawElements( gl.TRIANGLES, 12, gl.UNSIGNED_SHORT, 0 );
gl.disableVertexAttribArray( progDraw.pos );
gl.disableVertexAttribArray( progDraw.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;
}
var preTrans = [0, 0, 0];
var postTrans = [1, 0, 0];
var axisOfRotation = 2;
var sliderScale = 100.0;
function syncFromDocument() {
preTrans[0] = document.getElementById( "preX" ).value / sliderScale;
preTrans[1] = document.getElementById( "preY" ).value / sliderScale;
preTrans[2] = document.getElementById( "preZ" ).value / sliderScale;
axisOfRotation = document.getElementById( "axis" ).value;
postTrans[0] = document.getElementById( "postX" ).value / sliderScale;
postTrans[1] = document.getElementById( "postY" ).value / sliderScale;
postTrans[2] = document.getElementById( "postZ" ).value / sliderScale;
}
var gl;
var prog;
var bufObj = {};
function cameraStart() {
document.getElementById( "preX" ).value = preTrans[0] * sliderScale;
document.getElementById( "preY" ).value = preTrans[1] * sliderScale;
document.getElementById( "preZ" ).value = preTrans[2] * sliderScale;
document.getElementById( "axis" ).value = axisOfRotation;
document.getElementById( "postX" ).value = postTrans[0] * sliderScale;
document.getElementById( "postY" ).value = postTrans[1] * sliderScale;
document.getElementById( "postZ" ).value = postTrans[2] * sliderScale;
var canvas = document.getElementById( "camera-canvas");
gl = canvas.getContext( "experimental-webgl" );
if ( !gl )
return;
progDraw = ShaderProgram.Create(
[ { source : camera_vert, stage : gl.VERTEX_SHADER },
{ source : camera_frag, stage : gl.FRAGMENT_SHADER }
],
[ "u_projectionMat44", "u_viewMat44", "u_modelMat44"] );
progDraw.inPos = gl.getAttribLocation( progDraw, "inPos" );
progDraw.inCol = gl.getAttribLocation( progDraw, "inCol" );
if ( prog == 0 )
return;
var sin120 = 0.8660254;
// 0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2
var pos = [ 0.0, 0.0, 1.0, 0.0, -sin120, -0.5, sin120 * sin120, 0.5 * sin120, -0.5,
0.0, 0.0, 1.0, sin120 * sin120, 0.5 * sin120, -0.5, -sin120 * sin120, 0.5 * sin120, -0.5,
0.0, 0.0, 1.0, -sin120 * sin120, 0.5 * sin120, -0.5, 0.0, -sin120, -0.5,
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, 0.0, 0.0, 1.0, 0.0, 0.0,
1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0,
0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0,
0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0 ];
var inx = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ];
bufObj.pos = gl.createBuffer();
gl.bindBuffer( gl.ARRAY_BUFFER, bufObj.pos );
gl.bufferData( gl.ARRAY_BUFFER, new Float32Array( pos ), gl.STATIC_DRAW );
bufObj.col = gl.createBuffer();
gl.bindBuffer( gl.ARRAY_BUFFER, bufObj.col );
gl.bufferData( gl.ARRAY_BUFFER, new Float32Array( col ), gl.STATIC_DRAW );
bufObj.inx = gl.createBuffer();
gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, bufObj.inx );
gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, new Uint16Array( inx ), gl.STATIC_DRAW );
startTime = Date.now();
setInterval(drawScene, 50);
}
</script>
<body onload="cameraStart();">
<div style="margin-left: 260px;">
<div style="float: right; width: 100%; background-color: #CCF;">
<form name="inputs">
<table>
<tr> <td> pre translate X </td>
<td> <input type="range" id="preX" min="-100" max="100" value="0"/></td> </tr>
<tr> <td> pre translate Y </td>
<td> <input type="range" id="preY" min="-100" max="100" value="0"/></td> </tr>
<tr> <td> pre translate Z </td>
<td> <input type="range" id="preZ" min="-100" max="100" value="0"/></td> </tr>
<tr> <td> axis of rotation </td> <td>
<select id="axis">>
<option value="0">X</option>
<option value="1">Y</option>
<option value="2">Z</option>
</select>
</td> </tr>
<tr> <td> post translate X </td>
<td> <input type="range" id="postX" min="-100" max="100" value="0"/></td> </tr>
<tr> <td> post translate Y </td>
<td> <input type="range" id="postY" min="-100" max="100" value="0"/></td> </tr>
<tr> <td> post translate Z </td>
<td> <input type="range" id="postZ" min="-100" max="100" value="0"/></td> </tr>
</table>
</form>
</div>
<div style="float: right; width: 260px; margin-left: -260px;">
<canvas id="camera-canvas" style="border: none;" width="256" height="256"></canvas>
</div>
<div style="clear: both;"></div>
</div>
</body>