doxygen/html/_projector_8cpp_source.html

 /*  Project nGenEx

-         Destroyer Studios LLC

-         Copyright � 1997-2004. All Rights Reserved.

-

-         SUBSYSTEM:    nGenEx.lib

-         FILE:         Projector.cpp

-         AUTHOR:       John DiCamillo

-

-

-         OVERVIEW

-         ========

-         3D Projection Camera class

- */

-

- #include "MemDebug.h"

- #include "Projector.h"

-

- // +--------------------------------------------------------------------+

-

- static const float   CLIP_PLANE_EPSILON   = 0.0001f;

- static const double  Z_NEAR               = 1.0;

-

- void Print(const char* fmt, ...);

-

- // +--------------------------------------------------------------------+

-

- static Camera  emergency_cam;

-

- // +--------------------------------------------------------------------+

-

- Projector::Projector(Window* window, Camera* cam)

- : camera(cam), infinite(0), depth_scale(1.0f), orthogonal(false), field_of_view(2)

- {

-         if (!camera)

-         camera = &emergency_cam;

-

-         UseWindow(window);

- }

-

- Projector::~Projector()

- { }

-

- // +--------------------------------------------------------------------+

-

- void

- Projector::UseCamera(Camera* cam)

- {

-         if (cam)

-         camera = cam;

-         else

-         camera = &emergency_cam;

- }

-

- void

- Projector::UseWindow(Window* win)

- {

-         Rect r  = win->GetRect();

-         width   = r.w;

-         height  = r.h;

-

-         xcenter = (width  / 2.0);

-         ycenter = (height / 2.0);

-

-         xclip0  = 0.0f;

-         xclip1  = (float) width-0.5f;

-         yclip0  = 0.0f;

-         yclip1  = (float) height-0.5f;

-

-         SetFieldOfView(field_of_view);

- }

-

- void

- Projector::SetFieldOfView(double fov)

- {

-         field_of_view = fov;

-

-         xscreenscale = width  / fov;

-         yscreenscale = height / fov;

-

-         maxscale     = max(xscreenscale, yscreenscale);

-

-         xangle       = atan(2.0/fov * maxscale/xscreenscale);

-         yangle       = atan(2.0/fov * maxscale/yscreenscale);

- }

-

- double

- Projector::GetFieldOfView() const

- {

-         return field_of_view;

- }

-

- void

- Projector::SetDepthScale(float scale)

- {

-         depth_scale = scale;

- }

-

- double

- Projector::GetDepthScale() const

- {

-         return depth_scale;

- }

-

- int

- Projector::SetInfinite(int i)

- {

-         int old = infinite;

-         infinite = i;

-         return old;

- }

-

- // +--------------------------------------------------------------------+

-

- void

- Projector::StartFrame()

- {

-         SetUpFrustum();

-         SetWorldSpace();

- }

-

- // +--------------------------------------------------------------------+

- // Transform a point from worldspace to viewspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::Transform(Vec3& vec) const

- {

-         Vec3 tvert = vec;

-

-         // Translate into a viewpoint-relative coordinate

-         if (!infinite)

-         tvert -= camera->Pos();

-

-         // old method:

-         vec.x = (tvert * camera->vrt());

-         vec.y = (tvert * camera->vup());

-         vec.z = (tvert * camera->vpn());

-

-         // Rotate into the view orientation

-         // vec = tvert * camera->Orientation();

- }

-

- // +--------------------------------------------------------------------+

- // Transform a point from worldspace to viewspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::Transform(Point& point) const

- {

-         Point tvert = point;

-

-         // Translate into a viewpoint-relative coordinate

-         if (!infinite)

-         tvert -= camera->Pos();

-

-         // old method:

-         point.x = (tvert * camera->vrt());

-         point.y = (tvert * camera->vup());

-         point.z = (tvert * camera->vpn());

-

-         // Rotate into the view orientation

-         // point = tvert * camera->Orientation();

- }

-

- // +--------------------------------------------------------------------+

- // APPARENT RADIUS OF PROJECTED OBJECT

- // Project a viewspace point into screen coordinates.

- // Use projected Z to determine apparent radius of object.

- // +--------------------------------------------------------------------+

-

- float

- Projector::ProjectRadius(const Vec3& v, float radius) const

- {

-         return (float) fabs((radius * maxscale) / v.z);

- }

-

- // +--------------------------------------------------------------------+

- // IN PLACE PROJECTION OF POINT

- // Project a viewspace point into screen coordinates.

- // Note that the y axis goes up in worldspace and viewspace, but

- // goes down in screenspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::Project(Vec3& v, bool clamp) const

