Differential D8538 Diff 27613 intern/cycles/render/geometry.cpp

Changeset View

Standalone View

intern/cycles/render/geometry.cpp

Show All 25 Lines
#include "render/hair.h"		#include "render/hair.h"
#include "render/light.h"		#include "render/light.h"
#include "render/mesh.h"		#include "render/mesh.h"
#include "render/nodes.h"		#include "render/nodes.h"
#include "render/object.h"		#include "render/object.h"
#include "render/scene.h"		#include "render/scene.h"
#include "render/shader.h"		#include "render/shader.h"
#include "render/stats.h"		#include "render/stats.h"
		#include "render/volume.h"

#include "subd/subd_patch_table.h"		#include "subd/subd_patch_table.h"
#include "subd/subd_split.h"		#include "subd/subd_split.h"

#include "kernel/osl/osl_globals.h"		#include "kernel/osl/osl_globals.h"

#include "util/util_foreach.h"		#include "util/util_foreach.h"
#include "util/util_logging.h"		#include "util/util_logging.h"
▲ Show 20 Lines • Show All 749 Lines • ▼ Show 20 Lines	void GeometryManager::mesh_calc_offset(Scene *scene)

size_t patch_size = 0;		size_t patch_size = 0;
size_t face_size = 0;		size_t face_size = 0;
size_t corner_size = 0;		size_t corner_size = 0;

size_t optix_prim_size = 0;		size_t optix_prim_size = 0;

foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
if (geom->type == Geometry::MESH) {		if (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);

mesh->vert_offset = vert_size;		mesh->vert_offset = vert_size;
mesh->prim_offset = tri_size;		mesh->prim_offset = tri_size;

mesh->patch_offset = patch_size;		mesh->patch_offset = patch_size;
mesh->face_offset = face_size;		mesh->face_offset = face_size;
mesh->corner_offset = corner_size;		mesh->corner_offset = corner_size;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	void GeometryManager::device_update_mesh(
size_t tri_size = 0;		size_t tri_size = 0;

size_t curve_key_size = 0;		size_t curve_key_size = 0;
size_t curve_size = 0;		size_t curve_size = 0;

size_t patch_size = 0;		size_t patch_size = 0;

foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
if (geom->type == Geometry::MESH) {		if (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);

vert_size += mesh->verts.size();		vert_size += mesh->verts.size();
tri_size += mesh->num_triangles();		tri_size += mesh->num_triangles();

if (mesh->subd_faces.size()) {		if (mesh->subd_faces.size()) {
Mesh::SubdFace &last = mesh->subd_faces[mesh->subd_faces.size() - 1];		Mesh::SubdFace &last = mesh->subd_faces[mesh->subd_faces.size() - 1];
patch_size += (last.ptex_offset + last.num_ptex_faces()) * 8;		patch_size += (last.ptex_offset + last.num_ptex_faces()) * 8;
Show All 17 Lines	void GeometryManager::device_update_mesh(
vector<uint> tri_prim_index(tri_size);		vector<uint> tri_prim_index(tri_size);
if (for_displacement) {		if (for_displacement) {
/* For displacement kernels we do some trickery to make them believe		/* For displacement kernels we do some trickery to make them believe
* we've got all required data ready. However, that data is different		* we've got all required data ready. However, that data is different
* from final render kernels since we don't have BVH yet, so can't		* from final render kernels since we don't have BVH yet, so can't
* really use same semantic of arrays.		* really use same semantic of arrays.
*/		*/
foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
if (geom->type == Geometry::MESH) {		if (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);
for (size_t i = 0; i < mesh->num_triangles(); ++i) {		for (size_t i = 0; i < mesh->num_triangles(); ++i) {
tri_prim_index[i + mesh->prim_offset] = 3 * (i + mesh->prim_offset);		tri_prim_index[i + mesh->prim_offset] = 3 * (i + mesh->prim_offset);
}		}
}		}
}		}
}		}
else {		else {
Show All 11 Lines	if (tri_size != 0) {

uint *tri_shader = dscene->tri_shader.alloc(tri_size);		uint *tri_shader = dscene->tri_shader.alloc(tri_size);
float4 *vnormal = dscene->tri_vnormal.alloc(vert_size);		float4 *vnormal = dscene->tri_vnormal.alloc(vert_size);
uint4 *tri_vindex = dscene->tri_vindex.alloc(tri_size);		uint4 *tri_vindex = dscene->tri_vindex.alloc(tri_size);
uint *tri_patch = dscene->tri_patch.alloc(tri_size);		uint *tri_patch = dscene->tri_patch.alloc(tri_size);
float2 *tri_patch_uv = dscene->tri_patch_uv.alloc(vert_size);		float2 *tri_patch_uv = dscene->tri_patch_uv.alloc(vert_size);

foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
if (geom->type == Geometry::MESH) {		if (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);
mesh->pack_shaders(scene, &tri_shader[mesh->prim_offset]);		mesh->pack_shaders(scene, &tri_shader[mesh->prim_offset]);
mesh->pack_normals(&vnormal[mesh->vert_offset]);		mesh->pack_normals(&vnormal[mesh->vert_offset]);
mesh->pack_verts(tri_prim_index,		mesh->pack_verts(tri_prim_index,
&tri_vindex[mesh->prim_offset],		&tri_vindex[mesh->prim_offset],
&tri_patch[mesh->prim_offset],		&tri_patch[mesh->prim_offset],
&tri_patch_uv[mesh->vert_offset],		&tri_patch_uv[mesh->vert_offset],
mesh->vert_offset,		mesh->vert_offset,
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines	if (patch_size != 0) {
}		}

dscene->patches.copy_to_device();		dscene->patches.copy_to_device();
}		}

if (for_displacement) {		if (for_displacement) {
float4 prim_tri_verts = dscene->prim_tri_verts.alloc(tri_size 3);		float4 prim_tri_verts = dscene->prim_tri_verts.alloc(tri_size 3);
foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
if (geom->type == Geometry::MESH) {		if (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);
for (size_t i = 0; i < mesh->num_triangles(); ++i) {		for (size_t i = 0; i < mesh->num_triangles(); ++i) {
Mesh::Triangle t = mesh->get_triangle(i);		Mesh::Triangle t = mesh->get_triangle(i);
size_t offset = 3 * (i + mesh->prim_offset);		size_t offset = 3 * (i + mesh->prim_offset);
prim_tri_verts[offset + 0] = float3_to_float4(mesh->verts[t.v[0]]);		prim_tri_verts[offset + 0] = float3_to_float4(mesh->verts[t.v[0]]);
prim_tri_verts[offset + 1] = float3_to_float4(mesh->verts[t.v[1]]);		prim_tri_verts[offset + 1] = float3_to_float4(mesh->verts[t.v[1]]);
prim_tri_verts[offset + 2] = float3_to_float4(mesh->verts[t.v[2]]);		prim_tri_verts[offset + 2] = float3_to_float4(mesh->verts[t.v[2]]);
}		}
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines	foreach (const Shader *shader, geom->used_shaders) {
if (shader->has_volume) {		if (shader->has_volume) {
geom->has_volume = true;		geom->has_volume = true;
}		}
if (shader->has_surface_bssrdf) {		if (shader->has_surface_bssrdf) {
geom->has_surface_bssrdf = true;		geom->has_surface_bssrdf = true;
}		}
}		}

if (need_update && geom->has_volume && geom->type == Geometry::MESH) {		if (need_update && geom->type == Geometry::VOLUME) {
/* Create volume meshes if there is voxel data. */		/* Create volume meshes if there is voxel data. */
if (geom->has_voxel_attributes()) {
if (!volume_images_updated) {		if (!volume_images_updated) {
progress.set_status("Updating Meshes Volume Bounds");		progress.set_status("Updating Meshes Volume Bounds");
device_update_volume_images(device, scene, progress);		device_update_volume_images(device, scene, progress);
volume_images_updated = true;		volume_images_updated = true;
}		}

Mesh mesh = static_cast<Mesh >(geom);		Volume volume = static_cast<Volume >(geom);
create_volume_mesh(mesh, progress);		create_volume_mesh(volume, progress);
}
}		}

if (geom->type == Geometry::HAIR) {		if (geom->type == Geometry::HAIR) {
/* Set curve shape, still a global scene setting for now. */		/* Set curve shape, still a global scene setting for now. */
Hair hair = static_cast<Hair >(geom);		Hair hair = static_cast<Hair >(geom);
hair->curve_shape = scene->params.hair_shape;		hair->curve_shape = scene->params.hair_shape;
}		}
}		}
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines	void GeometryManager::device_update(Device *device,
size_t total_tess_needed = 0;		size_t total_tess_needed = 0;

foreach (Geometry *geom, scene->geometry) {		foreach (Geometry *geom, scene->geometry) {
foreach (Shader *shader, geom->used_shaders) {		foreach (Shader *shader, geom->used_shaders) {
if (shader->need_update_geometry)		if (shader->need_update_geometry)
geom->need_update = true;		geom->need_update = true;
}		}

if (geom->need_update && geom->type == Geometry::MESH) {		if (geom->need_update && (geom->type == Geometry::MESH \|\| geom->type == Geometry::VOLUME)) {
Mesh mesh = static_cast<Mesh >(geom);		Mesh mesh = static_cast<Mesh >(geom);

/* Update normals. */		/* Update normals. */
mesh->add_face_normals();		mesh->add_face_normals();
mesh->add_vertex_normals();		mesh->add_vertex_normals();

if (mesh->need_attribute(scene, ATTR_STD_POSITION_UNDISPLACED)) {		if (mesh->need_attribute(scene, ATTR_STD_POSITION_UNDISPLACED)) {
mesh->add_undisplaced();		mesh->add_undisplaced();
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines