Try to use CPU affinity to allow threads to run in different CPU
/*
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2006 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/render/intern/source/pipeline.c
* \ingroup render
*/
#include <math.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include "DNA_group_types.h"
#include "DNA_image_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_sequence_types.h"
#include "DNA_userdef_types.h"
#include "MEM_guardedalloc.h"
#include "BKE_animsys.h" /* <------ should this be here?, needed for sequencer update */
#include "BKE_global.h"
#include "BKE_image.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "BKE_object.h"
#include "BKE_pointcache.h"
#include "BKE_report.h"
#include "BKE_scene.h"
#include "BKE_sequencer.h"
#include "BKE_utildefines.h"
#include "BKE_writeavi.h" /* <------ should be replaced once with generic movie module */
#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_rand.h"
#include "BLI_threads.h"
#include "BLI_utildefines.h"
#include "PIL_time.h"
#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"
#include "intern/openexr/openexr_multi.h"
#include "RE_pipeline.h"
/* internal */
#include "render_types.h"
#include "renderpipeline.h"
#include "renderdatabase.h"
#include "rendercore.h"
#include "envmap.h"
#include "initrender.h"
#include "shadbuf.h"
#include "pixelblending.h"
#include "zbuf.h"
#define NICK_EDIT
/* render flow
1) Initialize state
- state data, tables
- movie/image file init
- everything that doesn't change during animation
2) Initialize data
- camera, world, matrices
- make render verts, faces, halos, strands
- everything can change per frame/field
3) Render Processor
- multiple layers
- tiles, rect, baking
- layers/tiles optionally to disk or directly in Render Result
4) Composite Render Result
- also read external files etc
5) Image Files
- save file or append in movie
*/
/* ********* globals ******** */
/* here we store all renders */
static struct {
ListBase renderlist;
/* commandline thread override */
int threads;
} RenderGlobal = {{NULL, NULL}, -1};
/* hardcopy of current render, used while rendering for speed */
Render R;
static int counter= 1;
/* ********* alloc and free ******** */
static int do_write_image_or_movie(Render *re, Scene *scene, bMovieHandle *mh, ReportList *reports, const char *name_override);
static RenderPart *find_next_pano_slice(Render *re, int *minx, rctf *viewplane);
static RenderPart *find_next_part(Render *re, int minx);
static volatile int g_break= 0;
static int thread_break(void *UNUSED(arg))
{
return g_break;
}
/* default callbacks, set in each new render */
static void result_nothing(void *UNUSED(arg), RenderResult *UNUSED(rr)) {}
static void result_rcti_nothing(void *UNUSED(arg), RenderResult *UNUSED(rr), volatile struct rcti *UNUSED(rect)) {}
static void stats_nothing(void *UNUSED(arg), RenderStats *UNUSED(rs)) {}
static void float_nothing(void *UNUSED(arg), float UNUSED(val)) {}
static void print_error(void *UNUSED(arg), const char *str) {printf("ERROR: %s\n", str);}
static int default_break(void *UNUSED(arg)) {return G.afbreek == 1;}
static void stats_background(void *UNUSED(arg), RenderStats *rs)
{
uintptr_t mem_in_use, mmap_in_use, peak_memory;
float megs_used_memory, mmap_used_memory, megs_peak_memory;
mem_in_use= MEM_get_memory_in_use();
mmap_in_use= MEM_get_mapped_memory_in_use();
peak_memory = MEM_get_peak_memory();
megs_used_memory= (mem_in_use-mmap_in_use)/(1024.0*1024.0);
mmap_used_memory= (mmap_in_use)/(1024.0*1024.0);
megs_peak_memory = (peak_memory)/(1024.0*1024.0);
fprintf(stdout, "Fra:%d Mem:%.2fM (%.2fM, peak %.2fM) ", rs->cfra,
megs_used_memory, mmap_used_memory,
megs_peak_memory);
if(rs->curfield)
fprintf(stdout, "Field %d ", rs->curfield);
if(rs->curblur)
fprintf(stdout, "Blur %d ", rs->curblur);
if(rs->infostr) {
fprintf(stdout, "| %s", rs->infostr);
}
else {
if(rs->tothalo)
fprintf(stdout, "Sce: %s Ve:%d Fa:%d Ha:%d La:%d", rs->scenename,
rs->totvert, rs->totface, rs->tothalo, rs->totlamp);
else
fprintf(stdout, "Sce: %s Ve:%d Fa:%d La:%d", rs->scenename,
rs->totvert, rs->totface, rs->totlamp);
}
fputc('\n', stdout);
fflush(stdout);
}
void RE_FreeRenderResult(RenderResult *res)
{
if(res==NULL) return;
while(res->layers.first) {
RenderLayer *rl= res->layers.first;
if(rl->rectf) MEM_freeN(rl->rectf);
/* acolrect and scolrect are
optionally allocated in shade_tile, only free here since it can be used
for drawing */
if(rl->acolrect) MEM_freeN(rl->acolrect);
if(rl->scolrect) MEM_freeN(rl->scolrect);
while(rl->passes.first) {
RenderPass *rpass= rl->passes.first;
if(rpass->rect) MEM_freeN(rpass->rect);
BLI_remlink(&rl->passes, rpass);
MEM_freeN(rpass);
}
BLI_remlink(&res->layers, rl);
MEM_freeN(rl);
}
if(res->rect32)
MEM_freeN(res->rect32);
if(res->rectz)
MEM_freeN(res->rectz);
if(res->rectf)
MEM_freeN(res->rectf);
if(res->text)
MEM_freeN(res->text);
MEM_freeN(res);
}
/* version that's compatible with fullsample buffers */
static void free_render_result(ListBase *lb, RenderResult *rr)
{
RenderResult *rrnext;
for(; rr; rr= rrnext) {
rrnext= rr->next;
if(lb && lb->first)
BLI_remlink(lb, rr);
RE_FreeRenderResult(rr);
}
}
/* all layers except the active one get temporally pushed away */
static void push_render_result(Render *re)
{
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
/* officially pushed result should be NULL... error can happen with do_seq */
RE_FreeRenderResult(re->pushedresult);
re->pushedresult= re->result;
re->result= NULL;
BLI_rw_mutex_unlock(&re->resultmutex);
}
/* if scemode is R_SINGLE_LAYER, at end of rendering, merge the both render results */
static void pop_render_result(Render *re)
{
if(re->result==NULL) {
printf("pop render result error; no current result!\n");
return;
}
if(re->pushedresult) {
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(re->pushedresult->rectx==re->result->rectx &&
re->pushedresult->recty==re->result->recty) {
/* find which layer in pushedresult should be replaced */
SceneRenderLayer *srl;
RenderLayer *rlpush;
RenderLayer *rl= re->result->layers.first;
int nr;
/* render result should be empty after this */
BLI_remlink(&re->result->layers, rl);
/* reconstruct render result layers */
for(nr=0, srl=
re->scene->r.layers.first; srl; srl= srl->next, nr++) {
if(nr==re->r.actlay)
BLI_addtail(&re->result->layers, rl);
else {
rlpush=
RE_GetRenderLayer(re->pushedresult, srl->name);
if(rlpush) {
BLI_remlink(&re->pushedresult->layers, rlpush);
BLI_addtail(&re->result->layers, rlpush);
}
}
}
}
RE_FreeRenderResult(re->pushedresult);
re->pushedresult= NULL;
BLI_rw_mutex_unlock(&re->resultmutex);
}
}
/* NOTE: OpenEXR only supports 32 chars for layer+pass names
In blender we now use max 10 chars for pass, max 20 for layer */
static const char *get_pass_name(int passtype, int channel)
{
if(passtype == SCE_PASS_COMBINED) {
if(channel==-1) return "Combined";
if(channel==0) return "Combined.R";
if(channel==1) return "Combined.G";
if(channel==2) return "Combined.B";
return "Combined.A";
}
if(passtype == SCE_PASS_Z) {
if(channel==-1) return "Depth";
return "Depth.Z";
}
if(passtype == SCE_PASS_VECTOR) {
if(channel==-1) return "Vector";
if(channel==0) return "Vector.X";
if(channel==1) return "Vector.Y";
if(channel==2) return "Vector.Z";
return "Vector.W";
}
if(passtype == SCE_PASS_NORMAL) {
if(channel==-1) return "Normal";
if(channel==0) return "Normal.X";
if(channel==1) return "Normal.Y";
return "Normal.Z";
}
if(passtype == SCE_PASS_UV) {
if(channel==-1) return "UV";
if(channel==0) return "UV.U";
if(channel==1) return "UV.V";
return "UV.A";
}
if(passtype == SCE_PASS_RGBA) {
if(channel==-1) return "Color";
if(channel==0) return "Color.R";
if(channel==1) return "Color.G";
if(channel==2) return "Color.B";
return "Color.A";
}
if(passtype == SCE_PASS_EMIT) {
if(channel==-1) return "Emit";
if(channel==0) return "Emit.R";
if(channel==1) return "Emit.G";
return "Emit.B";
}
if(passtype == SCE_PASS_DIFFUSE) {
if(channel==-1) return "Diffuse";
if(channel==0) return "Diffuse.R";
if(channel==1) return "Diffuse.G";
return "Diffuse.B";
}
if(passtype == SCE_PASS_SPEC) {
if(channel==-1) return "Spec";
if(channel==0) return "Spec.R";
if(channel==1) return "Spec.G";
return "Spec.B";
}
if(passtype == SCE_PASS_SHADOW) {
if(channel==-1) return "Shadow";
if(channel==0) return "Shadow.R";
if(channel==1) return "Shadow.G";
return "Shadow.B";
}
if(passtype == SCE_PASS_AO) {
if(channel==-1) return "AO";
if(channel==0) return "AO.R";
if(channel==1) return "AO.G";
return "AO.B";
}
if(passtype == SCE_PASS_ENVIRONMENT) {
if(channel==-1) return "Env";
if(channel==0) return "Env.R";
if(channel==1) return "Env.G";
return "Env.B";
}
if(passtype == SCE_PASS_INDIRECT) {
if(channel==-1) return "Indirect";
if(channel==0) return "Indirect.R";
if(channel==1) return "Indirect.G";
return "Indirect.B";
}
if(passtype == SCE_PASS_REFLECT) {
if(channel==-1) return "Reflect";
if(channel==0) return "Reflect.R";
if(channel==1) return "Reflect.G";
return "Reflect.B";
}
if(passtype == SCE_PASS_REFRACT) {
if(channel==-1) return "Refract";
if(channel==0) return "Refract.R";
if(channel==1) return "Refract.G";
return "Refract.B";
}
if(passtype == SCE_PASS_INDEXOB) {
if(channel==-1) return "IndexOB";
return "IndexOB.X";
}
if(passtype == SCE_PASS_MIST) {
if(channel==-1) return "Mist";
return "Mist.Z";
}
if(passtype == SCE_PASS_RAYHITS)
{
if(channel==-1) return "Rayhits";
if(channel==0) return "Rayhits.R";
if(channel==1) return "Rayhits.G";
return "Rayhits.B";
}
return "Unknown";
}
static int passtype_from_name(char *str)
{
if(strcmp(str, "Combined")==0)
return SCE_PASS_COMBINED;
if(strcmp(str, "Depth")==0)
return SCE_PASS_Z;
if(strcmp(str, "Vector")==0)
return SCE_PASS_VECTOR;
if(strcmp(str, "Normal")==0)
return SCE_PASS_NORMAL;
if(strcmp(str, "UV")==0)
return SCE_PASS_UV;
if(strcmp(str, "Color")==0)
return SCE_PASS_RGBA;
if(strcmp(str, "Emit")==0)
return SCE_PASS_EMIT;
if(strcmp(str, "Diffuse")==0)
return SCE_PASS_DIFFUSE;
if(strcmp(str, "Spec")==0)
return SCE_PASS_SPEC;
if(strcmp(str, "Shadow")==0)
return SCE_PASS_SHADOW;
if(strcmp(str, "AO")==0)
return SCE_PASS_AO;
if(strcmp(str, "Env")==0)
return SCE_PASS_ENVIRONMENT;
if(strcmp(str, "Indirect")==0)
return SCE_PASS_INDIRECT;
if(strcmp(str, "Reflect")==0)
return SCE_PASS_REFLECT;
if(strcmp(str, "Refract")==0)
return SCE_PASS_REFRACT;
if(strcmp(str, "IndexOB")==0)
return SCE_PASS_INDEXOB;
if(strcmp(str, "Mist")==0)
return SCE_PASS_MIST;
if(strcmp(str, "RayHits")==0)
return SCE_PASS_RAYHITS;
return 0;
}
static void scene_unique_exr_name(Scene *scene, char *str, int sample)
{
char di[FILE_MAX], name[FILE_MAXFILE+MAX_ID_NAME+100], fi[FILE_MAXFILE];
BLI_strncpy(di, G.main->name, FILE_MAX);
BLI_splitdirstring(di, fi);
if(sample==0)
BLI_snprintf(name, sizeof(name), "%s_%s.exr", fi, scene->id.name+2);
else
BLI_snprintf(name, sizeof(name), "%s_%s%d.exr", fi, scene->id.name+2, sample);
BLI_make_file_string("/", str, btempdir, name);
}
static void render_unique_exr_name(Render *re, char *str, int sample)
{
scene_unique_exr_name(re->scene, str, sample);
}
static void render_layer_add_pass(RenderResult *rr, RenderLayer *rl, int channels, int passtype)
{
const char *typestr= get_pass_name(passtype, 0);
RenderPass *rpass= MEM_callocN(sizeof(RenderPass), typestr);
int rectsize= rr->rectx*rr->recty*channels;
BLI_addtail(&rl->passes, rpass);
rpass->passtype= passtype;
rpass->channels= channels;
rpass->rectx= rl->rectx;
rpass->recty= rl->recty;
if(rr->exrhandle) {
int a;
for(a=0; a<channels; a++)
IMB_exr_add_channel(rr->exrhandle, rl->name,
get_pass_name(passtype, a), 0, 0, NULL);
}
else {
float *rect;
int x;
rpass->rect= MEM_mapallocN(sizeof(float)*rectsize, typestr);
if(passtype==SCE_PASS_VECTOR) {
/* initialize to max speed */
rect= rpass->rect;
for(x= rectsize-1; x>=0; x--)
rect[x]= PASS_VECTOR_MAX;
}
else if(passtype==SCE_PASS_Z) {
rect= rpass->rect;
for(x= rectsize-1; x>=0; x--)
rect[x]= 10e10;
}
}
}
float *RE_RenderLayerGetPass(RenderLayer *rl, int passtype)
{
RenderPass *rpass;
for(rpass=rl->passes.first; rpass; rpass= rpass->next)
if(rpass->passtype== passtype)
return rpass->rect;
return NULL;
}
RenderLayer *RE_GetRenderLayer(RenderResult *rr, const char *name)
{
RenderLayer *rl;
if(rr==NULL) return NULL;
for(rl= rr->layers.first; rl; rl= rl->next)
if(strncmp(rl->name, name, RE_MAXNAME)==0)
return rl;
return NULL;
}
#define RR_USEMEM 0
/* called by main render as well for parts */
/* will read info from Render *re to define layers */
/* called in threads */
/* re->winx,winy is coordinate space of entire image, partrct the part within */
static RenderResult *new_render_result(Render *re, rcti *partrct, int crop, int savebuffers)
{
RenderResult *rr;
RenderLayer *rl;
SceneRenderLayer *srl;
int rectx, recty, nr;
rectx= partrct->xmax - partrct->xmin;
recty= partrct->ymax - partrct->ymin;
if(rectx<=0 || recty<=0)
return NULL;
rr= MEM_callocN(sizeof(RenderResult), "new render result");
rr->rectx= rectx;
rr->recty= recty;
rr->renrect.xmin= 0; rr->renrect.xmax= rectx-2*crop;
/* crop is one or two extra pixels rendered for filtering, is used for merging and display too */
rr->crop= crop;
/* tilerect is relative coordinates within render disprect. do not subtract crop yet */
rr->tilerect.xmin= partrct->xmin - re->disprect.xmin;
rr->tilerect.xmax= partrct->xmax - re->disprect.xmax;
rr->tilerect.ymin= partrct->ymin - re->disprect.ymin;
rr->tilerect.ymax= partrct->ymax - re->disprect.ymax;
if(savebuffers) {
rr->exrhandle= IMB_exr_get_handle();
}
/* check renderdata for amount of layers */
for(nr=0, srl= re->r.layers.first; srl; srl= srl->next, nr++) {
if((re->r.scemode & R_SINGLE_LAYER) && nr!=re->r.actlay)
continue;
if(srl->layflag & SCE_LAY_DISABLE)
continue;
rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
BLI_addtail(&rr->layers, rl);
BLI_strncpy(rl->name, srl->name, sizeof(rl->name));
rl->lay= srl->lay;
rl->lay_zmask= srl->lay_zmask;
rl->layflag= srl->layflag;
rl->passflag= srl->passflag; // for debugging: srl->passflag|SCE_PASS_RAYHITS;
rl->pass_xor= srl->pass_xor;
rl->light_override= srl->light_override;
rl->mat_override= srl->mat_override;
rl->rectx= rectx;
rl->recty= recty;
if(rr->exrhandle) {
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.R", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.G", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.B", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.A", 0, 0,
NULL);
}
else
rl->rectf=
MEM_mapallocN(rectx*recty*sizeof(float)*4, "Combined rgba");
if(srl->passflag & SCE_PASS_Z)
render_layer_add_pass(rr, rl, 1, SCE_PASS_Z);
if(srl->passflag & SCE_PASS_VECTOR)
render_layer_add_pass(rr, rl, 4, SCE_PASS_VECTOR);
if(srl->passflag & SCE_PASS_NORMAL)
render_layer_add_pass(rr, rl, 3, SCE_PASS_NORMAL);
if(srl->passflag & SCE_PASS_UV)
render_layer_add_pass(rr, rl, 3, SCE_PASS_UV);
if(srl->passflag & SCE_PASS_RGBA)
render_layer_add_pass(rr, rl, 4, SCE_PASS_RGBA);
if(srl->passflag & SCE_PASS_EMIT)
render_layer_add_pass(rr, rl, 3, SCE_PASS_EMIT);
if(srl->passflag & SCE_PASS_DIFFUSE)
render_layer_add_pass(rr, rl, 3, SCE_PASS_DIFFUSE);
if(srl->passflag & SCE_PASS_SPEC)
render_layer_add_pass(rr, rl, 3, SCE_PASS_SPEC);
if(srl->passflag & SCE_PASS_AO)
render_layer_add_pass(rr, rl, 3, SCE_PASS_AO);
if(srl->passflag & SCE_PASS_ENVIRONMENT)
render_layer_add_pass(rr, rl, 3, SCE_PASS_ENVIRONMENT);
if(srl->passflag & SCE_PASS_INDIRECT)
render_layer_add_pass(rr, rl, 3, SCE_PASS_INDIRECT);
if(srl->passflag & SCE_PASS_SHADOW)
render_layer_add_pass(rr, rl, 3, SCE_PASS_SHADOW);
if(srl->passflag & SCE_PASS_REFLECT)
render_layer_add_pass(rr, rl, 3, SCE_PASS_REFLECT);
if(srl->passflag & SCE_PASS_REFRACT)
render_layer_add_pass(rr, rl, 3, SCE_PASS_REFRACT);
if(srl->passflag & SCE_PASS_INDEXOB)
render_layer_add_pass(rr, rl, 1, SCE_PASS_INDEXOB);
if(srl->passflag & SCE_PASS_MIST)
render_layer_add_pass(rr, rl, 1, SCE_PASS_MIST);
if(rl->passflag & SCE_PASS_RAYHITS)
render_layer_add_pass(rr, rl, 4, SCE_PASS_RAYHITS);
}
/* sss, previewrender and envmap don't do layers, so we make a default one */
if(rr->layers.first==NULL) {
rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
BLI_addtail(&rr->layers, rl);
rl->rectx= rectx;
rl->recty= recty;
/* duplicate code... */
if(rr->exrhandle) {
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.R", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.G", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.B", 0, 0,
NULL);
IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.A", 0, 0,
NULL);
}
else
rl->rectf=
MEM_mapallocN(rectx*recty*sizeof(float)*4, "Combined rgba");
/* note, this has to be in sync with scene.c */
rl->lay= (1<<20) -1;
rl->layflag= 0x7FFF; /* solid ztra halo strand */
rl->passflag= SCE_PASS_COMBINED;
re->r.actlay= 0;
}
/* border render; calculate offset for use in compositor. compo is centralized coords */
rr->xof= re->disprect.xmin + (re->disprect.xmax - re->disprect.xmin)/2 - re->winx/2;
rr->yof= re->disprect.ymin + (re->disprect.ymax - re->disprect.ymin)/2 - re->winy/2;
return rr;
}
static int render_scene_needs_vector(Render *re)
{
SceneRenderLayer *srl;
for(srl= re->scene->r.layers.first; srl; srl= srl->next)
if(!(srl->layflag & SCE_LAY_DISABLE))
if(srl->passflag & SCE_PASS_VECTOR)
return 1;
return 0;
}
static void do_merge_tile(RenderResult *rr, RenderResult *rrpart, float *target, float *tile, int pixsize)
{
int y, ofs, copylen, tilex, tiley;
copylen= tilex= rrpart->rectx;
tiley= rrpart->recty;
if(rrpart->crop) { /* filters add pixel extra */
tile+= pixsize*(rrpart->crop + rrpart->crop*tilex);
copylen= tilex - 2*rrpart->crop;
tiley -= 2*rrpart->crop;
ofs= (rrpart->tilerect.ymin +
rrpart->crop)*rr->rectx +
(rrpart->tilerect.xmin+rrpart->crop);
target+= pixsize*ofs;
}
else {
ofs= (rrpart->tilerect.ymin*rr->rectx + rrpart->tilerect.xmin);
target+= pixsize*ofs;
}
copylen *= sizeof(float)*pixsize;
tilex *= pixsize;
ofs= pixsize*rr->rectx;
for(y=0; y<tiley; y++) {
memcpy(target, tile, copylen);
target+= ofs;
tile+= tilex;
}
}
/* used when rendering to a full buffer, or when reading the exr part-layer-pass file */
/* no test happens here if it fits... we also assume layers are in sync */
/* is used within threads */
static void merge_render_result(RenderResult *rr, RenderResult *rrpart)
{
RenderLayer *rl, *rlp;
RenderPass *rpass, *rpassp;
for(rl= rr->layers.first, rlp=
rrpart->layers.first; rl && rlp; rl= rl->next, rlp=
rlp->next) {
/* combined */
if(rl->rectf && rlp->rectf)
do_merge_tile(rr, rrpart, rl->rectf, rlp->rectf, 4);
/* passes are allocated in sync */
for(rpass= rl->passes.first,
rpassp= rlp->passes.first; rpass && rpassp; rpass=
rpass->next, rpassp= rpassp->next) {
do_merge_tile(rr, rrpart, rpass->rect, rpassp->rect,
rpass->channels);
}
}
}
static void save_render_result_tile(RenderResult *rr, RenderResult *rrpart)
{
RenderLayer *rlp;
RenderPass *rpassp;
int offs, partx, party;
BLI_lock_thread(LOCK_IMAGE);
for(rlp= rrpart->layers.first; rlp; rlp= rlp->next) {
if(rrpart->crop) { /* filters add pixel extra */
offs= (rrpart->crop + rrpart->crop*rrpart->rectx);
}
else {
offs= 0;
}
/* combined */
if(rlp->rectf) {
int a, xstride= 4;
for(a=0; a<xstride; a++)
IMB_exr_set_channel(rr->exrhandle, rlp->name,
get_pass_name(SCE_PASS_COMBINED, a),
xstride,
xstride*rrpart->rectx, rlp->rectf+a + xstride*offs);
}
/* passes are allocated in sync */
for(rpassp= rlp->passes.first; rpassp; rpassp= rpassp->next) {
int a, xstride= rpassp->channels;
for(a=0; a<xstride; a++)
IMB_exr_set_channel(rr->exrhandle, rlp->name,
get_pass_name(rpassp->passtype, a),
xstride,
xstride*rrpart->rectx, rpassp->rect+a + xstride*offs);
}
}
party= rrpart->tilerect.ymin + rrpart->crop;
partx= rrpart->tilerect.xmin + rrpart->crop;
IMB_exrtile_write_channels(rr->exrhandle, partx, party, 0);
BLI_unlock_thread(LOCK_IMAGE);
}
static void save_empty_result_tiles(Render *re)
{
RenderPart *pa;
RenderResult *rr;
for(rr= re->result; rr; rr= rr->next) {
IMB_exrtile_clear_channels(rr->exrhandle);
for(pa= re->parts.first; pa; pa= pa->next) {
if(pa->ready==0) {
int party= pa->disprect.ymin -
re->disprect.ymin + pa->crop;
int partx= pa->disprect.xmin -
re->disprect.xmin + pa->crop;
IMB_exrtile_write_channels(rr->exrhandle, partx,
party, 0);
}
}
}
}
/* for passes read from files, these have names stored */
static char *make_pass_name(RenderPass *rpass, int chan)
{
static char name[16];
int len;
BLI_strncpy(name, rpass->name, EXR_PASS_MAXNAME);
len= strlen(name);
name[len]= '.';
name[len+1]= rpass->chan_id[chan];
name[len+2]= 0;
return name;
}
/* filename already made absolute */
/* called from within UI, saves both rendered result as a file-read result */
void RE_WriteRenderResult(RenderResult *rr, const char *filename, int compress)
{
RenderLayer *rl;
RenderPass *rpass;
void *exrhandle= IMB_exr_get_handle();
BLI_make_existing_file(filename);
/* composite result */
if(rr->rectf) {
IMB_exr_add_channel(exrhandle,
"Composite", "Combined.R", 4, 4*rr->rectx, rr->rectf);
IMB_exr_add_channel(exrhandle,
"Composite", "Combined.G", 4, 4*rr->rectx, rr->rectf+1);
IMB_exr_add_channel(exrhandle,
"Composite", "Combined.B", 4, 4*rr->rectx, rr->rectf+2);
IMB_exr_add_channel(exrhandle,
"Composite", "Combined.A", 4, 4*rr->rectx, rr->rectf+3);
}
/* add layers/passes and assign channels */
for(rl= rr->layers.first; rl; rl= rl->next) {
/* combined */
if(rl->rectf) {
int a, xstride= 4;
for(a=0; a<xstride; a++)
IMB_exr_add_channel(exrhandle, rl->name,
get_pass_name(SCE_PASS_COMBINED, a),
xstride,
xstride*rr->rectx, rl->rectf+a);
}
/* passes are allocated in sync */
for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
int a, xstride= rpass->channels;
for(a=0; a<xstride; a++) {
if(rpass->passtype)
IMB_exr_add_channel(exrhandle,
rl->name, get_pass_name(rpass->passtype, a),
xstride, xstride*rr->rectx, rpass->rect+a);
else
IMB_exr_add_channel(exrhandle,
rl->name, make_pass_name(rpass, a),
xstride, xstride*rr->rectx, rpass->rect+a);
}
}
}
IMB_exr_begin_write(exrhandle, filename, rr->rectx, rr->recty, compress);
IMB_exr_write_channels(exrhandle);
IMB_exr_close(exrhandle);
}
/* callbacks for RE_MultilayerConvert */
static void *ml_addlayer_cb(void *base, char *str)
{
RenderResult *rr= base;
RenderLayer *rl;
rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
BLI_addtail(&rr->layers, rl);
BLI_strncpy(rl->name, str, EXR_LAY_MAXNAME);
return rl;
}
static void ml_addpass_cb(void *UNUSED(base), void *lay, char *str, float *rect, int totchan, char *chan_id)
{
RenderLayer *rl= lay;
RenderPass *rpass= MEM_callocN(sizeof(RenderPass), "loaded pass");
int a;
BLI_addtail(&rl->passes, rpass);
rpass->channels= totchan;
rpass->passtype= passtype_from_name(str);
if(rpass->passtype==0) printf("unknown pass %s\n", str);
rl->passflag |= rpass->passtype;
BLI_strncpy(rpass->name, str, EXR_PASS_MAXNAME);
/* channel id chars */
for(a=0; a<totchan; a++)
rpass->chan_id[a]= chan_id[a];
rpass->rect= rect;
}
/* from imbuf, if a handle was returned we convert this to render result */
RenderResult *RE_MultilayerConvert(void *exrhandle, int rectx, int recty)
{
RenderResult *rr= MEM_callocN(sizeof(RenderResult), "loaded render result");
RenderLayer *rl;
RenderPass *rpass;
rr->rectx= rectx;
rr->recty= recty;
IMB_exr_multilayer_convert(exrhandle, rr, ml_addlayer_cb, ml_addpass_cb);
for(rl=rr->layers.first; rl; rl=rl->next) {
rl->rectx= rectx;
rl->recty= recty;
for(rpass=rl->passes.first; rpass; rpass=rpass->next) {
rpass->rectx= rectx;
rpass->recty= recty;
}
}
return rr;
}
/* called in end of render, to add names to passes... for UI only */
static void renderresult_add_names(RenderResult *rr)
{
RenderLayer *rl;
RenderPass *rpass;
for(rl= rr->layers.first; rl; rl= rl->next)
for(rpass= rl->passes.first; rpass; rpass= rpass->next)
BLI_strncpy(rpass->name, get_pass_name(rpass->passtype, -1),
sizeof(rpass->name));
}
/* called for reading temp files, and for external engines */
static int read_render_result_from_file(const char *filename, RenderResult *rr)
{
RenderLayer *rl;
RenderPass *rpass;
void *exrhandle= IMB_exr_get_handle();
int rectx, recty;
if(IMB_exr_begin_read(exrhandle, filename, &rectx, &recty)==0) {
printf("failed being read %s\n", filename);
IMB_exr_close(exrhandle);
return 0;
}
if(rr == NULL || rectx!=rr->rectx || recty!=rr->recty) {
if(rr)
printf("error in reading render result: dimensions don't match\n");
else
printf("error in reading render result: NULL result pointer\n");
IMB_exr_close(exrhandle);
return 0;
}
else {
for(rl= rr->layers.first; rl; rl= rl->next) {
/* combined */
if(rl->rectf) {
int a, xstride= 4;
for(a=0; a<xstride; a++)
IMB_exr_set_channel(exrhandle,
rl->name, get_pass_name(SCE_PASS_COMBINED, a),
xstride, xstride*rectx, rl->rectf+a);
}
/* passes are allocated in sync */
for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
int a, xstride= rpass->channels;
for(a=0; a<xstride; a++)
IMB_exr_set_channel(exrhandle,
rl->name, get_pass_name(rpass->passtype, a),
xstride, xstride*rectx, rpass->rect+a);
}
}
IMB_exr_read_channels(exrhandle);
renderresult_add_names(rr);
}
IMB_exr_close(exrhandle);
return 1;
}
/* only for temp buffer files, makes exact copy of render result */
static void read_render_result(Render *re, int sample)
{
char str[FILE_MAX];
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
RE_FreeRenderResult(re->result);
re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
render_unique_exr_name(re, str, sample);
printf("read exr tmp file: %s\n", str);
if(!read_render_result_from_file(str, re->result))
printf("cannot read: %s\n", str);
BLI_rw_mutex_unlock(&re->resultmutex);
}
/* *************************************************** */
Render *RE_GetRender(const char *name)
{
Render *re;
/* search for existing renders */
for(re= RenderGlobal.renderlist.first; re; re= re->next)
if(strncmp(re->name, name, RE_MAXNAME)==0)
break;
return re;
}
/* if you want to know exactly what has been done */
RenderResult *RE_AcquireResultRead(Render *re)
{
if(re) {
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ);
return re->result;
}
return NULL;
}
RenderResult *RE_AcquireResultWrite(Render *re)
{
if(re) {
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
return re->result;
}
return NULL;
}
void RE_SwapResult(Render *re, RenderResult **rr)
{
/* for keeping render buffers */
if(re) {
SWAP(RenderResult*, re->result, *rr);
}
}
void RE_ReleaseResult(Render *re)
{
if(re)
BLI_rw_mutex_unlock(&re->resultmutex);
}
/* displist.c util.... */
Scene *RE_GetScene(Render *re)
{
if(re)
return re->scene;
return NULL;
}
RenderLayer *render_get_active_layer(Render *re, RenderResult *rr)
{
RenderLayer *rl= BLI_findlink(&rr->layers, re->r.actlay);
if(rl)
return rl;
else
return rr->layers.first;
}
/* fill provided result struct with what's currently active or done */
void RE_AcquireResultImage(Render *re, RenderResult *rr)
{
memset(rr, 0, sizeof(RenderResult));
if(re) {
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ);
if(re->result) {
RenderLayer *rl;
rr->rectx= re->result->rectx;
rr->recty= re->result->recty;
rr->rectf= re->result->rectf;
rr->rectz= re->result->rectz;
rr->rect32= re->result->rect32;
/* active layer */
rl= render_get_active_layer(re, re->result);
if(rl) {
if(rr->rectf==NULL)
rr->rectf= rl->rectf;
if(rr->rectz==NULL)
rr->rectz=
RE_RenderLayerGetPass(rl, SCE_PASS_Z);
}
rr->have_combined= (re->result->rectf != NULL);
rr->layers= re->result->layers;
}
}
}
void RE_ReleaseResultImage(Render *re)
{
if(re)
BLI_rw_mutex_unlock(&re->resultmutex);
}
/* caller is responsible for allocating rect in correct size! */
void RE_ResultGet32(Render *re, unsigned int *rect)
{
RenderResult rres;
RE_AcquireResultImage(re, &rres);
if(rres.rect32)
memcpy(rect, rres.rect32, sizeof(int)*rres.rectx*rres.recty);
else if(rres.rectf) {
float *fp= rres.rectf;
int tot= rres.rectx*rres.recty;
char *cp= (char *)rect;
if (re->r.color_mgt_flag & R_COLOR_MANAGEMENT) {
/* Finally convert back to sRGB rendered image */
for(;tot>0; tot--, cp+=4, fp+=4) {
cp[0] = FTOCHAR(linearrgb_to_srgb(fp[0]));
cp[1] = FTOCHAR(linearrgb_to_srgb(fp[1]));
cp[2] = FTOCHAR(linearrgb_to_srgb(fp[2]));
cp[3] = FTOCHAR(fp[3]);
}
}
else {
/* Color management is off : no conversion necessary */
for(;tot>0; tot--, cp+=4, fp+=4) {
cp[0] = FTOCHAR(fp[0]);
cp[1] = FTOCHAR(fp[1]);
cp[2] = FTOCHAR(fp[2]);
cp[3] = FTOCHAR(fp[3]);
}
}
}
else
/* else fill with black */
memset(rect, 0, sizeof(int)*re->rectx*re->recty);
RE_ReleaseResultImage(re);
}
RenderStats *RE_GetStats(Render *re)
{
return &re->i;
}
Render *RE_NewRender(const char *name)
{
Render *re;
/* only one render per name exists */
re= RE_GetRender(name);
if(re==NULL) {
/* new render data struct */
re= MEM_callocN(sizeof(Render), "new render");
BLI_addtail(&RenderGlobal.renderlist, re);
strncpy(re->name, name, RE_MAXNAME);
BLI_rw_mutex_init(&re->resultmutex);
}
RE_InitRenderCB(re);
/* init some variables */
re->ycor= 1.0f;
return re;
}
/* called for new renders and when finishing rendering so
* we calways have valid callbacks on a render */
void RE_InitRenderCB(Render *re)
{
/* set default empty callbacks */
re->display_init= result_nothing;
re->display_clear= result_nothing;
re->display_draw= result_rcti_nothing;
re->progress= float_nothing;
re->test_break= default_break;
re->error= print_error;
if(G.background)
re->stats_draw= stats_background;
else
re->stats_draw= stats_nothing;
/* clear callback handles */
re->dih= re->dch= re->ddh= re->sdh= re->prh= re->tbh= re->erh= NULL;
}
/* only call this while you know it will remove the link too */
void RE_FreeRender(Render *re)
{
BLI_rw_mutex_end(&re->resultmutex);
free_renderdata_tables(re);
free_sample_tables(re);
RE_FreeRenderResult(re->result);
RE_FreeRenderResult(re->pushedresult);
BLI_remlink(&RenderGlobal.renderlist, re);
MEM_freeN(re);
}
/* exit blender */
void RE_FreeAllRender(void)
{
while(RenderGlobal.renderlist.first) {
RE_FreeRender(RenderGlobal.renderlist.first);
}
}
/* ********* initialize state ******** */
/* what doesn't change during entire render sequence */
/* disprect is optional, if NULL it assumes full window render */
void RE_InitState(Render *re, Render *source, RenderData *rd, SceneRenderLayer *srl, int winx, int winy, rcti *disprect)
{
re->ok= TRUE; /* maybe flag */
re->i.starttime= PIL_check_seconds_timer();
re->r= *rd; /* hardcopy */
re->winx= winx;
re->winy= winy;
if(disprect) {
re->disprect= *disprect;
re->rectx= disprect->xmax-disprect->xmin;
re->recty= disprect->ymax-disprect->ymin;
}
else {
re->disprect.xmin= re->disprect.ymin= 0;
re->disprect.xmax= winx;
re->disprect.ymax= winy;
re->rectx= winx;
re->recty= winy;
}
if(re->rectx < 2 || re->recty < 2 || (BKE_imtype_is_movie(rd->imtype) &&
(re->rectx < 16 || re->recty <
16) )) {
re->error(re->erh, "Image too small");
re->ok= 0;
return;
}
if((re->r.mode & (R_OSA))==0)
re->r.scemode &= ~R_FULL_SAMPLE;
#ifdef WITH_OPENEXR
if(re->r.scemode & R_FULL_SAMPLE)
re->r.scemode |= R_EXR_TILE_FILE; /* enable automatic */
/* Until use_border is made compatible with
save_buffers/full_sample, render without the later instead of not
rendering at all.*/
if(re->r.mode & R_BORDER)
{
re->r.scemode &= ~(R_EXR_TILE_FILE|R_FULL_SAMPLE);
}
#else
/* can't do this without openexr support */
re->r.scemode &= ~(R_EXR_TILE_FILE|R_FULL_SAMPLE);
#endif
/* fullsample wants uniform osa levels */
if(source && (re->r.scemode & R_FULL_SAMPLE)) {
/* but, if source has no full sample we disable it */
if((source->r.scemode & R_FULL_SAMPLE)==0)
re->r.scemode &= ~R_FULL_SAMPLE;
else
re->r.osa= re->osa= source->osa;
}
else {
/* check state variables, osa? */
if(re->r.mode & (R_OSA)) {
re->osa= re->r.osa;
if(re->osa>16) re->osa= 16;
}
else re->osa= 0;
}
if (srl) {
int index = BLI_findindex(&re->r.layers, srl);
if (index != -1) {
re->r.actlay = index;
re->r.scemode |= R_SINGLE_LAYER;
}
}
/* always call, checks for gamma, gamma tables and jitter too */
make_sample_tables(re);
/* if preview render, we try to keep old result */
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(re->r.scemode & R_PREVIEWBUTS) {
if(re->result &&
re->result->rectx==re->rectx &&
re->result->recty==re->recty);
else {
RE_FreeRenderResult(re->result);
re->result= NULL;
}
}
else {
/* make empty render result, so display callbacks can initialize */
RE_FreeRenderResult(re->result);
re->result= MEM_callocN(sizeof(RenderResult), "new render result");
re->result->rectx= re->rectx;
re->result->recty= re->recty;
}
BLI_rw_mutex_unlock(&re->resultmutex);
/* we clip faces with a minimum of 2 pixel boundary outside of image border. see zbuf.c */
re->clipcrop= 1.0f + 2.0f/(float)(re->winx>re->winy?re->winy:re->winx);
re->mblur_offs = re->field_offs = 0.f;
RE_init_threadcount(re);
}
/* part of external api, not called for regular render pipeline */
void RE_SetDispRect (struct Render *re, rcti *disprect)
{
re->disprect= *disprect;
re->rectx= disprect->xmax-disprect->xmin;
re->recty= disprect->ymax-disprect->ymin;
/* initialize render result */
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
RE_FreeRenderResult(re->result);
re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
BLI_rw_mutex_unlock(&re->resultmutex);
}
void RE_SetWindow(Render *re, rctf *viewplane, float clipsta, float clipend)
{
/* re->ok flag? */
re->viewplane= *viewplane;
re->clipsta= clipsta;
re->clipend= clipend;
re->r.mode &= ~R_ORTHO;
perspective_m4( re->winmat,re->viewplane.xmin,
re->viewplane.xmax, re->viewplane.ymin, re->viewplane.ymax,
re->clipsta, re->clipend);
}
void RE_SetOrtho(Render *re, rctf *viewplane, float clipsta, float clipend)
{
/* re->ok flag? */
re->viewplane= *viewplane;
re->clipsta= clipsta;
re->clipend= clipend;
re->r.mode |= R_ORTHO;
orthographic_m4(
re->winmat,re->viewplane.xmin, re->viewplane.xmax,
re->viewplane.ymin, re->viewplane.ymax, re->clipsta,
re->clipend);
}
void RE_SetView(Render *re, float mat[][4])
{
/* re->ok flag? */
copy_m4_m4(re->viewmat, mat);
invert_m4_m4(re->viewinv, re->viewmat);
}
/* image and movie output has to move to either imbuf or kernel */
void RE_display_init_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr))
{
re->display_init= f;
re->dih= handle;
}
void RE_display_clear_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr))
{
re->display_clear= f;
re->dch= handle;
}
void RE_display_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr, volatile rcti *rect))
{
re->display_draw= f;
re->ddh= handle;
}
void RE_stats_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderStats *rs))
{
re->stats_draw= f;
re->sdh= handle;
}
void RE_progress_cb(Render *re, void *handle, void (*f)(void *handle, float))
{
re->progress= f;
re->prh= handle;
}
void RE_draw_lock_cb(Render *re, void *handle, void (*f)(void *handle, int i))
{
re->draw_lock= f;
re->tbh= handle;
}
void RE_test_break_cb(Render *re, void *handle, int (*f)(void *handle))
{
re->test_break= f;
re->tbh= handle;
}
void RE_error_cb(Render *re, void *handle, void (*f)(void *handle, const char *str))
{
re->error= f;
re->erh= handle;
}
/* ********* add object data (later) ******** */
/* object is considered fully prepared on correct time etc */
/* includes lights */
void RE_AddObject(Render *UNUSED(re), Object *UNUSED(ob))
{
}
/* *************************************** */
static int render_display_draw_enabled(Render *re)
{
/* don't show preprocess for previewrender sss */
if(re->sss_points)
return !(re->r.scemode & R_PREVIEWBUTS);
else
return 1;
}
/* allocate osa new results for samples */
static RenderResult *new_full_sample_buffers(Render *re, ListBase *lb, rcti *partrct, int crop)
{
int a;
if(re->osa==0)
return new_render_result(re, partrct, crop, RR_USEMEM);
for(a=0; a<re->osa; a++) {
RenderResult *rr= new_render_result(re, partrct, crop, RR_USEMEM);
BLI_addtail(lb, rr);
rr->sample_nr= a;
}
return lb->first;
}
/* the main thread call, renders an entire part */
static void *do_part_thread(void *pa_v)
{
RenderPart *pa= pa_v;
/* need to return nicely all parts on esc */
if(R.test_break(R.tbh)==0) {
if(!R.sss_points && (R.r.scemode & R_FULL_SAMPLE))
pa->result=
new_full_sample_buffers(&R, &pa->fullresult,
&pa->disprect, pa->crop);
else
pa->result=
new_render_result(&R, &pa->disprect, pa->crop, RR_USEMEM);
if(R.sss_points)
zbufshade_sss_tile(pa);
else if(R.osa)
zbufshadeDA_tile(pa);
else
zbufshade_tile(pa);
/* merge too on break! */
if(R.result->exrhandle) {
RenderResult *rr, *rrpart;
for(rr=
R.result, rrpart= pa->result; rr && rrpart; rr= rr->next,
rrpart= rrpart->next)
save_render_result_tile(rr, rrpart);
}
else if(render_display_draw_enabled(&R)) {
/* on break, don't merge in result for preview renders, looks nicer */
if(R.test_break(R.tbh) && (R.r.scemode & R_PREVIEWBUTS));
else merge_render_result(R.result, pa->result);
}
}
pa->ready= 1;
return NULL;
}
static void *do_part_thread_wrapper(void* re_v)
{
Render* re = (Render*)re_v;
RenderPart *pa = NULL;
rctf viewplane= re->viewplane;
int minx = 0;
int mycounter;
while (re && !re->test_break(re->tbh))
{
BLI_lock_thread(LOCK_RENDER);
if(re->r.mode & R_PANORAMA)
{
pa= find_next_pano_slice(re, &minx, &viewplane);
}
else
{
pa= find_next_part(re, minx);
}
if (pa)
{
mycounter = counter;
pa->nr = mycounter;
counter ++;
}
BLI_unlock_thread(LOCK_RENDER);
CreateTiming("render thread[%d] begins new part...", mycounter);
if (pa && !re->test_break(re->tbh))
{
do_part_thread(pa);
}
else
{
// we need to quit... since no next part available...
break;
}
CreateTiming("render thread[%d] ends new part...", mycounter);
}
return NULL;
}
/* calculus for how much 1 pixel rendered should rotate the 3d geometry */
/* is not that simple, needs to be corrected for errors of larger viewplane sizes */
/* called in initrender.c, initparts() and convertblender.c, for speedvectors */
float panorama_pixel_rot(Render *re)
{
float psize, phi, xfac;
float borderfac= (float)(re->disprect.xmax - re->disprect.xmin) / (float)re->winx;
/* size of 1 pixel mapped to viewplane coords */
psize= (re->viewplane.xmax-re->viewplane.xmin)/(float)(re->winx);
/* angle of a pixel */
phi= atan(psize/re->clipsta);
/* correction factor for viewplane shifting, first calculate how much the viewplane angle is */
xfac= borderfac*((re->viewplane.xmax-re->viewplane.xmin))/(float)re->xparts;
xfac= atan(0.5f*xfac/re->clipsta);
/* and how much the same viewplane angle is wrapped */
psize= 0.5f*phi*((float)re->partx);
/* the ratio applied to final per-pixel angle */
phi*= xfac/psize;
return phi;
}
/* call when all parts stopped rendering, to find the next Y slice */
/* if slice found, it rotates the dbase */
static RenderPart *find_next_pano_slice(Render *re, int *minx, rctf *viewplane)
{
RenderPart *pa, *best= NULL;
*minx= re->winx;
/* most left part of the non-rendering parts */
for(pa= re->parts.first; pa; pa= pa->next) {
if(pa->ready==0 && pa->nr==0) {
if(pa->disprect.xmin < *minx) {
best= pa;
*minx= pa->disprect.xmin;
}
}
}
if(best) {
float phi= panorama_pixel_rot(re);
R.panodxp= (re->winx - (best->disprect.xmin + best->disprect.xmax) )/2;
R.panodxv= ((viewplane->xmax-viewplane->xmin)*R.panodxp)/(float)(re->winx);
/* shift viewplane */
R.viewplane.xmin = viewplane->xmin + R.panodxv;
R.viewplane.xmax = viewplane->xmax + R.panodxv;
RE_SetWindow(re, &R.viewplane, R.clipsta, R.clipend);
copy_m4_m4(R.winmat, re->winmat);
/* rotate database according to part coordinates */
project_renderdata(re, projectverto, 1, -R.panodxp*phi, 1);
R.panosi= sin(R.panodxp*phi);
R.panoco= cos(R.panodxp*phi);
}
return best;
}
#ifdef NICK_EDIT
static RenderPart *find_next_part(Render *re, int minx)
{
RenderPart *pa = NULL;
/* find center of rendered parts, image center counts for 1 too */
for(pa= re->parts.first; pa; pa= pa->next)
{
if(pa->nr == 0 && !pa->ready)
{
break;
}
}
return pa;
}
#else
static RenderPart *find_next_part(Render *re, int minx)
{
RenderPart *pa, *best= NULL;
/* long long int's needed because of overflow [#24414] */
long long int centx=re->winx/2, centy=re->winy/2, tot=1;
long long int mindist= (long long int)re->winx * (long long int)re->winy;
/* find center of rendered parts, image center counts for 1 too */
for(pa= re->parts.first; pa; pa= pa->next) {
if(pa->ready) {
centx+= (pa->disprect.xmin+pa->disprect.xmax)/2;
centy+= (pa->disprect.ymin+pa->disprect.ymax)/2;
tot++;
}
}
centx/=tot;
centy/=tot;
/* closest of the non-rendering parts */
for(pa= re->parts.first; pa; pa= pa->next) {
if(pa->ready==0 && pa->nr==0) {
long long int distx= centx -
(pa->disprect.xmin+pa->disprect.xmax)/2;
long long int disty= centy -
(pa->disprect.ymin+pa->disprect.ymax)/2;
distx= (long long int)sqrt(distx*distx + disty*disty);
if(distx<mindist) {
if(re->r.mode & R_PANORAMA) {
if(pa->disprect.xmin==minx) {
best= pa;
mindist= distx;
}
}
else {
best= pa;
mindist= distx;
}
}
}
}
return best;
}
#endif
static void print_part_stats(Render *re, RenderPart *pa)
{
char str[64];
BLI_snprintf(str, sizeof(str), "%s, Part %d-%d", re->scene->id.name+2, pa->nr, re->i.totpart);
re->i.infostr= str;
re->stats_draw(re->sdh, &re->i);
re->i.infostr= NULL;
}
/* make osa new results for samples */
static RenderResult *new_full_sample_buffers_exr(Render *re)
{
int a;
for(a=0; a<re->osa; a++) {
RenderResult *rr= new_render_result(re, &re->disprect, 0, 1);
BLI_addtail(&re->fullresult, rr);
rr->sample_nr= a;
}
return re->fullresult.first;
}
#ifdef NICK_EDIT
static void threaded_tile_processor(Render *re)
{
ListBase threads;
RenderPart *pa, *nextpa;
rctf viewplane= re->viewplane;
int rendering=1, drawtimer=0, hasdrawn, minx=0;
CreateTiming("begin comparison new:....");
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
/* first step; free the entire render result, make new, and/or prepare exr buffer saving */
if(re->result==NULL || !(re->r.scemode & R_PREVIEWBUTS)) {
RE_FreeRenderResult(re->result);
if(re->sss_points && render_display_draw_enabled(re))
re->result= new_render_result(re, &re->disprect, 0, 0);
else if(re->r.scemode & R_FULL_SAMPLE)
re->result= new_full_sample_buffers_exr(re);
else
re->result=
new_render_result(re, &re->disprect, 0, re->r.scemode &
(R_EXR_TILE_FILE|R_FULL_SAMPLE));
}
BLI_rw_mutex_unlock(&re->resultmutex);
if(re->result==NULL)
return;
/* warning; no return here without closing exr file */
initparts(re);
if(re->result->exrhandle) {
RenderResult *rr;
char str[FILE_MAX];
for(rr= re->result; rr; rr= rr->next) {
render_unique_exr_name(re, str, rr->sample_nr);
printf("write exr tmp file,
%dx%d, %s\n", rr->rectx, rr->recty, str);
IMB_exrtile_begin_write(rr->exrhandle, str, 0, rr->rectx,
rr->recty, re->partx, re->party);
}
}
BLI_init_threads(&threads, do_part_thread_wrapper, re->r.threads);
/* assuming no new data gets added to dbase... */
R= *re;
/* set threadsafe break */
R.test_break= thread_break;
/* timer loop demands to sleep when no parts are left, so we enter loop with a part */
counter = 1;
int i;
for (i = 0; i < re->r.threads; i ++)
{
BLI_insert_thread(&threads, re);
}
while(rendering)
{
/* on break, wait for all slots to get freed */
if(g_break = re->test_break(re->tbh))
{
PIL_sleep_ms(50);
// we don't want to draw anything at all.
hasdrawn= 1;
}
else
{
hasdrawn= 0;
}
/* check for ready ones to display, and if we need to continue */
// but even all parts are ready, we still have to
wait for all threads to exit gracefully...
// so, we just
rendering = 0;
for(pa= re->parts.first; pa; pa= pa->next)
{
if(pa->ready)
{
if(pa->result)
{
// a newly finished one will be drawn
immediately
if(render_display_draw_enabled(re) &&
!hasdrawn)
{
re->display_draw(re->ddh,
pa->result, NULL);
}
print_part_stats(re, pa);
free_render_result(&pa->fullresult,
pa->result);
pa->result= NULL;
re->i.partsdone++;
re->progress(re->prh, re->i.partsdone /
(float)re->i.totpart);
hasdrawn= 1;
}
}
else
{
// keep rendering...
rendering = 1;
if(pa->nr
&& pa->result && drawtimer>20 &&
!hasdrawn)
{
if(render_display_draw_enabled(re))
{
re->display_draw(re->ddh,
pa->result, &pa->result->renrect);
}
hasdrawn= 1;
}
}
}
if(hasdrawn)
{
drawtimer= 0;
}
drawtimer ++;
}
if(re->result->exrhandle)
{
RenderResult *rr;
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
save_empty_result_tiles(re);
for(rr= re->result; rr; rr= rr->next)
{
IMB_exr_close(rr->exrhandle);
rr->exrhandle= NULL;
}
free_render_result(&re->fullresult, re->result);
re->result= NULL;
BLI_rw_mutex_unlock(&re->resultmutex);
read_render_result(re, 0);
}
/* unset threadsafety */
g_break= 0;
BLI_end_threads(&threads);
freeparts(re);
re->viewplane= viewplane; /* restore viewplane, modified by pano render */
CreateTiming("end comparison new:....");
}
#else
static void threaded_tile_processor(Render *re)
{
ListBase threads;
RenderPart *pa, *nextpa;
rctf viewplane= re->viewplane;
int rendering=1, counter= 1, drawtimer=0, hasdrawn, minx=0;
CreateTiming("begin comparison old:....");
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
/* first step; free the entire render result, make new, and/or prepare exr buffer saving */
if(re->result==NULL || !(re->r.scemode & R_PREVIEWBUTS)) {
RE_FreeRenderResult(re->result);
if(re->sss_points && render_display_draw_enabled(re))
re->result= new_render_result(re, &re->disprect, 0, 0);
else if(re->r.scemode & R_FULL_SAMPLE)
re->result= new_full_sample_buffers_exr(re);
else
re->result=
new_render_result(re, &re->disprect, 0, re->r.scemode &
(R_EXR_TILE_FILE|R_FULL_SAMPLE));
}
BLI_rw_mutex_unlock(&re->resultmutex);
if(re->result==NULL)
return;
/* warning; no return here without closing exr file */
initparts(re);
if(re->result->exrhandle) {
RenderResult *rr;
char str[FILE_MAX];
for(rr= re->result; rr; rr= rr->next) {
render_unique_exr_name(re, str, rr->sample_nr);
printf("write exr tmp file,
%dx%d, %s\n", rr->rectx, rr->recty, str);
IMB_exrtile_begin_write(rr->exrhandle, str, 0, rr->rectx,
rr->recty, re->partx, re->party);
}
}
BLI_init_threads(&threads, do_part_thread, re->r.threads);
/* assuming no new data gets added to dbase... */
R= *re;
/* set threadsafe break */
R.test_break= thread_break;
/* timer loop demands to sleep when no parts are left, so we enter loop with a part */
if(re->r.mode & R_PANORAMA)
nextpa= find_next_pano_slice(re, &minx, &viewplane);
else
nextpa= find_next_part(re, 0);
while(rendering) {
if(re->test_break(re->tbh))
PIL_sleep_ms(50);
else if(nextpa && BLI_available_threads(&threads)) {
drawtimer= 0;
nextpa->nr=
counter++; /* for nicest part, and for stats */
nextpa->thread=
BLI_available_thread_index(&threads); /* sample
index */
BLI_insert_thread(&threads, nextpa);
nextpa= find_next_part(re, minx);
}
else if(re->r.mode & R_PANORAMA) {
if(nextpa==NULL &&
BLI_available_threads(&threads)==re->r.threads)
nextpa=
find_next_pano_slice(re, &minx, &viewplane);
else {
PIL_sleep_ms(50);
drawtimer++;
}
}
else {
PIL_sleep_ms(50);
drawtimer++;
}
/* check for ready ones to display, and if we need to continue */
rendering= 0;
hasdrawn= 0;
for(pa= re->parts.first; pa; pa= pa->next) {
if(pa->ready) {
BLI_remove_thread(&threads, pa);
if(pa->result) {
if(render_display_draw_enabled(re))
{
re->display_draw(re->ddh,
pa->result, NULL);
}
print_part_stats(re, pa);
free_render_result(&pa->fullresult,
pa->result);
pa->result= NULL;
re->i.partsdone++;
re->progress(re->prh, re->i.partsdone /
(float)re->i.totpart);
hasdrawn= 1;
}
}
else {
rendering= 1;
if(pa->nr
&& pa->result && drawtimer>20) {
if(render_display_draw_enabled(re))
{
re->display_draw(re->ddh,
pa->result, &pa->result->renrect);
}
hasdrawn= 1;
}
}
}
if(hasdrawn)
drawtimer= 0;
/* on break, wait for all slots to get freed */
if( (g_break=re->test_break(re->tbh))
&& BLI_available_threads(&threads)==re->r.threads)
rendering= 0;
}
if(re->result->exrhandle) {
RenderResult *rr;
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
save_empty_result_tiles(re);
for(rr= re->result; rr; rr= rr->next) {
IMB_exr_close(rr->exrhandle);
rr->exrhandle= NULL;
}
free_render_result(&re->fullresult, re->result);
re->result= NULL;
BLI_rw_mutex_unlock(&re->resultmutex);
read_render_result(re, 0);
}
/* unset threadsafety */
g_break= 0;
BLI_end_threads(&threads);
freeparts(re);
re->viewplane= viewplane; /* restore viewplane, modified by pano render */
CreateTiming("end comparison old:....");
}
#endif
/* currently only called by preview renders and envmap */
void RE_TileProcessor(Render *re)
{
threaded_tile_processor(re);
}
/* ************ This part uses API, for rendering Blender scenes ********** */
static int external_render_3d(Render *re, int do_all);
static void do_render_3d(Render *re)
{
/* try external */
if(external_render_3d(re, 0))
return;
/* internal */
// re->cfra= cfra; /* <- unused! */
re->scene->r.subframe = re->mblur_offs + re->field_offs;
/* lock drawing in UI during data phase */
if(re->draw_lock)
re->draw_lock(re->dlh, 1);
/* make render verts/faces/halos/lamps */
if(render_scene_needs_vector(re))
RE_Database_FromScene_Vectors(re, re->main, re->scene, re->lay);
else
RE_Database_FromScene(re, re->main, re->scene, re->lay, 1);
/* clear UI drawing locks */
if(re->draw_lock)
re->draw_lock(re->dlh, 0);
threaded_tile_processor(re);
/* do left-over 3d post effects (flares) */
if(re->flag & R_HALO)
if(!re->test_break(re->tbh))
add_halo_flare(re);
/* free all render verts etc */
RE_Database_Free(re);
re->scene->r.subframe = 0.f;
}
/* called by blur loop, accumulate RGBA key alpha */
static void addblur_rect_key(RenderResult *rr, float *rectf, float *rectf1, float blurfac)
{
float mfac= 1.0f - blurfac;
int a, b, stride= 4*rr->rectx;
int len= stride*sizeof(float);
for(a=0; a<rr->recty; a++) {
if(blurfac==1.0f) {
memcpy(rectf, rectf1, len);
}
else {
float *rf= rectf, *rf1= rectf1;
for( b= rr->rectx; b>0; b--, rf+=4, rf1+=4) {
if(rf1[3]<0.01f)
rf[3]= mfac*rf[3];
else if(rf[3]<0.01f) {
rf[0]= rf1[0];
rf[1]= rf1[1];
rf[2]= rf1[2];
rf[3]= blurfac*rf1[3];
}
else {
rf[0]= mfac*rf[0] +
blurfac*rf1[0];
rf[1]= mfac*rf[1] +
blurfac*rf1[1];
rf[2]= mfac*rf[2] +
blurfac*rf1[2];
rf[3]= mfac*rf[3] +
blurfac*rf1[3];
}
}
}
rectf+= stride;
rectf1+= stride;
}
}
/* called by blur loop, accumulate renderlayers */
static void addblur_rect(RenderResult *rr, float *rectf, float *rectf1, float blurfac, int channels)
{
float mfac= 1.0f - blurfac;
int a, b, stride= channels*rr->rectx;
int len= stride*sizeof(float);
for(a=0; a<rr->recty; a++) {
if(blurfac==1.0f) {
memcpy(rectf, rectf1, len);
}
else {
float *rf= rectf, *rf1= rectf1;
for( b= rr->rectx*channels; b>0; b--, rf++, rf1++) {
rf[0]= mfac*rf[0] + blurfac*rf1[0];
}
}
rectf+= stride;
rectf1+= stride;
}
}
/* called by blur loop, accumulate renderlayers */
static void merge_renderresult_blur(RenderResult *rr, RenderResult *brr, float blurfac, int key_alpha)
{
RenderLayer *rl, *rl1;
RenderPass *rpass, *rpass1;
rl1= brr->layers.first;
for(rl= rr->layers.first; rl && rl1; rl= rl->next, rl1= rl1->next) {
/* combined */
if(rl->rectf && rl1->rectf) {
if(key_alpha)
addblur_rect_key(rr, rl->rectf, rl1->rectf,
blurfac);
else
addblur_rect(rr, rl->rectf, rl1->rectf,
blurfac, 4);
}
/* passes are allocated in sync */
rpass1= rl1->passes.first;
for(rpass= rl->passes.first;
rpass && rpass1; rpass= rpass->next, rpass1=
rpass1->next) {
addblur_rect(rr, rpass->rect, rpass1->rect, blurfac,
rpass->channels);
}
}
}
/* main blur loop, can be called by fields too */
static void do_render_blur_3d(Render *re)
{
RenderResult *rres;
float blurfac;
int blur= re->r.mblur_samples;
/* create accumulation render result */
rres= new_render_result(re, &re->disprect, 0, RR_USEMEM);
/* do the blur steps */
while(blur--) {
re->mblur_offs =
re->r.blurfac*((float)(re->r.mblur_samples-blur))/(float)re->r.mblur_samples;
re->i.curblur= re->r.mblur_samples-blur; /* stats */
do_render_3d(re);
blurfac= 1.0f/(float)(re->r.mblur_samples-blur);
merge_renderresult_blur(rres,
re->result, blurfac, re->r.alphamode & R_ALPHAKEY);
if(re->test_break(re->tbh)) break;
}
/* swap results */
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
RE_FreeRenderResult(re->result);
re->result= rres;
BLI_rw_mutex_unlock(&re->resultmutex);
re->mblur_offs = 0.0f;
re->i.curblur= 0; /* stats */
/* weak... the display callback wants an active renderlayer pointer... */
re->result->renlay= render_get_active_layer(re, re->result);
re->display_draw(re->ddh, re->result, NULL);
}
/* function assumes rectf1 and rectf2 to be half size of rectf */
static void interleave_rect(RenderResult *rr, float *rectf, float *rectf1, float *rectf2, int channels)
{
int a, stride= channels*rr->rectx;
int len= stride*sizeof(float);
for(a=0; a<rr->recty; a+=2) {
memcpy(rectf, rectf1, len);
rectf+= stride;
rectf1+= stride;
memcpy(rectf, rectf2, len);
rectf+= stride;
rectf2+= stride;
}
}
/* merge render results of 2 fields */
static void merge_renderresult_fields(RenderResult *rr, RenderResult *rr1, RenderResult *rr2)
{
RenderLayer *rl, *rl1, *rl2;
RenderPass *rpass, *rpass1, *rpass2;
rl1= rr1->layers.first;
rl2= rr2->layers.first;
for(rl= rr->layers.first; rl && rl1
&& rl2; rl= rl->next, rl1= rl1->next, rl2= rl2->next) {
/* combined */
if(rl->rectf && rl1->rectf && rl2->rectf)
interleave_rect(rr, rl->rectf, rl1->rectf, rl2->rectf, 4);
/* passes are allocated in sync */
rpass1= rl1->passes.first;
rpass2= rl2->passes.first;
for(rpass= rl->passes.first;
rpass && rpass1 && rpass2; rpass= rpass->next,
rpass1= rpass1->next, rpass2= rpass2->next) {
interleave_rect(rr, rpass->rect, rpass1->rect, rpass2->rect,
rpass->channels);
}
}
}
/* interleaves 2 frames */
static void do_render_fields_3d(Render *re)
{
RenderResult *rr1, *rr2= NULL;
/* no render result was created, we can safely halve render y */
re->winy /= 2;
re->recty /= 2;
re->disprect.ymin /= 2;
re->disprect.ymax /= 2;
re->i.curfield= 1; /* stats */
/* first field, we have to call camera routine for correct aspect and subpixel offset */
RE_SetCamera(re, re->scene->camera);
if(re->r.mode & R_MBLUR && (re->r.scemode & R_FULL_SAMPLE)==0)
do_render_blur_3d(re);
else
do_render_3d(re);
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
rr1= re->result;
re->result= NULL;
BLI_rw_mutex_unlock(&re->resultmutex);
/* second field */
if(!re->test_break(re->tbh)) {
re->i.curfield= 2; /* stats */
re->flag |= R_SEC_FIELD;
if((re->r.mode & R_FIELDSTILL)==0) {
re->field_offs = 0.5f;
}
RE_SetCamera(re, re->scene->camera);
if(re->r.mode & R_MBLUR && (re->r.scemode & R_FULL_SAMPLE)==0)
do_render_blur_3d(re);
else
do_render_3d(re);
re->flag &= ~R_SEC_FIELD;
re->field_offs = 0.0f;
rr2= re->result;
}
/* allocate original height new buffers */
re->winy *= 2;
re->recty *= 2;
re->disprect.ymin *= 2;
re->disprect.ymax *= 2;
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
if(rr2) {
if(re->r.mode & R_ODDFIELD)
merge_renderresult_fields(re->result, rr2, rr1);
else
merge_renderresult_fields(re->result, rr1, rr2);
RE_FreeRenderResult(rr2);
}
RE_FreeRenderResult(rr1);
re->i.curfield= 0; /* stats */
/* weak... the display callback wants an active renderlayer pointer... */
re->result->renlay= render_get_active_layer(re, re->result);
BLI_rw_mutex_unlock(&re->resultmutex);
re->display_draw(re->ddh, re->result, NULL);
}
static void load_backbuffer(Render *re)
{
if(re->r.alphamode == R_ADDSKY) {
ImBuf *ibuf;
char name[256];
BLI_strncpy(name, re->r.backbuf, sizeof(name));
BLI_path_abs(name, re->main->name);
BLI_path_frame(name, re->r.cfra, 0);
if(re->backbuf) {
re->backbuf->id.us--;
if(re->backbuf->id.us<1)
BKE_image_signal(re->backbuf, NULL,
IMA_SIGNAL_RELOAD);
}
re->backbuf= BKE_add_image_file(name);
ibuf= BKE_image_get_ibuf(re->backbuf, NULL);
if(ibuf==NULL) {
// error() doesnt work with render window open
//error("No backbuf there!");
printf("Error: No backbuf %s\n", name);
}
else {
if (re->r.mode & R_FIELDS)
image_de_interlace(re->backbuf, re->r.mode
& R_ODDFIELD);
}
}
}
/* main render routine, no compositing */
static void do_render_fields_blur_3d(Render *re)
{
/* also check for camera here */
if(re->scene->camera==NULL) {
printf("ERROR: Cannot render, no camera\n");
G.afbreek= 1;
return;
}
/* backbuffer initialize */
if(re->r.bufflag & 1)
load_backbuffer(re);
/* now use renderdata and camera to set viewplane */
RE_SetCamera(re, re->scene->camera);
if(re->r.mode & R_FIELDS)
do_render_fields_3d(re);
else if(re->r.mode & R_MBLUR && (re->r.scemode & R_FULL_SAMPLE)==0)
do_render_blur_3d(re);
else
do_render_3d(re);
/* when border render, check if we have to insert it in black */
if(re->result) {
if(re->r.mode & R_BORDER) {
if((re->r.mode & R_CROP)==0) {
RenderResult *rres;
BLI_rw_mutex_lock(&re->resultmutex,
THREAD_LOCK_WRITE);
/* sub-rect for merge call later on */
re->result->tilerect= re->disprect;
/* this copying sequence could become function? */
/* weak is: it chances disprect from border */
re->disprect.xmin= re->disprect.ymin= 0;
re->disprect.xmax= re->winx;
re->disprect.ymax= re->winy;
re->rectx= re->winx;
re->recty= re->winy;
rres= new_render_result(re, &re->disprect, 0,
RR_USEMEM);
merge_render_result(rres, re->result);
RE_FreeRenderResult(re->result);
re->result= rres;
/* weak... the display callback wants an active
renderlayer pointer... */
re->result->renlay=
render_get_active_layer(re, re->result);
BLI_rw_mutex_unlock(&re->resultmutex);
re->display_init(re->dih, re->result);
re->display_draw(re->ddh, re->result, NULL);
}
else {
/* set offset (again) for use in compositor,
disprect was manipulated. */
re->result->xof= 0;
re->result->yof= 0;
}
}
}
}
/* within context of current Render *re, render another scene.
it uses current render image size and disprect, but doesn't execute composite
*/
static void render_scene(Render *re, Scene *sce, int cfra)
{
Render *resc= RE_NewRender(sce->id.name);
int winx= re->winx, winy= re->winy;
sce->r.cfra= cfra;
scene_camera_switch_update(sce);
/* exception: scene uses own size (unfinished code) */
if(0) {
winx= (sce->r.size*sce->r.xsch)/100;
winy= (sce->r.size*sce->r.ysch)/100;
}
/* initial setup */
RE_InitState(resc, re, &sce->r, NULL, winx, winy, &re->disprect);
/* still unsure entity this... */
resc->main= re->main;
resc->scene= sce;
resc->lay= sce->lay;
/* ensure scene has depsgraph, base flags etc OK */
set_scene_bg(re->main, sce);
/* copy callbacks */
resc->display_draw= re->display_draw;
resc->ddh= re->ddh;
resc->test_break= re->test_break;
resc->tbh= re->tbh;
resc->stats_draw= re->stats_draw;
resc->sdh= re->sdh;
do_render_fields_blur_3d(resc);
}
static void tag_scenes_for_render(Render *re)
{
bNode *node;
Scene *sce;
for(sce= re->main->scene.first; sce; sce= sce->id.next)
sce->id.flag &= ~LIB_DOIT;
re->scene->id.flag |= LIB_DOIT;
if(re->scene->nodetree==NULL) return;
/* check for render-layers nodes using other scenes, we tag them LIB_DOIT */
for(node= re->scene->nodetree->nodes.first; node; node= node->next) {
if(node->type==CMP_NODE_R_LAYERS) {
if(node->id) {
if(node->id != (ID *)re->scene)
node->id->flag |= LIB_DOIT;
}
}
}
}
static void ntree_render_scenes(Render *re)
{
bNode *node;
int cfra= re->scene->r.cfra;
int restore_scene= 0;
if(re->scene->nodetree==NULL) return;
tag_scenes_for_render(re);
/* now foreach render-result node tagged we do a full render */
/* results are stored in a way compisitor will find it */
for(node= re->scene->nodetree->nodes.first; node; node= node->next) {
if(node->type==CMP_NODE_R_LAYERS) {
if(node->id && node->id != (ID *)re->scene) {
if(node->id->flag & LIB_DOIT) {
Scene *scene =
(Scene*)node->id;
render_scene(re, scene, cfra);
restore_scene= (scene !=
re->scene);
node->id->flag &=
~LIB_DOIT;
}
}
}
}
/* restore scene if we rendered another last */
if(restore_scene)
set_scene_bg(re->main, re->scene);
}
/* helper call to detect if theres a composite with render-result node */
static int composite_needs_render(Scene *sce)
{
bNodeTree *ntree= sce->nodetree;
bNode *node;
if(ntree==NULL) return 1;
if(sce->use_nodes==0) return 1;
if((sce->r.scemode & R_DOCOMP)==0) return 1;
for(node= ntree->nodes.first; node; node= node->next) {
if(node->type==CMP_NODE_R_LAYERS)
if(node->id==NULL || node->id==&sce->id)
return 1;
}
return 0;
}
/* bad call... need to think over proper method still */
static void render_composit_stats(void *UNUSED(arg), char *str)
{
R.i.infostr= str;
R.stats_draw(R.sdh, &R.i);
R.i.infostr= NULL;
}
/* reads all buffers, calls optional composite, merges in first result->rectf */
static void do_merge_fullsample(Render *re, bNodeTree *ntree)
{
float *rectf, filt[3][3];
int sample;
/* filtmask needs it */
R= *re;
/* we accumulate in here */
rectf= MEM_mapallocN(re->rectx*re->recty*sizeof(float)*4, "fullsample rgba");
for(sample=0; sample<re->r.osa; sample++) {
RenderResult rres;
int x, y, mask;
/* set all involved renders on the samplebuffers (first was done by render itself) */
/* also function below assumes this */
if(sample) {
Render *re1;
tag_scenes_for_render(re);
for(re1= RenderGlobal.renderlist.first; re1; re1= re1->next) {
if(re1->scene->id.flag & LIB_DOIT) {
if(re1->r.scemode &
R_FULL_SAMPLE) {
read_render_result(re1, sample);
ntreeCompositTagRender(re1->scene); /* ensure node gets exec to put
buffers on stack */
}
}
}
}
/* composite */
if(ntree) {
ntreeCompositTagRender(re->scene);
ntreeCompositTagAnimated(ntree);
ntreeCompositExecTree(ntree, &re->r, G.background==0);
}
/* ensure we get either composited result or the active layer */
RE_AcquireResultImage(re, &rres);
/* accumulate with filter, and clip */
mask= (1<<sample);
mask_array(mask, filt);
for(y=0; y<re->recty; y++) {
float *rf= rectf + 4*y*re->rectx;
float *col= rres.rectf + 4*y*re->rectx;
for(x=0; x<re->rectx; x++, rf+=4, col+=4) {
/* clamping to 1.0 is needed for correct AA */
if(col[0]<0.0f) col[0]=0.0f; else if(col[0] >
1.0f) col[0]= 1.0f;
if(col[1]<0.0f) col[1]=0.0f; else if(col[1] >
1.0f) col[1]= 1.0f;
if(col[2]<0.0f) col[2]=0.0f; else if(col[2] >
1.0f) col[2]= 1.0f;
add_filt_fmask_coord(filt, col, rf, re->rectx,
re->recty, x, y);
}
}
RE_ReleaseResultImage(re);
/* show stuff */
if(sample!=re->osa-1) {
/* weak... the
display callback wants an active renderlayer pointer... */
re->result->renlay= render_get_active_layer(re, re->result);
re->display_draw(re->ddh, re->result, NULL);
}
if(re->test_break(re->tbh))
break;
}
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(re->result->rectf)
MEM_freeN(re->result->rectf);
re->result->rectf= rectf;
BLI_rw_mutex_unlock(&re->resultmutex);
}
/* called externally, via compositor */
void RE_MergeFullSample(Render *re, Main *bmain, Scene *sce, bNodeTree *ntree)
{
Scene *scene;
bNode *node;
/* default start situation */
G.afbreek= 0;
re->main= bmain;
re->scene= sce;
/* first call RE_ReadRenderResult on every renderlayer scene. this creates Render structs */
/* tag scenes unread */
for(scene= re->main->scene.first; scene; scene= scene->id.next)
scene->id.flag |= LIB_DOIT;
for(node= ntree->nodes.first; node; node= node->next) {
if(node->type==CMP_NODE_R_LAYERS) {
Scene *nodescene= (Scene *)node->id;
if(nodescene==NULL) nodescene= sce;
if(nodescene->id.flag & LIB_DOIT) {
nodescene->r.mode |= R_OSA; /*
render struct needs tables */
RE_ReadRenderResult(sce, nodescene);
nodescene->id.flag &= ~LIB_DOIT;
}
}
}
/* own render result should be read/allocated */
if(re->scene->id.flag & LIB_DOIT)
RE_ReadRenderResult(re->scene, re->scene);
/* and now we can draw (result is there) */
re->display_init(re->dih, re->result);
re->display_clear(re->dch, re->result);
do_merge_fullsample(re, ntree);
}
/* returns fully composited render-result on given time step (in RenderData) */
static void do_render_composite_fields_blur_3d(Render *re)
{
bNodeTree *ntree= re->scene->nodetree;
int update_newframe=0;
/* INIT seeding, compositor can use random texture */
BLI_srandom(re->r.cfra);
if(composite_needs_render(re->scene)) {
/* save memory... free all cached images */
ntreeFreeCache(ntree);
do_render_fields_blur_3d(re);
} else {
/* scene render process already updates animsys */
update_newframe = 1;
}
/* swap render result */
if(re->r.scemode & R_SINGLE_LAYER)
pop_render_result(re);
if(!re->test_break(re->tbh)) {
if(ntree) {
ntreeCompositTagRender(re->scene);
ntreeCompositTagAnimated(ntree);
}
if(ntree && re->r.scemode & R_DOCOMP) {
/* checks if there are render-result nodes that need scene */
if((re->r.scemode & R_SINGLE_LAYER)==0)
ntree_render_scenes(re);
if(!re->test_break(re->tbh)) {
ntree->stats_draw= render_composit_stats;
ntree->test_break= re->test_break;
ntree->progress= re->progress;
ntree->sdh= re->sdh;
ntree->tbh= re->tbh;
ntree->prh= re->prh;
/* in case it was never initialized */
R.sdh= re->sdh;
R.stats_draw= re->stats_draw;
if (update_newframe)
scene_update_for_newframe(re->main, re->scene, re->lay);
if(re->r.scemode & R_FULL_SAMPLE)
do_merge_fullsample(re, ntree);
else {
ntreeCompositExecTree(ntree,
&re->r, G.background==0);
}
ntree->stats_draw= NULL;
ntree->test_break= NULL;
ntree->progress= NULL;
ntree->tbh= ntree->sdh= ntree->prh= NULL;
}
}
else if(re->r.scemode & R_FULL_SAMPLE)
do_merge_fullsample(re, NULL);
}
/* weak... the display callback wants an active renderlayer pointer... */
re->result->renlay= render_get_active_layer(re, re->result);
re->display_draw(re->ddh, re->result, NULL);
}
static void renderresult_stampinfo(Scene *scene)
{
RenderResult rres;
Render *re= RE_GetRender(scene->id.name);
/* this is the basic trick to get the displayed float or char rect from render result */
RE_AcquireResultImage(re, &rres);
BKE_stamp_buf(scene, (unsigned char *)rres.rect32, rres.rectf, rres.rectx, rres.recty, 4);
RE_ReleaseResultImage(re);
}
static int seq_render_active(Render *re)
{
Editing *ed;
Sequence *seq;
ed = re->scene->ed;
if (!(re->r.scemode & R_DOSEQ) || !ed || !ed->seqbase.first)
return 0;
for (seq= ed->seqbase.first; seq; seq= seq->next) {
if (seq->type != SEQ_SOUND)
return 1;
}
return 0;
}
static void do_render_seq(Render * re)
{
static int recurs_depth = 0;
struct ImBuf *ibuf;
RenderResult *rr; /* don't assign re->result here as it might change during give_ibuf_seq */
int cfra = re->r.cfra;
SeqRenderData context;
re->i.cfra= cfra;
if(recurs_depth==0) {
/* otherwise sequencer animation isnt updated */
BKE_animsys_evaluate_all_animation(re->main, (float)cfra); // XXX,
was BKE_curframe(re->scene)
}
recurs_depth++;
context = seq_new_render_data(re->main, re->scene,
re->result->rectx, re->result->recty,
100);
ibuf = give_ibuf_seq(context, cfra, 0);
recurs_depth--;
rr = re->result;
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(ibuf) {
if(ibuf->rect_float) {
if (!rr->rectf)
rr->rectf=
MEM_mallocN(4*sizeof(float)*rr->rectx*rr->recty, "render_seq
rectf");
/* color
management: when off ensure rectf is non-lin, since thats what the
internal
* render engine delivers */
if(re->r.color_mgt_flag & R_COLOR_MANAGEMENT) {
if(ibuf->profile == IB_PROFILE_LINEAR_RGB)
memcpy(rr->rectf,
ibuf->rect_float, 4*sizeof(float)*rr->rectx*rr->recty);
else
srgb_to_linearrgb_rgba_rgba_buf(rr->rectf, ibuf->rect_float,
rr->rectx*rr->recty);
}
else {
if(ibuf->profile != IB_PROFILE_LINEAR_RGB)
memcpy(rr->rectf,
ibuf->rect_float, 4*sizeof(float)*rr->rectx*rr->recty);
else
linearrgb_to_srgb_rgba_rgba_buf(rr->rectf, ibuf->rect_float,
rr->rectx*rr->recty);
}
/* TSK! Since
sequence render doesn't free the *rr render result, the old rect32
can hang around when sequence render has rendered a 32 bits one before
*/
if(rr->rect32) {
MEM_freeN(rr->rect32);
rr->rect32= NULL;
}
}
else if(ibuf->rect) {
if (!rr->rect32)
rr->rect32=
MEM_mallocN(sizeof(int)*rr->rectx*rr->recty, "render_seq rect");
memcpy(rr->rect32, ibuf->rect, 4*rr->rectx*rr->recty);
/* if (ibuf->zbuf) { */
/* if (R.rectz) freeN(R.rectz); */
/* R.rectz = BLI_dupallocN(ibuf->zbuf); */
/* } */
/* Same things
as above, old rectf can hang around from previous render. */
if(rr->rectf) {
MEM_freeN(rr->rectf);
rr->rectf= NULL;
}
}
if (recurs_depth == 0) { /* with nested scenes, only free on toplevel... */
Editing * ed = re->scene->ed;
if (ed) {
free_imbuf_seq(re->scene, &ed->seqbase,
TRUE, TRUE);
}
}
IMB_freeImBuf(ibuf);
}
else {
/* render result is delivered empty in most cases, nevertheless we handle all cases */
if (rr->rectf)
memset(rr->rectf, 0, 4*sizeof(float)*rr->rectx*rr->recty);
else if (rr->rect32)
memset(rr->rect32, 0, 4*rr->rectx*rr->recty);
else
rr->rect32=
MEM_callocN(sizeof(int)*rr->rectx*rr->recty, "render_seq rect");
}
BLI_rw_mutex_unlock(&re->resultmutex);
/* just in case this flag went missing at some point */
re->r.scemode |= R_DOSEQ;
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/* main loop: doing sequence + fields + blur + 3d render + compositing */
static void do_render_all_options(Render *re)
{
scene_camera_switch_update(re->scene);
re->i.starttime= PIL_check_seconds_timer();
/* ensure no images are in memory from previous animated sequences */
BKE_image_all_free_anim_ibufs(re->r.cfra);
if(external_render_3d(re, 1)) {
/* in this case external render overrides all */
}
else if(seq_render_active(re)) {
/* note: do_render_seq() frees rect32 when sequencer returns float images */
if(!re->test_break(re->tbh))
do_render_seq(re);
re->stats_draw(re->sdh, &re->i);
re->display_draw(re->ddh, re->result, NULL);
}
else {
do_render_composite_fields_blur_3d(re);
}
/* for UI only */
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
renderresult_add_names(re->result);
BLI_rw_mutex_unlock(&re->resultmutex);
re->i.lastframetime= PIL_check_seconds_timer()- re->i.starttime;
re->stats_draw(re->sdh, &re->i);
/* stamp image info here */
if((re->r.stamp & R_STAMP_ALL) && (re->r.stamp & R_STAMP_DRAW)) {
renderresult_stampinfo(re->scene);
re->display_draw(re->ddh, re->result, NULL);
}
}
static int check_valid_camera(Scene *scene)
{
int check_comp= 1;
if (scene->camera == NULL)
scene->camera= scene_find_camera(scene);
if(scene->r.scemode&R_DOSEQ) {
if(scene->ed) {
Sequence *seq= scene->ed->seqbase.first;
check_comp= 0;
while(seq) {
if(seq->type == SEQ_SCENE) {
if(!seq->scene_camera) {
if(!seq->scene->camera &&
!scene_find_camera(seq->scene)) {
if(seq->scene == scene) {
/* for current scene camera could
be unneeded due to compisite nodes */
check_comp= 1;
} else {
/* for other scenes camera is
necessary */
return 0;
}
}
}
}
seq= seq->next;
}
}
}
if(check_comp) { /* no sequencer or sequencer depends on compositor */
if(scene->r.scemode&R_DOCOMP && scene->use_nodes) {
bNode *node= scene->nodetree->nodes.first;
while(node) {
if(node->type == CMP_NODE_R_LAYERS) {
Scene *sce= node->id ?
(Scene*)node->id : scene;
if(!sce->camera &&
!scene_find_camera(sce)) {
/* all render
layers nodes need camera */
return 0;
}
}
node= node->next;
}
} else return scene->camera != NULL;
}
return 1;
}
int RE_is_rendering_allowed(Scene *scene, void *erh, void (*error)(void *handle, const char *str))
{
SceneRenderLayer *srl;
if(scene->r.mode & R_BORDER) {
if(scene->r.border.xmax <= scene->r.border.xmin ||
scene->r.border.ymax <= scene->r.border.ymin) {
error(erh, "No border area selected.");
return 0;
}
}
if(scene->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) {
char str[FILE_MAX];
scene_unique_exr_name(scene, str, 0);
if (BLI_is_writable(str)==0) {
error(erh, "Can not save render buffers, check the temp default path");
return 0;
}
/* no fullsample and edge */
if((scene->r.scemode & R_FULL_SAMPLE) && (scene->r.mode & R_EDGE)) {
error(erh, "Full Sample doesn't support Edge Enhance");
return 0;
}
}
else
scene->r.scemode &= ~R_FULL_SAMPLE; /* clear to be sure */
if(scene->r.scemode & R_DOCOMP) {
if(scene->use_nodes) {
bNodeTree *ntree= scene->nodetree;
bNode *node;
if(ntree==NULL) {
error(erh, "No Nodetree in Scene");
return 0;
}
for(node= ntree->nodes.first; node; node= node->next)
if(node->type==CMP_NODE_COMPOSITE)
break;
if(node==NULL) {
error(erh, "No Render Output Node in Scene");
return 0;
}
if(scene->r.scemode & R_FULL_SAMPLE) {
if(composite_needs_render(scene)==0) {
error(erh, "Full Sample AA not
supported without 3d rendering");
return 0;
}
}
}
}
/* check valid camera, without camera render is OK (compo, seq) */
if(!check_valid_camera(scene)) {
error(erh, "No camera");
return 0;
}
/* get panorama & ortho, only after camera is set */
object_camera_mode(&scene->r, scene->camera);
/* forbidden combinations */
if(scene->r.mode & R_PANORAMA) {
if(scene->r.mode & R_ORTHO) {
error(erh, "No Ortho render possible for Panorama");
return 0;
}
}
/* layer flag tests */
if(scene->r.scemode & R_SINGLE_LAYER) {
srl= BLI_findlink(&scene->r.layers, scene->r.actlay);
/* force layer to be enabled */
srl->layflag &= ~SCE_LAY_DISABLE;
}
for(srl= scene->r.layers.first; srl; srl= srl->next)
if(!(srl->layflag & SCE_LAY_DISABLE))
break;
if(srl==NULL) {
error(erh, "All RenderLayers are disabled");
return 0;
}
/* renderer */
if(!ELEM(scene->r.renderer, R_INTERN, R_YAFRAY)) {
error(erh, "Unknown render engine set");
return 0;
}
return 1;
}
static void validate_render_settings(Render *re)
{
if(re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) {
/* no osa + fullsample won't work... */
if(re->r.osa==0)
re->r.scemode &= ~R_FULL_SAMPLE;
} else re->r.scemode &= ~R_FULL_SAMPLE; /* clear to be sure */
}
static void update_physics_cache(Render *re, Scene *scene, int UNUSED(anim_init))
{
PTCacheBaker baker;
baker.main = re->main;
baker.scene = scene;
baker.pid = NULL;
baker.bake = 0;
baker.render = 1;
baker.anim_init = 1;
baker.quick_step = 1;
baker.break_test = re->test_break;
baker.break_data = re->tbh;
baker.progressbar = NULL;
BKE_ptcache_bake(&baker);
}
/* evaluating scene options for general Blender render */
static int render_initialize_from_main(Render *re, Main *bmain, Scene
*scene, SceneRenderLayer *srl, unsigned int lay, int anim, int
anim_init)
{
int winx, winy;
rcti disprect;
/* r.xsch and r.ysch has the actual view window size
r.border is the clipping rect */
/* calculate actual render result and display size */
winx= (scene->r.size*scene->r.xsch)/100;
winy= (scene->r.size*scene->r.ysch)/100;
/* we always render smaller part, inserting it in larger image is compositor bizz, it uses disprect for it */
if(scene->r.mode & R_BORDER) {
disprect.xmin= scene->r.border.xmin*winx;
disprect.xmax= scene->r.border.xmax*winx;
disprect.ymin= scene->r.border.ymin*winy;
disprect.ymax= scene->r.border.ymax*winy;
}
else {
disprect.xmin= disprect.ymin= 0;
disprect.xmax= winx;
disprect.ymax= winy;
}
re->main= bmain;
re->scene= scene;
re->lay= lay;
/* not too nice, but it survives anim-border render */
if(anim) {
re->disprect= disprect;
return 1;
}
/* check all scenes involved */
tag_scenes_for_render(re);
/*
* Disabled completely for now,
* can be later set as render profile option
* and default for background render.
*/
if(0) {
/* make sure dynamics are up to date */
update_physics_cache(re, scene, anim_init);
}
if(srl || scene->r.scemode & R_SINGLE_LAYER)
push_render_result(re);
RE_InitState(re, NULL, &scene->r, srl, winx, winy, &disprect);
if(!re->ok) /* if an error was printed, abort */
return 0;
/* initstate makes new result, have to send changed tags around */
ntreeCompositTagRender(re->scene);
validate_render_settings(re);
re->display_init(re->dih, re->result);
re->display_clear(re->dch, re->result);
return 1;
}
/* general Blender frame render call */
void RE_BlenderFrame(Render *re, Main *bmain, Scene *scene,
SceneRenderLayer *srl, unsigned int lay, int frame, const short
write_still)
{
/* ugly global still... is to prevent preview events and signal subsurfs etc to make full resol */
G.rendering= 1;
scene->r.cfra= frame;
if(render_initialize_from_main(re, bmain, scene, srl, lay, 0, 0)) {
MEM_reset_peak_memory();
do_render_all_options(re);
if(write_still && !G.afbreek) {
if(BKE_imtype_is_movie(scene->r.imtype)) {
/* operator checks this but incase its called from
elsewhere */
printf("Error: cant write single images with a movie
format!\n");
}
else {
char name[FILE_MAX];
BKE_makepicstring(name, scene->r.pic,
scene->r.cfra, scene->r.imtype, scene->r.scemode &
R_EXTENSION, FALSE);
/* reports only used for Movie */
do_write_image_or_movie(re, scene, NULL, NULL, name);
}
}
}
/* UGLY WARNING */
G.rendering= 0;
}
static int do_write_image_or_movie(Render *re, Scene *scene, bMovieHandle *mh, ReportList *reports, const char *name_override)
{
char name[FILE_MAX];
RenderResult rres;
int ok= 1;
RE_AcquireResultImage(re, &rres);
/* write movie or image */
if(BKE_imtype_is_movie(scene->r.imtype)) {
int dofree = 0;
/* note; the way it gets 32 bits rects is weak... */
if(rres.rect32==NULL) {
rres.rect32=
MEM_mapallocN(sizeof(int)*rres.rectx*rres.recty, "temp 32 bits rect");
dofree = 1;
}
RE_ResultGet32(re, (unsigned int *)rres.rect32);
ok=
mh->append_movie(&re->r, scene->r.cfra, rres.rect32,
rres.rectx, rres.recty, reports);
if(dofree) {
MEM_freeN(rres.rect32);
}
printf("Append frame %d", scene->r.cfra);
}
else {
if(name_override)
BLI_strncpy(name, name_override, sizeof(name));
else
BKE_makepicstring(name, scene->r.pic, scene->r.cfra,
scene->r.imtype, scene->r.scemode & R_EXTENSION, TRUE);
if(re->r.imtype==R_MULTILAYER) {
if(re->result) {
RE_WriteRenderResult(re->result, name,
scene->r.quality);
printf("Saved: %s", name);
}
}
else {
ImBuf *ibuf=
IMB_allocImBuf(rres.rectx, rres.recty, scene->r.planes, 0);
/* if not exists, BKE_write_ibuf makes one */
ibuf->rect= (unsigned int *)rres.rect32;
ibuf->rect_float= rres.rectf;
ibuf->zbuf_float= rres.rectz;
/* float factor for random dither, imbuf takes care of it */
ibuf->dither= scene->r.dither_intensity;
/* prepare to gamma correct to sRGB color space */
if (scene->r.color_mgt_flag & R_COLOR_MANAGEMENT) {
/* sequence editor can generate 8bpc render buffers
*/
if (ibuf->rect) {
ibuf->profile =
IB_PROFILE_SRGB;
if (ELEM(scene->r.imtype,
R_OPENEXR, R_RADHDR))
IMB_float_from_rect(ibuf);
} else {
ibuf->profile =
IB_PROFILE_LINEAR_RGB;
}
}
ok=
BKE_write_ibuf(scene, ibuf, name, scene->r.imtype,
scene->r.subimtype, scene->r.quality);
if(ok==0) {
printf("Render error: cannot save %s\n", name);
}
else printf("Saved: %s", name);
/* optional preview images for exr */
if(ok
&& scene->r.imtype==R_OPENEXR &&
(scene->r.subimtype & R_PREVIEW_JPG)) {
if(BLI_testextensie(name, ".exr"))
name[strlen(name)-4]= 0;
BKE_add_image_extension(name, R_JPEG90);
ibuf->depth= 24;
BKE_write_ibuf(scene, ibuf, name, R_JPEG90,
scene->r.subimtype, scene->r.quality);
printf("\nSaved: %s", name);
}
/* imbuf knows which rects are
not part of ibuf */
IMB_freeImBuf(ibuf);
}
}
RE_ReleaseResultImage(re);
BLI_timestr(re->i.lastframetime, name);
printf(" Time: %s\n", name);
fflush(stdout); /* needed for renderd !! (not anymore... (ton)) */
return ok;
}
/* saves images to disk */
void RE_BlenderAnim(Render *re, Main *bmain, Scene *scene, unsigned int lay, int sfra, int efra, int tfra, ReportList *reports)
{
bMovieHandle *mh= BKE_get_movie_handle(scene->r.imtype);
int cfrao= scene->r.cfra;
int nfra;
/* do not fully call for each frame, it initializes & pops output window */
if(!render_initialize_from_main(re, bmain, scene, NULL, lay, 0, 1))
return;
/* ugly global still... is to prevent renderwin events and signal subsurfs etc to make full resol */
/* is also set by caller renderwin.c */
G.rendering= 1;
if(BKE_imtype_is_movie(scene->r.imtype))
if(!mh->start_movie(scene, &re->r, re->rectx, re->recty, reports))
G.afbreek= 1;
if (mh->get_next_frame) {
while (!(G.afbreek == 1)) {
int nf = mh->get_next_frame(&re->r, reports);
if (nf >= 0
&& nf >= scene->r.sfra && nf <=
scene->r.efra) {
scene->r.cfra = re->r.cfra = nf;
do_render_all_options(re);
if(re->test_break(re->tbh) == 0) {
if(!do_write_image_or_movie(re,
scene, mh, reports, NULL))
G.afbreek= 1;
}
} else {
if(re->test_break(re->tbh))
G.afbreek= 1;
}
}
} else {
for(nfra= sfra, scene->r.cfra= sfra; scene->r.cfra<=efra; scene->r.cfra++) {
char name[FILE_MAX];
/* only border now, todo: camera lens. (ton) */
render_initialize_from_main(re, bmain, scene, NULL, lay, 1, 0);
if(nfra!=scene->r.cfra) {
/*
* Skip this frame, but update for physics and
particles system.
* From convertblender.c:
* in localview, lamps are using normal layers,
objects only local bits.
*/
unsigned int updatelay;
if(re->lay & 0xFF000000)
updatelay= re->lay &
0xFF000000;
else
updatelay= re->lay;
scene_update_for_newframe(bmain, scene, updatelay);
continue;
}
else
nfra+= tfra;
/* Touch/NoOverwrite options are only valid for image's */
if(BKE_imtype_is_movie(scene->r.imtype) == 0) {
if(scene->r.mode & (R_NO_OVERWRITE | R_TOUCH))
BKE_makepicstring(name,
scene->r.pic, scene->r.cfra, scene->r.imtype,
scene->r.scemode & R_EXTENSION, TRUE);
if(scene->r.mode & R_NO_OVERWRITE &&
BLI_exist(name)) {
printf("skipping existing frame
\"%s\"\n", name);
continue;
}
if(scene->r.mode & R_TOUCH &&
!BLI_exist(name)) {
BLI_make_existing_file(name); /*
makes the dir if its not there */
BLI_touch(name);
}
}
re->r.cfra=
scene->r.cfra; /* weak.... */
do_render_all_options(re);
if(re->test_break(re->tbh) == 0) {
if(!G.afbreek)
if(!do_write_image_or_movie(re,
scene, mh, reports, NULL))
G.afbreek= 1;
}
else
G.afbreek= 1;
if(G.afbreek==1) {
/* remove touched file */
if(BKE_imtype_is_movie(scene->r.imtype) == 0) {
if (scene->r.mode &
R_TOUCH && BLI_exist(name) && BLI_filepathsize(name) ==
0) {
BLI_delete(name, 0, 0);
}
}
break;
}
}
}
/* end movie */
if(BKE_imtype_is_movie(scene->r.imtype))
mh->end_movie();
scene->r.cfra= cfrao;
/* UGLY WARNING */
G.rendering= 0;
}
void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
{
int winx, winy;
winx= (sce->r.size*sce->r.xsch)/100;
winy= (sce->r.size*sce->r.ysch)/100;
RE_InitState(re, NULL, &sce->r, NULL, winx, winy, NULL);
re->main = bmain;
re->scene = sce;
re->lay = sce->lay;
RE_SetCamera(re, sce->camera);
do_render_3d(re);
}
/* note; repeated win/disprect calc... solve that nicer, also in compo */
/* only the temp file! */
void RE_ReadRenderResult(Scene *scene, Scene *scenode)
{
Render *re;
int winx, winy;
rcti disprect;
/* calculate actual render result and display size */
winx= (scene->r.size*scene->r.xsch)/100;
winy= (scene->r.size*scene->r.ysch)/100;
/* only in movie case we render smaller part */
if(scene->r.mode & R_BORDER) {
disprect.xmin= scene->r.border.xmin*winx;
disprect.xmax= scene->r.border.xmax*winx;
disprect.ymin= scene->r.border.ymin*winy;
disprect.ymax= scene->r.border.ymax*winy;
}
else {
disprect.xmin= disprect.ymin= 0;
disprect.xmax= winx;
disprect.ymax= winy;
}
if(scenode)
scene= scenode;
/* get render: it can be called from UI with draw callbacks */
re= RE_GetRender(scene->id.name);
if(re==NULL)
re= RE_NewRender(scene->id.name);
RE_InitState(re, NULL, &scene->r, NULL, winx, winy, &disprect);
re->scene= scene;
read_render_result(re, 0);
}
void RE_set_max_threads(int threads)
{
if (threads==0) {
RenderGlobal.threads = BLI_system_thread_count();
} else if(threads>=1 && threads<=BLENDER_MAX_THREADS) {
RenderGlobal.threads= threads;
} else {
printf("Error, threads has to be in range 0-%d\n", BLENDER_MAX_THREADS);
}
}
void RE_init_threadcount(Render *re)
{
if(RenderGlobal.threads >= 1) { /* only set as an arg in background mode */
re->r.threads= MIN2(RenderGlobal.threads, BLENDER_MAX_THREADS);
} else if ((re->r.mode & R_FIXED_THREADS)==0 || RenderGlobal.threads == 0) { /* Automatic threads */
re->r.threads = BLI_system_thread_count();
}
}
/************************** External Engines ***************************/
RenderResult *RE_engine_begin_result(RenderEngine *engine, int x, int y, int w, int h)
{
Render *re= engine->re;
RenderResult *result;
rcti disprect;
/* ensure the coordinates are within the right limits */
CLAMP(x, 0, re->result->rectx);
CLAMP(y, 0, re->result->recty);
CLAMP(w, 0, re->result->rectx);
CLAMP(h, 0, re->result->recty);
if(x + w > re->result->rectx)
w= re->result->rectx - x;
if(y + h > re->result->recty)
h= re->result->recty - y;
/* allocate a render result */
disprect.xmin= x;
disprect.xmax= x+w;
disprect.ymin= y;
disprect.ymax= y+h;
if(0) { // XXX (re->r.scemode & R_FULL_SAMPLE)) {
result= new_full_sample_buffers(re, &engine->fullresult, &disprect, 0);
}
else {
result= new_render_result(re, &disprect, 0, RR_USEMEM);
BLI_addtail(&engine->fullresult, result);
}
return result;
}
void RE_engine_update_result(RenderEngine *engine, RenderResult *result)
{
Render *re= engine->re;
if(result && render_display_draw_enabled(re)) {
result->renlay= result->layers.first; // weak
re->display_draw(re->ddh, result, NULL);
}
}
void RE_engine_end_result(RenderEngine *engine, RenderResult *result)
{
Render *re= engine->re;
if(!result)
return;
/* merge */
if(re->result->exrhandle) {
RenderResult *rr, *rrpart;
// XXX crashes, exr expects very particular part sizes
for(rr= re->result, rrpart=
result; rr && rrpart; rr= rr->next, rrpart= rrpart->next)
save_render_result_tile(rr, rrpart);
}
else if(render_display_draw_enabled(re)) {
/* on break, don't merge in result for preview renders, looks nicer */
if(re->test_break(re->tbh) && (re->r.scemode & R_PREVIEWBUTS));
else merge_render_result(re->result, result);
}
/* draw */
if(!re->test_break(re->tbh) && render_display_draw_enabled(re)) {
result->renlay= result->layers.first; // weak
re->display_draw(re->ddh, result, NULL);
}
/* free */
free_render_result(&engine->fullresult, result);
}
int RE_engine_test_break(RenderEngine *engine)
{
Render *re= engine->re;
return re->test_break(re->tbh);
}
void RE_engine_update_stats(RenderEngine *engine, const char *stats, const char *info)
{
Render *re= engine->re;
re->i.statstr= stats;
re->i.infostr= info;
re->stats_draw(re->sdh, &re->i);
re->i.infostr= NULL;
re->i.statstr= NULL;
}
/* loads in image into a result, size must match
* x/y offsets are only used on a partial copy when dimensions dont match */
void RE_layer_load_from_file(RenderLayer *layer, ReportList *reports, const char *filename, int x, int y)
{
ImBuf *ibuf = IMB_loadiffname(filename, IB_rect);
if(ibuf && (ibuf->rect || ibuf->rect_float)) {
if (ibuf->x == layer->rectx && ibuf->y == layer->recty) {
if(ibuf->rect_float==NULL)
IMB_float_from_rect(ibuf);
memcpy(layer->rectf, ibuf->rect_float,
sizeof(float)*4*layer->rectx*layer->recty);
} else {
if
((ibuf->x - x >= layer->rectx) && (ibuf->y - y
>= layer->recty)) {
ImBuf *ibuf_clip;
if(ibuf->rect_float==NULL)
IMB_float_from_rect(ibuf);
ibuf_clip = IMB_allocImBuf(layer->rectx,
layer->recty, 32, IB_rectfloat);
if(ibuf_clip) {
IMB_rectcpy(ibuf_clip, ibuf, 0,0,
x,y, layer->rectx, layer->recty);
memcpy(layer->rectf,
ibuf_clip->rect_float,
sizeof(float)*4*layer->rectx*layer->recty);
IMB_freeImBuf(ibuf_clip);
}
else {
BKE_reportf(reports, RPT_ERROR,
"RE_result_rect_from_file: failed to allocate clip buffer '%s'\n",
filename);
}
}
else {
BKE_reportf(reports, RPT_ERROR,
"RE_result_rect_from_file: incorrect dimensions for partial copy
'%s'\n", filename);
}
}
IMB_freeImBuf(ibuf);
}
else {
BKE_reportf(reports, RPT_ERROR,
"RE_result_rect_from_file: failed to load '%s'\n", filename);
}
}
void RE_result_load_from_file(RenderResult *result, ReportList *reports, const char *filename)
{
if(!read_render_result_from_file(filename, result)) {
BKE_reportf(reports, RPT_ERROR,
"RE_result_rect_from_file: failed to load '%s'\n", filename);
return;
}
}
static int external_render_3d(Render *re, int do_all)
{
RenderEngineType *type= BLI_findstring(&R_engines, re->r.engine, offsetof(RenderEngineType, idname));
RenderEngine engine;
if(!(type && type->render))
return 0;
if((re->r.scemode & R_PREVIEWBUTS) && !(type->flag & RE_DO_PREVIEW))
return 0;
if(do_all && !(type->flag & RE_DO_ALL))
return 0;
if(!do_all && (type->flag & RE_DO_ALL))
return 0;
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(re->result==NULL || !(re->r.scemode & R_PREVIEWBUTS)) {
RE_FreeRenderResult(re->result);
if(0) // XXX re->r.scemode & R_FULL_SAMPLE)
re->result= new_full_sample_buffers_exr(re);
else
re->result=
new_render_result(re, &re->disprect, 0, 0); // XXX
re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE));
}
BLI_rw_mutex_unlock(&re->resultmutex);
if(re->result==NULL)
return 1;
/* external */
memset(&engine, 0, sizeof(engine));
engine.type= type;
engine.re= re;
type->render(&engine, re->scene);
free_render_result(&engine.fullresult, engine.fullresult.first);
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
if(re->result->exrhandle) {
RenderResult *rr;
save_empty_result_tiles(re);
for(rr= re->result; rr; rr= rr->next) {
IMB_exr_close(rr->exrhandle);
rr->exrhandle= NULL;
}
free_render_result(&re->fullresult, re->result);
re->result= NULL;
read_render_result(re, 0);
}
BLI_rw_mutex_unlock(&re->resultmutex);
return 1;
}
filename: source/creator/creator.c
กก
/*
* $Id: creator.c 36276 2011-04-21 15:53:30Z campbellbarton $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file creator/creator.c
* \ingroup creator
*/
#if defined(__linux__) && defined(__GNUC__)
#define _GNU_SOURCE
#include <fenv.h>
#endif
#if (defined(__APPLE__) && (defined(__i386__) || defined(__x86_64__)))
#define OSX_SSE_FPE
#include <xmmintrin.h>
#endif
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
/* for setuid / getuid */
#ifdef __sgi
#include <sys/types.h>
#include <unistd.h>
#endif
/* This little block needed for linking to Blender... */
#include "MEM_guardedalloc.h"
#ifdef WIN32
#include "BLI_winstuff.h"
#endif
#include "BLI_args.h"
#include "BLI_threads.h"
#include "BLI_scanfill.h" // for BLI_setErrorCallBack, TODO, move elsewhere
#include "BLI_utildefines.h"
#include "DNA_ID.h"
#include "DNA_scene_types.h"
#include "BLI_blenlib.h"
#include "BKE_utildefines.h"
#include "BKE_blender.h"
#include "BKE_context.h"
#include "BKE_depsgraph.h" // for DAG_on_visible_update
#include "BKE_font.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_material.h"
#include "BKE_packedFile.h"
#include "BKE_scene.h"
#include "BKE_node.h"
#include "BKE_report.h"
#include "BKE_sound.h"
#include "IMB_imbuf.h" // for IMB_init
#ifdef WITH_PYTHON
#include "BPY_extern.h"
#endif
#include "RE_pipeline.h"
//XXX #include "playanim_ext.h"
#include "ED_datafiles.h"
#include "WM_api.h"
#include "RNA_define.h"
#include "GPU_draw.h"
#include "GPU_extensions.h"
#ifdef WITH_BUILDINFO_HEADER
#define BUILD_DATE
#endif
/* for passing information between creator and gameengine */
#ifdef WITH_GAMEENGINE
#include "GEN_messaging.h"
#include "SYS_System.h"
#else /* dummy */
#define SYS_SystemHandle int
#endif
#include <signal.h>
#ifdef __FreeBSD__
# include <sys/types.h>
# include <floatingpoint.h>
# include <sys/rtprio.h>
#endif
#ifdef WITH_BINRELOC
#include "binreloc.h"
#endif
// from buildinfo.c
#ifdef BUILD_DATE
extern char build_date[];
extern char build_time[];
extern char build_rev[];
extern char build_platform[];
extern char build_type[];
extern char build_cflags[];
extern char build_cxxflags[];
extern char build_linkflags[];
extern char build_system[];
#endif
/* Local Function prototypes */
static int print_help(int argc, const char **argv, void *data);
static int print_version(int argc, const char **argv, void *data);
/* for the callbacks: */
extern int pluginapi_force_ref(void); /* from blenpluginapi:pluginapi.c */
char bprogname[FILE_MAX]; /* from blenpluginapi:pluginapi.c */
char btempdir[FILE_MAX];
#define BLEND_VERSION_STRING_FMT "Blender %d.%02d (sub %d)\n", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION
/* Initialise callbacks for the modules that need them */
static void setCallbacks(void);
/* set breakpoints here when running in debug mode, useful to catch floating point errors */
#if defined(__sgi) || defined(__linux__) || defined(_WIN32) || defined(OSX_SSE_FPE)
static void fpe_handler(int UNUSED(sig))
{
// printf("SIGFPE trapped\n");
}
#endif
#ifndef WITH_PYTHON_MODULE
/* handling ctrl-c event in console */
static void blender_esc(int sig)
{
static int count = 0;
G.afbreek = 1; /* forces render loop to read queue, not sure if its needed */
if (sig == 2) {
if (count) {
printf("\nBlender killed\n");
exit(2);
}
printf("\nSent an internal break event. Press ^C again to kill Blender\n");
count++;
}
}
#endif
/* buildinfo can have quotes */
#ifdef BUILD_DATE
static void strip_quotes(char *str)
{
if(str[0] == '"') {
int len= strlen(str) - 1;
memmove(str, str+1, len);
if(str[len-1] == '"') {
str[len-1]= '\0';
}
}
}
#endif
static int print_version(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
printf (BLEND_VERSION_STRING_FMT);
#ifdef BUILD_DATE
printf ("\tbuild date: %s\n", build_date);
printf ("\tbuild time: %s\n", build_time);
printf ("\tbuild revision: %s\n", build_rev);
printf ("\tbuild platform: %s\n", build_platform);
printf ("\tbuild type: %s\n", build_type);
printf ("\tbuild c flags: %s\n", build_cflags);
printf ("\tbuild c++ flags: %s\n", build_cxxflags);
printf ("\tbuild link flags: %s\n", build_linkflags);
printf ("\tbuild system: %s\n", build_system);
#endif
exit(0);
return 0;
}
static int print_help(int UNUSED(argc), const char **UNUSED(argv), void *data)
{
bArgs *ba = (bArgs*)data;
printf (BLEND_VERSION_STRING_FMT);
printf ("Usage: blender [args ...] [file] [args ...]\n\n");
printf ("Render Options:\n");
BLI_argsPrintArgDoc(ba, "--background");
BLI_argsPrintArgDoc(ba, "--render-anim");
BLI_argsPrintArgDoc(ba, "--scene");
BLI_argsPrintArgDoc(ba, "--render-frame");
BLI_argsPrintArgDoc(ba, "--frame-start");
BLI_argsPrintArgDoc(ba, "--frame-end");
BLI_argsPrintArgDoc(ba, "--frame-jump");
BLI_argsPrintArgDoc(ba, "--render-output");
BLI_argsPrintArgDoc(ba, "--engine");
printf("\n");
printf ("Format Options:\n");
BLI_argsPrintArgDoc(ba, "--render-format");
BLI_argsPrintArgDoc(ba, "--use-extension");
BLI_argsPrintArgDoc(ba, "--threads");
printf("\n");
printf ("Animation Playback Options:\n");
BLI_argsPrintArgDoc(ba, "-a");
printf("\n");
printf ("Window Options:\n");
BLI_argsPrintArgDoc(ba, "--window-border");
BLI_argsPrintArgDoc(ba, "--window-borderless");
BLI_argsPrintArgDoc(ba, "--window-geometry");
BLI_argsPrintArgDoc(ba, "--start-console");
printf("\n");
printf ("Game Engine Specific Options:\n");
BLI_argsPrintArgDoc(ba, "-g");
printf("\n");
printf ("Misc Options:\n");
BLI_argsPrintArgDoc(ba, "--debug");
BLI_argsPrintArgDoc(ba, "--debug-fpe");
printf("\n");
BLI_argsPrintArgDoc(ba, "--factory-startup");
printf("\n");
BLI_argsPrintArgDoc(ba, "--env-system-config");
BLI_argsPrintArgDoc(ba, "--env-system-datafiles");
BLI_argsPrintArgDoc(ba, "--env-system-scripts");
BLI_argsPrintArgDoc(ba, "--env-system-plugins");
BLI_argsPrintArgDoc(ba, "--env-system-python");
printf("\n");
BLI_argsPrintArgDoc(ba, "-nojoystick");
BLI_argsPrintArgDoc(ba, "-noglsl");
BLI_argsPrintArgDoc(ba, "-noaudio");
BLI_argsPrintArgDoc(ba, "-setaudio");
printf("\n");
BLI_argsPrintArgDoc(ba, "--help");
printf("\n");
BLI_argsPrintArgDoc(ba, "--enable-autoexec");
BLI_argsPrintArgDoc(ba, "--disable-autoexec");
printf("\n");
BLI_argsPrintArgDoc(ba, "--python");
BLI_argsPrintArgDoc(ba, "--python-console");
BLI_argsPrintArgDoc(ba, "--addons");
#ifdef WIN32
BLI_argsPrintArgDoc(ba, "-R");
BLI_argsPrintArgDoc(ba, "-r");
#endif
BLI_argsPrintArgDoc(ba, "--version");
BLI_argsPrintArgDoc(ba, "--");
printf ("Other Options:\n");
BLI_argsPrintOtherDoc(ba);
printf ("Argument Parsing:\n");
printf ("\targuments must be separated by white space. eg\n");
printf ("\t\t\"blender -ba test.blend\"\n");
printf ("\t...will ignore the 'a'\n");
printf ("\t\t\"blender -b test.blend -f8\"\n");
printf ("\t...will ignore 8 because there is no space between the -f and the frame value\n\n");
printf ("Argument Order:\n");
printf ("Arguments are executed in the order they are given. eg\n");
printf ("\t\t\"blender --background test.blend --render-frame 1 --render-output /tmp\"\n");
printf ("\t...will not render to /tmp because '--render-frame 1' renders before the output path is set\n");
printf ("\t\t\"blender --background --render-output /tmp test.blend --render-frame 1\"\n");
printf ("\t...will not render to /tmp because
loading the blend file overwrites the render output that was set\n");
printf ("\t\t\"blender --background test.blend
--render-output /tmp --render-frame 1\" works as expected.\n\n");
printf ("\nEnvironment Variables:\n");
printf ("
$BLENDER_USER_CONFIG Directory for user
configuration files.\n");
printf (" $BLENDER_SYSTEM_CONFIG Directory for system wide configuration files.\n");
printf (" $BLENDER_USER_SCRIPTS Directory for user scripts.\n");
printf (" $BLENDER_SYSTEM_SCRIPTS Directory for system wide scripts.\n");
printf (" $BLENDER_USER_DATAFILES
Directory for user data files (icons, translations, ..).\n");
printf (" $BLENDER_SYSTEM_DATAFILES Directory for system wide data files.\n");
printf (" $BLENDER_SYSTEM_PYTHON Directory for system python libraries.\n");
#ifdef WIN32
printf ("
$TEMP
Store temporary files here.\n");
#else
printf (" $TMP or
$TMPDIR
Store temporary files here.\n");
#endif
#ifndef DISABLE_SDL
printf ("
$SDL_AUDIODRIVER
LibSDL audio driver - alsa, esd, dma.\n");
#endif
printf ("
$PYTHONHOME
Path to the python directory, eg. /usr/lib/python.\n\n");
exit(0);
return 0;
}
double PIL_check_seconds_timer(void);
/* XXX This was here to fix a crash when running python scripts
* with -P that used the screen.
*
* static void main_init_screen( void )
{
setscreen(G.curscreen);
if(G.main->scene.first==0) {
set_scene( add_scene("1") );
}
}*/
static int end_arguments(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
return -1;
}
static int enable_python(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
G.f |= G_SCRIPT_AUTOEXEC;
G.f |= G_SCRIPT_OVERRIDE_PREF;
return 0;
}
static int disable_python(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
G.f &= ~G_SCRIPT_AUTOEXEC;
G.f |= G_SCRIPT_OVERRIDE_PREF;
return 0;
}
static int background_mode(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
G.background = 1;
return 0;
}
static int debug_mode(int UNUSED(argc), const char **UNUSED(argv), void *data)
{
G.f |= G_DEBUG; /* std output printf's */
printf(BLEND_VERSION_STRING_FMT);
MEM_set_memory_debug();
#ifdef NAN_BUILDINFO
printf("Build: %s %s %s %s\n", build_date, build_time, build_platform, build_type);
#endif // NAN_BUILDINFO
BLI_argsPrint(data);
return 0;
}
static int set_fpe(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
#if defined(__sgi) || defined(__linux__) || defined(_WIN32) || defined(OSX_SSE_FPE)
/* zealous but makes float issues a heck of a lot easier to find!
* set breakpoints on fpe_handler */
signal(SIGFPE, fpe_handler);
# if defined(__linux__) && defined(__GNUC__)
feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW );
# endif /* defined(__linux__) && defined(__GNUC__) */
# if defined(OSX_SSE_FPE)
/* OSX uses SSE for floating point by default, so here
* use SSE instructions to throw floating point exceptions */
_MM_SET_EXCEPTION_MASK(_MM_MASK_MASK &~
(_MM_MASK_OVERFLOW|_MM_MASK_INVALID|_MM_MASK_DIV_ZERO));
# endif /* OSX_SSE_FPE */
# if defined(_WIN32) && defined(_MSC_VER)
_controlfp_s(NULL, 0, _MCW_EM); /* enables all fp exceptions */
_controlfp_s(NULL, _EM_DENORMAL | _EM_UNDERFLOW |
_EM_INEXACT, _MCW_EM); /* hide the ones we don't care about */
# endif /* _WIN32 && _MSC_VER */
#endif
return 0;
}
static int set_factory_startup(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
G.factory_startup= 1;
return 0;
}
static int set_env(int argc, const char **argv, void *UNUSED(data))
{
/* "--env-system-scripts" --> "BLENDER_SYSTEM_SCRIPTS" */
char env[64]= "BLENDER";
char *ch_dst= env + 7; /* skip BLENDER */
const char *ch_src= argv[0] + 5; /* skip --env */
if (argc < 2) {
printf("%s requires one argument\n", argv[0]);
exit(1);
}
for(; *ch_src; ch_src++, ch_dst++) {
*ch_dst= (*ch_src == '-') ? '_' : (*ch_src)-32; /* toupper() */
}
*ch_dst= '\0';
BLI_setenv(env, argv[1]);
return 1;
}
static int playback_mode(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
/* not if -b was given first */
if (G.background == 0) {
// XXX
playanim(argc, argv); /* not the same argc and argv
as before */
exit(0);
}
return -2;
}
static int prefsize(int argc, const char **argv, void *UNUSED(data))
{
int stax, stay, sizx, sizy;
if (argc < 5) {
printf ("-p requires four arguments\n");
exit(1);
}
stax= atoi(argv[1]);
stay= atoi(argv[2]);
sizx= atoi(argv[3]);
sizy= atoi(argv[4]);
WM_setprefsize(stax, stay, sizx, sizy);
return 4;
}
static int with_borders(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
WM_setinitialstate_normal();
return 0;
}
static int without_borders(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
WM_setinitialstate_fullscreen();
return 0;
}
extern int wm_start_with_console; // blender/windowmanager/intern/wm_init_exit.c
static int start_with_console(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
wm_start_with_console = 1;
return 0;
}
static int register_extension(int UNUSED(argc), const char **UNUSED(argv), void *data)
{
#ifdef WIN32
if (data)
G.background = 1;
RegisterBlendExtension();
#else
(void)data; /* unused */
#endif
return 0;
}
static int no_joystick(int UNUSED(argc), const char **UNUSED(argv), void *data)
{
#ifndef WITH_GAMEENGINE
(void)data;
#else
SYS_SystemHandle *syshandle = data;
/**
don't initialize joysticks if user doesn't want to use joysticks
failed joystick initialization delays over 5 seconds, before game engine start
*/
SYS_WriteCommandLineInt(*syshandle, "nojoystick",1);
if (G.f & G_DEBUG) printf("disabling nojoystick\n");
#endif
return 0;
}
static int no_glsl(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
GPU_extensions_disable();
return 0;
}
static int no_audio(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
sound_force_device(0);
return 0;
}
static int set_audio(int argc, const char **argv, void *UNUSED(data))
{
if (argc < 1) {
printf("-setaudio require one argument\n");
exit(1);
}
sound_force_device(sound_define_from_str(argv[1]));
return 1;
}
static int set_output(int argc, const char **argv, void *data)
{
bContext *C = data;
if (argc >= 1){
if (CTX_data_scene(C)) {
Scene *scene= CTX_data_scene(C);
BLI_strncpy(scene->r.pic, argv[1], FILE_MAXDIR);
} else {
printf("\nError: no blend loaded. cannot use '-o /
--render-output'.\n");
}
return 1;
} else {
printf("\nError: you must specify a path after '-o / --render-output'.\n");
return 0;
}
}
static int set_engine(int argc, const char **argv, void *data)
{
bContext *C = data;
if (argc >= 1)
{
if (!strcmp(argv[1],"help"))
{
RenderEngineType *type = NULL;
for( type = R_engines.first; type; type = type->next )
{
printf("\t%s\n", type->idname);
}
exit(0);
}
else
{
if (CTX_data_scene(C)==NULL)
{
printf("\nError: no blend loaded. order the
arguments so '-E / --engine ' is after a blend is loaded.\n");
}
else {
Scene *scene= CTX_data_scene(C);
RenderData *rd = &scene->r;
if(BLI_findstring(&R_engines, argv[1],
offsetof(RenderEngineType, idname))) {
BLI_strncpy(rd->engine,
argv[1], sizeof(rd->engine));
}
}
}
return 1;
}
else
{
printf("\nEngine not specified.\n");
return 0;
}
}
static int set_image_type(int argc, const char **argv, void *data)
{
bContext *C = data;
if (argc >= 1){
const char *imtype = argv[1];
if (CTX_data_scene(C)==NULL) {
printf("\nError: no blend loaded. order the arguments so '-F /
--render-format' is after the blend is loaded.\n");
} else {
Scene *scene= CTX_data_scene(C);
if (!strcmp(imtype,"TGA"))
scene->r.imtype = R_TARGA;
else if (!strcmp(imtype,"IRIS")) scene->r.imtype = R_IRIS;
#ifdef WITH_DDS
else if (!strcmp(imtype,"DDS")) scene->r.imtype = R_DDS;
#endif
else if (!strcmp(imtype,"JPEG")) scene->r.imtype = R_JPEG90;
else if (!strcmp(imtype,"IRIZ")) scene->r.imtype = R_IRIZ;
else if (!strcmp(imtype,"RAWTGA")) scene->r.imtype = R_RAWTGA;
else if (!strcmp(imtype,"AVIRAW")) scene->r.imtype = R_AVIRAW;
else if (!strcmp(imtype,"AVIJPEG")) scene->r.imtype = R_AVIJPEG;
else if (!strcmp(imtype,"PNG")) scene->r.imtype = R_PNG;
else if (!strcmp(imtype,"AVICODEC")) scene->r.imtype = R_AVICODEC;
else if (!strcmp(imtype,"QUICKTIME")) scene->r.imtype = R_QUICKTIME;
else if (!strcmp(imtype,"BMP")) scene->r.imtype = R_BMP;
#ifdef WITH_HDR
else if (!strcmp(imtype,"HDR")) scene->r.imtype = R_RADHDR;
#endif
#ifdef WITH_TIFF
else if (!strcmp(imtype,"TIFF")) scene->r.imtype = R_TIFF;
#endif
#ifdef WITH_OPENEXR
else if (!strcmp(imtype,"EXR")) scene->r.imtype = R_OPENEXR;
else if
(!strcmp(imtype,"MULTILAYER")) scene->r.imtype = R_MULTILAYER;
#endif
else if (!strcmp(imtype,"MPEG")) scene->r.imtype = R_FFMPEG;
else if
(!strcmp(imtype,"FRAMESERVER")) scene->r.imtype = R_FRAMESERVER;
#ifdef WITH_CINEON
else if (!strcmp(imtype,"CINEON")) scene->r.imtype = R_CINEON;
else if (!strcmp(imtype,"DPX")) scene->r.imtype = R_DPX;
#endif
#if WITH_OPENJPEG
else if (!strcmp(imtype,"JP2")) scene->r.imtype = R_JP2;
#endif
else
printf("\nError: Format from '-F / --render-format' not known or not
compiled in this release.\n");
}
return 1;
} else {
printf("\nError: you must specify a format after '-F / --render-foramt'.\n");
return 0;
}
}
static int set_threads(int argc, const char **argv, void *UNUSED(data))
{
if (argc >= 1) {
if(G.background) {
RE_set_max_threads(atoi(argv[1]));
} else {
printf("Warning: threads can only be set in background mode\n");
}
return 1;
} else {
printf("\nError: you must specify
a number of threads between 0 and 8 '-t / --threads'.\n");
return 0;
}
}
static int set_extension(int argc, const char **argv, void *data)
{
bContext *C = data;
if (argc >= 1) {
if (CTX_data_scene(C)) {
Scene *scene= CTX_data_scene(C);
if (argv[1][0] == '0') {
scene->r.scemode &= ~R_EXTENSION;
} else if (argv[1][0] == '1') {
scene->r.scemode |= R_EXTENSION;
} else {
printf("\nError: Use '-x 1 / -x 0' To set the
extension option or '--use-extension'\n");
}
} else {
printf("\nError: no blend loaded. order the arguments so '-o ' is after
'-x '.\n");
}
return 1;
} else {
printf("\nError: you must specify a path after '- '.\n");
return 0;
}
}
static int set_ge_parameters(int argc, const char **argv, void *data)
{
int a = 0;
#ifdef WITH_GAMEENGINE
SYS_SystemHandle syshandle = *(SYS_SystemHandle*)data;
#else
(void)data;
#endif
/**
gameengine parameters are automaticly put into system
-g [paramname = value]
-g [boolparamname]
example:
-g novertexarrays
-g maxvertexarraysize = 512
*/
if(argc >= 1)
{
const char *paramname = argv[a];
/* check for single value versus assignment */
if (a+1 < argc && (*(argv[a+1]) == '='))
{
a++;
if (a+1 < argc)
{
a++;
/* assignment */
#ifdef WITH_GAMEENGINE
SYS_WriteCommandLineString(syshandle,paramname,argv[a]);
#endif
} else
{
printf("error: argument assignment (%s) without
value.\n",paramname);
return 0;
}
/* name arg eaten */
} else {
#ifdef WITH_GAMEENGINE
SYS_WriteCommandLineInt(syshandle,argv[a],1);
#endif
/* doMipMap */
if (!strcmp(argv[a],"nomipmap"))
{
GPU_set_mipmap(0); //doMipMap = 0;
}
/* linearMipMap */
if (!strcmp(argv[a],"linearmipmap"))
{
GPU_set_linear_mipmap(1); //linearMipMap = 1;
}
} /* if (*(argv[a+1]) == '=') */
}
return a;
}
static int render_frame(int argc, const char **argv, void *data)
{
bContext *C = data;
if (CTX_data_scene(C)) {
Main *bmain= CTX_data_main(C);
Scene *scene= CTX_data_scene(C);
if (argc > 1) {
Render *re = RE_NewRender(scene->id.name);
int frame;
ReportList reports;
switch(*argv[1]) {
case '+':
frame= scene->r.sfra + atoi(argv[1]+1);
break;
case '-':
frame= (scene->r.efra - atoi(argv[1]+1)) + 1;
break;
default:
frame= atoi(argv[1]);
break;
}
BKE_reports_init(&reports, RPT_PRINT);
frame = MIN2(MAXFRAME, MAX2(MINAFRAME, frame));
RE_BlenderAnim(re, bmain, scene, scene->lay, frame, frame,
scene->r.frame_step, &reports);
return 1;
} else {
printf("\nError: frame number must follow '-f / --render-frame'.\n");
return 0;
}
} else {
printf("\nError: no blend loaded. cannot use '-f / --render-frame'.\n");
return 0;
}
}
static int render_animation(int UNUSED(argc), const char **UNUSED(argv), void *data)
{
bContext *C = data;
if (CTX_data_scene(C)) {
Main *bmain= CTX_data_main(C);
Scene *scene= CTX_data_scene(C);
Render *re= RE_NewRender(scene->id.name);
ReportList reports;
BKE_reports_init(&reports, RPT_PRINT);
RE_BlenderAnim(re, bmain, scene,
scene->lay, scene->r.sfra, scene->r.efra,
scene->r.frame_step, &reports);
} else {
printf("\nError: no blend loaded. cannot use '-a'.\n");
}
return 0;
}
static int set_scene(int argc, const char **argv, void *data)
{
if(argc > 1) {
bContext *C= data;
Scene *sce= set_scene_name(CTX_data_main(C), argv[1]);
if(sce) {
CTX_data_scene_set(C, sce);
}
return 1;
} else {
printf("\nError: Scene name must follow '-S / --scene'.\n");
return 0;
}
}
static int set_start_frame(int argc, const char **argv, void *data)
{
bContext *C = data;
if (CTX_data_scene(C)) {
Scene *scene= CTX_data_scene(C);
if (argc > 1) {
int frame = atoi(argv[1]);
(scene->r.sfra) = CLAMPIS(frame, MINFRAME, MAXFRAME);
return 1;
} else {
printf("\nError: frame number must follow '-s / --frame-start'.\n");
return 0;
}
} else {
printf("\nError: no blend loaded. cannot use '-s / --frame-start'.\n");
return 0;
}
}
static int set_end_frame(int argc, const char **argv, void *data)
{
bContext *C = data;
if (CTX_data_scene(C)) {
Scene *scene= CTX_data_scene(C);
if (argc > 1) {
int frame = atoi(argv[1]);
(scene->r.efra) = CLAMPIS(frame, MINFRAME, MAXFRAME);
return 1;
} else {
printf("\nError: frame number must follow '-e / --frame-end'.\n");
return 0;
}
} else {
printf("\nError: no blend loaded. cannot use '-e / --frame-end'.\n");
return 0;
}
}
static int set_skip_frame(int argc, const char **argv, void *data)
{
bContext *C = data;
if (CTX_data_scene(C)) {
Scene *scene= CTX_data_scene(C);
if (argc > 1) {
int frame = atoi(argv[1]);
(scene->r.frame_step) = CLAMPIS(frame, 1, MAXFRAME);
return 1;
} else {
printf("\nError: number of frames to step must follow '-j /
--frame-jump'.\n");
return 0;
}
} else {
printf("\nError: no blend loaded. cannot use '-j / --frame-jump'.\n");
return 0;
}
}
/* macro for ugly context setup/reset */
#ifdef WITH_PYTHON
#define BPY_CTX_SETUP(_cmd) \
{ \
wmWindowManager *wm= CTX_wm_manager(C); \
wmWindow *prevwin= CTX_wm_window(C); \
Scene *prevscene= CTX_data_scene(C); \
if(wm->windows.first) { \
CTX_wm_window_set(C, wm->windows.first); \
_cmd; \
CTX_wm_window_set(C, prevwin); \
} \
else { \
fprintf(stderr, "Python script \"%s\" running with missing context data.\n", argv[1]); \
_cmd; \
} \
CTX_data_scene_set(C, prevscene); \
} \
#endif /* WITH_PYTHON */
static int run_python(int argc, const char **argv, void *data)
{
#ifdef WITH_PYTHON
bContext *C = data;
/* workaround for scripts not getting a bpy.context.scene, causes internal errors elsewhere */
if (argc > 1) {
/* Make the path absolute because its needed for relative linked blends to be found */
char filename[FILE_MAXDIR + FILE_MAXFILE];
BLI_strncpy(filename, argv[1], sizeof(filename));
BLI_path_cwd(filename);
BPY_CTX_SETUP(BPY_filepath_exec(C, filename, NULL))
return 1;
} else {
printf("\nError: you must specify a Python script after '-P / --python'.\n");
return 0;
}
#else
(void)argc; (void)argv; (void)data; /* unused */
printf("This blender was built without python support\n");
return 0;
#endif /* WITH_PYTHON */
}
static int run_python_console(int UNUSED(argc), const char **argv, void *data)
{
#ifdef WITH_PYTHON
bContext *C = data;
BPY_CTX_SETUP(BPY_string_exec(C, "__import__('code').interact()"))
return 0;
#else
(void)argv; (void)data; /* unused */
printf("This blender was built without python support\n");
return 0;
#endif /* WITH_PYTHON */
}
static int set_addons(int argc, const char **argv, void *data)
{
/* workaround for scripts not getting a bpy.context.scene, causes internal errors elsewhere */
if (argc > 1) {
#ifdef WITH_PYTHON
const int slen= strlen(argv[1]) + 128;
char *str= malloc(slen);
bContext *C= data;
BLI_snprintf(str, slen,
"[__import__('addon_utils').enable(i, default_set=False) for i in
'%s'.split(',')]", argv[1]);
BPY_CTX_SETUP(BPY_string_exec(C, str));
free(str);
#else
(void)argv; (void)data; /* unused */
#endif /* WITH_PYTHON */
return 1;
}
else {
printf("\nError: you must specify a comma separated list after '--addons'.\n");
return 0;
}
}
static int load_file(int UNUSED(argc), const char **argv, void *data)
{
bContext *C = data;
/* Make the path absolute because its needed for relative linked blends to be found */
char filename[FILE_MAXDIR + FILE_MAXFILE];
BLI_strncpy(filename, argv[0], sizeof(filename));
BLI_path_cwd(filename);
if (G.background) {
int retval = BKE_read_file(C, filename, NULL);
/*we successfully loaded a blend file, get sure that
pointcache works */
if (retval != BKE_READ_FILE_FAIL) {
wmWindowManager *wm= CTX_wm_manager(C);
/* special case, 2.4x files */
if(wm==NULL && CTX_data_main(C)->wm.first==NULL) {
extern void wm_add_default(bContext *C);
/* wm_add_default() needs the screen to be set. */
CTX_wm_screen_set(C,
CTX_data_main(C)->screen.first);
wm_add_default(C);
}
CTX_wm_manager_set(C, NULL); /* remove wm to force check */
WM_check(C);
G.relbase_valid = 1;
if
(CTX_wm_manager(C) == NULL) CTX_wm_manager_set(C, wm); /* reset wm */
DAG_on_visible_update(CTX_data_main(C), TRUE);
}
/* WM_read_file() runs normally but since we're in background mode do here */
#ifdef WITH_PYTHON
/* run any texts that were loaded in and flagged as modules */
BPY_driver_reset();
BPY_modules_load_user(C);
#endif
/* happens for the UI on file reading too (huh? (ton))*/
// XXX BKE_reset_undo();
//
BKE_write_undo("original"); /* save current state */
} else {
/* we are not running in background mode here, but start blender in UI mode with
a file - this should do everything a 'load file' does */
ReportList reports;
BKE_reports_init(&reports, RPT_PRINT);
WM_read_file(C, filename, &reports);
BKE_reports_clear(&reports);
}
G.file_loaded = 1;
return 0;
}
static void setupArguments(bContext *C, bArgs *ba, SYS_SystemHandle *syshandle)
{
static char output_doc[] = "<path>"
"\n\tSet the render path and file name."
"\n\tUse // at the start of the path to"
"\n\t\trender relative to the blend file."
"\n\tThe # characters are replaced by the frame number, and used to define zero padding."
"\n\t\tani_##_test.png becomes ani_01_test.png"
"\n\t\ttest-######.png becomes test-000001.png"
"\n\t\tWhen the filename does not contain #, The suffix #### is added to the filename"
"\n\tThe frame number will be added at the end of the filename."
"\n\t\teg: blender -b foobar.blend -o //render_ -F PNG -x 1 -a"
"\n\t\t//render_ becomes //render_####, writing frames as //render_0001.png//";
static char format_doc[] = "<format>"
"\n\tSet the render format, Valid options are..."
"\n\t\tTGA IRIS JPEG MOVIE IRIZ RAWTGA"
"\n\t\tAVIRAW AVIJPEG PNG BMP FRAMESERVER"
"\n\t(formats that can be compiled into blender, not available on all systems)"
"\n\t\tHDR TIFF EXR MULTILAYER MPEG AVICODEC QUICKTIME CINEON DPX DDS";
static char playback_doc[] = "<options> <file(s)>"
"\n\tPlayback <file(s)>, only operates this way when not running in background."
"\n\t\t-p <sx> <sy>\tOpen with lower left corner at <sx>, <sy>"
"\n\t\t-m\t\tRead from disk (Don't buffer)"
"\n\t\t-f <fps> <fps-base>\t\tSpecify FPS to start with"
"\n\t\t-j <frame>\tSet frame step to <frame>";
static char game_doc[] = "Game Engine specific options"
"\n\t-g fixedtime\t\tRun on 50 hertz without dropping frames"
"\n\t-g vertexarrays\t\tUse Vertex Arrays for rendering (usually faster)"
"\n\t-g nomipmap\t\tNo Texture Mipmapping"
"\n\t-g linearmipmap\t\tLinear Texture Mipmapping instead of Nearest (default)";
static char debug_doc[] = "\n\tTurn debugging on\n"
"\n\t* Prints every operator call and their arguments"
"\n\t* Disables mouse grab (to interact with a debugger in some cases)"
"\n\t* Keeps python sys.stdin rather then setting it to None";
//BLI_argsAdd(ba, pass, short_arg, long_arg, doc, cb, C);
/* end argument processing after -- */
BLI_argsAdd(ba, -1, "--", NULL, "\n\tEnds option
processing, following arguments passed unchanged. Access via python's
sys.argv", end_arguments, NULL);
/* first pass: background mode, disable python and commands that exit after usage */
BLI_argsAdd(ba, 1, "-h", "--help", "\n\tPrint this help text and exit", print_help, ba);
/* Windows only */
BLI_argsAdd(ba, 1, "/?", NULL, "\n\tPrint this help text and exit (windows only)", print_help, ba);
BLI_argsAdd(ba, 1, "-v", "--version", "\n\tPrint Blender version and exit", print_version, NULL);
BLI_argsAdd(ba, 1, "-y", "--enable-autoexec",
"\n\tEnable automatic python script execution (default)",
enable_python, NULL);
BLI_argsAdd(ba, 1, "-Y", "--disable-autoexec",
"\n\tDisable automatic python script execution (pydrivers,
pyconstraints, pynodes)", disable_python, NULL);
BLI_argsAdd(ba, 1, "-b", "--background",
"<file>\n\tLoad <file> in background (often used for
UI-less rendering)", background_mode, NULL);
BLI_argsAdd(ba, 1, "-a", NULL, playback_doc, playback_mode, NULL);
BLI_argsAdd(ba, 1, "-d", "--debug", debug_doc, debug_mode, ba);
BLI_argsAdd(ba, 1, NULL, "--debug-fpe", "\n\tEnable floating point exceptions", set_fpe, NULL);
BLI_argsAdd(ba, 1, NULL, "--factory-startup",
"\n\tSkip reading the "STRINGIFY(BLENDER_STARTUP_FILE)" in the users
home directory", set_factory_startup, NULL);
/* TODO, add user env vars? */
BLI_argsAdd(ba, 1, NULL,
"--env-system-config", "\n\tSet
the "STRINGIFY_ARG(BLENDER_SYSTEM_CONFIG)" environment variable",
set_env, NULL);
BLI_argsAdd(ba, 1, NULL,
"--env-system-datafiles", "\n\tSet the
"STRINGIFY_ARG(BLENDER_SYSTEM_DATAFILES)" environment variable",
set_env, NULL);
BLI_argsAdd(ba, 1, NULL,
"--env-system-scripts", "\n\tSet the
"STRINGIFY_ARG(BLENDER_SYSTEM_SCRIPTS)" environment variable", set_env,
NULL);
BLI_argsAdd(ba, 1, NULL,
"--env-system-plugins", "\n\tSet the
"STRINGIFY_ARG(BLENDER_SYSTEM_PLUGINS)" environment variable", set_env,
NULL);
BLI_argsAdd(ba, 1, NULL,
"--env-system-python", "\n\tSet
the "STRINGIFY_ARG(BLENDER_SYSTEM_PYTHON)" environment variable",
set_env, NULL);
/* second pass: custom window stuff */
BLI_argsAdd(ba, 2, "-p", "--window-geometry",
"<sx> <sy> <w> <h>\n\tOpen with lower left
corner at <sx>, <sy> and width and height as <w>,
<h>", prefsize, NULL);
BLI_argsAdd(ba, 2, "-w", "--window-border", "\n\tForce opening with borders (default)", with_borders, NULL);
BLI_argsAdd(ba, 2, "-W", "--window-borderless", "\n\tForce opening without borders", without_borders, NULL);
BLI_argsAdd(ba, 2, "-con", "--start-console",
"\n\tStart with the console window open (ignored if -b is set)",
start_with_console, NULL);
BLI_argsAdd(ba, 2, "-R", NULL, "\n\tRegister .blend
extension, then exit (Windows only)", register_extension, NULL);
BLI_argsAdd(ba, 2, "-r", NULL, "\n\tSilently
register .blend extension, then exit (Windows only)",
register_extension, ba);
/* third pass: disabling things and forcing settings */
BLI_argsAddCase(ba, 3, "-nojoystick", 1, NULL, 0, "\n\tDisable joystick support", no_joystick, syshandle);
BLI_argsAddCase(ba, 3, "-noglsl", 1, NULL, 0, "\n\tDisable GLSL shading", no_glsl, NULL);
BLI_argsAddCase(ba, 3, "-noaudio", 1, NULL, 0, "\n\tForce sound system to None", no_audio, NULL);
BLI_argsAddCase(ba, 3, "-setaudio", 1, NULL, 0,
"\n\tForce sound system to a specific device\n\tNULL SDL OPENAL JACK",
set_audio, NULL);
/* fourth pass: processing arguments */
BLI_argsAdd(ba, 4, "-g", NULL, game_doc, set_ge_parameters, syshandle);
BLI_argsAdd(ba, 4, "-f", "--render-frame",
"<frame>\n\tRender frame <frame> and save
it.\n\t+<frame> start frame relative, -<frame> end frame
relative.", render_frame, C);
BLI_argsAdd(ba, 4, "-a", "--render-anim",
"\n\tRender frames from start to end (inclusive)", render_animation, C);
BLI_argsAdd(ba, 4, "-S", "--scene",
"<name>\n\tSet the active scene <name> for rendering",
set_scene, C);
BLI_argsAdd(ba, 4, "-s", "--frame-start",
"<frame>\n\tSet start to frame <frame> (use before the -a
argument)", set_start_frame, C);
BLI_argsAdd(ba, 4, "-e", "--frame-end",
"<frame>\n\tSet end to frame <frame> (use before the -a
argument)", set_end_frame, C);
BLI_argsAdd(ba, 4, "-j", "--frame-jump",
"<frames>\n\tSet number of frames to step forward after each
rendered frame", set_skip_frame, C);
BLI_argsAdd(ba, 4, "-P", "--python",
"<filename>\n\tRun the given Python script (filename or Blender
Text)", run_python, C);
BLI_argsAdd(ba, 4, NULL, "--python-console",
"\n\tRun blender with an interactive console", run_python_console, C);
BLI_argsAdd(ba, 4, NULL, "--addons", "\n\tComma separated list of addons (no spaces)", set_addons, C);
BLI_argsAdd(ba, 4, "-o", "--render-output", output_doc, set_output, C);
BLI_argsAdd(ba, 4, "-E", "--engine",
"<engine>\n\tSpecify the render engine\n\tuse -E help to list
available engines", set_engine, C);
BLI_argsAdd(ba, 4, "-F", "--render-format", format_doc, set_image_type, C);
BLI_argsAdd(ba, 4, "-t", "--threads",
"<threads>\n\tUse amount of <threads> for rendering in
background\n\t[1-" STRINGIFY(BLENDER_MAX_THREADS) "], 0 for systems
processor count.", set_threads, NULL);
BLI_argsAdd(ba, 4, "-x", "--use-extension",
"<bool>\n\tSet option to add the file extension to the end of the
file", set_extension, C);
}
#ifdef WITH_PYTHON_MODULE
/* allow python module to call main */
#define main main_python
#endif
void CreateTiming(char* name, ...)
{
#include <time.h>
#include <stdarg.h>
static time_t nStartTime = 0;
static FILE* stream = NULL;
char buffer[256];
if (nStartTime == 0)
{
stream = fopen("timing.txt", "w");
nStartTime = time(NULL);
}
if (name != NULL)
{
va_list argptr;
va_start(argptr, name);
vsprintf(buffer, name, argptr);
sprintf(buffer + strlen(buffer), ": %d\n", time(NULL) - nStartTime);
va_end(argptr);
fprintf(stream, "%s", buffer);
}
else
{
fprintf(stream, "The end of program: %d\n", time(NULL) - nStartTime);
fclose(stream);
}
}
int main(int argc, const char **argv)
{
SYS_SystemHandle syshandle;
bContext *C= CTX_create();
bArgs *ba;
CreateTiming("Start program...");
#ifdef WITH_PYTHON_MODULE
#undef main
#endif
#ifdef WITH_BINRELOC
br_init( NULL );
#endif
setCallbacks();
#ifdef __APPLE__
/* patch to ignore argument finder gives us (pid?) */
if (argc==2 && strncmp(argv[1], "-psn_", 5)==0) {
extern int GHOST_HACK_getFirstFile(char buf[]);
static char firstfilebuf[512];
argc= 1;
if (GHOST_HACK_getFirstFile(firstfilebuf)) {
argc= 2;
argv[1]= firstfilebuf;
}
}
#endif
#ifdef __FreeBSD__
fpsetmask(0);
#endif
// copy path to executable in bprogname. playanim and creting runtimes
// need this.
BLI_where_am_i(bprogname, sizeof(bprogname), argv[0]);
#ifdef BUILD_DATE
strip_quotes(build_date);
strip_quotes(build_time);
strip_quotes(build_rev);
strip_quotes(build_platform);
strip_quotes(build_type);
strip_quotes(build_cflags);
strip_quotes(build_cxxflags);
strip_quotes(build_linkflags);
strip_quotes(build_system);
#endif
BLI_threadapi_init();
RNA_init();
RE_engines_init();
/* Hack - force inclusion of the plugin api functions,
* see blenpluginapi:pluginapi.c
*/
pluginapi_force_ref();
init_nodesystem();
initglobals(); /* blender.c */
IMB_init();
#ifdef WITH_GAMEENGINE
syshandle = SYS_GetSystem();
GEN_init_messaging_system();
#else
syshandle= 0;
#endif
/* first test for background */
ba = BLI_argsInit(argc, argv); /* skip binary path */
setupArguments(C, ba, &syshandle);
BLI_argsParse(ba, 1, NULL, NULL);
#ifdef __sgi
setuid(getuid()); /* end superuser */
#endif
#ifdef WITH_PYTHON_MODULE
G.background= 1; /* python module mode ALWAYS runs in background mode (for now) */
#else
/* for all platforms, even windos has it! */
if(G.background) signal(SIGINT, blender_esc); /* ctrl c out bg render */
#endif
/* background render uses this font too */
BKE_font_register_builtin(datatoc_Bfont, datatoc_Bfont_size);
/* Initialiaze ffmpeg if built in, also needed for bg mode if videos are
rendered via ffmpeg */
sound_init_once();
init_def_material();
if(G.background==0) {
BLI_argsParse(ba, 2, NULL, NULL);
BLI_argsParse(ba, 3, NULL, NULL);
WM_init(C, argc, argv);
/* this is properly initialized with user defs, but this is default */
BLI_where_is_temp(btempdir,
FILE_MAX, 1); /* call after loading the startup.blend so we can read
U.tempdir */
#ifndef DISABLE_SDL
BLI_setenv("SDL_VIDEODRIVER", "dummy");
#endif
}
else {
BLI_argsParse(ba, 3, NULL, NULL);
WM_init(C, argc, argv);
BLI_where_is_temp(btempdir,
FILE_MAX, 0); /* call after loading the startup.blend so we can read
U.tempdir */
}
#ifdef WITH_PYTHON
/**
* NOTE: the U.pythondir string is NULL until WM_init() is executed,
* so we provide the BPY_ function below to append the user defined
* pythondir to Python's sys.path at this point. Simply putting
* WM_init() before BPY_python_start() crashes Blender at startup.
* Update: now this function also inits the bpymenus, which also depend
* on U.pythondir.
*/
// TODO - U.pythondir
#else
printf("\n* WARNING * - Blender compiled without Python!\nthis is not intended for typical usage\n\n");
#endif
CTX_py_init_set(C, 1);
WM_keymap_init(C);
CreateTiming("Setup program...");
/* OK we are ready for it */
BLI_argsParse(ba, 4, load_file, C);
CreateTiming("Finish rendering program...");
BLI_argsFree(ba);
#ifdef WITH_PYTHON_MODULE
return 0; /* keep blender in background mode running */
#endif
if(G.background) {
/* actually incorrect, but works for now (ton) */
CreateTiming(NULL);
WM_exit(C);
}
else {
if((G.fileflags & G_FILE_AUTOPLAY) && (G.f & G_SCRIPT_AUTOEXEC))
{
if(WM_init_game(C))
return 0;
}
else if(!G.file_loaded)
WM_init_splash(C);
}
WM_main(C);
/*XXX if (scr_init==0) {
main_init_screen();
}
screenmain();*/ /* main display loop */
return 0;
} /* end of int main(argc,argv) */
static void error_cb(const char *err)
{
printf("%s\n", err); /* XXX do this in WM too */
}
static void mem_error_cb(const char *errorStr)
{
fputs(errorStr, stderr);
fflush(stderr);
}
static void setCallbacks(void)
{
/* Error output from the alloc routines: */
MEM_set_error_callback(mem_error_cb);
/* BLI_blenlib: */
BLI_setErrorCallBack(error_cb); /* */
// XXX BLI_setInterruptCallBack(blender_test_break);
}
////////////////////////////////////////////////////
The below is another futile efforts as I tried to put multiple thread
in procedure of raytree creating. However, it seems there is very
little concurrency as
I have to use multiple "critical-section" to synchronize threads.
Therefore it turns out the multiple-threaded version is even 30% slower
than original single
threaded one. (original say 35sec, threaded is 45sec)
filename: source/blender/render/intern/source/rayshade.c
กก
/*
* $Id: rayshade.c 36282 2011-04-22 14:47:35Z campbellbarton $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 1990-1998 NeoGeo BV.
* All rights reserved.
*
* Contributors: 2004/2005 Blender Foundation, full recode
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/render/intern/source/rayshade.c
* \ingroup render
*/
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <float.h>
#include <assert.h>
#include "MEM_guardedalloc.h"
#include "DNA_material_types.h"
#include "DNA_lamp_types.h"
#include "BLI_blenlib.h"
#include "BLI_cpu.h"
#include "BLI_jitter.h"
#include "BLI_math.h"
#include "BLI_rand.h"
#include "BLI_utildefines.h"
#include "BKE_global.h"
#include "BKE_node.h"
#include "PIL_time.h"
#include "render_types.h"
#include "renderpipeline.h"
#include "rendercore.h"
#include "renderdatabase.h"
#include "pixelblending.h"
#include "pixelshading.h"
#include "shading.h"
#include "texture.h"
#include "volumetric.h"
#include "rayintersection.h"
#include "rayobject.h"
#include "raycounter.h"
#define RAY_TRA 1
#define RAY_INSIDE 2
#define DEPTH_SHADOW_TRA 10
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/* defined in pipeline.c, is hardcopy of active dynamic allocated Render */
/* only to be used here in this file, it's for speed */
extern struct Render R;
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
static int test_break(void *data)
{
Render *re = (Render*)data;
return re->test_break(re->tbh);
}
static void RE_rayobject_config_control(RayObject *r, Render *re)
{
if(RE_rayobject_isRayAPI(r))
{
r = RE_rayobject_align( r );
r->control.data = re;
r->control.test_break = test_break;
}
}
RayObject* RE_rayobject_create(Render *re, int type, int size)
{
RayObject * res = NULL;
if(type == R_RAYSTRUCTURE_AUTO)
{
//TODO
//if(detect_simd())
#ifdef __SSE__
type = BLI_cpu_support_sse2()? R_RAYSTRUCTURE_SIMD_SVBVH: R_RAYSTRUCTURE_VBVH;
#else
type = R_RAYSTRUCTURE_VBVH;
#endif
}
#ifndef __SSE__
if(type == R_RAYSTRUCTURE_SIMD_SVBVH || type == R_RAYSTRUCTURE_SIMD_QBVH)
{
puts("Warning: Using VBVH (SSE was disabled at compile time)");
type = R_RAYSTRUCTURE_VBVH;
}
#endif
if(type == R_RAYSTRUCTURE_OCTREE) //TODO dynamic ocres
res = RE_rayobject_octree_create(re->r.ocres, size);
else if(type == R_RAYSTRUCTURE_BLIBVH)
res = RE_rayobject_blibvh_create(size);
else if(type == R_RAYSTRUCTURE_VBVH)
res = RE_rayobject_vbvh_create(size);
else if(type == R_RAYSTRUCTURE_SIMD_SVBVH)
res = RE_rayobject_svbvh_create(size);
else if(type == R_RAYSTRUCTURE_SIMD_QBVH)
res = RE_rayobject_qbvh_create(size);
else
res = RE_rayobject_vbvh_create(size); //Fallback
if(res)
RE_rayobject_config_control( res, re );
return res;
}
#ifdef RE_RAYCOUNTER
RayCounter re_rc_counter[BLENDER_MAX_THREADS];
#endif
void freeraytree(Render *re)
{
ObjectInstanceRen *obi;
if(re->raytree)
{
RE_rayobject_free(re->raytree);
re->raytree = NULL;
}
if(re->rayfaces)
{
MEM_freeN(re->rayfaces);
re->rayfaces = NULL;
}
if(re->rayprimitives)
{
MEM_freeN(re->rayprimitives);
re->rayprimitives = NULL;
}
for(obi=re->instancetable.first; obi; obi=obi->next)
{
ObjectRen *obr = obi->obr;
if(obr->raytree)
{
RE_rayobject_free(obr->raytree);
obr->raytree = NULL;
}
if(obr->rayfaces)
{
MEM_freeN(obr->rayfaces);
obr->rayfaces = NULL;
}
if(obi->raytree)
{
RE_rayobject_free(obi->raytree);
obi->raytree = NULL;
}
}
#ifdef RE_RAYCOUNTER
{
RayCounter sum;
memset( &sum, 0, sizeof(sum) );
int i;
for(i=0; i<BLENDER_MAX_THREADS; i++)
RE_RC_MERGE(&sum, re_rc_counter+i);
RE_RC_INFO(&sum);
}
#endif
}
static int is_raytraceable_vlr(Render *re, VlakRen *vlr)
{
/* note: volumetric must be tracable, wire must not */
if((re->flag & R_BAKE_TRACE) || (vlr->flag
& R_TRACEBLE) || (vlr->mat->material_type == MA_TYPE_VOLUME))
if(vlr->mat->material_type != MA_TYPE_WIRE)
return 1;
return 0;
}
static int is_raytraceable(Render *re, ObjectInstanceRen *obi)
{
int v;
ObjectRen *obr = obi->obr;
if(re->excludeob && obr->ob == re->excludeob)
return 0;
for(v=0;v<obr->totvlak;v++) {
VlakRen *vlr = obr->vlaknodes[v>>8].vlak + (v&255);
if(is_raytraceable_vlr(re, vlr))
return 1;
}
return 0;
}
RayObject* makeraytree_object(Render *re, ObjectInstanceRen *obi)
{
//TODO
// out-of-memory safeproof
// break render
// update render stats
ObjectRen *obr = obi->obr;
if(obr->raytree == NULL)
{
RayObject *raytree;
RayFace *face = NULL;
VlakPrimitive *vlakprimitive = NULL;
int v;
//Count faces
int faces = 0;
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak + (v&255);
if(is_raytraceable_vlr(re, vlr))
faces++;
}
if (faces == 0)
return NULL;
//Create Ray cast accelaration structure
raytree = RE_rayobject_create( re, re->r.raytrace_structure, faces );
if( (re->r.raytrace_options & R_RAYTRACE_USE_LOCAL_COORDS) )
vlakprimitive
= obr->rayprimitives =
(VlakPrimitive*)MEM_callocN(faces*sizeof(VlakPrimitive), "ObjectRen
primitives");
else
face =
obr->rayfaces = (RayFace*)MEM_callocN(faces*sizeof(RayFace),
"ObjectRen faces");
obr->rayobi = obi;
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak + (v&255);
if(is_raytraceable_vlr(re, vlr))
{
if( (re->r.raytrace_options &
R_RAYTRACE_USE_LOCAL_COORDS) )
{
RE_rayobject_add( raytree,
RE_vlakprimitive_from_vlak( vlakprimitive, obi, vlr ) );
vlakprimitive++;
}
else
{
RE_rayface_from_vlak( face, obi,
vlr );
RE_rayobject_add( raytree,
RE_rayobject_unalignRayFace(face) );
face++;
}
}
}
RE_rayobject_done( raytree );
/* in case of cancel during build, raytree is not usable */
if(test_break(re))
RE_rayobject_free(raytree);
else
obr->raytree= raytree;
}
if(obr->raytree) {
if((obi->flag & R_TRANSFORMED) && obi->raytree == NULL)
{
obi->transform_primitives = 0;
obi->raytree = RE_rayobject_instance_create( obr->raytree,
obi->mat, obi, obi->obr->rayobi );
}
}
if(obi->raytree) return obi->raytree;
return obi->obr->raytree;
}
static int has_special_rayobject(Render *re, ObjectInstanceRen *obi)
{
if( (obi->flag & R_TRANSFORMED) &&
(re->r.raytrace_options & R_RAYTRACE_USE_INSTANCES) )
{
ObjectRen *obr = obi->obr;
int v, faces = 0;
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak + (v&255);
if(is_raytraceable_vlr(re, vlr))
{
faces++;
if(faces > 4)
return 1;
}
}
}
return 0;
}
#ifdef NICK_EDIT
typedef struct MakeRayTreeThreadData
{
Render *re;
ObjectInstanceRen *obi;
RayFace *face;
VlakPrimitive *vlakprimitive;
int finishedCount;
} MakeRayTreeThreadData;
static void* do_make_raytree_single(void* ptr)
{
MakeRayTreeThreadData* threadData = (MakeRayTreeThreadData*)ptr;
Render *re;
RayObject *raytree = NULL;
ObjectInstanceRen *obi = NULL;
RayFace *face = NULL;
VlakPrimitive *vlakprimitive = NULL;
// we assume threadData is valid pointer
re = threadData->re;
raytree = re->raytree;
while (1)
{
///////////////////////////
// sync retrieve next obi
BLI_lock_thread(LOCK_RAYTREE_READ);
obi = threadData->obi;
if (obi)
{
threadData->obi = obi->next;
}
BLI_unlock_thread(LOCK_RAYTREE_READ);
/////////////////////////////////
if (obi == NULL || test_break(re))
{
break;
}
if(is_raytraceable(re, obi))
{
if(has_special_rayobject(re, obi))
{
RayObject *obj = makeraytree_object(re, obi);
if(test_break(re))
{
break;
}
if (obj)
{
BLI_lock_thread(LOCK_RAYTREE_WRITE);
RE_rayobject_add( re->raytree, obj );
BLI_unlock_thread(LOCK_RAYTREE_WRITE);
}
}
else
{
int v;
ObjectRen *obr = obi->obr;
if(obi->flag & R_TRANSFORMED)
{
obi->transform_primitives = 1;
}
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak +
(v&255);
if(is_raytraceable_vlr(re, vlr))
{
BLI_lock_thread(LOCK_RAYTREE_WRITE);
// REMEMBER WE NOW READ THE
POINTER!
face = threadData->face;
vlakprimitive =
threadData->vlakprimitive;
if( (re->r.raytrace_options
& R_RAYTRACE_USE_LOCAL_COORDS) )
{
RayObject *obj
= RE_vlakprimitive_from_vlak( vlakprimitive, obi, vlr );
RE_rayobject_add( raytree, obj );
vlakprimitive++;
}
else
{
RE_rayface_from_vlak(face, obi, vlr);
if((obi->flag & R_TRANSFORMED))
{
mul_m4_v3(obi->mat, face->v1);
mul_m4_v3(obi->mat, face->v2);
mul_m4_v3(obi->mat, face->v3);
if(RE_rayface_isQuad(face))
mul_m4_v3(obi->mat,
face->v4);
}
RE_rayobject_add( raytree, RE_rayobject_unalignRayFace(face) );
face++;
}
threadData->face = face;
threadData->vlakprimitive =
vlakprimitive;
BLI_unlock_thread(LOCK_RAYTREE_WRITE);
}
}
}
}
}
// lets assume read lock is relatively less used than write lock
BLI_lock_thread(LOCK_RAYTREE_READ);
threadData->finishedCount ++;
BLI_unlock_thread(LOCK_RAYTREE_READ);
return NULL;
}
/*
* create a single raytrace structure with all faces
*/
static void makeraytree_single(Render *re)
{
ListBase threads;
ObjectInstanceRen *obi;
RayObject *raytree;
RayFace *face = NULL;
VlakPrimitive *vlakprimitive = NULL;
int faces = 0, obs = 0, special = 0;
MakeRayTreeThreadData makeRayTreeThreadData;
CreateTiming("makeraytree_single new begins...");
for(obi=re->instancetable.first; obi; obi=obi->next)
{
if(is_raytraceable(re, obi))
{
int v;
ObjectRen *obr = obi->obr;
obs++;
if(has_special_rayobject(re, obi))
{
special++;
}
else
{
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak +
(v&255);
if(is_raytraceable_vlr(re, vlr))
faces++;
}
}
}
}
if(faces + special == 0)
{
re->raytree = RE_rayobject_empty_create();
return;
}
//Create raytree
raytree = re->raytree = RE_rayobject_create( re, re->r.raytrace_structure, faces+special );
if( (re->r.raytrace_options & R_RAYTRACE_USE_LOCAL_COORDS) )
{
vlakprimitive = re->rayprimitives =
(VlakPrimitive*)MEM_callocN(faces*sizeof(VlakPrimitive), "Raytrace
vlak-primitives");
}
else
{
face = re->rayfaces =
(RayFace*)MEM_callocN(faces*sizeof(RayFace), "Render ray faces");
}
// here we start threading...
BLI_init_threads(&threads, do_make_raytree_single, re->r.threads);
// initialize the global data for threads...
makeRayTreeThreadData.re = re;
makeRayTreeThreadData.obi = re->instancetable.first;
makeRayTreeThreadData.face = face;
makeRayTreeThreadData.vlakprimitive = vlakprimitive;
makeRayTreeThreadData.finishedCount = 0;
int i;
for (i = 0; i < re->r.threads; i ++)
{
BLI_insert_thread(&threads, &makeRayTreeThreadData);
}
while (makeRayTreeThreadData.finishedCount != R.r.threads)
{
PIL_sleep_ms(50);
}
BLI_end_threads(&threads);
if(!test_break(re))
{
re->i.infostr= "Raytree.. building";
re->stats_draw(re->sdh, &re->i);
RE_rayobject_done( raytree );
}
CreateTiming("makeraytree_single new ends...");
}
#else
/*
* create a single raytrace structure with all faces
*/
static void makeraytree_single(Render *re)
{
ObjectInstanceRen *obi;
RayObject *raytree;
RayFace *face = NULL;
VlakPrimitive *vlakprimitive = NULL;
int faces = 0, obs = 0, special = 0;
CreateTiming("makeraytree_single old begins...");
for(obi=re->instancetable.first; obi; obi=obi->next)
{
if(is_raytraceable(re, obi))
{
int v;
ObjectRen *obr = obi->obr;
obs++;
if(has_special_rayobject(re, obi))
{
special++;
}
else
{
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak +
(v&255);
if(is_raytraceable_vlr(re, vlr))
faces++;
}
}
}
}
if(faces + special == 0)
{
re->raytree = RE_rayobject_empty_create();
return;
}
//Create raytree
raytree = re->raytree = RE_rayobject_create( re, re->r.raytrace_structure, faces+special );
if( (re->r.raytrace_options & R_RAYTRACE_USE_LOCAL_COORDS) )
{
vlakprimitive = re->rayprimitives =
(VlakPrimitive*)MEM_callocN(faces*sizeof(VlakPrimitive), "Raytrace
vlak-primitives");
}
else
{
face = re->rayfaces =
(RayFace*)MEM_callocN(faces*sizeof(RayFace), "Render ray faces");
}
for(obi=re->instancetable.first; obi; obi=obi->next)
{
if(is_raytraceable(re, obi))
{
if(test_break(re))
{
break;
}
if(has_special_rayobject(re, obi))
{
RayObject *obj = makeraytree_object(re, obi);
if(test_break(re))
{
break;
}
if (obj)
{
RE_rayobject_add( re->raytree, obj );
}
}
else
{
int v;
ObjectRen *obr = obi->obr;
if(obi->flag & R_TRANSFORMED)
{
obi->transform_primitives = 1;
}
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak +
(v&255);
if(is_raytraceable_vlr(re, vlr))
{
if( (re->r.raytrace_options
& R_RAYTRACE_USE_LOCAL_COORDS) )
{
RayObject *obj
= RE_vlakprimitive_from_vlak( vlakprimitive, obi, vlr );
RE_rayobject_add( raytree, obj );
vlakprimitive++;
}
else
{
RE_rayface_from_vlak(face, obi, vlr);
if((obi->flag & R_TRANSFORMED))
{
mul_m4_v3(obi->mat, face->v1);
mul_m4_v3(obi->mat, face->v2);
mul_m4_v3(obi->mat, face->v3);
if(RE_rayface_isQuad(face))
mul_m4_v3(obi->mat,
face->v4);
}
RE_rayobject_add( raytree, RE_rayobject_unalignRayFace(face) );
face++;
}
}
}
}
}
}
if(!test_break(re))
{
re->i.infostr= "Raytree.. building";
re->stats_draw(re->sdh, &re->i);
RE_rayobject_done( raytree );
}
CreateTiming("makeraytree_single old ends...");
}
#endif
void makeraytree(Render *re)
{
float min[3], max[3], sub[3];
int i;
re->i.infostr= "Raytree.. preparing";
re->stats_draw(re->sdh, &re->i);
/* disable options not yet supported by octree,
they might actually never be supported (unless people really need it) */
if(re->r.raytrace_structure == R_RAYSTRUCTURE_OCTREE)
re->r.raytrace_options &=
~( R_RAYTRACE_USE_INSTANCES | R_RAYTRACE_USE_LOCAL_COORDS);
makeraytree_single(re);
if(test_break(re))
{
freeraytree(re);
re->i.infostr= "Raytree building canceled";
re->stats_draw(re->sdh, &re->i);
}
else
{
//Calculate raytree max_size
//This is ONLY needed to kept a bogus behaviour of SUN and HEMI lights
INIT_MINMAX(min, max);
RE_rayobject_merge_bb( re->raytree, min, max );
for(i=0; i<3; i++)
{
min[i] += 0.01f;
max[i] += 0.01f;
sub[i] = max[i]-min[i];
}
re->maxdist= sub[0]*sub[0] + sub[1]*sub[1] + sub[2]*sub[2];
if(re->maxdist > 0.0f) re->maxdist= sqrt(re->maxdist);
re->i.infostr= "Raytree finished";
re->stats_draw(re->sdh, &re->i);
}
#ifdef RE_RAYCOUNTER
memset( re_rc_counter, 0, sizeof(re_rc_counter) );
#endif
}
/* if(shi->osatex) */
static void shade_ray_set_derivative(ShadeInput *shi)
{
float detsh, t00, t10, t01, t11, xn, yn, zn;
int axis1, axis2;
/* find most stable axis to project */
xn= fabs(shi->facenor[0]);
yn= fabs(shi->facenor[1]);
zn= fabs(shi->facenor[2]);
if(zn>=xn && zn>=yn) { axis1= 0; axis2= 1; }
else if(yn>=xn && yn>=zn) { axis1= 0; axis2= 2; }
else { axis1= 1; axis2= 2; }
/* compute u,v and derivatives */
if(shi->obi->flag & R_TRANSFORMED) {
float v1[3], v2[3], v3[3];
mul_v3_m3v3(v1, shi->obi->nmat, shi->v1->co);
mul_v3_m3v3(v2, shi->obi->nmat, shi->v2->co);
mul_v3_m3v3(v3, shi->obi->nmat, shi->v3->co);
/* same as below */
t00= v3[axis1]-v1[axis1]; t01= v3[axis2]-v1[axis2];
t10= v3[axis1]-v2[axis1]; t11= v3[axis2]-v2[axis2];
}
else {
float *v1= shi->v1->co;
float *v2= shi->v2->co;
float *v3= shi->v3->co;
/* same as above */
t00= v3[axis1]-v1[axis1]; t01= v3[axis2]-v1[axis2];
t10= v3[axis1]-v2[axis1]; t11= v3[axis2]-v2[axis2];
}
detsh= 1.0f/(t00*t11-t10*t01);
t00*= detsh; t01*=detsh;
t10*=detsh; t11*=detsh;
shi->dx_u= shi->dxco[axis1]*t11- shi->dxco[axis2]*t10;
shi->dx_v= shi->dxco[axis2]*t00- shi->dxco[axis1]*t01;
shi->dy_u= shi->dyco[axis1]*t11- shi->dyco[axis2]*t10;
shi->dy_v= shi->dyco[axis2]*t00- shi->dyco[axis1]*t01;
}
void shade_ray(Isect *is, ShadeInput *shi, ShadeResult *shr)
{
ObjectInstanceRen *obi= (ObjectInstanceRen*)is->hit.ob;
VlakRen *vlr= (VlakRen*)is->hit.face;
/* set up view vector */
VECCOPY(shi->view, is->dir);
/* render co */
shi->co[0]= is->start[0]+is->dist*(shi->view[0]);
shi->co[1]= is->start[1]+is->dist*(shi->view[1]);
shi->co[2]= is->start[2]+is->dist*(shi->view[2]);
normalize_v3(shi->view);
shi->obi= obi;
shi->obr= obi->obr;
shi->vlr= vlr;
shi->mat= vlr->mat;
shade_input_init_material(shi);
if(is->isect==2)
shade_input_set_triangle_i(shi, obi, vlr, 0, 2, 3);
else
shade_input_set_triangle_i(shi, obi, vlr, 0, 1, 2);
shi->u= is->u;
shi->v= is->v;
shi->dx_u= shi->dx_v= shi->dy_u= shi->dy_v= 0.0f;
if(shi->osatex)
shade_ray_set_derivative(shi);
shade_input_set_normals(shi);
shade_input_set_shade_texco(shi);
if (shi->mat->material_type == MA_TYPE_VOLUME) {
if(ELEM(is->mode, RE_RAY_SHADOW, RE_RAY_SHADOW_TRA)) {
shade_volume_shadow(shi, shr, is);
} else {
shade_volume_outside(shi, shr);
}
}
else if(is->mode==RE_RAY_SHADOW_TRA) {
/* temp hack to prevent recursion */
if(shi->nodes==0 &&
shi->mat->nodetree && shi->mat->use_nodes) {
ntreeShaderExecTree(shi->mat->nodetree, shi, shr);
shi->mat=
vlr->mat; /* shi->mat is
being set in nodetree */
}
else
shade_color(shi, shr);
}
else {
if(shi->mat->nodetree && shi->mat->use_nodes) {
ntreeShaderExecTree(shi->mat->nodetree, shi, shr);
shi->mat=
vlr->mat; /* shi->mat is
being set in nodetree */
}
else {
shade_material_loop(shi, shr);
}
/* raytrace likes to separate the spec color */
VECSUB(shr->diff, shr->combined, shr->spec);
}
}
static int refraction(float *refract, float *n, float *view, float index)
{
float dot, fac;
VECCOPY(refract, view);
dot= view[0]*n[0] + view[1]*n[1] + view[2]*n[2];
if(dot>0.0f) {
index = 1.0f/index;
fac= 1.0f - (1.0f - dot*dot)*index*index;
if(fac<= 0.0f) return 0;
fac= -dot*index + sqrt(fac);
}
else {
fac= 1.0f - (1.0f - dot*dot)*index*index;
if(fac<= 0.0f) return 0;
fac= -dot*index - sqrt(fac);
}
refract[0]= index*view[0] + fac*n[0];
refract[1]= index*view[1] + fac*n[1];
refract[2]= index*view[2] + fac*n[2];
return 1;
}
/* orn = original face normal */
static void reflection(float *ref, float *n, float *view, float *orn)
{
float f1;
f1= -2.0f*(n[0]*view[0]+ n[1]*view[1]+ n[2]*view[2]);
ref[0]= (view[0]+f1*n[0]);
ref[1]= (view[1]+f1*n[1]);
ref[2]= (view[2]+f1*n[2]);
if(orn) {
/* test phong normals, then we should prevent vector going to the back */
f1= ref[0]*orn[0]+ ref[1]*orn[1]+ ref[2]*orn[2];
if(f1>0.0f) {
f1+= .01f;
ref[0]-= f1*orn[0];
ref[1]-= f1*orn[1];
ref[2]-= f1*orn[2];
}
}
}
#if 0
static void color_combine(float *result, float fac1, float fac2, float *col1, float *col2)
{
float col1t[3], col2t[3];
col1t[0]= sqrt(col1[0]);
col1t[1]= sqrt(col1[1]);
col1t[2]= sqrt(col1[2]);
col2t[0]= sqrt(col2[0]);
col2t[1]= sqrt(col2[1]);
col2t[2]= sqrt(col2[2]);
result[0]= (fac1*col1t[0] + fac2*col2t[0]);
result[0]*= result[0];
result[1]= (fac1*col1t[1] + fac2*col2t[1]);
result[1]*= result[1];
result[2]= (fac1*col1t[2] + fac2*col2t[2]);
result[2]*= result[2];
}
#endif
static float shade_by_transmission(Isect *is, ShadeInput *shi, ShadeResult *shr)
{
float dx, dy, dz, d, p;
if (0 == (shi->mat->mode & MA_TRANSP))
return -1;
if (shi->mat->tx_limit <= 0.0f) {
d= 1.0f;
}
else {
/* shi.co[] calculated by shade_ray() */
dx= shi->co[0] - is->start[0];
dy= shi->co[1] - is->start[1];
dz= shi->co[2] - is->start[2];
d= sqrt(dx*dx+dy*dy+dz*dz);
if (d > shi->mat->tx_limit)
d= shi->mat->tx_limit;
p = shi->mat->tx_falloff;
if(p < 0.0f) p= 0.0f;
else if (p > 10.0f) p= 10.0f;
shr->alpha *= pow(d, p);
if (shr->alpha > 1.0f)
shr->alpha= 1.0f;
}
return d;
}
static void ray_fadeout_endcolor(float *col, ShadeInput *origshi, ShadeInput *shi, ShadeResult *shr, Isect *isec, float *vec)
{
/* un-intersected rays get either rendered material color or sky color */
if (origshi->mat->fadeto_mir == MA_RAYMIR_FADETOMAT) {
VECCOPY(col, shr->combined);
} else if (origshi->mat->fadeto_mir == MA_RAYMIR_FADETOSKY) {
VECCOPY(shi->view, vec);
normalize_v3(shi->view);
shadeSkyView(col, isec->start, shi->view, NULL, shi->thread);
shadeSunView(col, shi->view);
}
}
static void ray_fadeout(Isect *is, ShadeInput *shi, float *col, float *blendcol, float dist_mir)
{
/* if fading out, linear blend against fade color */
float blendfac;
blendfac = 1.0 - len_v3v3(shi->co, is->start)/dist_mir;
col[0] = col[0]*blendfac + (1.0 - blendfac)*blendcol[0];
col[1] = col[1]*blendfac + (1.0 - blendfac)*blendcol[1];
col[2] = col[2]*blendfac + (1.0 - blendfac)*blendcol[2];
}
/* the main recursive tracer itself
* note: 'col' must be initialized */
static void traceray(ShadeInput *origshi, ShadeResult *origshr, short
depth, float *start, float *dir, float *col, ObjectInstanceRen *obi,
VlakRen *vlr, int traflag)
{
ShadeInput shi= {0};
Isect isec;
float dist_mir = origshi->mat->dist_mir;
VECCOPY(isec.start, start);
VECCOPY(isec.dir, dir );
isec.dist = dist_mir > 0 ? dist_mir : RE_RAYTRACE_MAXDIST;
isec.mode= RE_RAY_MIRROR;
isec.check = RE_CHECK_VLR_RENDER;
isec.skip = RE_SKIP_VLR_NEIGHBOUR;
isec.hint = 0;
isec.orig.ob = obi;
isec.orig.face = vlr;
RE_RC_INIT(isec, shi);
if(RE_rayobject_raycast(R.raytree, &isec)) {
ShadeResult shr= {{0}};
float d= 1.0f;
/* for as long we don't have proper dx/dy transform for rays we copy over original */
VECCOPY(shi.dxco, origshi->dxco);
VECCOPY(shi.dyco, origshi->dyco);
shi.mask= origshi->mask;
shi.osatex= origshi->osatex;
shi.depth= origshi->depth +
1;
/* only used to indicate tracing
*/
shi.thread= origshi->thread;
//shi.sample= 0; // memset above, so dont need this
shi.xs= origshi->xs;
shi.ys= origshi->ys;
shi.lay= origshi->lay;
shi.passflag= SCE_PASS_COMBINED; /* result of tracing needs no pass info */
shi.combinedflag=
0xFFFFFF; /* ray trace does
all options */
//shi.do_preview= 0; // memset above, so dont need this
shi.light_override= origshi->light_override;
shi.mat_override= origshi->mat_override;
shade_ray(&isec, &shi, &shr);
/* ray has traveled inside the material, so shade by transmission */
if (traflag & RAY_INSIDE)
d= shade_by_transmission(&isec, &shi, &shr);
if(depth>0) {
float fr, fg, fb, f, f1;
if((shi.mat->mode_l & MA_TRANSP) && shr.alpha < 1.0f
&& (shi.mat->mode_l & (MA_ZTRANSP | MA_RAYTRANSP))) {
float nf, f, refract[3], tracol[4];
tracol[0]= shi.r;
tracol[1]= shi.g;
tracol[2]= shi.b;
tracol[3]= col[3]; // we pass on
and accumulate alpha
if((shi.mat->mode & MA_TRANSP) &&
(shi.mat->mode & MA_RAYTRANSP)) {
if(traflag & RAY_INSIDE) {
/* inside the
material, so use inverse normal */
float norm[3];
norm[0]= -
shi.vn[0];
norm[1]= -
shi.vn[1];
norm[2]= -
shi.vn[2];
if
(refraction(refract, norm, shi.view, shi.ang)) {
/* ray comes out from the material into air */
traflag &= ~RAY_INSIDE;
}
else {
/* total internal reflection (ray stays inside the
material) */
reflection(refract, norm, shi.view, shi.vn);
}
}
else {
if
(refraction(refract, shi.vn, shi.view, shi.ang)) {
/* ray goes in to the material from air */
traflag |= RAY_INSIDE;
}
else {
/* total external reflection (ray doesn't enter the
material) */
reflection(refract, shi.vn, shi.view, shi.vn);
}
}
traceray(origshi, origshr,
depth-1, shi.co, refract, tracol, shi.obi, shi.vlr, traflag);
}
else
traceray(origshi, origshr,
depth-1, shi.co, shi.view, tracol, shi.obi, shi.vlr, 0);
f= shr.alpha; f1= 1.0f-f;
nf= d * shi.mat->filter;
fr= 1.0f+ nf*(shi.r-1.0f);
fg= 1.0f+ nf*(shi.g-1.0f);
fb= 1.0f+ nf*(shi.b-1.0f);
shr.diff[0]= f*shr.diff[0] + f1*fr*tracol[0];
shr.diff[1]= f*shr.diff[1] + f1*fg*tracol[1];
shr.diff[2]= f*shr.diff[2] + f1*fb*tracol[2];
shr.spec[0] *=f;
shr.spec[1] *=f;
shr.spec[2] *=f;
col[3]= f1*tracol[3] + f;
}
else
col[3]= 1.0f;
if(shi.mat->mode_l & MA_RAYMIRROR) {
f= shi.ray_mirror;
if(f!=0.0f) f*= fresnel_fac(shi.view, shi.vn,
shi.mat->fresnel_mir_i, shi.mat->fresnel_mir);
}
else f= 0.0f;
if(f!=0.0f) {
float mircol[4];
float ref[3];
reflection(ref, shi.vn, shi.view, NULL);
traceray(origshi, origshr, depth-1, shi.co, ref,
mircol, shi.obi, shi.vlr, 0);
f1= 1.0f-f;
/* combine */
//color_combine(col, f*fr*(1.0f-shr.spec[0]), f1,
col, shr.diff);
//col[0]+= shr.spec[0];
//col[1]+= shr.spec[1];
//col[2]+= shr.spec[2];
fr= shi.mirr;
fg= shi.mirg;
fb= shi.mirb;
col[0]= f*fr*(1.0f-shr.spec[0])*mircol[0] +
f1*shr.diff[0] + shr.spec[0];
col[1]= f*fg*(1.0f-shr.spec[1])*mircol[1] +
f1*shr.diff[1] + shr.spec[1];
col[2]= f*fb*(1.0f-shr.spec[2])*mircol[2] +
f1*shr.diff[2] + shr.spec[2];
}
else {
col[0]= shr.diff[0] + shr.spec[0];
col[1]= shr.diff[1] + shr.spec[1];
col[2]= shr.diff[2] + shr.spec[2];
}
if (dist_mir > 0.0) {
float blendcol[3];
/* max ray distance set, but found an intersection,
so fade this color
* out towards the sky/material color for a
smooth transition */
ray_fadeout_endcolor(blendcol, origshi, &shi,
origshr, &isec, dir);
ray_fadeout(&isec, &shi, col, blendcol,
dist_mir);
}
}
else {
col[0]= shr.diff[0] + shr.spec[0];
col[1]= shr.diff[1] + shr.spec[1];
col[2]= shr.diff[2] + shr.spec[2];
}
}
else {
ray_fadeout_endcolor(col, origshi, &shi, origshr, &isec, dir);
}
RE_RC_MERGE(&origshi->raycounter, &shi.raycounter);
}
/* **************** jitter blocks ********** */
/* calc distributed planar energy */
static void DP_energy(float *table, float *vec, int tot, float xsize, float ysize)
{
int x, y, a;
float *fp, force[3], result[3];
float dx, dy, dist, min;
min= MIN2(xsize, ysize);
min*= min;
result[0]= result[1]= 0.0f;
for(y= -1; y<2; y++) {
dy= ysize*y;
for(x= -1; x<2; x++) {
dx= xsize*x;
fp= table;
for(a=0; a<tot; a++, fp+= 2) {
force[0]= vec[0] - fp[0]-dx;
force[1]= vec[1] - fp[1]-dy;
dist= force[0]*force[0] + force[1]*force[1];
if(dist < min && dist>0.0f) {
result[0]+= force[0]/dist;
result[1]+= force[1]/dist;
}
}
}
}
vec[0] += 0.1*min*result[0]/(float)tot;
vec[1] += 0.1*min*result[1]/(float)tot;
// cyclic clamping
vec[0]= vec[0] - xsize*floor(vec[0]/xsize + 0.5);
vec[1]= vec[1] - ysize*floor(vec[1]/ysize + 0.5);
}
// random offset of 1 in 2
static void jitter_plane_offset(float *jitter1, float *jitter2, int tot, float sizex, float sizey, float ofsx, float ofsy)
{
float dsizex= sizex*ofsx;
float dsizey= sizey*ofsy;
float hsizex= 0.5*sizex, hsizey= 0.5*sizey;
int x;
for(x=tot; x>0; x--, jitter1+=2, jitter2+=2) {
jitter2[0]= jitter1[0] + dsizex;
jitter2[1]= jitter1[1] + dsizey;
if(jitter2[0] > hsizex) jitter2[0]-= sizex;
if(jitter2[1] > hsizey) jitter2[1]-= sizey;
}
}
/* called from convertBlenderScene.c */
/* we do this in advance to get consistent random, not alter the render seed, and be threadsafe */
void init_jitter_plane(LampRen *lar)
{
float *fp;
int x, iter=12, tot= lar->ray_totsamp;
/* test if already initialized */
if(lar->jitter) return;
/* at least 4, or max threads+1 tables */
if(BLENDER_MAX_THREADS < 4) x= 4;
else x= BLENDER_MAX_THREADS+1;
fp= lar->jitter= MEM_callocN(x*tot*2*sizeof(float), "lamp jitter tab");
/* if 1 sample, we leave table to be zero's */
if(tot>1) {
/* set per-lamp fixed seed */
BLI_srandom(tot);
/* fill table with random locations, area_size large */
for(x=0; x<tot; x++, fp+=2) {
fp[0]= (BLI_frand()-0.5)*lar->area_size;
fp[1]= (BLI_frand()-0.5)*lar->area_sizey;
}
while(iter--) {
fp= lar->jitter;
for(x=tot; x>0; x--, fp+=2) {
DP_energy(lar->jitter, fp, tot,
lar->area_size, lar->area_sizey);
}
}
}
/* create the dithered tables (could just check lamp type!) */
jitter_plane_offset(lar->jitter,
lar->jitter+2*tot, tot, lar->area_size, lar->area_sizey, 0.5f,
0.0f);
jitter_plane_offset(lar->jitter,
lar->jitter+4*tot, tot, lar->area_size, lar->area_sizey, 0.5f,
0.5f);
jitter_plane_offset(lar->jitter,
lar->jitter+6*tot, tot, lar->area_size, lar->area_sizey, 0.0f,
0.5f);
}
/* table around origin, -0.5*size to 0.5*size */
static float *give_jitter_plane(LampRen *lar, int thread, int xs, int ys)
{
int tot;
tot= lar->ray_totsamp;
if(lar->ray_samp_type & LA_SAMP_JITTER) {
/* made it threadsafe */
if(lar->xold[thread]!=xs || lar->yold[thread]!=ys) {
jitter_plane_offset(lar->jitter, lar->jitter+2*(thread+1)*tot,
tot, lar->area_size, lar->area_sizey, BLI_thread_frand(thread),
BLI_thread_frand(thread));
lar->xold[thread]= xs;
lar->yold[thread]= ys;
}
return lar->jitter+2*(thread+1)*tot;
}
if(lar->ray_samp_type & LA_SAMP_DITHER) {
return lar->jitter + 2*tot*((xs & 1)+2*(ys & 1));
}
return lar->jitter;
}
/* **************** QMC sampling *************** */
static void halton_sample(double *ht_invprimes, double *ht_nums, double *v)
{
// incremental halton sequence generator, from:
// "Instant Radiosity", Keller A.
unsigned int i;
for (i = 0; i < 2; i++)
{
double r = fabs((1.0 - ht_nums[i]) - 1e-10);
if (ht_invprimes[i] >= r)
{
double lasth;
double h = ht_invprimes[i];
do {
lasth = h;
h *= ht_invprimes[i];
} while (h >= r);
ht_nums[i] += ((lasth + h) - 1.0);
}
else
ht_nums[i] += ht_invprimes[i];
v[i] = (float)ht_nums[i];
}
}
/* Generate Hammersley points in [0,1)^2
* From Lucille renderer */
static void hammersley_create(double *out, int n)
{
double p, t;
int k, kk;
for (k = 0; k < n; k++) {
t = 0;
for (p = 0.5, kk = k; kk; p *= 0.5, kk >>= 1) {
if (kk &
1) { /* kk mod 2 =
1 */
t += p;
}
}
out[2 * k + 0] = (double)k / (double)n;
out[2 * k + 1] = t;
}
}
static struct QMCSampler *QMC_initSampler(int type, int tot)
{
QMCSampler *qsa = MEM_callocN(sizeof(QMCSampler), "qmc sampler");
qsa->samp2d = MEM_callocN(2*sizeof(double)*tot, "qmc sample table");
qsa->tot = tot;
qsa->type = type;
if (qsa->type==SAMP_TYPE_HAMMERSLEY)
hammersley_create(qsa->samp2d, qsa->tot);
return qsa;
}
static void QMC_initPixel(QMCSampler *qsa, int thread)
{
if (qsa->type==SAMP_TYPE_HAMMERSLEY)
{
/* hammersley sequence is fixed, already created in QMCSampler init.
* per pixel, gets a random
offset. We create separate offsets per thread, for write-safety */
qsa->offs[thread][0] = 0.5 * BLI_thread_frand(thread);
qsa->offs[thread][1] = 0.5 * BLI_thread_frand(thread);
}
else { /* SAMP_TYPE_HALTON */
/* generate a new randomised halton sequence per pixel
* to alleviate qmc artifacts and make it reproducable
* between threads/frames */
double ht_invprimes[2], ht_nums[2];
double r[2];
int i;
ht_nums[0] = BLI_thread_frand(thread);
ht_nums[1] = BLI_thread_frand(thread);
ht_invprimes[0] = 0.5;
ht_invprimes[1] = 1.0/3.0;
for (i=0; i< qsa->tot; i++) {
halton_sample(ht_invprimes, ht_nums, r);
qsa->samp2d[2*i+0] = r[0];
qsa->samp2d[2*i+1] = r[1];
}
}
}
static void QMC_freeSampler(QMCSampler *qsa)
{
MEM_freeN(qsa->samp2d);
MEM_freeN(qsa);
}
static void QMC_getSample(double *s, QMCSampler *qsa, int thread, int num)
{
if (qsa->type == SAMP_TYPE_HAMMERSLEY) {
s[0] = fmod(qsa->samp2d[2*num+0] + qsa->offs[thread][0], 1.0f);
s[1] = fmod(qsa->samp2d[2*num+1] + qsa->offs[thread][1], 1.0f);
}
else { /* SAMP_TYPE_HALTON */
s[0] = qsa->samp2d[2*num+0];
s[1] = qsa->samp2d[2*num+1];
}
}
/* phong weighted disc using 'blur' for exponent, centred on 0,0 */
static void QMC_samplePhong(float *vec, QMCSampler *qsa, int thread, int num, float blur)
{
double s[2];
float phi, pz, sqr;
QMC_getSample(s, qsa, thread, num);
phi = s[0]*2*M_PI;
pz = pow(s[1], blur);
sqr = sqrt(1.0f-pz*pz);
vec[0] = cos(phi)*sqr;
vec[1] = sin(phi)*sqr;
vec[2] = 0.0f;
}
/* rect of edge lengths sizex, sizey, centred on 0.0,0.0 i.e. ranging from -sizex/2 to +sizey/2 */
static void QMC_sampleRect(float *vec, QMCSampler *qsa, int thread, int num, float sizex, float sizey)
{
double s[2];
QMC_getSample(s, qsa, thread, num);
vec[0] = (s[0] - 0.5) * sizex;
vec[1] = (s[1] - 0.5) * sizey;
vec[2] = 0.0f;
}
/* disc of radius 'radius', centred on 0,0 */
static void QMC_sampleDisc(float *vec, QMCSampler *qsa, int thread, int num, float radius)
{
double s[2];
float phi, sqr;
QMC_getSample(s, qsa, thread, num);
phi = s[0]*2*M_PI;
sqr = sqrt(s[1]);
vec[0] = cos(phi)*sqr* radius/2.0;
vec[1] = sin(phi)*sqr* radius/2.0;
vec[2] = 0.0f;
}
/* uniform hemisphere sampling */
static void QMC_sampleHemi(float *vec, QMCSampler *qsa, int thread, int num)
{
double s[2];
float phi, sqr;
QMC_getSample(s, qsa, thread, num);
phi = s[0]*2.f*M_PI;
sqr = sqrt(s[1]);
vec[0] = cos(phi)*sqr;
vec[1] = sin(phi)*sqr;
vec[2] = 1.f - s[1]*s[1];
}
#if 0 /* currently not used */
/* cosine weighted hemisphere sampling */
static void QMC_sampleHemiCosine(float *vec, QMCSampler *qsa, int thread, int num)
{
double s[2];
float phi, sqr;
QMC_getSample(s, qsa, thread, num);
phi = s[0]*2.f*M_PI;
sqr = s[1]*sqrt(2-s[1]*s[1]);
vec[0] = cos(phi)*sqr;
vec[1] = sin(phi)*sqr;
vec[2] = 1.f - s[1]*s[1];
}
#endif
/* called from convertBlenderScene.c */
void init_render_qmcsampler(Render *re)
{
re->qmcsamplers= MEM_callocN(sizeof(ListBase)*BLENDER_MAX_THREADS, "QMCListBase");
}
static QMCSampler *get_thread_qmcsampler(Render *re, int thread, int type, int tot)
{
QMCSampler *qsa;
/* create qmc samplers as needed, since recursion makes it hard to
* predict how many are needed */
for(qsa=re->qmcsamplers[thread].first; qsa; qsa=qsa->next) {
if(qsa->type == type && qsa->tot == tot && !qsa->used) {
qsa->used= 1;
return qsa;
}
}
qsa= QMC_initSampler(type, tot);
qsa->used= 1;
BLI_addtail(&re->qmcsamplers[thread], qsa);
return qsa;
}
static void release_thread_qmcsampler(Render *re, int thread, QMCSampler *qsa)
{
qsa->used= 0;
}
void free_render_qmcsampler(Render *re)
{
QMCSampler *qsa, *next;
int a;
if(re->qmcsamplers) {
for(a=0; a<BLENDER_MAX_THREADS; a++) {
for(qsa=re->qmcsamplers[a].first; qsa; qsa=next) {
next= qsa->next;
QMC_freeSampler(qsa);
}
re->qmcsamplers[a].first= re->qmcsamplers[a].last= NULL;
}
MEM_freeN(re->qmcsamplers);
re->qmcsamplers= NULL;
}
}
static int adaptive_sample_variance(int samples, float *col, float *colsq, float thresh)
{
float var[3], mean[3];
/* scale threshold just to give a bit more precision in input rather than dealing with
* tiny tiny numbers in the UI */
thresh /= 2;
mean[0] = col[0] / (float)samples;
mean[1] = col[1] / (float)samples;
mean[2] = col[2] / (float)samples;
var[0] = (colsq[0] / (float)samples) - (mean[0]*mean[0]);
var[1] = (colsq[1] / (float)samples) - (mean[1]*mean[1]);
var[2] = (colsq[2] / (float)samples) - (mean[2]*mean[2]);
if ((var[0] * 0.4 < thresh) && (var[1] * 0.3 < thresh) && (var[2] * 0.6 < thresh))
return 1;
else
return 0;
}
static int adaptive_sample_contrast_val(int samples, float prev, float val, float thresh)
{
/* if the last sample's contribution to the total value was below a small threshold
* (i.e. the samples taken are very similar), then taking more samples that are probably
* going to be the same is wasting effort */
if (fabs( prev/(float)(samples-1) - val/(float)samples ) < thresh) {
return 1;
} else
return 0;
}
static float get_avg_speed(ShadeInput *shi)
{
float pre_x, pre_y, post_x, post_y, speedavg;
pre_x = (shi->winspeed[0] == PASS_VECTOR_MAX)?0.0:shi->winspeed[0];
pre_y = (shi->winspeed[1] == PASS_VECTOR_MAX)?0.0:shi->winspeed[1];
post_x = (shi->winspeed[2] == PASS_VECTOR_MAX)?0.0:shi->winspeed[2];
post_y = (shi->winspeed[3] == PASS_VECTOR_MAX)?0.0:shi->winspeed[3];
speedavg = (sqrt(pre_x*pre_x + pre_y*pre_y) + sqrt(post_x*post_x + post_y*post_y)) / 2.0;
return speedavg;
}
/* ***************** main calls ************** */
static void trace_refract(float *col, ShadeInput *shi, ShadeResult *shr)
{
QMCSampler *qsa=NULL;
int samp_type;
int traflag=0;
float samp3d[3], orthx[3], orthy[3];
float v_refract[3], v_refract_new[3];
float sampcol[4], colsq[4];
float blur = pow(1.0 - shi->mat->gloss_tra, 3);
short max_samples = shi->mat->samp_gloss_tra;
float adapt_thresh = shi->mat->adapt_thresh_tra;
int samples=0;
colsq[0] = colsq[1] = colsq[2] = 0.0;
col[0] = col[1] = col[2] = 0.0;
col[3]= shr->alpha;
if (blur > 0.0) {
if (adapt_thresh != 0.0) samp_type = SAMP_TYPE_HALTON;
else samp_type = SAMP_TYPE_HAMMERSLEY;
/* all samples are generated per pixel */
qsa = get_thread_qmcsampler(&R, shi->thread, samp_type, max_samples);
QMC_initPixel(qsa, shi->thread);
} else
max_samples = 1;
while (samples < max_samples) {
if(refraction(v_refract, shi->vn, shi->view, shi->ang)) {
traflag |= RAY_INSIDE;
} else {
/* total
external reflection can happen for materials with IOR < 1.0 */
if((shi->vlr->flag & R_SMOOTH))
reflection(v_refract, shi->vn, shi->view,
shi->facenor);
else
reflection(v_refract, shi->vn, shi->view,
NULL);
/* can't blur total external reflection */
max_samples = 1;
}
if (max_samples > 1) {
/* get a quasi-random vector from a phong-weighted disc */
QMC_samplePhong(samp3d, qsa, shi->thread, samples, blur);
ortho_basis_v3v3_v3( orthx, orthy,v_refract);
mul_v3_fl(orthx, samp3d[0]);
mul_v3_fl(orthy, samp3d[1]);
/* and perturb the refraction vector in it */
add_v3_v3v3(v_refract_new, v_refract, orthx);
add_v3_v3(v_refract_new, orthy);
normalize_v3(v_refract_new);
} else {
/* no blurriness, use the original normal */
VECCOPY(v_refract_new, v_refract);
}
sampcol[0]= sampcol[1]= sampcol[2]= sampcol[3]= 0.0f;
//CreateTiming("Raytracing begins...");
traceray(shi, shr,
shi->mat->ray_depth_tra, shi->co, v_refract_new, sampcol,
shi->obi, shi->vlr, traflag);
//CreateTiming("Raytracing ends...");
col[0] += sampcol[0];
col[1] += sampcol[1];
col[2] += sampcol[2];
col[3] += sampcol[3];
/* for variance calc */
colsq[0] += sampcol[0]*sampcol[0];
colsq[1] += sampcol[1]*sampcol[1];
colsq[2] += sampcol[2]*sampcol[2];
samples++;
/* adaptive sampling */
if (adapt_thresh < 1.0 && samples > max_samples/2)
{
if (adaptive_sample_variance(samples, col, colsq, adapt_thresh))
break;
/* if the
pixel so far is very dark, we can get away with less samples */
if ( (col[0] + col[1] + col[2])/3.0/(float)samples < 0.01 )
max_samples--;
}
}
col[0] /= (float)samples;
col[1] /= (float)samples;
col[2] /= (float)samples;
col[3] /= (float)samples;
if (qsa)
release_thread_qmcsampler(&R, shi->thread, qsa);
}
static void trace_reflect(float *col, ShadeInput *shi, ShadeResult *shr, float fresnelfac)
{
QMCSampler *qsa=NULL;
int samp_type;
float samp3d[3], orthx[3], orthy[3];
float v_nor_new[3], v_reflect[3];
float sampcol[4], colsq[4];
float blur = pow(1.0 - shi->mat->gloss_mir, 3);
short max_samples = shi->mat->samp_gloss_mir;
float adapt_thresh = shi->mat->adapt_thresh_mir;
float aniso = 1.0 - shi->mat->aniso_gloss_mir;
int samples=0;
col[0] = col[1] = col[2] = 0.0;
colsq[0] = colsq[1] = colsq[2] = 0.0;
if (blur > 0.0) {
if (adapt_thresh != 0.0) samp_type = SAMP_TYPE_HALTON;
else samp_type = SAMP_TYPE_HAMMERSLEY;
/* all samples are generated per pixel */
qsa = get_thread_qmcsampler(&R, shi->thread, samp_type, max_samples);
QMC_initPixel(qsa, shi->thread);
} else
max_samples = 1;
while (samples < max_samples) {
if (max_samples > 1) {
/* get a quasi-random vector from a phong-weighted disc */
QMC_samplePhong(samp3d, qsa, shi->thread, samples, blur);
/* find the normal's perpendicular plane, blurring along tangents
* if tangent shading enabled */
if (shi->mat->mode & (MA_TANGENT_V)) {
cross_v3_v3v3(orthx, shi->vn,
shi->tang); // bitangent
VECCOPY(orthy, shi->tang);
mul_v3_fl(orthx, samp3d[0]);
mul_v3_fl(orthy, samp3d[1]*aniso);
} else {
ortho_basis_v3v3_v3( orthx, orthy,shi->vn);
mul_v3_fl(orthx, samp3d[0]);
mul_v3_fl(orthy, samp3d[1]);
}
/* and perturb the normal in it */
add_v3_v3v3(v_nor_new, shi->vn, orthx);
add_v3_v3(v_nor_new, orthy);
normalize_v3(v_nor_new);
} else {
/* no blurriness, use the original normal */
VECCOPY(v_nor_new, shi->vn);
}
if((shi->vlr->flag & R_SMOOTH))
reflection(v_reflect, v_nor_new, shi->view, shi->facenor);
else
reflection(v_reflect, v_nor_new, shi->view, NULL);
sampcol[0]= sampcol[1]= sampcol[2]= sampcol[3]= 0.0f;
traceray(shi, shr,
shi->mat->ray_depth, shi->co, v_reflect, sampcol, shi->obi,
shi->vlr, 0);
col[0] += sampcol[0];
col[1] += sampcol[1];
col[2] += sampcol[2];
/* for variance calc */
colsq[0] += sampcol[0]*sampcol[0];
colsq[1] += sampcol[1]*sampcol[1];
colsq[2] += sampcol[2]*sampcol[2];
samples++;
/* adaptive sampling */
if (adapt_thresh > 0.0 && samples > max_samples/3)
{
if (adaptive_sample_variance(samples, col, colsq, adapt_thresh))
break;
/* if the
pixel so far is very dark, we can get away with less samples */
if ( (col[0] + col[1] + col[2])/3.0/(float)samples < 0.01 )
max_samples--;
/* reduce
samples when reflection is dim due to low ray mirror blend value or
fresnel factor
* and when reflection is blurry */
if (fresnelfac < 0.1 * (blur+1)) {
max_samples--;
/* even more for very dim */
if (fresnelfac < 0.05 * (blur+1))
max_samples--;
}
}
}
col[0] /= (float)samples;
col[1] /= (float)samples;
col[2] /= (float)samples;
if (qsa)
release_thread_qmcsampler(&R, shi->thread, qsa);
}
/* extern call from render loop */
void ray_trace(ShadeInput *shi, ShadeResult *shr)
{
float i, f, f1, fr, fg, fb;
float mircol[4], tracol[4];
float diff[3];
int do_tra, do_mir;
do_tra= ((shi->mode & MA_TRANSP) &&
(shi->mode & MA_RAYTRANSP) && shr->alpha!=1.0f
&& (shi->depth <= shi->mat->ray_depth_tra));
do_mir= ((shi->mat->mode & MA_RAYMIRROR)
&& shi->ray_mirror!=0.0f && (shi->depth <=
shi->mat->ray_depth));
/* raytrace mirror amd refract like to separate the spec color */
if(shi->combinedflag & SCE_PASS_SPEC)
VECSUB(diff, shr->combined, shr->spec) /* no ; */
else
VECCOPY(diff, shr->combined);
if(do_tra) {
float olddiff[3];
trace_refract(tracol, shi, shr);
f= shr->alpha; f1= 1.0f-f;
fr= 1.0f+ shi->mat->filter*(shi->r-1.0f);
fg= 1.0f+ shi->mat->filter*(shi->g-1.0f);
fb= 1.0f+ shi->mat->filter*(shi->b-1.0f);
/* for refract pass */
VECCOPY(olddiff, diff);
diff[0]= f*diff[0] + f1*fr*tracol[0];
diff[1]= f*diff[1] + f1*fg*tracol[1];
diff[2]= f*diff[2] + f1*fb*tracol[2];
if(shi->passflag & SCE_PASS_REFRACT)
VECSUB(shr->refr, diff, olddiff);
if(!(shi->combinedflag & SCE_PASS_REFRACT))
VECSUB(diff, diff, shr->refr);
shr->alpha= MIN2(1.0f, tracol[3]);
}
if(do_mir) {
i=
shi->ray_mirror*fresnel_fac(shi->view, shi->vn,
shi->mat->fresnel_mir_i, shi->mat->fresnel_mir);
if(i!=0.0f) {
trace_reflect(mircol, shi, shr, i);
fr= i*shi->mirr;
fg= i*shi->mirg;
fb= i*shi->mirb;
if(shi->passflag & SCE_PASS_REFLECT) {
/* mirror pass is not blocked out with spec */
shr->refl[0]= fr*mircol[0] - fr*diff[0];
shr->refl[1]= fg*mircol[1] - fg*diff[1];
shr->refl[2]= fb*mircol[2] - fb*diff[2];
}
if(shi->combinedflag & SCE_PASS_REFLECT) {
/* values in shr->spec can be greater then 1.0.
* In this case the mircol uses a zero blending
factor, so ignoring it is ok.
* Fixes bug #18837 - when the spec is higher
then 1.0,
* diff can become a negative color -
Campbell */
f1= 1.0f-i;
diff[0] *= f1;
diff[1] *= f1;
diff[2] *= f1;
if(shr->spec[0]<1.0f)
diff[0] += mircol[0] * (fr*(1.0f-shr->spec[0]));
if(shr->spec[1]<1.0f)
diff[1] += mircol[1] * (fg*(1.0f-shr->spec[1]));
if(shr->spec[2]<1.0f)
diff[2] += mircol[2] * (fb*(1.0f-shr->spec[2]));
}
}
}
/* put back together */
if(shi->combinedflag & SCE_PASS_SPEC)
VECADD(shr->combined, diff, shr->spec) /* no ; */
else
VECCOPY(shr->combined, diff);
}
/* color 'shadfac' passes through 'col' with alpha and filter */
/* filter is only applied on alpha defined transparent part */
static void addAlphaLight(float *shadfac, float *col, float alpha, float filter)
{
float fr, fg, fb;
fr= 1.0f+ filter*(col[0]-1.0f);
fg= 1.0f+ filter*(col[1]-1.0f);
fb= 1.0f+ filter*(col[2]-1.0f);
shadfac[0]= alpha*col[0] + fr*(1.0f-alpha)*shadfac[0];
shadfac[1]= alpha*col[1] + fg*(1.0f-alpha)*shadfac[1];
shadfac[2]= alpha*col[2] + fb*(1.0f-alpha)*shadfac[2];
shadfac[3]= (1.0f-alpha)*shadfac[3];
}
static void ray_trace_shadow_tra(Isect *is, ShadeInput *origshi, int depth, int traflag, float col[4])
{
/* ray to lamp, find first face that intersects, check alpha properties,
if it has col[3]>0.0f continue. so exit when alpha is full */
ShadeInput shi;
ShadeResult shr;
float initial_dist = is->dist;
if(RE_rayobject_raycast(R.raytree, is)) {
float d= 1.0f;
/* we got a face */
/* Warning, This is not that nice, and possibly a bit slow for every ray,
however some variables were not
initialized properly in, unless using shade_input_initialize(...), we
need to do a memset */
memset(&shi, 0, sizeof(ShadeInput));
/* end warning! - Campbell */
shi.depth= origshi->depth +
1;
/* only used to indicate tracing
*/
shi.mask= origshi->mask;
shi.thread= origshi->thread;
shi.passflag= SCE_PASS_COMBINED;
shi.combinedflag=
0xFFFFFF; /* ray trace does
all options */
shi.xs= origshi->xs;
shi.ys= origshi->ys;
shi.lay= origshi->lay;
shi.nodes= origshi->nodes;
shade_ray(is, &shi, &shr);
if (shi.mat->material_type == MA_TYPE_SURFACE) {
if (traflag & RAY_TRA)
d= shade_by_transmission(is, &shi, &shr);
/* mix colors based on shadfac (rgb + amount of light factor) */
addAlphaLight(col, shr.diff, shr.alpha, d*shi.mat->filter);
} else if (shi.mat->material_type == MA_TYPE_VOLUME) {
const float a = col[3];
col[0] = a*col[0] + shr.alpha*shr.combined[0];
col[1] = a*col[1] + shr.alpha*shr.combined[1];
col[2] = a*col[2] + shr.alpha*shr.combined[2];
col[3] = (1.0 - shr.alpha)*a;
}
if(depth>0 && col[3]>0.0f) {
/* adapt isect struct */
VECCOPY(is->start, shi.co);
is->dist = initial_dist-is->dist;
is->orig.ob = shi.obi;
is->orig.face = shi.vlr;
ray_trace_shadow_tra(is, origshi, depth-1, traflag | RAY_TRA, col);
}
RE_RC_MERGE(&origshi->raycounter, &shi.raycounter);
}
}
/* not used, test function for ambient occlusion (yaf: pathlight) */
/* main problem; has to be called within shading loop, giving unwanted recursion */
int ray_trace_shadow_rad(ShadeInput *ship, ShadeResult *shr)
{
static int counter=0, only_one= 0;
extern float hashvectf[];
Isect isec;
ShadeInput shi;
ShadeResult shr_t;
float vec[3], accum[3], div= 0.0f;
int a;
assert(0);
if(only_one) {
return 0;
}
only_one= 1;
accum[0]= accum[1]= accum[2]= 0.0f;
isec.mode= RE_RAY_MIRROR;
isec.orig.ob = ship->obi;
isec.orig.face = ship->vlr;
isec.hint = 0;
VECCOPY(isec.start, ship->co);
RE_RC_INIT(isec, shi);
for(a=0; a<8*8; a++) {
counter+=3;
counter %= 768;
VECCOPY(vec, hashvectf+counter);
if(ship->vn[0]*vec[0]+ship->vn[1]*vec[1]+ship->vn[2]*vec[2]>0.0f) {
vec[0]-= vec[0];
vec[1]-= vec[1];
vec[2]-= vec[2];
}
VECCOPY(isec.dir, vec );
isec.dist = RE_RAYTRACE_MAXDIST;
if(RE_rayobject_raycast(R.raytree, &isec)) {
float fac;
/* Warning,
This is not that nice, and possibly a bit slow for every ray,
however some
variables were not initialized properly in, unless using
shade_input_initialize(...), we need to do a memset */
memset(&shi, 0, sizeof(ShadeInput));
/* end warning! - Campbell */
shade_ray(&isec, &shi, &shr_t);
fac= isec.dist*isec.dist;
fac= 1.0f;
accum[0]+= fac*(shr_t.diff[0]+shr_t.spec[0]);
accum[1]+= fac*(shr_t.diff[1]+shr_t.spec[1]);
accum[2]+= fac*(shr_t.diff[2]+shr_t.spec[2]);
div+= fac;
}
else div+= 1.0f;
}
if(div!=0.0f) {
shr->diff[0]+= accum[0]/div;
shr->diff[1]+= accum[1]/div;
shr->diff[2]+= accum[2]/div;
}
shr->alpha= 1.0f;
only_one= 0;
return 1;
}
/* aolight: function to create random unit sphere vectors for total random sampling */
static void RandomSpherical(float *v)
{
float r;
v[2] = 2.f*BLI_frand()-1.f;
if ((r = 1.f - v[2]*v[2])>0.f) {
float a = 6.283185307f*BLI_frand();
r = sqrt(r);
v[0] = r * cos(a);
v[1] = r * sin(a);
}
else v[2] = 1.f;
}
/* calc distributed spherical energy */
static void DS_energy(float *sphere, int tot, float *vec)
{
float *fp, fac, force[3], res[3];
int a;
res[0]= res[1]= res[2]= 0.0f;
for(a=0, fp=sphere; a<tot; a++, fp+=3) {
sub_v3_v3v3(force, vec, fp);
fac= force[0]*force[0] + force[1]*force[1] + force[2]*force[2];
if(fac!=0.0f) {
fac= 1.0f/fac;
res[0]+= fac*force[0];
res[1]+= fac*force[1];
res[2]+= fac*force[2];
}
}
mul_v3_fl(res, 0.5);
add_v3_v3(vec, res);
normalize_v3(vec);
}
/* called from convertBlenderScene.c */
/* creates an equally distributed spherical sample pattern */
/* and allocates threadsafe memory */
void init_ao_sphere(World *wrld)
{
float *fp;
int a, tot, iter= 16;
/* we make twice the amount of samples, because only a hemisphere is used */
tot= 2*wrld->aosamp*wrld->aosamp;
wrld->aosphere= MEM_mallocN(3*tot*sizeof(float), "AO sphere");
/* fixed random */
BLI_srandom(tot);
/* init */
fp= wrld->aosphere;
for(a=0; a<tot; a++, fp+= 3) {
RandomSpherical(fp);
}
while(iter--) {
for(a=0, fp= wrld->aosphere; a<tot; a++, fp+= 3) {
DS_energy(wrld->aosphere, tot, fp);
}
}
/* tables */
wrld->aotables= MEM_mallocN(BLENDER_MAX_THREADS*3*tot*sizeof(float), "AO tables");
}
/* give per thread a table, we have to compare xs ys because of way OSA works... */
static float *threadsafe_table_sphere(int test, int thread, int xs, int ys, int tot)
{
static int xso[BLENDER_MAX_THREADS], yso[BLENDER_MAX_THREADS];
static int firsttime= 1;
if(firsttime) {
memset(xso, 255, sizeof(xso));
memset(yso, 255, sizeof(yso));
firsttime= 0;
}
if(xs==xso[thread] && ys==yso[thread]) return R.wrld.aotables+ thread*tot*3;
if(test) return NULL;
xso[thread]= xs; yso[thread]= ys;
return R.wrld.aotables+ thread*tot*3;
}
static float *sphere_sampler(int type, int resol, int thread, int xs, int ys, int reset)
{
int tot;
float *vec;
tot= 2*resol*resol;
if (type & WO_AORNDSMP) {
float *sphere;
int a;
// always returns table
sphere= threadsafe_table_sphere(0, thread, xs, ys, tot);
/* total random sampling. NOT THREADSAFE! (should be removed, is not useful) */
vec= sphere;
for (a=0; a<tot; a++, vec+=3) {
RandomSpherical(vec);
}
return sphere;
}
else {
float *sphere;
float cosfi, sinfi, cost, sint;
float ang, *vec1;
int a;
// returns table if xs and ys were equal to last call, and not resetting
sphere= (reset)? NULL: threadsafe_table_sphere(1, thread, xs, ys, tot);
if(sphere==NULL) {
sphere= threadsafe_table_sphere(0, thread, xs, ys, tot);
// random rotation
ang= BLI_thread_frand(thread);
sinfi= sin(ang); cosfi= cos(ang);
ang= BLI_thread_frand(thread);
sint= sin(ang); cost= cos(ang);
vec= R.wrld.aosphere;
vec1= sphere;
for (a=0; a<tot; a++, vec+=3, vec1+=3) {
vec1[0]= cost*cosfi*vec[0] - sinfi*vec[1] +
sint*cosfi*vec[2];
vec1[1]= cost*sinfi*vec[0] + cosfi*vec[1] +
sint*sinfi*vec[2];
vec1[2]= -sint*vec[0] + cost*vec[2];
}
}
return sphere;
}
}
static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
{
Isect isec;
RayHint point_hint;
QMCSampler *qsa=NULL;
float samp3d[3];
float up[3], side[3], dir[3], nrm[3];
float maxdist = R.wrld.aodist;
float fac=0.0f, prev=0.0f;
float adapt_thresh = R.wrld.ao_adapt_thresh;
float adapt_speed_fac = R.wrld.ao_adapt_speed_fac;
int samples=0;
int max_samples = R.wrld.aosamp*R.wrld.aosamp;
float dxyview[3], skyadded=0;
int envcolor;
RE_RC_INIT(isec, *shi);
isec.orig.ob = shi->obi;
isec.orig.face = shi->vlr;
isec.check = RE_CHECK_VLR_NON_SOLID_MATERIAL;
isec.skip = RE_SKIP_VLR_NEIGHBOUR;
isec.hint = 0;
isec.hit.ob = 0;
isec.hit.face = 0;
isec.last_hit = NULL;
isec.mode= (R.wrld.aomode & WO_AODIST)?RE_RAY_SHADOW_TRA:RE_RAY_SHADOW;
isec.lay= -1;
VECCOPY(isec.start, shi->co);
RE_rayobject_hint_bb( R.raytree, &point_hint, isec.start, isec.start );
isec.hint = &point_hint;
zero_v3(ao);
zero_v3(env);
/* prevent sky colors to be added for only shadow (shadow becomes alpha) */
envcolor= R.wrld.aocolor;
if(shi->mat->mode & MA_ONLYSHADOW)
envcolor= WO_AOPLAIN;
if(envcolor == WO_AOSKYTEX) {
dxyview[0]= 1.0f/(float)R.wrld.aosamp;
dxyview[1]= 1.0f/(float)R.wrld.aosamp;
dxyview[2]= 0.0f;
}
if(shi->vlr->flag & R_SMOOTH) {
VECCOPY(nrm, shi->vn);
}
else {
VECCOPY(nrm, shi->facenor);
}
ortho_basis_v3v3_v3( up, side,nrm);
/* sampling init */
if (R.wrld.ao_samp_method==WO_AOSAMP_HALTON) {
float speedfac;
speedfac = get_avg_speed(shi) * adapt_speed_fac;
CLAMP(speedfac, 1.0, 1000.0);
max_samples /= speedfac;
if (max_samples < 5) max_samples = 5;
qsa = get_thread_qmcsampler(&R, shi->thread, SAMP_TYPE_HALTON, max_samples);
} else if (R.wrld.ao_samp_method==WO_AOSAMP_HAMMERSLEY)
qsa = get_thread_qmcsampler(&R, shi->thread, SAMP_TYPE_HAMMERSLEY, max_samples);
QMC_initPixel(qsa, shi->thread);
while (samples < max_samples) {
/* sampling, returns quasi-random vector in unit hemisphere */
QMC_sampleHemi(samp3d, qsa, shi->thread, samples);
dir[0] = (samp3d[0]*up[0] + samp3d[1]*side[0] + samp3d[2]*nrm[0]);
dir[1] = (samp3d[0]*up[1] + samp3d[1]*side[1] + samp3d[2]*nrm[1]);
dir[2] = (samp3d[0]*up[2] + samp3d[1]*side[2] + samp3d[2]*nrm[2]);
normalize_v3(dir);
isec.dir[0] = -dir[0];
isec.dir[1] = -dir[1];
isec.dir[2] = -dir[2];
isec.dist = maxdist;
prev = fac;
if(RE_rayobject_raycast(R.raytree, &isec)) {
if
(R.wrld.aomode & WO_AODIST) fac+= exp(-isec.dist*R.wrld.aodistfac);
else fac+= 1.0f;
}
else if(envcolor!=WO_AOPLAIN) {
float skycol[4];
float skyfac, view[3];
view[0]= -dir[0];
view[1]= -dir[1];
view[2]= -dir[2];
normalize_v3(view);
if(envcolor==WO_AOSKYCOL) {
skyfac= 0.5*(1.0f+view[0]*R.grvec[0]+
view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
env[0]+= (1.0f-skyfac)*R.wrld.horr +
skyfac*R.wrld.zenr;
env[1]+= (1.0f-skyfac)*R.wrld.horg +
skyfac*R.wrld.zeng;
env[2]+= (1.0f-skyfac)*R.wrld.horb +
skyfac*R.wrld.zenb;
}
else { /* WO_AOSKYTEX */
shadeSkyView(skycol, isec.start, view, dxyview,
shi->thread);
shadeSunView(skycol, shi->view);
env[0]+= skycol[0];
env[1]+= skycol[1];
env[2]+= skycol[2];
}
skyadded++;
}
samples++;
if (qsa->type == SAMP_TYPE_HALTON) {
/* adaptive
sampling - consider samples below threshold as in shadow (or vice
versa) and exit early */
if (adapt_thresh > 0.0 && (samples > max_samples/2) ) {
if (adaptive_sample_contrast_val(samples, prev, fac,
adapt_thresh)) {
break;
}
}
}
}
/* average color times distances/hits formula */
ao[0]= ao[1]= ao[2]= 1.0f - fac/(float)samples;
if(envcolor!=WO_AOPLAIN && skyadded)
mul_v3_fl(env, (1.0f - fac/(float)samples)/((float)skyadded));
else
copy_v3_v3(env, ao);
if (qsa)
release_thread_qmcsampler(&R, shi->thread, qsa);
}
/* extern call from shade_lamp_loop, ambient occlusion calculus */
static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
{
Isect isec;
RayHint point_hint;
float *vec, *nrm, bias, sh=0.0f;
float maxdist = R.wrld.aodist;
float dxyview[3];
int j= -1, tot, actual=0, skyadded=0, envcolor, resol= R.wrld.aosamp;
RE_RC_INIT(isec, *shi);
isec.orig.ob = shi->obi;
isec.orig.face = shi->vlr;
isec.check = RE_CHECK_VLR_RENDER;
isec.skip = RE_SKIP_VLR_NEIGHBOUR;
isec.hint = 0;
isec.hit.ob = 0;
isec.hit.face = 0;
isec.last_hit = NULL;
isec.mode= (R.wrld.aomode & WO_AODIST)?RE_RAY_SHADOW_TRA:RE_RAY_SHADOW;
isec.lay= -1;
VECCOPY(isec.start, shi->co);
RE_rayobject_hint_bb( R.raytree, &point_hint, isec.start, isec.start );
isec.hint = &point_hint;
zero_v3(ao);
zero_v3(env);
/* bias prevents smoothed faces to appear flat */
if(shi->vlr->flag & R_SMOOTH) {
bias= R.wrld.aobias;
nrm= shi->vn;
}
else {
bias= 0.0f;
nrm= shi->facenor;
}
/* prevent sky colors to be added for only shadow (shadow becomes alpha) */
envcolor= R.wrld.aocolor;
if(shi->mat->mode & MA_ONLYSHADOW)
envcolor= WO_AOPLAIN;
if(resol>32) resol= 32;
/* get sphere samples. for faces we get the same samples for sample x/y values,
for strand render we always require a new sampler because x/y are not set */
vec= sphere_sampler(R.wrld.aomode, resol, shi->thread, shi->xs, shi->ys, shi->strand != NULL);
// warning: since we use full sphere now, and dotproduct is below, we do twice as much
tot= 2*resol*resol;
if(envcolor == WO_AOSKYTEX) {
dxyview[0]= 1.0f/(float)resol;
dxyview[1]= 1.0f/(float)resol;
dxyview[2]= 0.0f;
}
while(tot--) {
if ((vec[0]*nrm[0] + vec[1]*nrm[1] + vec[2]*nrm[2]) > bias) {
/* only ao samples for mask */
if(R.r.mode & R_OSA) {
j++;
if(j==R.osa) j= 0;
if(!(shi->mask & (1<<j))) {
vec+=3;
continue;
}
}
actual++;
/* always set start/vec/dist */
isec.dir[0] = -vec[0];
isec.dir[1] = -vec[1];
isec.dir[2] = -vec[2];
isec.dist = maxdist;
/* do the trace */
if(RE_rayobject_raycast(R.raytree, &isec)) {
if (R.wrld.aomode & WO_AODIST) sh+=
exp(-isec.dist*R.wrld.aodistfac);
else sh+= 1.0f;
}
else if(envcolor!=WO_AOPLAIN) {
float skycol[4];
float fac, view[3];
view[0]= -vec[0];
view[1]= -vec[1];
view[2]= -vec[2];
normalize_v3(view);
if(envcolor==WO_AOSKYCOL) {
fac=
0.5*(1.0f+view[0]*R.grvec[0]+ view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
env[0]+= (1.0f-fac)*R.wrld.horr +
fac*R.wrld.zenr;
env[1]+= (1.0f-fac)*R.wrld.horg +
fac*R.wrld.zeng;
env[2]+= (1.0f-fac)*R.wrld.horb +
fac*R.wrld.zenb;
}
else { /* WO_AOSKYTEX */
shadeSkyView(skycol, isec.start,
view, dxyview, shi->thread);
shadeSunView(skycol,
shi->view);
env[0]+= skycol[0];
env[1]+= skycol[1];
env[2]+= skycol[2];
}
skyadded++;
}
}
// samples
vec+= 3;
}
if(actual==0) sh= 1.0f;
else sh = 1.0f - sh/((float)actual);
/* average color times distances/hits formula */
ao[0]= ao[1]= ao[2]= sh;
if(envcolor!=WO_AOPLAIN && skyadded)
mul_v3_fl(env, sh/((float)skyadded));
else
copy_v3_v3(env, ao);
}
void ray_ao(ShadeInput *shi, float *ao, float *env)
{
/* Unfortunately, the unusual way that the sphere sampler calculates roughly twice as many
* samples as are actually traced, and skips them based on bias and OSA settings makes it very difficult
* to reuse code between these two functions. This is the easiest way I can think of to do it
* --broken */
if (ELEM(R.wrld.ao_samp_method, WO_AOSAMP_HAMMERSLEY, WO_AOSAMP_HALTON))
ray_ao_qmc(shi, ao, env);
else if (R.wrld.ao_samp_method == WO_AOSAMP_CONSTANT)
ray_ao_spheresamp(shi, ao, env);
}
static void ray_shadow_jittered_coords(ShadeInput *shi, int max, float jitco[RE_MAX_OSA][3], int *totjitco)
{
/* magic numbers for reordering sample positions to give better
* results with adaptive sample, when it usually only takes 4 samples */
int order8[8] = {0, 1, 5, 6, 2, 3, 4, 7};
int order11[11] = {1, 3, 8, 10, 0, 2, 4, 5, 6, 7, 9};
int order16[16] = {1, 3, 9, 12, 0, 6, 7, 8, 13, 2, 4, 5, 10, 11, 14, 15};
int count = count_mask(shi->mask);
/* for better antialising shadow samples are distributed over the subpixel
* sample coordinates, this only works for raytracing depth 0 though */
if(!shi->strand && shi->depth == 0 && count > 1 && count <= max) {
float xs, ys, zs, view[3];
int samp, ordsamp, tot= 0;
for(samp=0; samp<R.osa; samp++) {
if(R.osa == 8) ordsamp = order8[samp];
else if(R.osa == 11) ordsamp = order11[samp];
else if(R.osa == 16) ordsamp = order16[samp];
else ordsamp = samp;
if(shi->mask & (1<<ordsamp)) {
/* zbuffer has this inverse corrected, ensures xs,ys
are inside pixel */
xs= (float)shi->scanco[0] + R.jit[ordsamp][0] +
0.5f;
ys= (float)shi->scanco[1] + R.jit[ordsamp][1] +
0.5f;
zs= shi->scanco[2];
shade_input_calc_viewco(shi, xs, ys, zs, view, NULL,
jitco[tot], NULL, NULL);
tot++;
}
}
*totjitco= tot;
}
else {
VECCOPY(jitco[0], shi->co);
*totjitco= 1;
}
}
static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *shadfac, Isect *isec)
{
QMCSampler *qsa=NULL;
int samples=0;
float samp3d[3];
float fac=0.0f, vec[3], end[3];
float colsq[4];
float adapt_thresh = lar->adapt_thresh;
int min_adapt_samples=4, max_samples = lar->ray_totsamp;
float *co;
int do_soft=1, full_osa=0, i;
float min[3], max[3];
RayHint bb_hint;
float jitco[RE_MAX_OSA][3];
int totjitco;
colsq[0] = colsq[1] = colsq[2] = 0.0;
if(isec->mode==RE_RAY_SHADOW_TRA) {
shadfac[0]= shadfac[1]= shadfac[2]= shadfac[3]= 0.0f;
} else
shadfac[3]= 1.0f;
if (lar->ray_totsamp < 2) do_soft = 0;
if ((R.r.mode & R_OSA) && (R.osa > 0)
&& (shi->vlr->flag & R_FULL_OSA)) full_osa = 1;
if (full_osa) {
if (do_soft) max_samples = max_samples/R.osa + 1;
else max_samples = 1;
} else {
if (do_soft) max_samples = lar->ray_totsamp;
else if (shi->depth == 0) max_samples = (R.osa > 4)?R.osa:5;
else max_samples = 1;
}
ray_shadow_jittered_coords(shi, max_samples, jitco, &totjitco);
/* sampling init */
if (lar->ray_samp_method==LA_SAMP_HALTON)
qsa = get_thread_qmcsampler(&R, shi->thread, SAMP_TYPE_HALTON, max_samples);
else if (lar->ray_samp_method==LA_SAMP_HAMMERSLEY)
qsa = get_thread_qmcsampler(&R, shi->thread, SAMP_TYPE_HAMMERSLEY, max_samples);
QMC_initPixel(qsa, shi->thread);
INIT_MINMAX(min, max);
for(i=0; i<totjitco; i++)
{
DO_MINMAX(jitco[i], min, max);
}
RE_rayobject_hint_bb( R.raytree, &bb_hint, min, max);
isec->hint = &bb_hint;
isec->check = RE_CHECK_VLR_RENDER;
isec->skip = RE_SKIP_VLR_NEIGHBOUR;
VECCOPY(vec, lampco);
while (samples < max_samples) {
isec->orig.ob = shi->obi;
isec->orig.face = shi->vlr;
/* manually jitter the start shading co-ord per sample
* based on the pre-generated OSA texture sampling offsets,
* for anti-aliasing sharp shadow edges. */
co = jitco[samples % totjitco];
if (do_soft) {
/* sphere shadow source */
if (lar->type == LA_LOCAL) {
float ru[3], rv[3], v[3], s[3];
/* calc tangent plane vectors */
v[0] = co[0] - lampco[0];
v[1] = co[1] - lampco[1];
v[2] = co[2] - lampco[2];
normalize_v3(v);
ortho_basis_v3v3_v3( ru, rv,v);
/* sampling, returns quasi-random vector in
area_size disc */
QMC_sampleDisc(samp3d, qsa, shi->thread,
samples,lar->area_size);
/* distribute disc samples across the tangent plane
*/
s[0] = samp3d[0]*ru[0] + samp3d[1]*rv[0];
s[1] = samp3d[0]*ru[1] + samp3d[1]*rv[1];
s[2] = samp3d[0]*ru[2] + samp3d[1]*rv[2];
VECCOPY(samp3d, s);
}
else {
/* sampling, returns quasi-random vector in
[sizex,sizey]^2 plane */
QMC_sampleRect(samp3d, qsa, shi->thread, samples,
lar->area_size, lar->area_sizey);
/* align samples to lamp vector */
mul_m3_v3(lar->mat, samp3d);
}
end[0] = vec[0]+samp3d[0];
end[1] = vec[1]+samp3d[1];
end[2] = vec[2]+samp3d[2];
} else {
VECCOPY(end, vec);
}
if(shi->strand) {
/* bias away somewhat to avoid self intersection */
float jitbias= 0.5f*(len_v3(shi->dxco) + len_v3(shi->dyco));
float v[3];
VECSUB(v, co, end);
normalize_v3(v);
co[0] -= jitbias*v[0];
co[1] -= jitbias*v[1];
co[2] -= jitbias*v[2];
}
VECCOPY(isec->start, co);
isec->dir[0] = end[0]-isec->start[0];
isec->dir[1] = end[1]-isec->start[1];
isec->dir[2] = end[2]-isec->start[2];
isec->dist = normalize_v3(isec->dir);
/* trace the ray */
if(isec->mode==RE_RAY_SHADOW_TRA) {
float col[4] = {1.0f, 1.0f, 1.0f, 1.0f};
ray_trace_shadow_tra(isec, shi, DEPTH_SHADOW_TRA, 0, col);
shadfac[0] += col[0];
shadfac[1] += col[1];
shadfac[2] += col[2];
shadfac[3] += col[3];
/* for variance calc */
colsq[0] += col[0]*col[0];
colsq[1] += col[1]*col[1];
colsq[2] += col[2]*col[2];
}
else {
if( RE_rayobject_raycast(R.raytree, isec) ) fac+= 1.0f;
}
samples++;
if (lar->ray_samp_method == LA_SAMP_HALTON) {
/* adaptive
sampling - consider samples below threshold as in shadow (or vice
versa) and exit early */
if
((max_samples > min_adapt_samples) && (adapt_thresh >
0.0) && (samples > max_samples / 3)) {
if (isec->mode==RE_RAY_SHADOW_TRA) {
if ((shadfac[3] / samples >
(1.0-adapt_thresh)) || (shadfac[3] / samples < adapt_thresh))
break;
else if
(adaptive_sample_variance(samples, shadfac, colsq, adapt_thresh))
break;
} else {
if ((fac / samples >
(1.0-adapt_thresh)) || (fac / samples < adapt_thresh))
break;
}
}
}
}
if(isec->mode==RE_RAY_SHADOW_TRA) {
shadfac[0] /= samples;
shadfac[1] /= samples;
shadfac[2] /= samples;
shadfac[3] /= samples;
} else
shadfac[3]= 1.0f-fac/samples;
if (qsa)
release_thread_qmcsampler(&R, shi->thread, qsa);
}
static void ray_shadow_jitter(ShadeInput *shi, LampRen *lar, float *lampco, float *shadfac, Isect *isec)
{
/* area soft shadow */
float *jitlamp;
float fac=0.0f, div=0.0f, vec[3];
int a, j= -1, mask;
RayHint point_hint;
if(isec->mode==RE_RAY_SHADOW_TRA) {
shadfac[0]= shadfac[1]= shadfac[2]= shadfac[3]= 0.0f;
}
else shadfac[3]= 1.0f;
fac= 0.0f;
jitlamp= give_jitter_plane(lar, shi->thread, shi->xs, shi->ys);
a= lar->ray_totsamp;
/* this correction to make sure we always take at least 1 sample */
mask= shi->mask;
if(a==4) mask |= (mask>>4)|(mask>>8);
else if(a==9) mask |= (mask>>9);
VECCOPY(isec->start, shi->co);
isec->orig.ob = shi->obi;
isec->orig.face = shi->vlr;
RE_rayobject_hint_bb( R.raytree, &point_hint, isec->start, isec->start );
isec->hint = &point_hint;
while(a--) {
if(R.r.mode & R_OSA) {
j++;
if(j>=R.osa) j= 0;
if(!(mask & (1<<j))) {
jitlamp+= 2;
continue;
}
}
vec[0]= jitlamp[0];
vec[1]= jitlamp[1];
vec[2]= 0.0f;
mul_m3_v3(lar->mat, vec);
/* set start and vec */
isec->dir[0] = vec[0]+lampco[0]-isec->start[0];
isec->dir[1] = vec[1]+lampco[1]-isec->start[1];
isec->dir[2] = vec[2]+lampco[2]-isec->start[2];
isec->dist = 1.0f;
isec->check = RE_CHECK_VLR_RENDER;
isec->skip = RE_SKIP_VLR_NEIGHBOUR;
if(isec->mode==RE_RAY_SHADOW_TRA) {
/* isec.col is
like shadfac, so defines amount of light (0.0 is full shadow) */
float col[4] = {1.0f, 1.0f, 1.0f, 1.0f};
ray_trace_shadow_tra(isec, shi, DEPTH_SHADOW_TRA, 0, col);
shadfac[0] += col[0];
shadfac[1] += col[1];
shadfac[2] += col[2];
shadfac[3] += col[3];
}
else if( RE_rayobject_raycast(R.raytree, isec) ) fac+= 1.0f;
div+= 1.0f;
jitlamp+= 2;
}
if(isec->mode==RE_RAY_SHADOW_TRA) {
shadfac[0] /= div;
shadfac[1] /= div;
shadfac[2] /= div;
shadfac[3] /= div;
}
else {
// sqrt makes nice umbra effect
if(lar->ray_samp_type & LA_SAMP_UMBRA)
shadfac[3]= sqrt(1.0f-fac/div);
else
shadfac[3]= 1.0f-fac/div;
}
}
/* extern call from shade_lamp_loop */
void ray_shadow(ShadeInput *shi, LampRen *lar, float *shadfac)
{
Isect isec;
float lampco[3];
/* setup isec */
RE_RC_INIT(isec, *shi);
if(shi->mat->mode & MA_SHADOW_TRA) isec.mode= RE_RAY_SHADOW_TRA;
else isec.mode= RE_RAY_SHADOW;
isec.hint = 0;
if(lar->mode & (LA_LAYER|LA_LAYER_SHADOW))
isec.lay= lar->lay;
else
isec.lay= -1;
/* only when not mir tracing, first hit optimm */
if(shi->depth==0) {
isec.last_hit = lar->last_hit[shi->thread];
}
else {
isec.last_hit = NULL;
}
if(lar->type==LA_SUN || lar->type==LA_HEMI) {
/* jitter and QMC sampling add a displace vector to the lamp position
* that's incorrect because a SUN lamp does not has an exact position
* and the displace should be done at the ray vector instead of the
* lamp position.
* This is easily verified by noticing that shadows of SUN lights change
* with the scene BB.
*
* This was detected during SoC 2009 - Raytrace Optimization, but to keep
* consistency with older render code it wasn't removed.
*
* If the render code goes through some recode/serious bug-fix then this
* is something to consider!
*/
lampco[0]= shi->co[0] - R.maxdist*lar->vec[0];
lampco[1]= shi->co[1] - R.maxdist*lar->vec[1];
lampco[2]= shi->co[2] - R.maxdist*lar->vec[2];
}
else {
VECCOPY(lampco, lar->co);
}
if (ELEM(lar->ray_samp_method, LA_SAMP_HALTON, LA_SAMP_HAMMERSLEY)) {
ray_shadow_qmc(shi, lar, lampco, shadfac, &isec);
} else {
if(lar->ray_totsamp<2) {
isec.orig.ob = shi->obi;
isec.orig.face = shi->vlr;
shadfac[3]= 1.0f; // 1.0=full light
/* set up isec.dir */
VECCOPY(isec.start, shi->co);
VECSUB(isec.dir, lampco, isec.start);
isec.dist = normalize_v3(isec.dir);
if(isec.mode==RE_RAY_SHADOW_TRA) {
/* isec.col is like shadfac, so defines amount of
light (0.0 is full shadow) */
float col[4] = {1.0f, 1.0f, 1.0f, 1.0f};
ray_trace_shadow_tra(&isec, shi,
DEPTH_SHADOW_TRA, 0, col);
QUATCOPY(shadfac, col);
}
else if(RE_rayobject_raycast(R.raytree, &isec))
shadfac[3]= 0.0f;
}
else {
ray_shadow_jitter(shi, lar, lampco, shadfac, &isec);
}
}
/* for first hit optim, set last interesected shadow face */
if(shi->depth==0) {
lar->last_hit[shi->thread] = isec.last_hit;
}
}
#if 0
/* only when face points away from lamp, in direction of lamp, trace ray and find first exit point */
static void ray_translucent(ShadeInput *shi, LampRen *lar, float *distfac, float *co)
{
Isect isec;
float lampco[3];
assert(0);
/* setup isec */
RE_RC_INIT(isec, *shi);
isec.mode= RE_RAY_SHADOW_TRA;
isec.hint = 0;
if(lar->mode & LA_LAYER) isec.lay= lar->lay; else isec.lay= -1;
if(lar->type==LA_SUN || lar->type==LA_HEMI) {
lampco[0]= shi->co[0] - RE_RAYTRACE_MAXDIST*lar->vec[0];
lampco[1]= shi->co[1] - RE_RAYTRACE_MAXDIST*lar->vec[1];
lampco[2]= shi->co[2] - RE_RAYTRACE_MAXDIST*lar->vec[2];
}
else {
VECCOPY(lampco, lar->co);
}
isec.orig.ob = shi->obi;
isec.orig.face = shi->vlr;
/* set up isec.dir */
VECCOPY(isec.start, shi->co);
VECCOPY(isec.end, lampco);
if(RE_rayobject_raycast(R.raytree, &isec)) {
/* we got a face */
/* render co */
co[0]= isec.start[0]+isec.dist*(isec.dir[0]);
co[1]= isec.start[1]+isec.dist*(isec.dir[1]);
co[2]= isec.start[2]+isec.dist*(isec.dir[2]);
*distfac= len_v3(isec.dir);
}
else
*distfac= 0.0f;
}
#endif
กก