/*****************************************************************************
* "Irit" - the 3d polygonal solid modeller. *
* *
* Written by: Gershon Elber Unix - X11 Ver 0.1, Mar. 1990 *
******************************************************************************
* Module to handle viewing of objects in the ViewWindow. *
*****************************************************************************/
#include <stdio.h>
#include <math.h>
#include "program.h"
#include "attribut.h"
#include "graphgen.h"
#include "objects.h"
#include "freeform.h"
#include "geomat3d.h"
#include "primitiv.h"
#include "windows.h"
#include "viewobj.h"
#include "graphgen.h"
#define MAX_ROTATE_ANGLE 45.0 /* Maximum rates used by interact mode. */
#define MAX_TRANSLATE_FACTOR 2.0
#define MAX_SCALE_FACTOR 2.0
static int
ViewNormals = FALSE,
ClosedObject = FALSE,
SupportClosedObject = FALSE,
NormalsColor = 1, /* View normals to object. */
QuitView = FALSE;
static RealType
LastCoord[3], /* Used to store last point we moved/draw to. */
NormalsSize = 0.1;
static ObjectStruct
*ActiveObjList = NULL; /* Currently displayed objects. */
/* Prototypes for the View Object module: */
static void InteractHandleInput(ObjectStruct *PObjList,
MatrixType GlblViewMat, MatrixType GlblPrspMat);
static MatrixType *ComputeCrntViewMatrix(void);
static void ViewGeomObjectList(ObjectStruct *PObjList);
static int GetInternal(void);
static void ViewCagdPolyline(CagdPolylineStruct *Pl, int Color,
MatrixType Mat);
static void TestQuitView(void);
static void ViewPolygon(PolygonStruct *Pl, int Color, int IsPolyline,
MatrixType Mat, int ViewInternal);
static void DepthCueMoveTo(RealType Coord[3]);
static void DepthCueDrawTo(RealType NewCoord[3]);
#ifdef __GL__
static void DrawPolygonSolid(PolygonStruct *PPolygon, MatrixType Mat);
#endif /* __GL__ */
/*****************************************************************************
* Routine to interactively display geometric object(s) PObj on the View *
* window enable rotating/translating/scaling it using the Input Device. *
*****************************************************************************/
void InteractPolyObject(ObjectStruct *PObj, RealType *UpdateGlblMat)
{
ObjectStruct *ViewMat, *PrspMat;
MatrixType ViewMatCopy, PrspMatCopy; /* Save original trans. to recover. */
if (!GlblDoGraphics) return;
if ((ViewMat = GetObject("VIEW_MAT")) == NULL) {
WndwInputWindowPutStr(
"No view transformation matrix VIEW_MAT!");
return;
}
else if (!IS_MAT_OBJ(ViewMat)) {
WndwInputWindowPutStr(
"VIEW_MAT object was modified (not matrix object)");
return;
}
MAT_COPY(ViewMatCopy, ViewMat -> U.Mat);
if ((PrspMat = GetObject("PRSP_MAT")) == NULL) {
WndwInputWindowPutStr(
"No perspective transformation matrix PRSP_MAT!");
return;
}
else if (!IS_MAT_OBJ(PrspMat)) {
WndwInputWindowPutStr(
"PRSP_MAT object was modified (not matrix object)");
return;
}
MAT_COPY(PrspMatCopy, PrspMat -> U.Mat);
/* Get data from input device, interpret it, and display interactively: */
InteractHandleInput(PObj, ViewMat -> U.Mat, PrspMat -> U.Mat);
if (!APX_EQ(*UpdateGlblMat, 0.0)) {
MAT_COPY(ViewMat -> U.Mat, ViewMatCopy); /* Recover. */
MAT_COPY(PrspMat -> U.Mat, PrspMatCopy);
}
}
/*****************************************************************************
* Routine to handle data from the input device (keyboard, mouse etc.) - *
* clip it against the sub windows of the interactive menu and perform the *
* required transfomation, by updating the global view matrix object VIEW_MAT *
* The input data in the Rotation/Translation/Scaling sub windows is used *
* (horizontal distance from sub window center) to set amount of change. *
*****************************************************************************/
static void InteractHandleInput(ObjectStruct *PObjList,
MatrixType GlblViewMat, MatrixType GlblPrspMat)
{
int UpdateView;
RealType ChangeFactor;
MatrixType Mat, OrigViewMat, OrigPrspMat;
#if !defined(__MSDOS__) && !defined(DJGCC)
long WinID, DispID, ColorMapID;
#endif /* !__MSDOS__ && !DJGCC */
/* Save copy of original matrix, so we can recover if reset is required. */
GEN_COPY(OrigViewMat, GlblViewMat, sizeof(MatrixType));
GEN_COPY(OrigPrspMat, GlblPrspMat, sizeof(MatrixType));
ActiveObjList = PObjList;
QuitView = FALSE;
#ifdef __MSDOS__
IntrWndwPop(TransWindowID, TRUE, TRUE);
#endif /* __MSDOS__ */
#if defined(__MSDOS__) || defined(DJGCC)
GGClearViewArea();
/* Set the async. function for intr_lib to refresh the view window. */
IntrWndwSetRefreshFunc(ViewWindowID,
(IntrIntFunc) UpdateInteractHandleInput);
#endif /* __MSDOS__ || DJGCC */
UpdateInteractHandleInput(); /* Display it for the first time. */
while (TRUE) {
QuitView = FALSE;
UpdateView = TRUE;
switch (GGGetGraphicEvent(&ChangeFactor)) {
case EVENT_SCR_OBJ_TGL: /* Its Coordinate system - toggle it. */
UpdateView = FALSE;
break;
case EVENT_PERS_ORTHO_TGL: /* Its View mode - toggle it. */
MatGenUnitMat(Mat);
break;
case EVENT_PERS_ORTHO_Z: /* Its Perspective Z focal point modif. */
if (GlblViewMode != VIEW_PERSPECTIVE) {
GGTone(1000, 100); /* Do some noise! */
UpdateView = FALSE;
break;
}
/* Make it between 0.5 and 1.5: */
ChangeFactor = ChangeFactor / 2.0 + 1.0;
GlblPrspMat[2][2] *= ChangeFactor;
GlblPrspMat[2][3] *= ChangeFactor;
GlblPrspMat[3][2] *= ChangeFactor;
MatGenUnitMat(Mat);
break;
case EVENT_ROTATE_X: /* Its rotation along the X axis. */
MatGenMatRotX1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_ROTATE_Y: /* Its rotation along the Y axis. */
MatGenMatRotY1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_ROTATE_Z: /* Its rotation along the Z axis. */
MatGenMatRotZ1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_TRANSLATE_X: /* Its translation along the X axis. */
MatGenMatTrans(ChangeFactor * MAX_TRANSLATE_FACTOR, 0.0, 0.0,
Mat);
break;
case EVENT_TRANSLATE_Y: /* Its translation along the Y axis. */
MatGenMatTrans(0.0, ChangeFactor * MAX_TRANSLATE_FACTOR, 0.0,
Mat);
break;
case EVENT_TRANSLATE_Z: /* Its translation along the Z axis. */
MatGenMatTrans(0.0, 0.0, ChangeFactor * MAX_TRANSLATE_FACTOR,
Mat);
break;
case EVENT_SCALE: /* Its scaling along all axes. */
if (ChangeFactor > 0.0) /* Make it around 1... */
ChangeFactor = ChangeFactor * MAX_SCALE_FACTOR + 1.0;
else
ChangeFactor = 1.0 /
(-ChangeFactor * MAX_SCALE_FACTOR + 1.0);
MatGenMatScale(ChangeFactor, ChangeFactor, ChangeFactor, Mat);
break;
case EVENT_DEPTH_CUE:
if (!GlblDepthCue) GGMySetLineStyle(SOLID_LINE);
MatGenUnitMat(Mat);
break;
#ifdef __GL__ /* Only on GL library systems. */
case EVENT_DRAW_SOLID:
MatGenUnitMat(Mat);
break;
#else
case EVENT_DRAW_SOLID:
#endif
case EVENT_SAVE_GIF:
case EVENT_SAVE_PS:
case EVENT_SAVE_MATRIX:
GGTone(800, 100);
GGTone(400, 200);
UpdateView = FALSE;
break;
case EVENT_RESET_MATRIX:
GEN_COPY(GlblViewMat, OrigViewMat, sizeof(MatrixType));
GEN_COPY(GlblPrspMat, OrigPrspMat, sizeof(MatrixType));
MatGenUnitMat(Mat);
break;
case EVENT_QUIT:
ActiveObjList = NULL;
#ifdef __MSDOS__
IntrWndwPop(StatusWindowID, TRUE, TRUE);
#endif /* __MSDOS__ */
return; /* Its Quit. */
default:
FatalError("InteractHandleInput: Undefine input type, exit\n");
}
if (UpdateView) {
switch (GlblTransformMode) {/* Udpate the global viewing matrix. */
case TRANS_SCREEN:
MatMultTwo4by4(GlblViewMat, GlblViewMat, Mat);
break;
case TRANS_OBJECT:
MatMultTwo4by4(GlblViewMat, Mat, GlblViewMat);
break;
}
#if defined(__MSDOS__) || defined(DJGCC)
GGClearViewArea();
#endif /* __MSDOS__ || DJGCC */
UpdateInteractHandleInput();
}
}
}
/*****************************************************************************
* Compute the current view using VIEW_MAT and PRSP_MAT matrices. *
*****************************************************************************/
static MatrixType *ComputeCrntViewMatrix(void)
{
static MatrixType CrntViewMat;
ObjectStruct *ViewMat, *PrspMat;
if ((ViewMat = GetObject("VIEW_MAT")) == NULL) {
WndwInputWindowPutStr(
"No view transformation matrix VIEW_MAT!");
return NULL;
}
else if (!IS_MAT_OBJ(ViewMat)) {
WndwInputWindowPutStr(
"VIEW_MAT object was modified (not matrix object)");
return NULL;
}
if ((PrspMat = GetObject("PRSP_MAT")) == NULL) {
WndwInputWindowPutStr(
"No perspective transformation matrix PRSP_MAT!");
return NULL;
}
else if (!IS_MAT_OBJ(PrspMat)) {
WndwInputWindowPutStr(
"PRSP_MAT object was modified (not matrix object)");
return NULL;
}
switch (GlblViewMode) {
case VIEW_ORTHOGRAPHIC:
GEN_COPY(CrntViewMat, ViewMat -> U.Mat, sizeof(MatrixType));
break;
case VIEW_PERSPECTIVE:
MatMultTwo4by4(CrntViewMat, ViewMat -> U.Mat, PrspMat -> U.Mat);
break;
}
return &CrntViewMat;
}
/*****************************************************************************
* Routine to update the viewing screen. On unix systems this routine may *
* be invoked when X sends expose event to this program (see xgrphgen.c). *
* In MSDOS this routine is static and been called from InteractHandleInput *
* above routine only. *
*****************************************************************************/
void UpdateInteractHandleInput(void)
{
#if !defined(__MSDOS__) && !defined(DJGCC)
GGClearViewArea();
#endif /* !__MSDOS__ && !DJGCC */
if (ActiveObjList != NULL)
ViewGeomObject(ActiveObjList); /* And display it... */
#if !defined(__MSDOS__) && !defined(DJGCC)
GGGraphicFlush();
#endif /* !__MSDOS__ && !DJGCC */
}
/*****************************************************************************
* Routine to display the geometric objects in PObjList, by simply calling *
* ViewGeomObject on all of them. PObjList must be of type OBJ_LIST_OBJ. *
*****************************************************************************/
static void ViewGeomObjectList(ObjectStruct *PObjList)
{
int Param = 0;
ObjectStruct *PObj;
while ((PObj = PObjList -> U.PObjList[Param]) != NULL &&
Param++ < MAX_OBJ_LIST && !QuitView) {
ViewGeomObject(PObj);
}
}
/*****************************************************************************
* Routine to fetch the internal parameter from the INTERNAL object. *
*****************************************************************************/
static int GetInternal(void)
{
int Internal;
ObjectStruct *PObj = GetObject("INTERNAL");
if (PObj == NULL || !IS_NUM_OBJ(PObj)) {
WndwInputWindowPutStr("No numeric object name INTERNAL is defined");
Internal = DEFAULT_INTERNAL;
}
else
Internal = !APX_EQ((PObj -> U.R), 0.0);
return Internal;
}
/*****************************************************************************
* Routine to display the geometric object PObj on the View Window: *
* Uses the global view transformation as computed by ComputeCrntViewMat. *
*****************************************************************************/
void ViewGeomObject(ObjectStruct *PObj)
{
int Color, IsPolyline,
DrawCtlPtColor = GetDrawCtlPt(),
ViewInternal = GetInternal(),
RealResolution = GetResolution(FALSE);
CagdPolylineStruct *CagdPl;
PolygonStruct *Pl;
MatrixType *CrntMat;
if (!GlblDoGraphics) return;
QuitView = FALSE;
if (IS_OLST_OBJ(PObj)) {
/* Invoke the display routine on each of its componenets. */
ViewGeomObjectList(PObj);
return;
}
if (!IS_GEOM_OBJ(PObj)) {
WndwInputWindowPutStr("None displayable object ignored.");
return;
}
Color = GetObjectColor(PObj);
if ((CrntMat = ComputeCrntViewMatrix()) == NULL)
return;
if (IS_POLY_OBJ(PObj)) {
Pl = PObj -> U.Pl.P;
IsPolyline = IS_POLYLINE_OBJ(PObj);
if (!IsPolyline && SupportClosedObject)
ClosedObject = TRUE;
while (Pl && !QuitView) {
ViewPolygon(Pl, Color, IsPolyline, *CrntMat, ViewInternal);
Pl = Pl -> Pnext;
TestQuitView();/* if break display in the middle - Set QuitView. */
}
ClosedObject = FALSE;
}
else if (IS_CRV_OBJ(PObj)) {
if (!GlblDrawSolid) {
ComputeCurveIsoLines(PObj);
if (RealResolution > 0)
ViewCagdPolyline(PObj -> U.Crv.PLPolys, Color, *CrntMat);
if (DrawCtlPtColor)
ViewCagdPolyline(PObj -> U.Crv.CtlPoly, DrawCtlPtColor,
*CrntMat);
}
}
else if (IS_SRF_OBJ(PObj)) {
if (GlblDrawSolid) {
ComputeSurfacePolygons(PObj);
SetObjectColor(PObj -> U.Srf.Polygons, GetObjectColor(PObj));
ViewGeomObject(PObj -> U.Srf.Polygons);
}
else {
ComputeSurfaceIsoLines(PObj);
if (RealResolution > 0) {
CagdPl = PObj -> U.Srf.PLPolys;
while (CagdPl && !QuitView) {
ViewCagdPolyline(CagdPl, Color, *CrntMat);
CagdPl = CagdPl -> Pnext;
TestQuitView();/* Break display in middle - Set QuitView. */
}
}
if (DrawCtlPtColor) {
CagdPl = PObj -> U.Srf.CtlMesh;
while (CagdPl && !QuitView) {
ViewCagdPolyline(CagdPl, DrawCtlPtColor, *CrntMat);
CagdPl = CagdPl -> Pnext;
TestQuitView();
}
}
}
}
}
/*****************************************************************************
* Routine to display one polyline on the view window using the matrix Mat *
* as a transformation matrix. *
*****************************************************************************/
static void ViewCagdPolyline(CagdPolylineStruct *Pl, int Color,
MatrixType Mat)
{
int i, j;
PointType P, TempP;
CagdPtStruct
*Points = Pl -> Polyline;
/* Since we can not guarantee that CagdRType == RealType: */
for (i = 0; i < 3; i++) TempP[i] = Points[0].Pt[i];
MatMultVecby4by4(P, TempP, Mat); /* Transform the first point. */
DepthCueMoveTo(P);
GGMySetColor(Color);
for (i = 1; i < Pl -> Length; i++) {
for (j = 0; j < 3; j++) TempP[j] = Points[i].Pt[j];
MatMultVecby4by4(P, TempP, Mat);
DepthCueDrawTo(P);
};
}
/*****************************************************************************
* Routine to test if quit display event - occured - *
* Right button was clicked on mouse. *
*****************************************************************************/
static void TestQuitView(void)
{
QuitView = GGIsAbortKeyPressed();
}
/*****************************************************************************
* Routine to display one polygon on the view window using the matrix Mat as *
* a transformation matrix. *
*****************************************************************************/
static void ViewPolygon(PolygonStruct *Pl, int Color, int IsPolyline,
MatrixType Mat, int ViewInternal)
{
int NumOfPoints, DontDraw,
ShowNormals = ViewNormals && !IsPolyline;
PointType P, CenterP;
VertexStruct *V, *VStart;
V = VStart = Pl -> V;
if (V == NULL) FatalError("ViewPolygon: Empty polygon to view\n");
GGMySetColor(Color);
#ifdef __GL__ /* Only on GL library systems. */
if (GlblDrawSolid && !IsPolyline) {
DrawPolygonSolid(Pl, Mat);
return;
}
#endif
MatMultVecby4by4(P, V -> Pt, Mat); /* Transform the first point. */
DepthCueMoveTo(P);
DontDraw = IS_INTERNAL_EDGE(V) && !ViewInternal; /* Draw next edge? */
if (ShowNormals) { /* If display of normal is required. */
NumOfPoints = 0;
PT_CLEAR(CenterP);
}
do {
V = V -> Pnext;
if (ShowNormals) {
NumOfPoints++;
PT_ADD(CenterP, CenterP, V -> Pt);
}
MatMultVecby4by4(P, V -> Pt, Mat);
/* If edge is INTERNAL (Irit.h) and not ViewInternal - dont draw: */
if (DontDraw)
DepthCueMoveTo(P);
else
DepthCueDrawTo(P);
DontDraw = IS_INTERNAL_EDGE(V) && !ViewInternal; /* Draw next edge? */
} while (V != VStart && V -> Pnext != NULL);
if (ShowNormals) {
PT_SCALE(CenterP, 1.0/NumOfPoints); /* Estimate for normals. */
MatMultVecby4by4(P, CenterP, Mat); /* Transform the first point. */
DepthCueMoveTo(P);
PT_COPY(P, Pl -> Plane);
PT_SCALE(P, NormalsSize);
PT_ADD(CenterP, CenterP, P);
MatMultVecby4by4(P, CenterP, Mat); /* Transform the second point. */
GGMySetColor(NormalsColor);
DepthCueDrawTo(P);
}
}
/*****************************************************************************
* Routine to set the normals default values: *
*****************************************************************************/
void ViewSetNormals(RealType *Active, RealType *Size, RealType *Color)
{
ViewNormals = !APX_EQ(*Active, 0.0);
NormalsSize = *Size;
NormalsColor = (int) *Color;
}
/*****************************************************************************
* Routine to set the closed objects default. *
*****************************************************************************/
void ViewSetClosed(RealType *Closed)
{
SupportClosedObject = !APX_EQ(*Closed, 0.0);
}
/*****************************************************************************
* Routine to mave to 3D point given as Coord[3], using Mat transform. *
*****************************************************************************/
static void DepthCueMoveTo(RealType Coord[3])
{
GEN_COPY(LastCoord, Coord, 3 * sizeof(RealType)); /* Set crnt point. */
}
/*****************************************************************************
* Routine to draw to 3D point given as Coord[3], using Mat transform, from *
* the last point we moved to. *
*****************************************************************************/
static void DepthCueDrawTo(RealType NewCoord[3])
{
RealType MiddleCoord[3], t;
if (ClosedObject && NewCoord[2] < LastCoord[2]) {
GEN_COPY(LastCoord, NewCoord, 3 * sizeof(RealType));
return;
}
/* Implementation of simple depth cue - if line is >Z or <Z ... */
if (LastCoord[2] <= 0.0 && NewCoord[2] <= 0.0) { /* Draw the <Z part: */
if (GlblDepthCue) GGMySetLineStyle(DOTTED_LINE);
GGMyMove(LastCoord[0], LastCoord[1]);
GGMyDraw(NewCoord[0], NewCoord[1]); /* DRAW! */
}
else if (LastCoord[2] >= 0.0 && NewCoord[2] >= 0.0 ||
ABS(LastCoord[2] - NewCoord[2]) < EPSILON) {
if (GlblDepthCue) GGMySetLineStyle(SOLID_LINE);
GGMyMove(LastCoord[0], LastCoord[1]);
GGMyDraw(NewCoord[0], NewCoord[1]); /* DRAW! */
}
else { /* Line intersect Z = 0 plane. */
t = LastCoord[2] / (LastCoord[2] - NewCoord[2]);
MiddleCoord[0] = LastCoord[0] * (1.0 - t) + NewCoord[0] * t;
MiddleCoord[1] = LastCoord[1] * (1.0 - t) + NewCoord[1] * t;
if (GlblDepthCue) GGMySetLineStyle(SOLID_LINE);
if (LastCoord[2] > 0.0) {
GGMyMove(LastCoord[0], LastCoord[1]);
GGMyDraw(MiddleCoord[0], MiddleCoord[1]); /* DRAW! */
}
else {
GGMyMove(MiddleCoord[0], MiddleCoord[1]);
GGMyDraw(NewCoord[0], NewCoord[1]); /* DRAW! */
}
if (GlblDepthCue) GGMySetLineStyle(DOTTED_LINE);/* Draw the <Z part: */
if (LastCoord[2] < 0.0) {
GGMyMove(LastCoord[0], LastCoord[1]);
GGMyDraw(MiddleCoord[0], MiddleCoord[1]); /* DRAW! */
}
else {
GGMyMove(MiddleCoord[0], MiddleCoord[1]);
GGMyDraw(NewCoord[0], NewCoord[1]); /* DRAW! */
}
}
GEN_COPY(LastCoord, NewCoord, 3 * sizeof(RealType)); /* Set crnt point. */
}
#ifdef __GL__
/****************************************************************************
* Routine to draw a polygon full. *
****************************************************************************/
static void DrawPolygonSolid(PolygonStruct *PPolygon, MatrixType Mat)
{
int i, l = 0;
float Normal[3], Length;
double MappedVertex[3];
RealType V1R[3], V2R[3], V3R[3];
VertexStruct *PList = PPolygon -> V;
GGMyDrawPolygonSolid(NULL, NULL, TRUE);
do {
MatMultVecby4by4(V1R, PList -> Pt, Mat);
for (i = 0; i < 3; i++) MappedVertex[i] = V1R[i];
/* Each vertex has different normal - specify them. */
MatMultVecby4by4(V1R, PList -> Pt, Mat);
for (i = 0; i < 3; i++)
V2R[i] = PList -> Pt[i] + PList -> Normal[i];
MatMultVecby4by4(V2R, V2R, Mat);
for (i = 0; i < 3; i++) Normal[i] = V2R[i] - V1R[i];
Length = sqrt(SQR(Normal[0]) + SQR(Normal[1]) + SQR(Normal[2]));
for (i = 0; i < 3; i++) Normal[i] /= -Length;
GGMyDrawPolygonSolid(MappedVertex, Normal, TRUE);
PList = PList -> Pnext;
if (l++ >= 255)
FatalError("GL: polygon too complex (> 256 vertices).\n");
}
while (PList != NULL && PList != PPolygon -> V);
GGMyDrawPolygonSolid(NULL, NULL, FALSE);
}
#endif /* __GL__ */
