<<>>
<<G3dRayTraceImpl.mesa>>
<<Copyright Ó 1985, 1992 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, August 26, 1992 5:46 pm PDT>>

DIRECTORY CedarProcess, G3dBasic, G3dDraw, G3dLight, G3dMatrix, G3dRayTrace, G3dVector, G3dView, Imager, ImagerColor, 
--ImagerFullColorContext,-- ImagerPixel, ImagerSample, IO, Real, RealFns, Rope, RuntimeError--, Terminal--;

G3dRayTraceImpl: CEDAR PROGRAM
IMPORTS CedarProcess, G3dDraw, G3dLight, G3dVector, --ImagerFullColorContext,-- ImagerSample, IO, Real, RealFns, RuntimeError--, 
Terminal--
EXPORTS G3dRayTrace

~ BEGIN
<<Types>>
Triple:                TYPE ~ G3dBasic.Triple;
Matrix:                TYPE ~ G3dMatrix.Matrix;
RayProc:                TYPE ~ G3dRayTrace.RayProc;
RayData:                TYPE ~ G3dRayTrace.RayData;
RayDataRep:            TYPE ~ G3dRayTrace.RayDataRep;
Viewport:                TYPE ~ G3dMatrix.Viewport;
Context:                TYPE ~ Imager.Context;
RGB:                    TYPE ~ ImagerColor.RGB;
PixelMap:                TYPE ~ ImagerPixel.PixelMap;
ROPE:                    TYPE ~ Rope.ROPE;

origin:                Triple ~ G3dBasic.origin;
yAxis:                Triple ~ G3dBasic.yAxis;
zAxis:                    Triple ~ G3dBasic.zAxis;
<<Ray Tracing>>
RayTrace: PUBLIC PROC [
display:                    PixelMap,                    -- place to create the ray-traced image
eyePoint:                    Triple Ź origin,                -- position of the eye
eyeView:                    Triple Ź zAxis,                -- view direction
upDirection:                Triple Ź yAxis,                -- orientation
fieldOfView:                REAL Ź 40.0,                    -- half horizontal view in degrees
jitter:                        BOOL Ź FALSE,                -- stochastic ray from pixel center
nPixelSamples:            NAT Ź 1,                        -- sub-sampling of pixels
adaptiveLimit:            NAT Ź 0,                        -- # levels of adaptive refinement
rayProc:                    RayProc Ź NIL,                -- client supplied ray-tracing proc
clientData:                REF ANY Ź NIL]                -- passed to the rayProc
RETURNS                    [r: RayData]
~ {
r Ź NEW[RayDataRep];
r.eyePoint Ź eyePoint;
r.eyeView Ź G3dVector.Unit[eyeView];
r.upDirection Ź upDirection;
r.fieldOfView Ź fieldOfView;
r.jitter Ź jitter;
r.nPixelSamples Ź nPixelSamples;
r.adaptiveLimit Ź adaptiveLimit;
r.display Ź display;
r.clientData Ź clientData;
r.rayProc Ź rayProc;
r.process Ź CedarProcess.Fork[RayTracer, r, [priority: background, usePriority: TRUE]];
};

PrepareRayTracer: PUBLIC PROC [r: RayData] ~ {
r.eyeView Ź G3dVector.Unit[r.eyeView];
r.lights Ź G3dLight.PrepareLights[r.lights, r.eyeView];
};

StartRayTracing: PUBLIC PROC [r: RayData] ~ {
IF r.process = NIL OR CedarProcess.GetStatus[r.process] # busy
THEN r.process Ź CedarProcess.Fork[RayTracer, r, [background, TRUE]];
};

StopRayTracing: PUBLIC PROC [r: RayData] ~ {
IF CedarProcess.GetStatus[r.process] = busy THEN CedarProcess.Abort[r.process];
};

ResetRayTracing: PUBLIC PROC [r: RayData] ~ {r.nextPixel Ź [0, 0]};

SetNextPixel: PUBLIC PROC [r: RayData] ~ {
IF (r.nextPixel.x Ź r.nextPixel.x+1) = INTEGER[r.x+r.w] THEN {
r.nextPixel.x Ź r.x;
IF (r.nextPixel.y Ź r.nextPixel.y+1) = INTEGER[r.y+r.h] THEN r.nextPixel.y Ź r.y;
};
};

SetRay: PUBLIC PROC [r: RayData, x, y: NAT] ~ {
xHalf: REAL Ź 0.5*(r.w-r.x);
yHalf: REAL Ź 0.5*(r.h-r.y);
aspect: REAL Ź AspectRatio[r];
tangent: REAL Ź RealFns.TanDeg[r.fieldOfView];
xPortion: REAL Ź -(REAL[x-r.x]-xHalf)/xHalf;            -- +/- 1
yPortion: REAL Ź -(REAL[y-r.y]-yHalf)/yHalf;        -- +/- 1
xVec: Triple Ź G3dVector.SetVectorLength[
G3dVector.Cross[r.eyeView, r.upDirection], tangent*xPortion];
yVec: Triple Ź G3dVector.SetVectorLength[r.upDirection, tangent*yPortion*aspect];
r.ray.axis Ź
[r.eyeView.x+xVec.x+yVec.x, r.eyeView.y+xVec.y+yVec.y, r.eyeView.z+xVec.z+yVec.z];
r.ray.base Ź r.eyePoint;
};

