void BoundingTask::Run()
{
if((sceneData->objects.size() < boundingThreshold) || (sceneData->boundingMethod == 0))
{
SceneObjects objects(sceneData->objects);
sceneData->boundingMethod = 0;
sceneData->numberOfFiniteObjects = objects.finite.size();
sceneData->numberOfInfiniteObjects = objects.infinite.size() - objects.numLights;
return;
}
switch(sceneData->boundingMethod)
{
case 2:
{
// new BSP tree code
SceneObjects objects(sceneData->objects);
BSPProgress progress(sceneData->sceneId, sceneData->frontendAddress);
sceneData->objects.clear();
sceneData->objects.insert(sceneData->objects.end(), objects.finite.begin(), objects.finite.end());
sceneData->objects.insert(sceneData->objects.end(), objects.infinite.begin(), objects.infinite.end());
sceneData->numberOfFiniteObjects = objects.finite.size();
sceneData->numberOfInfiniteObjects = objects.infinite.size() - objects.numLights;
sceneData->tree = new BSPTree(sceneData->bspMaxDepth, sceneData->bspObjectIsectCost, sceneData->bspBaseAccessCost, sceneData->bspChildAccessCost, sceneData->bspMissChance);
sceneData->tree->build(progress, objects,
sceneData->nodes, sceneData->splitNodes, sceneData->objectNodes, sceneData->emptyNodes,
sceneData->maxObjects, sceneData->averageObjects, sceneData->maxDepth, sceneData->averageDepth,
sceneData->aborts, sceneData->averageAborts, sceneData->averageAbortObjects, sceneData->inputFile);
break;
}
case 1:
{
// old bounding box code
unsigned int numberOfLightSources;
Build_Bounding_Slabs(&(sceneData->boundingSlabs), sceneData->objects, sceneData->numberOfFiniteObjects,
sceneData->numberOfInfiniteObjects, numberOfLightSources);
break;
}
}
}
void FrameRender()
{
// Store start time for parse.
START_TIME
Current_Token_Count = 0;
tparse_frame = tphoton_frame = trender_frame = 0.0;
// Parse the scene file.
Send_Progress("Parsing", PROGRESS_PARSING);
opts.Do_Stats = false;
// Set up noise-tables
Initialize_Noise();
// Set up function VM
POVFPU_Init();
// Init module specific stuff.
Initialize_Mesh_Code();
Parse();
opts.Do_Stats = true;
if (opts.Radiosity_Enabled)
Experimental_Flag |= EF_RADIOS;
if (Experimental_Flag)
{
char str[512] = "" ;
if (Experimental_Flag & EF_SPLINE)
strcat (str, str [0] ? ", spline" : "spline") ;
if (Experimental_Flag & EF_RADIOS)
strcat (str, str [0] ? ", radiosity" : "radiosity") ;
if (Experimental_Flag & EF_SLOPEM)
strcat (str, str [0] ? ", slope pattern" : "slope pattern") ;
if (Experimental_Flag & EF_ISOFN)
strcat (str, str [0] ? ", function '.hf'" : "function '.hf'") ;
if (Experimental_Flag & EF_TIFF)
strcat (str, str [0] ? ", TIFF image support" : "TIFF image support") ;
Warning(0, "This rendering uses the following experimental feature(s): %s.\n"
"The design and implementation of these features is likely to change in future versions\n"
"of POV-Ray. Full backward compatibility with the current implementation is NOT guaranteed.",
str);
}
Experimental_Flag = 0;
// Switch off standard anti-aliasing.
if((Frame.Camera->Aperture != 0.0) && (Frame.Camera->Blur_Samples > 0))
{
opts.Options &= ~ANTIALIAS;
Warning(0, "Focal blur is used. Standard antialiasing is switched off.");
}
// Create the bounding box hierarchy.
Stage = STAGE_SLAB_BUILDING;
if(opts.Use_Slabs)
Send_Progress("Creating bounding slabs", PROGRESS_CREATING_BOUNDING_SLABS);
// Init module specific stuff.
Initialize_Atmosphere_Code();
Initialize_BBox_Code();
Initialize_Lighting_Code();
Initialize_VLBuffer_Code();
Initialize_Radiosity_Code();
// Always call this to print number of objects.
Build_Bounding_Slabs(&Root_Object);
// Create the vista buffer.
Build_Vista_Buffer();
// Create the light buffers.
Build_Light_Buffers();
// Save variable values.
variable_store(STORE);
// Get the parsing time.
STOP_TIME
tparse = TIME_ELAPSED
Send_ProgressUpdate(PROGRESS_PARSING, 0);
// Output parsing statistics.
Send_ParseStatistics();
if (photonOptions.photonsEnabled)
{
/* Store start time for photons. */
START_TIME
/* now backwards-trace the scene and build the photon maps */
InitBacktraceEverything();
BuildPhotonMaps();
/* Get the photon-shooting time. */
STOP_TIME
tphoton = TIME_ELAPSED
/* Get total parsing time. */
tphoton_total += tphoton;
tphoton_frame = tphoton;
tphoton = 0;
}
/* Store start time for the rest of parsing. */
START_TIME
Stage = STAGE_INIT;
// Open output file and if we are continuing an interrupted trace,
// read in the previous file settings and any data there. This has to
// be done before any image-size related allocations, since the settings
// in a resumed file take precedence over that specified by the user. [AED]
open_output_file();
// Start the display.
if(opts.Options & DISPLAY)
{
Send_Progress("Displaying", PROGRESS_DISPLAYING);
Display_Started = POV_DISPLAY_INIT(opts.Preview_RefCon, Frame.Screen_Width, Frame.Screen_Height);
// Display vista tree.
Draw_Vista_Buffer();
}
else
{
Display_Started = false;
}
// Get things ready for ray tracing (misc init, mem alloc)
Initialize_Renderer();
// This had to be taken out of open_output_file() because we don't have
// the final image size until the output file has been opened, so we can't
// initialize the display until we know this, which in turn means we can't
// read the rendered part before the display is initialized. [AED]
if((opts.Options & DISKWRITE) && (opts.Options & CONTINUE_TRACE))
{
Read_Rendered_Part(Actual_Output_Name);
if (opts.Last_Line > Frame.Screen_Height)
opts.Last_Line = Frame.Screen_Height;
if (opts.Last_Column > Frame.Screen_Width)
opts.Last_Column = Frame.Screen_Width;
}
// Get the rest of the parsing time.
STOP_TIME
tparse += TIME_ELAPSED
// Store start time for trace.
START_TIME
// Get total parsing time.
tparse_total += tparse;
tparse_frame = tparse;
tparse = 0;
// Start tracing.
Stage = STAGE_RENDERING;
POV_PRE_RENDER
Send_Progress("Rendering", PROGRESS_RENDERING);
// Macro for setting up any special FP options
CONFIG_MATH
// Ok, go for it - trace the picture.
// If radiosity preview has been done, we are continuing a trace, so it
// is important NOT to do the preview, even if the user requests it, as it
// will cause discontinuities in radiosity shading by (probably) calculating
// a few more radiosity values.
// Note that radiosity REQUIRES a mosaic preview prior to main scan
if ( opts.Radiosity_Enabled && !opts.Radiosity_Preview_Done)
Start_Tracing_Radiosity_Preview(opts.PreviewGridSize_Start, opts.PreviewGridSize_End);
else if((opts.Options & PREVIEW) && (opts.Options & DISPLAY))
Start_Tracing_Mosaic_Preview(opts.PreviewGridSize_Start, opts.PreviewGridSize_End);
switch(opts.Tracing_Method)
{
case 2:
Start_Adaptive_Tracing();
break;
case 1:
default:
Start_Non_Adaptive_Tracing();
}
// Record time so well spent before file close so it can be in comments
STOP_TIME
trender = TIME_ELAPSED
// shutdown (freeing memory) does not get included in the time!
// Get total render time.
trender_total += trender;
trender_frame = trender;
trender = 0;
// Close out our file
if(Output_File != NULL)
{
delete Output_File;
Output_File = NULL;
}
// For all those who never rtfm [trf]
if((Highest_Trace_Level >= Max_Trace_Level) && (Had_Max_Trace_Level == false))
PossibleError("Maximum trace level reached! If your scene contains black spots\nread more about the max_trace_level setting in the documentation!");
Stage = STAGE_SHUTDOWN;
POV_PRE_SHUTDOWN
// DESTROY lots of stuff
/* NK phmap */
FreeBacktraceEverything();
Deinitialize_Atmosphere_Code();
Deinitialize_BBox_Code();
Deinitialize_Lighting_Code();
Deinitialize_Mesh_Code();
Deinitialize_VLBuffer_Code();
Deinitialize_Radiosity_Code();
Destroy_Light_Buffers();
Destroy_Vista_Buffer();
Destroy_Bounding_Slabs();
Destroy_Frame();
Terminate_Renderer();
FreeFontInfo();
Free_Iteration_Stack();
Free_Noise_Tables();
POVFPU_Terminate();
POV_POST_SHUTDOWN
if((opts.Options & DISPLAY) && Display_Started)
{
POV_DISPLAY_FINISHED(opts.Preview_RefCon);
POV_DISPLAY_CLOSE(opts.Preview_RefCon);
Display_Started = false;
}
if(opts.histogram_on)
write_histogram(opts.Histogram_File_Name);
Send_Progress("Done Tracing", PROGRESS_DONE_TRACING);
// Print stats ...
Send_RenderStatistics();
if(opts.FrameSeq.FrameType == FT_MULTIPLE_FRAME)
{
// Add them up
sum_statistics(totalstats, stats);
// ... and then clear them for the next frame
init_statistics(stats);
}
// Restore variable values.
variable_store(RESTORE);
}