c++ graphical programming

I'm new to c++ 3D, so I may just be missing something obvious, but how do I convert from 3D to 2D and (for a given z location) fro开发者_C百科m 2D to 3D?

You map 3D to 2D via projection. You map 2D to 3D by inserting the appropriate value in the Z element of the vector.

It is a matter of casting a ray from the screen onto a plane which is parallel to x-y and is at the required z location. You then need to find out where on the plane the ray is colliding.
Here's one example, considering that screen_x and screen_y ranges from [0, 1], where 0 is the left-most or top-most coordinate and 1 is right-most or bottom-most, respectively:

Vector3 point_of_contact(-1.0f, -1.0f, -1.0f);
Matrix4 view_matrix = camera->getViewMatrix();
Matrix4 proj_matrix = camera->getProjectionMatrix();
Matrix4 inv_view_proj_matrix = (proj_matrix * view_matrix).inverse();
float nx = (2.0f * screen_x) - 1.0f;
float ny = 1.0f - (2.0f * screen_y);
Vector3 near_point(nx, ny, -1.0f);
Vector3 mid_point(nx, ny, 0.0f);
// Get ray origin and ray target on near plane in world space
Vector3 ray_origin, ray_target;
ray_origin = inv_view_proj_matrix * near_point;
ray_target = inv_view_proj_matrix * mid_point;

Vector3 ray_direction = ray_target - ray_origin;
ray_direction.normalise();

// Check for collision with the plane
Vector3 plane_normal(0.0f, 0.0f, 1.0f);
float denominator = plane_normal.dotProduct(ray_direction);
if (fabs(denom) >= std::numeric_limits<float>::epsilon())
{
    float num = plane_normal.dotProduct(ray.getOrigin()) + Vector3(0, 0, z_pos);
    float distance = -(num/denom);
    if (distance > 0)
    {
        point_of_contact = ray_origin + (ray_direction * distance);
    }
}
return point_of_contact

Disclaimer Notice: This solution was taken from bits and pieces of Ogre3D graphics library.

The simplest way is to do a divide by z. Therefore ...

screenX = projectionX / projectionZ;
screenY = projectionY / projectionZ;

That does perspective projection based on distance. Thing is it is often better to use homgeneous coordinates as this simplifies matrix transformation (everything becomes a multiply). Equally this is what D3D and OpenGL use. Understanding how to use non-homogeneous coordinates (ie an (x,y,z) coordinate triple) will be very helpful for things like shader optimisations however.

One lame solution:

^ y
|
|
|  /z
| /
+/--------->x

Angle is the angle between the Ox and Oz axes (

#include <cmath>

typedef struct {
  double x,y,z;
} Point3D;

typedef struct {
  double x,y;
} Point2D 

const double angle = M_PI/4; //can be changed

Point2D* projection(Point3D& point) {
  Point2D* p = new Point2D();
  p->x = point.x + point.z * sin(angle);
  p->y = point.y + point.z * cos(angle);
  return p;
}

However there are lots of tutorials on this on the net... Have you googled for it?