How to do panning/zooming operation in directx/c++ - c++

Question

For learning purposes im trying to create simple drawing program.Right now im trying to add panning and zooming features.
This is how i update my camera m_rightward and m_upward are 1 and 0 based on if wasd is clicked.
void Camera::updateCamera(int width, int height)
{
this->height = height;
this->width = width;
cc.client_height = this->height;
cc.client_width = this->width;
cc.m_time = ::GetTickCount();
//panning and zooming in here
new_pos = world_cam.getTranslation() + world_cam.getZDirection()*(m_forward*0.1f);
new_pos = new_pos + world_cam.getXDirection()*(m_rightward * 20);
new_pos = new_pos + world_cam.getYDirection()*(m_upward * 20);
world_cam.setTranslation(new_pos);
temp = world_cam;
temp.inverse();
cc.m_view = temp;
cc.m_proj.setOrthoLH
(
width,
height,
-1.0f,
1.0f
);
}
and this is how i fill my linestrip to draw
void AppWindow::onLeftMouseDown(const Point & mouse_pos)
{
Point pos = screenToClient(mouse_pos);
clickedPoint = Vector3D(pos.m_x, pos.m_y, 0.0f);
if (isLPressed)
{
if (counter == 0)
{
LineStrip.push_back(Line(clickedPoint));
counter++;
}
else
{
LineStrip.back().addPoint(clickedPoint);
counter++;
}
}
}
and this is vertex shader
VS_OUTPUT vsmain(VS_INPUT input)
{
VS_OUTPUT output = (VS_OUTPUT) 0;
float4 new_pos = mul(input.position, m_world);
float clip_x = (new_pos.x / client_width) * 2.0 - 1.0;
float clip_y = 1.0 - (new_pos.y / client_height) * 2.0;
output.position = float4(clip_x, clip_y, 0, 1);
output.color = input.color;
return output;
}
Right now i can draw lines as i wanted.The problem is i cant make panning and zooming work.It just doesn't move the screen at all.I'm guessing how i fill linestrip and vertex shader output is wrong.If you any of you help me out of this i will be so glad.
Thank you

Answer 1

Your main issue here stems from a misunderstanding of how 3D space works.
There are five main spaces used in the 3D rendering pipeline: Local Space, World Space, View Space, Projection Space/Homogeneous Clip Space, and Screen Space. The matrices used to convert between them are named for the space they convert to:
The World Matrix converts from Local Space to World Space.
The View Matrix converts from World Space to View Space.
The Projection Matrix converts from View Space to Projection Space.
The rasterizer does the final transformation based on the settings in the D3D11_VIEWPORT structure, specified in the ID3D11DeviceContext::RSSetViewports call.
Your system is simple enough that you don't need a world matrix. Since you presumably are making a 2D drawing program with the 3D API, you can specify the points for each line directly in world space.
In order to support camera operations, however, you need a view matrix, and in order to do the rendering properly, you will need a projection matrix and a D3D11_VIEWPORT structure with the size of the client area filled in.
In your code you create an orthographic projection matrix, which is perfect (though your near and far plane specifications should be the minumum and maximum zoom you support). You don't, however, create a view matrix properly. The view matrix is the inverse transpose of the camera's world matrix, and it can be created directly with XMMatrixLookAtLH or XMMatrixLookToLH (LookTo is likely to be a better option for your system).
Finally, when you update the shader's constant buffer with the new matrix, multiply the view and projection matrices together before writing the new combined matrix down to the buffer.
As a consequence of this new complexity, you no longer need the majority of the code in the vertex shader - you can do the multiplication directly:
VS_OUTPUT vsmain(VS_INPUT input)
{
VS_OUTPUT output = (VS_OUTPUT) 0;
output.position = mul(input.position, m_viewprojection);
output.color = input.color;
return output;
}
The final stage is the adding of new points. Because of the added view and projection matrices, the coordinates you get from the mouse down event are not world space coordinates. You need to convert them to clip space, then multiply them by the inverse of the combined view/projection matrix to convert them into the real coordinates in world space. Then you can add the new line segment to the strip, the same as how you have in your code.
The conversion to clip space is basic algebra - the conversion the rasterizer does is:
[ScreenX, ScreenY] = [(ProjX + 1)*(ScreenWidth/2), (ProjY + 1)*(ScreenHeight/2)]
To convert back to projection space:
[ProjX, ProjY] = [(ScreenX * (2 / ScreenWidth)) - 1, (ScreenY * (2 / ScreenHeight)) - 1]
From there, you can do a matrix-vector multiplication to get the X and Y coordinates in world space. Since this app is 2D (presumably), you can ignore the lost Z component and just take X and Y. If you ever convert to 3D however, you will need to project a ray from the X and Y coordinates out into the world to find the object to select, or somehow fix the Z coordinate with a different algorithm.