How to do perspective projection “parallax” but without changing the scale or offset of objects?

Question

Hello everyone I have this problem that I have tried everything I could think of. The problem: I am making a 2D game with parallax effect but I am using 3d space so am not simulating the parallax but letting the perspective projection take care of it for me. now the problem i have my own game editor where I design the levels, in this editor I use just images and I set a Z value for each layer. however I want the layers to show in the game engine exactly as I set them in the game editor, in short I want perspective projection to do parallax but without changing their scale or offset/position.

obvious solution is to scale them up and offset them but the problem how to calculate their offset? with scaling I tried object->Scale(object.Z/view.Z) and seems to return them to their real size but their positions are still wrong. I tried object->setPositionX(object->getPosition().x*(object.Z/view.Z)) and seems to be aligned except they all seems shifted.

I have tried unprojecting and tried to convert from world matrix to screen matrix and find some ratios and so on.

If anyone have any idea or anyway how this could be done in an elegant/mathematical way , I will be most grateful.

Thank you all in advance.

Answer 1

The easiest way to do that is to use an orthogonal projection when rendering, but do your own perspective divide on the origin of the objects.

If you want to use a perspective project when rendering, you'll need to reverse the effects of the assumed original perspective projection used when editing, and apply the new perspective projection for the current camera when playing.

In your editor, you have a camera. This camera transforms from the object coordinates into screen coordinates. Now, in your editor, this is an orthogonal camera, but you want to pretend that it actually was a perspective camera. If you take the screen coordinates, run them backwards through the camera transform for the perspective camera, you get new object coordinates out. This transform is a transform that you want to apply to your objects.

What happens when you render:

screen_position = screen_from_world_matrix * world_position

What you want to happen in your transform pipeline, is add another few steps, to transform between these various spaces: playscreen, playworld, editscreen, and editworld. editscreen has the same coordinates as the original orthogonal editor camera, and the pretend perspective editor camera, as that's the space where we'll be doing the "trick" of pretending that a different camera is being swapped out.

playscreen_position =
    playscreen_from_playworld_matrix *
    playworld_position

playworld_position =
    playworld_from_editscreen_matrix *
    editscreen_from_editworld_matrix *
    editworld_position

playworld_from_editscreen_matrix is the inverse of editscreen_from_playworld_matrix, which happens to be the screen_from_world_matrix of the pretend camera!

The good news is that all of these matrixes can be concatenated into one:

playscreen_from_editworld_matrix = 
    playscreen_from_playworld_matrix *
    playworld_from_editscreen_matrix *
    editscreen_from_editworld_matrix

Or if you just want to apply the editworld-to-playworld transform:

playworld_from_editworld_matrix =
    playworld_from_editscreen_matrix *
    editscreen_from_editworld_matrix

Then transform your objects using that matrix!