OpenGL ES 2.0 setLookAtM

Question

I have, a problem with the setLookAtM function. My goal is to create a cube within a cube something like this (yep, it's paint :P ):

So basically everything works... almoust... I have the smaller cube and I have the bigger one. However, there is a problem. I created the bigger one with coords from -1 to 1 and now I want to upscale it. With scale 1.0f i have something like this (the inner cube is rotating):

And thats good, but now... when I try to scale the bigger cube (so that it looks like in the paint drawing) the image goes black or white (i guess it's because the "camera" looks at the white cube but still i dont know why does my inner cube disappear :/ I don't understand what I'm doing wrong. Here is my code:

public void onDrawFrame(GL10 unused) {
    float[] scratch = new float[16];
    GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);
    Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -5.0f, 0f, 0f, -1.0f, 0f, 1.0f, 0.0f);

    Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

    mRoom.mScale = 1.0f;
    Matrix.setIdentityM(mScaleMatrix, 0);
    Matrix.scaleM(mScaleMatrix, 0, mRoom.mScale, mRoom.mScale, mRoom.mScale);

    float[] scaleTempMatrix = new float[16];
    Matrix.multiplyMM(scaleTempMatrix, 0, mMVPMatrix, 0, mScaleMatrix, 0);

    mRoom.draw(scaleTempMatrix);

When I set for example:

mRoom.mScale = 3.0f;

And

Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -2.0f, 0f, 0f, 0.0f, 1.0f, 1.0f, 0.0f);

My camera should be at (0, 0, -2) looking at (0,0, -1) and it should be inside the white cube (since scale is 3.0 so the coords should be from -3 to 3 right?) But all I get is a white screen without the smaller cube rotating inside :/

Answer 1

If your scale is 3x in this code, then your visible coordinate range is actually going to be [-1/3,1/3].

You are thinking about things backwards, it might help if you considered the order in which the scale operation is applied. Right now you are scaling the object-space coordinates, then applying the view matrix and then projection. It may not look that way, but that is how matrix multiplication in GL works; GL effectively flips the operands when it does matrix multiplication and matrix multiplication is not commutative.

I believe this is what you actually want:

public void onDrawFrame(GL10 unused) {
    float[] scratch = new float[16];
    GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);
    Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -5.0f, 0f, 0f, -1.0f, 0f, 1.0f, 0.0f);

    mRoom.mScale = 3.0f;
    Matrix.setIdentityM(mScaleMatrix, 0);
    Matrix.scaleM(mScaleMatrix, 0, mRoom.mScale, mRoom.mScale, mRoom.mScale);

    Matrix.multiplyMM(mMVPMatrix, 0, mScaleMatrix, 0, mProjectionMatrix, 0);
    Matrix.multiplyMM(mMVPMatrix, 0, mMVPMatrix,   0, mViewMatrix,       0);

    mRoom.draw(mMVPMatrix);