- {

-         double  zrecip;

-

-         if (orthogonal) {

-                 double scale = field_of_view/2;

-                 v.x  = (float)           (xcenter + scale * v.x);

-                 v.y  = (float) (height - (ycenter + scale * v.y));

-                 v.z  = (float) (0.0f);

-         }

-

-         else {

-                 //zrecip = 2 * (1.0e5 / (1.0e5-1)) / v.z;

-                 //zrecip = 2 * 0.97 / v.z; -- what the heck was this version used for?

-

-                 zrecip = 2 / v.z;

-                 v.x  = (float)           (xcenter + maxscale * v.x * zrecip);

-                 v.y  = (float) (height - (ycenter + maxscale * v.y * zrecip));

-                 v.z  = (float) (1 - zrecip);

-         }

-

-         // clamp the point to the viewport:

-         if (clamp) {

-                 if (v.x < xclip0) v.x = xclip0;

-                 if (v.x > xclip1) v.x = xclip1;

-                 if (v.y < yclip0) v.y = yclip0;

-                 if (v.y > yclip1) v.y = yclip1;

-         }

- }

-

- // +--------------------------------------------------------------------+

- // IN PLACE PROJECTION OF POINT

- // Project a viewspace point into screen coordinates.

- // Note that the y axis goes up in worldspace and viewspace, but

- // goes down in screenspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::Project(Point& v, bool clamp) const

- {

-         double  zrecip;

-

-         if (orthogonal) {

-                 double scale = field_of_view/2;

-                 v.x  =           (xcenter + scale * v.x);

-                 v.y  = (height - (ycenter + scale * v.y));

-                 v.z  = 0;

-         }

-

-         else {

-                 zrecip = 1 / v.z;

-                 v.x  =           (xcenter + 2 * maxscale * v.x * zrecip);

-                 v.y  = (height - (ycenter + 2 * maxscale * v.y * zrecip));

-                 v.z  = (1 - zrecip);

-         }

-

-         // clamp the point to the viewport:

-         if (clamp) {

-                 if (v.x < xclip0) v.x = xclip0;

-                 if (v.x > xclip1) v.x = xclip1;

-                 if (v.y < yclip0) v.y = yclip0;

-                 if (v.y > yclip1) v.y = yclip1;

-         }

- }

-

- // +--------------------------------------------------------------------+

- // IN PLACE UN-PROJECTION OF POINT

- // Convert a point in screen coordinates back to viewspace.

- // Note that the y axis goes up in worldspace and viewspace, but

- // goes down in screenspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::Unproject(Point& v) const

- {

-         double  zrecip = 1 / v.z;

-

-         /***

-         * forward projection:

- v.x  = (xcenter + maxscale * v.x * zrecip);

- v.y  = (height - (ycenter + maxscale * v.y * zrecip));

- v.z  = (1 - zrecip);

- ***/

-

-         v.x  = (         v.x - xcenter) / (maxscale * zrecip);

-         v.y  = (height - v.y - ycenter) / (maxscale * zrecip);

- }

-

- // +--------------------------------------------------------------------+

- // IN PLACE PROJECTION OF RECTANGLE (FOR SPRITES)

- // Project a viewspace point into screen coordinates.

- // Note that the y axis goes up in worldspace and viewspace, but

- // goes down in screenspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::ProjectRect(Point& v, double& w, double& h) const

- {

-         double  zrecip;

-

-         if (orthogonal) {

-                 double scale = field_of_view/2;

-                 v.x  =           (xcenter + scale * v.x);

-                 v.y  = (height - (ycenter + scale * v.y));

-                 v.z  = 0;

-         }

-

-         else {

-                 zrecip = 1 / v.z;

-                 v.x  =           (xcenter + 2 * maxscale * v.x * zrecip);

-                 v.y  = (height - (ycenter + 2 * maxscale * v.y * zrecip));

-                 v.z  = (1 - Z_NEAR*zrecip);

-

-                 w   *= maxscale * zrecip;

-                 h   *= maxscale * zrecip;

-         }

- }

-

- // +--------------------------------------------------------------------+

- // Set up a clip plane with the specified normal.

- // +--------------------------------------------------------------------+

-

- void

- Projector::SetWorldspaceClipPlane(Vec3& normal, Plane& plane)

- {

-         // Rotate the plane normal into worldspace

-         ViewToWorld(normal, plane.normal);

-         plane.distance = (float) (camera->Pos() * plane.normal + CLIP_PLANE_EPSILON);

- }

-

- // +--------------------------------------------------------------------+

- // Set up the planes of the frustum, in worldspace coordinates.

- // +--------------------------------------------------------------------+

-

- void

- Projector::SetUpFrustum()

