static void blender_camera_from_view(BlenderCamera *bcam, BL::RenderEngine b_engine, BL::Scene b_scene, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height, bool skip_panorama = false) { /* 3d view parameters */ bcam->nearclip = b_v3d.clip_start(); bcam->farclip = b_v3d.clip_end(); bcam->lens = b_v3d.lens(); bcam->shuttertime = b_scene.render().motion_blur_shutter(); curvemapping_to_array(b_scene.render().motion_blur_shutter_curve(), bcam->shutter_curve, RAMP_TABLE_SIZE); if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_CAMERA) { /* camera view */ BL::Object b_ob = (b_v3d.lock_camera_and_layers())? b_scene.camera(): b_v3d.camera(); if(b_ob) { blender_camera_from_object(bcam, b_engine, b_ob, skip_panorama); if(!skip_panorama && bcam->type == CAMERA_PANORAMA) { /* in panorama camera view, we map viewplane to camera border */ BoundBox2D view_box, cam_box; blender_camera_view_subset(b_engine, b_scene.render(), b_scene, b_ob, b_v3d, b_rv3d, width, height, &view_box, &cam_box); bcam->pano_viewplane = view_box.make_relative_to(cam_box); } else { /* magic zoom formula */ bcam->zoom = (float)b_rv3d.view_camera_zoom(); bcam->zoom = (1.41421f + bcam->zoom/50.0f); bcam->zoom *= bcam->zoom; bcam->zoom = 2.0f/bcam->zoom; /* offset */ bcam->offset = get_float2(b_rv3d.view_camera_offset()); } } } else if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_ORTHO) { /* orthographic view */ bcam->farclip *= 0.5f; bcam->nearclip = -bcam->farclip; float sensor_size; if(bcam->sensor_fit == BlenderCamera::VERTICAL) sensor_size = bcam->sensor_height; else sensor_size = bcam->sensor_width; bcam->type = CAMERA_ORTHOGRAPHIC; bcam->ortho_scale = b_rv3d.view_distance() * sensor_size / b_v3d.lens(); } bcam->zoom *= 2.0f; /* 3d view transform */ bcam->matrix = transform_inverse(get_transform(b_rv3d.view_matrix())); }
static void attr_create_subd_uv_map(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, bool subdivide_uvs) { if (b_mesh.uv_layers.length() != 0) { BL::Mesh::uv_layers_iterator l; int i = 0; for (b_mesh.uv_layers.begin(l); l != b_mesh.uv_layers.end(); ++l, ++i) { bool active_render = l->active_render(); AttributeStandard uv_std = (active_render) ? ATTR_STD_UV : ATTR_STD_NONE; ustring uv_name = ustring(l->name().c_str()); AttributeStandard tangent_std = (active_render) ? ATTR_STD_UV_TANGENT : ATTR_STD_NONE; ustring tangent_name = ustring((string(l->name().c_str()) + ".tangent").c_str()); /* Denotes whether UV map was requested directly. */ const bool need_uv = mesh->need_attribute(scene, uv_name) || mesh->need_attribute(scene, uv_std); /* Denotes whether tangent was requested directly. */ const bool need_tangent = mesh->need_attribute(scene, tangent_name) || (active_render && mesh->need_attribute(scene, tangent_std)); Attribute *uv_attr = NULL; /* UV map */ if (need_uv || need_tangent) { if (active_render) uv_attr = mesh->subd_attributes.add(uv_std, uv_name); else uv_attr = mesh->subd_attributes.add(uv_name, TypeFloat2, ATTR_ELEMENT_CORNER); if (subdivide_uvs) { uv_attr->flags |= ATTR_SUBDIVIDED; } BL::Mesh::polygons_iterator p; float2 *fdata = uv_attr->data_float2(); for (b_mesh.polygons.begin(p); p != b_mesh.polygons.end(); ++p) { int n = p->loop_total(); for (int j = 0; j < n; j++) { *(fdata++) = get_float2(l->data[p->loop_start() + j].uv()); } } } /* UV tangent */ if (need_tangent) { AttributeStandard sign_std = (active_render) ? ATTR_STD_UV_TANGENT_SIGN : ATTR_STD_NONE; ustring sign_name = ustring((string(l->name().c_str()) + ".tangent_sign").c_str()); bool need_sign = (mesh->need_attribute(scene, sign_name) || mesh->need_attribute(scene, sign_std)); mikk_compute_tangents(b_mesh, l->name().c_str(), mesh, need_sign, active_render); } /* Remove temporarily created UV attribute. */ if (!need_uv && uv_attr != NULL) { mesh->subd_attributes.remove(uv_attr); } } } else if (mesh->need_attribute(scene, ATTR_STD_UV_TANGENT)) { bool need_sign = mesh->need_attribute(scene, ATTR_STD_UV_TANGENT_SIGN); mikk_compute_tangents(b_mesh, NULL, mesh, need_sign, true); if (!mesh->need_attribute(scene, ATTR_STD_GENERATED)) { mesh->subd_attributes.remove(ATTR_STD_GENERATED); } } }
/* Create uv map attributes. */ static void attr_create_uv_map(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh) { if (b_mesh.uv_layers.length() != 0) { BL::Mesh::uv_layers_iterator l; for (b_mesh.uv_layers.begin(l); l != b_mesh.uv_layers.end(); ++l) { const bool active_render = l->active_render(); AttributeStandard uv_std = (active_render) ? ATTR_STD_UV : ATTR_STD_NONE; ustring uv_name = ustring(l->name().c_str()); AttributeStandard tangent_std = (active_render) ? ATTR_STD_UV_TANGENT : ATTR_STD_NONE; ustring tangent_name = ustring((string(l->name().c_str()) + ".tangent").c_str()); /* Denotes whether UV map was requested directly. */ const bool need_uv = mesh->need_attribute(scene, uv_name) || mesh->need_attribute(scene, uv_std); /* Denotes whether tangent was requested directly. */ const bool need_tangent = mesh->need_attribute(scene, tangent_name) || (active_render && mesh->need_attribute(scene, tangent_std)); /* UV map */ /* NOTE: We create temporary UV layer if its needed for tangent but * wasn't requested by other nodes in shaders. */ Attribute *uv_attr = NULL; if (need_uv || need_tangent) { if (active_render) { uv_attr = mesh->attributes.add(uv_std, uv_name); } else { uv_attr = mesh->attributes.add(uv_name, TypeFloat2, ATTR_ELEMENT_CORNER); } BL::Mesh::loop_triangles_iterator t; float2 *fdata = uv_attr->data_float2(); for (b_mesh.loop_triangles.begin(t); t != b_mesh.loop_triangles.end(); ++t) { int3 li = get_int3(t->loops()); fdata[0] = get_float2(l->data[li[0]].uv()); fdata[1] = get_float2(l->data[li[1]].uv()); fdata[2] = get_float2(l->data[li[2]].uv()); fdata += 3; } } /* UV tangent */ if (need_tangent) { AttributeStandard sign_std = (active_render) ? ATTR_STD_UV_TANGENT_SIGN : ATTR_STD_NONE; ustring sign_name = ustring((string(l->name().c_str()) + ".tangent_sign").c_str()); bool need_sign = (mesh->need_attribute(scene, sign_name) || mesh->need_attribute(scene, sign_std)); mikk_compute_tangents(b_mesh, l->name().c_str(), mesh, need_sign, active_render); } /* Remove temporarily created UV attribute. */ if (!need_uv && uv_attr != NULL) { mesh->attributes.remove(uv_attr); } } } else if (mesh->need_attribute(scene, ATTR_STD_UV_TANGENT)) { bool need_sign = mesh->need_attribute(scene, ATTR_STD_UV_TANGENT_SIGN); mikk_compute_tangents(b_mesh, NULL, mesh, need_sign, true); if (!mesh->need_attribute(scene, ATTR_STD_GENERATED)) { mesh->attributes.remove(ATTR_STD_GENERATED); } } }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Fill the Octane Camera properties from Blender View data ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void BlenderSync::load_camera_from_view(Camera* cam, BL::Scene b_scene, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height, float2& offset, bool skip_panorama) { float zoom; if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_CAMERA) { BL::Object b_ob = (b_v3d.lock_camera_and_layers()) ? b_scene.camera() : b_v3d.camera(); if(b_ob) { cam->matrix = scene->matrix * get_transform(b_ob.matrix_world()); // Magic zoom formula zoom = (float) b_rv3d.view_camera_zoom(); zoom = (1.41421f + zoom/50.0f); zoom *= zoom; zoom = 2.0f/zoom; zoom *= 2.0f; cam->zoom = zoom; offset = get_float2(b_rv3d.view_camera_offset()); load_camera_from_object(cam, b_ob, width, height, offset, skip_panorama); } } //if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_CAMERA) else if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_ORTHO || b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_PERSP) { cam->zoom = 2.0f; cam->near_clip_depth = b_v3d.clip_start(); cam->far_clip_depth = b_v3d.clip_end(); cam->matrix = scene->matrix * transform_inverse(get_transform(b_rv3d.view_matrix())); cam->type = CAMERA_PERSPECTIVE; if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_ORTHO) cam->ortho = true; else cam->ortho = false; PointerRNA oct_camera = RNA_pointer_get(&b_scene.ptr, "oct_view_cam"); get_cam_settings(cam, oct_camera, true); cam->lens_shift_x = 0; cam->lens_shift_y = 0; cam->sensorwidth = 32.0f; cam->sensorheight = 18.0f; cam->sensor_fit = Camera::AUTO; if(cam->ortho) { float ortho_scale; get_viewport_ortho_scale(cam, b_rv3d.view_distance(), b_v3d.lens(), width, height, &ortho_scale); cam->fov = ortho_scale * cam->zoom; } else { float sensor_size; get_camera_sensor_size(cam, width, height, &sensor_size); cam->fov = 2.0f * atanf((0.5f * sensor_size * cam->zoom) / b_v3d.lens()) *180.0f / M_PI_F; } // Position cam->look_at.x = cam->eye_point.x = cam->matrix.x.w; cam->look_at.y = cam->eye_point.y = cam->matrix.y.w; cam->look_at.z = cam->eye_point.z = cam->matrix.z.w; if(cam->ortho) { float3 dir = transform_direction(&cam->matrix, make_float3(0.0f, 0.0f, b_rv3d.view_distance())); cam->eye_point.x = cam->eye_point.x + dir.x; cam->eye_point.y = cam->eye_point.y + dir.y; cam->eye_point.z = cam->eye_point.z + dir.z; } else { float3 dir = transform_direction(&cam->matrix, make_float3(0.0f, 0.0f, -1.0f)); cam->look_at.x = cam->look_at.x + dir.x; cam->look_at.y = cam->look_at.y + dir.y; cam->look_at.z = cam->look_at.z + dir.z; } cam->up = normalize(transform_direction(&cam->matrix, make_float3(0.0f, 1.0f, 0.0f))); } //else if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_ORTHO || b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_PERSP) get_camera_border(cam, b_v3d, b_rv3d, width, height); } //load_camera_from_view()
Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph, BL::ViewLayer &b_view_layer, BL::DepsgraphObjectInstance &b_instance, float motion_time, bool show_self, bool show_particles, BlenderObjectCulling &culling, bool *use_portal) { const bool is_instance = b_instance.is_instance(); BL::Object b_ob = b_instance.object(); BL::Object b_parent = is_instance ? b_instance.parent() : b_instance.object(); BL::Object b_ob_instance = is_instance ? b_instance.instance_object() : b_ob; const bool motion = motion_time != 0.0f; /*const*/ Transform tfm = get_transform(b_ob.matrix_world()); int *persistent_id = NULL; BL::Array<int, OBJECT_PERSISTENT_ID_SIZE> persistent_id_array; if (is_instance) { persistent_id_array = b_instance.persistent_id(); persistent_id = persistent_id_array.data; } /* light is handled separately */ if (!motion && object_is_light(b_ob)) { /* TODO: don't use lights for excluded layers used as mask layer, * when dynamic overrides are back. */ #if 0 if (!((layer_flag & view_layer.holdout_layer) && (layer_flag & view_layer.exclude_layer))) #endif { sync_light(b_parent, persistent_id, b_ob, b_ob_instance, is_instance ? b_instance.random_id() : 0, tfm, use_portal); } return NULL; } /* only interested in object that we can create meshes from */ if (!object_is_mesh(b_ob)) { return NULL; } /* Perform object culling. */ if (culling.test(scene, b_ob, tfm)) { return NULL; } /* Visibility flags for both parent and child. */ PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles"); bool use_holdout = get_boolean(cobject, "is_holdout") || b_parent.holdout_get(PointerRNA_NULL, b_view_layer); uint visibility = object_ray_visibility(b_ob) & PATH_RAY_ALL_VISIBILITY; if (b_parent.ptr.data != b_ob.ptr.data) { visibility &= object_ray_visibility(b_parent); } /* TODO: make holdout objects on excluded layer invisible for non-camera rays. */ #if 0 if (use_holdout && (layer_flag & view_layer.exclude_layer)) { visibility &= ~(PATH_RAY_ALL_VISIBILITY - PATH_RAY_CAMERA); } #endif /* Clear camera visibility for indirect only objects. */ bool use_indirect_only = b_parent.indirect_only_get(PointerRNA_NULL, b_view_layer); if (use_indirect_only) { visibility &= ~PATH_RAY_CAMERA; } /* Don't export completely invisible objects. */ if (visibility == 0) { return NULL; } /* key to lookup object */ ObjectKey key(b_parent, persistent_id, b_ob_instance); Object *object; /* motion vector case */ if (motion) { object = object_map.find(key); if (object && object->use_motion()) { /* Set transform at matching motion time step. */ int time_index = object->motion_step(motion_time); if (time_index >= 0) { object->motion[time_index] = tfm; } /* mesh deformation */ if (object->mesh) sync_mesh_motion(b_depsgraph, b_ob, object, motion_time); } return object; } /* test if we need to sync */ bool object_updated = false; if (object_map.sync(&object, b_ob, b_parent, key)) object_updated = true; /* mesh sync */ object->mesh = sync_mesh( b_depsgraph, b_ob, b_ob_instance, object_updated, show_self, show_particles); /* special case not tracked by object update flags */ /* holdout */ if (use_holdout != object->use_holdout) { object->use_holdout = use_holdout; scene->object_manager->tag_update(scene); object_updated = true; } if (visibility != object->visibility) { object->visibility = visibility; object_updated = true; } bool is_shadow_catcher = get_boolean(cobject, "is_shadow_catcher"); if (is_shadow_catcher != object->is_shadow_catcher) { object->is_shadow_catcher = is_shadow_catcher; object_updated = true; } /* sync the asset name for Cryptomatte */ BL::Object parent = b_ob.parent(); ustring parent_name; if (parent) { while (parent.parent()) { parent = parent.parent(); } parent_name = parent.name(); } else { parent_name = b_ob.name(); } if (object->asset_name != parent_name) { object->asset_name = parent_name; object_updated = true; } /* object sync * transform comparison should not be needed, but duplis don't work perfect * in the depsgraph and may not signal changes, so this is a workaround */ if (object_updated || (object->mesh && object->mesh->need_update) || tfm != object->tfm) { object->name = b_ob.name().c_str(); object->pass_id = b_ob.pass_index(); object->tfm = tfm; object->motion.clear(); /* motion blur */ Scene::MotionType need_motion = scene->need_motion(); if (need_motion != Scene::MOTION_NONE && object->mesh) { Mesh *mesh = object->mesh; mesh->use_motion_blur = false; mesh->motion_steps = 0; uint motion_steps; if (need_motion == Scene::MOTION_BLUR) { motion_steps = object_motion_steps(b_parent, b_ob); mesh->motion_steps = motion_steps; if (motion_steps && object_use_deform_motion(b_parent, b_ob)) { mesh->use_motion_blur = true; } } else { motion_steps = 3; mesh->motion_steps = motion_steps; } object->motion.clear(); object->motion.resize(motion_steps, transform_empty()); if (motion_steps) { object->motion[motion_steps / 2] = tfm; for (size_t step = 0; step < motion_steps; step++) { motion_times.insert(object->motion_time(step)); } } } /* dupli texture coordinates and random_id */ if (is_instance) { object->dupli_generated = 0.5f * get_float3(b_instance.orco()) - make_float3(0.5f, 0.5f, 0.5f); object->dupli_uv = get_float2(b_instance.uv()); object->random_id = b_instance.random_id(); } else { object->dupli_generated = make_float3(0.0f, 0.0f, 0.0f); object->dupli_uv = make_float2(0.0f, 0.0f); object->random_id = hash_int_2d(hash_string(object->name.c_str()), 0); } object->tag_update(scene); } if (is_instance) { /* Sync possible particle data. */ sync_dupli_particle(b_parent, b_instance, object); } return object; }
Object *BlenderSync::sync_object(BL::Object b_parent, int persistent_id[OBJECT_PERSISTENT_ID_SIZE], BL::DupliObject b_dupli_ob, Transform& tfm, uint layer_flag, int motion, bool hide_tris) { BL::Object b_ob = (b_dupli_ob ? b_dupli_ob.object() : b_parent); /* light is handled separately */ if(object_is_light(b_ob)) { /* don't use lamps for excluded layers used as mask layer */ if(!motion && !((layer_flag & render_layer.holdout_layer) && (layer_flag & render_layer.exclude_layer))) sync_light(b_parent, persistent_id, b_ob, tfm); return NULL; } /* only interested in object that we can create meshes from */ if(!object_is_mesh(b_ob)) return NULL; /* key to lookup object */ ObjectKey key(b_parent, persistent_id, b_ob); Object *object; /* motion vector case */ if(motion) { object = object_map.find(key); if(object) { if(tfm != object->tfm) { if(motion == -1) object->motion.pre = tfm; else object->motion.post = tfm; object->use_motion = true; } /* mesh deformation blur not supported yet */ if(!scene->integrator->motion_blur) sync_mesh_motion(b_ob, object->mesh, motion); } return object; } /* test if we need to sync */ bool object_updated = false; if(object_map.sync(&object, b_ob, b_parent, key)) object_updated = true; bool use_holdout = (layer_flag & render_layer.holdout_layer) != 0; /* mesh sync */ object->mesh = sync_mesh(b_ob, object_updated, hide_tris); /* special case not tracked by object update flags */ /* holdout */ if(use_holdout != object->use_holdout) { object->use_holdout = use_holdout; scene->object_manager->tag_update(scene); object_updated = true; } /* visibility flags for both parent and child */ uint visibility = object_ray_visibility(b_ob) & PATH_RAY_ALL_VISIBILITY; if(b_parent.ptr.data != b_ob.ptr.data) { visibility &= object_ray_visibility(b_parent); object->random_id ^= hash_int(hash_string(b_parent.name().c_str())); } /* make holdout objects on excluded layer invisible for non-camera rays */ if(use_holdout && (layer_flag & render_layer.exclude_layer)) visibility &= ~(PATH_RAY_ALL_VISIBILITY - PATH_RAY_CAMERA); /* camera flag is not actually used, instead is tested against render layer * flags */ if(visibility & PATH_RAY_CAMERA) { visibility |= layer_flag << PATH_RAY_LAYER_SHIFT; visibility &= ~PATH_RAY_CAMERA; } if(visibility != object->visibility) { object->visibility = visibility; object_updated = true; } /* object sync * transform comparison should not be needed, but duplis don't work perfect * in the depsgraph and may not signal changes, so this is a workaround */ if(object_updated || (object->mesh && object->mesh->need_update) || tfm != object->tfm) { object->name = b_ob.name().c_str(); object->pass_id = b_ob.pass_index(); object->tfm = tfm; object->motion.pre = tfm; object->motion.post = tfm; object->use_motion = false; /* random number */ object->random_id = hash_string(object->name.c_str()); if(persistent_id) { for(int i = 0; i < OBJECT_PERSISTENT_ID_SIZE; i++) object->random_id = hash_int_2d(object->random_id, persistent_id[i]); } else object->random_id = hash_int_2d(object->random_id, 0); if(b_parent.ptr.data != b_ob.ptr.data) object->random_id ^= hash_int(hash_string(b_parent.name().c_str())); /* dupli texture coordinates */ 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()); } else { object->dupli_generated = make_float3(0.0f, 0.0f, 0.0f); object->dupli_uv = make_float2(0.0f, 0.0f); } object->tag_update(scene); } return object; }