void
projectAllPoints(void)
{
int i,j,k;
LLPoint *anLLPoint;
LPoint *anLPoint;
int *anIndex;
anLLPoint = viewData.lllp.llp;
for (i=0; i<viewData.lllp.numOfComponents; i++,anLLPoint++) {
anLPoint = anLLPoint->lp;
for (j=0; j<anLLPoint->numOfLists; j++,anLPoint++) {
anIndex = anLPoint->indices;
for (k=0; k<anLPoint->numOfPoints; k++,anIndex++) {
projectAPoint(refPt3D(viewData,*anIndex));
} /* for points in LPoints (k) */
} /* for LPoints in LLPoints (j) */
} /* for LLPoints in LLLPoints (i) */
} /* projectAllPoints() */
int
spadAction (void)
{
int code, viewCommand;
float f1, f2, f3;
int i1, i2, i3;
if (viewAloned==yes) {
close(0);
return(-1);
}
readViewman(&viewCommand, intSize);
switch (viewCommand) {
case rotate:
readViewman(&f1, floatSize);
readViewman(&f2, floatSize);
viewport->theta = f1;
viewport->phi = f2;
while (viewport->theta >= two_pi) viewport->theta -= two_pi;
while (viewport->theta < 0.0) viewport->theta += two_pi;
while (viewport->phi > pi) viewport->phi -= two_pi;
while (viewport->phi <= -pi) viewport->phi += two_pi;
viewport->axestheta = viewport->theta;
viewport->axesphi = viewport->phi;
spadDraw=yes;
rotated=yes;
viewport->yzOn = viewport->xzOn = viewport->xyOn = no;
break;
case zoom:
readViewman(&f1, floatSize);
viewport->scale = f1;
if (viewport->scale > maxScale) viewport->scale = maxScale;
else if (viewport->scale < minScale) viewport->scale = minScale;
spadDraw=yes;
zoomed = yes;
break;
case zoomx:
readViewman(&f1, floatSize);
readViewman(&f2, floatSize);
readViewman(&f3, floatSize);
viewport->scaleX = f1; viewport->scaleY = f2; viewport->scaleZ = f3;
if ((viewport->scaleX == 1.0) &&
(viewport->scaleY == 1.0) &&
(viewport->scaleZ == 1.0)) {
viewport->zoomXOn = viewport->zoomYOn = viewport->zoomZOn = yes;
} else {
if (viewport->scaleX == 1.0) viewport->zoomXOn = no;
else {
if (viewport->scaleX > maxScale) viewport->scaleX = maxScale;
else if (viewport->scaleX < minScale) viewport->scaleX = minScale;
}
if (viewport->scaleY == 1.0) viewport->zoomYOn = no;
else {
if (viewport->scaleY > maxScale) viewport->scaleY = maxScale;
else if (viewport->scaleY < minScale) viewport->scaleY = minScale;
}
if (viewport->scaleZ == 1.0) viewport->zoomZOn = no;
else {
if (viewport->scaleZ > maxScale) viewport->scaleZ = maxScale;
else if (viewport->scaleZ < minScale) viewport->scaleZ = minScale;
}
}
spadDraw=yes;
zoomed = yes;
break;
case translate:
readViewman(&(viewport->deltaX),floatSize);
readViewman(&(viewport->deltaY),floatSize);
if (viewport->deltaX > maxDeltaX) viewport->deltaX = maxDeltaX;
else if (viewport->deltaX < -maxDeltaX) viewport->deltaX = -maxDeltaX;
if (viewport->deltaY > maxDeltaY) viewport->deltaY = maxDeltaY;
else if (viewport->deltaY < -maxDeltaY) viewport->deltaY = -maxDeltaY;
spadDraw=yes;
translated = yes;
break;
case modifyPOINT:
readViewman(&i1,intSize);
i1--;
readViewman(&(refPt3D(viewData,i1)->x),floatSize);
readViewman(&(refPt3D(viewData,i1)->y),floatSize);
readViewman(&(refPt3D(viewData,i1)->z),floatSize);
readViewman(&(refPt3D(viewData,i1)->c),floatSize);
scalePoint(refPt3D(viewData,i1));
spadDraw=yes;
break;
case hideControl:
readViewman(&i1,intSize);
if (i1) { /* show control panel */
if (viewport->haveControl)
XUnmapWindow(dsply,control->controlWindow);
putControlPanelSomewhere(someInt);
} else { /* turn off control panel */
if (viewport->haveControl) {
viewport->haveControl = no;
XUnmapWindow(dsply,control->controlWindow);
}
}
break;
case axesOnOff:
readViewman(&i1,intSize);
viewport->axesOn = i1;
spadDraw=yes;
if (viewData.style == smooth) {
if (multiColorFlag) redoDither = yes;
else redoColor = yes;
}
if (viewport->haveControl) drawControlPanel();
break;
/* Non-uniform scaling is not in AXIOM yet. */
/* Neither is object or origin rotation. */
case perspectiveOnOff:
readViewman(&i1,intSize);
viewData.perspective = i1;
switchedPerspective = yes;
spadDraw=yes;
break;
case region3D:
readViewman(&i1,intSize);
viewport->regionOn = i1;
viewData.box = i1;
spadDraw=yes;
if (viewport->haveControl) drawControlPanel();
redoSmooth = yes;
break;
case clipRegionOnOff:
readViewman(&i1,intSize);
viewData.clipbox = i1;
spadDraw=yes;
break;
case clipSurfaceOnOff:
readViewman(&i1,intSize);
viewData.clipStuff = i1;
spadDraw=yes;
break;
case eyeDistanceData:
readViewman(&f1,floatSize);
viewData.eyeDistance = f1;
if (viewData.eyeDistance > maxEyeDistance)
viewData.eyeDistance = maxEyeDistance;
else if (viewData.eyeDistance < minEyeDistance)
viewData.eyeDistance = minEyeDistance;
spadDraw=yes;
changedEyeDistance = yes;
break;
case hitherPlaneData:
readViewman(&f1,floatSize);
viewData.clipPlane = f1;
spadDraw=yes;
changedEyeDistance = yes;
break;
case queryVIEWPOINT:
f1 = viewport->deltaX;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->deltaY;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->scale;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->scaleX;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->scaleY;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->scaleZ;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->theta;
code = check(write(Socket, &f1, floatSize));
f1 = viewport->phi;
code = check(write(Socket, &f1, floatSize));
break;
case changeVIEWPOINT:
readViewman(&f1, floatSize);
readViewman(&f2, floatSize);
viewport->deltaX = f1;
viewport->deltaY = f2;
if (viewport->deltaX > maxDeltaX) viewport->deltaX = maxDeltaX;
else if (viewport->deltaX < -maxDeltaX) viewport->deltaX = -maxDeltaX;
if (viewport->deltaY > maxDeltaY) viewport->deltaY = maxDeltaY;
else if (viewport->deltaY < -maxDeltaY) viewport->deltaY = -maxDeltaY;
translated = yes;
readViewman(&f1, floatSize);
viewport->scale = f1;
if (viewport->scale > maxScale) viewport->scale = maxScale;
else if (viewport->scale < minScale) viewport->scale = minScale;
zoomed = yes;
readViewman(&f1, floatSize);
readViewman(&f2, floatSize);
readViewman(&f3, floatSize);
viewport->scaleX = f1;
viewport->scaleY = f2;
viewport->scaleZ = f3;
if ((viewport->scaleX == 1.0) &&
(viewport->scaleY == 1.0) &&
(viewport->scaleZ == 1.0)) {
viewport->zoomXOn = viewport->zoomYOn = viewport->zoomZOn = yes;
} else {
if (viewport->scaleX == 1.0) viewport->zoomXOn = no;
else {
if (viewport->scaleX > maxScale) viewport->scaleX = maxScale;
else if (viewport->scaleX < minScale) viewport->scaleX = minScale;
}
if (viewport->scaleY == 1.0) viewport->zoomYOn = no;
else {
if (viewport->scaleY > maxScale) viewport->scaleY = maxScale;
else if (viewport->scaleY < minScale) viewport->scaleY = minScale;
}
if (viewport->scaleZ == 1.0) viewport->zoomZOn = no;
else {
if (viewport->scaleZ > maxScale) viewport->scaleZ = maxScale;
else if (viewport->scaleZ < minScale) viewport->scaleZ = minScale;
}
}
readViewman(&f1, floatSize);
readViewman(&f2, floatSize);
viewData.theta = f1;
viewData.phi = f2;
while (viewport->theta >= two_pi) viewport->theta -= two_pi;
while (viewport->theta < 0.0) viewport->theta += two_pi;
while (viewport->phi > pi) viewport->phi -= two_pi;
while (viewport->phi <= -pi) viewport->phi += two_pi;
viewport->axestheta = viewport->theta;
viewport->axesphi = viewport->phi;
spadDraw=yes;
rotated=yes;
break;
case colorDef:
readViewman(&(viewport->hueOffset),intSize);
readViewman(&(viewport->numberOfHues),intSize);
/* spadcolors is indexed by 0 */
viewport->hueOffset --;
viewport->numberOfHues --;
viewport->hueTop = viewport->numberOfHues;
if (viewport->hueOffset < 0) viewport->hueOffset = 0;
if (viewport->hueTop < 0) viewport->hueTop = 0;
if (viewport->hueOffset >= totalHues)
viewport->hueOffset = totalHues-1;
if (viewport->hueTop >= totalHues) viewport->hueTop = totalHues-1;
viewport->numberOfHues = viewport->hueTop - viewport->hueOffset;
if ((viewport->hueTop == viewport->hueOffset) && (!viewport->monoOn))
redoColor = yes;
else {
redoColor = no;
redoDither = yes;
}
if (viewport->haveControl) drawColorMap();
break;
case closeAll:
code = check(write(Socket,&ack,intSize));
goodbye(-1);
case moveViewport:
readViewman(&i1,intSize);
readViewman(&i2,intSize);
XMoveWindow(dsply,viewport->titleWindow,i1,i2);
XSync(dsply,0);
break;
case resizeViewport:
readViewman(&i1,intSize);
readViewman(&i2,intSize);
XResizeWindow(dsply,viewport->titleWindow,i1,i2+titleHeight);
XResizeWindow(dsply,viewport->viewWindow,i1,i2);
spadDraw=yes;
redoSmooth =yes;
break;
case transparent:
case opaqueMesh:
case render:
case smooth:
viewData.style = viewCommand;
spadDraw=yes;
redoSmooth =yes;
break;
case lightDef:
readViewman(&(viewport->lightVector[0]),floatSize);
readViewman(&(viewport->lightVector[1]),floatSize);
readViewman(&(viewport->lightVector[2]),floatSize);
normalizeVector(viewport->lightVector);
movingLight = yes;
drawLightingAxes();
XSync(dsply,0);
break;
case translucenceDef:
readViewman(&backLightIntensity,floatSize);
tempLightIntensity = backLightIntensity;
lightIntensity = tempLightIntensity;
changedIntensity = yes;
drawLightTransArrow();
XSync(dsply,0);
break;
case changeTitle:
readViewman(&i1,intSize);
readViewman(viewport->title,i1);
viewport->title[i1] = '\0';
writeTitle();
switch (doingPanel) {
case CONTROLpanel:
case CONTOURpanel:
writeControlTitle(control->controlWindow);
break;
case VOLUMEpanel:
writeControlTitle(volumeWindow);
break;
case LIGHTpanel:
writeControlTitle(lightingWindow);
break;
} /* switch */
XFlush(dsply);
break;
case writeView:
readViewman(&i1,intSize);
readViewman(filename,i1);
filename[i1] = '\0';
sprintf(errorStr,"writing of viewport data");
i3 = 0;
readViewman(&i2,intSize);
while (i2) {
i3 = i3 | (1<<i2);
readViewman(&i2,intSize);
}
if (writeViewport(i3) < 0)
fprintf(stderr," Nothing was written\n");
break;
case diagOnOff:
readViewman(&i1,intSize);
if (viewData.outlineRenderOn) {
viewport->diagonals = i1;
spadDraw=yes;
} else {
strcpy(control->message," Use this option with Outline ");
writeControlMessage();
}
break;
case outlineOnOff:
readViewman(&i1,intSize);
if (viewData.style == render) {
viewData.outlineRenderOn = i1;
spadDraw=yes;
if (viewport->haveControl) drawControlPanel();
} else {
strcpy(control->message," Use this option in Shaded mode ");
writeControlMessage();
}
break;
case spadPressedAButton:
readViewman(&i1,intSize);
buttonAction(i1);
break;
default:
return(-1);
} /* switch */
ack++;
code = check(write(Socket,&ack,intSize));
return(0);
}
void
projectAPoly (poly *p)
{
int i,clipped,clippedPz;
float Vtmp[4],V[4],V1[4];
float x0=0.0;
float y0=0.0;
float xA=0.0;
float yA=0.0;
float xB=0.0;
float yB=0.0;
int *anIndex;
viewTriple *aPt;
/* totalClip==yes => partialClip==yes */
p->totalClipPz = yes; /* start with 1, AND all points with Pz<0 */
p->partialClipPz = no; /* start with 0, OR any points with Pz<0 */
p->totalClip = yes; /* same idea, only with respect to clip volume */
p->partialClip = no;
for (i=0,anIndex=p->indexPtr; i<p->numpts; i++,anIndex++) {
aPt = refPt3D(viewData,*anIndex);
V[0] = aPt->x; V[1] = aPt->y; V[2] = aPt->z; V[3] = 1.0;
V[0] -= viewport->transX; V[1] -= viewport->transY;
V[2] -= viewport->transZ;
vectorMatrix4(V,R1,Vtmp);
matrixMultiply4x4(S,R,transform);
vectorMatrix4(Vtmp,transform,V1);
aPt->wx = V1[0]; aPt->wy = V1[1]; aPt->wz = V1[2];
V1[0] *= reScale; V1[1] *= reScale; V1[2] *= reScale;
aPt->pz = V1[2];
if (viewData.perspective) {
V1[0] *= projPersp(V1[2]);
V1[1] *= projPersp(V1[2]);
}
matrixMultiply4x4(I,T,transform);
vectorMatrix4(V1,transform,V);
V[0] = V[0]*viewScale + xCenter;
V[1] = vwInfo.height - (V[1]*viewScale + yCenter);
aPt->px = V[0]; aPt->py = V[1];
clipped = outsideClippedBoundary(aPt->x, aPt->y, aPt->z);
p->totalClip = p->totalClip && clipped;
p->partialClip = p->partialClip || clipped;
clippedPz = behindClipPlane(aPt->pz);
p->totalClipPz = p->totalClipPz && clippedPz;
p->partialClipPz = p->partialClipPz || clippedPz;
/* stuff for figuring out normalFacingOut, after the loop */
if (!i) {
x0 = aPt->px; y0 = aPt->py;
} else if (i==1) {
xA = x0 - aPt->px; yA = y0 - aPt->py;
x0 = aPt->px; y0 = aPt->py;
} else if (i==2) {
xB = aPt->px - x0; yB = aPt->py - y0;
}
}
if ((x0 = xA*yB - yA*xB) > machine0) p->normalFacingOut = 1;
else if (x0 < machine0) p->normalFacingOut = -1;
else p->normalFacingOut = 0;
} /* projectAPoly */
void
projectAllPolys (poly *pList)
{
int i,clipped,clippedPz;
float x0=0.0;
float y0=0.0;
float xA=0.0;
float yA=0.0;
float xB=0.0;
float yB=0.0;
int *anIndex;
viewTriple *aPt;
strcpy(control->message," Projecting Polygons ");
writeControlMessage();
projectAllPoints();
for (;pList != NIL(poly);pList=pList->next) {
/* totalClip==yes => partialClip==yes (of course) */
pList->totalClipPz = yes; /* start with 1, AND all points with Pz<0 */
pList->partialClipPz = no; /* start with 0, OR any points with Pz<0 */
pList->totalClip = yes; /* same idea, only wrt clip volume */
pList->partialClip = no;
for (i=0,anIndex=pList->indexPtr; i<pList->numpts; i++,anIndex++) {
aPt = refPt3D(viewData,*anIndex);
clipped = outsideClippedBoundary(aPt->x, aPt->y, aPt->z);
pList->totalClip = pList->totalClip && clipped;
pList->partialClip = pList->partialClip || clipped;
clippedPz = behindClipPlane(aPt->pz);
pList->totalClipPz = pList->totalClipPz && clippedPz;
pList->partialClipPz = pList->partialClipPz || clippedPz;
/* stuff for figuring out normalFacingOut, after the loop */
if (!i) {
x0 = aPt->px; y0 = aPt->py;
} else if (i==1) {
xA = x0 - aPt->px; yA = y0 - aPt->py;
x0 = aPt->px; y0 = aPt->py;
} else if (i==2) {
xB = aPt->px - x0; yB = aPt->py - y0;
}
} /* for i */
/* store face facing info */
/* For now, we shall give faces facing the user a factor of -1,
and faces facing away from the user a factor of +1. this is
to mimic the eye vector (pointing away from the user) dotted
into the surface normal.
This routine is being done because the surface normal in object
space does not transform over to image space linearly and so
has to be recalculated. but the triple product is zero in the
X and Y directions so we just take the Z component, of which,
we just examine the sign. */
if ((x0 = xA*yB - yA*xB) > machine0) pList->normalFacingOut = 1;
else if (x0 < machine0) pList->normalFacingOut = -1;
else pList->normalFacingOut = 0;
}
strcpy(control->message,viewport->title);
writeControlMessage();
} /* projectAllPolys */
int
writeViewport (int thingsToWrite)
{
int i, j, k, ii, code, *anIndex;
LLPoint *anLLPoint;
LPoint *anLPoint;
viewTriple *aPt;
XWindowAttributes vwInfo;
FILE *viewDataFile;
char viewDirName[80], viewDataFilename[80],
viewBitmapFilename[80], viewPixmapFilename[80],
command[80];
XGetWindowAttributes(dsply,viewport->titleWindow,&vwInfo);
sprintf(viewDirName,"%s%s",filename,".VIEW");
sprintf(command,"%s%s%s","rm -r ",viewDirName," > /dev/null 2>&1");
code = system(command);
sprintf(command,"%s%s%s","mkdir ",viewDirName," > /dev/null 2>&1");
system(command);
if (0) {
fprintf(stderr," Error: Cannot create %s\n",viewDirName);
return(-1);
} else {
/*** Create the data file ***/
sprintf(viewDataFilename,"%s%s",viewDirName,"/data");
if ((viewDataFile = fopen(viewDataFilename,"w")) == NULL) {
fprintf(stderr," Error: Cannot create %s\n",viewDataFilename);
perror("fopen");
return(-1);
} else {
/*** write out the view3DStruct stuff ***/
fprintf(viewDataFile,"%d\n",viewData.typeOf3D);
fprintf(viewDataFile,"%g %g %g %g %g %g\n",
viewData.xmin,viewData.xmax,viewData.ymin,viewData.ymax,
viewData.zmin,viewData.zmax);
fprintf(viewDataFile,"%s\n",viewport->title);
fprintf(viewDataFile,"%g %g %g %g %g %g %g %g\n",viewport->deltaX,
viewport->deltaY,viewport->scale,
viewport->scaleX,viewport->scaleY,viewport->scaleZ,
viewport->theta,viewport->phi);
fprintf(viewDataFile,"%d %d %d %d\n",vwInfo.x,vwInfo.y,vwInfo.width,
vwInfo.height);
fprintf(viewDataFile,"%d %d %d %d %d %d %d\n",viewport->haveControl,
viewData.style, viewport->axesOn,
viewport->hueOffset,viewport->numberOfHues,
viewport->diagonals, viewData.outlineRenderOn);
fprintf(viewDataFile,"%g %g %g %g\n",viewport->lightVector[0],
viewport->lightVector[1], viewport->lightVector[2],
viewport->translucency);
fprintf(viewDataFile,"%d %g\n",viewData.perspective,
viewData.eyeDistance);
/* write out the generalized 3D components */
fprintf(viewDataFile,"%d\n",viewData.numOfPoints);
for (i=0; i<viewData.numOfPoints; i++) {
aPt = refPt3D(viewData,i);
fprintf(viewDataFile,"%g %g %g %g\n",aPt->x, aPt->y, aPt->z, aPt->c);
}
fprintf(viewDataFile,"%d\n",viewData.lllp.numOfComponents);
anLLPoint = viewData.lllp.llp;
for (i=0; i<viewData.lllp.numOfComponents; i++,anLLPoint++) {
fprintf(viewDataFile,"%d %d\n",anLLPoint->prop.closed,
anLLPoint->prop.solid);
fprintf(viewDataFile,"%d\n",anLLPoint->numOfLists);
anLPoint = anLLPoint->lp;
for (j=0; j<anLLPoint->numOfLists; j++,anLPoint++) {
fprintf(viewDataFile,"%d %d\n",anLPoint->prop.closed,
anLPoint->prop.solid);
fprintf(viewDataFile,"%d\n",anLPoint->numOfPoints);
anIndex = anLPoint->indices;
for (k=0; k<anLPoint->numOfPoints; k++,anIndex++) {
fprintf(viewDataFile,"%d\n",*anIndex);
} /* for points in LPoints (k) */
} /* for LPoints in LLPoints (j) */
} /* for LLPoints in LLLPoints (i) */
fclose(viewDataFile);
} /* else was able to open file under the given filename */
/* write out special files */
for (ii=1; ii<numBits; ii++) { /* write.h is one-based */
if (thingsToWrite & (1<<ii)) {
switch (ii) {
case Bitmap:
/*** Create the pixmap (bitmaps need leaf name) ***/
sprintf(viewBitmapFilename,"%s%s%s",viewDirName,"/","image.bm");
XGetWindowAttributes(dsply,viewport->viewWindow,&vwInfo);
code = XWriteBitmapFile(dsply,viewBitmapFilename,
viewport->titleWindow,vwInfo.width,
vwInfo.height+vwInfo.border_width+20,-1,-1);
break;
case Pixmap:
/*** Create the pixmap (bitmaps need leaf name) ***/
sprintf(viewPixmapFilename,"%s%s%s",viewDirName,"/","image.xpm");
XGetWindowAttributes(dsply,viewport->viewWindow,&vwInfo);
write_pixmap_file(dsply,scrn,viewPixmapFilename,
viewport->titleWindow,0,0,vwInfo.width,
vwInfo.height+titleHeight);
break;
case Image:
/*** Create the image (bitmaps need leaf name) ***/
writeImage = yes;
sprintf(viewPixmapFilename,"%s%s%s",viewDirName,"/","image.xpm");
XResizeWindow(dsply,viewport->titleWindow,300,300+titleHeight);
XResizeWindow(dsply,viewport->viewWindow,300,300);
viewport->hueTop = totalHues-1; viewport->hueOffset = 0;
viewport->numberOfHues = viewport->hueTop - viewport->hueOffset;
firstTime = 1;
if (viewData.style == transparent) {
viewData.style = render;
viewData.outlineRenderOn = 1;
} else {
if (viewData.style == render) viewData.outlineRenderOn = 1;
}
drawViewport(Xoption);
writeTitle();
XGetWindowAttributes(dsply,viewport->viewWindow,&vwInfo);
write_pixmap_file(dsply,scrn,viewPixmapFilename,
viewport->titleWindow,0,0,vwInfo.width,
vwInfo.height+titleHeight);
viewport->monoOn = 1;
maxGreyShade = XInitShades(dsply,scrn);
firstTime = 1;
drawViewport(Xoption);
writeTitle();
sprintf(viewBitmapFilename,"%s%s%s",viewDirName,"/","image.bm");
code = XWriteBitmapFile(dsply,viewBitmapFilename,
viewport->titleWindow,vwInfo.width,
vwInfo.height+vwInfo.border_width+20,-1,-1);
writeImage = no;
break;
case Postscript:
/*** Create postscript output for viewport (in axiom3D.ps) ***/
sprintf(PSfilename,"%s%s",viewDirName,"/axiom3D.ps");
if (PSInit(viewport->viewWindow,viewport->titleWindow) == psError)
return(-1);
drawViewport(PSoption); /* write new script file in /tmp */
if (PSCreateFile(viewBorderWidth,viewport->viewWindow,
viewport->titleWindow, viewport->title) == psError)
return(-1); /* concat script & proc into axiom3D.ps */
break;
} /* switch on ii */
} /* if thingsToWrite >> ii */
} /* for ii */
return(0);
} /* else create directory okay */
}
void
drawPhong(int dFlag)
{
poly *p, *head;
polyList *s;
int i,j,hue;
int *anIndex, redo;
viewTriple *aPoint, *polyPt;
redo = (recalc || redoSmooth);
if (redo || redoColor || redoDither) {
rotated = no; zoomed = no; translated = no;
switchedPerspective = no; changedEyeDistance = no;
redoSmooth = no; movingLight = no;
/* If only a color change don't recalculate polygon info. */
if (!redo) {
/* glossy shading if a single hue is indicated */
changeColorMap();
scanLines(dFlag);
/* if axes are on then show axes labels */
if (viewport->axesOn) showAxesLabels(dFlag);
/* show pixmap of image */
XCopyArea(dsply,viewmap,viewport->viewWindow,trashGC,0,0,
vwInfo.width,vwInfo.height,0,0);
} else {
if (keepDrawingViewport()) {
if (!firstTime && !(scanline > 0)) {
strcpy(control->message," Freeing Polygons ");
writeControlMessage();
freeListOfPolygons(quickList);
freePointResevoir();
}
if (keepDrawingViewport()) {
strcpy(control->message," Collecting Polygons ");
writeControlMessage();
quickList = copyPolygons(viewData.polygons);
if (keepDrawingViewport()) {
strcpy(control->message," Projecting Polygons ");
writeControlMessage();
projectAllPolys(quickList);
if (keepDrawingViewport()) {
strcpy(control->message,
" Setting Polygon Extremes ");
writeControlMessage();
minMaxPolygons(quickList);
if (keepDrawingViewport()) {
strcpy(control->message,
" Sorting Polygons ");
writeControlMessage();
quickList = msort(quickList,0,viewData.numPolygons,
polyCompare);
calcEyePoint();
head = p = quickList;
/* glossy shading if a single hue is indicated */
changeColorMap();
for (i=0, aPoint=viewData.points;
i<viewData.numOfPoints; i++,aPoint++) {
aPoint->norm[0]= 0.0;
aPoint->norm[1]= 0.0;
aPoint->norm[2]= 0.0;
}
freePolyList();
for (i = 0; i < ARRAY_HEIGHT; i++)
scanList[i] = NIL(polyList);
/* for each polygon */
/* calculate average normal for each vertex */
strcpy(control->message,
" Build Polygon Lists ");
writeControlMessage();
p = head;
while ((p != NIL(poly)) && keepDrawingViewport()) {
for (j = 0, anIndex = p->indexPtr;
j < p->numpts; j++, anIndex++) {
polyPt = refPt3D(viewData,*(anIndex));
polyPt->norm[0] += p->N[0];
polyPt->norm[1] += p->N[1];
polyPt->norm[2] += p->N[2];
normalizeVector(polyPt->norm);
/* get hue for each point if multi-dithering is used */
if ((viewport->hueOffset != viewport->hueTop ||
smoothError) && !mono) {
if (absolute(p->color) > 1.0) {
hue = floor(absolute(p->color));
} else {
hue = floor(absolute(p->color) *
viewport->numberOfHues) +
viewport->hueOffset;
}
polyPt->sc = (float)hue;
} /* multi-color dither */
} /* for each point in polygon */
if ( ! ( p->partialClipPz ||
p->totalClipPz ||
(viewData.clipStuff && (p->partialClip || p->totalClip ) ) ) ) {
/* put polygon in each scanline list it intersects */
for (i=(int)p->pymin; i<= (int)p->pymax; i++) {
if ( (i>=0) && (i<ARRAY_HEIGHT ) ){
s = (polyList *)saymem("smoothShade.c",1,sizeof(polyList));
s->polyIndx = p;
s->next = scanList[i];
scanList[i] = s;
}
} /* put polygon in each scanline it intersects */
} /* if polygon not clipped */
p = p->next;
} /* while still polygons */
scanLines(dFlag);
/* if axes are on then show axes labels */
if (viewport->axesOn) showAxesLabels(dFlag);
/* show pixmap of image */
XCopyArea(dsply,viewmap,viewport->viewWindow,trashGC,0,0,
vwInfo.width,vwInfo.height,0,0);
/* freePolyList(scanList); */
} /* keepDrawingViewport() after setting extreme values */
} /* keepDrawingViewport() after projecting all polygons */
} /* keepDrawingViewport() after collecting polygons */
} /* keepDrawingViewport() after freeing polygons */
} /* keepDrawingViewport() after recalc */
finishedList = !(scanline>0);
if (firstTime) firstTime = no;
} /* not only a color change */
} else { /* else just redisplay current pixmap of image */
XCopyArea(dsply,viewmap,viewport->viewWindow,trashGC,0,0,
vwInfo.width,vwInfo.height,0,0);
}
clearControlMessage();
strcpy(control->message,viewport->title);
writeControlMessage();
} /* drawPhong */
void
changeColorMap(void)
{
int okay, i, hue, *index;
poly *cp;
viewTriple *pt;
strcpy(control->message," Make New Color Map ");
writeControlMessage();
if ((viewport->hueOffset == viewport->hueTop) &&
!mono && !viewport->monoOn) {
/* colormap is not an even distribution across spectrum */
/* see spadcolors.c code to understand why this is done */
if (viewport->hueTop < 11) smoothHue = viewport->hueTop * 6;
else
if (viewport->hueTop > 10 && viewport->hueTop < 16) {
smoothHue = viewport->hueTop*20 - 140;
}
else {
smoothHue = viewport->hueTop*12 - 12;
}
if (redoColor) {
/* reallocate colormap for new hue */
redoColor = no;
if (pixelSetFlag) {
FreePixels(dsply,colorMap,smoothConst+1);
}
okay = makeNewColorMap(dsply,colorMap,smoothHue);
if (okay) {
pixelSetFlag = yes;
smoothError = no; }
else {
pixelSetFlag = no;
smoothError = yes; }
} /* if redoColor */
} else {
redoDither = no;
if (pixelSetFlag && !mono) {
FreePixels(dsply,colorMap,smoothConst);
pixelSetFlag = no;
redoColor = no;
multiColorFlag = yes;
}
if (!mono && !viewport->monoOn) {
cp = quickList;
while (cp != NIL(poly) && keepDrawingViewport()) {
for (i = 0, index = cp->indexPtr;
i < cp->numpts; i++, index++) {
pt = refPt3D(viewData,*(index));
/* get hue for each point if multi-dithering is used */
if (absolute(cp->color) > 1.0)
hue = floor(absolute(cp->color));
else
hue = floor(absolute(cp->color) * viewport->numberOfHues) +
viewport->hueOffset;
pt->sc = (float)hue;
} /* for each point in polygon */
cp = cp->next;
}
} /* multi-color dither */
} /* else hueOffset != hueTop */
}
void
scanPhong(int dFlag)
{
viewTriple *p1, *p2;
polyList *polygon;
poly *p;
int i,num,xtemp,numttt;
int *anIndex, *start, *end;
float x1,x2,y1,y2,z2,zright,wx1,wx2,wy1,wy2,wz1,wz2;
float intersectionx[2], intersectionz[2];
float c1,c2,colortemp,ztemp,dY,diffy,diffx,n1[3],n2[3],NV[3];
triple ntemp, intersectPt[2], ptemp, pt, intersectN[2];
/* polygon list intersecting the current scanline, will be modified to
edge list structure */
polygon = scanList[scanline];
while (polygon != NIL(polyList) && polygon->polyIndx != NIL(poly) ) {
/* for each polygon in the list */
p = polygon->polyIndx;
/* don't include clipped polygons */
if ( ! ( p->partialClipPz ||
p->totalClipPz ||
(viewData.clipStuff && (p->partialClip || p->totalClip ) ) ) ) {
num = 0; /* 0 & 1, for the 2 edges of polygon that intersect scanline */
numttt =0;
if ((scanline >= (int)p->pymin) && (scanline <= (int)p->pymax)) {
/* which edges of the polygon intersect the scanline */
for (i=0, anIndex=p->indexPtr; i<p->numpts; i++) {
start = anIndex + i;
p1 = refPt3D(viewData,*(start));
x1 = p1->px; y1 = p1->py; zC = p1->pz; c1 = p1->sc;
/* if (x1 < machine0){ x1 = machine0; } */
wx1 = p1->wx; wy1 = p1->wy; wz1 = p1->wz;
n1[0] = p1->norm[0]; n1[1] = p1->norm[1]; n1[2] = p1->norm[2];
end = (i != (p->numpts - 1)) ? anIndex + (i + 1) : anIndex;
p2 = refPt3D(viewData,*(end));
x2 = p2->px; y2 = p2->py; z2 = p2->pz; c2 = p2->sc;
/* if (x2 < machine0){ x2 = machine0; } */
wx2 = p2->wx; wy2 = p2->wy; wz2 = p2->wz;
n2[0] = p2->norm[0]; n2[1] = p2->norm[1]; n2[2] = p2->norm[2];
/* find beginning and end for intersecting edge */
if ((scanline < y1 && scanline >= y2) ||
(scanline >= y1 && scanline < y2)) {
dY = (float)scanline - y1;
diffy = y2 - y1;
if (absolute(diffy) < 0.01) diffy = 1.0;
intersectionx[num] = x1 + ((x2-x1)/diffy) * dY;
intersectionz[num] = zC + ((z2-zC)/diffy) * dY;
if (viewport->hueOffset != viewport->hueTop || smoothError ||
viewport->monoOn)
intersectColor[num] = c1 + ((c2 - c1)/diffy) * dY;
intersectN[num].x = n1[0] + ((n2[0] - n1[0])/diffy)*dY;
intersectN[num].y = n1[1] + ((n2[1] - n1[1])/diffy)*dY;
intersectN[num].z = n1[2] + ((n2[2] - n1[2])/diffy)*dY;
intersectPt[num].x = wx1 + ((wx2 - wx1)/diffy)*dY;
intersectPt[num].y = wy1 + ((wy2 - wy1)/diffy)*dY;
intersectPt[num].z = wz1 + ((wz2 - wz1)/diffy)*dY;
num = 1-num;
numttt++;
} /* if edge intersects scanline */
} /* for each edge */
if (numttt>=2) { /* if numttt 0 or 1 something has gone wrong */
xleft = intersectionx[0]; xright = intersectionx[1];
zC = intersectionz[0]; zright = intersectionz[1];
/* edges are drawn from left to right, so switch if necessary */
if (xright < xleft) {
xtemp = xright; xright = xleft; xleft = xtemp;
ztemp = zright; zright = zC; zC = ztemp;
if (viewport->hueOffset != viewport->hueTop || smoothError ||
viewport->monoOn) {
colortemp = intersectColor[1];
intersectColor[1] = intersectColor[0];
intersectColor[0] = colortemp;
}
ntemp = intersectN[1]; intersectN[1] = intersectN[0];
intersectN[0] = ntemp;
ptemp = intersectPt[1];
intersectPt[1] = intersectPt[0];
intersectPt[0] = ptemp;
}
diffx = xright - xleft;
if (absolute(diffx) > .01) {
if (viewport->hueOffset != viewport->hueTop || smoothError ||
viewport->monoOn)
dcolor = (intersectColor[1] - intersectColor[0]) / diffx;
dnorm.x = (intersectN[1].x - intersectN[0].x) / diffx;
dnorm.y = (intersectN[1].y - intersectN[0].y) / diffx;
dnorm.z = (intersectN[1].z - intersectN[0].z) / diffx;
dpt.x = (intersectPt[1].x - intersectPt[0].x) / diffx;
dpt.y = (intersectPt[1].y - intersectPt[0].y) / diffx;
dpt.z = (intersectPt[1].z - intersectPt[0].z) / diffx;
dzdx = (zright - zC) / diffx;
} else {
if (viewport->hueOffset != viewport->hueTop || smoothError ||
viewport->monoOn)
dcolor = intersectColor[1];
dnorm.x = 0.0; dnorm.y = 0.0; dnorm.z = 0.0;
dpt.x = 0.0; dpt.y = 0.0; dpt.z = 0.0;
dzdx = 0.0;
}
NV[0] = intersectN[0].x;
NV[1] = intersectN[0].y;
NV[2] = intersectN[0].z;
pt.x = intersectPt[0].x;
pt.y = intersectPt[0].y;
pt.z = intersectPt[0].z;
drawPhongSpan(pt,NV,dFlag);
} /* numttt guard */
} /* if scanline intersect */
} /* clipped */
polygon = polygon->next;
} /* while still polygons */
}
