Maya-like camera implementation

Question

I am working on Maya-like camera implementation, and I've done track and dolly functions correctly but I just cannot implement tumble.

I am working in PhiloGL engine (WebGL base), so I would really appreciate some help with code in this engine.

I've looked at how Maya's camera actually work, but I cannot find out. Here is my code so-far

if(mode == "rot")
    {                           
      var angleX = diffx / 150;
      var angleY = diffy / 150;
      //var angleZ = sign * Math.sqrt((diffx * diffx)+(diffy * diffy)) / 150;

      e.stop(); 

      //axe Z
      //camera.position.x = x * Math.cos(angleX) - y * Math.sin(angleX);       
      //camera.position.y = x * Math.sin(angleX) + y * Math.cos(angleX);                    

      //axe X   
      //camera.position.y = y * Math.cos(angleY) - z * Math.sin(angleY);
      //camera.position.z = y * Math.sin(angleY) + z * Math.cos(angleY);   

      //camera.update();                                                                                                 

      //axe Y                                   
      camera.position.z = z * Math.cos(angleX) - x * Math.sin(angleX);
      camera.position.x = z * Math.sin(angleX) + x * Math.cos(angleX);                                                                                                                          

      camera.update();                                                         

      position.x = e.x;
      position.y = e.y;
      position.z = e.z;  
    }

This isn't working nor do I know what am I doing wrong.

Any clues?

For one thing this is always going to rotate the camera around world origin. Maya has the idea of a 'center of interest' around which the camera rotates, you can get the same idea by making two matrices: one for the center of interest that rotates in azimuth and elevation, and one for the camera which is transformed by the first matrix : effectively make the camera a 'child' of your center-of-interest transform and then rotate it around by using the c-o-i. Local moves in that space equate to pan and dolly camera moves — theodox, Nov 19 '13 at 21:04
Center of interest ?... I did not figure that out. Thanks a lot theodox, I will try this new concept. — Michal Rosa, Nov 28 '13 at 07:42

score 1 · Accepted Answer · answered Nov 30 '13 at 23:18

I use this in inka3d (www.inka3d.com) but it does not depend on inka3d. The output is a 4x4 matrix. Can you make use of that?

// turntable like camera, y is up-vector
// tx, ty and tz are camera target position
// rx, ry and rz are camera rotation angles (rad)
// di is camera distance from target
// fr is an array where the resulting view matrix is written into (16 values, row major)
control.cameraY = function(tx, ty, tz, rx, ry, rz, di, fr)
{
    var a = rx * 0.5;
    var b = ry * 0.5;
    var c = rz * 0.5;
    var d = Math.cos(a);
    var e = Math.sin(a);
    var f = Math.cos(b);
    var g = Math.sin(b);
    var h = Math.cos(c);
    var i = Math.sin(c);
    var j = f * e * h + g * d * i;
    var k = f * -e * i + g * d * h;
    var l = f * d * i - g * e * h;
    var m = f * d * h - g * -e * i;
    var n = j * j;
    var o = k * k;
    var p = l * l;
    var q = m * m;
    var r = j * k;
    var s = k * l;
    var t = j * l;
    var u = m * j;
    var v = m * k;
    var w = m * l;
    var x = q + n - o - p;
    var y = (r + w) * 2.0;
    var z = (t - v) * 2.0;
    var A = (r - w) * 2.0;
    var B = q - n + o - p;
    var C = (s + u) * 2.0;
    var D = (t + v) * 2.0;
    var E = (s - u) * 2.0;
    var F = q - n - o + p;
    var G = di;
    var H = -(tx + D * G);
    var I = -(ty + E * G);
    var J = -(tz + F * G);
    fr[0] = x;
    fr[1] = A;
    fr[2] = D;
    fr[3] = 0.0;
    fr[4] = y;
    fr[5] = B;
    fr[6] = E;
    fr[7] = 0.0;
    fr[8] = z;
    fr[9] = C;
    fr[10] = F;
    fr[11] = 0.0;
    fr[12] = x * H + y * I + z * J;
    fr[13] = A * H + B * I + C * J;
    fr[14] = D * H + E * I + F * J;
    fr[15] = 1.0; 
};

Maya-like camera implementation

1 Answers1