Differential D12367 Diff 41308 intern/cycles/kernel/osl/osl_services.cpp

Changeset View

Standalone View

intern/cycles/kernel/osl/osl_services.cpp

Show All 34 Lines
#include "kernel/osl/osl_services.h"		#include "kernel/osl/osl_services.h"
#include "kernel/osl/osl_shader.h"		#include "kernel/osl/osl_shader.h"

#include "util/util_foreach.h"		#include "util/util_foreach.h"
#include "util/util_logging.h"		#include "util/util_logging.h"
#include "util/util_string.h"		#include "util/util_string.h"

// clang-format off		// clang-format off
#include "kernel/kernel_compat_cpu.h"		#include "kernel/device/cpu/compat.h"
#include "kernel/split/kernel_split_data_types.h"		#include "kernel/device/cpu/globals.h"
#include "kernel/kernel_globals.h"		#include "kernel/device/cpu/image.h"

#include "kernel/kernel_color.h"		#include "kernel/kernel_color.h"
#include "kernel/kernel_random.h"
#include "kernel/kernel_write_passes.h"
#include "kernel/kernel_projection.h"
#include "kernel/kernel_differential.h"
#include "kernel/kernel_montecarlo.h"
#include "kernel/kernel_camera.h"		#include "kernel/kernel_camera.h"
#include "kernel/kernels/cpu/kernel_cpu_image.h"
#include "kernel/geom/geom.h"		#include "kernel/geom/geom.h"
#include "kernel/bvh/bvh.h"		#include "kernel/bvh/bvh.h"

#include "kernel/kernel_projection.h"		#include "kernel/kernel_projection.h"
#include "kernel/kernel_accumulate.h"
#include "kernel/kernel_shader.h"
// clang-format on		// clang-format on

CCL_NAMESPACE_BEGIN		CCL_NAMESPACE_BEGIN

/* RenderServices implementation */		/* RenderServices implementation */

static void copy_matrix(OSL::Matrix44 &m, const Transform &tfm)		static void copy_matrix(OSL::Matrix44 &m, const Transform &tfm)
{		{
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines	bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
OSL::TransformationPtr xform,		OSL::TransformationPtr xform,
float time)		float time)
{		{
/* this is only used for shader and object space, we don't really have		/* this is only used for shader and object space, we don't really have
* a concept of shader space, so we just use object space for both. */		* a concept of shader space, so we just use object space for both. */
if (xform) {		if (xform) {
const ShaderData sd = (const ShaderData )xform;		const ShaderData sd = (const ShaderData )xform;
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;
int object = sd->object;		int object = sd->object;

if (object != OBJECT_NONE) {		if (object != OBJECT_NONE) {
#ifdef __OBJECT_MOTION__		#ifdef __OBJECT_MOTION__
Transform tfm;		Transform tfm;

if (time == sd->time)		if (time == sd->time)
tfm = sd->ob_tfm;		tfm = object_get_transform(kg, sd);
else		else
tfm = object_fetch_transform_motion_test(kg, object, time, NULL);		tfm = object_fetch_transform_motion_test(kg, object, time, NULL);
#else		#else
Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);		const Transform tfm = object_get_transform(kg, sd);
#endif		#endif
copy_matrix(result, tfm);		copy_matrix(result, tfm);

return true;		return true;
}		}
else if (sd->type == PRIMITIVE_LAMP) {		else if (sd->type == PRIMITIVE_LAMP) {
copy_matrix(result, sd->ob_tfm);		const Transform tfm = lamp_fetch_transform(kg, sd->lamp, false);
		copy_matrix(result, tfm);

return true;		return true;
}		}
}		}

return false;		return false;
}		}

bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
OSL::TransformationPtr xform,		OSL::TransformationPtr xform,
float time)		float time)
{		{
/* this is only used for shader and object space, we don't really have		/* this is only used for shader and object space, we don't really have
* a concept of shader space, so we just use object space for both. */		* a concept of shader space, so we just use object space for both. */
if (xform) {		if (xform) {
const ShaderData sd = (const ShaderData )xform;		const ShaderData sd = (const ShaderData )xform;
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;
int object = sd->object;		int object = sd->object;

if (object != OBJECT_NONE) {		if (object != OBJECT_NONE) {
#ifdef __OBJECT_MOTION__		#ifdef __OBJECT_MOTION__
Transform itfm;		Transform itfm;

if (time == sd->time)		if (time == sd->time)
itfm = sd->ob_itfm;		itfm = object_get_inverse_transform(kg, sd);
else		else
object_fetch_transform_motion_test(kg, object, time, &itfm);		object_fetch_transform_motion_test(kg, object, time, &itfm);
#else		#else
Transform itfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);		const Transform itfm = object_get_inverse_transform(kg, sd);
#endif		#endif
copy_matrix(result, itfm);		copy_matrix(result, itfm);

return true;		return true;
}		}
else if (sd->type == PRIMITIVE_LAMP) {		else if (sd->type == PRIMITIVE_LAMP) {
copy_matrix(result, sd->ob_itfm);		const Transform itfm = lamp_fetch_transform(kg, sd->lamp, true);
		copy_matrix(result, itfm);

return true;		return true;
}		}
}		}

return false;		return false;
}		}

bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
ustring from,		ustring from,
float time)		float time)
{		{
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

if (from == u_ndc) {		if (from == u_ndc) {
copy_matrix(result, kernel_data.cam.ndctoworld);		copy_matrix(result, kernel_data.cam.ndctoworld);
return true;		return true;
}		}
else if (from == u_raster) {		else if (from == u_raster) {
copy_matrix(result, kernel_data.cam.rastertoworld);		copy_matrix(result, kernel_data.cam.rastertoworld);
return true;		return true;
Show All 15 Lines
}		}

bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
ustring to,		ustring to,
float time)		float time)
{		{
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

if (to == u_ndc) {		if (to == u_ndc) {
copy_matrix(result, kernel_data.cam.worldtondc);		copy_matrix(result, kernel_data.cam.worldtondc);
return true;		return true;
}		}
else if (to == u_raster) {		else if (to == u_raster) {
copy_matrix(result, kernel_data.cam.worldtoraster);		copy_matrix(result, kernel_data.cam.worldtoraster);
return true;		return true;
Show All 17 Lines
bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
OSL::TransformationPtr xform)		OSL::TransformationPtr xform)
{		{
/* this is only used for shader and object space, we don't really have		/* this is only used for shader and object space, we don't really have
* a concept of shader space, so we just use object space for both. */		* a concept of shader space, so we just use object space for both. */
if (xform) {		if (xform) {
const ShaderData sd = (const ShaderData )xform;		const ShaderData sd = (const ShaderData )xform;
		const KernelGlobals *kg = sd->osl_globals;
int object = sd->object;		int object = sd->object;

if (object != OBJECT_NONE) {		if (object != OBJECT_NONE) {
#ifdef __OBJECT_MOTION__		const Transform tfm = object_get_transform(kg, sd);
Transform tfm = sd->ob_tfm;
#else
KernelGlobals *kg = sd->osl_globals;
Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);
#endif
copy_matrix(result, tfm);		copy_matrix(result, tfm);

return true;		return true;
}		}
else if (sd->type == PRIMITIVE_LAMP) {		else if (sd->type == PRIMITIVE_LAMP) {
copy_matrix(result, sd->ob_tfm);		const Transform tfm = lamp_fetch_transform(kg, sd->lamp, false);
		copy_matrix(result, tfm);

return true;		return true;
}		}
}		}

return false;		return false;
}		}

bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
OSL::TransformationPtr xform)		OSL::TransformationPtr xform)
{		{
/* this is only used for shader and object space, we don't really have		/* this is only used for shader and object space, we don't really have
* a concept of shader space, so we just use object space for both. */		* a concept of shader space, so we just use object space for both. */
if (xform) {		if (xform) {
const ShaderData sd = (const ShaderData )xform;		const ShaderData sd = (const ShaderData )xform;
		const KernelGlobals *kg = sd->osl_globals;
int object = sd->object;		int object = sd->object;

if (object != OBJECT_NONE) {		if (object != OBJECT_NONE) {
#ifdef __OBJECT_MOTION__		const Transform tfm = object_get_inverse_transform(kg, sd);
Transform tfm = sd->ob_itfm;
#else
KernelGlobals *kg = sd->osl_globals;
Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);
#endif
copy_matrix(result, tfm);		copy_matrix(result, tfm);

return true;		return true;
}		}
else if (sd->type == PRIMITIVE_LAMP) {		else if (sd->type == PRIMITIVE_LAMP) {
copy_matrix(result, sd->ob_itfm);		const Transform itfm = lamp_fetch_transform(kg, sd->lamp, true);
		copy_matrix(result, itfm);

return true;		return true;
}		}
}		}

return false;		return false;
}		}

bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from)		bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from)
{		{
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

if (from == u_ndc) {		if (from == u_ndc) {
copy_matrix(result, kernel_data.cam.ndctoworld);		copy_matrix(result, kernel_data.cam.ndctoworld);
return true;		return true;
}		}
else if (from == u_raster) {		else if (from == u_raster) {
copy_matrix(result, kernel_data.cam.rastertoworld);		copy_matrix(result, kernel_data.cam.rastertoworld);
return true;		return true;
Show All 10 Lines	bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from)
return false;		return false;
}		}

bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,		bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,		OSL::Matrix44 &result,
ustring to)		ustring to)
{		{
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

if (to == u_ndc) {		if (to == u_ndc) {
copy_matrix(result, kernel_data.cam.worldtondc);		copy_matrix(result, kernel_data.cam.worldtondc);
return true;		return true;
}		}
else if (to == u_raster) {		else if (to == u_raster) {
copy_matrix(result, kernel_data.cam.worldtoraster);		copy_matrix(result, kernel_data.cam.worldtoraster);
return true;		return true;
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines	static bool set_attribute_matrix(const Transform &tfm, TypeDesc type, void *val)
if (type == TypeDesc::TypeMatrix) {		if (type == TypeDesc::TypeMatrix) {
copy_matrix((OSL::Matrix44 )val, tfm);		copy_matrix((OSL::Matrix44 )val, tfm);
return true;		return true;
}		}

return false;		return false;
}		}

static bool get_primitive_attribute(KernelGlobals *kg,		static bool get_primitive_attribute(const KernelGlobals *kg,
const ShaderData *sd,		const ShaderData *sd,
const OSLGlobals::Attribute &attr,		const OSLGlobals::Attribute &attr,
const TypeDesc &type,		const TypeDesc &type,
bool derivatives,		bool derivatives,
void *val)		void *val)
{		{
if (attr.type == TypeDesc::TypePoint \|\| attr.type == TypeDesc::TypeVector \|\|		if (attr.type == TypeDesc::TypePoint \|\| attr.type == TypeDesc::TypeVector \|\|
attr.type == TypeDesc::TypeNormal \|\| attr.type == TypeDesc::TypeColor) {		attr.type == TypeDesc::TypeNormal \|\| attr.type == TypeDesc::TypeColor) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	else if (attr.type == TypeDesc::TypeFloat4 \|\| attr.type == TypeRGBA) {
}		}
return set_attribute_float4(fval, type, derivatives, val);		return set_attribute_float4(fval, type, derivatives, val);
}		}
else {		else {
return false;		return false;
}		}
}		}

