home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The World of Computer Software
/
World_Of_Computer_Software-02-385-Vol-1of3.iso
/
i
/
iritsm3s.zip
/
poly3d
/
interact.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-02-26
|
21KB
|
642 lines
/*****************************************************************************
* Module to handle viewing of objects in the ViewWindow. *
* *
* Written by: Gershon Elber Unix - X11 Ver 0.1, Mar. 1990 *
*****************************************************************************/
#ifdef __MSDOS__
#include <conio.h>
#include <graphics.h>
#endif /* __MSDOS__ */
#include <stdio.h>
#include <string.h>
#include <setjmp.h>
#include <math.h>
#include "program.h"
#include "interact.h"
#include "iritprsr.h"
#include "graphgen.h"
#ifdef SUPPORT_GIF_SAVE
#include "gif_lib.h"
#endif /* SUPPORT_GIF_SAVE */
#define MAX_ROTATE_ANGLE 45.0 /* Max. rates used by interactive mode. */
#define MAX_TRANSLATE_FACTOR 2.0
#define MAX_SCALE_FACTOR 2.0
#define MAX_PERSP_FACTOR 2.0
#define PERSPECTIVE_DEFAULT -5
/* We support depth cues iff DepthCueFlag is TRUE: */
#define IS_DOTTED_LINE (GlblDepthCue ? DOTTED_LINE : SOLID_LINE)
static RealType LastCoord[3]; /* Used to store last point we moved/draw to. */
void (* MoveToPtr)(RealType Coord[3]);
void (* DrawToPtr)(RealType Coord[3]);
/* Save the current displayed object information in local variables. */
static IPObjectStruct *LocalObjects;
static jmp_buf LongJumpBuffer; /* Used in breaking. */
static void ViewGeomObjectList(IPObjectStruct *Objects);
static void SaveCurrentMat(void);
static void DrawOneObject(IPObjectStruct *PObject);
static void DrawOnePolygon(IPPolygonStruct *PPolygon);
static void TestQuitView(void);
#ifdef __GL__
static void DrawPolygonSolid(IPPolygonStruct *PPolygon);
#endif /* __GL__ */
/*****************************************************************************
* 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. *
*****************************************************************************/
void InteractGeomObject(IPObjectStruct *Objects)
{
#ifdef SUPPORT_GIF_SAVE
static char GifFileCount = '0';
char GifFileName[PATH_NAME_LEN];
#endif /* SUPPORT_GIF_SAVE */
char *p;
int UpdateView;
RealType ChangeFactor;
MatrixType Mat, OrigViewMat, OrigPrspMat;
#ifndef __MSDOS__
long WinID, DispID, ColorMapID;
#endif /* __MSDOS__ */
/* Save copy of original matrix, so we can recover if reset is required. */
GEN_COPY(OrigViewMat, IritPrsrViewMat, sizeof(MatrixType));
GEN_COPY(OrigPrspMat, IritPrsrPrspMat, sizeof(MatrixType));
/* Update the drawing routine pointers: */
MoveToPtr = ScrnMoveTo;
DrawToPtr = ScrnDrawTo;
switch (GlblViewMode) { /* Update the current view. */
case VIEW_ORTHOGRAPHIC:
GEN_COPY(CrntViewMat, IritPrsrViewMat, sizeof(MatrixType));
break;
case VIEW_PERSPECTIVE:
MultTwo4by4(CrntViewMat, IritPrsrViewMat, IritPrsrPrspMat);
break;
}
LocalObjects = Objects;
GGMySetLineStyle(SOLID_LINE);
GGClearViewArea(); /* Clear the view window. */
ViewGeomObjectList(Objects); /* Display it for first time. */
#if defined(__MSDOS__) || defined(DJGCC)
/* Set the async. function for intr_lib to refresh the view window. */
IntrWndwSetRefreshFunc(ViewWindowID,
(IntrIntFunc) UpdateInteractHandleInput);
#endif /* __MSDOS__ || DJGCC */
while (TRUE) {
UpdateView = TRUE;
GenUnitMat(Mat); /* No transformation by default! */
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. */
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;
IritPrsrPrspMat[2][2] *= ChangeFactor;
IritPrsrPrspMat[2][3] *= ChangeFactor;
IritPrsrPrspMat[3][2] *= ChangeFactor;
break;
case EVENT_ROTATE_X: /* Its rotation along the X axis. */
GenMatRotX1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_ROTATE_Y: /* Its rotation along the Y axis. */
GenMatRotY1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_ROTATE_Z: /* Its rotation along the Z axis. */
GenMatRotZ1(DEG2RAD(ChangeFactor * MAX_ROTATE_ANGLE), Mat);
break;
case EVENT_TRANSLATE_X: /* Its translation along the X axis. */
GenMatTrans(ChangeFactor * MAX_TRANSLATE_FACTOR, 0.0, 0.0,
Mat);
break;
case EVENT_TRANSLATE_Y: /* Its translation along the Y axis. */
GenMatTrans(0.0, ChangeFactor * MAX_TRANSLATE_FACTOR, 0.0,
Mat);
break;
case EVENT_TRANSLATE_Z: /* Its translation along the Z axis. */
GenMatTrans(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);
GenMatScale(ChangeFactor, ChangeFactor, ChangeFactor, Mat);
break;
case EVENT_DEPTH_CUE:
if (!GlblDepthCue) GGMySetLineStyle(SOLID_LINE);
break;
#ifdef __GL__
case EVENT_DRAW_SOLID:
break;
#endif
#if defined(__GL__) || defined(__X11__) || defined(__MSDOS__) || defined(DJGCC)
case EVENT_SAVE_GIF:
#ifdef SUPPORT_GIF_SAVE
strcpy(GifFileName, GENERIC_GIF_FILE);
if ((p = strchr(GifFileName, '#')) != NULL) {
*p = GifFileCount;
if (GifFileCount++ == '9') GifFileCount = '0';
}
#ifdef __GL__
if (DumpScreen2Gif(GifFileName, (int) GIF_DUMP_SGI_WINDOW,
GetViewWindowID(), 0, 0) != 0) {
#endif
#ifdef __X11__
WinID = GetViewWindowID(&DispID, &ColorMapID);
if (DumpScreen2Gif(GifFileName, (int) GIF_DUMP_X_WINDOW,
WinID, DispID, ColorMapID) != 0) {
#endif
#ifdef __MSDOS__
if (DumpScreen2Gif(GifFileName, GRGraphDriver, GRGraphMode, 0, 0)
!= 0) {
#endif
#ifdef DJGCC
if (DumpScreen2Gif(GifFileName, 0, 0, GRScreenMaxX, GRScreenMaxY)
!= 0) {
#endif
/* Something went wrong - let the user know about it. */
GGTone(400, 300);
GGTone(100, 300);
}
else
GGTone(1000, 100);
UpdateView = FALSE;
#else
GGTone(400, 300);
GGTone(100, 300);
#endif /* SUPPORT_GIF_SAVE */
break;
#endif /* __GL__ || __X11__ || __MSDOS__ || DJGCC */
case EVENT_SAVE_PS:
SavePostScript(Objects);
UpdateView = FALSE;
break;
case EVENT_SAVE_MATRIX:
SaveCurrentMat();
UpdateView = FALSE;
break;
case EVENT_RESET_MATRIX:
GEN_COPY(IritPrsrViewMat, OrigViewMat, sizeof(MatrixType));
GEN_COPY(IritPrsrPrspMat, OrigPrspMat, sizeof(MatrixType));
break;
case EVENT_QUIT:
LocalObjects = NULL;
return; /* Its Quit. */
default:
GGTone(1000, 100); /* Do some noise! */
UpdateView = FALSE;
}
if (UpdateView) {
GGClearViewArea(); /* Clear the view window. */
switch (GlblTransformMode) {/* Udpate the global viewing matrix. */
case TRANS_SCREEN:
MultTwo4by4(IritPrsrViewMat, IritPrsrViewMat, Mat);
break;
case TRANS_OBJECT:
MultTwo4by4(IritPrsrViewMat, Mat, IritPrsrViewMat);
break;
}
switch (GlblViewMode) { /* Update the current view. */
case VIEW_ORTHOGRAPHIC:
GEN_COPY(CrntViewMat, IritPrsrViewMat, sizeof(MatrixType));
break;
case VIEW_PERSPECTIVE:
MultTwo4by4(CrntViewMat, IritPrsrViewMat, IritPrsrPrspMat);
break;
}
ViewGeomObjectList(Objects); /* And display it... */
}
}
}
/*****************************************************************************
* 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). *
*****************************************************************************/
void UpdateInteractHandleInput(void)
{
#if !defined(__MSDOS__) && !defined(DJGCC)
GGClearViewArea();
#endif /* !__MSDOS__ && !DJGCC */
if (LocalObjects)
ViewGeomObjectList(LocalObjects);
}
/*****************************************************************************
* A wrap to trap escapes in the drawing stage using long jump. *
*****************************************************************************/
static void ViewGeomObjectList(IPObjectStruct *Objects)
{
if (setjmp(LongJumpBuffer) == 0) { /* Its the setjmp itself call! */
DrawAllObjects(Objects);
#if !defined(__MSDOS__) && !defined(DJGCC)
GGGraphicFlush();
#endif /* !__MSDOS__ && !DJGCC */
}
}
/*****************************************************************************
* Routine to save current view trans. IritPrsrViewMat to a generic mat file *
*****************************************************************************/
static void SaveCurrentMat(void)
{
int i, j;
FILE *f;
char *p, FileName[PATH_NAME_LEN];
static char FileCount = '0';
strcpy(FileName, GENERIC_MAT_FILE);
if ((p = strchr(FileName, '#')) != NULL) {
*p = FileCount;
if (FileCount++ == '9') FileCount = '0';
}
if ((f = fopen(FileName, "wt")) == NULL) {
GGTone(700, 200);
return;
}
fprintf(f, "[OBJECT MATRICES\n [OBJECT VIEW_MAT\n\t[MATRIX");
for (i = 0; i < 4; i++) {
fprintf(f, "\n\t ");
for (j = 0; j < 4; j++) fprintf(f, "%12.9lf ", IritPrsrViewMat[i][j]);
}
fprintf(f, "\n\t]\n ]\n");
if (GlblViewMode == VIEW_PERSPECTIVE) {
fprintf(f, " [OBJECT PRSP_MAT\n\t[MATRIX");
for (i = 0; i < 4; i++) {
fprintf(f, "\n\t ");
for (j = 0; j < 4; j++) fprintf(f, "%12.9lf ", IritPrsrPrspMat[i][j]);
}
fprintf(f, "\n\t]\n ]\n");
}
fprintf(f, "]\n");
fclose(f);
}
/*****************************************************************************
* Routine to draw all the objects in object list Objects. *
*****************************************************************************/
void DrawAllObjects(IPObjectStruct *Objects)
{
while (Objects) {
DrawOneObject(Objects);
Objects = Objects -> Pnext;
}
}
/*****************************************************************************
* Routine to draw one object Object. *
*****************************************************************************/
static void DrawOneObject(IPObjectStruct *PObject)
{
IPPolygonStruct *PList;
switch (PObject -> Type) {
case IP_OBJ_POLY:
PList = PObject -> U.PPolygon;
GGMySetColor(PObject -> Color);
while (PList) {
DrawOnePolygon(PList);
PList = PList -> Pnext;
}
break;
case IP_OBJ_SURFACE:
#ifdef __GL__
if (GlblDrawSolid) {
CagdSrfStruct *Srf;
IPObjectStruct *PPolyObj;
IPPolygonStruct *PPolygonTemp, *PPolygon;
if (PObject -> FFPolygons == NULL) {
PObject -> FFPolygons = PPolyObj = IritPrsrNewObjectStruct();
*PPolyObj = *PObject; /* Copy all its attributes. */
PPolyObj -> U.PPolygon = NULL;
PPolyObj -> Type = IP_OBJ_POLY;
for (Srf = PObject -> U.PSrfs;
Srf != NULL;
Srf = Srf -> Pnext) {
PPolygon = PPolygonTemp = Surface2Polygons(Srf);
while (PPolygonTemp -> Pnext)
PPolygonTemp = PPolygonTemp -> Pnext;
PPolygonTemp -> Pnext = PPolyObj -> U.PPolygon;
PPolyObj -> U.PPolygon = PPolygon;
}
}
DrawOneObject(PObject -> FFPolygons);
}
else
#endif /* __GL__ */
DrawOneObject(PObject -> FFPolylines);
break;
case IP_OBJ_CURVE:
DrawOneObject(PObject -> FFPolylines);
break;
}
}
/*****************************************************************************
* Routine to draw one polygon, using global Matrix transform Mat. *
* Note this is the routine that makes the real drawing... *
*****************************************************************************/
static void DrawOnePolygon(IPPolygonStruct *PPolygon)
{
int i, j, DrawNextEdge, NumOfVertices;
RealType MappedNormal[3], PolyNormal[3];
IPVertexStruct
*VList = PPolygon -> PVertex,
*VHead = VList;
if (VList == NULL) return;
TestQuitView();
switch (PPolygon -> Type) {
case IP_POINTLIST:
MoveToPtr(VList -> Coord);
DrawToPtr(VList -> Coord);
VList = VList -> Pnext;
for (i = 0;
i < GlblNumEdges && VList != NULL && VList != VHead;
i++) {
MoveToPtr(VList -> Coord);
DrawToPtr(VList -> Coord);
VList = VList -> Pnext;
}
break;
case IP_POLYLINE:
MoveToPtr(VList -> Coord);
DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
VList = VList -> Pnext;
for (i = 1;
i < GlblNumEdges && VList != NULL && VList != VHead;
i++) {
if (DrawNextEdge || GlblInternal)
DrawToPtr(VList -> Coord);
else
MoveToPtr(VList -> Coord);
DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
VList = VList -> Pnext;
}
break;
case IP_POLYGON:
#ifdef __GL__
if (GlblDrawSolid) {
DrawPolygonSolid(PPolygon);
break;
}
#endif /* __GL__ */
if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
/* Sum all points to be averaged for normal position. */
for (i = 0; i < 3; i++) PolyNormal[i] = VList -> Coord[i];
NumOfVertices = 1;
}
MoveToPtr(VList -> Coord);
DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
VList = VList -> Pnext;
for (i = 1;
i < GlblNumEdges && VList != NULL;
i++) {
if (DrawNextEdge || GlblInternal)
DrawToPtr(VList -> Coord);
else
MoveToPtr(VList -> Coord);
if (GlblDrawVNormal && IP_HAS_VRTX_NORMAL(VList)) {
for (j = 0; j < 3; j++) MappedNormal[j] =
VList -> Coord[j] + VList -> Normal[j] * GlblNormalLen;
j = GlblClosedObject;
GlblClosedObject = FALSE;
DrawToPtr(MappedNormal);
MoveToPtr(VList -> Coord);
GlblClosedObject = j;
}
if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
for (j = 0; j < 3; j++) PolyNormal[j] += VList -> Coord[j];
NumOfVertices++;
}
DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
VList = VList -> Pnext;
}
if (GlblNumEdges > i) {
/* Close polygon by drawing a line to first vertex. */
if (DrawNextEdge || GlblInternal)
DrawToPtr(VHead -> Coord);
else
MoveToPtr(VHead -> Coord);
if (GlblDrawVNormal && IP_HAS_VRTX_NORMAL(VList)) {
for (j = 0; j < 3; j++) MappedNormal[j] =
VList -> Coord[j] + VList -> Normal[j] * GlblNormalLen;
j = GlblClosedObject;
GlblClosedObject = FALSE;
DrawToPtr(MappedNormal);
MoveToPtr(VList -> Coord);
GlblClosedObject = j;
}
}
if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
for (i = 0; i < 3; i++) PolyNormal[i] /= NumOfVertices;
MoveToPtr(PolyNormal);
for (i = 0; i < 3; i++)
PolyNormal[i] += PPolygon -> Plane[i] * GlblNormalLen;
i = GlblClosedObject;
GlblClosedObject = FALSE;
DrawToPtr(PolyNormal);
GlblClosedObject = i;
}
break;
}
}
/*****************************************************************************
* Routine to test if quit display event - occured - SPACE was hit on *
* keyboard or right button was clicked on mouse. *
*****************************************************************************/
static void TestQuitView(void)
{
if (GGIsAbortKeyPressed()) longjmp(LongJumpBuffer, 1); /* Jump to... */
}
/*****************************************************************************
* Routine to mave to 3D point given as Coord[3], using Mat transform. *
*****************************************************************************/
void ScrnMoveTo(RealType Coords[3])
{
MultVecby4by4(LastCoord, Coords, CrntViewMat); /* Set last point coord. */
}
/*****************************************************************************
* Routine to draw to 3D point given as Coord[3], using Mat transform, from *
* the last point we moved to. *
*****************************************************************************/
void ScrnDrawTo(RealType Coords[3])
{
RealType NewCoord[3], MiddleCoord[3], t;
MultVecby4by4(NewCoord, Coords, CrntViewMat); /* Set last point coord. */
if (GlblClosedObject && 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. *
* This routine should be supplied only if GL is linked in. *
****************************************************************************/
static void DrawPolygonSolid(IPPolygonStruct *PPolygon)
{
int i,
l = 0,
UseVertexNormal = FALSE;
float *PolygonNormal, FloatNormal[3], Length;
RealType Normal[3], MappedVertex[3], V1[3], V2[3], V3[3];
IPVertexStruct
*VList = PPolygon -> PVertex;
if (IP_HAS_VRTX_NORMAL(VList))
UseVertexNormal = TRUE;
else if (!IP_HAS_POLY_PLANE(PPolygon)) {
/* Compute normal to polygon by cross prod. of 3 consecutive points. */
MultVecby4by4(V1, VList -> Coord, IritPrsrViewMat);
MultVecby4by4(V2, VList -> Pnext-> Coord, IritPrsrViewMat);
MultVecby4by4(V3, VList -> Pnext -> Pnext -> Coord, IritPrsrViewMat);
for (i = 0; i < 3; i++) V1[i] -= V2[i];
for (i = 0; i < 3; i++) V2[i] -= V3[i];
Normal[0] = V1[1] * V2[2] - V1[2] * V2[1];
Normal[1] = V1[2] * V2[0] - V1[0] * V2[2];
Normal[2] = V1[0] * V2[1] - V1[1] * V2[0];
Length = sqrt(SQR(Normal[0]) + SQR(Normal[1]) + SQR(Normal[2]));
for (i = 0; i < 3; i++) Normal[i] /= -Length;
}
else {
for (i = 0; i < 3; i++)
Normal[i] = VList -> Coord[i] + PPolygon -> Plane[i];
MultVecby4by4(V1, VList -> Coord, IritPrsrViewMat);
MultVecby4by4(V2, Normal, IritPrsrViewMat);
for (i = 0; i < 3; i++) Normal[i] = V2[i] - V1[i];
Length = sqrt(SQR(Normal[0]) + SQR(Normal[1]) + SQR(Normal[2]));
for (i = 0; i < 3; i++) Normal[i] /= -Length;
}
GGMyDrawPolygonSolid(NULL, NULL, TRUE);
for (; VList != NULL; VList = VList -> Pnext) {
MultVecby4by4(MappedVertex, VList -> Coord, CrntViewMat);
/* Each vertex has different normal - specify them. */
if (UseVertexNormal) {
MultVecby4by4(V1, VList -> Coord, IritPrsrViewMat);
for (i = 0; i < 3; i++)
Normal[i] = VList -> Coord[i] + VList -> Normal[i];
MultVecby4by4(V2, Normal, IritPrsrViewMat);
for (i = 0; i < 3; i++) Normal[i] = V2[i] - V1[i];
Length = sqrt(SQR(Normal[0]) + SQR(Normal[1]) + SQR(Normal[2]));
for (i = 0; i < 3; i++) Normal[i] /= -Length;
}
for (i = 0; i < 3; i++) FloatNormal[i] = Normal[i];
GGMyDrawPolygonSolid(MappedVertex, FloatNormal, TRUE);
if (l >= 255) break; /* GL limit. */
}
GGMyDrawPolygonSolid(NULL, NULL, FALSE);
}
#endif /* __GL__ */