Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later.

Cycles uses code from some great open source projects, many thanks them:

* BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs":
http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/
* Open Shading Language for a large part of the shading system:
http://code.google.com/p/openshadinglanguage/
* Blender for procedural textures and a few other nodes.
* Approximate Catmull Clark subdivision from NVidia Mesh tools:
http://code.google.com/p/nvidia-mesh-tools/
* Sobol direction vectors from:
http://web.maths.unsw.edu.au/~fkuo/sobol/
* Film response functions from:
http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php

1 files changed, 153 insertions, 0 deletions

diff --git a/intern/cycles/render/mesh_displace.cpp b/intern/cycles/render/mesh_displace.cpp
new file mode 100644
index 00000000000..e86bea59ec1
--- /dev/null
+++ b/intern/cycles/render/mesh_displace.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "device.h"
+
+#include "mesh.h"
+#include "scene.h"
+#include "shader.h"
+
+#include "util_foreach.h"
+#include "util_progress.h"
+
+CCL_NAMESPACE_BEGIN
+
+bool MeshManager::displace(Device *device, Scene *scene, Mesh *mesh, Progress& progress)
+{
+	/* verify if we have a displacement shader */
+	bool has_displacement = false;
+
+	if(mesh->displacement_method != Mesh::DISPLACE_BUMP) {
+		foreach(uint sindex, mesh->used_shaders)
+			if(scene->shaders[sindex]->has_displacement)
+				has_displacement = true;
+	}
+	
+	if(!has_displacement)
+		return false;
+
+	/* setup input for device task */
+	vector<bool> done(mesh->verts.size(), false);
+	device_vector<uint4> d_input;
+	uint4 *d_input_data = d_input.resize(mesh->verts.size());
+	size_t d_input_offset = 0;
+
+	for(size_t i = 0; i < mesh->triangles.size(); i++) {
+		Mesh::Triangle t = mesh->triangles[i];
+		Shader *shader = scene->shaders[mesh->shader[i]];
+
+		if(!shader->has_displacement)
+			continue;
+
+		for(int j = 0; j < 3; j++) {
+			if(done[t.v[j]])
+				continue;
+
+			done[t.v[j]] = true;
+
+			/* set up object, primitive and barycentric coordinates */
+			/* when used, non-instanced convention: object = -object-1; */
+			int object = ~0; /* todo */
+			int prim = mesh->tri_offset + i;
+			float u, v;
+
+			if(j == 0) {
+				u = 1.0f;
+				v = 0.0f;
+			}
+			else if(j == 1) {
+				u = 0.0f;
+				v = 1.0f;
+			}
+			else {
+				u = 0.0f;
+				v = 0.0f;
+			}
+
+			/* back */
+			uint4 in = make_uint4(object, prim, __float_as_int(u), __float_as_int(v));
+			d_input_data[d_input_offset++] = in;
+		}
+	}
+
+	if(d_input_offset == 0)
+		return false;
+	
+	/* run device task */
+	device_vector<float3> d_offset;
+	d_offset.resize(d_input.size());
+
+	device->mem_alloc(d_input, MEM_READ_ONLY);
+	device->mem_copy_to(d_input);
+	device->mem_alloc(d_offset, MEM_WRITE_ONLY);
+
+	DeviceTask task(DeviceTask::DISPLACE);
+	task.displace_input = d_input.device_pointer;
+	task.displace_offset = d_offset.device_pointer;
+	task.displace_x = 0;
+	task.displace_w = d_input.size();
+
+	device->task_add(task);
+	device->task_wait();
+
+	device->mem_copy_from(d_offset, 0, sizeof(float3)*d_offset.size());
+	device->mem_free(d_input);
+	device->mem_free(d_offset);
+
+	if(progress.get_cancel())
+		return false;
+
+	/* read result */
+	done.clear();
+	done.resize(mesh->verts.size(), false);
+	int k = 0;
+
+	float3 *offset = (float3*)d_offset.data_pointer;
+
+	for(size_t i = 0; i < mesh->triangles.size(); i++) {
+		Mesh::Triangle t = mesh->triangles[i];
+		Shader *shader = scene->shaders[mesh->shader[i]];
+
+		if(!shader->has_displacement)
+			continue;
+
+		for(int j = 0; j < 3; j++) {
+			if(!done[t.v[j]]) {
+				done[t.v[j]] = true;
+				mesh->verts[t.v[j]] += offset[k++];
+			}
+		}
+	}
+
+	/* for displacement method both, we only need to recompute the face
+	 * normals, as bump mapping in the shader will already alter the
+	 * vertex normal, so we start from the non-displaced vertex normals
+	 * to avoid applying the perturbation twice. */
+	mesh->attributes.remove(Attribute::STD_FACE_NORMAL);
+	mesh->add_face_normals();
+
+	if(mesh->displacement_method == Mesh::DISPLACE_TRUE) {
+		mesh->attributes.remove(Attribute::STD_VERTEX_NORMAL);
+		mesh->add_vertex_normals();
+	}
+
+	return true;
+}
+
+CCL_NAMESPACE_END
+