static bool get_mesh_attribute(KernelGlobals *kg,		static bool get_mesh_attribute(const KernelGlobals *kg,
const ShaderData *sd,		const ShaderData *sd,
const OSLGlobals::Attribute &attr,		const OSLGlobals::Attribute &attr,
const TypeDesc &type,		const TypeDesc &type,
bool derivatives,		bool derivatives,
void *val)		void *val)
{		{
if (attr.type == TypeDesc::TypeMatrix) {		if (attr.type == TypeDesc::TypeMatrix) {
Transform tfm = primitive_attribute_matrix(kg, sd, attr.desc);		Transform tfm = primitive_attribute_matrix(kg, sd, attr.desc);
Show All 32 Lines	else if (attr.type == type) {

return true;		return true;
}		}
else {		else {
return false;		return false;
}		}
}		}

bool OSLRenderServices::get_object_standard_attribute(		bool OSLRenderServices::get_object_standard_attribute(const KernelGlobals *kg,
KernelGlobals kg, ShaderData sd, ustring name, TypeDesc type, bool derivatives, void *val)		ShaderData *sd,
		ustring name,
		TypeDesc type,
		bool derivatives,
		void *val)
{		{
/* todo: turn this into hash table? */		/* todo: turn this into hash table? */

/* Object Attributes */		/* Object Attributes */
if (name == u_object_location) {		if (name == u_object_location) {
float3 f = object_location(kg, sd);		float3 f = object_location(kg, sd);
return set_attribute_float3(f, type, derivatives, val);		return set_attribute_float3(f, type, derivatives, val);
}		}
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines	#endif
else if (name == u_curve_tangent_normal) {		else if (name == u_curve_tangent_normal) {
float3 f = curve_tangent_normal(kg, sd);		float3 f = curve_tangent_normal(kg, sd);
return set_attribute_float3(f, type, derivatives, val);		return set_attribute_float3(f, type, derivatives, val);
}		}
else		else
return false;		return false;
}		}

bool OSLRenderServices::get_background_attribute(		bool OSLRenderServices::get_background_attribute(const KernelGlobals *kg,
KernelGlobals kg, ShaderData sd, ustring name, TypeDesc type, bool derivatives, void *val)		ShaderData *sd,
		ustring name,
		TypeDesc type,
		bool derivatives,
		void *val)
{		{
if (name == u_path_ray_length) {		if (name == u_path_ray_length) {
/* Ray Length */		/* Ray Length */
float f = sd->ray_length;		float f = sd->ray_length;
return set_attribute_float(f, type, derivatives, val);		return set_attribute_float(f, type, derivatives, val);
}		}
		/* TODO */
		#if 0
else if (name == u_path_ray_depth) {		else if (name == u_path_ray_depth) {
/* Ray Depth */		/* Ray Depth */
PathState *state = sd->osl_path_state;		PathState *state = sd->osl_path_state;
int f = state->bounce;		int f = state->bounce;
return set_attribute_int(f, type, derivatives, val);		return set_attribute_int(f, type, derivatives, val);
}		}
else if (name == u_path_diffuse_depth) {		else if (name == u_path_diffuse_depth) {
/* Diffuse Ray Depth */		/* Diffuse Ray Depth */
Show All 20 Lines	else if (name == u_path_transparent_depth) {
return set_attribute_int(f, type, derivatives, val);		return set_attribute_int(f, type, derivatives, val);
}		}
else if (name == u_path_transmission_depth) {		else if (name == u_path_transmission_depth) {
/* Transmission Ray Depth */		/* Transmission Ray Depth */
PathState *state = sd->osl_path_state;		PathState *state = sd->osl_path_state;
int f = state->transmission_bounce;		int f = state->transmission_bounce;
return set_attribute_int(f, type, derivatives, val);		return set_attribute_int(f, type, derivatives, val);
}		}
		#endif
else if (name == u_ndc) {		else if (name == u_ndc) {
/* NDC coordinates with special exception for orthographic projection. */		/* NDC coordinates with special exception for orthographic projection. */
OSLThreadData *tdata = kg->osl_tdata;		OSLThreadData *tdata = kg->osl_tdata;
OSL::ShaderGlobals *globals = &tdata->globals;		OSL::ShaderGlobals *globals = &tdata->globals;
float3 ndc[3];		float3 ndc[3];

if ((globals->raytype & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&		if ((globals->raytype & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&
kernel_data.cam.type == CAMERA_ORTHOGRAPHIC) {		kernel_data.cam.type == CAMERA_ORTHOGRAPHIC) {
ndc[0] = camera_world_to_ndc(kg, sd, sd->ray_P);		ndc[0] = camera_world_to_ndc(kg, sd, sd->ray_P);

if (derivatives) {		if (derivatives) {
ndc[1] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dx) - ndc[0];		ndc[1] = camera_world_to_ndc(kg, sd, sd->ray_P /* TODO: + sd->ray_dP.dx*/) - ndc[0];
ndc[2] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dy) - ndc[0];		ndc[2] = camera_world_to_ndc(kg, sd, sd->ray_P /* TODO: + sd->ray_dP.dy*/) - ndc[0];
}		}
}		}
else {		else {
ndc[0] = camera_world_to_ndc(kg, sd, sd->P);		ndc[0] = camera_world_to_ndc(kg, sd, sd->P);

if (derivatives) {		if (derivatives) {
ndc[1] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx) - ndc[0];		ndc[1] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx) - ndc[0];
ndc[2] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy) - ndc[0];		ndc[2] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy) - ndc[0];
Show All 18 Lines	bool OSLRenderServices::get_attribute(OSL::ShaderGlobals *sg,

ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
return get_attribute(sd, derivatives, object_name, type, name, val);		return get_attribute(sd, derivatives, object_name, type, name, val);
}		}

bool OSLRenderServices::get_attribute(		bool OSLRenderServices::get_attribute(
ShaderData sd, bool derivatives, ustring object_name, TypeDesc type, ustring name, void val)		ShaderData sd, bool derivatives, ustring object_name, TypeDesc type, ustring name, void val)
{		{
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;
int prim_type = 0;		int prim_type = 0;
int object;		int object;

/* lookup of attribute on another object */		/* lookup of attribute on another object */
if (object_name != u_empty) {		if (object_name != u_empty) {
OSLGlobals::ObjectNameMap::iterator it = kg->osl->object_name_map.find(object_name);		OSLGlobals::ObjectNameMap::iterator it = kg->osl->object_name_map.find(object_name);

if (it == kg->osl->object_name_map.end())		if (it == kg->osl->object_name_map.end())
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	bool OSLRenderServices::texture(ustring filename,
float *result,		float *result,
float *dresultds,		float *dresultds,
float *dresultdt,		float *dresultdt,
ustring *errormessage)		ustring *errormessage)
{		{
OSLTextureHandle handle = (OSLTextureHandle )texture_handle;		OSLTextureHandle handle = (OSLTextureHandle )texture_handle;
OSLTextureHandle::Type texture_type = (handle) ? handle->type : OSLTextureHandle::OIIO;		OSLTextureHandle::Type texture_type = (handle) ? handle->type : OSLTextureHandle::OIIO;
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kernel_globals = sd->osl_globals;		const KernelGlobals *kernel_globals = sd->osl_globals;
bool status = false;		bool status = false;

switch (texture_type) {		switch (texture_type) {
case OSLTextureHandle::BEVEL: {		case OSLTextureHandle::BEVEL: {
		/* TODO */
		#if 0
/* Bevel shader hack. */		/* Bevel shader hack. */
if (nchannels >= 3) {		if (nchannels >= 3) {
PathState *state = sd->osl_path_state;		PathState *state = sd->osl_path_state;
int num_samples = (int)s;		int num_samples = (int)s;
float radius = t;		float radius = t;
float3 N = svm_bevel(kernel_globals, sd, state, radius, num_samples);		float3 N = svm_bevel(kernel_globals, sd, state, radius, num_samples);
result[0] = N.x;		result[0] = N.x;
result[1] = N.y;		result[1] = N.y;
result[2] = N.z;		result[2] = N.z;
status = true;		status = true;
}		}
		#endif
break;		break;
}		}
case OSLTextureHandle::AO: {		case OSLTextureHandle::AO: {
		/* TODO */
		#if 0
/* AO shader hack. */		/* AO shader hack. */
PathState *state = sd->osl_path_state;		PathState *state = sd->osl_path_state;
int num_samples = (int)s;		int num_samples = (int)s;
float radius = t;		float radius = t;
float3 N = make_float3(dsdx, dtdx, dsdy);		float3 N = make_float3(dsdx, dtdx, dsdy);
int flags = 0;		int flags = 0;
if ((int)dtdy) {		if ((int)dtdy) {
flags \|= NODE_AO_INSIDE;		flags \|= NODE_AO_INSIDE;
}		}
if ((int)options.sblur) {		if ((int)options.sblur) {
flags \|= NODE_AO_ONLY_LOCAL;		flags \|= NODE_AO_ONLY_LOCAL;
}		}
if ((int)options.tblur) {		if ((int)options.tblur) {
flags \|= NODE_AO_GLOBAL_RADIUS;		flags \|= NODE_AO_GLOBAL_RADIUS;
}		}
result[0] = svm_ao(kernel_globals, sd, N, state, radius, num_samples, flags);		result[0] = svm_ao(kernel_globals, sd, N, state, radius, num_samples, flags);
status = true;		status = true;
		#endif
break;		break;
}		}
case OSLTextureHandle::SVM: {		case OSLTextureHandle::SVM: {
/* Packed texture. */		/* Packed texture. */
float4 rgba = kernel_tex_image_interp(kernel_globals, handle->svm_slot, s, 1.0f - t);		float4 rgba = kernel_tex_image_interp(kernel_globals, handle->svm_slot, s, 1.0f - t);

result[0] = rgba[0];		result[0] = rgba[0];
if (nchannels > 1)		if (nchannels > 1)
result[1] = rgba[1];		result[1] = rgba[1];
if (nchannels > 2)		if (nchannels > 2)
result[2] = rgba[2];		result[2] = rgba[2];
if (nchannels > 3)		if (nchannels > 3)
result[3] = rgba[3];		result[3] = rgba[3];
status = true;		status = true;
break;		break;
}		}
case OSLTextureHandle::IES: {		case OSLTextureHandle::IES: {
		/* TODO */
		#if 0
/* IES light. */		/* IES light. */
result[0] = kernel_ies_interp(kernel_globals, handle->svm_slot, s, t);		result[0] = kernel_ies_interp(kernel_globals, handle->svm_slot, s, t);
status = true;		status = true;
		#endif
break;		break;
}		}
case OSLTextureHandle::OIIO: {		case OSLTextureHandle::OIIO: {
/* OpenImageIO texture cache. */		/* OpenImageIO texture cache. */
OSL::TextureSystem *ts = texture_system;		OSL::TextureSystem *ts = texture_system;

if (handle && handle->oiio_handle) {		if (handle && handle->oiio_handle) {
if (texture_thread_info == NULL) {		if (texture_thread_info == NULL) {
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines	bool OSLRenderServices::texture3d(ustring filename,
OSLTextureHandle handle = (OSLTextureHandle )texture_handle;		OSLTextureHandle handle = (OSLTextureHandle )texture_handle;
OSLTextureHandle::Type texture_type = (handle) ? handle->type : OSLTextureHandle::OIIO;		OSLTextureHandle::Type texture_type = (handle) ? handle->type : OSLTextureHandle::OIIO;
bool status = false;		bool status = false;

switch (texture_type) {		switch (texture_type) {
case OSLTextureHandle::SVM: {		case OSLTextureHandle::SVM: {
/* Packed texture. */		/* Packed texture. */
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kernel_globals = sd->osl_globals;		const KernelGlobals *kernel_globals = sd->osl_globals;
int slot = handle->svm_slot;		int slot = handle->svm_slot;
float3 P_float3 = make_float3(P.x, P.y, P.z);		float3 P_float3 = make_float3(P.x, P.y, P.z);
float4 rgba = kernel_tex_image_interp_3d(kernel_globals, slot, P_float3, INTERPOLATION_NONE);		float4 rgba = kernel_tex_image_interp_3d(kernel_globals, slot, P_float3, INTERPOLATION_NONE);

result[0] = rgba[0];		result[0] = rgba[0];
if (nchannels > 1)		if (nchannels > 1)
result[1] = rgba[1];		result[1] = rgba[1];
if (nchannels > 2)		if (nchannels > 2)
result[2] = rgba[2];		result[2] = rgba[2];
if (nchannels > 3)		if (nchannels > 3)
result[3] = rgba[3];		result[3] = rgba[3];
status = true;		status = true;
break;		break;
}		}
case OSLTextureHandle::OIIO: {		case OSLTextureHandle::OIIO: {
/* OpenImageIO texture cache. */		/* OpenImageIO texture cache. */
OSL::TextureSystem *ts = texture_system;		OSL::TextureSystem *ts = texture_system;

if (handle && handle->oiio_handle) {		if (handle && handle->oiio_handle) {
if (texture_thread_info == NULL) {		if (texture_thread_info == NULL) {
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kernel_globals = sd->osl_globals;		const KernelGlobals *kernel_globals = sd->osl_globals;
OSLThreadData *tdata = kernel_globals->osl_tdata;		OSLThreadData *tdata = kernel_globals->osl_tdata;
texture_thread_info = tdata->oiio_thread_info;		texture_thread_info = tdata->oiio_thread_info;
}		}

status = ts->texture3d(handle->oiio_handle,		status = ts->texture3d(handle->oiio_handle,
texture_thread_info,		texture_thread_info,
options,		options,
P,		P,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
{		{
OSLTextureHandle handle = (OSLTextureHandle )texture_handle;		OSLTextureHandle handle = (OSLTextureHandle )texture_handle;
OSL::TextureSystem *ts = texture_system;		OSL::TextureSystem *ts = texture_system;
bool status = false;		bool status = false;

if (handle && handle->oiio_handle) {		if (handle && handle->oiio_handle) {
if (thread_info == NULL) {		if (thread_info == NULL) {
ShaderData sd = (ShaderData )(sg->renderstate);		ShaderData sd = (ShaderData )(sg->renderstate);
KernelGlobals *kernel_globals = sd->osl_globals;		const KernelGlobals *kernel_globals = sd->osl_globals;
OSLThreadData *tdata = kernel_globals->osl_tdata;		OSLThreadData *tdata = kernel_globals->osl_tdata;
thread_info = tdata->oiio_thread_info;		thread_info = tdata->oiio_thread_info;
}		}

status = ts->environment(handle->oiio_handle,		status = ts->environment(handle->oiio_handle,
thread_info,		thread_info,
options,		options,
R,		R,
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines	if (options.mindist == 0.0f) {
}		}
}		}
else {		else {
/* offset for minimum distance */		/* offset for minimum distance */
ray.P += options.mindist * ray.D;		ray.P += options.mindist * ray.D;
}		}

/* ray differentials */		/* ray differentials */
ray.dP.dx = TO_FLOAT3(dPdx);		differential3 dP;
ray.dP.dy = TO_FLOAT3(dPdy);		dP.dx = TO_FLOAT3(dPdx);
ray.dD.dx = TO_FLOAT3(dRdx);		dP.dy = TO_FLOAT3(dPdy);
ray.dD.dy = TO_FLOAT3(dRdy);		ray.dP = differential_make_compact(dP);
		differential3 dD;
		dD.dx = TO_FLOAT3(dRdx);
		dD.dy = TO_FLOAT3(dRdy);
		ray.dD = differential_make_compact(dD);

/* allocate trace data */		/* allocate trace data */
OSLTraceData tracedata = (OSLTraceData )sg->tracedata;		OSLTraceData tracedata = (OSLTraceData )sg->tracedata;
tracedata->ray = ray;		tracedata->ray = ray;
tracedata->setup = false;		tracedata->setup = false;
tracedata->init = true;		tracedata->init = true;
tracedata->hit = false;		tracedata->hit = false;
tracedata->sd.osl_globals = sd->osl_globals;		tracedata->sd.osl_globals = sd->osl_globals;

KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

/* Can't raytrace from shaders like displacement, before BVH exists. */		/* Can't raytrace from shaders like displacement, before BVH exists. */
if (kernel_data.bvh.bvh_layout == BVH_LAYOUT_NONE) {		if (kernel_data.bvh.bvh_layout == BVH_LAYOUT_NONE) {
return false;		return false;
}		}

/* Raytrace, leaving out shadow opaque to avoid early exit. */		/* Raytrace, leaving out shadow opaque to avoid early exit. */
uint visibility = PATH_RAY_ALL_VISIBILITY - PATH_RAY_SHADOW_OPAQUE;		uint visibility = PATH_RAY_ALL_VISIBILITY - PATH_RAY_SHADOW_OPAQUE;
Show All 15 Lines	if (name == u_hit) {
return set_attribute_int(tracedata->hit, type, derivatives, val);		return set_attribute_int(tracedata->hit, type, derivatives, val);
}		}
else if (tracedata->hit) {		else if (tracedata->hit) {
if (name == u_hitdist) {		if (name == u_hitdist) {
float f[3] = {tracedata->isect.t, 0.0f, 0.0f};		float f[3] = {tracedata->isect.t, 0.0f, 0.0f};
return set_attribute_float(f, type, derivatives, val);		return set_attribute_float(f, type, derivatives, val);
}		}
else {		else {
		/* TODO */
		#if 0
ShaderData *sd = &tracedata->sd;		ShaderData *sd = &tracedata->sd;
KernelGlobals *kg = sd->osl_globals;		const KernelGlobals *kg = sd->osl_globals;

if (!tracedata->setup) {		if (!tracedata->setup) {
/* lazy shader data setup */		/* lazy shader data setup */
shader_setup_from_ray(kg, sd, &tracedata->isect, &tracedata->ray);		shader_setup_from_ray(kg, sd, &tracedata->isect, &tracedata->ray);
tracedata->setup = true;		tracedata->setup = true;
}		}

if (name == u_N) {		if (name == u_N) {
Show All 15 Lines	#if 0
return set_attribute_float(f, type, derivatives, val);		return set_attribute_float(f, type, derivatives, val);
}		}
else if (name == u_v) {		else if (name == u_v) {
float f[3] = {sd->v, sd->dv.dx, sd->dv.dy};		float f[3] = {sd->v, sd->dv.dx, sd->dv.dy};
return set_attribute_float(f, type, derivatives, val);		return set_attribute_float(f, type, derivatives, val);
}		}

return get_attribute(sd, derivatives, u_empty, type, name, val);		return get_attribute(sd, derivatives, u_empty, type, name, val);
		#endif
}		}
}		}
}		}

return false;		return false;
}		}

CCL_NAMESPACE_END		CCL_NAMESPACE_END