Cycles: Code cleanup, spaces around keywords
This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
This commit is contained in:
parent
6f43e1dfef
commit
5ff132182d
|
@ -66,7 +66,7 @@ int main(int argc, const char **argv)
|
|||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (debug) {
|
||||
if(debug) {
|
||||
util_logging_start();
|
||||
util_logging_verbosity_set(verbosity);
|
||||
}
|
||||
|
|
|
@ -124,7 +124,7 @@ static void scene_init()
|
|||
xml_read_file(options.scene, options.filepath.c_str());
|
||||
|
||||
/* Camera width/height override? */
|
||||
if (!(options.width == 0 || options.height == 0)) {
|
||||
if(!(options.width == 0 || options.height == 0)) {
|
||||
options.scene->camera->width = options.width;
|
||||
options.scene->camera->height = options.height;
|
||||
}
|
||||
|
@ -367,7 +367,7 @@ static void options_parse(int argc, const char **argv)
|
|||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (debug) {
|
||||
if(debug) {
|
||||
util_logging_start();
|
||||
util_logging_verbosity_set(verbosity);
|
||||
}
|
||||
|
|
|
@ -225,21 +225,21 @@ static ShaderSocketType xml_read_socket_type(pugi::xml_node node, const char *na
|
|||
|
||||
if(attr) {
|
||||
string value = attr.value();
|
||||
if (string_iequals(value, "float"))
|
||||
if(string_iequals(value, "float"))
|
||||
return SHADER_SOCKET_FLOAT;
|
||||
else if (string_iequals(value, "int"))
|
||||
else if(string_iequals(value, "int"))
|
||||
return SHADER_SOCKET_INT;
|
||||
else if (string_iequals(value, "color"))
|
||||
else if(string_iequals(value, "color"))
|
||||
return SHADER_SOCKET_COLOR;
|
||||
else if (string_iequals(value, "vector"))
|
||||
else if(string_iequals(value, "vector"))
|
||||
return SHADER_SOCKET_VECTOR;
|
||||
else if (string_iequals(value, "point"))
|
||||
else if(string_iequals(value, "point"))
|
||||
return SHADER_SOCKET_POINT;
|
||||
else if (string_iequals(value, "normal"))
|
||||
else if(string_iequals(value, "normal"))
|
||||
return SHADER_SOCKET_NORMAL;
|
||||
else if (string_iequals(value, "closure color"))
|
||||
else if(string_iequals(value, "closure color"))
|
||||
return SHADER_SOCKET_CLOSURE;
|
||||
else if (string_iequals(value, "string"))
|
||||
else if(string_iequals(value, "string"))
|
||||
return SHADER_SOCKET_STRING;
|
||||
else
|
||||
fprintf(stderr, "Unknown shader socket type \"%s\" for attribute \"%s\".\n", value.c_str(), name);
|
||||
|
@ -419,25 +419,25 @@ static void xml_read_shader_graph(const XMLReadState& state, Shader *shader, pug
|
|||
* Socket names must be stored in the extra lists instead. */
|
||||
/* read input values */
|
||||
for(pugi::xml_node param = node.first_child(); param; param = param.next_sibling()) {
|
||||
if (string_iequals(param.name(), "input")) {
|
||||
if(string_iequals(param.name(), "input")) {
|
||||
string name;
|
||||
if (!xml_read_string(&name, param, "name"))
|
||||
if(!xml_read_string(&name, param, "name"))
|
||||
continue;
|
||||
|
||||
ShaderSocketType type = xml_read_socket_type(param, "type");
|
||||
if (type == SHADER_SOCKET_UNDEFINED)
|
||||
if(type == SHADER_SOCKET_UNDEFINED)
|
||||
continue;
|
||||
|
||||
osl->input_names.push_back(ustring(name));
|
||||
osl->add_input(osl->input_names.back().c_str(), type);
|
||||
}
|
||||
else if (string_iequals(param.name(), "output")) {
|
||||
else if(string_iequals(param.name(), "output")) {
|
||||
string name;
|
||||
if (!xml_read_string(&name, param, "name"))
|
||||
if(!xml_read_string(&name, param, "name"))
|
||||
continue;
|
||||
|
||||
ShaderSocketType type = xml_read_socket_type(param, "type");
|
||||
if (type == SHADER_SOCKET_UNDEFINED)
|
||||
if(type == SHADER_SOCKET_UNDEFINED)
|
||||
continue;
|
||||
|
||||
osl->output_names.push_back(ustring(name));
|
||||
|
|
|
@ -303,7 +303,7 @@ static void blender_camera_sync(Camera *cam, BlenderCamera *bcam, int width, int
|
|||
&cam->viewplane, &aspectratio, &sensor_size);
|
||||
|
||||
/* panorama sensor */
|
||||
if (bcam->type == CAMERA_PANORAMA && bcam->panorama_type == PANORAMA_FISHEYE_EQUISOLID) {
|
||||
if(bcam->type == CAMERA_PANORAMA && bcam->panorama_type == PANORAMA_FISHEYE_EQUISOLID) {
|
||||
float fit_xratio = (float)bcam->full_width*bcam->pixelaspect.x;
|
||||
float fit_yratio = (float)bcam->full_height*bcam->pixelaspect.y;
|
||||
bool horizontal_fit;
|
||||
|
|
|
@ -152,7 +152,7 @@ bool ObtainCacheParticleData(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, Par
|
|||
continue;
|
||||
|
||||
int ren_step = (1 << draw_step) + 1;
|
||||
if (b_part.kink() == BL::ParticleSettings::kink_SPIRAL)
|
||||
if(b_part.kink() == BL::ParticleSettings::kink_SPIRAL)
|
||||
ren_step += b_part.kink_extra_steps();
|
||||
|
||||
PointerRNA cpsys = RNA_pointer_get(&b_part.ptr, "cycles");
|
||||
|
@ -233,10 +233,10 @@ bool ObtainCacheParticleUV(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, Parti
|
|||
int totchild = background ? b_psys.child_particles.length() : (int)((float)b_psys.child_particles.length() * (float)b_part.draw_percentage() / 100.0f);
|
||||
int totcurves = totchild;
|
||||
|
||||
if (b_part.child_type() == 0)
|
||||
if(b_part.child_type() == 0)
|
||||
totcurves += totparts;
|
||||
|
||||
if (totcurves == 0)
|
||||
if(totcurves == 0)
|
||||
continue;
|
||||
|
||||
int pa_no = 0;
|
||||
|
@ -287,10 +287,10 @@ bool ObtainCacheParticleVcol(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, Par
|
|||
int totchild = background ? b_psys.child_particles.length() : (int)((float)b_psys.child_particles.length() * (float)b_part.draw_percentage() / 100.0f);
|
||||
int totcurves = totchild;
|
||||
|
||||
if (b_part.child_type() == 0)
|
||||
if(b_part.child_type() == 0)
|
||||
totcurves += totparts;
|
||||
|
||||
if (totcurves == 0)
|
||||
if(totcurves == 0)
|
||||
continue;
|
||||
|
||||
int pa_no = 0;
|
||||
|
@ -326,7 +326,7 @@ static void set_resolution(BL::Object *b_ob, BL::Scene *scene, bool render)
|
|||
{
|
||||
BL::Object::modifiers_iterator b_mod;
|
||||
for(b_ob->modifiers.begin(b_mod); b_mod != b_ob->modifiers.end(); ++b_mod) {
|
||||
if ((b_mod->type() == b_mod->type_PARTICLE_SYSTEM) && ((b_mod->show_viewport()) || (b_mod->show_render()))) {
|
||||
if((b_mod->type() == b_mod->type_PARTICLE_SYSTEM) && ((b_mod->show_viewport()) || (b_mod->show_render()))) {
|
||||
BL::ParticleSystemModifier psmd((const PointerRNA)b_mod->ptr);
|
||||
BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
|
||||
b_psys.set_resolution(*scene, *b_ob, (render)? 2: 1);
|
||||
|
@ -513,7 +513,7 @@ void ExportCurveTriangleGeometry(Mesh *mesh, ParticleCurveData *CData, int resol
|
|||
|
||||
ybasis = normalize(cross(xbasis, v2));
|
||||
|
||||
for (; subv <= 1; subv++) {
|
||||
for(; subv <= 1; subv++) {
|
||||
float3 ickey_loc = make_float3(0.0f,0.0f,0.0f);
|
||||
float time = 0.0f;
|
||||
|
||||
|
@ -581,7 +581,7 @@ void ExportCurveSegments(Scene *scene, Mesh *mesh, ParticleCurveData *CData)
|
|||
}
|
||||
}
|
||||
|
||||
if (num_curves > 0) {
|
||||
if(num_curves > 0) {
|
||||
VLOG(1) << "Exporting curve segments for mesh " << mesh->name;
|
||||
}
|
||||
|
||||
|
|
|
@ -302,7 +302,7 @@ static void attr_create_uv_map(Scene *scene,
|
|||
BL::Mesh b_mesh,
|
||||
const vector<int>& nverts)
|
||||
{
|
||||
if (b_mesh.tessface_uv_textures.length() != 0) {
|
||||
if(b_mesh.tessface_uv_textures.length() != 0) {
|
||||
BL::Mesh::tessface_uv_textures_iterator l;
|
||||
|
||||
for(b_mesh.tessface_uv_textures.begin(l); l != b_mesh.tessface_uv_textures.end(); ++l) {
|
||||
|
|
|
@ -356,7 +356,7 @@ Object *BlenderSync::sync_object(BL::Object b_parent, int persistent_id[OBJECT_P
|
|||
object->random_id ^= hash_int(hash_string(b_parent.name().c_str()));
|
||||
|
||||
/* dupli texture coordinates */
|
||||
if (b_dupli_ob) {
|
||||
if(b_dupli_ob) {
|
||||
object->dupli_generated = 0.5f*get_float3(b_dupli_ob.orco()) - make_float3(0.5f, 0.5f, 0.5f);
|
||||
object->dupli_uv = get_float2(b_dupli_ob.uv());
|
||||
}
|
||||
|
|
|
@ -76,7 +76,7 @@ bool BlenderSync::sync_dupli_particle(BL::Object b_ob, BL::DupliObject b_dup, Ob
|
|||
|
||||
psys->particles.push_back(pa);
|
||||
|
||||
if (object->particle_index != psys->particles.size() - 1)
|
||||
if(object->particle_index != psys->particles.size() - 1)
|
||||
scene->object_manager->tag_update(scene);
|
||||
object->particle_system = psys;
|
||||
object->particle_index = psys->particles.size() - 1;
|
||||
|
|
|
@ -391,7 +391,7 @@ static PyObject *osl_update_node_func(PyObject * /*self*/, PyObject *args)
|
|||
|
||||
/* find socket socket */
|
||||
BL::NodeSocket b_sock(PointerRNA_NULL);
|
||||
if (param->isoutput) {
|
||||
if(param->isoutput) {
|
||||
b_sock = b_node.outputs[param->name.string()];
|
||||
/* remove if type no longer matches */
|
||||
if(b_sock && b_sock.bl_idname() != socket_type) {
|
||||
|
@ -445,7 +445,7 @@ static PyObject *osl_update_node_func(PyObject * /*self*/, PyObject *args)
|
|||
|
||||
removed = false;
|
||||
|
||||
for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
|
||||
for(b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
|
||||
if(used_sockets.find(b_input->ptr.data) == used_sockets.end()) {
|
||||
b_node.inputs.remove(*b_input);
|
||||
removed = true;
|
||||
|
@ -453,7 +453,7 @@ static PyObject *osl_update_node_func(PyObject * /*self*/, PyObject *args)
|
|||
}
|
||||
}
|
||||
|
||||
for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
|
||||
for(b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
|
||||
if(used_sockets.find(b_output->ptr.data) == used_sockets.end()) {
|
||||
b_node.outputs.remove(*b_output);
|
||||
removed = true;
|
||||
|
|
|
@ -353,7 +353,7 @@ void BlenderSession::do_write_update_render_tile(RenderTile& rtile, bool do_upda
|
|||
BL::RenderResult b_rr = begin_render_result(b_engine, x, y, w, h, b_rlay_name.c_str());
|
||||
|
||||
/* can happen if the intersected rectangle gives 0 width or height */
|
||||
if (b_rr.ptr.data == NULL) {
|
||||
if(b_rr.ptr.data == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -366,10 +366,10 @@ void BlenderSession::do_write_update_render_tile(RenderTile& rtile, bool do_upda
|
|||
|
||||
BL::RenderLayer b_rlay = *b_single_rlay;
|
||||
|
||||
if (do_update_only) {
|
||||
if(do_update_only) {
|
||||
/* update only needed */
|
||||
|
||||
if (rtile.sample != 0) {
|
||||
if(rtile.sample != 0) {
|
||||
/* sample would be zero at initial tile update, which is only needed
|
||||
* to tag tile form blender side as IN PROGRESS for proper highlight
|
||||
* no buffers should be sent to blender yet
|
||||
|
@ -397,7 +397,7 @@ void BlenderSession::update_render_tile(RenderTile& rtile)
|
|||
* be updated in blender side
|
||||
* would need to be investigated a bit further, but for now shall be fine
|
||||
*/
|
||||
if (!b_engine.is_preview())
|
||||
if(!b_engine.is_preview())
|
||||
do_write_update_render_tile(rtile, true);
|
||||
else
|
||||
do_write_update_render_tile(rtile, false);
|
||||
|
@ -601,7 +601,7 @@ void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::Re
|
|||
|
||||
vector<float> pixels(params.width*params.height*4);
|
||||
|
||||
if (!do_update_only) {
|
||||
if(!do_update_only) {
|
||||
/* copy each pass */
|
||||
BL::RenderLayer::passes_iterator b_iter;
|
||||
|
||||
|
@ -869,7 +869,7 @@ void BlenderSession::update_status_progress()
|
|||
last_progress = progress;
|
||||
}
|
||||
|
||||
if (session->progress.get_error()) {
|
||||
if(session->progress.get_error()) {
|
||||
string error = session->progress.get_error_message();
|
||||
if(error != last_error) {
|
||||
/* TODO(sergey): Currently C++ RNA API doesn't let us to
|
||||
|
|
|
@ -184,48 +184,48 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
ShaderNode *node = NULL;
|
||||
|
||||
/* existing blender nodes */
|
||||
if (b_node.is_a(&RNA_ShaderNodeRGBCurve)) {
|
||||
if(b_node.is_a(&RNA_ShaderNodeRGBCurve)) {
|
||||
BL::ShaderNodeRGBCurve b_curve_node(b_node);
|
||||
RGBCurvesNode *curves = new RGBCurvesNode();
|
||||
curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, true);
|
||||
node = curves;
|
||||
}
|
||||
if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
|
||||
if(b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
|
||||
BL::ShaderNodeVectorCurve b_curve_node(b_node);
|
||||
VectorCurvesNode *curves = new VectorCurvesNode();
|
||||
curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, false);
|
||||
node = curves;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeValToRGB)) {
|
||||
RGBRampNode *ramp = new RGBRampNode();
|
||||
BL::ShaderNodeValToRGB b_ramp_node(b_node);
|
||||
colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE);
|
||||
ramp->interpolate = b_ramp_node.color_ramp().interpolation() != BL::ColorRamp::interpolation_CONSTANT;
|
||||
node = ramp;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeRGB)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeRGB)) {
|
||||
ColorNode *color = new ColorNode();
|
||||
color->value = get_node_output_rgba(b_node, "Color");
|
||||
node = color;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeValue)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeValue)) {
|
||||
ValueNode *value = new ValueNode();
|
||||
value->value = get_node_output_value(b_node, "Value");
|
||||
node = value;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeCameraData)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeCameraData)) {
|
||||
node = new CameraNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeInvert)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeInvert)) {
|
||||
node = new InvertNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeGamma)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeGamma)) {
|
||||
node = new GammaNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBrightContrast)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBrightContrast)) {
|
||||
node = new BrightContrastNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeMixRGB)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeMixRGB)) {
|
||||
BL::ShaderNodeMixRGB b_mix_node(b_node);
|
||||
MixNode *mix = new MixNode();
|
||||
mix->type = MixNode::type_enum[b_mix_node.blend_type()];
|
||||
|
@ -236,44 +236,44 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
mix->use_clamp = b_mix_node.use_clamp();
|
||||
node = mix;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeSeparateRGB)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeSeparateRGB)) {
|
||||
node = new SeparateRGBNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeCombineRGB)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeCombineRGB)) {
|
||||
node = new CombineRGBNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeSeparateHSV)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeSeparateHSV)) {
|
||||
node = new SeparateHSVNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeCombineHSV)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeCombineHSV)) {
|
||||
node = new CombineHSVNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeSeparateXYZ)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeSeparateXYZ)) {
|
||||
node = new SeparateXYZNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeCombineXYZ)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeCombineXYZ)) {
|
||||
node = new CombineXYZNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeHueSaturation)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeHueSaturation)) {
|
||||
node = new HSVNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeRGBToBW)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeRGBToBW)) {
|
||||
node = new ConvertNode(SHADER_SOCKET_COLOR, SHADER_SOCKET_FLOAT);
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeMath)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeMath)) {
|
||||
BL::ShaderNodeMath b_math_node(b_node);
|
||||
MathNode *math = new MathNode();
|
||||
math->type = MathNode::type_enum[b_math_node.operation()];
|
||||
math->use_clamp = b_math_node.use_clamp();
|
||||
node = math;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeVectorMath)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeVectorMath)) {
|
||||
BL::ShaderNodeVectorMath b_vector_math_node(b_node);
|
||||
VectorMathNode *vmath = new VectorMathNode();
|
||||
vmath->type = VectorMathNode::type_enum[b_vector_math_node.operation()];
|
||||
node = vmath;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeVectorTransform)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeVectorTransform)) {
|
||||
BL::ShaderNodeVectorTransform b_vector_transform_node(b_node);
|
||||
VectorTransformNode *vtransform = new VectorTransformNode();
|
||||
vtransform->type = VectorTransformNode::type_enum[b_vector_transform_node.type()];
|
||||
|
@ -281,7 +281,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
vtransform->convert_to = VectorTransformNode::convert_space_enum[b_vector_transform_node.convert_to()];
|
||||
node = vtransform;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeNormal)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeNormal)) {
|
||||
BL::Node::outputs_iterator out_it;
|
||||
b_node.outputs.begin(out_it);
|
||||
|
||||
|
@ -289,7 +289,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
norm->direction = get_node_output_vector(b_node, "Normal");
|
||||
node = norm;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeMapping)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeMapping)) {
|
||||
BL::ShaderNodeMapping b_mapping_node(b_node);
|
||||
MappingNode *mapping = new MappingNode();
|
||||
|
||||
|
@ -297,31 +297,31 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
|
||||
node = mapping;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeFresnel)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeFresnel)) {
|
||||
node = new FresnelNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeLayerWeight)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeLayerWeight)) {
|
||||
node = new LayerWeightNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeAddShader)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeAddShader)) {
|
||||
node = new AddClosureNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeMixShader)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeMixShader)) {
|
||||
node = new MixClosureNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeAttribute)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeAttribute)) {
|
||||
BL::ShaderNodeAttribute b_attr_node(b_node);
|
||||
AttributeNode *attr = new AttributeNode();
|
||||
attr->attribute = b_attr_node.attribute_name();
|
||||
node = attr;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBackground)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBackground)) {
|
||||
node = new BackgroundNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeHoldout)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeHoldout)) {
|
||||
node = new HoldoutNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfAnisotropic)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfAnisotropic)) {
|
||||
BL::ShaderNodeBsdfAnisotropic b_aniso_node(b_node);
|
||||
AnisotropicBsdfNode *aniso = new AnisotropicBsdfNode();
|
||||
|
||||
|
@ -340,10 +340,10 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
|
||||
node = aniso;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfDiffuse)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfDiffuse)) {
|
||||
node = new DiffuseBsdfNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeSubsurfaceScattering)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeSubsurfaceScattering)) {
|
||||
BL::ShaderNodeSubsurfaceScattering b_subsurface_node(b_node);
|
||||
|
||||
SubsurfaceScatteringNode *subsurface = new SubsurfaceScatteringNode();
|
||||
|
@ -359,7 +359,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
|
||||
node = subsurface;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfGlossy)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfGlossy)) {
|
||||
BL::ShaderNodeBsdfGlossy b_glossy_node(b_node);
|
||||
GlossyBsdfNode *glossy = new GlossyBsdfNode();
|
||||
|
||||
|
@ -379,7 +379,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = glossy;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfGlass)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfGlass)) {
|
||||
BL::ShaderNodeBsdfGlass b_glass_node(b_node);
|
||||
GlassBsdfNode *glass = new GlassBsdfNode();
|
||||
switch(b_glass_node.distribution()) {
|
||||
|
@ -395,7 +395,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = glass;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfRefraction)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfRefraction)) {
|
||||
BL::ShaderNodeBsdfRefraction b_refraction_node(b_node);
|
||||
RefractionBsdfNode *refraction = new RefractionBsdfNode();
|
||||
switch(b_refraction_node.distribution()) {
|
||||
|
@ -411,7 +411,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = refraction;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfToon)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfToon)) {
|
||||
BL::ShaderNodeBsdfToon b_toon_node(b_node);
|
||||
ToonBsdfNode *toon = new ToonBsdfNode();
|
||||
switch(b_toon_node.component()) {
|
||||
|
@ -424,7 +424,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = toon;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfHair)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfHair)) {
|
||||
BL::ShaderNodeBsdfHair b_hair_node(b_node);
|
||||
HairBsdfNode *hair = new HairBsdfNode();
|
||||
switch(b_hair_node.component()) {
|
||||
|
@ -437,64 +437,64 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = hair;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfTranslucent)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfTranslucent)) {
|
||||
node = new TranslucentBsdfNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfTransparent)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfTransparent)) {
|
||||
node = new TransparentBsdfNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBsdfVelvet)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBsdfVelvet)) {
|
||||
node = new VelvetBsdfNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeEmission)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeEmission)) {
|
||||
node = new EmissionNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) {
|
||||
node = new AmbientOcclusionNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeVolumeScatter)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeVolumeScatter)) {
|
||||
node = new ScatterVolumeNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeVolumeAbsorption)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeVolumeAbsorption)) {
|
||||
node = new AbsorptionVolumeNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeNewGeometry)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeNewGeometry)) {
|
||||
node = new GeometryNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeWireframe)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeWireframe)) {
|
||||
BL::ShaderNodeWireframe b_wireframe_node(b_node);
|
||||
WireframeNode *wire = new WireframeNode();
|
||||
wire->use_pixel_size = b_wireframe_node.use_pixel_size();
|
||||
node = wire;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeWavelength)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeWavelength)) {
|
||||
node = new WavelengthNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBlackbody)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBlackbody)) {
|
||||
node = new BlackbodyNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeLightPath)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeLightPath)) {
|
||||
node = new LightPathNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeLightFalloff)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeLightFalloff)) {
|
||||
node = new LightFalloffNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeObjectInfo)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeObjectInfo)) {
|
||||
node = new ObjectInfoNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeParticleInfo)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeParticleInfo)) {
|
||||
node = new ParticleInfoNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeHairInfo)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeHairInfo)) {
|
||||
node = new HairInfoNode();
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeBump)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeBump)) {
|
||||
BL::ShaderNodeBump b_bump_node(b_node);
|
||||
BumpNode *bump = new BumpNode();
|
||||
bump->invert = b_bump_node.invert();
|
||||
node = bump;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeScript)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeScript)) {
|
||||
#ifdef WITH_OSL
|
||||
if(scene->shader_manager->use_osl()) {
|
||||
/* create script node */
|
||||
|
@ -510,7 +510,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
* Socket names must be stored in the extra lists instead. */
|
||||
BL::Node::inputs_iterator b_input;
|
||||
|
||||
for (b_script_node.inputs.begin(b_input); b_input != b_script_node.inputs.end(); ++b_input) {
|
||||
for(b_script_node.inputs.begin(b_input); b_input != b_script_node.inputs.end(); ++b_input) {
|
||||
script_node->input_names.push_back(ustring(b_input->name()));
|
||||
ShaderInput *input = script_node->add_input(script_node->input_names.back().c_str(),
|
||||
convert_socket_type(*b_input));
|
||||
|
@ -519,7 +519,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
|
||||
BL::Node::outputs_iterator b_output;
|
||||
|
||||
for (b_script_node.outputs.begin(b_output); b_output != b_script_node.outputs.end(); ++b_output) {
|
||||
for(b_script_node.outputs.begin(b_output); b_output != b_script_node.outputs.end(); ++b_output) {
|
||||
script_node->output_names.push_back(ustring(b_output->name()));
|
||||
script_node->add_output(script_node->output_names.back().c_str(),
|
||||
convert_socket_type(*b_output));
|
||||
|
@ -548,7 +548,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
(void)b_ntree;
|
||||
#endif
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexImage)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexImage)) {
|
||||
BL::ShaderNodeTexImage b_image_node(b_node);
|
||||
BL::Image b_image(b_image_node.image());
|
||||
ImageTextureNode *image = new ImageTextureNode();
|
||||
|
@ -581,7 +581,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
image->use_alpha = b_image.use_alpha();
|
||||
|
||||
/* TODO(sergey): Does not work properly when we change builtin type. */
|
||||
if (b_image.is_updated()) {
|
||||
if(b_image.is_updated()) {
|
||||
scene->image_manager->tag_reload_image(image->filename,
|
||||
image->builtin_data,
|
||||
(InterpolationType)b_image_node.interpolation());
|
||||
|
@ -594,7 +594,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
|
||||
node = image;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
|
||||
BL::ShaderNodeTexEnvironment b_env_node(b_node);
|
||||
BL::Image b_image(b_env_node.image());
|
||||
EnvironmentTextureNode *env = new EnvironmentTextureNode();
|
||||
|
@ -618,7 +618,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
env->use_alpha = b_image.use_alpha();
|
||||
|
||||
/* TODO(sergey): Does not work properly when we change builtin type. */
|
||||
if (b_image.is_updated()) {
|
||||
if(b_image.is_updated()) {
|
||||
scene->image_manager->tag_reload_image(env->filename,
|
||||
env->builtin_data,
|
||||
INTERPOLATION_LINEAR);
|
||||
|
@ -629,41 +629,41 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping());
|
||||
node = env;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexGradient)) {
|
||||
BL::ShaderNodeTexGradient b_gradient_node(b_node);
|
||||
GradientTextureNode *gradient = new GradientTextureNode();
|
||||
gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()];
|
||||
get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping());
|
||||
node = gradient;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
|
||||
BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
|
||||
VoronoiTextureNode *voronoi = new VoronoiTextureNode();
|
||||
voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()];
|
||||
get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping());
|
||||
node = voronoi;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexMagic)) {
|
||||
BL::ShaderNodeTexMagic b_magic_node(b_node);
|
||||
MagicTextureNode *magic = new MagicTextureNode();
|
||||
magic->depth = b_magic_node.turbulence_depth();
|
||||
get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping());
|
||||
node = magic;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexWave)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexWave)) {
|
||||
BL::ShaderNodeTexWave b_wave_node(b_node);
|
||||
WaveTextureNode *wave = new WaveTextureNode();
|
||||
wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()];
|
||||
get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping());
|
||||
node = wave;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexChecker)) {
|
||||
BL::ShaderNodeTexChecker b_checker_node(b_node);
|
||||
CheckerTextureNode *checker = new CheckerTextureNode();
|
||||
get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping());
|
||||
node = checker;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexBrick)) {
|
||||
BL::ShaderNodeTexBrick b_brick_node(b_node);
|
||||
BrickTextureNode *brick = new BrickTextureNode();
|
||||
brick->offset = b_brick_node.offset();
|
||||
|
@ -673,20 +673,20 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping());
|
||||
node = brick;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexNoise)) {
|
||||
BL::ShaderNodeTexNoise b_noise_node(b_node);
|
||||
NoiseTextureNode *noise = new NoiseTextureNode();
|
||||
get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping());
|
||||
node = noise;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
|
||||
BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
|
||||
MusgraveTextureNode *musgrave = new MusgraveTextureNode();
|
||||
musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()];
|
||||
get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping());
|
||||
node = musgrave;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexCoord)) {
|
||||
BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
|
||||
TextureCoordinateNode *tex_coord = new TextureCoordinateNode();
|
||||
tex_coord->from_dupli = b_tex_coord_node.from_dupli();
|
||||
|
@ -696,7 +696,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
}
|
||||
node = tex_coord;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTexSky)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTexSky)) {
|
||||
BL::ShaderNodeTexSky b_sky_node(b_node);
|
||||
SkyTextureNode *sky = new SkyTextureNode();
|
||||
sky->type = SkyTextureNode::type_enum[(int)b_sky_node.sky_type()];
|
||||
|
@ -706,14 +706,14 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping());
|
||||
node = sky;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeNormalMap)) {
|
||||
BL::ShaderNodeNormalMap b_normal_map_node(b_node);
|
||||
NormalMapNode *nmap = new NormalMapNode();
|
||||
nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()];
|
||||
nmap->attribute = b_normal_map_node.uv_map();
|
||||
node = nmap;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeTangent)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeTangent)) {
|
||||
BL::ShaderNodeTangent b_tangent_node(b_node);
|
||||
TangentNode *tangent = new TangentNode();
|
||||
tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()];
|
||||
|
@ -721,7 +721,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
tangent->attribute = b_tangent_node.uv_map();
|
||||
node = tangent;
|
||||
}
|
||||
else if (b_node.is_a(&RNA_ShaderNodeUVMap)) {
|
||||
else if(b_node.is_a(&RNA_ShaderNodeUVMap)) {
|
||||
BL::ShaderNodeUVMap b_uvmap_node(b_node);
|
||||
UVMapNode *uvm = new UVMapNode();
|
||||
uvm->attribute = b_uvmap_node.uv_map();
|
||||
|
@ -737,7 +737,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
|
|||
|
||||
static bool node_use_modified_socket_name(ShaderNode *node)
|
||||
{
|
||||
if (node->special_type == SHADER_SPECIAL_TYPE_SCRIPT)
|
||||
if(node->special_type == SHADER_SPECIAL_TYPE_SCRIPT)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
|
@ -747,14 +747,14 @@ static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, B
|
|||
{
|
||||
string name = b_socket.name();
|
||||
|
||||
if (node_use_modified_socket_name(node)) {
|
||||
if(node_use_modified_socket_name(node)) {
|
||||
BL::Node::inputs_iterator b_input;
|
||||
bool found = false;
|
||||
int counter = 0, total = 0;
|
||||
|
||||
for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
|
||||
if (b_input->name() == name) {
|
||||
if (!found)
|
||||
for(b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
|
||||
if(b_input->name() == name) {
|
||||
if(!found)
|
||||
counter++;
|
||||
total++;
|
||||
}
|
||||
|
@ -764,10 +764,10 @@ static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, B
|
|||
}
|
||||
|
||||
/* rename if needed */
|
||||
if (name == "Shader")
|
||||
if(name == "Shader")
|
||||
name = "Closure";
|
||||
|
||||
if (total > 1)
|
||||
if(total > 1)
|
||||
name = string_printf("%s%d", name.c_str(), counter);
|
||||
}
|
||||
|
||||
|
@ -778,14 +778,14 @@ static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node,
|
|||
{
|
||||
string name = b_socket.name();
|
||||
|
||||
if (node_use_modified_socket_name(node)) {
|
||||
if(node_use_modified_socket_name(node)) {
|
||||
BL::Node::outputs_iterator b_output;
|
||||
bool found = false;
|
||||
int counter = 0, total = 0;
|
||||
|
||||
for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
|
||||
if (b_output->name() == name) {
|
||||
if (!found)
|
||||
for(b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
|
||||
if(b_output->name() == name) {
|
||||
if(!found)
|
||||
counter++;
|
||||
total++;
|
||||
}
|
||||
|
@ -795,10 +795,10 @@ static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node,
|
|||
}
|
||||
|
||||
/* rename if needed */
|
||||
if (name == "Shader")
|
||||
if(name == "Shader")
|
||||
name = "Closure";
|
||||
|
||||
if (total > 1)
|
||||
if(total > 1)
|
||||
name = string_printf("%s%d", name.c_str(), counter);
|
||||
}
|
||||
|
||||
|
@ -821,7 +821,7 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
BL::ShaderNode output_node(PointerRNA_NULL);
|
||||
|
||||
for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) {
|
||||
if (is_output_node(*b_node)) {
|
||||
if(is_output_node(*b_node)) {
|
||||
BL::ShaderNodeOutputMaterial b_output_node(*b_node);
|
||||
|
||||
if(b_output_node.is_active_output()) {
|
||||
|
@ -837,10 +837,10 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
|
||||
/* add nodes */
|
||||
for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) {
|
||||
if (b_node->mute() || b_node->is_a(&RNA_NodeReroute)) {
|
||||
if(b_node->mute() || b_node->is_a(&RNA_NodeReroute)) {
|
||||
/* replace muted node with internal links */
|
||||
BL::Node::internal_links_iterator b_link;
|
||||
for (b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) {
|
||||
for(b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) {
|
||||
ProxyNode *proxy = new ProxyNode(convert_socket_type(b_link->to_socket()));
|
||||
|
||||
input_map[b_link->from_socket().ptr.data] = proxy->inputs[0];
|
||||
|
@ -849,10 +849,10 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
graph->add(proxy);
|
||||
}
|
||||
}
|
||||
else if (b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup)) {
|
||||
else if(b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup)) {
|
||||
|
||||
BL::ShaderNodeTree b_group_ntree(PointerRNA_NULL);
|
||||
if (b_node->is_a(&RNA_ShaderNodeGroup))
|
||||
if(b_node->is_a(&RNA_ShaderNodeGroup))
|
||||
b_group_ntree = BL::ShaderNodeTree(((BL::NodeGroup)(*b_node)).node_tree());
|
||||
else
|
||||
b_group_ntree = BL::ShaderNodeTree(((BL::NodeCustomGroup)(*b_node)).node_tree());
|
||||
|
@ -883,28 +883,28 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
output_map[b_output->ptr.data] = proxy->outputs[0];
|
||||
}
|
||||
|
||||
if (b_group_ntree)
|
||||
if(b_group_ntree)
|
||||
add_nodes(scene, b_data, b_scene, graph, b_group_ntree, group_proxy_input_map, group_proxy_output_map);
|
||||
}
|
||||
else if (b_node->is_a(&RNA_NodeGroupInput)) {
|
||||
else if(b_node->is_a(&RNA_NodeGroupInput)) {
|
||||
/* map each socket to a proxy node */
|
||||
for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
|
||||
ProxyMap::const_iterator proxy_it = proxy_input_map.find(b_output->identifier());
|
||||
if (proxy_it != proxy_input_map.end()) {
|
||||
if(proxy_it != proxy_input_map.end()) {
|
||||
ProxyNode *proxy = proxy_it->second;
|
||||
|
||||
output_map[b_output->ptr.data] = proxy->outputs[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (b_node->is_a(&RNA_NodeGroupOutput)) {
|
||||
else if(b_node->is_a(&RNA_NodeGroupOutput)) {
|
||||
BL::NodeGroupOutput b_output_node(*b_node);
|
||||
/* only the active group output is used */
|
||||
if (b_output_node.is_active_output()) {
|
||||
if(b_output_node.is_active_output()) {
|
||||
/* map each socket to a proxy node */
|
||||
for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
|
||||
ProxyMap::const_iterator proxy_it = proxy_output_map.find(b_input->identifier());
|
||||
if (proxy_it != proxy_output_map.end()) {
|
||||
if(proxy_it != proxy_output_map.end()) {
|
||||
ProxyNode *proxy = proxy_it->second;
|
||||
|
||||
input_map[b_input->ptr.data] = proxy->inputs[0];
|
||||
|
@ -917,8 +917,8 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
else {
|
||||
ShaderNode *node = NULL;
|
||||
|
||||
if (is_output_node(*b_node)) {
|
||||
if (b_node->ptr.data == output_node.ptr.data) {
|
||||
if(is_output_node(*b_node)) {
|
||||
if(b_node->ptr.data == output_node.ptr.data) {
|
||||
node = graph->output();
|
||||
}
|
||||
}
|
||||
|
@ -930,7 +930,7 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
/* map node sockets for linking */
|
||||
for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
|
||||
ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input);
|
||||
if (!input) {
|
||||
if(!input) {
|
||||
/* XXX should not happen, report error? */
|
||||
continue;
|
||||
}
|
||||
|
@ -940,7 +940,7 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
}
|
||||
for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
|
||||
ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output);
|
||||
if (!output) {
|
||||
if(!output) {
|
||||
/* XXX should not happen, report error? */
|
||||
continue;
|
||||
}
|
||||
|
@ -966,10 +966,10 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha
|
|||
ShaderInput *input = 0;
|
||||
|
||||
PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data);
|
||||
if (output_it != output_map.end())
|
||||
if(output_it != output_map.end())
|
||||
output = output_it->second;
|
||||
PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data);
|
||||
if (input_it != input_map.end())
|
||||
if(input_it != input_map.end())
|
||||
input = input_it->second;
|
||||
|
||||
/* either node may be NULL when the node was not exported, typically
|
||||
|
|
|
@ -111,7 +111,7 @@ bool BlenderSync::sync_recalc()
|
|||
|
||||
if(b_ob->is_updated_data()) {
|
||||
BL::Object::particle_systems_iterator b_psys;
|
||||
for (b_ob->particle_systems.begin(b_psys); b_psys != b_ob->particle_systems.end(); ++b_psys)
|
||||
for(b_ob->particle_systems.begin(b_psys); b_psys != b_ob->particle_systems.end(); ++b_psys)
|
||||
particle_system_map.set_recalc(*b_ob);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -43,8 +43,8 @@ void python_thread_state_restore(void **python_thread_state);
|
|||
static inline BL::Mesh object_to_mesh(BL::BlendData data, BL::Object object, BL::Scene scene, bool apply_modifiers, bool render, bool calc_undeformed)
|
||||
{
|
||||
BL::Mesh me = data.meshes.new_from_object(scene, object, apply_modifiers, (render)? 2: 1, false, calc_undeformed);
|
||||
if ((bool)me) {
|
||||
if (me.use_auto_smooth()) {
|
||||
if((bool)me) {
|
||||
if(me.use_auto_smooth()) {
|
||||
me.calc_normals_split();
|
||||
}
|
||||
me.calc_tessface(true);
|
||||
|
@ -310,7 +310,7 @@ static inline string get_string(PointerRNA& ptr, const char *name)
|
|||
char cstrbuf[1024];
|
||||
char *cstr = RNA_string_get_alloc(&ptr, name, cstrbuf, sizeof(cstrbuf));
|
||||
string str(cstr);
|
||||
if (cstr != cstrbuf)
|
||||
if(cstr != cstrbuf)
|
||||
MEM_freeN(cstr);
|
||||
|
||||
return str;
|
||||
|
@ -388,7 +388,7 @@ static inline BL::SmokeDomainSettings object_smoke_domain_find(BL::Object b_ob)
|
|||
BL::Object::modifiers_iterator b_mod;
|
||||
|
||||
for(b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
|
||||
if (b_mod->is_a(&RNA_SmokeModifier)) {
|
||||
if(b_mod->is_a(&RNA_SmokeModifier)) {
|
||||
BL::SmokeModifier b_smd(*b_mod);
|
||||
|
||||
if(b_smd.smoke_type() == BL::SmokeModifier::smoke_type_DOMAIN)
|
||||
|
|
|
@ -638,7 +638,7 @@ void RegularBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility
|
|||
size_t steps = mesh->motion_steps - 1;
|
||||
float4 *key_steps = attr->data_float4();
|
||||
|
||||
for (size_t i = 0; i < steps; i++)
|
||||
for(size_t i = 0; i < steps; i++)
|
||||
curve.bounds_grow(k, key_steps + i*mesh_size, bbox);
|
||||
}
|
||||
}
|
||||
|
@ -660,7 +660,7 @@ void RegularBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility
|
|||
size_t steps = mesh->motion_steps - 1;
|
||||
float3 *vert_steps = attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps; i++)
|
||||
for(size_t i = 0; i < steps; i++)
|
||||
triangle.bounds_grow(vert_steps + i*mesh_size, bbox);
|
||||
}
|
||||
}
|
||||
|
@ -877,7 +877,7 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
|
|||
size_t steps = mesh->motion_steps - 1;
|
||||
float4 *key_steps = attr->data_float4();
|
||||
|
||||
for (size_t i = 0; i < steps; i++)
|
||||
for(size_t i = 0; i < steps; i++)
|
||||
curve.bounds_grow(k, key_steps + i*mesh_size, bbox);
|
||||
}
|
||||
}
|
||||
|
@ -899,7 +899,7 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
|
|||
size_t steps = mesh->motion_steps - 1;
|
||||
float3 *vert_steps = attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps; i++)
|
||||
for(size_t i = 0; i < steps; i++)
|
||||
triangle.bounds_grow(vert_steps + i*mesh_size, bbox);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -42,7 +42,7 @@ ccl_device_inline int bitscan(int value)
|
|||
{
|
||||
assert(value != 0);
|
||||
int bit = 0;
|
||||
while (value >>= 1) {
|
||||
while(value >>= 1) {
|
||||
++bit;
|
||||
}
|
||||
return bit;
|
||||
|
@ -136,7 +136,7 @@ void BVHBuild::add_reference_mesh(BoundBox& root, BoundBox& center, Mesh *mesh,
|
|||
size_t steps = mesh->motion_steps - 1;
|
||||
float4 *key_steps = curve_attr_mP->data_float4();
|
||||
|
||||
for (size_t i = 0; i < steps; i++)
|
||||
for(size_t i = 0; i < steps; i++)
|
||||
curve.bounds_grow(k, key_steps + i*mesh_size, bounds);
|
||||
|
||||
type = PRIMITIVE_MOTION_CURVE;
|
||||
|
|
|
@ -253,7 +253,7 @@ void BVHSpatialSplit::split_reference(BVHBuild *builder, BVHReference& left, BVH
|
|||
Object *ob = builder->objects[ref.prim_object()];
|
||||
const Mesh *mesh = ob->mesh;
|
||||
|
||||
if (ref.prim_type() & PRIMITIVE_ALL_TRIANGLE) {
|
||||
if(ref.prim_type() & PRIMITIVE_ALL_TRIANGLE) {
|
||||
const int *inds = mesh->triangles[ref.prim_index()].v;
|
||||
const float3 *verts = &mesh->verts[0];
|
||||
const float3* v1 = &verts[inds[2]];
|
||||
|
|
|
@ -209,7 +209,7 @@ public:
|
|||
int end_sample = tile.start_sample + tile.num_samples;
|
||||
|
||||
for(int sample = start_sample; sample < end_sample; sample++) {
|
||||
if (task.get_cancel() || task_pool.canceled()) {
|
||||
if(task.get_cancel() || task_pool.canceled()) {
|
||||
if(task.need_finish_queue == false)
|
||||
break;
|
||||
}
|
||||
|
@ -370,7 +370,7 @@ public:
|
|||
|
||||
int get_split_task_count(DeviceTask& task)
|
||||
{
|
||||
if (task.type == DeviceTask::SHADER)
|
||||
if(task.type == DeviceTask::SHADER)
|
||||
return task.get_subtask_count(TaskScheduler::num_threads(), 256);
|
||||
else
|
||||
return task.get_subtask_count(TaskScheduler::num_threads());
|
||||
|
|
|
@ -331,7 +331,7 @@ public:
|
|||
string cubin_data;
|
||||
CUresult result;
|
||||
|
||||
if (path_read_text(cubin, cubin_data))
|
||||
if(path_read_text(cubin, cubin_data))
|
||||
result = cuModuleLoadData(&cuModule, cubin_data.c_str());
|
||||
else
|
||||
result = CUDA_ERROR_FILE_NOT_FOUND;
|
||||
|
@ -483,7 +483,7 @@ public:
|
|||
if(interpolation == INTERPOLATION_CLOSEST) {
|
||||
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_POINT));
|
||||
}
|
||||
else if (interpolation == INTERPOLATION_LINEAR) {
|
||||
else if(interpolation == INTERPOLATION_LINEAR) {
|
||||
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_LINEAR));
|
||||
}
|
||||
else {/* CUBIC and SMART are unsupported for CUDA */
|
||||
|
@ -966,7 +966,7 @@ public:
|
|||
int end_sample = tile.start_sample + tile.num_samples;
|
||||
|
||||
for(int sample = start_sample; sample < end_sample; sample++) {
|
||||
if (task->get_cancel()) {
|
||||
if(task->get_cancel()) {
|
||||
if(task->need_finish_queue == false)
|
||||
break;
|
||||
}
|
||||
|
@ -1035,12 +1035,12 @@ bool device_cuda_init(void)
|
|||
static bool initialized = false;
|
||||
static bool result = false;
|
||||
|
||||
if (initialized)
|
||||
if(initialized)
|
||||
return result;
|
||||
|
||||
initialized = true;
|
||||
int cuew_result = cuewInit();
|
||||
if (cuew_result == CUEW_SUCCESS) {
|
||||
if(cuew_result == CUEW_SUCCESS) {
|
||||
VLOG(1) << "CUEW initialization succeeded";
|
||||
if(CUDADevice::have_precompiled_kernels()) {
|
||||
VLOG(1) << "Found precompiled kernels";
|
||||
|
|
|
@ -269,7 +269,7 @@ public:
|
|||
lock.unlock();
|
||||
|
||||
TileList::iterator it = tile_list_find(the_tiles, tile);
|
||||
if (it != the_tiles.end()) {
|
||||
if(it != the_tiles.end()) {
|
||||
tile.buffers = it->buffers;
|
||||
the_tiles.erase(it);
|
||||
}
|
||||
|
|
|
@ -423,7 +423,7 @@ public:
|
|||
int num_base = 0;
|
||||
int total_devices = 0;
|
||||
|
||||
for (int platform = 0; platform < num_platforms; platform++) {
|
||||
for(int platform = 0; platform < num_platforms; platform++) {
|
||||
cl_uint num_devices;
|
||||
|
||||
if(opencl_error(clGetDeviceIDs(platforms[platform], opencl_device_type(), 0, NULL, &num_devices)))
|
||||
|
@ -1125,7 +1125,7 @@ bool device_opencl_init(void) {
|
|||
static bool initialized = false;
|
||||
static bool result = false;
|
||||
|
||||
if (initialized)
|
||||
if(initialized)
|
||||
return result;
|
||||
|
||||
initialized = true;
|
||||
|
@ -1160,7 +1160,7 @@ void device_opencl_info(vector<DeviceInfo>& devices)
|
|||
/* devices are numbered consecutively across platforms */
|
||||
int num_base = 0;
|
||||
|
||||
for (int platform = 0; platform < num_platforms; platform++, num_base += num_devices) {
|
||||
for(int platform = 0; platform < num_platforms; platform++, num_base += num_devices) {
|
||||
num_devices = 0;
|
||||
if(clGetDeviceIDs(platform_ids[platform], opencl_device_type(), 0, NULL, &num_devices) != CL_SUCCESS || num_devices == 0)
|
||||
continue;
|
||||
|
|
|
@ -111,7 +111,7 @@ void DeviceTask::update_progress(RenderTile *rtile)
|
|||
if(update_tile_sample) {
|
||||
double current_time = time_dt();
|
||||
|
||||
if (current_time - last_update_time >= 1.0) {
|
||||
if(current_time - last_update_time >= 1.0) {
|
||||
update_tile_sample(*rtile);
|
||||
|
||||
last_update_time = current_time;
|
||||
|
|
|
@ -157,7 +157,7 @@ ccl_device float bssrdf_cubic_quintic_root_find(float xi)
|
|||
float x = 0.25f;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < max_iteration_count; i++) {
|
||||
for(i = 0; i < max_iteration_count; i++) {
|
||||
float x2 = x*x;
|
||||
float x3 = x2*x;
|
||||
float nx = (1.0f - x);
|
||||
|
|
|
@ -442,12 +442,12 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
float r_ext = mw_extension + r_curr;
|
||||
float coverage = 1.0f;
|
||||
|
||||
if (bminz - r_curr > isect->t || bmaxz + r_curr < epsilon || bminx > r_ext|| bmaxx < -r_ext|| bminy > r_ext|| bmaxy < -r_ext) {
|
||||
if(bminz - r_curr > isect->t || bmaxz + r_curr < epsilon || bminx > r_ext|| bmaxx < -r_ext|| bminy > r_ext|| bmaxy < -r_ext) {
|
||||
/* the bounding box does not overlap the square centered at O */
|
||||
tree += level;
|
||||
level = tree & -tree;
|
||||
}
|
||||
else if (level == 1) {
|
||||
else if(level == 1) {
|
||||
|
||||
/* the maximum recursion depth is reached.
|
||||
* check if dP0.(Q-P0)>=0 and dPn.(Pn-Q)>=0.
|
||||
|
@ -459,7 +459,7 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
if(flags & CURVE_KN_RIBBONS) {
|
||||
float3 tg = (p_en - p_st);
|
||||
float w = tg.x * tg.x + tg.y * tg.y;
|
||||
if (w == 0) {
|
||||
if(w == 0) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
|
@ -474,17 +474,17 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
float3 p_curr = ((curve_coef[3] * u + curve_coef[2]) * u + curve_coef[1]) * u + curve_coef[0];
|
||||
|
||||
float3 dp_st = (3 * curve_coef[3] * i_st + 2 * curve_coef[2]) * i_st + curve_coef[1];
|
||||
if (dot(tg, dp_st)< 0)
|
||||
if(dot(tg, dp_st)< 0)
|
||||
dp_st *= -1;
|
||||
if (dot(dp_st, -p_st) + p_curr.z * dp_st.z < 0) {
|
||||
if(dot(dp_st, -p_st) + p_curr.z * dp_st.z < 0) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
}
|
||||
float3 dp_en = (3 * curve_coef[3] * i_en + 2 * curve_coef[2]) * i_en + curve_coef[1];
|
||||
if (dot(tg, dp_en) < 0)
|
||||
if(dot(tg, dp_en) < 0)
|
||||
dp_en *= -1;
|
||||
if (dot(dp_en, p_en) - p_curr.z * dp_en.z < 0) {
|
||||
if(dot(dp_en, p_en) - p_curr.z * dp_en.z < 0) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
|
@ -500,13 +500,13 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
float d0 = d - r_curr;
|
||||
float d1 = d + r_curr;
|
||||
float inv_mw_extension = 1.0f/mw_extension;
|
||||
if (d0 >= 0)
|
||||
if(d0 >= 0)
|
||||
coverage = (min(d1 * inv_mw_extension, 1.0f) - min(d0 * inv_mw_extension, 1.0f)) * 0.5f;
|
||||
else // inside
|
||||
coverage = (min(d1 * inv_mw_extension, 1.0f) + min(-d0 * inv_mw_extension, 1.0f)) * 0.5f;
|
||||
}
|
||||
|
||||
if (p_curr.x * p_curr.x + p_curr.y * p_curr.y >= r_ext * r_ext || p_curr.z <= epsilon || isect->t < p_curr.z) {
|
||||
if(p_curr.x * p_curr.x + p_curr.y * p_curr.y >= r_ext * r_ext || p_curr.z <= epsilon || isect->t < p_curr.z) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
|
@ -548,7 +548,7 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
float tb = 2*(tdif.z - tg.z*(tdifz + gd*(tdifz*gd + or1)));
|
||||
float tc = dot(tdif,tdif) - tdifz * tdifz * (1 + gd*gd) - or1*or1 - 2*or1*tdifz*gd;
|
||||
float td = tb*tb - 4*cyla*tc;
|
||||
if (td < 0.0f) {
|
||||
if(td < 0.0f) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
|
@ -559,10 +559,10 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
t = tcentre + correction;
|
||||
|
||||
float3 dp_st = (3 * curve_coef[3] * i_st + 2 * curve_coef[2]) * i_st + curve_coef[1];
|
||||
if (dot(tg, dp_st)< 0)
|
||||
if(dot(tg, dp_st)< 0)
|
||||
dp_st *= -1;
|
||||
float3 dp_en = (3 * curve_coef[3] * i_en + 2 * curve_coef[2]) * i_en + curve_coef[1];
|
||||
if (dot(tg, dp_en) < 0)
|
||||
if(dot(tg, dp_en) < 0)
|
||||
dp_en *= -1;
|
||||
|
||||
if(flags & CURVE_KN_BACKFACING && (dot(dp_st, -p_st) + t * dp_st.z < 0 || dot(dp_en, p_en) - t * dp_en.z < 0 || isect->t < t || t <= 0.0f)) {
|
||||
|
@ -570,7 +570,7 @@ ccl_device_inline bool bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersect
|
|||
t = tcentre + correction;
|
||||
}
|
||||
|
||||
if (dot(dp_st, -p_st) + t * dp_st.z < 0 || dot(dp_en, p_en) - t * dp_en.z < 0 || isect->t < t || t <= 0.0f) {
|
||||
if(dot(dp_st, -p_st) + t * dp_st.z < 0 || dot(dp_en, p_en) - t * dp_en.z < 0 || isect->t < t || t <= 0.0f) {
|
||||
tree++;
|
||||
level = tree & -tree;
|
||||
continue;
|
||||
|
@ -777,7 +777,7 @@ ccl_device_inline bool bvh_curve_intersect(KernelGlobals *kg, Intersection *isec
|
|||
float tc = dot3(tdif, tdif) - tdifz*tdifz - tdifma*tdifma;
|
||||
float td = tb*tb - 4*a*tc;
|
||||
|
||||
if (td < 0.0f)
|
||||
if(td < 0.0f)
|
||||
return false;
|
||||
|
||||
float rootd = 0.0f;
|
||||
|
@ -818,7 +818,7 @@ ccl_device_inline bool bvh_curve_intersect(KernelGlobals *kg, Intersection *isec
|
|||
|
||||
if(t > 0.0f && t < isect->t && z >= 0 && z <= l) {
|
||||
|
||||
if (flags & CURVE_KN_ENCLOSEFILTER) {
|
||||
if(flags & CURVE_KN_ENCLOSEFILTER) {
|
||||
float enc_ratio = 1.01f;
|
||||
if((difz > -r1 * enc_ratio) && (dot3(dif_second, tg) < r2 * enc_ratio)) {
|
||||
float a2 = 1.0f - (dirz*dirz*(1 + gd*gd*enc_ratio*enc_ratio));
|
||||
|
@ -984,7 +984,7 @@ ccl_device_inline float3 bvh_curve_refine(KernelGlobals *kg, ShaderData *sd, con
|
|||
sd->v = 0.0f;
|
||||
#endif
|
||||
|
||||
if (flag & CURVE_KN_TRUETANGENTGNORMAL) {
|
||||
if(flag & CURVE_KN_TRUETANGENTGNORMAL) {
|
||||
sd->Ng = -(D - tg * dot(tg, D));
|
||||
sd->Ng = normalize(sd->Ng);
|
||||
}
|
||||
|
@ -995,7 +995,7 @@ ccl_device_inline float3 bvh_curve_refine(KernelGlobals *kg, ShaderData *sd, con
|
|||
sd->Ng = (dif - tg * sd->u * l) / (P_curve[0].w + sd->u * l * gd);
|
||||
|
||||
/* adjustment for changing radius */
|
||||
if (gd != 0.0f) {
|
||||
if(gd != 0.0f) {
|
||||
sd->Ng = sd->Ng - gd * tg;
|
||||
sd->Ng = normalize(sd->Ng);
|
||||
}
|
||||
|
|
|
@ -194,7 +194,7 @@ ccl_device float4 primitive_motion_vector(KernelGlobals *kg, ShaderData *sd)
|
|||
|
||||
/* camera motion, for perspective/orthographic motion.pre/post will be a
|
||||
* world-to-raster matrix, for panorama it's world-to-camera */
|
||||
if (kernel_data.cam.type != CAMERA_PANORAMA) {
|
||||
if(kernel_data.cam.type != CAMERA_PANORAMA) {
|
||||
tfm = kernel_data.cam.worldtoraster;
|
||||
motion_center = transform_perspective(&tfm, center);
|
||||
|
||||
|
|
|
@ -155,8 +155,8 @@ ccl_device_inline bool triangle_intersect(KernelGlobals *kg,
|
|||
*/
|
||||
const float T = (U * A_kz + V * B_kz + W * C_kz) * Sz;
|
||||
const float sign_T = xor_signmast(T, sign_mask);
|
||||
if ((sign_T < 0.0f) ||
|
||||
(sign_T > isect->t * xor_signmast(det, sign_mask)))
|
||||
if((sign_T < 0.0f) ||
|
||||
(sign_T > isect->t * xor_signmast(det, sign_mask)))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -254,8 +254,8 @@ ccl_device_inline void triangle_intersect_subsurface(
|
|||
const float Cz = Sz * C_kz;
|
||||
const float T = U * Az + V * Bz + W * Cz;
|
||||
|
||||
if ((xor_signmast(T, sign_mask) < 0.0f) ||
|
||||
(xor_signmast(T, sign_mask) > tmax * xor_signmast(det, sign_mask)))
|
||||
if((xor_signmast(T, sign_mask) < 0.0f) ||
|
||||
(xor_signmast(T, sign_mask) > tmax * xor_signmast(det, sign_mask)))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -55,7 +55,7 @@ void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t
|
|||
int id = atoi(name + strlen("__tex_image_float_"));
|
||||
int array_index = id;
|
||||
|
||||
if (array_index >= 0 && array_index < MAX_FLOAT_IMAGES) {
|
||||
if(array_index >= 0 && array_index < MAX_FLOAT_IMAGES) {
|
||||
tex = &kg->texture_float_images[array_index];
|
||||
}
|
||||
|
||||
|
@ -70,7 +70,7 @@ void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t
|
|||
int id = atoi(name + strlen("__tex_image_"));
|
||||
int array_index = id - MAX_FLOAT_IMAGES;
|
||||
|
||||
if (array_index >= 0 && array_index < MAX_BYTE_IMAGES) {
|
||||
if(array_index >= 0 && array_index < MAX_BYTE_IMAGES) {
|
||||
tex = &kg->texture_byte_images[array_index];
|
||||
}
|
||||
|
||||
|
|
|
@ -57,7 +57,7 @@ ccl_device void compute_light_pass(KernelGlobals *kg, ShaderData *sd, PathRadian
|
|||
/* sample subsurface scattering */
|
||||
if((is_combined || is_sss_sample) && (sd->flag & SD_BSSRDF)) {
|
||||
/* when mixing BSSRDF and BSDF closures we should skip BSDF lighting if scattering was successful */
|
||||
if (kernel_path_subsurface_scatter(kg, sd, &L_sample, &state, &rng, &ray, &throughput))
|
||||
if(kernel_path_subsurface_scatter(kg, sd, &L_sample, &state, &rng, &ray, &throughput))
|
||||
is_sss_sample = true;
|
||||
}
|
||||
#endif
|
||||
|
@ -259,7 +259,7 @@ ccl_device void kernel_bake_evaluate(KernelGlobals *kg, ccl_global uint4 *input,
|
|||
/* data passes */
|
||||
case SHADER_EVAL_NORMAL:
|
||||
{
|
||||
if ((sd.flag & SD_HAS_BUMP)) {
|
||||
if((sd.flag & SD_HAS_BUMP)) {
|
||||
shader_eval_surface(kg, &sd, 0.f, 0, SHADER_CONTEXT_MAIN);
|
||||
}
|
||||
|
||||
|
|
|
@ -128,7 +128,7 @@ ccl_device_inline uint cmj_permute(uint i, uint l, uint p)
|
|||
i *= 0xc860a3df;
|
||||
i &= w;
|
||||
i ^= i >> 5;
|
||||
} while (i >= l);
|
||||
} while(i >= l);
|
||||
|
||||
return (i + p) % l;
|
||||
}
|
||||
|
|
|
@ -627,7 +627,7 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg, PathState *sta
|
|||
step_size = kernel_data.integrator.volume_step_size;
|
||||
/* compute exact steps in advance for malloc */
|
||||
max_steps = max((int)ceilf(ray->t/step_size), 1);
|
||||
if (max_steps > global_max_steps) {
|
||||
if(max_steps > global_max_steps) {
|
||||
max_steps = global_max_steps;
|
||||
step_size = ray->t / (float)max_steps;
|
||||
}
|
||||
|
|
|
@ -138,12 +138,12 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result
|
|||
{
|
||||
/* 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. */
|
||||
if (xform) {
|
||||
if(xform) {
|
||||
const ShaderData *sd = (const ShaderData *)xform;
|
||||
KernelGlobals *kg = sd->osl_globals;
|
||||
int object = sd->object;
|
||||
|
||||
if (object != OBJECT_NONE) {
|
||||
if(object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm;
|
||||
|
||||
|
@ -168,12 +168,12 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44
|
|||
{
|
||||
/* 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. */
|
||||
if (xform) {
|
||||
if(xform) {
|
||||
const ShaderData *sd = (const ShaderData *)xform;
|
||||
KernelGlobals *kg = sd->osl_globals;
|
||||
int object = sd->object;
|
||||
|
||||
if (object != OBJECT_NONE) {
|
||||
if(object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform itfm;
|
||||
|
||||
|
@ -198,27 +198,27 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result
|
|||
{
|
||||
KernelGlobals *kg = kernel_globals;
|
||||
|
||||
if (from == u_ndc) {
|
||||
if(from == u_ndc) {
|
||||
Transform tfm = transform_transpose(transform_quick_inverse(kernel_data.cam.worldtondc));
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_raster) {
|
||||
else if(from == u_raster) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.rastertoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_screen) {
|
||||
else if(from == u_screen) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.screentoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_camera) {
|
||||
else if(from == u_camera) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.cameratoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_world) {
|
||||
else if(from == u_world) {
|
||||
result.makeIdentity();
|
||||
return true;
|
||||
}
|
||||
|
@ -230,27 +230,27 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44
|
|||
{
|
||||
KernelGlobals *kg = kernel_globals;
|
||||
|
||||
if (to == u_ndc) {
|
||||
if(to == u_ndc) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtondc);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_raster) {
|
||||
else if(to == u_raster) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtoraster);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_screen) {
|
||||
else if(to == u_screen) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtoscreen);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_camera) {
|
||||
else if(to == u_camera) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtocamera);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_world) {
|
||||
else if(to == u_world) {
|
||||
result.makeIdentity();
|
||||
return true;
|
||||
}
|
||||
|
@ -262,11 +262,11 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result
|
|||
{
|
||||
/* 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. */
|
||||
if (xform) {
|
||||
if(xform) {
|
||||
const ShaderData *sd = (const ShaderData *)xform;
|
||||
int object = sd->object;
|
||||
|
||||
if (object != OBJECT_NONE) {
|
||||
if(object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_tfm;
|
||||
#else
|
||||
|
@ -287,11 +287,11 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44
|
|||
{
|
||||
/* 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. */
|
||||
if (xform) {
|
||||
if(xform) {
|
||||
const ShaderData *sd = (const ShaderData *)xform;
|
||||
int object = sd->object;
|
||||
|
||||
if (object != OBJECT_NONE) {
|
||||
if(object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_itfm;
|
||||
#else
|
||||
|
@ -312,22 +312,22 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result
|
|||
{
|
||||
KernelGlobals *kg = kernel_globals;
|
||||
|
||||
if (from == u_ndc) {
|
||||
if(from == u_ndc) {
|
||||
Transform tfm = transform_transpose(transform_quick_inverse(kernel_data.cam.worldtondc));
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_raster) {
|
||||
else if(from == u_raster) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.rastertoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_screen) {
|
||||
else if(from == u_screen) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.screentoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (from == u_camera) {
|
||||
else if(from == u_camera) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.cameratoworld);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
|
@ -340,22 +340,22 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44
|
|||
{
|
||||
KernelGlobals *kg = kernel_globals;
|
||||
|
||||
if (to == u_ndc) {
|
||||
if(to == u_ndc) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtondc);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_raster) {
|
||||
else if(to == u_raster) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtoraster);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_screen) {
|
||||
else if(to == u_screen) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtoscreen);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
}
|
||||
else if (to == u_camera) {
|
||||
else if(to == u_camera) {
|
||||
Transform tfm = transform_transpose(kernel_data.cam.worldtocamera);
|
||||
COPY_MATRIX44(&result, &tfm);
|
||||
return true;
|
||||
|
@ -373,8 +373,8 @@ bool OSLRenderServices::get_array_attribute(OSL::ShaderGlobals *sg, bool derivat
|
|||
|
||||
static bool set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, void *val)
|
||||
{
|
||||
if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
|
||||
type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
|
||||
if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
|
||||
type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
|
||||
{
|
||||
float *fval = (float *)val;
|
||||
|
||||
|
@ -382,7 +382,7 @@ static bool set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, v
|
|||
fval[1] = f[0].y;
|
||||
fval[2] = f[0].z;
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
fval[3] = f[1].x;
|
||||
fval[4] = f[1].y;
|
||||
fval[5] = f[1].z;
|
||||
|
@ -398,7 +398,7 @@ static bool set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, v
|
|||
float *fval = (float *)val;
|
||||
fval[0] = average(f[0]);
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
fval[1] = average(f[1]);
|
||||
fval[2] = average(f[2]);
|
||||
}
|
||||
|
@ -422,15 +422,15 @@ static bool set_attribute_float3(float3 f, TypeDesc type, bool derivatives, void
|
|||
|
||||
static bool set_attribute_float(float f[3], TypeDesc type, bool derivatives, void *val)
|
||||
{
|
||||
if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
|
||||
type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
|
||||
if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
|
||||
type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
|
||||
{
|
||||
float *fval = (float *)val;
|
||||
fval[0] = f[0];
|
||||
fval[1] = f[1];
|
||||
fval[2] = f[2];
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
fval[3] = f[1];
|
||||
fval[4] = f[1];
|
||||
fval[5] = f[1];
|
||||
|
@ -446,7 +446,7 @@ static bool set_attribute_float(float f[3], TypeDesc type, bool derivatives, voi
|
|||
float *fval = (float *)val;
|
||||
fval[0] = f[0];
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
fval[1] = f[1];
|
||||
fval[2] = f[2];
|
||||
}
|
||||
|
@ -474,7 +474,7 @@ static bool set_attribute_int(int i, TypeDesc type, bool derivatives, void *val)
|
|||
int *ival = (int *)val;
|
||||
ival[0] = i;
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
ival[1] = 0;
|
||||
ival[2] = 0;
|
||||
}
|
||||
|
@ -491,7 +491,7 @@ static bool set_attribute_string(ustring str, TypeDesc type, bool derivatives, v
|
|||
ustring *sval = (ustring *)val;
|
||||
sval[0] = str;
|
||||
|
||||
if (derivatives) {
|
||||
if(derivatives) {
|
||||
sval[1] = OSLRenderServices::u_empty;
|
||||
sval[2] = OSLRenderServices::u_empty;
|
||||
}
|
||||
|
@ -521,7 +521,7 @@ static bool set_attribute_float3_3(float3 P[3], TypeDesc type, bool derivatives,
|
|||
|
||||
if(type.arraylen > 3)
|
||||
memset(fval + 3*3, 0, sizeof(float)*3*(type.arraylen - 3));
|
||||
if (derivatives)
|
||||
if(derivatives)
|
||||
memset(fval + type.arraylen*3, 0, sizeof(float)*2*3*type.arraylen);
|
||||
|
||||
return true;
|
||||
|
@ -544,15 +544,15 @@ static bool set_attribute_matrix(const Transform& tfm, TypeDesc type, void *val)
|
|||
static bool get_mesh_element_attribute(KernelGlobals *kg, const ShaderData *sd, const OSLGlobals::Attribute& attr,
|
||||
const TypeDesc& type, bool derivatives, void *val)
|
||||
{
|
||||
if (attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector ||
|
||||
attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor)
|
||||
if(attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector ||
|
||||
attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor)
|
||||
{
|
||||
float3 fval[3];
|
||||
fval[0] = primitive_attribute_float3(kg, sd, attr.elem, attr.offset,
|
||||
(derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
|
||||
return set_attribute_float3(fval, type, derivatives, val);
|
||||
}
|
||||
else if (attr.type == TypeDesc::TypeFloat) {
|
||||
else if(attr.type == TypeDesc::TypeFloat) {
|
||||
float fval[3];
|
||||
fval[0] = primitive_attribute_float(kg, sd, attr.elem, attr.offset,
|
||||
(derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
|
||||
|
@ -566,7 +566,7 @@ static bool get_mesh_element_attribute(KernelGlobals *kg, const ShaderData *sd,
|
|||
static bool get_mesh_attribute(KernelGlobals *kg, const ShaderData *sd, const OSLGlobals::Attribute& attr,
|
||||
const TypeDesc& type, bool derivatives, void *val)
|
||||
{
|
||||
if (attr.type == TypeDesc::TypeMatrix) {
|
||||
if(attr.type == TypeDesc::TypeMatrix) {
|
||||
Transform tfm = primitive_attribute_matrix(kg, sd, attr.offset);
|
||||
return set_attribute_matrix(tfm, type, val);
|
||||
}
|
||||
|
@ -580,7 +580,7 @@ static void get_object_attribute(const OSLGlobals::Attribute& attr, bool derivat
|
|||
size_t datasize = attr.value.datasize();
|
||||
|
||||
memcpy(val, attr.value.data(), datasize);
|
||||
if (derivatives)
|
||||
if(derivatives)
|
||||
memset((char *)val + datasize, 0, datasize * 2);
|
||||
}
|
||||
|
||||
|
@ -590,80 +590,80 @@ bool OSLRenderServices::get_object_standard_attribute(KernelGlobals *kg, ShaderD
|
|||
/* todo: turn this into hash table? */
|
||||
|
||||
/* Object Attributes */
|
||||
if (name == u_object_location) {
|
||||
if(name == u_object_location) {
|
||||
float3 f = object_location(kg, sd);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_object_index) {
|
||||
else if(name == u_object_index) {
|
||||
float f = object_pass_id(kg, sd->object);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_geom_dupli_generated) {
|
||||
else if(name == u_geom_dupli_generated) {
|
||||
float3 f = object_dupli_generated(kg, sd->object);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_geom_dupli_uv) {
|
||||
else if(name == u_geom_dupli_uv) {
|
||||
float3 f = object_dupli_uv(kg, sd->object);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_material_index) {
|
||||
else if(name == u_material_index) {
|
||||
float f = shader_pass_id(kg, sd);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_object_random) {
|
||||
else if(name == u_object_random) {
|
||||
float f = object_random_number(kg, sd->object);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
|
||||
/* Particle Attributes */
|
||||
else if (name == u_particle_index) {
|
||||
else if(name == u_particle_index) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float f = particle_index(kg, particle_id);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_particle_age) {
|
||||
else if(name == u_particle_age) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float f = particle_age(kg, particle_id);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_particle_lifetime) {
|
||||
else if(name == u_particle_lifetime) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float f = particle_lifetime(kg, particle_id);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_particle_location) {
|
||||
else if(name == u_particle_location) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float3 f = particle_location(kg, particle_id);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
#if 0 /* unsupported */
|
||||
else if (name == u_particle_rotation) {
|
||||
else if(name == u_particle_rotation) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float4 f = particle_rotation(kg, particle_id);
|
||||
return set_attribute_float4(f, type, derivatives, val);
|
||||
}
|
||||
#endif
|
||||
else if (name == u_particle_size) {
|
||||
else if(name == u_particle_size) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float f = particle_size(kg, particle_id);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_particle_velocity) {
|
||||
else if(name == u_particle_velocity) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float3 f = particle_velocity(kg, particle_id);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_particle_angular_velocity) {
|
||||
else if(name == u_particle_angular_velocity) {
|
||||
int particle_id = object_particle_id(kg, sd->object);
|
||||
float3 f = particle_angular_velocity(kg, particle_id);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
|
||||
/* Geometry Attributes */
|
||||
else if (name == u_geom_numpolyvertices) {
|
||||
else if(name == u_geom_numpolyvertices) {
|
||||
return set_attribute_int(3, type, derivatives, val);
|
||||
}
|
||||
else if ((name == u_geom_trianglevertices || name == u_geom_polyvertices)
|
||||
else if((name == u_geom_trianglevertices || name == u_geom_polyvertices)
|
||||
#ifdef __HAIR__
|
||||
&& sd->type & PRIMITIVE_ALL_TRIANGLE)
|
||||
#else
|
||||
|
@ -689,21 +689,21 @@ bool OSLRenderServices::get_object_standard_attribute(KernelGlobals *kg, ShaderD
|
|||
ustring object_name = kg->osl->object_names[sd->object];
|
||||
return set_attribute_string(object_name, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_is_smooth) {
|
||||
else if(name == u_is_smooth) {
|
||||
float f = ((sd->shader & SHADER_SMOOTH_NORMAL) != 0);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
#ifdef __HAIR__
|
||||
/* Hair Attributes */
|
||||
else if (name == u_is_curve) {
|
||||
else if(name == u_is_curve) {
|
||||
float f = (sd->type & PRIMITIVE_ALL_CURVE) != 0;
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_curve_thickness) {
|
||||
else if(name == u_curve_thickness) {
|
||||
float f = curve_thickness(kg, sd);
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_curve_tangent_normal) {
|
||||
else if(name == u_curve_tangent_normal) {
|
||||
float3 f = curve_tangent_normal(kg, sd);
|
||||
return set_attribute_float3(f, type, derivatives, val);
|
||||
}
|
||||
|
@ -715,22 +715,22 @@ bool OSLRenderServices::get_object_standard_attribute(KernelGlobals *kg, ShaderD
|
|||
bool OSLRenderServices::get_background_attribute(KernelGlobals *kg, ShaderData *sd, ustring name,
|
||||
TypeDesc type, bool derivatives, void *val)
|
||||
{
|
||||
if (name == u_path_ray_length) {
|
||||
if(name == u_path_ray_length) {
|
||||
/* Ray Length */
|
||||
float f = sd->ray_length;
|
||||
return set_attribute_float(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_path_ray_depth) {
|
||||
else if(name == u_path_ray_depth) {
|
||||
/* Ray Depth */
|
||||
int f = sd->ray_depth;
|
||||
return set_attribute_int(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_path_transparent_depth) {
|
||||
else if(name == u_path_transparent_depth) {
|
||||
/* Transparent Ray Depth */
|
||||
int f = sd->transparent_depth;
|
||||
return set_attribute_int(f, type, derivatives, val);
|
||||
}
|
||||
else if (name == u_ndc) {
|
||||
else if(name == u_ndc) {
|
||||
/* NDC coordinates with special exception for otho */
|
||||
OSLThreadData *tdata = kg->osl_tdata;
|
||||
OSL::ShaderGlobals *globals = &tdata->globals;
|
||||
|
@ -762,7 +762,7 @@ bool OSLRenderServices::get_background_attribute(KernelGlobals *kg, ShaderData *
|
|||
bool OSLRenderServices::get_attribute(OSL::ShaderGlobals *sg, bool derivatives, ustring object_name,
|
||||
TypeDesc type, ustring name, void *val)
|
||||
{
|
||||
if (sg->renderstate == NULL)
|
||||
if(sg->renderstate == NULL)
|
||||
return false;
|
||||
|
||||
ShaderData *sd = (ShaderData *)(sg->renderstate);
|
||||
|
@ -777,10 +777,10 @@ bool OSLRenderServices::get_attribute(ShaderData *sd, bool derivatives, ustring
|
|||
int 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);
|
||||
|
||||
if (it == kg->osl->object_name_map.end())
|
||||
if(it == kg->osl->object_name_map.end())
|
||||
return false;
|
||||
|
||||
object = it->second;
|
||||
|
@ -790,7 +790,7 @@ bool OSLRenderServices::get_attribute(ShaderData *sd, bool derivatives, ustring
|
|||
object = sd->object;
|
||||
is_curve = (sd->type & PRIMITIVE_ALL_CURVE) != 0;
|
||||
|
||||
if (object == OBJECT_NONE)
|
||||
if(object == OBJECT_NONE)
|
||||
return get_background_attribute(kg, sd, name, type, derivatives, val);
|
||||
}
|
||||
|
||||
|
@ -799,10 +799,10 @@ bool OSLRenderServices::get_attribute(ShaderData *sd, bool derivatives, ustring
|
|||
OSLGlobals::AttributeMap& attribute_map = kg->osl->attribute_map[object];
|
||||
OSLGlobals::AttributeMap::iterator it = attribute_map.find(name);
|
||||
|
||||
if (it != attribute_map.end()) {
|
||||
if(it != attribute_map.end()) {
|
||||
const OSLGlobals::Attribute& attr = it->second;
|
||||
|
||||
if (attr.elem != ATTR_ELEMENT_OBJECT) {
|
||||
if(attr.elem != ATTR_ELEMENT_OBJECT) {
|
||||
/* triangle and vertex attributes */
|
||||
if(get_mesh_element_attribute(kg, sd, attr, type, derivatives, val))
|
||||
return true;
|
||||
|
@ -819,7 +819,7 @@ bool OSLRenderServices::get_attribute(ShaderData *sd, bool derivatives, ustring
|
|||
/* not found in attribute, check standard object info */
|
||||
bool is_std_object_attribute = get_object_standard_attribute(kg, sd, name, type, derivatives, val);
|
||||
|
||||
if (is_std_object_attribute)
|
||||
if(is_std_object_attribute)
|
||||
return true;
|
||||
|
||||
return get_background_attribute(kg, sd, name, type, derivatives, val);
|
||||
|
|
|
@ -146,11 +146,11 @@ static void flatten_surface_closure_tree(ShaderData *sd, int path_flag,
|
|||
/* OSL gives us a closure tree, we flatten it into arrays per
|
||||
* closure type, for evaluation, sampling, etc later on. */
|
||||
|
||||
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
if(closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
||||
CClosurePrimitive *prim = (CClosurePrimitive *)comp->data();
|
||||
|
||||
if (prim) {
|
||||
if(prim) {
|
||||
ShaderClosure sc;
|
||||
|
||||
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
|
||||
|
@ -296,11 +296,11 @@ static void flatten_surface_closure_tree(ShaderData *sd, int path_flag,
|
|||
}
|
||||
}
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::MUL) {
|
||||
else if(closure->type == OSL::ClosureColor::MUL) {
|
||||
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
||||
flatten_surface_closure_tree(sd, path_flag, mul->closure, TO_FLOAT3(mul->weight) * weight);
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::ADD) {
|
||||
else if(closure->type == OSL::ClosureColor::ADD) {
|
||||
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
||||
flatten_surface_closure_tree(sd, path_flag, add->closureA, weight);
|
||||
flatten_surface_closure_tree(sd, path_flag, add->closureB, weight);
|
||||
|
@ -319,11 +319,11 @@ void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, int path_flag, S
|
|||
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
||||
int shader = sd->shader & SHADER_MASK;
|
||||
|
||||
if (kg->osl->surface_state[shader])
|
||||
if(kg->osl->surface_state[shader])
|
||||
ss->execute(*octx, *(kg->osl->surface_state[shader]), *globals);
|
||||
|
||||
/* flatten closure tree */
|
||||
if (globals->Ci)
|
||||
if(globals->Ci)
|
||||
flatten_surface_closure_tree(sd, path_flag, globals->Ci);
|
||||
}
|
||||
|
||||
|
@ -335,23 +335,23 @@ static float3 flatten_background_closure_tree(const OSL::ClosureColor *closure)
|
|||
* is only one supported closure type at the moment, which has no evaluation
|
||||
* functions, so we just sum the weights */
|
||||
|
||||
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
if(closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
||||
CClosurePrimitive *prim = (CClosurePrimitive *)comp->data();
|
||||
|
||||
if (prim && prim->category == CClosurePrimitive::Background)
|
||||
if(prim && prim->category == CClosurePrimitive::Background)
|
||||
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
|
||||
return TO_FLOAT3(comp->w);
|
||||
#else
|
||||
return make_float3(1.0f, 1.0f, 1.0f);
|
||||
#endif
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::MUL) {
|
||||
else if(closure->type == OSL::ClosureColor::MUL) {
|
||||
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
||||
|
||||
return TO_FLOAT3(mul->weight) * flatten_background_closure_tree(mul->closure);
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::ADD) {
|
||||
else if(closure->type == OSL::ClosureColor::ADD) {
|
||||
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
||||
|
||||
return flatten_background_closure_tree(add->closureA) +
|
||||
|
@ -372,11 +372,11 @@ float3 OSLShader::eval_background(KernelGlobals *kg, ShaderData *sd, int path_fl
|
|||
OSL::ShaderGlobals *globals = &tdata->globals;
|
||||
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
||||
|
||||
if (kg->osl->background_state)
|
||||
if(kg->osl->background_state)
|
||||
ss->execute(*octx, *(kg->osl->background_state), *globals);
|
||||
|
||||
/* return background color immediately */
|
||||
if (globals->Ci)
|
||||
if(globals->Ci)
|
||||
return flatten_background_closure_tree(globals->Ci);
|
||||
|
||||
return make_float3(0.0f, 0.0f, 0.0f);
|
||||
|
@ -390,11 +390,11 @@ static void flatten_volume_closure_tree(ShaderData *sd,
|
|||
/* OSL gives us a closure tree, we flatten it into arrays per
|
||||
* closure type, for evaluation, sampling, etc later on. */
|
||||
|
||||
if (closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
if(closure->type == OSL::ClosureColor::COMPONENT) {
|
||||
OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure;
|
||||
CClosurePrimitive *prim = (CClosurePrimitive *)comp->data();
|
||||
|
||||
if (prim) {
|
||||
if(prim) {
|
||||
ShaderClosure sc;
|
||||
|
||||
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
|
||||
|
@ -451,11 +451,11 @@ static void flatten_volume_closure_tree(ShaderData *sd,
|
|||
}
|
||||
}
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::MUL) {
|
||||
else if(closure->type == OSL::ClosureColor::MUL) {
|
||||
OSL::ClosureMul *mul = (OSL::ClosureMul *)closure;
|
||||
flatten_volume_closure_tree(sd, mul->closure, TO_FLOAT3(mul->weight) * weight);
|
||||
}
|
||||
else if (closure->type == OSL::ClosureColor::ADD) {
|
||||
else if(closure->type == OSL::ClosureColor::ADD) {
|
||||
OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure;
|
||||
flatten_volume_closure_tree(sd, add->closureA, weight);
|
||||
flatten_volume_closure_tree(sd, add->closureB, weight);
|
||||
|
@ -474,11 +474,11 @@ void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, int path_flag, Sh
|
|||
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
||||
int shader = sd->shader & SHADER_MASK;
|
||||
|
||||
if (kg->osl->volume_state[shader])
|
||||
if(kg->osl->volume_state[shader])
|
||||
ss->execute(*octx, *(kg->osl->volume_state[shader]), *globals);
|
||||
|
||||
/* flatten closure tree */
|
||||
if (globals->Ci)
|
||||
if(globals->Ci)
|
||||
flatten_volume_closure_tree(sd, globals->Ci);
|
||||
}
|
||||
|
||||
|
@ -496,7 +496,7 @@ void OSLShader::eval_displacement(KernelGlobals *kg, ShaderData *sd, ShaderConte
|
|||
OSL::ShadingContext *octx = tdata->context[(int)ctx];
|
||||
int shader = sd->shader & SHADER_MASK;
|
||||
|
||||
if (kg->osl->displacement_state[shader])
|
||||
if(kg->osl->displacement_state[shader])
|
||||
ss->execute(*octx, *(kg->osl->displacement_state[shader]), *globals);
|
||||
|
||||
/* get back position */
|
||||
|
@ -523,7 +523,7 @@ float3 OSLShader::bsdf_eval(const ShaderData *sd, const ShaderClosure *sc, const
|
|||
CBSDFClosure *bsdf = (CBSDFClosure *)sc->prim;
|
||||
float3 bsdf_eval;
|
||||
|
||||
if (dot(sd->Ng, omega_in) >= 0.0f)
|
||||
if(dot(sd->Ng, omega_in) >= 0.0f)
|
||||
bsdf_eval = bsdf->eval_reflect(sd->I, omega_in, pdf);
|
||||
else
|
||||
bsdf_eval = bsdf->eval_transmit(sd->I, omega_in, pdf);
|
||||
|
@ -551,7 +551,7 @@ int OSLShader::find_attribute(KernelGlobals *kg, const ShaderData *sd, uint id,
|
|||
ustring stdname(std::string("geom:") + std::string(Attribute::standard_name((AttributeStandard)id)));
|
||||
OSLGlobals::AttributeMap::const_iterator it = attr_map.find(stdname);
|
||||
|
||||
if (it != attr_map.end()) {
|
||||
if(it != attr_map.end()) {
|
||||
const OSLGlobals::Attribute &osl_attr = it->second;
|
||||
*elem = osl_attr.elem;
|
||||
|
||||
|
|
|
@ -42,11 +42,11 @@ ccl_device void svm_node_blackbody(KernelGlobals *kg, ShaderData *sd, float *sta
|
|||
/* Input */
|
||||
float temperature = stack_load_float(stack, temperature_offset);
|
||||
|
||||
if (temperature < BB_DRAPER) {
|
||||
if(temperature < BB_DRAPER) {
|
||||
/* just return very very dim red */
|
||||
color_rgb = make_float3(1.0e-6f,0.0f,0.0f);
|
||||
}
|
||||
else if (temperature <= BB_MAX_TABLE_RANGE) {
|
||||
else if(temperature <= BB_MAX_TABLE_RANGE) {
|
||||
/* This is the overall size of the table */
|
||||
const int lookuptablesize = 956;
|
||||
const float lookuptablenormalize = 1.0f/956.0f;
|
||||
|
@ -74,10 +74,10 @@ ccl_device void svm_node_blackbody(KernelGlobals *kg, ShaderData *sd, float *sta
|
|||
|
||||
/* Luminance */
|
||||
float l = linear_rgb_to_gray(color_rgb);
|
||||
if (l != 0.0f)
|
||||
if(l != 0.0f)
|
||||
color_rgb /= l;
|
||||
|
||||
if (stack_valid(col_offset))
|
||||
if(stack_valid(col_offset))
|
||||
stack_store_float3(stack, col_offset, color_rgb);
|
||||
}
|
||||
|
||||
|
|
|
@ -32,7 +32,7 @@ ccl_device void svm_node_brightness(ShaderData *sd, float *stack, uint in_color,
|
|||
color.y = max(a*color.y + b, 0.0f);
|
||||
color.z = max(a*color.z + b, 0.0f);
|
||||
|
||||
if (stack_valid(out_color))
|
||||
if(stack_valid(out_color))
|
||||
stack_store_float3(stack, out_color, color);
|
||||
}
|
||||
|
||||
|
|
|
@ -27,13 +27,13 @@ ccl_device void svm_node_camera(KernelGlobals *kg, ShaderData *sd, float *stack,
|
|||
zdepth = vector.z;
|
||||
distance = len(vector);
|
||||
|
||||
if (stack_valid(out_vector))
|
||||
if(stack_valid(out_vector))
|
||||
stack_store_float3(stack, out_vector, normalize(vector));
|
||||
|
||||
if (stack_valid(out_zdepth))
|
||||
if(stack_valid(out_zdepth))
|
||||
stack_store_float(stack, out_zdepth, zdepth);
|
||||
|
||||
if (stack_valid(out_distance))
|
||||
if(stack_valid(out_distance))
|
||||
stack_store_float(stack, out_distance, distance);
|
||||
}
|
||||
|
||||
|
|
|
@ -331,9 +331,9 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
|
|||
|
||||
sc->data2 = 0.0f;
|
||||
|
||||
if (type == CLOSURE_BSDF_MICROFACET_BECKMANN_ANISO_ID)
|
||||
if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_ANISO_ID)
|
||||
sd->flag |= bsdf_microfacet_beckmann_aniso_setup(sc);
|
||||
else if (type == CLOSURE_BSDF_MICROFACET_GGX_ANISO_ID)
|
||||
else if(type == CLOSURE_BSDF_MICROFACET_GGX_ANISO_ID)
|
||||
sd->flag |= bsdf_microfacet_ggx_aniso_setup(sc);
|
||||
else
|
||||
sd->flag |= bsdf_ashikhmin_shirley_aniso_setup(sc);
|
||||
|
@ -365,7 +365,7 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
|
|||
sc->data1 = param2;
|
||||
sc->data2 = 0.0f;
|
||||
|
||||
if (type == CLOSURE_BSDF_DIFFUSE_TOON_ID)
|
||||
if(type == CLOSURE_BSDF_DIFFUSE_TOON_ID)
|
||||
sd->flag |= bsdf_diffuse_toon_setup(sc);
|
||||
else
|
||||
sd->flag |= bsdf_glossy_toon_setup(sc);
|
||||
|
|
|
@ -21,14 +21,14 @@ ccl_device void svm_node_gamma(ShaderData *sd, float *stack, uint in_gamma, uint
|
|||
float3 color = stack_load_float3(stack, in_color);
|
||||
float gamma = stack_load_float(stack, in_gamma);
|
||||
|
||||
if (color.x > 0.0f)
|
||||
if(color.x > 0.0f)
|
||||
color.x = powf(color.x, gamma);
|
||||
if (color.y > 0.0f)
|
||||
if(color.y > 0.0f)
|
||||
color.y = powf(color.y, gamma);
|
||||
if (color.z > 0.0f)
|
||||
if(color.z > 0.0f)
|
||||
color.z = powf(color.z, gamma);
|
||||
|
||||
if (stack_valid(out_color))
|
||||
if(stack_valid(out_color))
|
||||
stack_store_float3(stack, out_color, color);
|
||||
}
|
||||
|
||||
|
|
|
@ -51,7 +51,7 @@ ccl_device void svm_node_hsv(KernelGlobals *kg, ShaderData *sd, float *stack, ui
|
|||
color.y = max(color.y, 0.0f);
|
||||
color.z = max(color.z, 0.0f);
|
||||
|
||||
if (stack_valid(out_color_offset))
|
||||
if(stack_valid(out_color_offset))
|
||||
stack_store_float3(stack, out_color_offset, color);
|
||||
}
|
||||
|
||||
|
|
|
@ -65,7 +65,7 @@ ccl_device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y,
|
|||
|
||||
float4 r;
|
||||
int ix, iy, nix, niy;
|
||||
if (interpolation == INTERPOLATION_CLOSEST) {
|
||||
if(interpolation == INTERPOLATION_CLOSEST) {
|
||||
svm_image_texture_frac(x*width, &ix);
|
||||
svm_image_texture_frac(y*height, &iy);
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@ ccl_device void svm_node_invert(ShaderData *sd, float *stack, uint in_fac, uint
|
|||
color.y = invert(color.y, factor);
|
||||
color.z = invert(color.z, factor);
|
||||
|
||||
if (stack_valid(out_color))
|
||||
if(stack_valid(out_color))
|
||||
stack_store_float3(stack, out_color, color);
|
||||
}
|
||||
|
||||
|
|
|
@ -28,10 +28,10 @@ ccl_device void svm_node_normal(KernelGlobals *kg, ShaderData *sd, float *stack,
|
|||
direction.z = __int_as_float(node1.z);
|
||||
direction = normalize(direction);
|
||||
|
||||
if (stack_valid(out_normal_offset))
|
||||
if(stack_valid(out_normal_offset))
|
||||
stack_store_float3(stack, out_normal_offset, direction);
|
||||
|
||||
if (stack_valid(out_dot_offset))
|
||||
if(stack_valid(out_dot_offset))
|
||||
stack_store_float(stack, out_dot_offset, dot(direction, normalize(normal)));
|
||||
}
|
||||
|
||||
|
|
|
@ -28,7 +28,7 @@ ccl_device void svm_node_combine_hsv(KernelGlobals *kg, ShaderData *sd, float *s
|
|||
/* Combine, and convert back to RGB */
|
||||
float3 color = hsv_to_rgb(make_float3(hue, saturation, value));
|
||||
|
||||
if (stack_valid(color_out))
|
||||
if(stack_valid(color_out))
|
||||
stack_store_float3(stack, color_out, color);
|
||||
}
|
||||
|
||||
|
@ -42,11 +42,11 @@ ccl_device void svm_node_separate_hsv(KernelGlobals *kg, ShaderData *sd, float *
|
|||
/* Convert to HSV */
|
||||
color = rgb_to_hsv(color);
|
||||
|
||||
if (stack_valid(hue_out))
|
||||
if(stack_valid(hue_out))
|
||||
stack_store_float(stack, hue_out, color.x);
|
||||
if (stack_valid(saturation_out))
|
||||
if(stack_valid(saturation_out))
|
||||
stack_store_float(stack, saturation_out, color.y);
|
||||
if (stack_valid(value_out))
|
||||
if(stack_valid(value_out))
|
||||
stack_store_float(stack, value_out, color.z);
|
||||
}
|
||||
|
||||
|
|
|
@ -22,7 +22,7 @@ ccl_device void svm_node_combine_vector(ShaderData *sd, float *stack, uint in_of
|
|||
{
|
||||
float vector = stack_load_float(stack, in_offset);
|
||||
|
||||
if (stack_valid(out_offset))
|
||||
if(stack_valid(out_offset))
|
||||
stack_store_float(stack, out_offset+vector_index, vector);
|
||||
}
|
||||
|
||||
|
@ -30,10 +30,10 @@ ccl_device void svm_node_separate_vector(ShaderData *sd, float *stack, uint ivec
|
|||
{
|
||||
float3 vector = stack_load_float3(stack, ivector_offset);
|
||||
|
||||
if (stack_valid(out_offset)) {
|
||||
if (vector_index == 0)
|
||||
if(stack_valid(out_offset)) {
|
||||
if(vector_index == 0)
|
||||
stack_store_float(stack, out_offset, vector.x);
|
||||
else if (vector_index == 1)
|
||||
else if(vector_index == 1)
|
||||
stack_store_float(stack, out_offset, vector.y);
|
||||
else
|
||||
stack_store_float(stack, out_offset, vector.z);
|
||||
|
|
|
@ -129,9 +129,9 @@ ccl_device float voronoi_F1_distance(float3 p)
|
|||
#ifndef __KERNEL_SSE2__
|
||||
int ix = floor_to_int(p.x), iy = floor_to_int(p.y), iz = floor_to_int(p.z);
|
||||
|
||||
for (int xx = -1; xx <= 1; xx++) {
|
||||
for (int yy = -1; yy <= 1; yy++) {
|
||||
for (int zz = -1; zz <= 1; zz++) {
|
||||
for(int xx = -1; xx <= 1; xx++) {
|
||||
for(int yy = -1; yy <= 1; yy++) {
|
||||
for(int zz = -1; zz <= 1; zz++) {
|
||||
float3 ip = make_float3(ix + xx, iy + yy, iz + zz);
|
||||
float3 vp = ip + cellnoise_color(ip);
|
||||
float d = len_squared(p - vp);
|
||||
|
@ -143,9 +143,9 @@ ccl_device float voronoi_F1_distance(float3 p)
|
|||
ssef vec_p = load4f(p);
|
||||
ssei xyzi = quick_floor_sse(vec_p);
|
||||
|
||||
for (int xx = -1; xx <= 1; xx++) {
|
||||
for (int yy = -1; yy <= 1; yy++) {
|
||||
for (int zz = -1; zz <= 1; zz++) {
|
||||
for(int xx = -1; xx <= 1; xx++) {
|
||||
for(int yy = -1; yy <= 1; yy++) {
|
||||
for(int zz = -1; zz <= 1; zz++) {
|
||||
ssef ip = ssef(xyzi + ssei(xx, yy, zz, 0));
|
||||
ssef vp = ip + cellnoise_color(ip);
|
||||
float d = len_squared<1, 1, 1, 0>(vec_p - vp);
|
||||
|
@ -167,9 +167,9 @@ ccl_device float3 voronoi_F1_color(float3 p)
|
|||
float3 pa;
|
||||
int ix = floor_to_int(p.x), iy = floor_to_int(p.y), iz = floor_to_int(p.z);
|
||||
|
||||
for (int xx = -1; xx <= 1; xx++) {
|
||||
for (int yy = -1; yy <= 1; yy++) {
|
||||
for (int zz = -1; zz <= 1; zz++) {
|
||||
for(int xx = -1; xx <= 1; xx++) {
|
||||
for(int yy = -1; yy <= 1; yy++) {
|
||||
for(int zz = -1; zz <= 1; zz++) {
|
||||
float3 ip = make_float3(ix + xx, iy + yy, iz + zz);
|
||||
float3 vp = ip + cellnoise_color(ip);
|
||||
float d = len_squared(p - vp);
|
||||
|
@ -187,9 +187,9 @@ ccl_device float3 voronoi_F1_color(float3 p)
|
|||
ssef pa, vec_p = load4f(p);
|
||||
ssei xyzi = quick_floor_sse(vec_p);
|
||||
|
||||
for (int xx = -1; xx <= 1; xx++) {
|
||||
for (int yy = -1; yy <= 1; yy++) {
|
||||
for (int zz = -1; zz <= 1; zz++) {
|
||||
for(int xx = -1; xx <= 1; xx++) {
|
||||
for(int yy = -1; yy <= 1; yy++) {
|
||||
for(int zz = -1; zz <= 1; zz++) {
|
||||
ssef ip = ssef(xyzi + ssei(xx, yy, zz, 0));
|
||||
ssef vp = ip + cellnoise_color(ip);
|
||||
float d = len_squared<1, 1, 1, 0>(vec_p - vp);
|
||||
|
|
|
@ -45,7 +45,7 @@ ccl_device void svm_node_vector_transform(KernelGlobals *kg, ShaderData *sd, flo
|
|||
else
|
||||
in = transform_point(&tfm, in);
|
||||
}
|
||||
else if (to == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT && is_object) {
|
||||
else if(to == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT && is_object) {
|
||||
if(is_direction)
|
||||
object_inverse_dir_transform(kg, sd, &in);
|
||||
else
|
||||
|
@ -54,7 +54,7 @@ ccl_device void svm_node_vector_transform(KernelGlobals *kg, ShaderData *sd, flo
|
|||
}
|
||||
|
||||
/* From camera */
|
||||
else if (from == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_CAMERA) {
|
||||
else if(from == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_CAMERA) {
|
||||
if(to == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_WORLD || to == NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT) {
|
||||
tfm = kernel_data.cam.cameratoworld;
|
||||
if(is_direction)
|
||||
|
|
|
@ -77,7 +77,7 @@ ccl_device void svm_node_wavelength(ShaderData *sd, float *stack, uint wavelengt
|
|||
int i = float_to_int(ii);
|
||||
float3 color;
|
||||
|
||||
if (i < 0 || i >= 80) {
|
||||
if(i < 0 || i >= 80) {
|
||||
color = make_float3(0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else {
|
||||
|
|
|
@ -41,9 +41,9 @@ ccl_device float wireframe(KernelGlobals *kg,
|
|||
float3 *P)
|
||||
{
|
||||
#ifdef __HAIR__
|
||||
if (sd->prim != PRIM_NONE && sd->type & PRIMITIVE_ALL_TRIANGLE)
|
||||
if(sd->prim != PRIM_NONE && sd->type & PRIMITIVE_ALL_TRIANGLE)
|
||||
#else
|
||||
if (sd->prim != PRIM_NONE)
|
||||
if(sd->prim != PRIM_NONE)
|
||||
#endif
|
||||
{
|
||||
float3 Co[3];
|
||||
|
@ -76,7 +76,7 @@ ccl_device float wireframe(KernelGlobals *kg,
|
|||
// other half. And take the square for fast comparison
|
||||
pixelwidth *= 0.5f * size;
|
||||
pixelwidth *= pixelwidth;
|
||||
for (int i = 0; i < np; i++) {
|
||||
for(int i = 0; i < np; i++) {
|
||||
int i2 = i ? i - 1 : np - 1;
|
||||
float3 dir = *P - Co[i];
|
||||
float3 edge = Co[i] - Co[i2];
|
||||
|
@ -84,7 +84,7 @@ ccl_device float wireframe(KernelGlobals *kg,
|
|||
// At this point dot(crs, crs) / dot(edge, edge) is
|
||||
// the square of area / length(edge) == square of the
|
||||
// distance to the edge.
|
||||
if (dot(crs, crs) < (dot(edge, edge) * pixelwidth))
|
||||
if(dot(crs, crs) < (dot(edge, edge) * pixelwidth))
|
||||
return 1.0f;
|
||||
}
|
||||
}
|
||||
|
@ -113,12 +113,12 @@ ccl_device void svm_node_wireframe(KernelGlobals *kg,
|
|||
float3 Px = sd->P - sd->dP.dx;
|
||||
f += (f - wireframe(kg, sd, size, pixel_size, &Px)) / len(sd->dP.dx);
|
||||
}
|
||||
else if (bump_offset == NODE_BUMP_OFFSET_DY) {
|
||||
else if(bump_offset == NODE_BUMP_OFFSET_DY) {
|
||||
float3 Py = sd->P - sd->dP.dy;
|
||||
f += (f - wireframe(kg, sd, size, pixel_size, &Py)) / len(sd->dP.dy);
|
||||
}
|
||||
|
||||
if (stack_valid(out_fac))
|
||||
if(stack_valid(out_fac))
|
||||
stack_store_float(stack, out_fac, f);
|
||||
}
|
||||
|
||||
|
|
|
@ -52,7 +52,7 @@ void Attribute::set(ustring name_, TypeDesc type_, AttributeElement element_)
|
|||
|
||||
void Attribute::reserve(int numverts, int numtris, int numsteps, int numcurves, int numkeys, bool resize)
|
||||
{
|
||||
if (resize) {
|
||||
if(resize) {
|
||||
buffer.resize(buffer_size(numverts, numtris, numsteps, numcurves, numkeys), 0);
|
||||
}
|
||||
else {
|
||||
|
|
|
@ -99,14 +99,14 @@ vector<float> blackbody_table_build()
|
|||
float X, Y, Z;
|
||||
|
||||
/* ToDo: bring this back to what OSL does with the lastTemperature limit ? */
|
||||
for (int i = 0; i <= 317; ++i) {
|
||||
for(int i = 0; i <= 317; ++i) {
|
||||
double Temperature = pow((double)i, (double)BB_TABLE_XPOWER) * (double)BB_TABLE_SPACING + (double)BB_DRAPER;
|
||||
X = 0;
|
||||
Y = 0;
|
||||
Z = 0;
|
||||
|
||||
/* from OSL "spectrum_to_XYZ" */
|
||||
for (int n = 0; n < 81; ++n) {
|
||||
for(int n = 0; n < 81; ++n) {
|
||||
float lambda = 380.0f + 5.0f * n;
|
||||
double wlm = lambda * 1e-9f; // Wavelength in meters
|
||||
// N.B. spec_intens returns result in W/m^2 but it's a differential,
|
||||
|
|
|
@ -179,7 +179,7 @@ void Camera::device_update(Device *device, DeviceScene *dscene, Scene *scene)
|
|||
|
||||
update();
|
||||
|
||||
if (previous_need_motion != need_motion) {
|
||||
if(previous_need_motion != need_motion) {
|
||||
/* scene's motion model could have been changed since previous device
|
||||
* camera update this could happen for example in case when one render
|
||||
* layer has got motion pass and another not */
|
||||
|
@ -368,7 +368,7 @@ float3 Camera::transform_raster_to_world(float raster_x, float raster_y)
|
|||
*/
|
||||
P += nearclip * D / Pclip.z;
|
||||
}
|
||||
else if (type == CAMERA_ORTHOGRAPHIC) {
|
||||
else if(type == CAMERA_ORTHOGRAPHIC) {
|
||||
D = make_float3(0.0f, 0.0f, 1.0f);
|
||||
/* TODO(sergey): Aperture support? */
|
||||
P = transform_perspective(&rastertocamera,
|
||||
|
|
|
@ -210,11 +210,11 @@ void Mesh::compute_bounds()
|
|||
bnds.grow(float4_to_float3(curve_keys[i]), curve_keys[i].w);
|
||||
|
||||
Attribute *attr = attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
|
||||
if (use_motion_blur && attr) {
|
||||
if(use_motion_blur && attr) {
|
||||
size_t steps_size = verts.size() * (motion_steps - 1);
|
||||
float3 *vert_steps = attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
bnds.grow(vert_steps[i]);
|
||||
}
|
||||
|
||||
|
@ -223,7 +223,7 @@ void Mesh::compute_bounds()
|
|||
size_t steps_size = curve_keys.size() * (motion_steps - 1);
|
||||
float3 *key_steps = curve_attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
bnds.grow(key_steps[i]);
|
||||
}
|
||||
|
||||
|
@ -237,19 +237,19 @@ void Mesh::compute_bounds()
|
|||
for(size_t i = 0; i < curve_keys_size; i++)
|
||||
bnds.grow_safe(float4_to_float3(curve_keys[i]), curve_keys[i].w);
|
||||
|
||||
if (use_motion_blur && attr) {
|
||||
if(use_motion_blur && attr) {
|
||||
size_t steps_size = verts.size() * (motion_steps - 1);
|
||||
float3 *vert_steps = attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
bnds.grow_safe(vert_steps[i]);
|
||||
}
|
||||
|
||||
if (use_motion_blur && curve_attr) {
|
||||
if(use_motion_blur && curve_attr) {
|
||||
size_t steps_size = curve_keys.size() * (motion_steps - 1);
|
||||
float3 *key_steps = curve_attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
bnds.grow_safe(key_steps[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -227,7 +227,7 @@ void ImageTextureNode::attributes(Shader *shader, AttributeRequestSet *attribute
|
|||
#ifdef WITH_PTEX
|
||||
/* todo: avoid loading other texture coordinates when using ptex,
|
||||
* and hide texture coordinate socket in the UI */
|
||||
if (shader->has_surface && string_endswith(filename, ".ptx")) {
|
||||
if(shader->has_surface && string_endswith(filename, ".ptx")) {
|
||||
/* ptex */
|
||||
attributes->add(ATTR_STD_PTEX_FACE_ID);
|
||||
attributes->add(ATTR_STD_PTEX_UV);
|
||||
|
@ -417,7 +417,7 @@ ShaderNode *EnvironmentTextureNode::clone() const
|
|||
void EnvironmentTextureNode::attributes(Shader *shader, AttributeRequestSet *attributes)
|
||||
{
|
||||
#ifdef WITH_PTEX
|
||||
if (shader->has_surface && string_endswith(filename, ".ptx")) {
|
||||
if(shader->has_surface && string_endswith(filename, ".ptx")) {
|
||||
/* ptex */
|
||||
attributes->add(ATTR_STD_PTEX_FACE_ID);
|
||||
attributes->add(ATTR_STD_PTEX_UV);
|
||||
|
@ -632,7 +632,7 @@ static void sky_texture_precompute_new(SunSky *sunsky, float3 dir, float turbidi
|
|||
sky_state = arhosek_xyz_skymodelstate_alloc_init(turbidity, ground_albedo, solarElevation);
|
||||
|
||||
/* Copy values from sky_state to SunSky */
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
for(int i = 0; i < 9; ++i) {
|
||||
sunsky->config_x[i] = (float)sky_state->configs[0][i];
|
||||
sunsky->config_y[i] = (float)sky_state->configs[1][i];
|
||||
sunsky->config_z[i] = (float)sky_state->configs[2][i];
|
||||
|
@ -2442,7 +2442,7 @@ void UVMapNode::attributes(Shader *shader, AttributeRequestSet *attributes)
|
|||
if(shader->has_surface) {
|
||||
if(!from_dupli) {
|
||||
if(!output("UV")->links.empty()) {
|
||||
if (attribute != "")
|
||||
if(attribute != "")
|
||||
attributes->add(attribute);
|
||||
else
|
||||
attributes->add(ATTR_STD_UV);
|
||||
|
@ -2475,7 +2475,7 @@ void UVMapNode::compile(SVMCompiler& compiler)
|
|||
compiler.add_node(texco_node, NODE_TEXCO_DUPLI_UV, out->stack_offset);
|
||||
}
|
||||
else {
|
||||
if (attribute != "")
|
||||
if(attribute != "")
|
||||
attr = compiler.attribute(attribute);
|
||||
else
|
||||
attr = compiler.attribute(ATTR_STD_UV);
|
||||
|
@ -3987,7 +3987,7 @@ void RGBCurvesNode::compile(OSLCompiler& compiler)
|
|||
{
|
||||
float ramp[RAMP_TABLE_SIZE][3];
|
||||
|
||||
for (int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
for(int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
ramp[i][0] = curves[i].x;
|
||||
ramp[i][1] = curves[i].y;
|
||||
ramp[i][2] = curves[i].z;
|
||||
|
@ -4025,7 +4025,7 @@ void VectorCurvesNode::compile(OSLCompiler& compiler)
|
|||
{
|
||||
float ramp[RAMP_TABLE_SIZE][3];
|
||||
|
||||
for (int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
for(int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
ramp[i][0] = curves[i].x;
|
||||
ramp[i][1] = curves[i].y;
|
||||
ramp[i][2] = curves[i].z;
|
||||
|
@ -4075,7 +4075,7 @@ void RGBRampNode::compile(OSLCompiler& compiler)
|
|||
float ramp_color[RAMP_TABLE_SIZE][3];
|
||||
float ramp_alpha[RAMP_TABLE_SIZE];
|
||||
|
||||
for (int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
for(int i = 0; i < RAMP_TABLE_SIZE; ++i) {
|
||||
ramp_color[i][0] = ramp[i].x;
|
||||
ramp_color[i][1] = ramp[i].y;
|
||||
ramp_color[i][2] = ramp[i].z;
|
||||
|
|
|
@ -104,11 +104,11 @@ void Object::apply_transform(bool apply_to_motion)
|
|||
if(apply_to_motion) {
|
||||
Attribute *attr = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
|
||||
|
||||
if (attr) {
|
||||
if(attr) {
|
||||
size_t steps_size = mesh->verts.size() * (mesh->motion_steps - 1);
|
||||
float3 *vert_steps = attr->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
vert_steps[i] = transform_point(&tfm, vert_steps[i]);
|
||||
}
|
||||
|
||||
|
@ -119,7 +119,7 @@ void Object::apply_transform(bool apply_to_motion)
|
|||
size_t steps_size = mesh->verts.size() * (mesh->motion_steps - 1);
|
||||
float3 *normal_steps = attr_N->data_float3();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++)
|
||||
for(size_t i = 0; i < steps_size; i++)
|
||||
normal_steps[i] = normalize(transform_direction(&ntfm, normal_steps[i]));
|
||||
}
|
||||
}
|
||||
|
@ -146,12 +146,12 @@ void Object::apply_transform(bool apply_to_motion)
|
|||
if(apply_to_motion) {
|
||||
Attribute *curve_attr = mesh->curve_attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
|
||||
|
||||
if (curve_attr) {
|
||||
if(curve_attr) {
|
||||
/* apply transform to motion curve keys */
|
||||
size_t steps_size = mesh->curve_keys.size() * (mesh->motion_steps - 1);
|
||||
float4 *key_steps = curve_attr->data_float4();
|
||||
|
||||
for (size_t i = 0; i < steps_size; i++) {
|
||||
for(size_t i = 0; i < steps_size; i++) {
|
||||
float3 co = transform_point(&tfm, float4_to_float3(key_steps[i]));
|
||||
float radius = key_steps[i].w * scalar;
|
||||
|
||||
|
|
|
@ -414,7 +414,7 @@ string OSLCompiler::compatible_name(ShaderNode *node, ShaderInput *input)
|
|||
|
||||
/* if output exists with the same name, add "In" suffix */
|
||||
foreach(ShaderOutput *output, node->outputs) {
|
||||
if (strcmp(input->name, output->name)==0) {
|
||||
if(strcmp(input->name, output->name)==0) {
|
||||
sname += "In";
|
||||
break;
|
||||
}
|
||||
|
@ -434,7 +434,7 @@ string OSLCompiler::compatible_name(ShaderNode *node, ShaderOutput *output)
|
|||
|
||||
/* if input exists with the same name, add "Out" suffix */
|
||||
foreach(ShaderInput *input, node->inputs) {
|
||||
if (strcmp(input->name, output->name)==0) {
|
||||
if(strcmp(input->name, output->name)==0) {
|
||||
sname += "Out";
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -889,9 +889,9 @@ bool Session::update_progressive_refine(bool cancel)
|
|||
|
||||
double current_time = time_dt();
|
||||
|
||||
if (current_time - last_update_time < params.progressive_update_timeout) {
|
||||
if(current_time - last_update_time < params.progressive_update_timeout) {
|
||||
/* if last sample was processed, we need to write buffers anyway */
|
||||
if (!write)
|
||||
if(!write)
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
@ -312,7 +312,7 @@ double arhosekskymodel_radiance(
|
|||
{
|
||||
int low_wl = (int)((wavelength - 320.0) / 40.0);
|
||||
|
||||
if ( low_wl < 0 || low_wl >= 11 )
|
||||
if( low_wl < 0 || low_wl >= 11 )
|
||||
return 0.0f;
|
||||
|
||||
double interp = fmod((wavelength - 320.0 ) / 40.0, 1.0);
|
||||
|
@ -326,12 +326,12 @@ double arhosekskymodel_radiance(
|
|||
* state->radiances[low_wl]
|
||||
* state->emission_correction_factor_sky[low_wl];
|
||||
|
||||
if ( interp < 1e-6 )
|
||||
if( interp < 1e-6 )
|
||||
return val_low;
|
||||
|
||||
double result = ( 1.0 - interp ) * val_low;
|
||||
|
||||
if ( low_wl+1 < 11 )
|
||||
if( low_wl+1 < 11 )
|
||||
{
|
||||
result +=
|
||||
interp
|
||||
|
|
|
@ -235,7 +235,7 @@ bool TileManager::next_tile(Tile& tile, int device)
|
|||
{
|
||||
list<Tile>::iterator tile_it;
|
||||
|
||||
if (background)
|
||||
if(background)
|
||||
tile_it = next_background_tile(device, tile_order);
|
||||
else
|
||||
tile_it = next_viewport_tile(device);
|
||||
|
|
|
@ -109,8 +109,8 @@ public:
|
|||
evalctrl.EvalLimitSample<OsdCpuVertexBuffer,OsdCpuVertexBuffer>(coords, evalctx, 0);
|
||||
|
||||
*P_ = make_float3(P[0], P[1], P[2]);
|
||||
if (dPdu_) *dPdu_ = make_float3(dPdv[0], dPdv[1], dPdv[2]);
|
||||
if (dPdv_) *dPdv_ = make_float3(dPdu[0], dPdu[1], dPdu[2]);
|
||||
if(dPdu_) *dPdu_ = make_float3(dPdv[0], dPdv[1], dPdv[2]);
|
||||
if(dPdv_) *dPdv_ = make_float3(dPdu[0], dPdu[1], dPdu[2]);
|
||||
|
||||
/* optimize: skip evaluating derivatives when not needed */
|
||||
/* todo: swapped derivatives, different winding convention? */
|
||||
|
@ -234,7 +234,7 @@ bool OpenSubdMesh::finish()
|
|||
|
||||
void OpenSubdMesh::tessellate(DiagSplit *split)
|
||||
{
|
||||
if (num_ptex_faces == 0)
|
||||
if(num_ptex_faces == 0)
|
||||
return;
|
||||
|
||||
const int level = 3;
|
||||
|
|
|
@ -55,7 +55,7 @@ void *util_aligned_malloc(size_t size, int alignment)
|
|||
return malloc(size);
|
||||
#elif defined(__FreeBSD__) || defined(__NetBSD__)
|
||||
void *result;
|
||||
if (posix_memalign(&result, alignment, size)) {
|
||||
if(posix_memalign(&result, alignment, size)) {
|
||||
/* Non-zero means allocation error
|
||||
* either no allocation or bad alignment value.
|
||||
*/
|
||||
|
|
|
@ -23,8 +23,8 @@
|
|||
ATOMIC_INLINE void atomic_update_max_z(size_t *maximum_value, size_t value)
|
||||
{
|
||||
size_t prev_value = *maximum_value;
|
||||
while (prev_value < value) {
|
||||
if (atomic_cas_z(maximum_value, prev_value, value) != prev_value) {
|
||||
while(prev_value < value) {
|
||||
if(atomic_cas_z(maximum_value, prev_value, value) != prev_value) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -53,7 +53,7 @@ static inline uint hash_string(const char *str)
|
|||
{
|
||||
uint i = 0, c;
|
||||
|
||||
while ((c = *str++))
|
||||
while((c = *str++))
|
||||
i = i * 37 + c;
|
||||
|
||||
return i;
|
||||
|
|
|
@ -1461,7 +1461,7 @@ ccl_device_inline float2 map_to_tube(const float3 co)
|
|||
{
|
||||
float len, u, v;
|
||||
len = sqrtf(co.x * co.x + co.y * co.y);
|
||||
if (len > 0.0f) {
|
||||
if(len > 0.0f) {
|
||||
u = (1.0f - (atan2f(co.x / len, co.y / len) / M_PI_F)) * 0.5f;
|
||||
v = (co.x + 1.0f) * 0.5f;
|
||||
}
|
||||
|
|
|
@ -133,7 +133,7 @@ __forceinline int clz(const int x)
|
|||
#if defined(__KERNEL_AVX2__)
|
||||
return _lzcnt_u32(x);
|
||||
#else
|
||||
if (UNLIKELY(x == 0)) return 32;
|
||||
if(UNLIKELY(x == 0)) return 32;
|
||||
return 31 - __bsr(x);
|
||||
#endif
|
||||
}
|
||||
|
@ -286,7 +286,7 @@ __forceinline int clz(const int x)
|
|||
#if defined(__KERNEL_AVX2__)
|
||||
return _lzcnt_u32(x);
|
||||
#else
|
||||
if (UNLIKELY(x == 0)) return 32;
|
||||
if(UNLIKELY(x == 0)) return 32;
|
||||
return 31 - __bsr(x);
|
||||
#endif
|
||||
}
|
||||
|
@ -358,7 +358,7 @@ __forceinline __m128i _mm_mullo_epi32( __m128i value, __m128i input ) {
|
|||
char* _r = (char*)(&rvalue + 1);
|
||||
char* _v = (char*)(& value + 1);
|
||||
char* _i = (char*)(& input + 1);
|
||||
for ( ssize_t i = -16 ; i != 0 ; i += 4 ) *((int32*)(_r + i)) = *((int32*)(_v + i))* *((int32*)(_i + i));
|
||||
for( ssize_t i = -16 ; i != 0 ; i += 4 ) *((int32*)(_r + i)) = *((int32*)(_v + i))* *((int32*)(_i + i));
|
||||
return rvalue;
|
||||
}
|
||||
|
||||
|
|
|
@ -71,7 +71,7 @@ void time_sleep(double t)
|
|||
|
||||
/* get microseconds */
|
||||
int us = (int)(t * 1e6);
|
||||
if (us > 0)
|
||||
if(us > 0)
|
||||
usleep(us);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue