style cleanup: assignment & indentation.
authorCampbell Barton <ideasman42@gmail.com>
Sat, 9 Jun 2012 18:56:12 +0000 (18:56 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 9 Jun 2012 18:56:12 +0000 (18:56 +0000)
32 files changed:
intern/cycles/app/cycles_test.cpp
intern/cycles/blender/blender_camera.cpp
intern/cycles/blender/blender_mesh.cpp
intern/cycles/blender/blender_particles.cpp
intern/cycles/blender/blender_python.cpp
intern/cycles/blender/blender_session.cpp
intern/cycles/blender/blender_shader.cpp
intern/cycles/blender/blender_sync.cpp
intern/cycles/bvh/bvh_node.cpp
intern/cycles/kernel/kernel_differential.h
intern/cycles/kernel/kernel_path.h
intern/cycles/kernel/svm/bsdf.h
intern/cycles/kernel/svm/svm_gradient.h
intern/cycles/kernel/svm/svm_magic.h
intern/cycles/kernel/svm/svm_mix.h
intern/cycles/kernel/svm/svm_noise.h
intern/cycles/kernel/svm/svm_texture.h
intern/cycles/kernel/svm/svm_voronoi.h
intern/cycles/kernel/svm/svm_wave.h
intern/cycles/render/attribute.cpp
intern/cycles/render/buffers.cpp
intern/cycles/render/camera.cpp
intern/cycles/render/camera.h
intern/cycles/render/filter.cpp
intern/cycles/render/nodes.h
intern/cycles/util/util_cuda.h
intern/cycles/util/util_hash.h
intern/cycles/util/util_md5.cpp
intern/cycles/util/util_md5.h
intern/cycles/util/util_opencl.cpp
intern/cycles/util/util_opencl.h
intern/cycles/util/util_view.cpp

index 0b8853d7036b730f0a67a385e7ff07e50d0b7117..f5890998adc7bbee5838586b2af6df71418510b8 100644 (file)
@@ -172,8 +172,8 @@ static void display()
 
 static void resize(int width, int height)
 {
-       options.width= width;
-       options.height= height;
+       options.width = width;
+       options.height = height;
 
        if(options.session)
                options.session->reset(session_buffer_params(), options.session_params.samples);
@@ -197,8 +197,8 @@ static int files_parse(int argc, const char *argv[])
 
 static void options_parse(int argc, const char **argv)
 {
-       options.width= 0;
-       options.height= 0;
+       options.width = 0;
+       options.height = 0;
        options.filepath = "";
        options.session = NULL;
        options.quiet = false;
index cffc533f87b24721823c595be8caf3d0c828a1dd..122d0bd7c17c08e2d4ac8af9f40e636eaa8bf2b6 100644 (file)
@@ -222,14 +222,14 @@ static void blender_camera_viewplane(BlenderCamera *bcam, int width, int height,
        }
 
        if(horizontal_fit) {
-               *aspectratio= xratio/yratio;
-               xaspect= *aspectratio;
-               yaspect= 1.0f;
+               *aspectratio = xratio/yratio;
+               xaspect = *aspectratio;
+               yaspect = 1.0f;
        }
        else {
-               *aspectratio= yratio/xratio;
-               xaspect= 1.0f;
-               yaspect= *aspectratio;
+               *aspectratio = yratio/xratio;
+               xaspect = 1.0f;
+               yaspect = *aspectratio;
        }
 
        /* modify aspect for orthographic scale */
index f3266435040cfcd78126536cbc49d3f43491b3f0..16e4ceded89bfa7d0f29be860d32352617388d38 100644 (file)
@@ -46,7 +46,7 @@ static void create_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, const vector<
        float3 *N = attr_N->data_float3();
 
        for(b_mesh.vertices.begin(v); v != b_mesh.vertices.end(); ++v, ++N)
-               *N= get_float3(v->normal());
+               *N = get_float3(v->normal());
 
        /* create faces */
        BL::Mesh::tessfaces_iterator f;
@@ -175,7 +175,7 @@ static void create_subd_mesh(Mesh *mesh, BL::Mesh b_mesh, PointerRNA *cmesh, con
 
        for(b_mesh.tessfaces.begin(f); f != b_mesh.tessfaces.end(); ++f) {
                int4 vi = get_int4(f->vertices_raw());
-               int n= (vi[3] == 0)? 3: 4;
+               int n = (vi[3] == 0) ? 3: 4;
                //int shader = used_shaders[f->material_index()];
 
                if(n == 4)
index 2b19009989a2064f90bb1b90d2a4fbb2a954aab9..f591aaa6d835bb8c0aa05c211e3d84729f37ef7f 100644 (file)
@@ -145,7 +145,7 @@ void BlenderSync::sync_particles(Object *ob, BL::Object b_ob)
        for(b_ob.particle_systems.begin(b_psys); b_psys != b_ob.particle_systems.end(); ++b_psys) {
                if (use_particle_system(*b_psys)) {
                        BL::ParticleSystem::particles_iterator b_pa;
-                       for(b_psys->particles.begin(b_pa), index=0; b_pa != b_psys->particles.end(); ++b_pa, ++index) {
+                       for(b_psys->particles.begin(b_pa), index = 0; b_pa != b_psys->particles.end(); ++b_pa, ++index) {
                                if(use_particle(*b_pa)) {
                                        Particle pa;
                                        
index 6e892095387a3b4e7f2967e15c72f664ebf6bfe6..4560c2f8543ea310c56a9cdbaa71e5d58f749649 100644 (file)
@@ -193,7 +193,8 @@ CCLDeviceInfo *compute_device_list(DeviceType type)
 
                foreach(DeviceInfo& info, devices) {
                        if(info.type == type ||
-                          (info.type == DEVICE_MULTI && info.multi_devices[0].type == type)) {
+                          (info.type == DEVICE_MULTI && info.multi_devices[0].type == type))
+                       {
                                CCLDeviceInfo cinfo = {info.id.c_str(), info.description.c_str(), i++};
                                device_list.push_back(cinfo);
                        }
@@ -214,7 +215,7 @@ CCL_NAMESPACE_END
 
 void *CCL_python_module_init()
 {
-       PyObject *mod= PyModule_Create(&ccl::module);
+       PyObject *mod = PyModule_Create(&ccl::module);
 
 #ifdef WITH_OSL
        PyModule_AddObject(mod, "with_osl", Py_True);
index be0c26867134aa3d551f5b0744f6ab30ad81be06..12d7d00fb610513c7131057d897b1ba60a4f6ecd 100644 (file)
@@ -83,8 +83,8 @@ void BlenderSession::create_session()
        SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
 
        /* reset status/progress */
-       last_status= "";
-       last_progress= -1.0f;
+       last_status = "";
+       last_progress = -1.0f;
 
        /* create scene */
        scene = new Scene(scene_params);
@@ -292,7 +292,8 @@ void BlenderSession::synchronize()
        SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
 
        if(session->params.modified(session_params) ||
-          scene->params.modified(scene_params)) {
+          scene->params.modified(scene_params))
+       {
                free_session();
                create_session();
                session->start();
index f9331fc1b1432d0fa61a9291d9ff6ca7cca2d685..35fe4c67673dbafc03801ef10943965045a49122 100644 (file)
@@ -784,7 +784,9 @@ void BlenderSync::sync_lamps()
                                if(b_lamp->type() == BL::Lamp::type_POINT ||
                                   b_lamp->type() == BL::Lamp::type_SPOT ||
                                   b_lamp->type() == BL::Lamp::type_AREA)
+                               {
                                        strength = 100.0f;
+                               }
 
                                closure = graph->add(new EmissionNode());
                                closure->input("Color")->value = get_float3(b_lamp->color());
index a9714d6d72fa27260862a9a9f64cd8ac64ffe68b..13040e551bdcd9e46dacdec1fdf7777cf511dcce 100644 (file)
@@ -105,10 +105,13 @@ bool BlenderSync::sync_recalc()
 
        BL::BlendData::worlds_iterator b_world;
 
-       for(b_data.worlds.begin(b_world); b_world != b_data.worlds.end(); ++b_world)
+       for(b_data.worlds.begin(b_world); b_world != b_data.worlds.end(); ++b_world) {
                if(world_map == b_world->ptr.data &&
-                       (b_world->is_updated() || (b_world->node_tree() && b_world->node_tree().is_updated())))
+                  (b_world->is_updated() || (b_world->node_tree() && b_world->node_tree().is_updated())))
+               {
                        world_recalc = true;
+               }
+       }
 
        bool recalc =
                shader_map.has_recalc() ||
index 4edfb4b70a4a3ad11fe3aa668e2079d3f6b22b60..7cc9bd333b070c99cea665c6b822efb22fe018dc 100644 (file)
@@ -52,7 +52,7 @@ int BVHNode::getSubtreeSize(BVH_STAT stat) const
        }
 
        if(!is_leaf())
-               for(int i=0;i<num_children();i++)
+               for(int i = 0; i < num_children(); i++)
                        cnt += get_child(i)->getSubtreeSize(stat);
 
        return cnt;
@@ -60,7 +60,7 @@ int BVHNode::getSubtreeSize(BVH_STAT stat) const
 
 void BVHNode::deleteSubtree()
 {
-       for(int i=0;i<num_children();i++)
+       for(int i = 0; i < num_children(); i++)
                if(get_child(i))
                        get_child(i)->deleteSubtree();
 
@@ -71,7 +71,7 @@ float BVHNode::computeSubtreeSAHCost(const BVHParams& p, float probability) cons
 {
        float SAH = probability * p.cost(num_children(), num_triangles());
 
-       for(int i=0;i<num_children();i++) {
+       for(int i = 0; i < num_children(); i++) {
                BVHNode *child = get_child(i);
                SAH += child->computeSubtreeSAHCost(p, probability * child->m_bounds.safe_area()/m_bounds.safe_area());
        }
index 5b4290a77226fb6540e5ed9d9e5cc0a4a0429c01..04027523ea58c641f7124dd0e350a80303934ca0 100644 (file)
@@ -49,9 +49,9 @@ __device void differential_dudv(differential *du, differential *dv, float3 dPdu,
         * mainly used for differentials of arbitrary mesh attributes. */
 
        /* find most stable axis to project to 2D */
-       float xn= fabsf(Ng.x);
-       float yn= fabsf(Ng.y);
-       float zn= fabsf(Ng.z);
+       float xn = fabsf(Ng.x);
+       float yn = fabsf(Ng.y);
+       float zn = fabsf(Ng.z);
 
        if(zn < xn || zn < yn) {
                if(yn < xn || yn < zn) {
index 16fd0499b0017fc74d8354b6f6311768b00ecddd..8dbf66c108c08ced5d1d0fca3b71b80d6203f6ed 100644 (file)
@@ -137,9 +137,12 @@ __device_inline float path_state_terminate_probability(KernelGlobals *kg, PathSt
                   (state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) ||
                   (state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) ||
                   (state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce))
+               {
                        return 0.0f;
-               else if(state->bounce <= kernel_data.integrator.min_bounce)
+               }
+               else if(state->bounce <= kernel_data.integrator.min_bounce) {
                        return 1.0f;
+               }
        }
 
        /* probalistic termination */
index ba78a93f54fc80a88ea5ad65e23a525adf96d9fe..1a90eab0cd19395f525f93874c2bc7147a704640 100644 (file)
@@ -47,7 +47,7 @@ __device float fresnel_dielectric(float eta, const float3 N,
        float cos = dot(N, I), neta;
        float3 Nn;
        // compute reflection
-       *R =(2 * cos)* N - I;
+       *R = (2 * cos)* N - I;
 #ifdef __RAY_DIFFERENTIALS__
        *dRdx = (2 * dot(N, dIdx)) * N - dIdx;
        *dRdy = (2 * dot(N, dIdy)) * N - dIdy;
@@ -65,18 +65,18 @@ __device float fresnel_dielectric(float eta, const float3 N,
                Nn   = -N;
                *is_inside = true;
        }
-       *R =(2 * cos)* Nn - I;
+       *R = (2 * cos)* Nn - I;
        float arg = 1 -(neta * neta *(1 -(cos * cos)));
        if(arg < 0) {
-               *T= make_float3(0.0f, 0.0f, 0.0f);
+               *T = make_float3(0.0f, 0.0f, 0.0f);
 #ifdef __RAY_DIFFERENTIALS__
-               *dTdx= make_float3(0.0f, 0.0f, 0.0f);
-               *dTdy= make_float3(0.0f, 0.0f, 0.0f);
+               *dTdx = make_float3(0.0f, 0.0f, 0.0f);
+               *dTdy = make_float3(0.0f, 0.0f, 0.0f);
 #endif
                return 1; // total internal reflection
        } else {
                float dnp = sqrtf(arg);
-               float nK =(neta * cos)- dnp;
+               float nK = (neta * cos)- dnp;
                *T = -(neta * I)+(nK * Nn);
 #ifdef __RAY_DIFFERENTIALS__
                *dTdx = -(neta * dIdx) + ((neta - neta * neta * cos / dnp) * dot(dIdx, Nn)) * Nn;
@@ -85,8 +85,8 @@ __device float fresnel_dielectric(float eta, const float3 N,
                // compute Fresnel terms
                float cosTheta1 = cos; // N.R
                float cosTheta2 = -dot(Nn, *T);
-               float pPara =(cosTheta1 - eta * cosTheta2)/(cosTheta1 + eta * cosTheta2);
-               float pPerp =(eta * cosTheta1 - cosTheta2)/(eta * cosTheta1 + cosTheta2);
+               float pPara = (cosTheta1 - eta * cosTheta2)/(cosTheta1 + eta * cosTheta2);
+               float pPerp = (eta * cosTheta1 - cosTheta2)/(eta * cosTheta1 + cosTheta2);
                return 0.5f * (pPara * pPara + pPerp * pPerp);
        }
 }
@@ -99,8 +99,8 @@ __device float fresnel_dielectric_cos(float cosi, float eta)
        float g = eta * eta - 1 + c * c;
        if(g > 0) {
                g = sqrtf(g);
-               float A =(g - c)/(g + c);
-               float B =(c *(g + c)- 1)/(c *(g - c)+ 1);
+               float A = (g - c)/(g + c);
+               float B = (c *(g + c)- 1)/(c *(g - c)+ 1);
                return 0.5f * A * A *(1 + B * B);
        }
        return 1.0f; // TIR(no refracted component)
@@ -110,10 +110,10 @@ __device float fresnel_conductor(float cosi, float eta, float k)
 {
        float tmp_f = eta * eta + k * k;
        float tmp = tmp_f * cosi * cosi;
-       float Rparl2 =(tmp -(2.0f * eta * cosi)+ 1)/
-                                (tmp +(2.0f * eta * cosi)+ 1);
-       float Rperp2 =(tmp_f -(2.0f * eta * cosi)+ cosi * cosi)/
-                                (tmp_f +(2.0f * eta * cosi)+ cosi * cosi);
+       float Rparl2 = (tmp - (2.0f * eta * cosi) + 1)/
+                      (tmp + (2.0f * eta * cosi) + 1);
+       float Rperp2 = (tmp_f - (2.0f * eta * cosi) + cosi * cosi)/
+                      (tmp_f + (2.0f * eta * cosi) + cosi * cosi);
        return(Rparl2 + Rperp2) * 0.5f;
 }
 
index b29abed4edccbea07b59c81f62ca8aaad9f2f8b9..7fad1175c493c452d2ed3477fbf8203d05ad54b1 100644 (file)
@@ -24,9 +24,9 @@ __device float svm_gradient(float3 p, NodeGradientType type)
 {
        float x, y, z;
 
-       x= p.x;
-       y= p.y;
-       z= p.z;
+       x = p.x;
+       y = p.y;
+       z = p.z;
 
        if(type == NODE_BLEND_LINEAR) {
                return x;
index 65d37937e1e1e981b9038fe7843f195ff59f2a24..fdded813784fc1096e3b7e28816bc1680bf91272 100644 (file)
@@ -34,39 +34,39 @@ __device_noinline float3 svm_magic(float3 p, int n, float distortion)
                y *= distortion;
 
                if(n > 1) {
-                       x= cosf(x-y-z);
+                       x = cosf(x-y-z);
                        x *= distortion;
 
                        if(n > 2) {
-                               z= sinf(-x-y-z);
+                               z = sinf(-x-y-z);
                                z *= distortion;
 
                                if(n > 3) {
-                                       x= -cosf(-x+y-z);
+                                       x = -cosf(-x+y-z);
                                        x *= distortion;
 
                                        if(n > 4) {
-                                               y= -sinf(-x+y+z);
+                                               y = -sinf(-x+y+z);
                                                y *= distortion;
 
                                                if(n > 5) {
-                                                       y= -cosf(-x+y+z);
+                                                       y = -cosf(-x+y+z);
                                                        y *= distortion;
 
                                                        if(n > 6) {
-                                                               x= cosf(x+y+z);
+                                                               x = cosf(x+y+z);
                                                                x *= distortion;
 
                                                                if(n > 7) {
-                                                                       z= sinf(x+y-z);
+                                                                       z = sinf(x+y-z);
                                                                        z *= distortion;
 
                                                                        if(n > 8) {
-                                                                               x= -cosf(-x-y+z);
+                                                                               x = -cosf(-x-y+z);
                                                                                x *= distortion;
 
                                                                                if(n > 9) {
-                                                                                       y= -sinf(x-y+z);
+                                                                                       y = -sinf(x-y+z);
                                                                                        y *= distortion;
                                                                                }
                                                                        }
index e2274a2e691be12e1945e95a675625b91e8cc152..6b455e713c287c0a8b2ed0373104265d2ddae9b0 100644 (file)
@@ -248,8 +248,8 @@ __device float3 svm_mix_soft(float t, float3 col1, float3 col2)
 {
        float tm = 1.0f - t;
 
-       float3 one= make_float3(1.0f, 1.0f, 1.0f);
-       float3 scr= one - (one - col2)*(one - col1);
+       float3 one = make_float3(1.0f, 1.0f, 1.0f);
+       float3 scr = one - (one - col2)*(one - col1);
 
        return tm*col1 + t*((one - col1)*col2*col1 + col1*scr);
 }
@@ -259,19 +259,19 @@ __device float3 svm_mix_linear(float t, float3 col1, float3 col2)
        float3 outcol = col1;
 
        if(col2.x > 0.5f)
-               outcol.x= col1.x + t*(2.0f*(col2.x - 0.5f));
+               outcol.x = col1.x + t*(2.0f*(col2.x - 0.5f));
        else
-               outcol.x= col1.x + t*(2.0f*(col2.x) - 1.0f);
+               outcol.x = col1.x + t*(2.0f*(col2.x) - 1.0f);
 
        if(col2.y > 0.5f)
-               outcol.y= col1.y + t*(2.0f*(col2.y - 0.5f));
+               outcol.y = col1.y + t*(2.0f*(col2.y - 0.5f));
        else
-               outcol.y= col1.y + t*(2.0f*(col2.y) - 1.0f);
+               outcol.y = col1.y + t*(2.0f*(col2.y) - 1.0f);
 
        if(col2.z > 0.5f)
-               outcol.z= col1.z + t*(2.0f*(col2.z - 0.5f));
+               outcol.z = col1.z + t*(2.0f*(col2.z - 0.5f));
        else
-               outcol.z= col1.z + t*(2.0f*(col2.z) - 1.0f);
+               outcol.z = col1.z + t*(2.0f*(col2.z) - 1.0f);
        
        return outcol;
 }
index 22f3187943ceccc0e43bab714409b4a29ddaef0a..dfaf43acbd4402536e39da8373d725cda3be42ec 100644 (file)
@@ -84,9 +84,9 @@ __device uint phash(int kx, int ky, int kz, int3 p)
 
 __device float floorfrac(float x, int* i)
 {
-    float f = floorf(x);
-    *i = (int)f;
-    return x - f;
+       float f = floorf(x);
+       *i = (int)f;
+       return x - f;
 }
 
 __device float fade(float t)
@@ -96,7 +96,7 @@ __device float fade(float t)
 
 __device float nerp(float t, float a, float b)
 {
-    return (1.0f - t) * a + t * b;
+       return (1.0f - t) * a + t * b;
 }
 
 __device float grad(int hash, float x, float y, float z)
index d12a85a5402c41573e963c94cc6ae70336aa96c6..6c22d98e0df84e010541f7821b64fd4f0090a90c 100644 (file)
@@ -221,7 +221,7 @@ __device_noinline float noise_turbulence(float3 p, NodeNoiseBasis basis, float o
        int i, n;
 
        octaves = clamp(octaves, 0.0f, 16.0f);
-       n= (int)octaves;
+       n = (int)octaves;
 
        for(i = 0; i <= n; i++) {
                float t = noise_basis(fscale*p, basis);
index f5ee7851a51d476adabd78bd651d0ad7564fe417..7e7bd970320d9fb9e9854c849e2eaca2f6885054 100644 (file)
@@ -38,7 +38,7 @@ __device_noinline float4 svm_voronoi(NodeVoronoiColoring coloring, float scale,
        }
        else {
                color = cellnoise_color(pa[0]);
-        fac= average(color);
+               fac = average(color);
        }
 
        return make_float4(color.x, color.y, color.z, fac);
index 7050bbe7f00f39fcd98857c84ba0df5c934b2db6..d2d808e40631ebbc65bdf312b30df06630e67213 100644 (file)
@@ -27,9 +27,9 @@ __device_noinline float svm_wave(NodeWaveType type, float3 p, float scale, float
        p *= scale;
 
        if(type == NODE_WAVE_BANDS)
-               n= (p.x + p.y + p.z)*10.0f;
+               n = (p.x + p.y + p.z) * 10.0f;
        else /* if(type == NODE_WAVE_RINGS) */
-               n= len(p)*20.0f;
+               n = len(p) * 20.0f;
        
        if(distortion != 0.0f)
                n += distortion * noise_turbulence(p*dscale, NODE_NOISE_PERLIN, detail, 0);
index c1a089cc8721abd2cec61977212b5a876617d505..5c7966d6d96f02993b6598d92c353f03eb64bc2e 100644 (file)
@@ -74,10 +74,13 @@ bool Attribute::same_storage(TypeDesc a, TypeDesc b)
        
        if(a == TypeDesc::TypeColor || a == TypeDesc::TypePoint ||
           a == TypeDesc::TypeVector || a == TypeDesc::TypeNormal)
+       {
                if(b == TypeDesc::TypeColor || b == TypeDesc::TypePoint ||
                   b == TypeDesc::TypeVector || b == TypeDesc::TypeNormal)
+               {
                        return true;
-       
+               }
+       }
        return false;
 }
 
@@ -286,10 +289,13 @@ bool AttributeRequestSet::modified(const AttributeRequestSet& other)
                for(size_t j = 0; j < requests.size() && !found; j++)
                        if(requests[i].name == other.requests[j].name &&
                           requests[i].std == other.requests[j].std)
+                       {
                                found = true;
+                       }
 
-               if(!found)
+               if(!found) {
                        return true;
+               }
        }
 
        return false;
index a7fd47c94cf895e039f41abdb7ad730756ca213b..a79a3591e0f4fa584de00d38ff5147a323cb2a56 100644 (file)
@@ -117,8 +117,8 @@ void RenderBuffers::reset(Device *device, BufferParams& params_)
        uint *init_state = rng_state.resize(params.width, params.height);
        int x, y, width = params.width, height = params.height;
        
-       for(x=0; x<width; x++)
-               for(y=0; y<height; y++)
+       for(x = 0; x < width; x++)
+               for(y = 0; y < height; y++)
                        init_state[x + y*width] = hash_int_2d(params.full_x+x, params.full_y+y);
 
        device->mem_alloc(rng_state, MEM_READ_WRITE);
index ed239074cd452be4d0145df4a7b8ef32b10df7b9..55a0f23f8d0d866883fccedef09c884eaf5c9be7 100644 (file)
@@ -199,7 +199,7 @@ void Camera::device_update(Device *device, DeviceScene *dscene, Scene *scene)
        kcam->bladesrotation = bladesrotation;
 
        /* motion blur */
-       kcam->shuttertime= (need_motion == Scene::MOTION_BLUR)? shuttertime: 0.0f;
+       kcam->shuttertime = (need_motion == Scene::MOTION_BLUR) ? shuttertime: 0.0f;
 
        /* type */
        kcam->type = type;
index 647423d88baf8bfc2a282d69134fd48f7294efd5..d2a3cce181708980bec5a55e86b7c5a3191371b1 100644 (file)
@@ -78,7 +78,7 @@ public:
        bool use_motion;
 
        /* computed camera parameters */
-    Transform screentoworld;
+       Transform screentoworld;
        Transform rastertoworld;
        Transform ndctoworld;
        Transform rastertocamera;
index 9bcf57b5a274f91b005a8aa2afc04d69a0486283..0bd4fb4d57946e2e8bd27ba63cce8bf2174fea3a 100644 (file)
@@ -73,17 +73,17 @@ static vector<float> filter_table(FilterType type, float width)
        /* compute cumulative distribution function */
        filter_table_cdf[0] = 0.0f;
        
-       for(i=0; i<filter_table_size; i++) {
+       for(i = 0; i < filter_table_size; i++) {
                float x = i*width*0.5f/(filter_table_size-1);
                float y = filter_func(x, width);
                filter_table_cdf[i+1] += filter_table_cdf[i] + fabsf(y);
        }
 
-       for(i=0; i<=filter_table_size; i++)
+       for(i = 0; i <= filter_table_size; i++)
                filter_table_cdf[i] /= filter_table_cdf[filter_table_size];
        
        /* create importance sampling table */
-       for(i=0; i<=half_size; i++) {
+       for(i = 0; i <= half_size; i++) {
                float x = i/(float)half_size;
                int index = upper_bound(filter_table_cdf.begin(), filter_table_cdf.end(), x) - filter_table_cdf.begin();
                float t;
index eb9effc2658c7d16545e7cd3f55fb52f381b350d..efd814e4ae6c687098f56e37d7a492cc6fa0938a 100644 (file)
@@ -44,7 +44,7 @@ public:
        float3 min, max;
        bool use_minmax;
 
-       enum Mapping { NONE=0, X=1, Y=2, Z=3 };
+       enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
        Mapping x_mapping, y_mapping, z_mapping;
 
        enum Projection { FLAT, CUBE, TUBE, SPHERE };
index ffc71b8864e360b7aa6ea7bf49ea71506757e47a..d9d956b7bd976b7d009040493d28e97a22ae7945 100644 (file)
@@ -56,225 +56,225 @@ typedef struct CUstream_st *CUstream;
 typedef struct CUgraphicsResource_st *CUgraphicsResource;
 
 typedef struct CUuuid_st {
-    char bytes[16];
+       char bytes[16];
 } CUuuid;
 
 typedef enum CUctx_flags_enum {
-    CU_CTX_SCHED_AUTO  = 0,
-    CU_CTX_SCHED_SPIN  = 1,
-    CU_CTX_SCHED_YIELD = 2,
-    CU_CTX_SCHED_MASK  = 0x3,
-    CU_CTX_BLOCKING_SYNC = 4,
-    CU_CTX_MAP_HOST = 8,
-    CU_CTX_LMEM_RESIZE_TO_MAX = 16,
-    CU_CTX_FLAGS_MASK  = 0x1f
+       CU_CTX_SCHED_AUTO  = 0,
+       CU_CTX_SCHED_SPIN  = 1,
+       CU_CTX_SCHED_YIELD = 2,
+       CU_CTX_SCHED_MASK  = 0x3,
+       CU_CTX_BLOCKING_SYNC = 4,
+       CU_CTX_MAP_HOST = 8,
+       CU_CTX_LMEM_RESIZE_TO_MAX = 16,
+       CU_CTX_FLAGS_MASK  = 0x1f
 } CUctx_flags;
 
 typedef enum CUevent_flags_enum {
-    CU_EVENT_DEFAULT        = 0,
-    CU_EVENT_BLOCKING_SYNC  = 1,
-    CU_EVENT_DISABLE_TIMING = 2
+       CU_EVENT_DEFAULT        = 0,
+       CU_EVENT_BLOCKING_SYNC  = 1,
+       CU_EVENT_DISABLE_TIMING = 2
 } CUevent_flags;
 
 typedef enum CUarray_format_enum {
-    CU_AD_FORMAT_UNSIGNED_INT8  = 0x01,
-    CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
-    CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
-    CU_AD_FORMAT_SIGNED_INT8    = 0x08,
-    CU_AD_FORMAT_SIGNED_INT16   = 0x09,
-    CU_AD_FORMAT_SIGNED_INT32   = 0x0a,
-    CU_AD_FORMAT_HALF           = 0x10,
-    CU_AD_FORMAT_FLOAT          = 0x20
+       CU_AD_FORMAT_UNSIGNED_INT8  = 0x01,
+       CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
+       CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
+       CU_AD_FORMAT_SIGNED_INT8    = 0x08,
+       CU_AD_FORMAT_SIGNED_INT16   = 0x09,
+       CU_AD_FORMAT_SIGNED_INT32   = 0x0a,
+       CU_AD_FORMAT_HALF           = 0x10,
+       CU_AD_FORMAT_FLOAT          = 0x20
 } CUarray_format;
 
 typedef enum CUaddress_mode_enum {
-    CU_TR_ADDRESS_MODE_WRAP   = 0,
-    CU_TR_ADDRESS_MODE_CLAMP  = 1,
-    CU_TR_ADDRESS_MODE_MIRROR = 2,
-    CU_TR_ADDRESS_MODE_BORDER = 3
+       CU_TR_ADDRESS_MODE_WRAP   = 0,
+       CU_TR_ADDRESS_MODE_CLAMP  = 1,
+       CU_TR_ADDRESS_MODE_MIRROR = 2,
+       CU_TR_ADDRESS_MODE_BORDER = 3
 } CUaddress_mode;
 
 typedef enum CUfilter_mode_enum {
-    CU_TR_FILTER_MODE_POINT  = 0,
-    CU_TR_FILTER_MODE_LINEAR = 1
+       CU_TR_FILTER_MODE_POINT  = 0,
+       CU_TR_FILTER_MODE_LINEAR = 1
 } CUfilter_mode;
 
 typedef enum CUdevice_attribute_enum {
-    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
-    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
-    CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = 8,
-    CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
-    CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
-    CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
-    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
-    CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = 12,
-    CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
-    CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
-    CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
-    CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
-    CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
-    CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
-    CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
-    CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = 27,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = 28,
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = 29,
-    CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
-    CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
-    CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
-    CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
-    CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
-    CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35
+       CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
+       CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
+       CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
+       CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
+       CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
+       CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
+       CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
+       CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
+       CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = 8,
+       CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
+       CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
+       CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
+       CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
+       CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = 12,
+       CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
+       CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
+       CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
+       CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
+       CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
+       CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
+       CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
+       CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = 27,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = 28,
+       CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = 29,
+       CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
+       CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
+       CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
+       CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
+       CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
+       CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35
 } CUdevice_attribute;
 
 typedef struct CUdevprop_st {
-    int maxThreadsPerBlock;
-    int maxThreadsDim[3];
-    int maxGridSize[3];
-    int sharedMemPerBlock;
-    int totalConstantMemory;
-    int SIMDWidth;
-    int memPitch;
-    int regsPerBlock;
-    int clockRate;
-    int textureAlign;
+       int maxThreadsPerBlock;
+       int maxThreadsDim[3];
+       int maxGridSize[3];
+       int sharedMemPerBlock;
+       int totalConstantMemory;
+       int SIMDWidth;
+       int memPitch;
+       int regsPerBlock;
+       int clockRate;
+       int textureAlign;
 } CUdevprop;
 
 typedef enum CUfunction_attribute_enum {
-    CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
-    CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
-    CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
-    CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
-    CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
-    CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
-    CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
-    CU_FUNC_ATTRIBUTE_MAX
+       CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
+       CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
+       CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
+       CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
+       CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
+       CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
+       CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
+       CU_FUNC_ATTRIBUTE_MAX
 } CUfunction_attribute;
 
 typedef enum CUfunc_cache_enum {
-    CU_FUNC_CACHE_PREFER_NONE    = 0x00,
-    CU_FUNC_CACHE_PREFER_SHARED  = 0x01,
-    CU_FUNC_CACHE_PREFER_L1      = 0x02
+       CU_FUNC_CACHE_PREFER_NONE    = 0x00,
+       CU_FUNC_CACHE_PREFER_SHARED  = 0x01,
+       CU_FUNC_CACHE_PREFER_L1      = 0x02
 } CUfunc_cache;
 
 typedef enum CUmemorytype_enum {
-    CU_MEMORYTYPE_HOST   = 0x01,
-    CU_MEMORYTYPE_DEVICE = 0x02,
-    CU_MEMORYTYPE_ARRAY  = 0x03
+       CU_MEMORYTYPE_HOST   = 0x01,
+       CU_MEMORYTYPE_DEVICE = 0x02,
+       CU_MEMORYTYPE_ARRAY  = 0x03
 } CUmemorytype;
 
 typedef enum CUcomputemode_enum {
-    CU_COMPUTEMODE_DEFAULT    = 0,
-    CU_COMPUTEMODE_EXCLUSIVE  = 1,
-    CU_COMPUTEMODE_PROHIBITED = 2
+       CU_COMPUTEMODE_DEFAULT    = 0,
+       CU_COMPUTEMODE_EXCLUSIVE  = 1,
+       CU_COMPUTEMODE_PROHIBITED = 2
 } CUcomputemode;
 
 typedef enum CUjit_option_enum
 {
-    CU_JIT_MAX_REGISTERS = 0,
-    CU_JIT_THREADS_PER_BLOCK,
-    CU_JIT_WALL_TIME,
-    CU_JIT_INFO_LOG_BUFFER,
-    CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,
-    CU_JIT_ERROR_LOG_BUFFER,
-    CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,
-    CU_JIT_OPTIMIZATION_LEVEL,
-    CU_JIT_TARGET_FROM_CUCONTEXT,
-    CU_JIT_TARGET,
-    CU_JIT_FALLBACK_STRATEGY
+       CU_JIT_MAX_REGISTERS = 0,
+       CU_JIT_THREADS_PER_BLOCK,
+       CU_JIT_WALL_TIME,
+       CU_JIT_INFO_LOG_BUFFER,
+       CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,
+       CU_JIT_ERROR_LOG_BUFFER,
+       CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,
+       CU_JIT_OPTIMIZATION_LEVEL,
+       CU_JIT_TARGET_FROM_CUCONTEXT,
+       CU_JIT_TARGET,
+       CU_JIT_FALLBACK_STRATEGY
 
 } CUjit_option;
 
 typedef enum CUjit_target_enum
 {
-    CU_TARGET_COMPUTE_10 = 0,
-    CU_TARGET_COMPUTE_11,
-    CU_TARGET_COMPUTE_12,
-    CU_TARGET_COMPUTE_13,
-    CU_TARGET_COMPUTE_20,
-    CU_TARGET_COMPUTE_21,
-    CU_TARGET_COMPUTE_30
+       CU_TARGET_COMPUTE_10 = 0,
+       CU_TARGET_COMPUTE_11,
+       CU_TARGET_COMPUTE_12,
+       CU_TARGET_COMPUTE_13,
+       CU_TARGET_COMPUTE_20,
+       CU_TARGET_COMPUTE_21,
+       CU_TARGET_COMPUTE_30
 } CUjit_target;
 
 typedef enum CUjit_fallback_enum
 {
-    CU_PREFER_PTX = 0,
-    CU_PREFER_BINARY
+       CU_PREFER_PTX = 0,
+       CU_PREFER_BINARY
 
 } CUjit_fallback;
 
 typedef enum CUgraphicsRegisterFlags_enum {
-    CU_GRAPHICS_REGISTER_FLAGS_NONE  = 0x00
+       CU_GRAPHICS_REGISTER_FLAGS_NONE  = 0x00
 } CUgraphicsRegisterFlags;
 
 typedef enum CUgraphicsMapResourceFlags_enum {
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE          = 0x00,
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY     = 0x01,
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02
+       CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE          = 0x00,
+       CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY     = 0x01,
+       CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02
 } CUgraphicsMapResourceFlags;
 
 typedef enum CUarray_cubemap_face_enum {
-    CU_CUBEMAP_FACE_POSITIVE_X  = 0x00,
-    CU_CUBEMAP_FACE_NEGATIVE_X  = 0x01,
-    CU_CUBEMAP_FACE_POSITIVE_Y  = 0x02,
-    CU_CUBEMAP_FACE_NEGATIVE_Y  = 0x03,
-    CU_CUBEMAP_FACE_POSITIVE_Z  = 0x04,
-    CU_CUBEMAP_FACE_NEGATIVE_Z  = 0x05
+       CU_CUBEMAP_FACE_POSITIVE_X  = 0x00,
+       CU_CUBEMAP_FACE_NEGATIVE_X  = 0x01,
+       CU_CUBEMAP_FACE_POSITIVE_Y  = 0x02,
+       CU_CUBEMAP_FACE_NEGATIVE_Y  = 0x03,
+       CU_CUBEMAP_FACE_POSITIVE_Z  = 0x04,
+       CU_CUBEMAP_FACE_NEGATIVE_Z  = 0x05
 } CUarray_cubemap_face;
 
 typedef enum CUlimit_enum {
-    CU_LIMIT_STACK_SIZE        = 0x00,
-    CU_LIMIT_PRINTF_FIFO_SIZE  = 0x01,
-    CU_LIMIT_MALLOC_HEAP_SIZE  = 0x02
+       CU_LIMIT_STACK_SIZE        = 0x00,
+       CU_LIMIT_PRINTF_FIFO_SIZE  = 0x01,
+       CU_LIMIT_MALLOC_HEAP_SIZE  = 0x02
 } CUlimit;
 
 typedef enum cudaError_enum {
-    CUDA_SUCCESS                              = 0,
-    CUDA_ERROR_INVALID_VALUE                  = 1,
-    CUDA_ERROR_OUT_OF_MEMORY                  = 2,
-    CUDA_ERROR_NOT_INITIALIZED                = 3,
-    CUDA_ERROR_DEINITIALIZED                  = 4,
-    CUDA_ERROR_NO_DEVICE                      = 100,
-    CUDA_ERROR_INVALID_DEVICE                 = 101,
-    CUDA_ERROR_INVALID_IMAGE                  = 200,
-    CUDA_ERROR_INVALID_CONTEXT                = 201,
-    CUDA_ERROR_CONTEXT_ALREADY_CURRENT        = 202,
-    CUDA_ERROR_MAP_FAILED                     = 205,
-    CUDA_ERROR_UNMAP_FAILED                   = 206,
-    CUDA_ERROR_ARRAY_IS_MAPPED                = 207,
-    CUDA_ERROR_ALREADY_MAPPED                 = 208,
-    CUDA_ERROR_NO_BINARY_FOR_GPU              = 209,
-    CUDA_ERROR_ALREADY_ACQUIRED               = 210,
-    CUDA_ERROR_NOT_MAPPED                     = 211,
-    CUDA_ERROR_NOT_MAPPED_AS_ARRAY            = 212,
-    CUDA_ERROR_NOT_MAPPED_AS_POINTER          = 213,
-    CUDA_ERROR_ECC_UNCORRECTABLE              = 214,
-    CUDA_ERROR_UNSUPPORTED_LIMIT              = 215,
-    CUDA_ERROR_INVALID_SOURCE                 = 300,
-    CUDA_ERROR_FILE_NOT_FOUND                 = 301,
-    CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
-    CUDA_ERROR_SHARED_OBJECT_INIT_FAILED      = 303,
-    CUDA_ERROR_OPERATING_SYSTEM               = 304,
-    CUDA_ERROR_INVALID_HANDLE                 = 400,
-    CUDA_ERROR_NOT_FOUND                      = 500,
-    CUDA_ERROR_NOT_READY                      = 600,
-    CUDA_ERROR_LAUNCH_FAILED                  = 700,
-    CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES        = 701,
-    CUDA_ERROR_LAUNCH_TIMEOUT                 = 702,
-    CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING  = 703,
-    CUDA_ERROR_UNKNOWN                        = 999
+       CUDA_SUCCESS                              = 0,
+       CUDA_ERROR_INVALID_VALUE                  = 1,
+       CUDA_ERROR_OUT_OF_MEMORY                  = 2,
+       CUDA_ERROR_NOT_INITIALIZED                = 3,
+       CUDA_ERROR_DEINITIALIZED                  = 4,
+       CUDA_ERROR_NO_DEVICE                      = 100,
+       CUDA_ERROR_INVALID_DEVICE                 = 101,
+       CUDA_ERROR_INVALID_IMAGE                  = 200,
+       CUDA_ERROR_INVALID_CONTEXT                = 201,
+       CUDA_ERROR_CONTEXT_ALREADY_CURRENT        = 202,
+       CUDA_ERROR_MAP_FAILED                     = 205,
+       CUDA_ERROR_UNMAP_FAILED                   = 206,
+       CUDA_ERROR_ARRAY_IS_MAPPED                = 207,
+       CUDA_ERROR_ALREADY_MAPPED                 = 208,
+       CUDA_ERROR_NO_BINARY_FOR_GPU              = 209,
+       CUDA_ERROR_ALREADY_ACQUIRED               = 210,
+       CUDA_ERROR_NOT_MAPPED                     = 211,
+       CUDA_ERROR_NOT_MAPPED_AS_ARRAY            = 212,
+       CUDA_ERROR_NOT_MAPPED_AS_POINTER          = 213,
+       CUDA_ERROR_ECC_UNCORRECTABLE              = 214,
+       CUDA_ERROR_UNSUPPORTED_LIMIT              = 215,
+       CUDA_ERROR_INVALID_SOURCE                 = 300,
+       CUDA_ERROR_FILE_NOT_FOUND                 = 301,
+       CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
+       CUDA_ERROR_SHARED_OBJECT_INIT_FAILED      = 303,
+       CUDA_ERROR_OPERATING_SYSTEM               = 304,
+       CUDA_ERROR_INVALID_HANDLE                 = 400,
+       CUDA_ERROR_NOT_FOUND                      = 500,
+       CUDA_ERROR_NOT_READY                      = 600,
+       CUDA_ERROR_LAUNCH_FAILED                  = 700,
+       CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES        = 701,
+       CUDA_ERROR_LAUNCH_TIMEOUT                 = 702,
+       CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING  = 703,
+       CUDA_ERROR_UNKNOWN                        = 999
 } CUresult;
 
 #define CU_MEMHOSTALLOC_PORTABLE        0x01
@@ -282,76 +282,76 @@ typedef enum cudaError_enum {
 #define CU_MEMHOSTALLOC_WRITECOMBINED   0x04
 
 typedef struct CUDA_MEMCPY2D_st {
-    size_t srcXInBytes;
-    size_t srcY;
-
-    CUmemorytype srcMemoryType;
-    const void *srcHost;
-    CUdeviceptr srcDevice;
-    CUarray srcArray;
-    size_t srcPitch;
-
-    size_t dstXInBytes;
-    size_t dstY;
-
-    CUmemorytype dstMemoryType;
-    void *dstHost;
-    CUdeviceptr dstDevice;
-    CUarray dstArray;
-    size_t dstPitch;
-
-    size_t WidthInBytes;
-    size_t Height;
+       size_t srcXInBytes;
+       size_t srcY;
+
+       CUmemorytype srcMemoryType;
+       const void *srcHost;
+       CUdeviceptr srcDevice;
+       CUarray srcArray;
+       size_t srcPitch;
+
+       size_t dstXInBytes;
+       size_t dstY;
+
+       CUmemorytype dstMemoryType;
+       void *dstHost;
+       CUdeviceptr dstDevice;
+       CUarray dstArray;
+       size_t dstPitch;
+
+       size_t WidthInBytes;
+       size_t Height;
 } CUDA_MEMCPY2D;
 
 typedef struct CUDA_MEMCPY3D_st {
-    size_t srcXInBytes;
-    size_t srcY;
-    size_t srcZ;
-    size_t srcLOD;
-    CUmemorytype srcMemoryType;
-    const void *srcHost;
-    CUdeviceptr srcDevice;
-    CUarray srcArray;
-    void *reserved0;
-    size_t srcPitch;
-    size_t srcHeight;
-
-    size_t dstXInBytes;
-    size_t dstY;
-    size_t dstZ;
-    size_t dstLOD;
-    CUmemorytype dstMemoryType;
-    void *dstHost;
-    CUdeviceptr dstDevice;
-    CUarray dstArray;
-    void *reserved1;
-    size_t dstPitch;
-    size_t dstHeight;
-
-    size_t WidthInBytes;
-    size_t Height;
-    size_t Depth;
+       size_t srcXInBytes;
+       size_t srcY;
+       size_t srcZ;
+       size_t srcLOD;
+       CUmemorytype srcMemoryType;
+       const void *srcHost;
+       CUdeviceptr srcDevice;
+       CUarray srcArray;
+       void *reserved0;
+       size_t srcPitch;
+       size_t srcHeight;
+
+       size_t dstXInBytes;
+       size_t dstY;
+       size_t dstZ;
+       size_t dstLOD;
+       CUmemorytype dstMemoryType;
+       void *dstHost;
+       CUdeviceptr dstDevice;
+       CUarray dstArray;
+       void *reserved1;
+       size_t dstPitch;
+       size_t dstHeight;
+
+       size_t WidthInBytes;
+       size_t Height;
+       size_t Depth;
 } CUDA_MEMCPY3D;
 
 typedef struct CUDA_ARRAY_DESCRIPTOR_st
 {
-    size_t Width;
-    size_t Height;
+       size_t Width;
+       size_t Height;
 
-    CUarray_format Format;
-    unsigned int NumChannels;
+       CUarray_format Format;
+       unsigned int NumChannels;
 } CUDA_ARRAY_DESCRIPTOR;
 
 typedef struct CUDA_ARRAY3D_DESCRIPTOR_st
 {
-    size_t Width;
-    size_t Height;
-    size_t Depth;
+       size_t Width;
+       size_t Height;
+       size_t Depth;
 
-    CUarray_format Format;
-    unsigned int NumChannels;
-    unsigned int Flags;
+       CUarray_format Format;
+       unsigned int NumChannels;
+       unsigned int Flags;
 } CUDA_ARRAY3D_DESCRIPTOR;
 
 #define CUDA_ARRAY3D_2DARRAY        0x01
index c31b46e1580647ad36924110a030ea67bfed08bb..5b3ff76af7f1230cec05602c036f9fdf1949027e 100644 (file)
@@ -34,14 +34,14 @@ static inline uint hash_int_2d(uint kx, uint ky)
        b += ky;
 
        c ^= b; c -= rot(b,14);
-    a ^= c; a -= rot(c,11);
-    b ^= a; b -= rot(a,25);
-    c ^= b; c -= rot(b,16);
-    a ^= c; a -= rot(c,4);
-    b ^= a; b -= rot(a,14);
-    c ^= b; c -= rot(b,24);
-
-    return c;
+       a ^= c; a -= rot(c,11);
+       b ^= a; b -= rot(a,25);
+       c ^= b; c -= rot(b,16);
+       a ^= c; a -= rot(c,4);
+       b ^= a; b -= rot(a,14);
+       c ^= b; c -= rot(b,24);
+
+       return c;
 
        #undef rot
 }
index 749b777efdc9be8ecc5f90219fa1557167047b82..9dcd69cec999b9d8d401bc5dc91d026d36562f0a 100644 (file)
@@ -365,7 +365,7 @@ string MD5Hash::get_hex()
 
        finish(digest);
 
-       for(int i=0; i<16; i++)
+       for(int i = 0; i < 16; i++)
                sprintf(buf + i*2, "%02X", digest[i]);
        buf[sizeof(buf)-1] = '\0';
        
index 5e7e604c4cf4484576d536a0839db974d227ce18..43e08e64f39fc7d03fef77b6346bd10549ea5a20 100644 (file)
@@ -44,13 +44,13 @@ public:
        bool append_file(const string& filepath);
        string get_hex();
 
-protected:
+       protected:
        void process(const uint8_t *data);
        void finish(uint8_t digest[16]);
 
-    uint32_t count[2]; /* message length in bits, lsw first */
-    uint32_t abcd[4]; /* digest buffer */
-    uint8_t buf[64]; /* accumulate block */
+       uint32_t count[2]; /* message length in bits, lsw first */
+       uint32_t abcd[4]; /* digest buffer */
+       uint8_t buf[64]; /* accumulate block */
 };
 
 CCL_NAMESPACE_END
index 4087c2c38237573029d8cd65830d0e08bf3d21bd..c9df9c2ff5c2e8b566b7c371982c3d22a9875305 100644 (file)
 
 #ifndef CLCC_GENERATE_DOCUMENTATION
 #ifdef _WIN32
-    #define WIN32_LEAN_AND_MEAN
-    #define VC_EXTRALEAN
-    #include <windows.h>
+#  define WIN32_LEAN_AND_MEAN
+#  define VC_EXTRALEAN
+#  include <windows.h>
 
-    typedef HMODULE             CLCC_DYNLIB_HANDLE;
+   typedef HMODULE             CLCC_DYNLIB_HANDLE;
 
-    #define CLCC_DYNLIB_OPEN    LoadLibrary
-    #define CLCC_DYNLIB_CLOSE   FreeLibrary
-    #define CLCC_DYNLIB_IMPORT  GetProcAddress
+#  define CLCC_DYNLIB_OPEN    LoadLibrary
+#  define CLCC_DYNLIB_CLOSE   FreeLibrary
+#  define CLCC_DYNLIB_IMPORT  GetProcAddress
 #else
-    #include <dlfcn.h>
-    
-    typedef void*                   CLCC_DYNLIB_HANDLE;
+#  include <dlfcn.h>
 
-    #define CLCC_DYNLIB_OPEN(path)  dlopen(path, RTLD_NOW | RTLD_GLOBAL)
-    #define CLCC_DYNLIB_CLOSE       dlclose
-    #define CLCC_DYNLIB_IMPORT      dlsym
+   typedef void*                   CLCC_DYNLIB_HANDLE;
+
+#  define CLCC_DYNLIB_OPEN(path)  dlopen(path, RTLD_NOW | RTLD_GLOBAL)
+#  define CLCC_DYNLIB_CLOSE       dlclose
+#  define CLCC_DYNLIB_IMPORT      dlsym
 #endif
 #else
-    //typedef implementation_defined  CLCC_DYNLIB_HANDLE;
-    //#define CLCC_DYNLIB_OPEN(path)  implementation_defined
-    //#define CLCC_DYNLIB_CLOSE       implementation_defined
-    //#define CLCC_DYNLIB_IMPORT      implementation_defined
+//  typedef implementation_defined  CLCC_DYNLIB_HANDLE;
+//#  define CLCC_DYNLIB_OPEN(path)  implementation_defined
+//#  define CLCC_DYNLIB_CLOSE       implementation_defined
+//#  define CLCC_DYNLIB_IMPORT      implementation_defined
 #endif
 
 CCL_NAMESPACE_BEGIN
@@ -117,12 +117,12 @@ PFNCLGETEXTENSIONFUNCTIONADDRESS    __clewGetExtensionFunctionAddress   = NULL;
 //! \brief Unloads OpenCL dynamic library, should not be called directly
 static void clewExit(void)
 {
-    if (module != NULL)
-    {
-        //  Ignore errors
-        CLCC_DYNLIB_CLOSE(module);
-        module = NULL;
-    }
+       if (module != NULL)
+       {
+               //  Ignore errors
+               CLCC_DYNLIB_CLOSE(module);
+               module = NULL;
+       }
 }
 
 //! \param path path to dynamic library to load
@@ -138,186 +138,186 @@ int clLibraryInit()
 #else
        const char *path = "libOpenCL.so";
 #endif
-    int error = 0;
+       int error = 0;
 
-    //  Check if already initialized
-    if (module != NULL)
-    {
-        return 1;
-    }
+       //  Check if already initialized
+       if (module != NULL)
+       {
+               return 1;
+       }
 
-    //  Load library
-    module = CLCC_DYNLIB_OPEN(path);
+       //  Load library
+       module = CLCC_DYNLIB_OPEN(path);
 
-    //  Check for errors
-    if (module == NULL)
-    {
-        return 0;
-    }
+       //  Check for errors
+       if (module == NULL)
+       {
+               return 0;
+       }
 
-    //  Set unloading
-    error = atexit(clewExit);
+       //  Set unloading
+       error = atexit(clewExit);
 
-    if (error)
-    {
-        //  Failure queing atexit, shutdown with error
-        CLCC_DYNLIB_CLOSE(module);
-        module = NULL;
+       if (error)
+       {
+               //  Failure queing atexit, shutdown with error
+               CLCC_DYNLIB_CLOSE(module);
+               module = NULL;
 
-        return 0;
-    }
+               return 0;
+       }
 
-    //  Determine function entry-points
-    __clewGetPlatformIDs                = (PFNCLGETPLATFORMIDS              )CLCC_DYNLIB_IMPORT(module, "clGetPlatformIDs");
-    __clewGetPlatformInfo               = (PFNCLGETPLATFORMINFO             )CLCC_DYNLIB_IMPORT(module, "clGetPlatformInfo");
-    __clewGetDeviceIDs                  = (PFNCLGETDEVICEIDS                )CLCC_DYNLIB_IMPORT(module, "clGetDeviceIDs");
-    __clewGetDeviceInfo                 = (PFNCLGETDEVICEINFO               )CLCC_DYNLIB_IMPORT(module, "clGetDeviceInfo");
-    __clewCreateContext                 = (PFNCLCREATECONTEXT               )CLCC_DYNLIB_IMPORT(module, "clCreateContext");
-    __clewCreateContextFromType         = (PFNCLCREATECONTEXTFROMTYPE       )CLCC_DYNLIB_IMPORT(module, "clCreateContextFromType");
-    __clewRetainContext                 = (PFNCLRETAINCONTEXT               )CLCC_DYNLIB_IMPORT(module, "clRetainContext");
-    __clewReleaseContext                = (PFNCLRELEASECONTEXT              )CLCC_DYNLIB_IMPORT(module, "clReleaseContext");
-    __clewGetContextInfo                = (PFNCLGETCONTEXTINFO              )CLCC_DYNLIB_IMPORT(module, "clGetContextInfo");
-    __clewCreateCommandQueue            = (PFNCLCREATECOMMANDQUEUE          )CLCC_DYNLIB_IMPORT(module, "clCreateCommandQueue");
-    __clewRetainCommandQueue            = (PFNCLRETAINCOMMANDQUEUE          )CLCC_DYNLIB_IMPORT(module, "clRetainCommandQueue");
-    __clewReleaseCommandQueue           = (PFNCLRELEASECOMMANDQUEUE         )CLCC_DYNLIB_IMPORT(module, "clReleaseCommandQueue");
-    __clewGetCommandQueueInfo           = (PFNCLGETCOMMANDQUEUEINFO         )CLCC_DYNLIB_IMPORT(module, "clGetCommandQueueInfo");
-    __clewSetCommandQueueProperty       = (PFNCLSETCOMMANDQUEUEPROPERTY     )CLCC_DYNLIB_IMPORT(module, "clSetCommandQueueProperty");
-    __clewCreateBuffer                  = (PFNCLCREATEBUFFER                )CLCC_DYNLIB_IMPORT(module, "clCreateBuffer");
-    __clewCreateImage2D                 = (PFNCLCREATEIMAGE2D               )CLCC_DYNLIB_IMPORT(module, "clCreateImage2D");
-    __clewCreateImage3D                 = (PFNCLCREATEIMAGE3D               )CLCC_DYNLIB_IMPORT(module, "clCreateImage3D");
-    __clewRetainMemObject               = (PFNCLRETAINMEMOBJECT             )CLCC_DYNLIB_IMPORT(module, "clRetainMemObject");
-    __clewReleaseMemObject              = (PFNCLRELEASEMEMOBJECT            )CLCC_DYNLIB_IMPORT(module, "clReleaseMemObject");
-    __clewGetSupportedImageFormats      = (PFNCLGETSUPPORTEDIMAGEFORMATS    )CLCC_DYNLIB_IMPORT(module, "clGetSupportedImageFormats");
-    __clewGetMemObjectInfo              = (PFNCLGETMEMOBJECTINFO            )CLCC_DYNLIB_IMPORT(module, "clGetMemObjectInfo");
-    __clewGetImageInfo                  = (PFNCLGETIMAGEINFO                )CLCC_DYNLIB_IMPORT(module, "clGetImageInfo");
-    __clewCreateSampler                 = (PFNCLCREATESAMPLER               )CLCC_DYNLIB_IMPORT(module, "clCreateSampler");
-    __clewRetainSampler                 = (PFNCLRETAINSAMPLER               )CLCC_DYNLIB_IMPORT(module, "clRetainSampler");
-    __clewReleaseSampler                = (PFNCLRELEASESAMPLER              )CLCC_DYNLIB_IMPORT(module, "clReleaseSampler");
-    __clewGetSamplerInfo                = (PFNCLGETSAMPLERINFO              )CLCC_DYNLIB_IMPORT(module, "clGetSamplerInfo");
-    __clewCreateProgramWithSource       = (PFNCLCREATEPROGRAMWITHSOURCE     )CLCC_DYNLIB_IMPORT(module, "clCreateProgramWithSource");
-    __clewCreateProgramWithBinary       = (PFNCLCREATEPROGRAMWITHBINARY     )CLCC_DYNLIB_IMPORT(module, "clCreateProgramWithBinary");
-    __clewRetainProgram                 = (PFNCLRETAINPROGRAM               )CLCC_DYNLIB_IMPORT(module, "clRetainProgram");
-    __clewReleaseProgram                = (PFNCLRELEASEPROGRAM              )CLCC_DYNLIB_IMPORT(module, "clReleaseProgram");
-    __clewBuildProgram                  = (PFNCLBUILDPROGRAM                )CLCC_DYNLIB_IMPORT(module, "clBuildProgram");
-    __clewUnloadCompiler                = (PFNCLUNLOADCOMPILER              )CLCC_DYNLIB_IMPORT(module, "clUnloadCompiler");
-    __clewGetProgramInfo                = (PFNCLGETPROGRAMINFO              )CLCC_DYNLIB_IMPORT(module, "clGetProgramInfo");
-    __clewGetProgramBuildInfo           = (PFNCLGETPROGRAMBUILDINFO         )CLCC_DYNLIB_IMPORT(module, "clGetProgramBuildInfo");
-    __clewCreateKernel                  = (PFNCLCREATEKERNEL                )CLCC_DYNLIB_IMPORT(module, "clCreateKernel");
-    __clewCreateKernelsInProgram        = (PFNCLCREATEKERNELSINPROGRAM      )CLCC_DYNLIB_IMPORT(module, "clCreateKernelsInProgram");
-    __clewRetainKernel                  = (PFNCLRETAINKERNEL                )CLCC_DYNLIB_IMPORT(module, "clRetainKernel");
-    __clewReleaseKernel                 = (PFNCLRELEASEKERNEL               )CLCC_DYNLIB_IMPORT(module, "clReleaseKernel");
-    __clewSetKernelArg                  = (PFNCLSETKERNELARG                )CLCC_DYNLIB_IMPORT(module, "clSetKernelArg");
-    __clewGetKernelInfo                 = (PFNCLGETKERNELINFO               )CLCC_DYNLIB_IMPORT(module, "clGetKernelInfo");
-    __clewGetKernelWorkGroupInfo        = (PFNCLGETKERNELWORKGROUPINFO      )CLCC_DYNLIB_IMPORT(module, "clGetKernelWorkGroupInfo");
-    __clewWaitForEvents                 = (PFNCLWAITFOREVENTS               )CLCC_DYNLIB_IMPORT(module, "clWaitForEvents");
-    __clewGetEventInfo                  = (PFNCLGETEVENTINFO                )CLCC_DYNLIB_IMPORT(module, "clGetEventInfo");
-    __clewRetainEvent                   = (PFNCLRETAINEVENT                 )CLCC_DYNLIB_IMPORT(module, "clRetainEvent");
-    __clewReleaseEvent                  = (PFNCLRELEASEEVENT                )CLCC_DYNLIB_IMPORT(module, "clReleaseEvent");
-    __clewGetEventProfilingInfo         = (PFNCLGETEVENTPROFILINGINFO       )CLCC_DYNLIB_IMPORT(module, "clGetEventProfilingInfo");
-    __clewFlush                         = (PFNCLFLUSH                       )CLCC_DYNLIB_IMPORT(module, "clFlush");
-    __clewFinish                        = (PFNCLFINISH                      )CLCC_DYNLIB_IMPORT(module, "clFinish");
-    __clewEnqueueReadBuffer             = (PFNCLENQUEUEREADBUFFER           )CLCC_DYNLIB_IMPORT(module, "clEnqueueReadBuffer");
-    __clewEnqueueWriteBuffer            = (PFNCLENQUEUEWRITEBUFFER          )CLCC_DYNLIB_IMPORT(module, "clEnqueueWriteBuffer");
-    __clewEnqueueCopyBuffer             = (PFNCLENQUEUECOPYBUFFER           )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyBuffer");
-    __clewEnqueueReadImage              = (PFNCLENQUEUEREADIMAGE            )CLCC_DYNLIB_IMPORT(module, "clEnqueueReadImage");
-    __clewEnqueueWriteImage             = (PFNCLENQUEUEWRITEIMAGE           )CLCC_DYNLIB_IMPORT(module, "clEnqueueWriteImage");
-    __clewEnqueueCopyImage              = (PFNCLENQUEUECOPYIMAGE            )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyImage");
-    __clewEnqueueCopyImageToBuffer      = (PFNCLENQUEUECOPYIMAGETOBUFFER    )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyImageToBuffer");
-    __clewEnqueueCopyBufferToImage      = (PFNCLENQUEUECOPYBUFFERTOIMAGE    )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyBufferToImage");
-    __clewEnqueueMapBuffer              = (PFNCLENQUEUEMAPBUFFER            )CLCC_DYNLIB_IMPORT(module, "clEnqueueMapBuffer");
-    __clewEnqueueMapImage               = (PFNCLENQUEUEMAPIMAGE             )CLCC_DYNLIB_IMPORT(module, "clEnqueueMapImage");
-    __clewEnqueueUnmapMemObject         = (PFNCLENQUEUEUNMAPMEMOBJECT       )CLCC_DYNLIB_IMPORT(module, "clEnqueueUnmapMemObject");
-    __clewEnqueueNDRangeKernel          = (PFNCLENQUEUENDRANGEKERNEL        )CLCC_DYNLIB_IMPORT(module, "clEnqueueNDRangeKernel");
-    __clewEnqueueTask                   = (PFNCLENQUEUETASK                 )CLCC_DYNLIB_IMPORT(module, "clEnqueueTask");
-    __clewEnqueueNativeKernel           = (PFNCLENQUEUENATIVEKERNEL         )CLCC_DYNLIB_IMPORT(module, "clEnqueueNativeKernel");
-    __clewEnqueueMarker                 = (PFNCLENQUEUEMARKER               )CLCC_DYNLIB_IMPORT(module, "clEnqueueMarker");
-    __clewEnqueueWaitForEvents          = (PFNCLENQUEUEWAITFOREVENTS        )CLCC_DYNLIB_IMPORT(module, "clEnqueueWaitForEvents");
-    __clewEnqueueBarrier                = (PFNCLENQUEUEBARRIER              )CLCC_DYNLIB_IMPORT(module, "clEnqueueBarrier");
-    __clewGetExtensionFunctionAddress   = (PFNCLGETEXTENSIONFUNCTIONADDRESS )CLCC_DYNLIB_IMPORT(module, "clGetExtensionFunctionAddress");
+       //  Determine function entry-points
+       __clewGetPlatformIDs                = (PFNCLGETPLATFORMIDS              )CLCC_DYNLIB_IMPORT(module, "clGetPlatformIDs");
+       __clewGetPlatformInfo               = (PFNCLGETPLATFORMINFO             )CLCC_DYNLIB_IMPORT(module, "clGetPlatformInfo");
+       __clewGetDeviceIDs                  = (PFNCLGETDEVICEIDS                )CLCC_DYNLIB_IMPORT(module, "clGetDeviceIDs");
+       __clewGetDeviceInfo                 = (PFNCLGETDEVICEINFO               )CLCC_DYNLIB_IMPORT(module, "clGetDeviceInfo");
+       __clewCreateContext                 = (PFNCLCREATECONTEXT               )CLCC_DYNLIB_IMPORT(module, "clCreateContext");
+       __clewCreateContextFromType         = (PFNCLCREATECONTEXTFROMTYPE       )CLCC_DYNLIB_IMPORT(module, "clCreateContextFromType");
+       __clewRetainContext                 = (PFNCLRETAINCONTEXT               )CLCC_DYNLIB_IMPORT(module, "clRetainContext");
+       __clewReleaseContext                = (PFNCLRELEASECONTEXT              )CLCC_DYNLIB_IMPORT(module, "clReleaseContext");
+       __clewGetContextInfo                = (PFNCLGETCONTEXTINFO              )CLCC_DYNLIB_IMPORT(module, "clGetContextInfo");
+       __clewCreateCommandQueue            = (PFNCLCREATECOMMANDQUEUE          )CLCC_DYNLIB_IMPORT(module, "clCreateCommandQueue");
+       __clewRetainCommandQueue            = (PFNCLRETAINCOMMANDQUEUE          )CLCC_DYNLIB_IMPORT(module, "clRetainCommandQueue");
+       __clewReleaseCommandQueue           = (PFNCLRELEASECOMMANDQUEUE         )CLCC_DYNLIB_IMPORT(module, "clReleaseCommandQueue");
+       __clewGetCommandQueueInfo           = (PFNCLGETCOMMANDQUEUEINFO         )CLCC_DYNLIB_IMPORT(module, "clGetCommandQueueInfo");
+       __clewSetCommandQueueProperty       = (PFNCLSETCOMMANDQUEUEPROPERTY     )CLCC_DYNLIB_IMPORT(module, "clSetCommandQueueProperty");
+       __clewCreateBuffer                  = (PFNCLCREATEBUFFER                )CLCC_DYNLIB_IMPORT(module, "clCreateBuffer");
+       __clewCreateImage2D                 = (PFNCLCREATEIMAGE2D               )CLCC_DYNLIB_IMPORT(module, "clCreateImage2D");
+       __clewCreateImage3D                 = (PFNCLCREATEIMAGE3D               )CLCC_DYNLIB_IMPORT(module, "clCreateImage3D");
+       __clewRetainMemObject               = (PFNCLRETAINMEMOBJECT             )CLCC_DYNLIB_IMPORT(module, "clRetainMemObject");
+       __clewReleaseMemObject              = (PFNCLRELEASEMEMOBJECT            )CLCC_DYNLIB_IMPORT(module, "clReleaseMemObject");
+       __clewGetSupportedImageFormats      = (PFNCLGETSUPPORTEDIMAGEFORMATS    )CLCC_DYNLIB_IMPORT(module, "clGetSupportedImageFormats");
+       __clewGetMemObjectInfo              = (PFNCLGETMEMOBJECTINFO            )CLCC_DYNLIB_IMPORT(module, "clGetMemObjectInfo");
+       __clewGetImageInfo                  = (PFNCLGETIMAGEINFO                )CLCC_DYNLIB_IMPORT(module, "clGetImageInfo");
+       __clewCreateSampler                 = (PFNCLCREATESAMPLER               )CLCC_DYNLIB_IMPORT(module, "clCreateSampler");
+       __clewRetainSampler                 = (PFNCLRETAINSAMPLER               )CLCC_DYNLIB_IMPORT(module, "clRetainSampler");
+       __clewReleaseSampler                = (PFNCLRELEASESAMPLER              )CLCC_DYNLIB_IMPORT(module, "clReleaseSampler");
+       __clewGetSamplerInfo                = (PFNCLGETSAMPLERINFO              )CLCC_DYNLIB_IMPORT(module, "clGetSamplerInfo");
+       __clewCreateProgramWithSource       = (PFNCLCREATEPROGRAMWITHSOURCE     )CLCC_DYNLIB_IMPORT(module, "clCreateProgramWithSource");
+       __clewCreateProgramWithBinary       = (PFNCLCREATEPROGRAMWITHBINARY     )CLCC_DYNLIB_IMPORT(module, "clCreateProgramWithBinary");
+       __clewRetainProgram                 = (PFNCLRETAINPROGRAM               )CLCC_DYNLIB_IMPORT(module, "clRetainProgram");
+       __clewReleaseProgram                = (PFNCLRELEASEPROGRAM              )CLCC_DYNLIB_IMPORT(module, "clReleaseProgram");
+       __clewBuildProgram                  = (PFNCLBUILDPROGRAM                )CLCC_DYNLIB_IMPORT(module, "clBuildProgram");
+       __clewUnloadCompiler                = (PFNCLUNLOADCOMPILER              )CLCC_DYNLIB_IMPORT(module, "clUnloadCompiler");
+       __clewGetProgramInfo                = (PFNCLGETPROGRAMINFO              )CLCC_DYNLIB_IMPORT(module, "clGetProgramInfo");
+       __clewGetProgramBuildInfo           = (PFNCLGETPROGRAMBUILDINFO         )CLCC_DYNLIB_IMPORT(module, "clGetProgramBuildInfo");
+       __clewCreateKernel                  = (PFNCLCREATEKERNEL                )CLCC_DYNLIB_IMPORT(module, "clCreateKernel");
+       __clewCreateKernelsInProgram        = (PFNCLCREATEKERNELSINPROGRAM      )CLCC_DYNLIB_IMPORT(module, "clCreateKernelsInProgram");
+       __clewRetainKernel                  = (PFNCLRETAINKERNEL                )CLCC_DYNLIB_IMPORT(module, "clRetainKernel");
+       __clewReleaseKernel                 = (PFNCLRELEASEKERNEL               )CLCC_DYNLIB_IMPORT(module, "clReleaseKernel");
+       __clewSetKernelArg                  = (PFNCLSETKERNELARG                )CLCC_DYNLIB_IMPORT(module, "clSetKernelArg");
+       __clewGetKernelInfo                 = (PFNCLGETKERNELINFO               )CLCC_DYNLIB_IMPORT(module, "clGetKernelInfo");
+       __clewGetKernelWorkGroupInfo        = (PFNCLGETKERNELWORKGROUPINFO      )CLCC_DYNLIB_IMPORT(module, "clGetKernelWorkGroupInfo");
+       __clewWaitForEvents                 = (PFNCLWAITFOREVENTS               )CLCC_DYNLIB_IMPORT(module, "clWaitForEvents");
+       __clewGetEventInfo                  = (PFNCLGETEVENTINFO                )CLCC_DYNLIB_IMPORT(module, "clGetEventInfo");
+       __clewRetainEvent                   = (PFNCLRETAINEVENT                 )CLCC_DYNLIB_IMPORT(module, "clRetainEvent");
+       __clewReleaseEvent                  = (PFNCLRELEASEEVENT                )CLCC_DYNLIB_IMPORT(module, "clReleaseEvent");
+       __clewGetEventProfilingInfo         = (PFNCLGETEVENTPROFILINGINFO       )CLCC_DYNLIB_IMPORT(module, "clGetEventProfilingInfo");
+       __clewFlush                         = (PFNCLFLUSH                       )CLCC_DYNLIB_IMPORT(module, "clFlush");
+       __clewFinish                        = (PFNCLFINISH                      )CLCC_DYNLIB_IMPORT(module, "clFinish");
+       __clewEnqueueReadBuffer             = (PFNCLENQUEUEREADBUFFER           )CLCC_DYNLIB_IMPORT(module, "clEnqueueReadBuffer");
+       __clewEnqueueWriteBuffer            = (PFNCLENQUEUEWRITEBUFFER          )CLCC_DYNLIB_IMPORT(module, "clEnqueueWriteBuffer");
+       __clewEnqueueCopyBuffer             = (PFNCLENQUEUECOPYBUFFER           )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyBuffer");
+       __clewEnqueueReadImage              = (PFNCLENQUEUEREADIMAGE            )CLCC_DYNLIB_IMPORT(module, "clEnqueueReadImage");
+       __clewEnqueueWriteImage             = (PFNCLENQUEUEWRITEIMAGE           )CLCC_DYNLIB_IMPORT(module, "clEnqueueWriteImage");
+       __clewEnqueueCopyImage              = (PFNCLENQUEUECOPYIMAGE            )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyImage");
+       __clewEnqueueCopyImageToBuffer      = (PFNCLENQUEUECOPYIMAGETOBUFFER    )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyImageToBuffer");
+       __clewEnqueueCopyBufferToImage      = (PFNCLENQUEUECOPYBUFFERTOIMAGE    )CLCC_DYNLIB_IMPORT(module, "clEnqueueCopyBufferToImage");
+       __clewEnqueueMapBuffer              = (PFNCLENQUEUEMAPBUFFER            )CLCC_DYNLIB_IMPORT(module, "clEnqueueMapBuffer");
+       __clewEnqueueMapImage               = (PFNCLENQUEUEMAPIMAGE             )CLCC_DYNLIB_IMPORT(module, "clEnqueueMapImage");
+       __clewEnqueueUnmapMemObject         = (PFNCLENQUEUEUNMAPMEMOBJECT       )CLCC_DYNLIB_IMPORT(module, "clEnqueueUnmapMemObject");
+       __clewEnqueueNDRangeKernel          = (PFNCLENQUEUENDRANGEKERNEL        )CLCC_DYNLIB_IMPORT(module, "clEnqueueNDRangeKernel");
+       __clewEnqueueTask                   = (PFNCLENQUEUETASK                 )CLCC_DYNLIB_IMPORT(module, "clEnqueueTask");
+       __clewEnqueueNativeKernel           = (PFNCLENQUEUENATIVEKERNEL         )CLCC_DYNLIB_IMPORT(module, "clEnqueueNativeKernel");
+       __clewEnqueueMarker                 = (PFNCLENQUEUEMARKER               )CLCC_DYNLIB_IMPORT(module, "clEnqueueMarker");
+       __clewEnqueueWaitForEvents          = (PFNCLENQUEUEWAITFOREVENTS        )CLCC_DYNLIB_IMPORT(module, "clEnqueueWaitForEvents");
+       __clewEnqueueBarrier                = (PFNCLENQUEUEBARRIER              )CLCC_DYNLIB_IMPORT(module, "clEnqueueBarrier");
+       __clewGetExtensionFunctionAddress   = (PFNCLGETEXTENSIONFUNCTIONADDRESS )CLCC_DYNLIB_IMPORT(module, "clGetExtensionFunctionAddress");
 
        if(__clewGetPlatformIDs == NULL)
                return 0;
 
-    return 1;
+       return 1;
 }
 
 //! \param error CL error code
 //! \return a string representation of the error code
 const char *clErrorString(cl_int error)
 {
-    static const char* strings[] =
-    {
-        // Error Codes
-          "CL_SUCCESS"                                  //   0
-        , "CL_DEVICE_NOT_FOUND"                         //  -1
-        , "CL_DEVICE_NOT_AVAILABLE"                     //  -2
-        , "CL_COMPILER_NOT_AVAILABLE"                   //  -3
-        , "CL_MEM_OBJECT_ALLOCATION_FAILURE"            //  -4
-        , "CL_OUT_OF_RESOURCES"                         //  -5
-        , "CL_OUT_OF_HOST_MEMORY"                       //  -6
-        , "CL_PROFILING_INFO_NOT_AVAILABLE"             //  -7
-        , "CL_MEM_COPY_OVERLAP"                         //  -8
-        , "CL_IMAGE_FORMAT_MISMATCH"                    //  -9
-        , "CL_IMAGE_FORMAT_NOT_SUPPORTED"               //  -10
-        , "CL_BUILD_PROGRAM_FAILURE"                    //  -11
-        , "CL_MAP_FAILURE"                              //  -12
+       static const char* strings[] =
+       {
+           // Error Codes
+           "CL_SUCCESS"                                  //   0
+           , "CL_DEVICE_NOT_FOUND"                         //  -1
+           , "CL_DEVICE_NOT_AVAILABLE"                     //  -2
+           , "CL_COMPILER_NOT_AVAILABLE"                   //  -3
+           , "CL_MEM_OBJECT_ALLOCATION_FAILURE"            //  -4
+           , "CL_OUT_OF_RESOURCES"                         //  -5
+           , "CL_OUT_OF_HOST_MEMORY"                       //  -6
+           , "CL_PROFILING_INFO_NOT_AVAILABLE"             //  -7
+           , "CL_MEM_COPY_OVERLAP"                         //  -8
+           , "CL_IMAGE_FORMAT_MISMATCH"                    //  -9
+           , "CL_IMAGE_FORMAT_NOT_SUPPORTED"               //  -10
+           , "CL_BUILD_PROGRAM_FAILURE"                    //  -11
+           , "CL_MAP_FAILURE"                              //  -12
 
-        , ""    //  -13
-        , ""    //  -14
-        , ""    //  -15
-        , ""    //  -16
-        , ""    //  -17
-        , ""    //  -18
-        , ""    //  -19
+           , ""    //  -13
+           , ""    //  -14
+           , ""    //  -15
+           , ""    //  -16
+           , ""    //  -17
+           , ""    //  -18
+           , ""    //  -19
 
-        , ""    //  -20
-        , ""    //  -21
-        , ""    //  -22
-        , ""    //  -23
-        , ""    //  -24
-        , ""    //  -25
-        , ""    //  -26
-        , ""    //  -27
-        , ""    //  -28
-        , ""    //  -29
+           , ""    //  -20
+           , ""    //  -21
+           , ""    //  -22
+           , ""    //  -23
+           , ""    //  -24
+           , ""    //  -25
+           , ""    //  -26
+           , ""    //  -27
+           , ""    //  -28
+           , ""    //  -29
 
-        , "CL_INVALID_VALUE"                            //  -30
-        , "CL_INVALID_DEVICE_TYPE"                      //  -31
-        , "CL_INVALID_PLATFORM"                         //  -32
-        , "CL_INVALID_DEVICE"                           //  -33
-        , "CL_INVALID_CONTEXT"                          //  -34
-        , "CL_INVALID_QUEUE_PROPERTIES"                 //  -35
-        , "CL_INVALID_COMMAND_QUEUE"                    //  -36
-        , "CL_INVALID_HOST_PTR"                         //  -37
-        , "CL_INVALID_MEM_OBJECT"                       //  -38
-        , "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"          //  -39
-        , "CL_INVALID_IMAGE_SIZE"                       //  -40
-        , "CL_INVALID_SAMPLER"                          //  -41
-        , "CL_INVALID_BINARY"                           //  -42
-        , "CL_INVALID_BUILD_OPTIONS"                    //  -43
-        , "CL_INVALID_PROGRAM"                          //  -44
-        , "CL_INVALID_PROGRAM_EXECUTABLE"               //  -45
-        , "CL_INVALID_KERNEL_NAME"                      //  -46
-        , "CL_INVALID_KERNEL_DEFINITION"                //  -47
-        , "CL_INVALID_KERNEL"                           //  -48
-        , "CL_INVALID_ARG_INDEX"                        //  -49
-        , "CL_INVALID_ARG_VALUE"                        //  -50
-        , "CL_INVALID_ARG_SIZE"                         //  -51
-        , "CL_INVALID_KERNEL_ARGS"                      //  -52
-        , "CL_INVALID_WORK_DIMENSION"                   //  -53
-        , "CL_INVALID_WORK_GROUP_SIZE"                  //  -54
-        , "CL_INVALID_WORK_ITEM_SIZE"                   //  -55
-        , "CL_INVALID_GLOBAL_OFFSET"                    //  -56
-        , "CL_INVALID_EVENT_WAIT_LIST"                  //  -57
-        , "CL_INVALID_EVENT"                            //  -58
-        , "CL_INVALID_OPERATION"                        //  -59
-        , "CL_INVALID_GL_OBJECT"                        //  -60
-        , "CL_INVALID_BUFFER_SIZE"                      //  -61
-        , "CL_INVALID_MIP_LEVEL"                        //  -62
-        , "CL_INVALID_GLOBAL_WORK_SIZE"                 //  -63
-    };
+           , "CL_INVALID_VALUE"                            //  -30
+           , "CL_INVALID_DEVICE_TYPE"                      //  -31
+           , "CL_INVALID_PLATFORM"                         //  -32
+           , "CL_INVALID_DEVICE"                           //  -33
+           , "CL_INVALID_CONTEXT"                          //  -34
+           , "CL_INVALID_QUEUE_PROPERTIES"                 //  -35
+           , "CL_INVALID_COMMAND_QUEUE"                    //  -36
+           , "CL_INVALID_HOST_PTR"                         //  -37
+           , "CL_INVALID_MEM_OBJECT"                       //  -38
+           , "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"          //  -39
+           , "CL_INVALID_IMAGE_SIZE"                       //  -40
+           , "CL_INVALID_SAMPLER"                          //  -41
+           , "CL_INVALID_BINARY"                           //  -42
+           , "CL_INVALID_BUILD_OPTIONS"                    //  -43
+           , "CL_INVALID_PROGRAM"                          //  -44
+           , "CL_INVALID_PROGRAM_EXECUTABLE"               //  -45
+           , "CL_INVALID_KERNEL_NAME"                      //  -46
+           , "CL_INVALID_KERNEL_DEFINITION"                //  -47
+           , "CL_INVALID_KERNEL"                           //  -48
+           , "CL_INVALID_ARG_INDEX"                        //  -49
+           , "CL_INVALID_ARG_VALUE"                        //  -50
+           , "CL_INVALID_ARG_SIZE"                         //  -51
+           , "CL_INVALID_KERNEL_ARGS"                      //  -52
+           , "CL_INVALID_WORK_DIMENSION"                   //  -53
+           , "CL_INVALID_WORK_GROUP_SIZE"                  //  -54
+           , "CL_INVALID_WORK_ITEM_SIZE"                   //  -55
+           , "CL_INVALID_GLOBAL_OFFSET"                    //  -56
+           , "CL_INVALID_EVENT_WAIT_LIST"                  //  -57
+           , "CL_INVALID_EVENT"                            //  -58
+           , "CL_INVALID_OPERATION"                        //  -59
+           , "CL_INVALID_GL_OBJECT"                        //  -60
+           , "CL_INVALID_BUFFER_SIZE"                      //  -61
+           , "CL_INVALID_MIP_LEVEL"                        //  -62
+           , "CL_INVALID_GLOBAL_WORK_SIZE"                 //  -63
+       };
 
-    return strings[-error];
+       return strings[-error];
 }
 
 CCL_NAMESPACE_END
index 907d372d3ce5c0fe166fad51517f2450f74189e9..5f3f1667bccec107a70b64ec99e6d1c7dfa3f839 100644 (file)
@@ -339,8 +339,8 @@ typedef cl_uint             cl_command_type;
 typedef cl_uint             cl_profiling_info;
 
 typedef struct _cl_image_format {
-    cl_channel_order        image_channel_order;
-    cl_channel_type         image_channel_data_type;
+       cl_channel_order        image_channel_order;
+       cl_channel_type         image_channel_data_type;
 } cl_image_format;
 
 
index 0b311b0331ab6517156c651943f504b545a37000..328c0c9739158d8791d0def85e7503d0d9df271d 100644 (file)
@@ -55,7 +55,7 @@ static void view_display_text(int x, int y, const char *text)
 
        glRasterPos3f(x, y, 0);
 
-       for(c=text; *c != '\0'; c++)
+       for(c = text; *c != '\0'; c++)
                glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, *c);
 }