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, 266 insertions, 0 deletions

diff --git a/intern/cycles/util/util_types.h b/intern/cycles/util/util_types.h
new file mode 100644
index 00000000000..a0e352128d1
--- /dev/null
+++ b/intern/cycles/util/util_types.h
@@ -0,0 +1,266 @@
+/*
+ * 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.
+ */
+
+#ifndef __UTIL_TYPES_H__
+#define __UTIL_TYPES_H__
+
+#ifndef __KERNEL_OPENCL__
+
+#include <stdlib.h>
+
+#endif
+
+/* Qualifiers for kernel code shared by CPU and GPU */
+
+#ifndef __KERNEL_GPU__
+
+#define __device static inline
+#define __global
+#define __local
+#define __shared
+#define __constant
+#define __device_inline static inline __attribute__((always_inline))
+
+#endif
+
+/* SIMD Types */
+
+#ifndef __KERNEL_GPU__
+
+#include <emmintrin.h>
+#include <xmmintrin.h>
+
+#endif
+
+#ifndef _WIN32
+#ifndef __KERNEL_GPU__
+
+#include <stdint.h>
+
+#endif
+#endif
+
+CCL_NAMESPACE_BEGIN
+
+/* Types
+ *
+ * Define simpler unsigned type names, and integer with defined number of bits.
+ * Also vector types, named to be compatible with OpenCL builtin types, while
+ * working for CUDA and C++ too. */
+
+/* Shorter Unsigned Names */
+
+typedef unsigned char uchar;
+typedef unsigned int uint;
+
+#ifndef __KERNEL_GPU__
+
+/* Fixed Bits Types */
+
+#ifdef _WIN32
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+
+typedef long long int64_t;
+typedef unsigned long long uint64_t;
+
+#endif
+
+/* Generic Memory Pointer */
+
+typedef uint64_t device_ptr;
+
+/* Vector Types */
+
+struct uchar2 {
+	uchar x, y;
+
+	uchar operator[](int i) const { return *(&x + i); }
+	uchar& operator[](int i) { return *(&x + i); }
+};
+
+struct uchar3 {
+	uchar x, y, z;
+
+	uchar operator[](int i) const { return *(&x + i); }
+	uchar& operator[](int i) { return *(&x + i); }
+};
+
+struct uchar4 {
+	uchar x, y, z, w;
+
+	uchar operator[](int i) const { return *(&x + i); }
+	uchar& operator[](int i) { return *(&x + i); }
+};
+
+struct int2 {
+	int x, y;
+
+	int operator[](int i) const { return *(&x + i); }
+	int& operator[](int i) { return *(&x + i); }
+};
+
+struct int3 {
+	int x, y, z;
+
+	int operator[](int i) const { return *(&x + i); }
+	int& operator[](int i) { return *(&x + i); }
+};
+
+struct int4 {
+	int x, y, z, w;
+
+	int operator[](int i) const { return *(&x + i); }
+	int& operator[](int i) { return *(&x + i); }
+};
+
+struct uint2 {
+	uint x, y;
+
+	uint operator[](int i) const { return *(&x + i); }
+	uint& operator[](int i) { return *(&x + i); }
+};
+
+struct uint3 {
+	uint x, y, z;
+
+	uint operator[](int i) const { return *(&x + i); }
+	uint& operator[](int i) { return *(&x + i); }
+};
+
+struct uint4 {
+	uint x, y, z, w;
+
+	uint operator[](int i) const { return *(&x + i); }
+	uint& operator[](int i) { return *(&x + i); }
+};
+
+struct float2 {
+	float x, y;
+
+	float operator[](int i) const { return *(&x + i); }
+	float& operator[](int i) { return *(&x + i); }
+};
+
+struct float3 {
+	float x, y, z;
+
+	float operator[](int i) const { return *(&x + i); }
+	float& operator[](int i) { return *(&x + i); }
+};
+
+struct float4 {
+	float x, y, z, w;
+
+	float operator[](int i) const { return *(&x + i); }
+	float& operator[](int i) { return *(&x + i); }
+};
+
+#endif
+
+#ifndef __KERNEL_GPU__
+
+/* Vector Type Constructors
+ * 
+ * OpenCL does not support C++ class, so we use these instead. */
+
+__device uchar2 make_uchar2(uchar x, uchar y)
+{
+	uchar2 a = {x, y};
+	return a;
+}
+
+__device uchar3 make_uchar3(uchar x, uchar y, uchar z)
+{
+	uchar3 a = {x, y, z};
+	return a;
+}
+
+__device uchar4 make_uchar4(uchar x, uchar y, uchar z, uchar w)
+{
+	uchar4 a = {x, y, z, w};
+	return a;
+}
+
+__device int2 make_int2(int x, int y)
+{
+	int2 a = {x, y};
+	return a;
+}
+
+__device int3 make_int3(int x, int y, int z)
+{
+	int3 a = {x, y, z};
+	return a;
+}
+
+__device int4 make_int4(int x, int y, int z, int w)
+{
+	int4 a = {x, y, z, w};
+	return a;
+}
+
+__device uint2 make_uint2(uint x, uint y)
+{
+	uint2 a = {x, y};
+	return a;
+}
+
+__device uint3 make_uint3(uint x, uint y, uint z)
+{
+	uint3 a = {x, y, z};
+	return a;
+}
+
+__device uint4 make_uint4(uint x, uint y, uint z, uint w)
+{
+	uint4 a = {x, y, z, w};
+	return a;
+}
+
+__device float2 make_float2(float x, float y)
+{
+	float2 a = {x, y};
+	return a;
+}
+
+__device float3 make_float3(float x, float y, float z)
+{
+	float3 a = {x, y, z};
+	return a;
+}
+
+__device float4 make_float4(float x, float y, float z, float w)
+{
+	float4 a = {x, y, z, w};
+	return a;
+}
+
+#endif
+
+CCL_NAMESPACE_END
+
+#endif /* __UTIL_TYPES_H__ */
+