2011-04-27 11:58:34 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2011, Blender Foundation.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "kernel_compat_cpu.h"
|
|
|
|
#include "kernel_types.h"
|
|
|
|
#include "kernel_globals.h"
|
|
|
|
#include "kernel_object.h"
|
|
|
|
|
2012-10-20 12:18:00 +00:00
|
|
|
#include "osl_closures.h"
|
2012-12-01 19:15:05 +00:00
|
|
|
#include "osl_globals.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
#include "osl_services.h"
|
|
|
|
#include "osl_shader.h"
|
|
|
|
|
|
|
|
#include "util_foreach.h"
|
|
|
|
|
2013-01-03 12:08:54 +00:00
|
|
|
#include "attribute.h"
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
#include <OSL/oslexec.h>
|
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
|
|
|
/* Threads */
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
void OSLShader::thread_init(KernelGlobals *kg, KernelGlobals *kernel_globals, OSLGlobals *osl_globals)
|
2012-11-09 03:10:22 +00:00
|
|
|
{
|
2012-12-01 19:15:05 +00:00
|
|
|
/* no osl used? */
|
|
|
|
if(!osl_globals->use) {
|
|
|
|
kg->osl = NULL;
|
|
|
|
return;
|
|
|
|
}
|
2012-11-09 03:10:22 +00:00
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
/* per thread kernel data init*/
|
|
|
|
kg->osl = osl_globals;
|
|
|
|
kg->osl->services->thread_init(kernel_globals);
|
2012-11-09 03:10:22 +00:00
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
OSL::ShadingSystem *ss = kg->osl->ss;
|
|
|
|
OSLThreadData *tdata = new OSLThreadData();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
memset(&tdata->globals, 0, sizeof(OSL::ShaderGlobals));
|
2012-12-15 10:18:42 +00:00
|
|
|
tdata->globals.tracedata = &tdata->tracedata;
|
|
|
|
tdata->globals.flipHandedness = false;
|
2012-08-31 20:31:21 +00:00
|
|
|
tdata->thread_info = ss->create_thread_info();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
for(int i = 0; i < SHADER_CONTEXT_NUM; i++)
|
|
|
|
tdata->context[i] = ss->get_context(tdata->thread_info);
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
kg->osl_ss = (OSLShadingSystem*)ss;
|
|
|
|
kg->osl_tdata = tdata;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void OSLShader::thread_free(KernelGlobals *kg)
|
|
|
|
{
|
2012-12-01 19:15:05 +00:00
|
|
|
if(!kg->osl)
|
|
|
|
return;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss;
|
|
|
|
OSLThreadData *tdata = kg->osl_tdata;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
for(int i = 0; i < SHADER_CONTEXT_NUM; i++)
|
|
|
|
ss->release_context(tdata->context[i]);
|
|
|
|
|
2012-08-31 20:31:21 +00:00
|
|
|
ss->destroy_thread_info(tdata->thread_info);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
delete tdata;
|
2012-12-01 19:15:05 +00:00
|
|
|
|
|
|
|
kg->osl = NULL;
|
|
|
|
kg->osl_ss = NULL;
|
|
|
|
kg->osl_tdata = NULL;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Globals */
|
|
|
|
|
|
|
|
static void shaderdata_to_shaderglobals(KernelGlobals *kg, ShaderData *sd,
|
2012-12-15 10:18:42 +00:00
|
|
|
int path_flag, OSLThreadData *tdata)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-12-15 10:18:42 +00:00
|
|
|
OSL::ShaderGlobals *globals = &tdata->globals;
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* copy from shader data to shader globals */
|
|
|
|
globals->P = TO_VEC3(sd->P);
|
|
|
|
globals->dPdx = TO_VEC3(sd->dP.dx);
|
|
|
|
globals->dPdy = TO_VEC3(sd->dP.dy);
|
|
|
|
globals->I = TO_VEC3(sd->I);
|
|
|
|
globals->dIdx = TO_VEC3(sd->dI.dx);
|
|
|
|
globals->dIdy = TO_VEC3(sd->dI.dy);
|
|
|
|
globals->N = TO_VEC3(sd->N);
|
|
|
|
globals->Ng = TO_VEC3(sd->Ng);
|
|
|
|
globals->u = sd->u;
|
|
|
|
globals->dudx = sd->du.dx;
|
|
|
|
globals->dudy = sd->du.dy;
|
|
|
|
globals->v = sd->v;
|
|
|
|
globals->dvdx = sd->dv.dx;
|
|
|
|
globals->dvdy = sd->dv.dy;
|
|
|
|
globals->dPdu = TO_VEC3(sd->dPdu);
|
|
|
|
globals->dPdv = TO_VEC3(sd->dPdv);
|
2012-06-04 22:44:58 +00:00
|
|
|
globals->surfacearea = (sd->object == ~0) ? 1.0f : object_surface_area(kg, sd->object);
|
2012-11-29 16:11:37 +00:00
|
|
|
globals->time = sd->time;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* booleans */
|
2012-12-15 10:18:42 +00:00
|
|
|
globals->raytype = path_flag;
|
2011-04-27 11:58:34 +00:00
|
|
|
globals->backfacing = (sd->flag & SD_BACKFACING);
|
|
|
|
|
|
|
|
/* shader data to be used in services callbacks */
|
|
|
|
globals->renderstate = sd;
|
|
|
|
|
|
|
|
/* hacky, we leave it to services to fetch actual object matrix */
|
|
|
|
globals->shader2common = sd;
|
|
|
|
globals->object2common = sd;
|
|
|
|
|
|
|
|
/* must be set to NULL before execute */
|
|
|
|
globals->Ci = NULL;
|
2012-12-15 10:18:42 +00:00
|
|
|
|
|
|
|
/* clear trace data */
|
|
|
|
tdata->tracedata.init = false;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Surface */
|
|
|
|
|
|
|
|
static void flatten_surface_closure_tree(ShaderData *sd, bool no_glossy,
|
2012-06-04 22:44:58 +00:00
|
|
|
const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f))
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-06-05 09:29:47 +00:00
|
|
|
/* OSL gives us a closure tree, we flatten it into arrays per
|
2011-04-27 11:58:34 +00:00
|
|
|
* closure type, for evaluation, sampling, etc later on. */
|
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
|
|
|
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
|
|
|
OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive *)comp->data();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (prim) {
|
2011-09-12 13:13:56 +00:00
|
|
|
ShaderClosure sc;
|
|
|
|
sc.weight = weight;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
switch (prim->category()) {
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::BSDF: {
|
2012-10-20 12:18:00 +00:00
|
|
|
CBSDFClosure *bsdf = (CBSDFClosure *)prim;
|
|
|
|
int scattering = bsdf->scattering();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* no caustics option */
|
2012-10-20 12:18:00 +00:00
|
|
|
if (no_glossy && scattering == LABEL_GLOSSY)
|
2011-04-27 11:58:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* sample weight */
|
2012-10-20 12:18:00 +00:00
|
|
|
float sample_weight = fabsf(average(weight));
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-10-20 12:18:00 +00:00
|
|
|
sc.sample_weight = sample_weight;
|
2012-12-15 10:18:42 +00:00
|
|
|
|
|
|
|
sc.type = bsdf->sc.type;
|
|
|
|
sc.N = bsdf->sc.N;
|
|
|
|
sc.T = bsdf->sc.T;
|
|
|
|
sc.data0 = bsdf->sc.data0;
|
|
|
|
sc.data1 = bsdf->sc.data1;
|
|
|
|
sc.prim = bsdf->sc.prim;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* add */
|
2012-12-03 12:21:44 +00:00
|
|
|
if(sc.sample_weight > 1e-5f && sd->num_closure < MAX_CLOSURE) {
|
|
|
|
sd->closure[sd->num_closure++] = sc;
|
|
|
|
sd->flag |= bsdf->shaderdata_flag();
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Emissive: {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* sample weight */
|
|
|
|
float sample_weight = fabsf(average(weight));
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
sc.sample_weight = sample_weight;
|
|
|
|
sc.type = CLOSURE_EMISSION_ID;
|
2012-12-15 10:18:42 +00:00
|
|
|
sc.prim = NULL;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* flag */
|
2012-12-03 12:21:44 +00:00
|
|
|
if(sd->num_closure < MAX_CLOSURE) {
|
|
|
|
sd->closure[sd->num_closure++] = sc;
|
|
|
|
sd->flag |= SD_EMISSION;
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-11-06 19:59:02 +00:00
|
|
|
case AmbientOcclusion: {
|
|
|
|
/* sample weight */
|
|
|
|
float sample_weight = fabsf(average(weight));
|
|
|
|
|
|
|
|
sc.sample_weight = sample_weight;
|
|
|
|
sc.type = CLOSURE_AMBIENT_OCCLUSION_ID;
|
2012-12-15 10:18:42 +00:00
|
|
|
sc.prim = NULL;
|
2012-11-06 19:59:02 +00:00
|
|
|
|
2012-12-03 12:21:44 +00:00
|
|
|
if(sd->num_closure < MAX_CLOSURE) {
|
|
|
|
sd->closure[sd->num_closure++] = sc;
|
|
|
|
sd->flag |= SD_AO;
|
|
|
|
}
|
2012-11-06 19:59:02 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Holdout:
|
2011-09-12 13:13:56 +00:00
|
|
|
sc.sample_weight = 0.0f;
|
|
|
|
sc.type = CLOSURE_HOLDOUT_ID;
|
2012-12-15 10:18:42 +00:00
|
|
|
sc.prim = NULL;
|
2012-12-03 12:21:44 +00:00
|
|
|
|
|
|
|
if(sd->num_closure < MAX_CLOSURE) {
|
|
|
|
sd->closure[sd->num_closure++] = sc;
|
|
|
|
sd->flag |= SD_HOLDOUT;
|
|
|
|
}
|
2011-08-28 13:55:59 +00:00
|
|
|
break;
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::BSSRDF:
|
|
|
|
case OSL::ClosurePrimitive::Debug:
|
2011-04-27 11:58:34 +00:00
|
|
|
break; /* not implemented */
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Background:
|
|
|
|
case OSL::ClosurePrimitive::Volume:
|
2011-04-27 11:58:34 +00:00
|
|
|
break; /* not relevant */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::MUL) {
|
|
|
|
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
flatten_surface_closure_tree(sd, no_glossy, mul->closure, TO_FLOAT3(mul->weight) * weight);
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::ADD) {
|
|
|
|
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
flatten_surface_closure_tree(sd, no_glossy, add->closureA, weight);
|
|
|
|
flatten_surface_closure_tree(sd, no_glossy, add->closureB, weight);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag, ShaderContext ctx)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
/* setup shader globals from shader data */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSLThreadData *tdata = kg->osl_tdata;
|
|
|
|
shaderdata_to_shaderglobals(kg, sd, path_flag, tdata);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* execute shader for this point */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss;
|
|
|
|
OSL::ShaderGlobals *globals = &tdata->globals;
|
|
|
|
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
2011-09-27 20:37:24 +00:00
|
|
|
int shader = sd->shader & SHADER_MASK;
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
if (kg->osl->surface_state[shader])
|
2012-12-15 10:18:42 +00:00
|
|
|
ss->execute(*octx, *(kg->osl->surface_state[shader]), *globals);
|
Cycles OSL: support for the trace(point pos, vector dir, ...) function, to trace
rays from the OSL shader. The "shade" parameter is not supported currently, but
attributes can be retrieved from the object that was hit using the
getmessage("trace", ..) function.
As mentioned in the OSL specification, this function can't be used instead of
lighting, the main purpose is to allow shaders to "probe" nearby geometry, for
example to apply a projected texture that can be blocked by geometry, apply
more “wear” to exposed geometry, or make other ambient occlusion-like effects.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/OSL#Trace
Example .blend and render:
http://www.pasteall.org/blend/17347
http://www.pasteall.org/pic/show.php?id=40066
2012-11-06 19:59:10 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* flatten closure tree */
|
2011-09-12 13:13:56 +00:00
|
|
|
sd->num_closure = 0;
|
|
|
|
sd->randb_closure = randb;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (globals->Ci) {
|
2011-04-27 11:58:34 +00:00
|
|
|
bool no_glossy = (path_flag & PATH_RAY_DIFFUSE) && kernel_data.integrator.no_caustics;
|
|
|
|
flatten_surface_closure_tree(sd, no_glossy, globals->Ci);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Background */
|
|
|
|
|
|
|
|
static float3 flatten_background_closure_tree(const OSL::ClosureColor *closure)
|
|
|
|
{
|
2012-06-05 09:29:47 +00:00
|
|
|
/* OSL gives us a closure tree, if we are shading for background there
|
2011-04-27 11:58:34 +00:00
|
|
|
* is only one supported closure type at the moment, which has no evaluation
|
|
|
|
* functions, so we just sum the weights */
|
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
|
|
|
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
|
|
|
OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive *)comp->data();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (prim && prim->category() == OSL::ClosurePrimitive::Background)
|
2011-04-27 11:58:34 +00:00
|
|
|
return make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::MUL) {
|
|
|
|
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
return TO_FLOAT3(mul->weight) * flatten_background_closure_tree(mul->closure);
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::ADD) {
|
|
|
|
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
return flatten_background_closure_tree(add->closureA) +
|
2012-06-04 22:44:58 +00:00
|
|
|
flatten_background_closure_tree(add->closureB);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
}
|
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
float3 OSLShader::eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag, ShaderContext ctx)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
/* setup shader globals from shader data */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSLThreadData *tdata = kg->osl_tdata;
|
|
|
|
shaderdata_to_shaderglobals(kg, sd, path_flag, tdata);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* execute shader for this point */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss;
|
|
|
|
OSL::ShaderGlobals *globals = &tdata->globals;
|
|
|
|
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
if (kg->osl->background_state)
|
|
|
|
ss->execute(*octx, *(kg->osl->background_state), *globals);
|
Cycles OSL: support for the trace(point pos, vector dir, ...) function, to trace
rays from the OSL shader. The "shade" parameter is not supported currently, but
attributes can be retrieved from the object that was hit using the
getmessage("trace", ..) function.
As mentioned in the OSL specification, this function can't be used instead of
lighting, the main purpose is to allow shaders to "probe" nearby geometry, for
example to apply a projected texture that can be blocked by geometry, apply
more “wear” to exposed geometry, or make other ambient occlusion-like effects.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/OSL#Trace
Example .blend and render:
http://www.pasteall.org/blend/17347
http://www.pasteall.org/pic/show.php?id=40066
2012-11-06 19:59:10 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* return background color immediately */
|
2012-06-04 22:44:58 +00:00
|
|
|
if (globals->Ci)
|
2011-04-27 11:58:34 +00:00
|
|
|
return flatten_background_closure_tree(globals->Ci);
|
|
|
|
|
|
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Volume */
|
|
|
|
|
|
|
|
static void flatten_volume_closure_tree(ShaderData *sd,
|
2012-06-04 22:44:58 +00:00
|
|
|
const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f))
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-06-05 09:29:47 +00:00
|
|
|
/* OSL gives us a closure tree, we flatten it into arrays per
|
2011-04-27 11:58:34 +00:00
|
|
|
* closure type, for evaluation, sampling, etc later on. */
|
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
|
|
|
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
|
|
|
OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive *)comp->data();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (prim) {
|
2011-09-12 13:13:56 +00:00
|
|
|
ShaderClosure sc;
|
|
|
|
sc.weight = weight;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
switch (prim->category()) {
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Volume: {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* sample weight */
|
|
|
|
float sample_weight = fabsf(average(weight));
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
sc.sample_weight = sample_weight;
|
|
|
|
sc.type = CLOSURE_VOLUME_ID;
|
2012-12-15 10:18:42 +00:00
|
|
|
sc.prim = NULL;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* add */
|
2012-12-03 12:21:44 +00:00
|
|
|
if(sc.sample_weight > 1e-5f && sd->num_closure < MAX_CLOSURE)
|
|
|
|
sd->closure[sd->num_closure++] = sc;
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Holdout:
|
|
|
|
case OSL::ClosurePrimitive::Debug:
|
2011-04-27 11:58:34 +00:00
|
|
|
break; /* not implemented */
|
2012-08-31 20:08:55 +00:00
|
|
|
case OSL::ClosurePrimitive::Background:
|
|
|
|
case OSL::ClosurePrimitive::BSDF:
|
|
|
|
case OSL::ClosurePrimitive::Emissive:
|
|
|
|
case OSL::ClosurePrimitive::BSSRDF:
|
2011-04-27 11:58:34 +00:00
|
|
|
break; /* not relevant */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::MUL) {
|
|
|
|
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
flatten_volume_closure_tree(sd, mul->closure, TO_FLOAT3(mul->weight) * weight);
|
|
|
|
}
|
2012-06-04 22:44:58 +00:00
|
|
|
else if (closure->type == OSL::ClosureColor::ADD) {
|
|
|
|
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
2011-04-27 11:58:34 +00:00
|
|
|
flatten_volume_closure_tree(sd, add->closureA, weight);
|
|
|
|
flatten_volume_closure_tree(sd, add->closureB, weight);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag, ShaderContext ctx)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
/* setup shader globals from shader data */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSLThreadData *tdata = kg->osl_tdata;
|
|
|
|
shaderdata_to_shaderglobals(kg, sd, path_flag, tdata);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* execute shader */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss;
|
|
|
|
OSL::ShaderGlobals *globals = &tdata->globals;
|
|
|
|
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
2011-09-27 20:37:24 +00:00
|
|
|
int shader = sd->shader & SHADER_MASK;
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
if (kg->osl->volume_state[shader])
|
2012-12-15 10:18:42 +00:00
|
|
|
ss->execute(*octx, *(kg->osl->volume_state[shader]), *globals);
|
Cycles OSL: support for the trace(point pos, vector dir, ...) function, to trace
rays from the OSL shader. The "shade" parameter is not supported currently, but
attributes can be retrieved from the object that was hit using the
getmessage("trace", ..) function.
As mentioned in the OSL specification, this function can't be used instead of
lighting, the main purpose is to allow shaders to "probe" nearby geometry, for
example to apply a projected texture that can be blocked by geometry, apply
more “wear” to exposed geometry, or make other ambient occlusion-like effects.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/OSL#Trace
Example .blend and render:
http://www.pasteall.org/blend/17347
http://www.pasteall.org/pic/show.php?id=40066
2012-11-06 19:59:10 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (globals->Ci)
|
2011-04-27 11:58:34 +00:00
|
|
|
flatten_volume_closure_tree(sd, globals->Ci);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Displacement */
|
|
|
|
|
2012-12-15 10:18:42 +00:00
|
|
|
void OSLShader::eval_displacement(KernelGlobals *kg, ShaderData *sd, ShaderContext ctx)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
/* setup shader globals from shader data */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSLThreadData *tdata = kg->osl_tdata;
|
|
|
|
shaderdata_to_shaderglobals(kg, sd, 0, tdata);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* execute shader */
|
2012-12-15 10:18:42 +00:00
|
|
|
OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss;
|
|
|
|
OSL::ShaderGlobals *globals = &tdata->globals;
|
|
|
|
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
2011-09-27 20:37:24 +00:00
|
|
|
int shader = sd->shader & SHADER_MASK;
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
if (kg->osl->displacement_state[shader])
|
2012-12-15 10:18:42 +00:00
|
|
|
ss->execute(*octx, *(kg->osl->displacement_state[shader]), *globals);
|
Cycles OSL: support for the trace(point pos, vector dir, ...) function, to trace
rays from the OSL shader. The "shade" parameter is not supported currently, but
attributes can be retrieved from the object that was hit using the
getmessage("trace", ..) function.
As mentioned in the OSL specification, this function can't be used instead of
lighting, the main purpose is to allow shaders to "probe" nearby geometry, for
example to apply a projected texture that can be blocked by geometry, apply
more “wear” to exposed geometry, or make other ambient occlusion-like effects.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/OSL#Trace
Example .blend and render:
http://www.pasteall.org/blend/17347
http://www.pasteall.org/pic/show.php?id=40066
2012-11-06 19:59:10 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* get back position */
|
|
|
|
sd->P = TO_FLOAT3(globals->P);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* BSDF Closure */
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
int OSLShader::bsdf_sample(const ShaderData *sd, const ShaderClosure *sc, float randu, float randv, float3& eval, float3& omega_in, differential3& domega_in, float& pdf)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-10-20 12:18:00 +00:00
|
|
|
CBSDFClosure *sample_bsdf = (CBSDFClosure *)sc->prim;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
pdf = 0.0f;
|
|
|
|
|
2012-10-20 12:18:00 +00:00
|
|
|
return sample_bsdf->sample(sd->Ng,
|
|
|
|
sd->I, sd->dI.dx, sd->dI.dy,
|
|
|
|
randu, randv,
|
|
|
|
omega_in, domega_in.dx, domega_in.dy,
|
|
|
|
pdf, eval);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
float3 OSLShader::bsdf_eval(const ShaderData *sd, const ShaderClosure *sc, const float3& omega_in, float& pdf)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-10-20 12:18:00 +00:00
|
|
|
CBSDFClosure *bsdf = (CBSDFClosure *)sc->prim;
|
|
|
|
float3 bsdf_eval;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-06-04 22:44:58 +00:00
|
|
|
if (dot(sd->Ng, omega_in) >= 0.0f)
|
2012-10-20 12:18:00 +00:00
|
|
|
bsdf_eval = bsdf->eval_reflect(sd->I, omega_in, pdf);
|
2011-09-12 13:13:56 +00:00
|
|
|
else
|
2012-10-20 12:18:00 +00:00
|
|
|
bsdf_eval = bsdf->eval_transmit(sd->I, omega_in, pdf);
|
2011-09-12 13:13:56 +00:00
|
|
|
|
2012-10-20 12:18:00 +00:00
|
|
|
return bsdf_eval;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OSLShader::bsdf_blur(ShaderClosure *sc, float roughness)
|
|
|
|
{
|
|
|
|
CBSDFClosure *bsdf = (CBSDFClosure *)sc->prim;
|
|
|
|
bsdf->blur(roughness);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Emissive Closure */
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
float3 OSLShader::emissive_eval(const ShaderData *sd, const ShaderClosure *sc)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2012-06-04 22:44:58 +00:00
|
|
|
OSL::EmissiveClosure *emissive = (OSL::EmissiveClosure *)sc->prim;
|
2011-09-12 13:13:56 +00:00
|
|
|
OSL::Color3 emissive_eval = emissive->eval(TO_VEC3(sd->Ng), TO_VEC3(sd->I));
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-08-31 19:59:50 +00:00
|
|
|
return TO_FLOAT3(emissive_eval);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Volume Closure */
|
|
|
|
|
2012-10-20 12:18:00 +00:00
|
|
|
float3 OSLShader::volume_eval_phase(const ShaderClosure *sc, const float3 omega_in, const float3 omega_out)
|
2011-08-28 13:55:59 +00:00
|
|
|
{
|
2012-06-04 22:44:58 +00:00
|
|
|
OSL::VolumeClosure *volume = (OSL::VolumeClosure *)sc->prim;
|
2011-09-12 13:13:56 +00:00
|
|
|
OSL::Color3 volume_eval = volume->eval_phase(TO_VEC3(omega_in), TO_VEC3(omega_out));
|
2012-06-04 22:44:58 +00:00
|
|
|
return TO_FLOAT3(volume_eval) * sc->weight;
|
2011-08-28 13:55:59 +00:00
|
|
|
}
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
/* Attributes */
|
|
|
|
|
2013-01-03 12:08:54 +00:00
|
|
|
int OSLShader::find_attribute(KernelGlobals *kg, const ShaderData *sd, uint id, AttributeElement *elem)
|
2012-12-01 19:15:05 +00:00
|
|
|
{
|
|
|
|
/* for OSL, a hash map is used to lookup the attribute by name. */
|
2013-01-09 21:09:20 +00:00
|
|
|
int object = sd->object*ATTR_PRIM_TYPES;
|
|
|
|
#ifdef __HAIR__
|
|
|
|
if(sd->segment != ~0) object += ATTR_PRIM_CURVE;
|
|
|
|
#endif
|
|
|
|
|
2013-01-03 12:08:54 +00:00
|
|
|
OSLGlobals::AttributeMap &attr_map = kg->osl->attribute_map[object];
|
|
|
|
ustring stdname(std::string("geom:") + std::string(Attribute::standard_name((AttributeStandard)id)));
|
2012-12-01 19:15:05 +00:00
|
|
|
OSLGlobals::AttributeMap::const_iterator it = attr_map.find(stdname);
|
|
|
|
|
|
|
|
if (it != attr_map.end()) {
|
|
|
|
const OSLGlobals::Attribute &osl_attr = it->second;
|
2013-01-03 12:08:54 +00:00
|
|
|
*elem = osl_attr.elem;
|
2012-12-01 19:15:05 +00:00
|
|
|
/* return result */
|
|
|
|
return (osl_attr.elem == ATTR_ELEMENT_NONE) ? (int)ATTR_STD_NOT_FOUND : osl_attr.offset;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return (int)ATTR_STD_NOT_FOUND;
|
|
|
|
}
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|