OpenGL ModelView for head movement & scale.

            gl2.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
            gl2.glLoadIdentity();
            GLU glu = new GLU();
            glu.gluPerspective(45.0f, ((float) width / (float) height), 0.1f, 1000000.0f);

            gl2.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
            
            MatrixStack.MODELVIEW.set(player.invert());
            recenterView();

       for (int eye = 0; eye < 2; ++eye) {
            fovPorts[eye] = hmd.DefaultEyeFov[eye];
            projections[eye] = RiftUtils.toMatrix4f(
                    Hmd.getPerspectiveProjection(
                        fovPorts[eye], 0.1f, 1000000f, true));
        }

                       public void display(GLAutoDrawable drawable) {
            hmd.beginFrameTiming(++frameCount);
            GL2 gl = drawable.getGL().getGL2();
            
            Posef pose[] = new Posef[2];
            pose[ovrEyeType.ovrEye_Left] = hmd.getEyePose(ovrEyeType.ovrEye_Left);
            pose[ovrEyeType.ovrEye_Right] = hmd.getEyePose(ovrEyeType.ovrEye_Right);

            for (int eyeIndex = 0; eyeIndex < ovrEyeType.ovrEye_Count; eyeIndex++){
                int eye = hmd.EyeRenderOrder[eyeIndex];
                eyeRenderPose[eye].Orientation = pose[eye].Orientation;
                eyeRenderPose[eye].Position = pose[eye].Position;

                gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, fboIds[eye]);
                gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);

                gl.glMatrixMode(GL2.GL_PROJECTION);
                gl.glLoadMatrixf(projectionDFB[eye]);
                
                gl.glMatrixMode(GL2.GL_MODELVIEW);
                MatrixStack mv = MatrixStack.MODELVIEW;
                mv.push();
                {
                    mv.preTranslate(RiftUtils.toVector3f(eyeRenderPose[eye].Position).mult(-1));
                    mv.preRotate(RiftUtils.toQuaternion(eyeRenderPose[eye].Orientation).inverse());
                    mv.preTranslate(RiftUtils.toVector3f(eyeRenderDescs[eye].ViewAdjust));
                    mv.translate(new Vector3f(0, eyeHeight, 0 ));
                    modelviewDFB.clear();
                    MatrixStack.MODELVIEW.top().fillFloatBuffer(modelviewDFB, true);
                    modelviewDFB.rewind();
                    gl.glLoadMatrixf(modelviewDFB);

                    //tiles on floor
                    gl.glEnable(GL2.GL_TEXTURE_2D);
                    gl.glBindTexture(GL2.GL_TEXTURE_2D, cheq.getId());
                    gl.glTranslatef(0.0f, -eyeHeight, 0.0f);
                    mof.drawPlaneXZ(gl);
                    gl.glTranslatef(0.0f, eyeHeight, 0.0f);
                    gl.glDisable(GL2.GL_TEXTURE_2D);
                }
                mv.pop();
            }
            gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, 0);
            gl.glBindTexture(GL2.GL_TEXTURE_2D, 0);
            gl.glDisable(GL2.GL_TEXTURE_2D);
            
            hmd.endFrame(eyeRenderPose, eyeTextures);
        }

        @Override
        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
            System.out.println("reshape loc "+x+","+y+" size "+width+"x"+height);
            GL2 gl = drawable.getGL().getGL2();
            
            gl.glMatrixMode(GL2.GL_PROJECTION);
            for (int eye = 0; eye < 2; ++eye) {
                MatrixStack.PROJECTION.set(projections[eye]);
                gl.glMatrixMode(GL2.GL_PROJECTION);
                projectionDFB[eye] = ByteBuffer.allocateDirect(16*4).order(ByteOrder.nativeOrder()).asFloatBuffer();
                MatrixStack.PROJECTION.top().fillFloatBuffer(projectionDFB[eye], true);
                projectionDFB[eye].rewind();
                gl.glLoadMatrixf(projectionDFB[eye]);            
            }

            gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
            gl.glLoadIdentity();
            MatrixStack.MODELVIEW.set(player.invert());
            recenterView();
        }
    }   //end inner class
    
    private void recenterView() {
        Vector3f center = Vector3f.UNIT_Y.mult(eyeHeight);
        Vector3f eye = new Vector3f(0, eyeHeight, ipd * 5.0f);
        player = Matrix4f.lookat(eye, center, Vector3f.UNIT_Y).invert();
        hmd.recenterPose();
    }

  public static Matrix4f lookat(Vector3f eye, Vector3f center, Vector3f up) {
    Vector3f f = center.subtract(eye).normalize();
    Vector3f s = f.cross(up).normalize();
    Vector3f u = s.cross(f);

    Matrix4fTemp m = new Matrix4fTemp();
    m.m00 = s.x;
    m.m01 = s.y;
    m.m02 = s.z;
    m.m10 = u.x;
    m.m11 = u.y;
    m.m12 = u.z;
    m.m20 = -f.x;
    m.m21 = -f.y;
    m.m22 = -f.z;
    m.m03 = -s.dot(eye);
    m.m13 = -u.dot(eye);
    m.m23 = f.dot(eye);
    return new Matrix4f(m);
  }

"whitehexagon" wrote:
Does anyone have an OpenGL snippet doing anything similar for me to study please? It seems there are a lot less 'developers' on these boards since DKs started arriving :)

"bluenote" wrote:
Yes, maybe it is best if you just start with a working example. I do not understand what you are trying to achieve with this lookAt function, and it looks a bit as if you are going in a wrong direction here. I think you over-complicate things if you try to get the viewing matrix from an eye+center+up vector. The rotational part of your transformation can be easily obtained from the pose quaternion. Convert this quaternion to a 3x3 rotation matrix, and embed it in a 4x4 matrix. If you are using immediate mode, you can use glMultMatrix to apply the rotation. If you are using shaders, you have to apply the transformation in a "translate -- rotate -- translate" order -- for example by representing all 3 steps as a 4x4 matrix and multiplying them. You could also do that in immediate mode and use glLoadMatrix with the resulting 4x4 matrix.

for (int eyeIndex = 0; eyeIndex < ovrEye_Count; eyeIndex++) {
  ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex];
  headPose[eye] = ovrHmd_GetEyePose(hmd, eye);

  mat4 ovrOrient = toMat4(quat(
           headPose[eye].Orientation.w,
          -headPose[eye].Orientation.x,
          -headPose[eye].Orientation.y,
          -headPose[eye].Orientation.z));
  mat4 ovrPos = glm::translate(glm::mat4(1.f),
          -vec3(headPose[eye].Position.x,
                headPose[eye].Position.y,
                headPose[eye].Position.z));
  eyeView[eye] = eyeAdjust[eye] * ovrOrient * ovrPos * View;
  eyeVP[eye] = eyeProjection[eye] * eyeView[eye];
}

#define GLM_SWIZZLE
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>

eyeAdjust[eye] = glm::translate(glm::mat4(1.f),
      vec3(EyeRenderDesc[eye].ViewAdjust.x,
           EyeRenderDesc[eye].ViewAdjust.y,
           EyeRenderDesc[eye].ViewAdjust.z));