style cleanup: block comments
authorCampbell Barton <ideasman42@gmail.com>
Sat, 9 Jun 2012 17:22:52 +0000 (17:22 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 9 Jun 2012 17:22:52 +0000 (17:22 +0000)
70 files changed:
intern/cycles/blender/blender_camera.cpp
intern/cycles/blender/blender_mesh.cpp
intern/cycles/blender/blender_object.cpp
intern/cycles/blender/blender_session.cpp
intern/cycles/blender/blender_shader.cpp
intern/cycles/blender/blender_sync.cpp
intern/cycles/blender/blender_util.h
intern/cycles/bvh/bvh.cpp
intern/cycles/bvh/bvh.h
intern/cycles/bvh/bvh_binning.cpp
intern/cycles/bvh/bvh_sort.h
intern/cycles/device/device.cpp
intern/cycles/device/device_cpu.cpp
intern/cycles/device/device_cuda.cpp
intern/cycles/device/device_network.h
intern/cycles/device/device_opencl.cpp
intern/cycles/kernel/kernel_accumulate.h
intern/cycles/kernel/kernel_bvh.h
intern/cycles/kernel/kernel_compat_cpu.h
intern/cycles/kernel/kernel_emission.h
intern/cycles/kernel/kernel_globals.h
intern/cycles/kernel/kernel_light.h
intern/cycles/kernel/kernel_montecarlo.h
intern/cycles/kernel/kernel_optimized.cpp
intern/cycles/kernel/kernel_path.h
intern/cycles/kernel/kernel_projection.h
intern/cycles/kernel/kernel_random.h
intern/cycles/kernel/kernel_triangle.h
intern/cycles/kernel/osl/nodes/node_fresnel.h
intern/cycles/kernel/osl/osl_services.cpp
intern/cycles/kernel/osl/osl_services.h
intern/cycles/kernel/svm/bsdf.h
intern/cycles/kernel/svm/bsdf_ashikhmin_velvet.h
intern/cycles/kernel/svm/bsdf_diffuse.h
intern/cycles/kernel/svm/bsdf_microfacet.h
intern/cycles/kernel/svm/bsdf_reflection.h
intern/cycles/kernel/svm/bsdf_refraction.h
intern/cycles/kernel/svm/bsdf_transparent.h
intern/cycles/kernel/svm/bsdf_ward.h
intern/cycles/kernel/svm/bsdf_westin.h
intern/cycles/kernel/svm/emissive.h
intern/cycles/kernel/svm/svm_closure.h
intern/cycles/kernel/svm/svm_image.h
intern/cycles/kernel/svm/svm_noise.h
intern/cycles/kernel/svm/svm_texture.h
intern/cycles/kernel/svm/volume.h
intern/cycles/render/buffers.h
intern/cycles/render/film.cpp
intern/cycles/render/graph.cpp
intern/cycles/render/image.cpp
intern/cycles/render/light.cpp
intern/cycles/render/mesh.cpp
intern/cycles/render/object.cpp
intern/cycles/render/osl.cpp
intern/cycles/render/session.cpp
intern/cycles/render/shader.cpp
intern/cycles/render/shader.h
intern/cycles/render/svm.cpp
intern/cycles/subd/subd_build.cpp
intern/cycles/subd/subd_dice.cpp
intern/cycles/subd/subd_ring.cpp
intern/cycles/util/util_cuda.cpp
intern/cycles/util/util_md5.cpp
intern/cycles/util/util_opencl.h
intern/cycles/util/util_path.cpp
intern/cycles/util/util_system.cpp
intern/cycles/util/util_task.cpp
intern/cycles/util/util_thread.h
intern/cycles/util/util_transform.cpp
intern/cycles/util/util_transform.h

index 9bc82344fcc808a5a8b311cbc0f9bcfc1baa6308..3bc1fa34a98192dd8122e8f0e62c85e6ba4a57c6 100644 (file)
@@ -141,7 +141,7 @@ static void blender_camera_from_object(BlenderCamera *bcam, BL::Object b_ob)
                bcam->lens = b_camera.lens();
 
                /* allow f/stop number to change aperture_size but still
-                  give manual control over aperture radius */
+                * give manual control over aperture radius */
                int aperture_type = RNA_enum_get(&ccamera, "aperture_type");
 
                if(aperture_type == 1) {
@@ -179,8 +179,8 @@ static Transform blender_camera_matrix(const Transform& tfm, CameraType type)
 
        if(type == CAMERA_PANORAMA) {
                /* make it so environment camera needs to be pointed in the direction
-                  of the positive x-axis to match an environment texture, this way
-                  it is looking at the center of the texture */
+                * of the positive x-axis to match an environment texture, this way
+                * it is looking at the center of the texture */
                result = tfm *
                        make_transform( 0.0f, -1.0f, 0.0f, 0.0f,
                                        0.0f,  0.0f, 1.0f, 0.0f,
index ad91022de075d23fef187854d70e0d042b64c742..f9d26c40a741bd4b8e38035a85b6737b2c4d7c32 100644 (file)
@@ -68,8 +68,8 @@ static void create_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, const vector<
        }
 
        /* create generated coordinates. todo: we should actually get the orco
-          coordinates from modifiers, for now we use texspace loc/size which
-          is available in the api. */
+        * coordinates from modifiers, for now we use texspace loc/size which
+        * is available in the api. */
        if(mesh->need_attribute(scene, ATTR_STD_GENERATED)) {
                Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
                float3 loc = get_float3(b_mesh.texspace_location());
@@ -181,8 +181,10 @@ static void create_subd_mesh(Mesh *mesh, BL::Mesh b_mesh, PointerRNA *cmesh, con
 
                if(n == 4)
                        sdmesh.add_face(vi[0], vi[1], vi[2], vi[3]);
-               /*else
-                       sdmesh.add_face(vi[0], vi[1], vi[2]);*/
+#if 0
+               else
+                       sdmesh.add_face(vi[0], vi[1], vi[2]);
+#endif
        }
 
        /* finalize subd mesh */
@@ -232,7 +234,7 @@ Mesh *BlenderSync::sync_mesh(BL::Object b_ob, bool object_updated)
                /* if transform was applied to mesh, need full update */
                if(object_updated && mesh->transform_applied);
                /* test if shaders changed, these can be object level so mesh
-                  does not get tagged for recalc */
+                * does not get tagged for recalc */
                else if(mesh->used_shaders != used_shaders);
                else {
                        /* even if not tagged for recalc, we may need to sync anyway
index b70491a7b8236fbf30b75a7f05a6202afdbc087d..c4b58d6fa761c5ffa6642a01397d70b45366d2a8 100644 (file)
@@ -264,7 +264,7 @@ void BlenderSync::sync_object(BL::Object b_parent, int b_index, BL::Object b_ob,
                }
 
                /* camera flag is not actually used, instead is tested
-                  against render layer flags */
+                * against render layer flags */
                if(object->visibility & PATH_RAY_CAMERA) {
                        object->visibility |= layer_flag << PATH_RAY_LAYER_SHIFT;
                        object->visibility &= ~PATH_RAY_CAMERA;
index 9726f7b94cf3a7e08851a20dc967acd0eaed9db7..aeda40ae40e4b6a9bddf8f4bcf7773f3ee06bad0 100644 (file)
@@ -304,7 +304,7 @@ void BlenderSession::synchronize()
        session->set_pause(BlenderSync::get_session_pause(b_scene, background));
 
        /* copy recalc flags, outside of mutex so we can decide to do the real
-          synchronization at a later time to not block on running updates */
+        * synchronization at a later time to not block on running updates */
        sync->sync_recalc();
 
        /* try to acquire mutex. if we don't want to or can't, come back later */
@@ -334,7 +334,7 @@ void BlenderSession::synchronize()
 bool BlenderSession::draw(int w, int h)
 {
        /* before drawing, we verify camera and viewport size changes, because
-          we do not get update callbacks for those, we must detect them here */
+        * we do not get update callbacks for those, we must detect them here */
        if(session->ready_to_reset()) {
                bool reset = false;
 
@@ -429,7 +429,7 @@ void BlenderSession::tag_redraw()
 {
        if(background) {
                /* update stats and progress, only for background here because
-                  in 3d view we do it in draw for thread safety reasons */
+                * in 3d view we do it in draw for thread safety reasons */
                update_status_progress();
 
                /* offline render, redraw if timeout passed */
index a7be0a8fb5472737991033f3d7fb629154111e09..f9331fc1b1432d0fa61a9291d9ff6ca7cca2d685 100644 (file)
@@ -641,7 +641,7 @@ static void add_nodes(BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *grap
                        to_pair = sockets_map[b_to_sock.ptr.data];
 
                /* either node may be NULL when the node was not exported, typically
-                  because the node type is not supported */
+                * because the node type is not supported */
                if(from_pair.first && to_pair.first) {
                        ShaderOutput *output = from_pair.first->output(from_pair.second.c_str());
                        ShaderInput *input = to_pair.first->input(to_pair.second.c_str());
index 488fea8d12b4f15e26c1685c311329eb967cef96..a9714d6d72fa27260862a9a9f64cd8ac64ffe68b 100644 (file)
@@ -63,7 +63,7 @@ BlenderSync::~BlenderSync()
 bool BlenderSync::sync_recalc()
 {
        /* sync recalc flags from blender to cycles. actual update is done separate,
-          so we can do it later on if doing it immediate is not suitable */
+        * so we can do it later on if doing it immediate is not suitable */
 
        BL::BlendData::materials_iterator b_mat;
 
index b9c60738b36797c56d2afb5ad5b2b92f42a0747c..9b9e0d3a42536d1288b55100a9f5d78f34dfe108 100644 (file)
@@ -27,7 +27,7 @@
 #include "util_vector.h"
 
 /* Hacks to hook into Blender API
  todo: clean this up ... */
* todo: clean this up ... */
 
 extern "C" {
 
@@ -121,7 +121,7 @@ static inline Transform get_transform(BL::Array<float, 16> array)
        Transform tfm;
 
        /* we assume both types to be just 16 floats, and transpose because blender
-          use column major matrix order while we use row major */
+        * use column major matrix order while we use row major */
        memcpy(&tfm, &array, sizeof(float)*16);
        tfm = transform_transpose(tfm);
 
@@ -164,12 +164,14 @@ static inline uint get_layer(BL::Array<int, 20> array)
        return layer;
 }
 
-/*static inline float3 get_float3(PointerRNA& ptr, const char *name)
+#if 0
+static inline float3 get_float3(PointerRNA& ptr, const char *name)
 {
        float3 f;
        RNA_float_get_array(&ptr, name, &f.x);
        return f;
-}*/
+}
+#endif
 
 static inline bool get_boolean(PointerRNA& ptr, const char *name)
 {
index 15695dddf459f2580ced4716d587d366a43c8c0c..a383ad317ab873f951e4cd8d69914bf6a78ac14f 100644 (file)
@@ -292,13 +292,13 @@ void BVH::pack_triangles()
 void BVH::pack_instances(size_t nodes_size)
 {
        /* The BVH's for instances are built separately, but for traversal all
-          BVH's are stored in global arrays. This function merges them into the
-          top level BVH, adjusting indexes and offsets where appropriate. */
+        * BVH's are stored in global arrays. This function merges them into the
+        * top level BVH, adjusting indexes and offsets where appropriate. */
        bool use_qbvh = params.use_qbvh;
        size_t nsize = (use_qbvh)? BVH_QNODE_SIZE: BVH_NODE_SIZE;
 
        /* adjust primitive index to point to the triangle in the global array, for
-          meshes with transform applied and already in the top level BVH */
+        * meshes with transform applied and already in the top level BVH */
        for(size_t i = 0; i < pack.prim_index.size(); i++)
                if(pack.prim_index[i] != -1)
                        pack.prim_index[i] += objects[pack.prim_object[i]]->mesh->tri_offset;
@@ -356,14 +356,14 @@ void BVH::pack_instances(size_t nodes_size)
                Mesh *mesh = ob->mesh;
 
                /* if mesh transform is applied, that means it's already in the top
-                  level BVH, and we don't need to merge it in */
+                * level BVH, and we don't need to merge it in */
                if(mesh->transform_applied) {
                        pack.object_node[object_offset++] = 0;
                        continue;
                }
 
                /* if mesh already added once, don't add it again, but used set
-                  node offset for this object */
+                * node offset for this object */
                map<Mesh*, int>::iterator it = mesh_map.find(mesh);
 
                if(mesh_map.find(mesh) != mesh_map.end()) {
index 30ae7dac1069b1150e5e5968ef30ec3c8b38e8a7..549f1e3ac1d190cd078c8fc979b478a34ec3028d 100644 (file)
@@ -46,7 +46,7 @@ class Progress;
 
 struct PackedBVH {
        /* BVH nodes storage, one node is 4x int4, and contains two bounding boxes,
-          and child, triangle or object indexes dependening on the node type */
+        * and child, triangle or object indexes dependening on the node type */
        array<int4> nodes; 
        /* object index to BVH node index mapping for instances */
        array<int> object_node; 
@@ -55,12 +55,12 @@ struct PackedBVH {
        /* visibility visibilitys for primitives */
        array<uint> prim_visibility;
        /* mapping from BVH primitive index to true primitive index, as primitives
-          may be duplicated due to spatial splits. -1 for instances. */
+        * may be duplicated due to spatial splits. -1 for instances. */
        array<int> prim_index;
        /* mapping from BVH primitive index, to the object id of that primitive. */
        array<int> prim_object;
        /* quick array to lookup if a node is a leaf, not used for traversal, only
-          for instance BVH merging  */
+        * for instance BVH merging  */
        array<int> is_leaf;
 
        /* index of the root node. */
index e4b88584a33c9290b32501f2a32cbb8ee094dac3..05a674a47a7f5c1278871c7f747a203e39a3a2ec 100644 (file)
@@ -200,7 +200,7 @@ void BVHObjectBinning::split(BVHReference* prims, BVHObjectBinning& left_o, BVHO
        }
 
        /* object medium split if we did not make progress, can happen when all
-          primitives have same centroid */
+        * primitives have same centroid */
        lgeom_bounds = BoundBox::empty;
        rgeom_bounds = BoundBox::empty;
        lcent_bounds = BoundBox::empty;
index ba35ba3fae70dbdfb388badfb61e213f6d515c19..18aafb5f1ff1ceb0635959b64de9ab728d456328 100644 (file)
@@ -1,4 +1,4 @@
- /*
+/*
  * Adapted from code copyright 2009-2010 NVIDIA Corporation
  * Modifications Copyright 2011, Blender Foundation.
  *
index 42dda1180c7318642fec0eb51772079efc32f193..33040f287d10e85dd2572b8fc37fc1b3bb07660f 100644 (file)
@@ -124,7 +124,7 @@ void Device::draw_pixels(device_memory& rgba, int y, int w, int h, int dy, int w
        uint8_t *pixels = (uint8_t*)rgba.data_pointer;
 
        /* for multi devices, this assumes the ineffecient method that we allocate
-          all pixels on the device even though we only render to a subset */
+        * all pixels on the device even though we only render to a subset */
        pixels += 4*y*w;
 
        glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
index 5f422332cd2b75c373506edad725b2eae0a004d0..070b20aec49d457427f5e753adecd130652e34fd 100644 (file)
@@ -226,7 +226,7 @@ public:
        void task_add(DeviceTask& task)
        {
                /* split task into smaller ones, more than number of threads for uneven
-                  workloads where some parts of the image render slower than others */
+                * workloads where some parts of the image render slower than others */
                list<DeviceTask> tasks;
 
                task.split(tasks, TaskScheduler::num_threads()*10);
index 491a63a7cf2f1c87834c17fcbbd7771edcd06c27..357f99145b218c4b4bdada8b5710fba42936d722 100644 (file)
@@ -771,7 +771,7 @@ public:
                        cuda_push_context();
 
                        /* for multi devices, this assumes the ineffecient method that we allocate
-                          all pixels on the device even though we only render to a subset */
+                        * all pixels on the device even though we only render to a subset */
                        size_t offset = sizeof(uint8_t)*4*y*w;
 
                        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pmem.cuPBO);
index 591216a77b934a8a77563aa36a842cd27bcc3e48..e3afe46d2b091472911e96a77e0c28d32cc5177b 100644 (file)
@@ -126,8 +126,10 @@ typedef struct RPCReceive {
 
                                if(len == data_size) {
                                        archive_str = (data.size())? string(&data[0], data.size()): string("");
-                                       /*istringstream archive_stream(archive_str);
-                                       boost::archive::text_iarchive archive(archive_stream);*/
+#if 0
+                                       istringstream archive_stream(archive_str);
+                                       boost::archive::text_iarchive archive(archive_stream);
+#endif
                                        archive_stream = new istringstream(archive_str);
                                        archive = new boost::archive::text_iarchive(*archive_stream);
 
index bb2b852d4e13649bc4b53e5b26403d18d9988eaf..c979065d23acbc3b53cb242c131f00d69922f6af 100644 (file)
@@ -239,7 +239,7 @@ public:
                }
 
                /* we don't check CL_DEVICE_VERSION since for e.g. nvidia sm 1.3 cards this is
-                       1.0 even if the language features are there, just limited shared memory */
+                * 1.0 even if the language features are there, just limited shared memory */
 
                return true;
        }
@@ -344,8 +344,8 @@ public:
        bool compile_kernel(const string& kernel_path, const string& kernel_md5)
        {
                /* we compile kernels consisting of many files. unfortunately opencl
-                  kernel caches do not seem to recognize changes in included files.
-                  so we force recompile on changes by adding the md5 hash of all files */
+                * kernel caches do not seem to recognize changes in included files.
+                * so we force recompile on changes by adding the md5 hash of all files */
                string source = "#include \"kernel.cl\" // " + kernel_md5 + "\n";
                source = path_source_replace_includes(source, kernel_path);
 
index 6c3ade1c531b9f13296ed9d22954ce0e45ba5a66..d99beb8905acf09ebcd86ad8ab7e1f611a684156 100644 (file)
@@ -271,8 +271,8 @@ __device_inline float3 path_radiance_sum(KernelGlobals *kg, PathRadiance *L)
 #ifdef __PASSES__
        if(L->use_light_pass) {
                /* this division is a bit ugly, but means we only have to keep track of
-                  only a single throughput further along the path, here we recover just
-                  the indirect parth that is not influenced by any particular BSDF type */
+                * only a single throughput further along the path, here we recover just
+                * the indirect parth that is not influenced by any particular BSDF type */
                L->direct_emission = safe_divide_color(L->direct_emission, L->direct_throughput);
                L->direct_diffuse += L->indirect_diffuse*L->direct_emission;
                L->direct_glossy += L->indirect_glossy*L->direct_emission;
index 522f9861c35fe5b0f789c9cfef5d3d8c3db56c99..34a44af8b8d974c8a0b18ee6d54280941ca92c6e 100644 (file)
@@ -34,8 +34,8 @@ CCL_NAMESPACE_BEGIN
 #define TRI_NODE_SIZE 3
 
 /* silly workaround for float extended precision that happens when compiling
  without sse support on x86, it results in different results for float ops
  that you would otherwise expect to compare correctly */
* without sse support on x86, it results in different results for float ops
* that you would otherwise expect to compare correctly */
 #if !defined(__i386__) || defined(__SSE__)
 #define NO_EXTENDED_PRECISION
 #else
@@ -160,7 +160,7 @@ __device_inline void bvh_triangle_intersect(KernelGlobals *kg, Intersection *ise
                        if(v >= 0.0f && u + v <= 1.0f) {
 #ifdef __VISIBILITY_FLAG__
                                /* visibility flag test. we do it here under the assumption
-                                  that most triangles are culled by node flags */
+                                * that most triangles are culled by node flags */
                                if(kernel_tex_fetch(__prim_visibility, triAddr) & visibility)
 #endif
                                {
index 2bd0b61b4fad52785dc6ac5c4807a343f5b43078..cc8f1f3323bbe913572e583270385b21685a70e9 100644 (file)
 CCL_NAMESPACE_BEGIN
 
 /* Assertions inside the kernel only work for the CPU device, so we wrap it in
  a macro which is empty for other devices */
* a macro which is empty for other devices */
 
 #define kernel_assert(cond) assert(cond)
 
 /* Texture types to be compatible with CUDA textures. These are really just
  simple arrays and after inlining fetch hopefully revert to being a simple
  pointer lookup. */
* simple arrays and after inlining fetch hopefully revert to being a simple
* pointer lookup. */
 
 template<typename T> struct texture  {
        T fetch(int index)
@@ -43,7 +43,8 @@ template<typename T> struct texture  {
                return data[index];
        }
 
-       /*__m128 fetch_m128(int index)
+#if 0
+       __m128 fetch_m128(int index)
        {
                kernel_assert(index >= 0 && index < width);
                return ((__m128*)data)[index];
@@ -53,7 +54,8 @@ template<typename T> struct texture  {
        {
                kernel_assert(index >= 0 && index < width);
                return ((__m128i*)data)[index];
-       }*/
+       }
+#endif
 
        float interp(float x, int size)
        {
index 881d25ad7ba79d9f4a9ce34bf26636b8efd0db77..f582ace69f0a2b1424cbaaf02b7e5fb7e948de35 100644 (file)
@@ -44,7 +44,7 @@ __device float3 direct_emissive_eval(KernelGlobals *kg, float rando,
                ls->Ng = sd.Ng;
 
                /* no path flag, we're evaluating this for all closures. that's weak but
-                  we'd have to do multiple evaluations otherwise */
+                * we'd have to do multiple evaluations otherwise */
                shader_eval_surface(kg, &sd, rando, 0);
 
                /* evaluate emissive closure */
@@ -145,7 +145,7 @@ __device float3 indirect_emission(KernelGlobals *kg, ShaderData *sd, float t, in
 
        if(!(path_flag & PATH_RAY_MIS_SKIP) && (sd->flag & SD_SAMPLE_AS_LIGHT)) {
                /* multiple importance sampling, get triangle light pdf,
-                  and compute weight with respect to BSDF pdf */
+                * and compute weight with respect to BSDF pdf */
                float pdf = triangle_light_pdf(kg, sd->Ng, sd->I, t);
                float mis_weight = power_heuristic(bsdf_pdf, pdf);
 
@@ -172,7 +172,7 @@ __device float3 indirect_background(KernelGlobals *kg, Ray *ray, int path_flag,
 
        if(!(path_flag & PATH_RAY_MIS_SKIP) && res) {
                /* multiple importance sampling, get background light pdf for ray
-                  direction, and compute weight with respect to BSDF pdf */
+                * direction, and compute weight with respect to BSDF pdf */
                float pdf = background_light_pdf(kg, ray->D);
                float mis_weight = power_heuristic(bsdf_pdf, pdf);
 
index 1f2fc97e6854bf1f8c58f7ed786658137b3d36f1..a99fffbc519e6deb4e9153a887ba037d8c0f3811 100644 (file)
@@ -29,9 +29,9 @@
 CCL_NAMESPACE_BEGIN
 
 /* On the CPU, we pass along the struct KernelGlobals to nearly everywhere in
  the kernel, to access constant data. These are all stored as "textures", but
  these are really just standard arrays. We can't use actually globals because
  multiple renders may be running inside the same process. */
* the kernel, to access constant data. These are all stored as "textures", but
* these are really just standard arrays. We can't use actually globals because
* multiple renders may be running inside the same process. */
 
 #ifdef __KERNEL_CPU__
 
@@ -45,7 +45,7 @@ typedef struct KernelGlobals {
 
 #ifdef __OSL__
        /* On the CPU, we also have the OSL globals here. Most data structures are shared
-          with SVM, the difference is in the shaders and object/mesh attributes. */
+        * with SVM, the difference is in the shaders and object/mesh attributes. */
        OSLGlobals osl;
 #endif
 
@@ -54,9 +54,9 @@ typedef struct KernelGlobals {
 #endif
 
 /* For CUDA, constant memory textures must be globals, so we can't put them
  into a struct. As a result we don't actually use this struct and use actual
  globals and simply pass along a NULL pointer everywhere, which we hope gets
  optimized out. */
* into a struct. As a result we don't actually use this struct and use actual
* globals and simply pass along a NULL pointer everywhere, which we hope gets
* optimized out. */
 
 #ifdef __KERNEL_CUDA__
 
index 2bc5a882ce5bdbf720492d298e0801ce4b385eaf..edc302cd6e38f3a42f2eeaee3a8597463ac973b5 100644 (file)
@@ -64,8 +64,8 @@ __device float3 area_light_sample(float3 axisu, float3 axisv, float randu, float
 __device float3 background_light_sample(KernelGlobals *kg, float randu, float randv, float *pdf)
 {
        /* for the following, the CDF values are actually a pair of floats, with the
-          function value as X and the actual CDF as Y.  The last entry's function
-          value is the CDF total. */
+        * function value as X and the actual CDF as Y.  The last entry's function
+        * value is the CDF total. */
        int res = kernel_data.integrator.pdf_background_res;
        int cdf_count = res + 1;
 
@@ -326,9 +326,9 @@ __device float triangle_light_pdf(KernelGlobals *kg,
 __device int light_distribution_sample(KernelGlobals *kg, float randt)
 {
        /* this is basically std::upper_bound as used by pbrt, to find a point light or
-          triangle to emit from, proportional to area. a good improvement would be to
-          also sample proportional to power, though it's not so well defined with
-          OSL shaders. */
+        * triangle to emit from, proportional to area. a good improvement would be to
+        * also sample proportional to power, though it's not so well defined with
+        * OSL shaders. */
        int first = 0;
        int len = kernel_data.integrator.num_distribution + 1;
 
index bdd147f83d3c9dc2a20b9f47651cea1c2995f2d0..939f3915b6cb7ee49c111f815edcb9de4287c154 100644 (file)
@@ -28,7 +28,7 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 #ifndef __KERNEL_MONTECARLO_CL__
 #define __KERNEL_MONTECARLO_CL__
index 393686bb2031209c4e7cd3a10018c81b7263ae6e..0b662095133c1e1fcd847e13b17d61bfa280aa86 100644 (file)
@@ -17,8 +17,8 @@
  */
 
 /* Optimized CPU kernel entry points. This file is compiled with SSE3
  optimization flags and nearly all functions inlined, while kernel.cpp
  is compiled without for other CPU's. */
* optimization flags and nearly all functions inlined, while kernel.cpp
* is compiled without for other CPU's. */
 
 #ifdef WITH_OPTIMIZED_KERNEL
 
index e41a5a62c1476bc07c4bd4487d81cbbcab7312f2..16fd0499b0017fc74d8354b6f6311768b00ecddd 100644 (file)
@@ -59,7 +59,7 @@ __device_inline void path_state_init(PathState *state)
 __device_inline void path_state_next(KernelGlobals *kg, PathState *state, int label)
 {
        /* ray through transparent keeps same flags from previous ray and is
-          not counted as a regular bounce, transparent has separate max */
+        * not counted as a regular bounce, transparent has separate max */
        if(label & LABEL_TRANSPARENT) {
                state->flag |= PATH_RAY_TRANSPARENT;
                state->transparent_bounce++;
@@ -159,13 +159,13 @@ __device_inline bool shadow_blocked(KernelGlobals *kg, PathState *state, Ray *ra
 #ifdef __TRANSPARENT_SHADOWS__
        if(result && kernel_data.integrator.transparent_shadows) {
                /* transparent shadows work in such a way to try to minimize overhead
-                  in cases where we don't need them. after a regular shadow ray is
-                  cast we check if the hit primitive was potentially transparent, and
-                  only in that case start marching. this gives on extra ray cast for
-                  the cases were we do want transparency.
-                  
-                  also note that for this to work correct, multi close sampling must
-                  be used, since we don't pass a random number to shader_eval_surface */
+                * in cases where we don't need them. after a regular shadow ray is
+                * cast we check if the hit primitive was potentially transparent, and
+                * only in that case start marching. this gives on extra ray cast for
+                * the cases were we do want transparency.
+                *
+                * also note that for this to work correct, multi close sampling must
+                * be used, since we don't pass a random number to shader_eval_surface */
                if(shader_transparent_shadow(kg, &isect)) {
                        float3 throughput = make_float3(1.0f, 1.0f, 1.0f);
                        float3 Pend = ray->P + ray->D*ray->t;
@@ -266,7 +266,7 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
                kernel_write_data_passes(kg, buffer, &L, &sd, sample, state.flag, throughput);
 
                /* blurring of bsdf after bounces, for rays that have a small likelihood
-                  of following this particular path (diffuse, rough glossy) */
+                * of following this particular path (diffuse, rough glossy) */
                if(kernel_data.integrator.filter_glossy != FLT_MAX) {
                        float blur_pdf = kernel_data.integrator.filter_glossy*min_ray_pdf;
 
@@ -305,8 +305,8 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
 #endif
 
                /* path termination. this is a strange place to put the termination, it's
-                  mainly due to the mixed in MIS that we use. gives too many unneeded
-                  shader evaluations, only need emission if we are going to terminate */
+                * mainly due to the mixed in MIS that we use. gives too many unneeded
+                * shader evaluations, only need emission if we are going to terminate */
                float probability = path_state_terminate_probability(kg, &state, throughput);
                float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
 
index 72d368116264b4d5e26550e1151a454abf7d242a..64747bcb42e1c28776e0cc6c3281f16f34908376 100644 (file)
@@ -28,7 +28,7 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 #ifndef __KERNEL_PROJECTION_CL__
 #define __KERNEL_PROJECTION_CL__
index 6d15100f8a32870c3d19bd101167d6055e2f2818..008ef2061a25d09cea076043df042a95fef2b2a9 100644 (file)
@@ -23,8 +23,8 @@ typedef uint RNG;
 #ifdef __SOBOL__
 
 /* skip initial numbers that are not as well distributed, especially the
  first sequence is just 0 everywhere, which can be problematic for e.g.
  path termination */
* first sequence is just 0 everywhere, which can be problematic for e.g.
* path termination */
 #define SOBOL_SKIP 64
 
 /* High Dimensional Sobol */
@@ -66,7 +66,7 @@ __device uint sobol_inverse(uint i)
 }
 
 /* multidimensional sobol with generator matrices
  dimension 0 and 1 are equal to van_der_corput() and sobol() respectively */
* dimension 0 and 1 are equal to van_der_corput() and sobol() respectively */
 __device uint sobol_dimension(KernelGlobals *kg, int index, int dimension)
 {
        uint result = 0;
index 674c3b52539f50f7ccaeba4d059a9f1c460fb4e0..384c3a8a506468d44a969872603b9163f6c95708 100644 (file)
@@ -208,7 +208,7 @@ __device float4 triangle_motion_vector(KernelGlobals *kg, ShaderData *sd)
                motion_post = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_VERTEX, offset_post, NULL, NULL);
 
        /* object motion. note that depending on the mesh having motion vectors, this
-          transformation was set match the world/object space of motion_pre/post */
+        * transformation was set match the world/object space of motion_pre/post */
        Transform tfm;
        
        tfm = object_fetch_transform(kg, sd->object, TIME_INVALID, OBJECT_TRANSFORM_MOTION_PRE);
@@ -220,7 +220,7 @@ __device float4 triangle_motion_vector(KernelGlobals *kg, ShaderData *sd)
        float3 P;
 
        /* camera motion, for perspective/orthographic motion.pre/post will be a
-          world-to-raster matrix, for panorama it's world-to-camera */
+        * world-to-raster matrix, for panorama it's world-to-camera */
        if (kernel_data.cam.type != CAMERA_PANORAMA) {
                tfm = kernel_data.cam.worldtoraster;
                P = transform_perspective(&tfm, sd->P);
index de5d29a3c1818a726c920220f54b563565a3088d..dfd0a23fe1e952ec5a7985bf65d125bd4f083298 100644 (file)
@@ -17,7 +17,7 @@
 float fresnel_dielectric(vector Incoming, normal Normal, float eta)
 {
        /* compute fresnel reflectance without explicitly computing
-          the refracted direction */
+        * the refracted direction */
        float c = fabs(dot(Incoming, Normal));
        float g = eta * eta - 1 + c * c;
        float result;
index 12f3a377ef4fcd7d1edac34573d7fc37c24d5120..a1574d6e0db5cb03963aa85eb3a1a9e53c4b012a 100644 (file)
@@ -65,7 +65,7 @@ void OSLRenderServices::thread_init(KernelGlobals *kernel_globals_)
 bool OSLRenderServices::get_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time)
 {
        /* 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. */
+        * a concept of shader space, so we just use object space for both. */
        if (xform) {
                KernelGlobals *kg = kernel_globals;
                const ShaderData *sd = (const ShaderData *)xform;
@@ -86,7 +86,7 @@ bool OSLRenderServices::get_matrix(OSL::Matrix44 &result, OSL::TransformationPtr
 bool OSLRenderServices::get_inverse_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time)
 {
        /* 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. */
+        * a concept of shader space, so we just use object space for both. */
        if (xform) {
                KernelGlobals *kg = kernel_globals;
                const ShaderData *sd = (const ShaderData *)xform;
@@ -305,11 +305,11 @@ void *OSLRenderServices::get_pointcloud_attr_query(ustring *attr_names,
        AttrQuery &query = m_attr_queries.back();
 
        /* make space for what we need. the only reason to use
-          std::vector is to skip the delete */
+        * std::vector is to skip the delete */
        query.attr_names.resize(nattrs);
        query.attr_partio_types.resize(nattrs);
        /* capacity will keep the length of the smallest array passed
-          to the query. Just to prevent buffer overruns */
+        * to the query. Just to prevent buffer overruns */
        query.capacity = -1;
 
        for (int i = 0; i < nattrs; ++i) {
@@ -323,7 +323,7 @@ void *OSLRenderServices::get_pointcloud_attr_query(ustring *attr_names,
                        query.capacity = min(query.capacity, (int)attr_types[i].numelements());
 
                /* convert the OSL (OIIO) type to the equivalent Partio type so
-                  we can do a fast check at query time. */
+                * we can do a fast check at query time. */
                if (element_type == TypeDesc::TypeFloat) {
                        query.attr_partio_types[i] = Partio::FLOAT;
                }
@@ -359,7 +359,7 @@ int OSLRenderServices::pointcloud(ustring filename, const OSL::Vec3 &center, flo
                                   int max_points, void *_attr_query, void **attr_outdata)
 {
        /* todo: this code has never been tested, and most likely does not
-          work. it's based on the example code in OSL */
+        * work. it's based on the example code in OSL */
 
 #ifdef WITH_PARTIO
        /* query Partio for this pointcloud lookup using cached attr_query */
@@ -374,7 +374,7 @@ int OSLRenderServices::pointcloud(ustring filename, const OSL::Vec3 &center, flo
        Partio::ParticlesData *cloud = get_pointcloud(filename);
 
        /* now we have to look up all the attributes in the file. we can't do this
-          before hand cause we never know what we are going to load. */
+        * before hand cause we never know what we are going to load. */
        int nattrs = attr_query->attr_names.size();
        Partio::ParticleAttribute *attr = (Partio::ParticleAttribute *)alloca(sizeof(Partio::ParticleAttribute) * nattrs);
 
@@ -414,8 +414,8 @@ int OSLRenderServices::pointcloud(ustring filename, const OSL::Vec3 &center, flo
                }
                else {
                        /* note we make a single call per attribute, we don't loop over the
-                          points. Partio does it, so it is there that we have to care about
-                          performance */
+                        * points. Partio does it, so it is there that we have to care about
+                        * performance */
                        cloud->data(attr[j], count, &indices[0], true, attr_outdata[j]);
                }
        }
index 88735c073c25d058d0685c1bf4c33dba9cc052d9..e637b53ab78d27eeba76d04cdb704ff38dfbd206 100644 (file)
@@ -76,14 +76,14 @@ private:
 
 #ifdef WITH_PARTIO
        /* OSL gets pointers to this but its definition is private.
-          right now it only caches the types already converted to
-          Partio constants. this is what get_pointcloud_attr_query
-          returns */
+        * right now it only caches the types already converted to
+        * Partio constants. this is what get_pointcloud_attr_query
+        * returns */
        struct AttrQuery {
                /* names of the attributes to query */
                std::vector<ustring> attr_names;
                /* types as (enum Partio::ParticleAttributeType) of the
-                  attributes in the query */
+                * attributes in the query */
                std::vector<int> attr_partio_types;
                /* for sanity checks, capacity of the output arrays */
                int capacity;
index 18c1da73fbd8877496adbaba309aa5fde0d39fce..ba78a93f54fc80a88ea5ad65e23a525adf96d9fe 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __OSL_BSDF_H__
 #define __OSL_BSDF_H__
index 2e9343647b84e456f7697c5085af6b2753f60806..40249dbe9c6cfd78cdaffe86bfc22e14e2d79ecf 100644 (file)
@@ -28,7 +28,7 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 #ifndef __BSDF_ASHIKHMIN_VELVET_H__
 #define __BSDF_ASHIKHMIN_VELVET_H__
index e8a002cb84c58238aff0f48c7153d3650b52e642..45e82a566c07831bed15cb5ed858f813f3f3f6e1 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_DIFFUSE_H__
 #define __BSDF_DIFFUSE_H__
index 8771578a2fd6c426cec0b818b868b91796a3c4ed..01e3acb76e83cdfa00e39cb7083d5609ad8f4767 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_MICROFACET_H__
 #define __BSDF_MICROFACET_H__
index f00b72c4869e70dc93a74846ddf378fae75c2d70..09b4e0e48f0da42a8b03fe0f0d14f6ee5f89df32 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_REFLECTION_H__
 #define __BSDF_REFLECTION_H__
index 07ef8633e0dfed0939b144ff8148973e7cdd297f..c9c268999c0ea482dba7fdfff5be05668f30c5e3 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_REFRACTION_H__
 #define __BSDF_REFRACTION_H__
index 4425c4bf1041e77b0d1bf716e955fb1dea4ab805..511836cdfa2a286b84a285a03beb4f274e2681ba 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_TRANSPARENT_H__
 #define __BSDF_TRANSPARENT_H__
index d46baf099a6c13da3b30f10660d32e1363bc2b18..86bca69425d7710c84eaca355d415d9c69f3d221 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_WARD_H__
 #define __BSDF_WARD_H__
index 21e5018c4896b846939c6adb740b2f8ef8764b13..6193d81c244e78fddc51c8ca6b26ba0e24cca32e 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #ifndef __BSDF_WESTIN_H__
 #define __BSDF_WESTIN_H__
index 0b0218674b8b0cd7dd738a643b93987d7627b72c..9a906f82963753eca36fce630055727978141793 100644 (file)
@@ -1,34 +1,34 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Adapted from Open Shading Language with this license:
+ *
+ * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+ * All Rights Reserved.
+ *
+ * Modifications Copyright 2011, Blender Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sony Pictures Imageworks nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 CCL_NAMESPACE_BEGIN
 
index 8409e83d94ecb07ffd99928019e44be7f9b956b4..935504026ef60e41832447802acd28a845fef30b 100644 (file)
@@ -374,7 +374,7 @@ __device void svm_node_mix_closure(ShaderData *sd, float *stack,
 {
 #ifdef __MULTI_CLOSURE__
        /* fetch weight from blend input, previous mix closures,
-          and write to stack to be used by closure nodes later */
+        * and write to stack to be used by closure nodes later */
        uint weight_offset, in_weight_offset, weight1_offset, weight2_offset;
        decode_node_uchar4(node.y, &weight_offset, &in_weight_offset, &weight1_offset, &weight2_offset);
 
@@ -387,8 +387,8 @@ __device void svm_node_mix_closure(ShaderData *sd, float *stack,
                stack_store_float(stack, weight2_offset, in_weight*weight);
 #else
        /* pick a closure and make the random number uniform over 0..1 again.
-          closure 1 starts on the next node, for closure 2 the start is at an
-          offset from the current node, so we jump */
+        * closure 1 starts on the next node, for closure 2 the start is at an
+        * offset from the current node, so we jump */
        uint weight_offset = node.y;
        uint node_jump = node.z;
        float weight = stack_load_float(stack, weight_offset);
@@ -410,8 +410,8 @@ __device void svm_node_add_closure(ShaderData *sd, float *stack, uint unused,
        /* nothing to do, handled in compiler */
 #else
        /* pick one of the two closures with probability 0.5. sampling quality
-          is not going to be great, for that we'd need to evaluate the weights
-          of the two closures being added */
+        * is not going to be great, for that we'd need to evaluate the weights
+        * of the two closures being added */
        float weight = 0.5f;
 
        if(*randb < weight) {
index 388f006c40f40d7cf139414ea7142275aad43f72..3b2b9204d864ed81b09c629af492f93fb390aef7 100644 (file)
@@ -92,13 +92,13 @@ __device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
        float4 r;
 
        /* not particularly proud of this massive switch, what are the
-          alternatives?
-          - use a single big 1D texture, and do our own lookup/filtering
-          - group by size and use a 3d texture, performance impact
-          - group into larger texture with some padding for correct lerp
-
-          also note that cuda has 128 textures limit, we use 100 now, since
-          we still need some for other storage */
+        * alternatives?
+        * - use a single big 1D texture, and do our own lookup/filtering
+        * - group by size and use a 3d texture, performance impact
+        * - group into larger texture with some padding for correct lerp
+        *
+        * also note that cuda has 128 textures limit, we use 100 now, since
+        * we still need some for other storage */
 
        switch(id) {
                case 0: r = kernel_tex_image_interp(__tex_image_000, x, y); break;
index 1d3ace061ab4ca9b1c46ac1642bde7fb2eb783b5..22f3187943ceccc0e43bab714409b4a29ddaef0a 100644 (file)
@@ -28,7 +28,7 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 CCL_NAMESPACE_BEGIN
 
index da74654f25e7af7e5a809d51324340c100fe8258..d85826211321b640beb71235976c3baddf1f0cdb 100644 (file)
@@ -152,7 +152,7 @@ __device float voronoi_CrS(float3 p) { return 2.0f*voronoi_Cr(p) - 1.0f; }
 __device float noise_basis(float3 p, NodeNoiseBasis basis)
 {
        /* Only Perlin enabled for now, others break CUDA compile by making kernel
-          too big, with compile using > 4GB, due to everything being inlined. */
+        * too big, with compile using > 4GB, due to everything being inlined. */
 
 #if 0
        if(basis == NODE_NOISE_PERLIN)
index 86cb2dcc24e32fe5a87b0fcfe773872cfc1af0af..10e9c5de3529855e3a677b558f1c4e7ad3f4d03f 100644 (file)
@@ -19,7 +19,7 @@
 CCL_NAMESPACE_BEGIN
 
 /* note: the interfaces here are just as an example, need to figure
  out the right functions and parameters to use */
* out the right functions and parameters to use */
 
 /* ISOTROPIC VOLUME CLOSURE */
 
index 77ad4a5a4b05e4f1936d1e0dc44f0bd4d9d199cc..78712ed89ef1318fa3c979400920bfb96b899350 100644 (file)
@@ -35,7 +35,7 @@ class Device;
 struct float4;
 
 /* Buffer Parameters
  Size of render buffer and how it fits in the full image (border render). */
* Size of render buffer and how it fits in the full image (border render). */
 
 class BufferParams {
 public:
@@ -98,8 +98,8 @@ public:
        /* buffer parameters */
        BufferParams params;
        /* dimensions for how much of the buffer is actually ready for display.
-          with progressive render we can be using only a subset of the buffer.
-          if these are zero, it means nothing can be drawn yet */
+        * with progressive render we can be using only a subset of the buffer.
+        * if these are zero, it means nothing can be drawn yet */
        int draw_width, draw_height;
        /* draw alpha channel? */
        bool transparent;
index 878aa87510e9056ea1cbdb10b7cdc53fbf76e2b2..035821faddeb6c3d03c99c007bc331c4ceed06fa 100644 (file)
@@ -142,7 +142,7 @@ void Pass::add(PassType type, vector<Pass>& passes)
        passes.push_back(pass);
 
        /* order from by components, to ensure alignment so passes with size 4
-          come first and then passes with size 1 */
+        * come first and then passes with size 1 */
        sort(passes.begin(), passes.end(), compare_pass_order);
 
        if(pass.divide_type != PASS_NONE)
index a0e7af6610012b9c6ae34aa78788adfcd83a2161..34c8879aa1f8952e11ea77c0db6610ecabd2f733 100644 (file)
@@ -375,8 +375,8 @@ void ShaderGraph::break_cycles(ShaderNode *node, vector<bool>& visited, vector<b
 void ShaderGraph::clean()
 {
        /* we do two things here: find cycles and break them, and remove unused
-          nodes that don't feed into the output. how cycles are broken is
-          undefined, they are invalid input, the important thing is to not crash */
+        * nodes that don't feed into the output. how cycles are broken is
+        * undefined, they are invalid input, the important thing is to not crash */
 
        vector<bool> removed(nodes.size(), false);
        vector<bool> visited(nodes.size(), false);
@@ -495,7 +495,7 @@ void ShaderGraph::bump_from_displacement()
        copy_nodes(nodes_displace, nodes_dy);
 
        /* mark nodes to indicate they are use for bump computation, so
-          that any texture coordinates are shifted by dx/dy when sampling */
+        * that any texture coordinates are shifted by dx/dy when sampling */
        foreach(NodePair& pair, nodes_center)
                pair.second->bump = SHADER_BUMP_CENTER;
        foreach(NodePair& pair, nodes_dx)
@@ -516,15 +516,15 @@ void ShaderGraph::bump_from_displacement()
        connect(out_dy, bump->input("SampleY"));
 
        /* connect bump output to normal input nodes that aren't set yet. actually
-          this will only set the normal input to the geometry node that we created
-          and connected to all other normal inputs already. */
+        * this will only set the normal input to the geometry node that we created
+        * and connected to all other normal inputs already. */
        foreach(ShaderNode *node, nodes)
                foreach(ShaderInput *input, node->inputs)
                        if(!input->link && input->default_value == ShaderInput::NORMAL)
                                connect(bump->output("Normal"), input);
        
        /* finally, add the copied nodes to the graph. we can't do this earlier
-          because we would create dependency cycles in the above loop */
+        * because we would create dependency cycles in the above loop */
        foreach(NodePair& pair, nodes_center)
                add(pair.second);
        foreach(NodePair& pair, nodes_dx)
index 6417d0e2103583da65645c08ffd3cba7617123cb..dc20dbdbea2d143a64185356cd27ff2f2917f1cf 100644 (file)
@@ -66,7 +66,7 @@ static bool is_float_image(const string& filename)
 
                if(in->open(filename, spec)) {
                        /* check the main format, and channel formats;
-                          if any take up more than one byte, we'll need a float texture slot */
+                        * if any take up more than one byte, we'll need a float texture slot */
                        if(spec.format.basesize() > 1)
                                is_float = true;
 
@@ -171,8 +171,8 @@ void ImageManager::remove_image(const string& filename)
                        assert(images[slot]->users >= 0);
 
                        /* don't remove immediately, rather do it all together later on. one of
-                          the reasons for this is that on shader changes we add and remove nodes
-                          that use them, but we do not want to reload the image all the time. */
+                        * the reasons for this is that on shader changes we add and remove nodes
+                        * that use them, but we do not want to reload the image all the time. */
                        if(images[slot]->users == 0)
                                need_update = true;
 
@@ -189,8 +189,8 @@ void ImageManager::remove_image(const string& filename)
                                assert(float_images[slot]->users >= 0);
 
                                /* don't remove immediately, rather do it all together later on. one of
-                                  the reasons for this is that on shader changes we add and remove nodes
-                                  that use them, but we do not want to reload the image all the time. */
+                                * the reasons for this is that on shader changes we add and remove nodes
+                                * that use them, but we do not want to reload the image all the time. */
                                if(float_images[slot]->users == 0)
                                        need_update = true;
 
@@ -483,7 +483,7 @@ void ImageManager::device_update(Device *device, DeviceScene *dscene, Progress&
 void ImageManager::device_pack_images(Device *device, DeviceScene *dscene, Progress& progess)
 {
        /* for OpenCL, we pack all image textures inside a single big texture, and
-          will do our own interpolation in the kernel */
+        * will do our own interpolation in the kernel */
        size_t size = 0;
 
        for(size_t slot = 0; slot < images.size(); slot++) {
index 1bf1cde4a1ce202b7fce551388318d59bb17c28c..e918de990c212ea17a5c1d0620dc19e785c58075 100644 (file)
@@ -362,7 +362,7 @@ void LightManager::device_update_background(Device *device, DeviceScene *dscene,
                float cdf_total = cond_cdf[i * cdf_count + res - 1].y + cond_cdf[i * cdf_count + res - 1].x / res;
 
                /* stuff the total into the brightness value for the last entry, because
-                  we are going to normalize the CDFs to 0.0 to 1.0 afterwards */
+                * we are going to normalize the CDFs to 0.0 to 1.0 afterwards */
                cond_cdf[i * cdf_count + res].x = cdf_total;
 
                if(cdf_total > 0.0f)
index cabbd5760c264da50e2c5967ae498c0ac32eb5e5..8f5f2647ebf2941f91d87b91cad376de73e58e17 100644 (file)
@@ -474,7 +474,7 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
                AttributeRequestSet& attributes = mesh_attributes[i];
 
                /* todo: we now store std and name attributes from requests even if
-                  they actually refer to the same mesh attributes, optimize */
+                * they actually refer to the same mesh attributes, optimize */
                foreach(AttributeRequest& req, attributes.requests) {
                        Attribute *mattr = mesh->attributes.find(req);
 
@@ -493,7 +493,7 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
                        }
 
                        /* we abuse AttributeRequest to pass on info like element and
-                          offset, it doesn't really make sense but is convenient */
+                        * offset, it doesn't really make sense but is convenient */
 
                        /* store element and type */
                        if(mattr->element == Attribute::VERTEX)
@@ -528,7 +528,7 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
                        }
 
                        /* mesh vertex/triangle index is global, not per object, so we sneak
-                          a correction for that in here */
+                        * a correction for that in here */
                        if(req.element == ATTR_ELEMENT_VERTEX)
                                req.offset -= mesh->vert_offset;
                        else if(mattr->element == Attribute::FACE)
index 259a0d25bccdb505f8cc454a4c76c4c534bd8a46..376a7911fc909a0fdbf361738f389d23f12af5a7 100644 (file)
@@ -89,7 +89,7 @@ void Object::apply_transform()
        Transform ntfm = transform_transpose(transform_inverse(tfm));
 
        /* we keep normals pointing in same direction on negative scale, notify
-          mesh about this in it (re)calculates normals */
+        * mesh about this in it (re)calculates normals */
        if(transform_negative_scale(tfm))
                mesh->transform_negative_scaled = true;
 
@@ -161,7 +161,7 @@ void ObjectManager::device_update_transforms(Device *device, DeviceScene *dscene
                Transform itfm = transform_inverse(tfm);
 
                /* compute surface area. for uniform scale we can do avoid the many
-                  transform calls and share computation for instances */
+                * transform calls and share computation for instances */
                /* todo: correct for displacement, and move to a better place */
                float uniform_scale;
                float surface_area = 0.0f;
@@ -206,8 +206,8 @@ void ObjectManager::device_update_transforms(Device *device, DeviceScene *dscene
 
                if(need_motion == Scene::MOTION_PASS) {
                        /* motion transformations, is world/object space depending if mesh
-                          comes with deformed position in object space, or if we transform
-                          the shading point in world space */
+                        * comes with deformed position in object space, or if we transform
+                        * the shading point in world space */
                        Transform mtfm_pre = ob->motion.pre;
                        Transform mtfm_post = ob->motion.post;
 
index b0173334c76c97f5e66f42e4c3283ce0956be3ea..04af9b48280186dbb4b351b5acdf8ead20581695 100644 (file)
@@ -167,7 +167,7 @@ string OSLCompiler::compatible_name(const char *name)
 bool OSLCompiler::node_skip_input(ShaderNode *node, ShaderInput *input)
 {
        /* exception for output node, only one input is actually used
-          depending on the current shader type */
+        * depending on the current shader type */
 
        if(node->name == ustring("output")) {
                if(strcmp(input->name, "Surface") == 0 && current_type != SHADER_TYPE_SURFACE)
index 173d73ea2c77f460c6ca31d08cbbf886812ce797..a9f7e5beb567fc73466b9f097fcd2a93d9dc6485 100644 (file)
@@ -116,8 +116,8 @@ bool Session::ready_to_reset()
 void Session::reset_gpu(BufferParams& buffer_params, int samples)
 {
        /* block for buffer acces and reset immediately. we can't do this
-          in the thread, because we need to allocate an OpenGL buffer, and
-          that only works in the main thread */
+        * in the thread, because we need to allocate an OpenGL buffer, and
+        * that only works in the main thread */
        thread_scoped_lock display_lock(display->mutex);
        thread_scoped_lock buffers_lock(buffers->mutex);
 
@@ -140,10 +140,10 @@ bool Session::draw_gpu(BufferParams& buffer_params)
        /* first check we already rendered something */
        if(gpu_draw_ready) {
                /* then verify the buffers have the expected size, so we don't
-                  draw previous results in a resized window */
+                * draw previous results in a resized window */
                if(!buffer_params.modified(display->params)) {
                        /* for CUDA we need to do tonemapping still, since we can
-                          only access GL buffers from the main thread */
+                        * only access GL buffers from the main thread */
                        if(gpu_need_tonemap) {
                                thread_scoped_lock buffers_lock(buffers->mutex);
                                tonemap();
@@ -185,7 +185,7 @@ void Session::run_gpu()
                }
                else {
                        /* if in interactive mode, and we are either paused or done for now,
-                          wait for pause condition notify to wake up again */
+                        * wait for pause condition notify to wake up again */
                        thread_scoped_lock pause_lock(pause_mutex);
 
                        if(pause || no_tiles) {
@@ -224,8 +224,8 @@ void Session::run_gpu()
 
                if(!no_tiles) {
                        /* buffers mutex is locked entirely while rendering each
-                          sample, and released/reacquired on each iteration to allow
-                          reset and draw in between */
+                        * sample, and released/reacquired on each iteration to allow
+                        * reset and draw in between */
                        thread_scoped_lock buffers_lock(buffers->mutex);
 
                        /* update status and timing */
@@ -294,7 +294,7 @@ bool Session::draw_cpu(BufferParams& buffer_params)
        /* first check we already rendered something */
        if(display->draw_ready()) {
                /* then verify the buffers have the expected size, so we don't
-                  draw previous results in a resized window */
+                * draw previous results in a resized window */
                if(!buffer_params.modified(display->params)) {
                        display->draw(device);
 
@@ -334,7 +334,7 @@ void Session::run_cpu()
                }
                else {
                        /* if in interactive mode, and we are either paused or done for now,
-                          wait for pause condition notify to wake up again */
+                        * wait for pause condition notify to wake up again */
                        thread_scoped_lock pause_lock(pause_mutex);
 
                        if(pause || no_tiles) {
@@ -362,8 +362,8 @@ void Session::run_cpu()
 
                if(!no_tiles) {
                        /* buffers mutex is locked entirely while rendering each
-                          sample, and released/reacquired on each iteration to allow
-                          reset and draw in between */
+                        * sample, and released/reacquired on each iteration to allow
+                        * reset and draw in between */
                        thread_scoped_lock buffers_lock(buffers->mutex);
 
                        /* update scene */
@@ -406,7 +406,7 @@ void Session::run_cpu()
                        }
                        else if(need_tonemap) {
                                /* tonemap only if we do not reset, we don't we don't
-                                  want to show the result of an incomplete sample*/
+                                * wan't to show the result of an incomplete sample*/
                                tonemap();
                        }
 
@@ -535,8 +535,8 @@ void Session::update_scene()
        progress.set_status("Updating Scene");
 
        /* update camera if dimensions changed for progressive render. the camera
-          knows nothing about progressive or cropped rendering, it just gets the
-          image dimensions passed in */
+        * knows nothing about progressive or cropped rendering, it just gets the
+        * image dimensions passed in */
        Camera *cam = scene->camera;
        int width = tile_manager.state.buffer.full_width;
        int height = tile_manager.state.buffer.full_height;
index f50709146efd68d36cde87970106c1a630d13a2e..fae1d6bd81ca32265d1b3461d9186dce4b9ebcfb 100644 (file)
@@ -81,9 +81,9 @@ void Shader::tag_update(Scene *scene)
                scene->light_manager->need_update = true;
 
        /* get requested attributes. this could be optimized by pruning unused
-          nodes here already, but that's the job of the shader manager currently,
-          and may not be so great for interactive rendering where you temporarily
-          disconnect a node */
+        * nodes here already, but that's the job of the shader manager currently,
+        * and may not be so great for interactive rendering where you temporarily
+        * disconnect a node */
        AttributeRequestSet prev_attributes = attributes;
 
        attributes.clear();
@@ -91,7 +91,7 @@ void Shader::tag_update(Scene *scene)
                node->attributes(&attributes);
        
        /* compare if the attributes changed, mesh manager will check
-          need_update_attributes, update the relevant meshes and clear it. */
+        * need_update_attributes, update the relevant meshes and clear it. */
        if(attributes.modified(prev_attributes)) {
                need_update_attributes = true;
                scene->mesh_manager->need_update = true;
index 48d517ce21aa9b8d46734f2b2efc2e5d4051bee1..02788008060200066c7ba77929e4b90dce74c3bc 100644 (file)
@@ -53,8 +53,8 @@ public:
        ShaderGraph *graph;
 
        /* shader graph with auto bump mapping included, we compile two shaders,
-          with and without bump,  because the displacement method is a mesh
-          level setting, so we need to handle both */
+        * with and without bump,  because the displacement method is a mesh
+        * level setting, so we need to handle both */
        ShaderGraph *graph_bump;
 
        /* sampling */
@@ -109,7 +109,7 @@ public:
        int get_shader_id(uint shader, Mesh *mesh = NULL, bool smooth = false);
 
        /* add default shaders to scene, to use as default for things that don't
-          have any shader assigned explicitly */
+        * have any shader assigned explicitly */
        static void add_default(Scene *scene);
 
 protected:
index 1ff3ac20d5051a55d6b3bfbf31504f6353ee5333..e160f1c93af9a52098acf9340f128d207f09f1f2 100644 (file)
@@ -251,11 +251,11 @@ void SVMCompiler::stack_link(ShaderInput *input, ShaderOutput *output)
 void SVMCompiler::stack_clear_users(ShaderNode *node, set<ShaderNode*>& done)
 {
        /* optimization we should add:
-          find and lower user counts for outputs for which all inputs are done.
-          this is done before the node is compiled, under the assumption that the
-          node will first load all inputs from the stack and then writes its
-          outputs. this used to work, but was disabled because it gave trouble
-          with inputs getting stack positions assigned */
+        * find and lower user counts for outputs for which all inputs are done.
+        * this is done before the node is compiled, under the assumption that the
+        * node will first load all inputs from the stack and then writes its
+        * outputs. this used to work, but was disabled because it gave trouble
+        * with inputs getting stack positions assigned */
 
        foreach(ShaderInput *input, node->inputs) {
                ShaderOutput *output = input->link;
@@ -418,8 +418,8 @@ void SVMCompiler::generate_closure(ShaderNode *node, set<ShaderNode*>& done)
                        add_node(NODE_ADD_CLOSURE, 0, 0, 0);
 
                /* generate code for closure 1
-                  note we backup all compiler state and restore it afterwards, so one
-                  closure choice doesn't influence the other*/
+                * note we backup all compiler state and restore it afterwards, so one
+                * closure choice doesn't influence the other*/
                if(cl1in->link) {
                        StackBackup backup;
                        stack_backup(backup, done);
@@ -448,7 +448,7 @@ void SVMCompiler::generate_closure(ShaderNode *node, set<ShaderNode*>& done)
                        add_node(NODE_END, 0, 0, 0);
 
                /* set jump for mix node, -1 because offset is already
-                  incremented when this jump is added to it */
+                * incremented when this jump is added to it */
                svm_nodes[mix_offset].z = cl2_offset - mix_offset - 1;
 
                done.insert(node);
@@ -482,9 +482,9 @@ void SVMCompiler::generate_closure(ShaderNode *node, set<ShaderNode*>& done)
 void SVMCompiler::generate_multi_closure(ShaderNode *node, set<ShaderNode*>& done, uint in_offset)
 {
        /* todo: the weaks point here is that unlike the single closure sampling 
-          we will evaluate all nodes even if they are used as input for closures
-          that are unused. it's not clear what would be the best way to skip such
-          nodes at runtime, especially if they are tangled up  */
+        * we will evaluate all nodes even if they are used as input for closures
+        * that are unused. it's not clear what would be the best way to skip such
+        * nodes at runtime, especially if they are tangled up  */
 
        if(node->name == ustring("mix_closure") || node->name == ustring("add_closure")) {
                ShaderInput *fin = node->input("Fac");
index 640c30eba9d4b1ed04be12e1e3318931e23fade0..07f89b2a371b155e2962b53188ad40a112f94f04 100644 (file)
@@ -82,7 +82,7 @@ static float pseudoValence(SubdVert *vert)
 
        if(vert->is_boundary()) {
                /* we treat boundary verts as being half a closed mesh. corners are
-                  special case. n = 4 for corners and n = 2*(n-1) for boundaries. */
+                * special case. n = 4 for corners and n = 2*(n-1) for boundaries. */
                if(valence == 2) return 4;
                return (valence - 1)*2;
        }
@@ -481,10 +481,11 @@ void SubdAccBuilder::computeInteriorStencil(SubdFaceRing *ring, GregoryAccStenci
                        }
 
                        /* this change makes the triangle boundaries smoother, but distorts the quads next to them */
-                       /*if(ring->is_triangle() || SubdFaceRing::is_triangle(edge->pair->face))
-                       {
+#if 0
+                       if(ring->is_triangle() || SubdFaceRing::is_triangle(edge->pair->face)) {
                                y *= 4.0f / 3.0f;
-                       }*/
+                       }
+#endif
 
                        stencil->get(interior1Indices[primitiveOffset+v]) = stencil->get(edge1Indices[primitiveOffset+v]);
                        stencil->get(interior1Indices[primitiveOffset+v]) += x;
@@ -539,8 +540,10 @@ void SubdAccBuilder::computeInteriorStencil(SubdFaceRing *ring, GregoryAccStenci
                        }
 
                        /* this change makes the triangle boundaries smoother, but distorts the quads next to them. */
-                       /*if(ring->is_triangle() || SubdFaceRing::is_triangle(edge->pair->face))
-                               y *= 4.0f / 3.0f;*/
+#if 0
+                       if(ring->is_triangle() || SubdFaceRing::is_triangle(edge->pair->face))
+                               y *= 4.0f / 3.0f;
+#endif
 
                        stencil->get(interior2Indices[primitiveOffset+v]) = stencil->get(edge2Indices[primitiveOffset+v]);
                        stencil->get(interior2Indices[primitiveOffset+v]) += x;
index 6e24bb410b578f1913c1635022ce8f665e0f8ac9..583abb2b58a43404637aeff715f706788cfe0dcc 100644 (file)
@@ -81,9 +81,9 @@ void EdgeDice::stitch_triangles(vector<int>& outer, vector<int>& inner)
                return; // XXX avoid crashes for Mu or Mv == 1, missing polygons
 
        /* stitch together two arrays of verts with triangles. at each step,
-          we compare using the next verts on both sides, to find the split
-          direction with the smallest diagonal, and use that in order to keep
-          the triangle shape reasonable. */
+        * we compare using the next verts on both sides, to find the split
+        * direction with the smallest diagonal, and use that in order to keep
+        * the triangle shape reasonable. */
        for(size_t i = 0, j = 0; i+1 < inner.size() || j+1 < outer.size();) {
                int v0, v1, v2;
 
@@ -354,8 +354,8 @@ void TriangleDice::add_grid(SubPatch& sub, EdgeFactors& ef, int M)
        // XXX normals are flipped, why?
 
        /* grid is constructed starting from the outside edges, and adding
-          progressively smaller inner triangles that connected to the outer
-          one, until M = 1 or 2, the we fill up the last part. */
+        * progressively smaller inner triangles that connected to the outer
+        * one, until M = 1 or 2, the we fill up the last part. */
        vector<int> outer_u, outer_v, outer_w;
        int m;
 
index cbd12e60da049aff52652523eb9762d3c86ae0f4..66eab02231cd8bf2bd5b96f30fe09048d4ce65dc 100644 (file)
@@ -82,8 +82,8 @@ int SubdFaceRing::vert_index(SubdVert *vertex)
 void SubdFaceRing::evaluate_stencils(float3 *P, StencilMask *mask, int num)
 {
        /* first we sort verts by id. this way verts will always be added
-          in the same order to ensure the exact same float ops happen for control
-          points of other patches, so we get water-tight patches */
+        * in the same order to ensure the exact same float ops happen for control
+        * points of other patches, so we get water-tight patches */
        int num_verts = m_verts.size();
 
        vector<int> vmap(num_verts);
@@ -161,8 +161,8 @@ bool SubdFaceRing::is_quad(SubdFace *face)
 bool SubdFaceRing::is_boundary(SubdFace *face)
 {
        /* note that face->is_boundary() returns a different result. That function
-          returns true when any of the *edges* are on the boundary. however, this
-          function returns true if any of the face *verts* are on the boundary.  */
+        * returns true when any of the *edges* are on the boundary. however, this
+        * function returns true if any of the face *verts* are on the boundary.  */
 
        for(SubdFace::EdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
                SubdEdge *edge = it.current();
index f81a11ba9dabe7d244f980fa373ff8ac47cb28c2..2960022fd8dae35d1c5faa12022b7feb4117ec0b 100644 (file)
@@ -326,8 +326,8 @@ bool cuLibraryInit()
        CUDA_LIBRARY_FIND(cuCtxGetLimit);
 
        /* functions which changed 3.1 -> 3.2 for 64 bit stuff, the cuda library
-          has both the old ones for compatibility and new ones with _v2 postfix,
-          we load the _v2 ones here. */
+        * has both the old ones for compatibility and new ones with _v2 postfix,
+        * we load the _v2 ones here. */
        CUDA_LIBRARY_FIND_V2(cuDeviceTotalMem);
        CUDA_LIBRARY_FIND_V2(cuCtxCreate);
        CUDA_LIBRARY_FIND_V2(cuModuleGetGlobal);
index 25a77f18d0247ff77c508b0e6bc12656197910d0..749b777efdc9be8ecc5f90219fa1557167047b82 100644 (file)
@@ -148,7 +148,7 @@ void MD5Hash::process(const uint8_t *data /*[64]*/)
 
        /* Round 1. */
        /* Let [abcd k s i] denote the operation
-          a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+        * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + F(b,c,d) + X[k] + Ti;\
@@ -172,9 +172,9 @@ void MD5Hash::process(const uint8_t *data /*[64]*/)
        SET(b, c, d, a, 15, 22, T16);
 #undef SET
 
-        /* Round 2. */
-        /* Let [abcd k s i] denote the operation
-                 a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+       /* Round 2. */
+       /* Let [abcd k s i] denote the operation
+        * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + G(b,c,d) + X[k] + Ti;\
@@ -198,9 +198,9 @@ void MD5Hash::process(const uint8_t *data /*[64]*/)
        SET(b, c, d, a, 12, 20, T32);
 #undef SET
 
-        /* Round 3. */
-        /* Let [abcd k s t] denote the operation
-                 a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+       /* Round 3. */
+       /* Let [abcd k s t] denote the operation
+        * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
 #define H(x, y, z) ((x) ^ (y) ^ (z))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + H(b,c,d) + X[k] + Ti;\
@@ -224,9 +224,9 @@ void MD5Hash::process(const uint8_t *data /*[64]*/)
        SET(b, c, d, a,  2, 23, T48);
 #undef SET
 
-        /* Round 4. */
-        /* Let [abcd k s t] denote the operation
-                 a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+       /* Round 4. */
+       /* Let [abcd k s t] denote the operation
+        * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + I(b,c,d) + X[k] + Ti;\
@@ -250,9 +250,9 @@ void MD5Hash::process(const uint8_t *data /*[64]*/)
        SET(b, c, d, a,  9, 21, T64);
 #undef SET
 
-        /* Then perform the following additions. (That is increment each
-               of the four registers by the value it had before this block
-               was started.) */
+       /* Then perform the following additions. (That is increment each
+        * of the four registers by the value it had before this block
+        * was started.) */
        abcd[0] += a;
        abcd[1] += b;
        abcd[2] += c;
index 2e97097ef369c7e01fc4e41737f3d46de67de759..907d372d3ce5c0fe166fad51517f2450f74189e9 100644 (file)
@@ -36,27 +36,27 @@ CCL_NAMESPACE_BEGIN
 #endif  //  CLCC_GENERATE_DOCUMENTATION
 
 /*******************************************************************************
-* Copyright (c) 2008-2009 The Khronos Group Inc.
-*
-* Permission is hereby granted, free of charge, to any person obtaining a
-* copy of this software and/or associated documentation files (the
-* "Materials"), to deal in the Materials without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Materials, and to
-* permit persons to whom the Materials are furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be included
-* in all copies or substantial portions of the Materials.
-*
-* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-******************************************************************************/
+ * Copyright (c) 2008-2009 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
 
 #ifndef CLCC_GENERATE_DOCUMENTATION
 
@@ -88,20 +88,20 @@ typedef double                  cl_double;
 
 
 /*
-* Vector types 
-*
-*  Note:   OpenCL requires that all types be naturally aligned. 
-*          This means that vector types must be naturally aligned.
-*          For example, a vector of four floats must be aligned to
-*          a 16 byte boundary (calculated as 4 * the natural 4-byte 
-*          alignment of the float).  The alignment qualifiers here
-*          will only function properly if your compiler supports them
-*          and if you don't actively work to defeat them.  For example,
-*          in order for a cl_float4 to be 16 byte aligned in a struct,
-*          the start of the struct must itself be 16-byte aligned. 
-*
-*          Maintaining proper alignment is the user's responsibility.
-*/
+ * Vector types
+ *
+ *  Note:   OpenCL requires that all types be naturally aligned.
+ *          This means that vector types must be naturally aligned.
+ *          For example, a vector of four floats must be aligned to
+ *          a 16 byte boundary (calculated as 4 * the natural 4-byte
+ *          alignment of the float).  The alignment qualifiers here
+ *          will only function properly if your compiler supports them
+ *          and if you don't actively work to defeat them.  For example,
+ *          in order for a cl_float4 to be 16 byte aligned in a struct,
+ *          the start of the struct must itself be 16-byte aligned.
+ *
+ *          Maintaining proper alignment is the user's responsibility.
+ */
 typedef signed   __int8          cl_char2[2];
 typedef signed   __int8          cl_char4[4];
 typedef signed   __int8          cl_char8[8];
@@ -168,20 +168,20 @@ typedef float           cl_float    __attribute__((aligned(4)));
 typedef double          cl_double   __attribute__((aligned(8)));
 
 /*
-* Vector types 
-*
-*  Note:   OpenCL requires that all types be naturally aligned. 
-*          This means that vector types must be naturally aligned.
-*          For example, a vector of four floats must be aligned to
-*          a 16 byte boundary (calculated as 4 * the natural 4-byte 
-*          alignment of the float).  The alignment qualifiers here
-*          will only function properly if your compiler supports them
-*          and if you don't actively work to defeat them.  For example,
-*          in order for a cl_float4 to be 16 byte aligned in a struct,
-*          the start of the struct must itself be 16-byte aligned. 
-*
-*          Maintaining proper alignment is the user's responsibility.
-*/
+ * Vector types
+ *
+ *  Note:   OpenCL requires that all types be naturally aligned.
+ *          This means that vector types must be naturally aligned.
+ *          For example, a vector of four floats must be aligned to
+ *          a 16 byte boundary (calculated as 4 * the natural 4-byte
+ *          alignment of the float).  The alignment qualifiers here
+ *          will only function properly if your compiler supports them
+ *          and if you don't actively work to defeat them.  For example,
+ *          in order for a cl_float4 to be 16 byte aligned in a struct,
+ *          the start of the struct must itself be 16-byte aligned.
+ *
+ *          Maintaining proper alignment is the user's responsibility.
+ */
 typedef int8_t          cl_char2[2]     __attribute__((aligned(2)));
 typedef int8_t          cl_char4[4]     __attribute__((aligned(4)));
 typedef int8_t          cl_char8[8]     __attribute__((aligned(8)));
index 69069a3bbce4929884fdc60b6d2d7ebffc8a0151..717aa34c4265769bacce5137bcb8dd808fa14edb 100644 (file)
@@ -179,8 +179,8 @@ static bool path_read_text(const string& path, string& text)
 string path_source_replace_includes(const string& source_, const string& path)
 {
        /* our own little c preprocessor that replaces #includes with the file
-          contents, to work around issue of opencl drivers not supporting
-          include paths with spaces in them */
+        * contents, to work around issue of opencl drivers not supporting
+        * include paths with spaces in them */
        string source = source_;
        const string include = "#include \"";
        size_t n, pos = 0;
index ad7f3347cee7fba3c87bf6e5fb55147bee3f1bcd..2d9f0fffae66a853e3bcbd059dd9673df8573741 100644 (file)
@@ -149,8 +149,10 @@ bool system_cpu_support_optimized()
                __cpuid(result, 0);
                num = result[0];
 
-               /*__cpuid(result, 0x80000000);
-               num_ex = result[0];*/
+#if 0
+               __cpuid(result, 0x80000000);
+               num_ex = result[0];
+#endif
 
                if(num >= 1) {
                        __cpuid(result, 0x00000001);
@@ -167,13 +169,15 @@ bool system_cpu_support_optimized()
                        caps.fma3 = (result[2] & ((int)1 << 12)) != 0;
                }
 
-               /*if(num_ex >= 0x80000001) {
+#if 0
+               if(num_ex >= 0x80000001) {
                        __cpuid(result, 0x80000001);
                        caps.x64 = (result[3] & ((int)1 << 29)) != 0;
                        caps.sse4a = (result[2] & ((int)1 <<  6)) != 0;
                        caps.fma4 = (result[2] & ((int)1 << 16)) != 0;
                        caps.xop = (result[2] & ((int)1 << 11)) != 0;
-               }*/
+               }
+#endif
 
                caps_init = true;
        }
index 023630e8faed4c23843c33f9c9aef2d42240757a..ea0abd6f54f31eaf03b741027d86f98f326f58ca 100644 (file)
@@ -164,7 +164,7 @@ void TaskScheduler::init(int num_threads)
        thread_scoped_lock lock(mutex);
 
        /* multiple cycles instances can use this task scheduler, sharing the same
-          threads, so we keep track of the number of users. */
+        * threads, so we keep track of the number of users. */
        if(users == 0) {
                do_exit = false;
 
index 008f68e69e8f8a6bdfdc4ef92452f0dadf454359..9bea4e7808a3b8b0430abe49bc65e42d51ac5f21 100644 (file)
@@ -34,7 +34,7 @@ typedef boost::mutex::scoped_lock thread_scoped_lock;
 typedef boost::condition_variable thread_condition_variable;
 
 /* own pthread based implementation, to avoid boost version conflicts with
  dynamically loaded blender plugins */
* dynamically loaded blender plugins */
 
 class thread {
 public:
index 1780994da27f48e679b8de7a6a18dd8ce47c5757..860f2d4d8887dc61d9de7297c8ae9d35bb299140 100644 (file)
@@ -139,7 +139,7 @@ Transform transform_inverse(const Transform& tfm)
 
        if(!transform_matrix4_gj_inverse(R, M)) {
                /* matrix is degenerate (e.g. 0 scale on some axis), ideally we should
-                  never be in this situation, but try to invert it anyway with tweak */
+                * never be in this situation, but try to invert it anyway with tweak */
                M[0][0] += 1e-8f;
                M[1][1] += 1e-8f;
                M[2][2] += 1e-8f;
index b460c4c87a2a8d04c7e252da48c1faf742ae6ba3..d93bbff5415d3cc0303ff994be87863792b1247a 100644 (file)
@@ -255,7 +255,7 @@ Transform transform_inverse(const Transform& a);
 __device_inline bool transform_uniform_scale(const Transform& tfm, float& scale)
 {
        /* the epsilon here is quite arbitrary, but this function is only used for
-          surface area and bump, where we except it to not be so sensitive */
+        * surface area and bump, where we except it to not be so sensitive */
        Transform ttfm = transform_transpose(tfm);
        float eps = 1e-6f;