stopEverything: BOOL Ź FALSE;            -- for emergencies

RayTracer: CedarProcess.ForkableProc ~ {
Luminance: PROC [rgb: RGB] RETURNS [NAT] ~ {
v: REAL Ź IF rgb.R=rgb.G AND rgb.R=rgb.B THEN rgb.R ELSE .3*rgb.R+.59*rgb.G+.11*rgb.B;
RETURN[Real.Round[255.0*v]];
};
r: RayData Ź NARROW[data];
<<fbA: Terminal.FrameBuffer _ Terminal.GetColorFrameBufferA[Terminal.Current[]];>>
<<fbB: Terminal.FrameBuffer _ Terminal.GetColorFrameBufferB[Terminal.Current[]];>>
PrepareRayTracer[r];
<<r.display _ ImagerFullColorContext.PixelMapFromFrameBuffers[fbA, fbB];>>
r.display[0] Ź ImagerSample.Clip[r.display[0], [[r.y, r.x], [r.y+r.h, r.x+r.w]]];
r.display[1] Ź ImagerSample.Clip[r.display[1], [[r.y, r.x], [r.y+r.h, r.x+r.w]]];
r.redo Ź ImagerSample.NewSampleMap[r.display.box, 1];
WHILE NOT stopEverything DO
ENABLE RuntimeError.BoundsFault => CONTINUE;
x, y: NAT;
CedarProcess.CheckAbort[];
SetRay[r, x Ź r.nextPixel.x, y Ź r.nextPixel.y];
r.rgb Ź r.rayProc[[r.ray.base, G3dVector.Unit[r.ray.axis]], r.clientData];
SELECT r.display.samplesPerPixel FROM
1 => ImagerSample.Put[r.display[0], [y, x], Luminance[r.rgb]];
3 => {
ImagerSample.Put[r.display[0], [y, x], Real.Round[255.0*r.rgb.R]];
ImagerSample.Put[r.display[1], [y, x], Real.Round[255.0*r.rgb.G]];
ImagerSample.Put[r.display[2], [y, x], Real.Round[255.0*r.rgb.B]];
};
ENDCASE;
SetNextPixel[r];
IF r.nextPixel = [r.x, r.y] THEN {
IF r.finishProc # NIL THEN [] Ź CedarProcess.Fork[Finisher, r];
EXIT;
};
ENDLOOP;
};

Finisher: CedarProcess.ForkableProc ~ {
r: RayData Ź NARROW[data];
r.finishProc[r.clientData];
};
<<Miscellany>>
AspectRatio: PUBLIC PROC [r: RayData] RETURNS [REAL] ~ {
RETURN[REAL[r.h-r.y]/REAL[r.w-r.x]];
};

RayImageScreenCorners: PUBLIC PROC [r: RayData] RETURNS [p1, p2, p3, p4: Triple] ~ {
tangent: REAL Ź RealFns.TanDeg[r.fieldOfView];
aspect: REAL Ź AspectRatio[r];
xVec: Triple Ź G3dVector.SetVectorLength[
G3dVector.Cross[r.eyeView, r.upDirection], tangent];
yVec: Triple Ź G3dVector.SetVectorLength[r.upDirection, tangent*aspect];
at: Triple Ź G3dVector.Add[r.eyePoint, r.eyeView];
p1 Ź [at.x+xVec.x+yVec.x, at.y+xVec.y+yVec.y, at.z+xVec.z+yVec.z];
p2 Ź [at.x+xVec.x-yVec.x, at.y+xVec.y-yVec.y, at.z+xVec.z-yVec.z];
p3 Ź [at.x-xVec.x-yVec.x, at.y-xVec.y-yVec.y, at.z-xVec.z-yVec.z];
p4 Ź [at.x-xVec.x+yVec.x, at.y-xVec.y+yVec.y, at.z-xVec.z+yVec.z];
};

DrawRayTip: PUBLIC PROC [context: Context, r: RayData, view: Matrix, viewport: Viewport] ~ {
G3dDraw.Mark[context, G3dVector.Add[r.ray.base, r.ray.axis], view, viewport,, dot];
};

DrawRayImageScreen: PUBLIC PROC [
context: Context,
r: RayData,
view: Matrix,
viewport: Viewport Ź []]
~ {
p1, p2, p3, p4: Triple;
[p1, p2, p3, p4] Ź RayImageScreenCorners[r];
G3dDraw.Segment[context, p1, p2, view, viewport];
G3dDraw.Segment[context, p2, p3, view, viewport];
G3dDraw.Segment[context, p3, p4, view, viewport];
G3dDraw.Segment[context, p4, p1, view, viewport];
G3dDraw.Segment[context, r.eyePoint, p1, view, viewport];
G3dDraw.Segment[context, r.eyePoint, p2, view, viewport];
G3dDraw.Segment[context, r.eyePoint, p3, view, viewport];
G3dDraw.Segment[context, r.eyePoint, p4, view, viewport];
};

ParametersMessage: PUBLIC PROC [r: RayData] RETURNS [rope: ROPE] ~ {
rope Ź IO.PutFLR["display w, h: %g, %g, %gjitter, %g subSamples, %g adaptLimit", LIST[
IO.int[r.w], IO.int[r.h], IO.rope[IF r.jitter THEN NIL ELSE "not "],
IO.int[r.nPixelSamples], IO.int[r.adaptiveLimit]]];
};

END.