- {

-         double  angle, s, c;

-         Vec3    normal;

-

-         angle = XAngle();

-         s = sin(angle);

-         c = cos(angle);

-

-         // Left clip plane

-         normal.x = (float) s;

-         normal.y = (float) 0;

-         normal.z = (float) c;

-         view_planes[0].normal   = normal;

-         view_planes[0].distance = CLIP_PLANE_EPSILON;

-         SetWorldspaceClipPlane(normal, world_planes[0]);

-

-         // Right clip plane

-         normal.x = (float) -s;

-         view_planes[1].normal   = normal;

-         view_planes[1].distance = CLIP_PLANE_EPSILON;

-         SetWorldspaceClipPlane(normal, world_planes[1]);

-

-         angle = YAngle();

-         s = sin(angle);

-         c = cos(angle);

-

-         // Bottom clip plane

-         normal.x = (float) 0;

-         normal.y = (float) s;

-         normal.z = (float) c;

-         view_planes[2].normal   = normal;

-         view_planes[2].distance = CLIP_PLANE_EPSILON;

-         SetWorldspaceClipPlane(normal, world_planes[2]);

-

-         // Top clip plane

-         normal.y = (float) -s;

-         view_planes[3].normal   = normal;

-         view_planes[3].distance = CLIP_PLANE_EPSILON;

-         SetWorldspaceClipPlane(normal, world_planes[3]);

- }

-

- // +--------------------------------------------------------------------+

- // Clip the point against the frustum and return 1 if partially inside

- // Return 2 if completely inside

- // +--------------------------------------------------------------------+

-

- int

- Projector::IsVisible(const Vec3& v, float radius) const

- {

-         int visible = 1;

-         int complete = 1;

-

-         Plane* plane = (Plane*) frustum_planes;

-         if (infinite) {

-                 complete = 0;

-

-                 for (int i = 0; visible && (i < NUM_FRUSTUM_PLANES); i++) {

-                         visible = ((v * plane->normal) >= CLIP_PLANE_EPSILON);

-                         plane++;

-                 }

-         }

-         else {

-                 for (int i = 0; visible && (i < NUM_FRUSTUM_PLANES); i++) {

-                         float dot = v * plane->normal;

-                         visible  = ((dot + radius) >= plane->distance);

-                         complete = complete && ((dot - radius) >= plane->distance);

-                         plane++;

-                 }

-         }

-

-         return visible + complete;

- }

-

- // +--------------------------------------------------------------------+

- // Clip the bouding point against the frustum and return non zero

- // if at least partially inside.  This version is not terribly

- // efficient as it checks all eight box corners rather than just

- // the minimum two.

- // +--------------------------------------------------------------------+

-

- int

- Projector::IsBoxVisible(const Point* p) const

- {

-         int   i, j, outside = 0;

-

-         // if all eight corners are outside of the same

-         // frustrum plane, then the box is not visible

-         Plane* plane = (Plane*) frustum_planes;

-

-         if (infinite) {

-                 for (i = 0; !outside && (i < NUM_FRUSTUM_PLANES); i++) {

-                         for (j = 0; j < 8; j++)

-                         outside += (p[j] * plane->normal) < CLIP_PLANE_EPSILON;

-

-                         if (outside < 8)

-                         outside = 0;

-

-                         plane++;

-                 }

-         }

-         else {

-                 for (i = 0; !outside && (i < NUM_FRUSTUM_PLANES); i++) {

-                         for (j = 0; j < 8; j++)

-                         outside += (p[j] * plane->normal) < plane->distance;

-

-                         if (outside < 8)

-                         outside = 0;

-

-                         plane++;

-                 }

-         }

-

-         // if not outside, then the box is visible

-         return !outside;

- }

-

- // +--------------------------------------------------------------------+

-

- float

- Projector::ApparentRadius(const Vec3& v, float radius) const

- {

-         Vec3 vloc = v;

-

-         Transform(vloc);                  // transform in place

-         return ProjectRadius(vloc, radius);

- }

-

-

- // +--------------------------------------------------------------------+

- // Rotate a vector from viewspace to worldspace.

- // +--------------------------------------------------------------------+

-

- void

- Projector::ViewToWorld(Point& pin, Point& pout)

- {

-         // Rotate into the world orientation

-         pout.x = pin.x * camera->vrt().x + pin.y * camera->vup().x + pin.z * camera->vpn().x;

-         pout.y = pin.x * camera->vrt().y + pin.y * camera->vup().y + pin.z * camera->vpn().y;

-         pout.z = pin.x * camera->vrt().z + pin.y * camera->vup().z + pin.z * camera->vpn().z;

- }

-

- void

- Projector::ViewToWorld(Vec3& vin, Vec3& vout)

- {

-         // Rotate into the world orientation

-         vout.x = (float) (vin.x * camera->vrt().x + vin.y * camera->vup().x + vin.z * camera->vpn().x);

-         vout.y = (float) (vin.x * camera->vrt().y + vin.y * camera->vup().y + vin.z * camera->vpn().y);

-         vout.z = (float) (vin.x * camera->vrt().z + vin.y * camera->vup().z + vin.z * camera->vpn().z);

- }

-

-