diff options
Diffstat (limited to 'intern/cycles/util')
41 files changed, 5012 insertions, 0 deletions
diff --git a/intern/cycles/util/CMakeLists.txt b/intern/cycles/util/CMakeLists.txt new file mode 100644 index 00000000000..3fea6182a97 --- /dev/null +++ b/intern/cycles/util/CMakeLists.txt @@ -0,0 +1,47 @@ + +INCLUDE_DIRECTORIES(.) + +SET(sources + util_cache.cpp + util_cuda.cpp + util_dynlib.cpp + util_md5.cpp + util_path.cpp + util_string.cpp + util_system.cpp + util_time.cpp + util_transform.cpp + util_view.cpp) + +SET(headers + util_algorithm.h + util_args.h + util_boundbox.h + util_cache.h + util_cuda.h + util_debug.h + util_dynlib.h + util_function.h + util_hash.h + util_image.h + util_list.h + util_map.h + util_math.h + util_md5.h + util_opengl.h + util_param.h + util_path.h + util_progress.h + util_set.h + util_string.h + util_system.h + util_thread.h + util_time.h + util_transform.h + util_types.h + util_view.h + util_vector.h + util_xml.h) + +ADD_LIBRARY(util ${sources} ${headers}) + diff --git a/intern/cycles/util/util_algorithm.h b/intern/cycles/util/util_algorithm.h new file mode 100644 index 00000000000..708a2730be7 --- /dev/null +++ b/intern/cycles/util/util_algorithm.h @@ -0,0 +1,35 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_ALGORITHM_H__ +#define __UTIL_ALGORITHM_H__ + +#include <algorithm> + +CCL_NAMESPACE_BEGIN + +using std::sort; +using std::swap; +using std::max; +using std::min; +using std::remove; + +CCL_NAMESPACE_END + +#endif /* __UTIL_ALGORITHM_H__ */ + diff --git a/intern/cycles/util/util_args.h b/intern/cycles/util/util_args.h new file mode 100644 index 00000000000..639fd06bead --- /dev/null +++ b/intern/cycles/util/util_args.h @@ -0,0 +1,34 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_ARGS_H__ +#define __UTIL_ARGS_H__ + +/* Argument Parsing for command line, we use the OpenImageIO + * library because it has nice functions to do this. */ + +#include <OpenImageIO/argparse.h> + +CCL_NAMESPACE_BEGIN + +OIIO_NAMESPACE_USING + +CCL_NAMESPACE_END + +#endif /* __UTIL_ARGS_H__ */ + diff --git a/intern/cycles/util/util_boundbox.h b/intern/cycles/util/util_boundbox.h new file mode 100644 index 00000000000..34cc1d6e11c --- /dev/null +++ b/intern/cycles/util/util_boundbox.h @@ -0,0 +1,98 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_BOUNDBOX_H__ +#define __UTIL_BOUNDBOX_H__ + +#include <float.h> + +#include "util_transform.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +class BoundBox +{ +public: + float3 min, max; + + BoundBox(void) + { + min = make_float3(FLT_MAX, FLT_MAX, FLT_MAX); + max = make_float3(-FLT_MAX, -FLT_MAX, -FLT_MAX); + } + + BoundBox(const float3& min_, const float3& max_) + : min(min_), max(max_) + { + } + + void grow(const float3& pt) + { + min = ccl::min(min, pt); + max = ccl::max(max, pt); + } + + void grow(const BoundBox& bbox) + { + grow(bbox.min); + grow(bbox.max); + } + + void intersect(const BoundBox& bbox) + { + min = ccl::max(min, bbox.min); + max = ccl::min(max, bbox.max); + } + + float area(void) const + { + if(!valid()) + return 0.0f; + + float3 d = max - min; + return dot(d, d)*2.0f; + } + + bool valid(void) const + { + return (min.x <= max.x) && (min.y <= max.y) && (min.z <= max.z); + } + + BoundBox transformed(const Transform *tfm) + { + BoundBox result; + + for(int i = 0; i < 8; i++) { + float3 p; + + p.x = (i & 1)? min.x: max.x; + p.y = (i & 2)? min.y: max.y; + p.z = (i & 4)? min.z: max.z; + + result.grow(transform(tfm, p)); + } + + return result; + } +}; + +CCL_NAMESPACE_END + +#endif /* __UTIL_BOUNDBOX_H__ */ + diff --git a/intern/cycles/util/util_cache.cpp b/intern/cycles/util/util_cache.cpp new file mode 100644 index 00000000000..49a0f62cae8 --- /dev/null +++ b/intern/cycles/util/util_cache.cpp @@ -0,0 +1,93 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdio.h> + +#include "util_cache.h" +#include "util_foreach.h" +#include "util_md5.h" +#include "util_path.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +/* CacheData */ + +CacheData::CacheData(const string& name_) +{ + name = name_; + f = NULL; +} + +CacheData::~CacheData() +{ + if(f) + fclose(f); +} + +/* Cache */ + +Cache Cache::global; + +string Cache::data_filename(const CacheData& key) +{ + MD5Hash hash; + + foreach(const CacheBuffer& buffer, key.buffers) + hash.append((uint8_t*)buffer.data, buffer.size); + + string fname = key.name + "_" + hash.get_hex(); + return path_get("cache/" + fname); +} + +void Cache::insert(const CacheData& key, const CacheData& value) +{ + string filename = data_filename(key); + FILE *f = fopen(filename.c_str(), "wb"); + + if(!f) { + fprintf(stderr, "Failed to open file %s for writing.\n", filename.c_str()); + return; + } + + foreach(const CacheBuffer& buffer, value.buffers) { + if(!fwrite(&buffer.size, sizeof(buffer.size), 1, f)) + fprintf(stderr, "Failed to write to file %s.\n", filename.c_str()); + if(!fwrite(buffer.data, buffer.size, 1, f)) + fprintf(stderr, "Failed to write to file %s.\n", filename.c_str()); + } + + fclose(f); +} + +bool Cache::lookup(const CacheData& key, CacheData& value) +{ + string filename = data_filename(key); + FILE *f = fopen(filename.c_str(), "rb"); + + if(!f) + return false; + + value.name = key.name; + value.f = f; + + return true; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_cache.h b/intern/cycles/util/util_cache.h new file mode 100644 index 00000000000..25b1f2e7a51 --- /dev/null +++ b/intern/cycles/util/util_cache.h @@ -0,0 +1,132 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_CACHE_H__ +#define __UTIL_CACHE_H__ + +/* Disk Cache based on Hashing + * + * To be used to cache expensive computations. The hash key is created from an + * arbitrary number of bytes, by hashing the bytes using MD5, which then gives + * the file name containing the data. This data then is read from the file + * again into the appropriate data structures. + * + * This way we do not need to accurately track changes, compare dates and + * invalidate cache entries, at the cost of exta computation. If everything + * is stored in a global cache, computations can perhaps even be shared between + * different scenes where it may be hard to detect duplicate work. + */ + +#include "util_string.h" +#include "util_vector.h" + +CCL_NAMESPACE_BEGIN + +class CacheBuffer { +public: + const void *data; + size_t size; + + CacheBuffer(const void *data_, size_t size_) + { data = data_; size = size_; } +}; + +class CacheData { +public: + vector<CacheBuffer> buffers; + string name; + FILE *f; + + CacheData(const string& name = ""); + ~CacheData(); + + template<typename T> void add(const vector<T>& data) + { + CacheBuffer buffer(&data[0], data.size()*sizeof(T)); + buffers.push_back(buffer); + } + + template<typename T> void add(const array<T>& data) + { + CacheBuffer buffer(&data[0], data.size()*sizeof(T)); + buffers.push_back(buffer); + } + + void add(void *data, size_t size) + { + CacheBuffer buffer(data, size); + buffers.push_back(buffer); + } + + void add(int& data) + { + CacheBuffer buffer(&data, sizeof(int)); + buffers.push_back(buffer); + } + + void add(size_t& data) + { + CacheBuffer buffer(&data, sizeof(size_t)); + buffers.push_back(buffer); + } + + template<typename T> void read(array<T>& data) + { + size_t size; + + if(!fread(&size, sizeof(size), 1, f)) { + fprintf(stderr, "Failed to read vector size from cache.\n"); + return; + } + + data.resize(size/sizeof(T)); + + if(!fread(&data[0], size, 1, f)) { + fprintf(stderr, "Failed to read vector data from cache (%ld).\n", size); + return; + } + } + + void read(int& data) + { + if(!fread(&data, sizeof(data), 1, f)) + fprintf(stderr, "Failed to read int from cache.\n"); + } + + void read(size_t& data) + { + if(!fread(&data, sizeof(data), 1, f)) + fprintf(stderr, "Failed to read size_t from cache.\n"); + } +}; + +class Cache { +public: + static Cache global; + + void insert(const CacheData& key, const CacheData& value); + bool lookup(const CacheData& key, CacheData& value); + +protected: + string data_filename(const CacheData& key); +}; + +CCL_NAMESPACE_END + +#endif /* __UTIL_CACHE_H__ */ + diff --git a/intern/cycles/util/util_color.h b/intern/cycles/util/util_color.h new file mode 100644 index 00000000000..fbba0fade63 --- /dev/null +++ b/intern/cycles/util/util_color.h @@ -0,0 +1,46 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_COLOR_H__ +#define __UTIL_COLOR_H__ + +#include "util_math.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +__device float color_srgb_to_scene_linear(float c) +{ + if(c < 0.04045f) + return (c < 0.0f)? 0.0f: c * (1.0f/12.92f); + else + return pow((c + 0.055f)*(1.0f/1.055f), 2.4f); +} + +__device float color_scene_linear_to_srgb(float c) +{ + if(c < 0.0031308f) + return (c < 0.0f)? 0.0f: c * 12.92f; + else + return 1.055f * pow(c, 1.0f/2.4f) - 0.055f; +} + +CCL_NAMESPACE_END + +#endif /* __UTIL_COLOR_H__ */ + diff --git a/intern/cycles/util/util_cuda.cpp b/intern/cycles/util/util_cuda.cpp new file mode 100644 index 00000000000..15ce7efd9ee --- /dev/null +++ b/intern/cycles/util/util_cuda.cpp @@ -0,0 +1,379 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "util_cuda.h" +#include "util_debug.h" +#include "util_dynlib.h" + +/* function defininitions */ + +tcuInit *cuInit; +tcuDriverGetVersion *cuDriverGetVersion; +tcuDeviceGet *cuDeviceGet; +tcuDeviceGetCount *cuDeviceGetCount; +tcuDeviceGetName *cuDeviceGetName; +tcuDeviceComputeCapability *cuDeviceComputeCapability; +tcuDeviceTotalMem *cuDeviceTotalMem; +tcuDeviceGetProperties *cuDeviceGetProperties; +tcuDeviceGetAttribute *cuDeviceGetAttribute; +tcuCtxCreate *cuCtxCreate; +tcuCtxDestroy *cuCtxDestroy; +tcuCtxAttach *cuCtxAttach; +tcuCtxDetach *cuCtxDetach; +tcuCtxPushCurrent *cuCtxPushCurrent; +tcuCtxPopCurrent *cuCtxPopCurrent; +tcuCtxGetDevice *cuCtxGetDevice; +tcuCtxSynchronize *cuCtxSynchronize; +tcuModuleLoad *cuModuleLoad; +tcuModuleLoadData *cuModuleLoadData; +tcuModuleLoadDataEx *cuModuleLoadDataEx; +tcuModuleLoadFatBinary *cuModuleLoadFatBinary; +tcuModuleUnload *cuModuleUnload; +tcuModuleGetFunction *cuModuleGetFunction; +tcuModuleGetGlobal *cuModuleGetGlobal; +tcuModuleGetTexRef *cuModuleGetTexRef; +tcuModuleGetSurfRef *cuModuleGetSurfRef; +tcuMemGetInfo *cuMemGetInfo; +tcuMemAlloc *cuMemAlloc; +tcuMemAllocPitch *cuMemAllocPitch; +tcuMemFree *cuMemFree; +tcuMemGetAddressRange *cuMemGetAddressRange; +tcuMemAllocHost *cuMemAllocHost; +tcuMemFreeHost *cuMemFreeHost; +tcuMemHostAlloc *cuMemHostAlloc; +tcuMemHostGetDevicePointer *cuMemHostGetDevicePointer; +tcuMemHostGetFlags *cuMemHostGetFlags; +tcuMemcpyHtoD *cuMemcpyHtoD; +tcuMemcpyDtoH *cuMemcpyDtoH; +tcuMemcpyDtoD *cuMemcpyDtoD; +tcuMemcpyDtoA *cuMemcpyDtoA; +tcuMemcpyAtoD *cuMemcpyAtoD; +tcuMemcpyHtoA *cuMemcpyHtoA; +tcuMemcpyAtoH *cuMemcpyAtoH; +tcuMemcpyAtoA *cuMemcpyAtoA; +tcuMemcpy2D *cuMemcpy2D; +tcuMemcpy2DUnaligned *cuMemcpy2DUnaligned; +tcuMemcpy3D *cuMemcpy3D; +tcuMemcpyHtoDAsync *cuMemcpyHtoDAsync; +tcuMemcpyDtoHAsync *cuMemcpyDtoHAsync; +tcuMemcpyDtoDAsync *cuMemcpyDtoDAsync; +tcuMemcpyHtoAAsync *cuMemcpyHtoAAsync; +tcuMemcpyAtoHAsync *cuMemcpyAtoHAsync; +tcuMemcpy2DAsync *cuMemcpy2DAsync; +tcuMemcpy3DAsync *cuMemcpy3DAsync; +tcuMemsetD8 *cuMemsetD8; +tcuMemsetD16 *cuMemsetD16; +tcuMemsetD32 *cuMemsetD32; +tcuMemsetD2D8 *cuMemsetD2D8; +tcuMemsetD2D16 *cuMemsetD2D16; +tcuMemsetD2D32 *cuMemsetD2D32; +tcuFuncSetBlockShape *cuFuncSetBlockShape; +tcuFuncSetSharedSize *cuFuncSetSharedSize; +tcuFuncGetAttribute *cuFuncGetAttribute; +tcuFuncSetCacheConfig *cuFuncSetCacheConfig; +tcuArrayCreate *cuArrayCreate; +tcuArrayGetDescriptor *cuArrayGetDescriptor; +tcuArrayDestroy *cuArrayDestroy; +tcuArray3DCreate *cuArray3DCreate; +tcuArray3DGetDescriptor *cuArray3DGetDescriptor; +tcuTexRefCreate *cuTexRefCreate; +tcuTexRefDestroy *cuTexRefDestroy; +tcuTexRefSetArray *cuTexRefSetArray; +tcuTexRefSetAddress *cuTexRefSetAddress; +tcuTexRefSetAddress2D *cuTexRefSetAddress2D; +tcuTexRefSetFormat *cuTexRefSetFormat; +tcuTexRefSetAddressMode *cuTexRefSetAddressMode; +tcuTexRefSetFilterMode *cuTexRefSetFilterMode; +tcuTexRefSetFlags *cuTexRefSetFlags; +tcuTexRefGetAddress *cuTexRefGetAddress; +tcuTexRefGetArray *cuTexRefGetArray; +tcuTexRefGetAddressMode *cuTexRefGetAddressMode; +tcuTexRefGetFilterMode *cuTexRefGetFilterMode; +tcuTexRefGetFormat *cuTexRefGetFormat; +tcuTexRefGetFlags *cuTexRefGetFlags; +tcuSurfRefSetArray *cuSurfRefSetArray; +tcuSurfRefGetArray *cuSurfRefGetArray; +tcuParamSetSize *cuParamSetSize; +tcuParamSeti *cuParamSeti; +tcuParamSetf *cuParamSetf; +tcuParamSetv *cuParamSetv; +tcuParamSetTexRef *cuParamSetTexRef; +tcuLaunch *cuLaunch; +tcuLaunchGrid *cuLaunchGrid; +tcuLaunchGridAsync *cuLaunchGridAsync; +tcuEventCreate *cuEventCreate; +tcuEventRecord *cuEventRecord; +tcuEventQuery *cuEventQuery; +tcuEventSynchronize *cuEventSynchronize; +tcuEventDestroy *cuEventDestroy; +tcuEventElapsedTime *cuEventElapsedTime; +tcuStreamCreate *cuStreamCreate; +tcuStreamQuery *cuStreamQuery; +tcuStreamSynchronize *cuStreamSynchronize; +tcuStreamDestroy *cuStreamDestroy; +tcuGraphicsUnregisterResource *cuGraphicsUnregisterResource; +tcuGraphicsSubResourceGetMappedArray *cuGraphicsSubResourceGetMappedArray; +tcuGraphicsResourceGetMappedPointer *cuGraphicsResourceGetMappedPointer; +tcuGraphicsResourceSetMapFlags *cuGraphicsResourceSetMapFlags; +tcuGraphicsMapResources *cuGraphicsMapResources; +tcuGraphicsUnmapResources *cuGraphicsUnmapResources; +tcuGetExportTable *cuGetExportTable; +tcuCtxSetLimit *cuCtxSetLimit; +tcuCtxGetLimit *cuCtxGetLimit; +tcuGLCtxCreate *cuGLCtxCreate; +tcuGraphicsGLRegisterBuffer *cuGraphicsGLRegisterBuffer; +tcuGraphicsGLRegisterImage *cuGraphicsGLRegisterImage; +tcuCtxSetCurrent *cuCtxSetCurrent; + +CCL_NAMESPACE_BEGIN + +/* utility macros */ + +#define CUDA_LIBRARY_FIND(name) \ + name = (t##name*)dynamic_library_find(lib, #name); \ + assert(name); + +#define CUDA_LIBRARY_FIND_V2(name) \ + name = (t##name*)dynamic_library_find(lib, #name "_v2"); \ + assert(name); + +/* initialization function */ + +bool cuLibraryInit() +{ + static bool initialized = false; + static bool result = false; + + if(initialized) + return result; + + initialized = true; + + /* library paths */ +#ifdef _WIN32 + /* expected in c:/windows/system or similar, no path needed */ + const char *path = "nvcuda.dll"; +#elif defined(__APPLE__) + /* default installation path */ + const char *path = "/usr/local/cuda/lib/libcuda.dylib"; +#else + const char *path = "libcuda.so"; +#endif + + /* load library */ + DynamicLibrary *lib = dynamic_library_open(path); + + if(lib == NULL) + return false; + + /* detect driver version */ + int driver_version = 1000; + + CUDA_LIBRARY_FIND(cuDriverGetVersion); + if(cuDriverGetVersion) + cuDriverGetVersion(&driver_version); + + /* we require version 4.0 */ + if(driver_version < 4000) + return false; + + /* fetch all function pointers */ + CUDA_LIBRARY_FIND(cuInit); + CUDA_LIBRARY_FIND(cuDeviceGet); + CUDA_LIBRARY_FIND(cuDeviceGetCount); + CUDA_LIBRARY_FIND(cuDeviceGetName); + CUDA_LIBRARY_FIND(cuDeviceComputeCapability); + CUDA_LIBRARY_FIND(cuDeviceTotalMem); + CUDA_LIBRARY_FIND(cuDeviceGetProperties); + CUDA_LIBRARY_FIND(cuDeviceGetAttribute); + CUDA_LIBRARY_FIND(cuCtxCreate); + CUDA_LIBRARY_FIND(cuCtxDestroy); + CUDA_LIBRARY_FIND(cuCtxAttach); + CUDA_LIBRARY_FIND(cuCtxDetach); + CUDA_LIBRARY_FIND(cuCtxPushCurrent); + CUDA_LIBRARY_FIND(cuCtxPopCurrent); + CUDA_LIBRARY_FIND(cuCtxGetDevice); + CUDA_LIBRARY_FIND(cuCtxSynchronize); + CUDA_LIBRARY_FIND(cuModuleLoad); + CUDA_LIBRARY_FIND(cuModuleLoadData); + CUDA_LIBRARY_FIND(cuModuleUnload); + CUDA_LIBRARY_FIND(cuModuleGetFunction); + CUDA_LIBRARY_FIND(cuModuleGetGlobal); + CUDA_LIBRARY_FIND(cuModuleGetTexRef); + CUDA_LIBRARY_FIND(cuMemGetInfo); + CUDA_LIBRARY_FIND(cuMemAlloc); + CUDA_LIBRARY_FIND(cuMemAllocPitch); + CUDA_LIBRARY_FIND(cuMemFree); + CUDA_LIBRARY_FIND(cuMemGetAddressRange); + CUDA_LIBRARY_FIND(cuMemAllocHost); + CUDA_LIBRARY_FIND(cuMemFreeHost); + CUDA_LIBRARY_FIND(cuMemHostAlloc); + CUDA_LIBRARY_FIND(cuMemHostGetDevicePointer); + CUDA_LIBRARY_FIND(cuMemcpyHtoD); + CUDA_LIBRARY_FIND(cuMemcpyDtoH); + CUDA_LIBRARY_FIND(cuMemcpyDtoD); + CUDA_LIBRARY_FIND(cuMemcpyDtoA); + CUDA_LIBRARY_FIND(cuMemcpyAtoD); + CUDA_LIBRARY_FIND(cuMemcpyHtoA); + CUDA_LIBRARY_FIND(cuMemcpyAtoH); + CUDA_LIBRARY_FIND(cuMemcpyAtoA); + CUDA_LIBRARY_FIND(cuMemcpy2D); + CUDA_LIBRARY_FIND(cuMemcpy2DUnaligned); + CUDA_LIBRARY_FIND(cuMemcpy3D); + CUDA_LIBRARY_FIND(cuMemcpyHtoDAsync); + CUDA_LIBRARY_FIND(cuMemcpyDtoHAsync); + CUDA_LIBRARY_FIND(cuMemcpyHtoAAsync); + CUDA_LIBRARY_FIND(cuMemcpyAtoHAsync); + CUDA_LIBRARY_FIND(cuMemcpy2DAsync); + CUDA_LIBRARY_FIND(cuMemcpy3DAsync); + CUDA_LIBRARY_FIND(cuMemsetD8); + CUDA_LIBRARY_FIND(cuMemsetD16); + CUDA_LIBRARY_FIND(cuMemsetD32); + CUDA_LIBRARY_FIND(cuMemsetD2D8); + CUDA_LIBRARY_FIND(cuMemsetD2D16); + CUDA_LIBRARY_FIND(cuMemsetD2D32); + CUDA_LIBRARY_FIND(cuFuncSetBlockShape); + CUDA_LIBRARY_FIND(cuFuncSetSharedSize); + CUDA_LIBRARY_FIND(cuFuncGetAttribute); + CUDA_LIBRARY_FIND(cuArrayCreate); + CUDA_LIBRARY_FIND(cuArrayGetDescriptor); + CUDA_LIBRARY_FIND(cuArrayDestroy); + CUDA_LIBRARY_FIND(cuArray3DCreate); + CUDA_LIBRARY_FIND(cuArray3DGetDescriptor); + CUDA_LIBRARY_FIND(cuTexRefCreate); + CUDA_LIBRARY_FIND(cuTexRefDestroy); + CUDA_LIBRARY_FIND(cuTexRefSetArray); + CUDA_LIBRARY_FIND(cuTexRefSetAddress); + CUDA_LIBRARY_FIND(cuTexRefSetAddress2D); + CUDA_LIBRARY_FIND(cuTexRefSetFormat); + CUDA_LIBRARY_FIND(cuTexRefSetAddressMode); + CUDA_LIBRARY_FIND(cuTexRefSetFilterMode); + CUDA_LIBRARY_FIND(cuTexRefSetFlags); + CUDA_LIBRARY_FIND(cuTexRefGetAddress); + CUDA_LIBRARY_FIND(cuTexRefGetArray); + CUDA_LIBRARY_FIND(cuTexRefGetAddressMode); + CUDA_LIBRARY_FIND(cuTexRefGetFilterMode); + CUDA_LIBRARY_FIND(cuTexRefGetFormat); + CUDA_LIBRARY_FIND(cuTexRefGetFlags); + CUDA_LIBRARY_FIND(cuParamSetSize); + CUDA_LIBRARY_FIND(cuParamSeti); + CUDA_LIBRARY_FIND(cuParamSetf); + CUDA_LIBRARY_FIND(cuParamSetv); + CUDA_LIBRARY_FIND(cuParamSetTexRef); + CUDA_LIBRARY_FIND(cuLaunch); + CUDA_LIBRARY_FIND(cuLaunchGrid); + CUDA_LIBRARY_FIND(cuLaunchGridAsync); + CUDA_LIBRARY_FIND(cuEventCreate); + CUDA_LIBRARY_FIND(cuEventRecord); + CUDA_LIBRARY_FIND(cuEventQuery); + CUDA_LIBRARY_FIND(cuEventSynchronize); + CUDA_LIBRARY_FIND(cuEventDestroy); + CUDA_LIBRARY_FIND(cuEventElapsedTime); + CUDA_LIBRARY_FIND(cuStreamCreate); + CUDA_LIBRARY_FIND(cuStreamQuery); + CUDA_LIBRARY_FIND(cuStreamSynchronize); + CUDA_LIBRARY_FIND(cuStreamDestroy); + + /* cuda 2.1 */ + CUDA_LIBRARY_FIND(cuModuleLoadDataEx); + CUDA_LIBRARY_FIND(cuModuleLoadFatBinary); + CUDA_LIBRARY_FIND(cuGLCtxCreate); + CUDA_LIBRARY_FIND(cuGraphicsGLRegisterBuffer); + CUDA_LIBRARY_FIND(cuGraphicsGLRegisterImage); + + /* cuda 2.3 */ + CUDA_LIBRARY_FIND(cuMemHostGetFlags); + CUDA_LIBRARY_FIND(cuGraphicsGLRegisterBuffer); + CUDA_LIBRARY_FIND(cuGraphicsGLRegisterImage); + + /* cuda 3.0 */ + CUDA_LIBRARY_FIND(cuMemcpyDtoDAsync); + CUDA_LIBRARY_FIND(cuFuncSetCacheConfig); + CUDA_LIBRARY_FIND(cuGraphicsUnregisterResource); + CUDA_LIBRARY_FIND(cuGraphicsSubResourceGetMappedArray); + CUDA_LIBRARY_FIND(cuGraphicsResourceGetMappedPointer); + CUDA_LIBRARY_FIND(cuGraphicsResourceSetMapFlags); + CUDA_LIBRARY_FIND(cuGraphicsMapResources); + CUDA_LIBRARY_FIND(cuGraphicsUnmapResources); + CUDA_LIBRARY_FIND(cuGetExportTable); + + /* cuda 3.1 */ + CUDA_LIBRARY_FIND(cuModuleGetSurfRef); + CUDA_LIBRARY_FIND(cuSurfRefSetArray); + CUDA_LIBRARY_FIND(cuSurfRefGetArray); + CUDA_LIBRARY_FIND(cuCtxSetLimit); + 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. */ + CUDA_LIBRARY_FIND_V2(cuDeviceTotalMem); + CUDA_LIBRARY_FIND_V2(cuCtxCreate); + CUDA_LIBRARY_FIND_V2(cuModuleGetGlobal); + CUDA_LIBRARY_FIND_V2(cuMemGetInfo); + CUDA_LIBRARY_FIND_V2(cuMemAlloc); + CUDA_LIBRARY_FIND_V2(cuMemAllocPitch); + CUDA_LIBRARY_FIND_V2(cuMemFree); + CUDA_LIBRARY_FIND_V2(cuMemGetAddressRange); + CUDA_LIBRARY_FIND_V2(cuMemAllocHost); + CUDA_LIBRARY_FIND_V2(cuMemHostGetDevicePointer); + CUDA_LIBRARY_FIND_V2(cuMemcpyHtoD); + CUDA_LIBRARY_FIND_V2(cuMemcpyDtoH); + CUDA_LIBRARY_FIND_V2(cuMemcpyDtoD); + CUDA_LIBRARY_FIND_V2(cuMemcpyDtoA); + CUDA_LIBRARY_FIND_V2(cuMemcpyAtoD); + CUDA_LIBRARY_FIND_V2(cuMemcpyHtoA); + CUDA_LIBRARY_FIND_V2(cuMemcpyAtoH); + CUDA_LIBRARY_FIND_V2(cuMemcpyAtoA); + CUDA_LIBRARY_FIND_V2(cuMemcpyHtoAAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpyAtoHAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpy2D); + CUDA_LIBRARY_FIND_V2(cuMemcpy2DUnaligned); + CUDA_LIBRARY_FIND_V2(cuMemcpy3D); + CUDA_LIBRARY_FIND_V2(cuMemcpyHtoDAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpyDtoHAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpyDtoDAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpy2DAsync); + CUDA_LIBRARY_FIND_V2(cuMemcpy3DAsync); + CUDA_LIBRARY_FIND_V2(cuMemsetD8); + CUDA_LIBRARY_FIND_V2(cuMemsetD16); + CUDA_LIBRARY_FIND_V2(cuMemsetD32); + CUDA_LIBRARY_FIND_V2(cuMemsetD2D8); + CUDA_LIBRARY_FIND_V2(cuMemsetD2D16); + CUDA_LIBRARY_FIND_V2(cuMemsetD2D32); + CUDA_LIBRARY_FIND_V2(cuArrayCreate); + CUDA_LIBRARY_FIND_V2(cuArrayGetDescriptor); + CUDA_LIBRARY_FIND_V2(cuArray3DCreate); + CUDA_LIBRARY_FIND_V2(cuArray3DGetDescriptor); + CUDA_LIBRARY_FIND_V2(cuTexRefSetAddress); + CUDA_LIBRARY_FIND_V2(cuTexRefSetAddress2D); + CUDA_LIBRARY_FIND_V2(cuTexRefGetAddress); + CUDA_LIBRARY_FIND_V2(cuGraphicsResourceGetMappedPointer); + CUDA_LIBRARY_FIND_V2(cuGLCtxCreate); + + /* cuda 4.0 */ + CUDA_LIBRARY_FIND(cuCtxSetCurrent); + + /* success */ + result = true; + + return result; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_cuda.h b/intern/cycles/util/util_cuda.h new file mode 100644 index 00000000000..ecfaddf43cb --- /dev/null +++ b/intern/cycles/util/util_cuda.h @@ -0,0 +1,619 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_CUDA_H__ +#define __UTIL_CUDA_H__ + +#include <stdlib.h> +#include "util_opengl.h" + +CCL_NAMESPACE_BEGIN + +/* CUDA is linked in dynamically at runtime, so we can start the application + * without requiring a CUDA installation. Code adapted from the example + * matrixMulDynlinkJIT in the CUDA SDK. */ + +bool cuLibraryInit(); + +CCL_NAMESPACE_END + +/* defines, structs, enums */ + +#define CUDA_VERSION 3020 + +#if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64) +typedef unsigned long long CUdeviceptr; +#else +typedef unsigned int CUdeviceptr; +#endif + +typedef int CUdevice; +typedef struct CUctx_st *CUcontext; +typedef struct CUmod_st *CUmodule; +typedef struct CUfunc_st *CUfunction; +typedef struct CUarray_st *CUarray; +typedef struct CUtexref_st *CUtexref; +typedef struct CUsurfref_st *CUsurfref; +typedef struct CUevent_st *CUevent; +typedef struct CUstream_st *CUstream; +typedef struct CUgraphicsResource_st *CUgraphicsResource; + +typedef struct CUuuid_st { + 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 +} CUctx_flags; + +typedef enum CUevent_flags_enum { + 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 +} 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 +} CUaddress_mode; + +typedef enum CUfilter_mode_enum { + 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 +} 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; +} 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 +} 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 +} CUfunc_cache; + +typedef enum CUmemorytype_enum { + 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 +} 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 + +} 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 +} CUjit_target; + +typedef enum CUjit_fallback_enum +{ + CU_PREFER_PTX = 0, + CU_PREFER_BINARY + +} CUjit_fallback; + +typedef enum CUgraphicsRegisterFlags_enum { + 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 +} 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 +} CUarray_cubemap_face; + +typedef enum CUlimit_enum { + 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 +} CUresult; + +#define CU_MEMHOSTALLOC_PORTABLE 0x01 +#define CU_MEMHOSTALLOC_DEVICEMAP 0x02 +#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; +} 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; +} CUDA_MEMCPY3D; + +typedef struct CUDA_ARRAY_DESCRIPTOR_st +{ + size_t Width; + size_t Height; + + CUarray_format Format; + unsigned int NumChannels; +} CUDA_ARRAY_DESCRIPTOR; + +typedef struct CUDA_ARRAY3D_DESCRIPTOR_st +{ + size_t Width; + size_t Height; + size_t Depth; + + CUarray_format Format; + unsigned int NumChannels; + unsigned int Flags; +} CUDA_ARRAY3D_DESCRIPTOR; + +#define CUDA_ARRAY3D_2DARRAY 0x01 +#define CUDA_ARRAY3D_SURFACE_LDST 0x02 +#define CU_TRSA_OVERRIDE_FORMAT 0x01 +#define CU_TRSF_READ_AS_INTEGER 0x01 +#define CU_TRSF_NORMALIZED_COORDINATES 0x02 +#define CU_TRSF_SRGB 0x10 +#define CU_PARAM_TR_DEFAULT -1 + +#ifdef _WIN32 +#define CUDAAPI __stdcall +#else +#define CUDAAPI +#endif + +/* function types */ + +typedef CUresult CUDAAPI tcuInit(unsigned int Flags); +typedef CUresult CUDAAPI tcuDriverGetVersion(int *driverVersion); +typedef CUresult CUDAAPI tcuDeviceGet(CUdevice *device, int ordinal); +typedef CUresult CUDAAPI tcuDeviceGetCount(int *count); +typedef CUresult CUDAAPI tcuDeviceGetName(char *name, int len, CUdevice dev); +typedef CUresult CUDAAPI tcuDeviceComputeCapability(int *major, int *minor, CUdevice dev); +typedef CUresult CUDAAPI tcuDeviceTotalMem(size_t *bytes, CUdevice dev); +typedef CUresult CUDAAPI tcuDeviceGetProperties(CUdevprop *prop, CUdevice dev); +typedef CUresult CUDAAPI tcuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevice dev); +typedef CUresult CUDAAPI tcuCtxCreate(CUcontext *pctx, unsigned int flags, CUdevice dev); +typedef CUresult CUDAAPI tcuCtxDestroy(CUcontext ctx); +typedef CUresult CUDAAPI tcuCtxAttach(CUcontext *pctx, unsigned int flags); +typedef CUresult CUDAAPI tcuCtxDetach(CUcontext ctx); +typedef CUresult CUDAAPI tcuCtxPushCurrent(CUcontext ctx ); +typedef CUresult CUDAAPI tcuCtxPopCurrent(CUcontext *pctx); +typedef CUresult CUDAAPI tcuCtxGetDevice(CUdevice *device); +typedef CUresult CUDAAPI tcuCtxSynchronize(void); +typedef CUresult CUDAAPI tcuCtxSetLimit(CUlimit limit, size_t value); +typedef CUresult CUDAAPI tcuCtxGetLimit(size_t *pvalue, CUlimit limit); +typedef CUresult CUDAAPI tcuCtxGetCacheConfig(CUfunc_cache *pconfig); +typedef CUresult CUDAAPI tcuCtxSetCacheConfig(CUfunc_cache config); +typedef CUresult CUDAAPI tcuCtxGetApiVersion(CUcontext ctx, unsigned int *version); +typedef CUresult CUDAAPI tcuModuleLoad(CUmodule *module, const char *fname); +typedef CUresult CUDAAPI tcuModuleLoadData(CUmodule *module, const void *image); +typedef CUresult CUDAAPI tcuModuleLoadDataEx(CUmodule *module, const void *image, unsigned int numOptions, CUjit_option *options, void **optionValues); +typedef CUresult CUDAAPI tcuModuleLoadFatBinary(CUmodule *module, const void *fatCubin); +typedef CUresult CUDAAPI tcuModuleUnload(CUmodule hmod); +typedef CUresult CUDAAPI tcuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, const char *name); +typedef CUresult CUDAAPI tcuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char *name); +typedef CUresult CUDAAPI tcuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, const char *name); +typedef CUresult CUDAAPI tcuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const char *name); +typedef CUresult CUDAAPI tcuMemGetInfo(size_t *free, size_t *total); +typedef CUresult CUDAAPI tcuMemAlloc(CUdeviceptr *dptr, size_t bytesize); +typedef CUresult CUDAAPI tcuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes); +typedef CUresult CUDAAPI tcuMemFree(CUdeviceptr dptr); +typedef CUresult CUDAAPI tcuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdeviceptr dptr); +typedef CUresult CUDAAPI tcuMemAllocHost(void **pp, size_t bytesize); +typedef CUresult CUDAAPI tcuMemFreeHost(void *p); +typedef CUresult CUDAAPI tcuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags); +typedef CUresult CUDAAPI tcuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags); +typedef CUresult CUDAAPI tcuMemHostGetFlags(unsigned int *pFlags, void *p); +typedef CUresult CUDAAPI tcuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount); +typedef CUresult CUDAAPI tcuMemcpy2D(const CUDA_MEMCPY2D *pCopy); +typedef CUresult CUDAAPI tcuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); +typedef CUresult CUDAAPI tcuMemcpy3D(const CUDA_MEMCPY3D *pCopy); +typedef CUresult CUDAAPI tcuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); +typedef CUresult CUDAAPI tcuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N); +typedef CUresult CUDAAPI tcuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N); +typedef CUresult CUDAAPI tcuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N); +typedef CUresult CUDAAPI tcuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height); +typedef CUresult CUDAAPI tcuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height); +typedef CUresult CUDAAPI tcuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height); +typedef CUresult CUDAAPI tcuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream); +typedef CUresult CUDAAPI tcuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream); +typedef CUresult CUDAAPI tcuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pAllocateArray); +typedef CUresult CUDAAPI tcuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray); +typedef CUresult CUDAAPI tcuArrayDestroy(CUarray hArray); +typedef CUresult CUDAAPI tcuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray); +typedef CUresult CUDAAPI tcuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray); +typedef CUresult CUDAAPI tcuStreamCreate(CUstream *phStream, unsigned int Flags); +typedef CUresult CUDAAPI tcuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags); +typedef CUresult CUDAAPI tcuStreamQuery(CUstream hStream); +typedef CUresult CUDAAPI tcuStreamSynchronize(CUstream hStream); +typedef CUresult CUDAAPI tcuStreamDestroy(CUstream hStream); +typedef CUresult CUDAAPI tcuEventCreate(CUevent *phEvent, unsigned int Flags); +typedef CUresult CUDAAPI tcuEventRecord(CUevent hEvent, CUstream hStream); +typedef CUresult CUDAAPI tcuEventQuery(CUevent hEvent); +typedef CUresult CUDAAPI tcuEventSynchronize(CUevent hEvent); +typedef CUresult CUDAAPI tcuEventDestroy(CUevent hEvent); +typedef CUresult CUDAAPI tcuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUevent hEnd); +typedef CUresult CUDAAPI tcuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z); +typedef CUresult CUDAAPI tcuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes); +typedef CUresult CUDAAPI tcuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunction hfunc); +typedef CUresult CUDAAPI tcuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config); +typedef CUresult CUDAAPI tcuParamSetSize(CUfunction hfunc, unsigned int numbytes); +typedef CUresult CUDAAPI tcuParamSeti(CUfunction hfunc, int offset, unsigned int value); +typedef CUresult CUDAAPI tcuParamSetf(CUfunction hfunc, int offset, float value); +typedef CUresult CUDAAPI tcuParamSetv(CUfunction hfunc, int offset, void *ptr, unsigned int numbytes); +typedef CUresult CUDAAPI tcuLaunch(CUfunction f); +typedef CUresult CUDAAPI tcuLaunchGrid(CUfunction f, int grid_width, int grid_height); +typedef CUresult CUDAAPI tcuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream); +typedef CUresult CUDAAPI tcuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags); +typedef CUresult CUDAAPI tcuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t bytes); +typedef CUresult CUDAAPI tcuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch); +typedef CUresult CUDAAPI tcuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents); +typedef CUresult CUDAAPI tcuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am); +typedef CUresult CUDAAPI tcuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm); +typedef CUresult CUDAAPI tcuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags); +typedef CUresult CUDAAPI tcuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefGetArray(CUarray *phArray, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, int dim); +typedef CUresult CUDAAPI tcuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef); +typedef CUresult CUDAAPI tcuTexRefCreate(CUtexref *pTexRef); +typedef CUresult CUDAAPI tcuTexRefDestroy(CUtexref hTexRef); +typedef CUresult CUDAAPI tcuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags); +typedef CUresult CUDAAPI tcuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); +typedef CUresult CUDAAPI tcuGraphicsUnregisterResource(CUgraphicsResource resource); +typedef CUresult CUDAAPI tcuGraphicsSubResourceGetMappedArray(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel); +typedef CUresult CUDAAPI tcuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource); +typedef CUresult CUDAAPI tcuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags); +typedef CUresult CUDAAPI tcuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); +typedef CUresult CUDAAPI tcuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); +typedef CUresult CUDAAPI tcuGetExportTable(const void **ppExportTable, const CUuuid *pExportTableId); +typedef CUresult CUDAAPI tcuGLCtxCreate(CUcontext *pCtx, unsigned int Flags, CUdevice device ); +typedef CUresult CUDAAPI tcuGraphicsGLRegisterBuffer(CUgraphicsResource *pCudaResource, GLuint buffer, unsigned int Flags); +typedef CUresult CUDAAPI tcuGraphicsGLRegisterImage(CUgraphicsResource *pCudaResource, GLuint image, GLenum target, unsigned int Flags); +typedef CUresult CUDAAPI tcuCtxSetCurrent(CUcontext ctx); + +/* function declarations */ + +extern tcuInit *cuInit; +extern tcuDriverGetVersion *cuDriverGetVersion; +extern tcuDeviceGet *cuDeviceGet; +extern tcuDeviceGetCount *cuDeviceGetCount; +extern tcuDeviceGetName *cuDeviceGetName; +extern tcuDeviceComputeCapability *cuDeviceComputeCapability; +extern tcuDeviceTotalMem *cuDeviceTotalMem; +extern tcuDeviceGetProperties *cuDeviceGetProperties; +extern tcuDeviceGetAttribute *cuDeviceGetAttribute; +extern tcuCtxCreate *cuCtxCreate; +extern tcuCtxDestroy *cuCtxDestroy; +extern tcuCtxAttach *cuCtxAttach; +extern tcuCtxDetach *cuCtxDetach; +extern tcuCtxPushCurrent *cuCtxPushCurrent; +extern tcuCtxPopCurrent *cuCtxPopCurrent; +extern tcuCtxGetDevice *cuCtxGetDevice; +extern tcuCtxSynchronize *cuCtxSynchronize; +extern tcuModuleLoad *cuModuleLoad; +extern tcuModuleLoadData *cuModuleLoadData; +extern tcuModuleLoadDataEx *cuModuleLoadDataEx; +extern tcuModuleLoadFatBinary *cuModuleLoadFatBinary; +extern tcuModuleUnload *cuModuleUnload; +extern tcuModuleGetFunction *cuModuleGetFunction; +extern tcuModuleGetGlobal *cuModuleGetGlobal; +extern tcuModuleGetTexRef *cuModuleGetTexRef; +extern tcuModuleGetSurfRef *cuModuleGetSurfRef; +extern tcuMemGetInfo *cuMemGetInfo; +extern tcuMemAlloc *cuMemAlloc; +extern tcuMemAllocPitch *cuMemAllocPitch; +extern tcuMemFree *cuMemFree; +extern tcuMemGetAddressRange *cuMemGetAddressRange; +extern tcuMemAllocHost *cuMemAllocHost; +extern tcuMemFreeHost *cuMemFreeHost; +extern tcuMemHostAlloc *cuMemHostAlloc; +extern tcuMemHostGetDevicePointer *cuMemHostGetDevicePointer; +extern tcuMemHostGetFlags *cuMemHostGetFlags; +extern tcuMemcpyHtoD *cuMemcpyHtoD; +extern tcuMemcpyDtoH *cuMemcpyDtoH; +extern tcuMemcpyDtoD *cuMemcpyDtoD; +extern tcuMemcpyDtoA *cuMemcpyDtoA; +extern tcuMemcpyAtoD *cuMemcpyAtoD; +extern tcuMemcpyHtoA *cuMemcpyHtoA; +extern tcuMemcpyAtoH *cuMemcpyAtoH; +extern tcuMemcpyAtoA *cuMemcpyAtoA; +extern tcuMemcpy2D *cuMemcpy2D; +extern tcuMemcpy2DUnaligned *cuMemcpy2DUnaligned; +extern tcuMemcpy3D *cuMemcpy3D; +extern tcuMemcpyHtoDAsync *cuMemcpyHtoDAsync; +extern tcuMemcpyDtoHAsync *cuMemcpyDtoHAsync; +extern tcuMemcpyDtoDAsync *cuMemcpyDtoDAsync; +extern tcuMemcpyHtoAAsync *cuMemcpyHtoAAsync; +extern tcuMemcpyAtoHAsync *cuMemcpyAtoHAsync; +extern tcuMemcpy2DAsync *cuMemcpy2DAsync; +extern tcuMemcpy3DAsync *cuMemcpy3DAsync; +extern tcuMemsetD8 *cuMemsetD8; +extern tcuMemsetD16 *cuMemsetD16; +extern tcuMemsetD32 *cuMemsetD32; +extern tcuMemsetD2D8 *cuMemsetD2D8; +extern tcuMemsetD2D16 *cuMemsetD2D16; +extern tcuMemsetD2D32 *cuMemsetD2D32; +extern tcuFuncSetBlockShape *cuFuncSetBlockShape; +extern tcuFuncSetSharedSize *cuFuncSetSharedSize; +extern tcuFuncGetAttribute *cuFuncGetAttribute; +extern tcuFuncSetCacheConfig *cuFuncSetCacheConfig; +extern tcuArrayCreate *cuArrayCreate; +extern tcuArrayGetDescriptor *cuArrayGetDescriptor; +extern tcuArrayDestroy *cuArrayDestroy; +extern tcuArray3DCreate *cuArray3DCreate; +extern tcuArray3DGetDescriptor *cuArray3DGetDescriptor; +extern tcuTexRefCreate *cuTexRefCreate; +extern tcuTexRefDestroy *cuTexRefDestroy; +extern tcuTexRefSetArray *cuTexRefSetArray; +extern tcuTexRefSetAddress *cuTexRefSetAddress; +extern tcuTexRefSetAddress2D *cuTexRefSetAddress2D; +extern tcuTexRefSetFormat *cuTexRefSetFormat; +extern tcuTexRefSetAddressMode *cuTexRefSetAddressMode; +extern tcuTexRefSetFilterMode *cuTexRefSetFilterMode; +extern tcuTexRefSetFlags *cuTexRefSetFlags; +extern tcuTexRefGetAddress *cuTexRefGetAddress; +extern tcuTexRefGetArray *cuTexRefGetArray; +extern tcuTexRefGetAddressMode *cuTexRefGetAddressMode; +extern tcuTexRefGetFilterMode *cuTexRefGetFilterMode; +extern tcuTexRefGetFormat *cuTexRefGetFormat; +extern tcuTexRefGetFlags *cuTexRefGetFlags; +extern tcuSurfRefSetArray *cuSurfRefSetArray; +extern tcuSurfRefGetArray *cuSurfRefGetArray; +extern tcuParamSetSize *cuParamSetSize; +extern tcuParamSeti *cuParamSeti; +extern tcuParamSetf *cuParamSetf; +extern tcuParamSetv *cuParamSetv; +extern tcuParamSetTexRef *cuParamSetTexRef; +extern tcuLaunch *cuLaunch; +extern tcuLaunchGrid *cuLaunchGrid; +extern tcuLaunchGridAsync *cuLaunchGridAsync; +extern tcuEventCreate *cuEventCreate; +extern tcuEventRecord *cuEventRecord; +extern tcuEventQuery *cuEventQuery; +extern tcuEventSynchronize *cuEventSynchronize; +extern tcuEventDestroy *cuEventDestroy; +extern tcuEventElapsedTime *cuEventElapsedTime; +extern tcuStreamCreate *cuStreamCreate; +extern tcuStreamQuery *cuStreamQuery; +extern tcuStreamSynchronize *cuStreamSynchronize; +extern tcuStreamDestroy *cuStreamDestroy; +extern tcuGraphicsUnregisterResource *cuGraphicsUnregisterResource; +extern tcuGraphicsSubResourceGetMappedArray *cuGraphicsSubResourceGetMappedArray; +extern tcuGraphicsResourceGetMappedPointer *cuGraphicsResourceGetMappedPointer; +extern tcuGraphicsResourceSetMapFlags *cuGraphicsResourceSetMapFlags; +extern tcuGraphicsMapResources *cuGraphicsMapResources; +extern tcuGraphicsUnmapResources *cuGraphicsUnmapResources; +extern tcuGetExportTable *cuGetExportTable; +extern tcuCtxSetLimit *cuCtxSetLimit; +extern tcuCtxGetLimit *cuCtxGetLimit; +extern tcuGLCtxCreate *cuGLCtxCreate; +extern tcuGraphicsGLRegisterBuffer *cuGraphicsGLRegisterBuffer; +extern tcuGraphicsGLRegisterImage *cuGraphicsGLRegisterImage; +extern tcuCtxSetCurrent *cuCtxSetCurrent; + +#endif /* __UTIL_CUDA_H__ */ + diff --git a/intern/cycles/util/util_debug.h b/intern/cycles/util/util_debug.h new file mode 100644 index 00000000000..17c169859ec --- /dev/null +++ b/intern/cycles/util/util_debug.h @@ -0,0 +1,25 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_DEBUG_H__ +#define __UTIL_DEBUG_H__ + +#include <assert.h> + +#endif /* __UTIL_DEBUG_H__ */ + diff --git a/intern/cycles/util/util_dynlib.cpp b/intern/cycles/util/util_dynlib.cpp new file mode 100644 index 00000000000..5836073a07a --- /dev/null +++ b/intern/cycles/util/util_dynlib.cpp @@ -0,0 +1,96 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdlib.h> + +#include "util_dynlib.h" + +#ifdef _WIN32 + +#include <Windows.h> + +CCL_NAMESPACE_BEGIN + +struct DynamicLibrary { + HMODULE module; +}; + +DynamicLibrary *dynamic_library_open(const char *name) +{ + HMODULE module = LoadLibrary(name); + + if(!module) + return NULL; + + DynamicLibrary *lib = new DynamicLibrary(); + lib->module = module; + + return lib; +} + +void *dynamic_library_find(DynamicLibrary *lib, const char *name) +{ + return (void*)GetProcAddress(lib->module, name); +} + +void dynamic_library_close(DynamicLibrary *lib) +{ + FreeLibrary(lib->module); + delete lib; +} + +CCL_NAMESPACE_END + +#else + +#include <dlfcn.h> + +CCL_NAMESPACE_BEGIN + +struct DynamicLibrary { + void *module; +}; + +DynamicLibrary *dynamic_library_open(const char *name) +{ + void *module = dlopen(name, RTLD_NOW); + + if(!module) + return NULL; + + DynamicLibrary *lib = new DynamicLibrary(); + lib->module = module; + + return lib; +} + +void *dynamic_library_find(DynamicLibrary *lib, const char *name) +{ + return dlsym(lib->module, name); +} + +void dynamic_library_close(DynamicLibrary *lib) +{ + dlclose(lib->module); + delete lib; +} + +CCL_NAMESPACE_END + +#endif + diff --git a/intern/cycles/util/util_dynlib.h b/intern/cycles/util/util_dynlib.h new file mode 100644 index 00000000000..888fb6cef24 --- /dev/null +++ b/intern/cycles/util/util_dynlib.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_DYNLIB_H__ +#define __UTIL_DYNLIB_H__ + +CCL_NAMESPACE_BEGIN + +struct DynamicLibrary; + +DynamicLibrary *dynamic_library_open(const char *name); +void *dynamic_library_find(DynamicLibrary *lib, const char *name); +void dynamic_library_close(DynamicLibrary *lib); + +CCL_NAMESPACE_END + +#endif /* __UTIL_DYNLIB_H__ */ + diff --git a/intern/cycles/util/util_foreach.h b/intern/cycles/util/util_foreach.h new file mode 100644 index 00000000000..b8298c003b5 --- /dev/null +++ b/intern/cycles/util/util_foreach.h @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_FOREACH_H__ +#define __UTIL_FOREACH_H__ + +/* Use Boost to get nice foreach() loops for STL data structures. */ + +#include <boost/foreach.hpp> +#define foreach BOOST_FOREACH + +#endif /* __UTIL_FOREACH_H__ */ + diff --git a/intern/cycles/util/util_function.h b/intern/cycles/util/util_function.h new file mode 100644 index 00000000000..dfcd58183d9 --- /dev/null +++ b/intern/cycles/util/util_function.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_FUNCTION_H__ +#define __UTIL_FUNCTION_H__ + +#include <boost/bind.hpp> +#include <boost/function.hpp> + +CCL_NAMESPACE_BEGIN + +using boost::function; +#define function_bind boost::bind + +CCL_NAMESPACE_END + +#endif /* __UTIL_FUNCTION_H__ */ + diff --git a/intern/cycles/util/util_hash.h b/intern/cycles/util/util_hash.h new file mode 100644 index 00000000000..0b7164403f2 --- /dev/null +++ b/intern/cycles/util/util_hash.h @@ -0,0 +1,50 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_HASH_H__ +#define __UTIL_HASH_H__ + +CCL_NAMESPACE_BEGIN + +static unsigned int hash_int_2d(unsigned int kx, unsigned int ky) +{ + #define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) + + unsigned int a, b, c; + + a = b = c = 0xdeadbeef + (2 << 2) + 13; + a += kx; + 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; + + #undef rot +} + +CCL_NAMESPACE_END + +#endif /* __UTIL_HASH_H__ */ + diff --git a/intern/cycles/util/util_image.h b/intern/cycles/util/util_image.h new file mode 100644 index 00000000000..df566ccc79c --- /dev/null +++ b/intern/cycles/util/util_image.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_IMAGE_H__ +#define __UTIL_IMAGE_H__ + +/* OpenImageIO is used for all image file reading and writing. */ + +#include <OpenImageIO/imageio.h> + +CCL_NAMESPACE_BEGIN + +OIIO_NAMESPACE_USING + +CCL_NAMESPACE_END + +#endif /* __UTIL_IMAGE_H__ */ + diff --git a/intern/cycles/util/util_list.h b/intern/cycles/util/util_list.h new file mode 100644 index 00000000000..d8f79643469 --- /dev/null +++ b/intern/cycles/util/util_list.h @@ -0,0 +1,31 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_LIST_H__ +#define __UTIL_LIST_H__ + +#include <list> + +CCL_NAMESPACE_BEGIN + +using std::list; + +CCL_NAMESPACE_END + +#endif /* __UTIL_LIST_H__ */ + diff --git a/intern/cycles/util/util_map.h b/intern/cycles/util/util_map.h new file mode 100644 index 00000000000..884f45c3b27 --- /dev/null +++ b/intern/cycles/util/util_map.h @@ -0,0 +1,34 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_MAP_H__ +#define __UTIL_MAP_H__ + +#include <map> +#include <tr1/unordered_map> + +CCL_NAMESPACE_BEGIN + +using std::map; +using std::pair; +using std::tr1::unordered_map; + +CCL_NAMESPACE_END + +#endif /* __UTIL_MAP_H__ */ + diff --git a/intern/cycles/util/util_math.h b/intern/cycles/util/util_math.h new file mode 100644 index 00000000000..349496e4a70 --- /dev/null +++ b/intern/cycles/util/util_math.h @@ -0,0 +1,759 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_MATH_H__ +#define __UTIL_MATH_H__ + +/* Math + * + * Basic math functions on scalar and vector types. This header is used by + * both the kernel code when compiled as C++, and other C++ non-kernel code. */ + +#ifndef __KERNEL_OPENCL__ + +#define _USE_MATH_DEFINES + +#include <float.h> +#include <math.h> +#include <stdio.h> + +#endif + +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +#define M_PI_F ((float)3.14159265358979323846264338327950288) +#define M_PI_2_F ((float)1.57079632679489661923132169163975144) +#define M_PI_4_F ((float)0.785398163397448309615660845819875721) +#define M_1_PI_F ((float)0.318309886183790671537767526745028724) +#define M_2_PI_F ((float)0.636619772367581343075535053490057448) + +/* Scalar */ + +#ifdef _WIN32 + +#define copysignf _copysign + +__device_inline float fmaxf(float a, float b) +{ + return (a > b)? a: b; +} + +__device_inline float fminf(float a, float b) +{ + return (a < b)? a: b; +} + +#endif + +#ifndef __KERNEL_OPENCL__ + +__device_inline int max(int a, int b) +{ + return (a > b)? a: b; +} + +__device_inline int min(int a, int b) +{ + return (a < b)? a: b; +} + +__device_inline float max(float a, float b) +{ + return (a > b)? a: b; +} + +__device_inline float min(float a, float b) +{ + return (a < b)? a: b; +} + +#endif + +__device_inline float min4(float a, float b, float c, float d) +{ + return min(min(min(a, b), c), d); +} + +__device_inline float max4(float a, float b, float c, float d) +{ + return max(max(max(a, b), c), d); +} + +#ifndef __KERNEL_OPENCL__ + +__device_inline int clamp(int a, int mn, int mx) +{ + return min(max(a, mn), mx); +} + +__device_inline float clamp(float a, float mn, float mx) +{ + return min(max(a, mn), mx); +} + +#endif + +__device_inline float signf(float f) +{ + return (f < 0.0f)? -1.0f: 1.0f; +} + +__device_inline float nonzerof(float f, float eps) +{ + if(fabsf(f) < eps) + return signf(f)*eps; + else + return f; +} + +/* Float2 Vector */ + +#ifndef __KERNEL_OPENCL__ + +__device_inline bool is_zero(const float2 a) +{ + return (a.x == 0.0f && a.y == 0.0f); +} + +#endif + +#ifndef __KERNEL_OPENCL__ + +__device_inline float average(const float2 a) +{ + return (a.x + a.y)*(1.0f/2.0f); +} + +#endif + +#ifndef __KERNEL_OPENCL__ + +__device_inline float2 operator-(const float2 a) +{ + float2 r = {-a.x, -a.y}; + return r; +} + +__device_inline float2 operator*(const float2 a, const float2 b) +{ + float2 r = {a.x*b.x, a.y*b.y}; + return r; +} + +__device_inline float2 operator*(const float2 a, float f) +{ + float2 r = {a.x*f, a.y*f}; + return r; +} + +__device_inline float2 operator*(float f, const float2 a) +{ + float2 r = {a.x*f, a.y*f}; + return r; +} + +__device_inline float2 operator/(float f, const float2 a) +{ + float2 r = {f/a.x, f/a.y}; + return r; +} + +__device_inline float2 operator/(const float2 a, float f) +{ + float invf = 1.0f/f; + float2 r = {a.x*invf, a.y*invf}; + return r; +} + +__device_inline float2 operator/(const float2 a, const float2 b) +{ + float2 r = {a.x/b.x, a.y/b.y}; + return r; +} + +__device_inline float2 operator+(const float2 a, const float2 b) +{ + float2 r = {a.x+b.x, a.y+b.y}; + return r; +} + +__device_inline float2 operator-(const float2 a, const float2 b) +{ + float2 r = {a.x-b.x, a.y-b.y}; + return r; +} + +__device_inline float2 operator+=(float2& a, const float2 b) +{ + a.x += b.x; + a.y += b.y; + return a; +} + +__device_inline float2 operator*=(float2& a, const float2 b) +{ + a.x *= b.x; + a.y *= b.y; + return a; +} + +__device_inline float2 operator*=(float2& a, float f) +{ + a.x *= f; + a.y *= f; + return a; +} + +__device_inline float2 operator/=(float2& a, const float2 b) +{ + a.x /= b.x; + a.y /= b.y; + return a; +} + +__device_inline float2 operator/=(float2& a, float f) +{ + float invf = 1.0f/f; + a.x *= invf; + a.y *= invf; + return a; +} + + +__device_inline float dot(const float2 a, const float2 b) +{ + return a.x*b.x + a.y*b.y; +} + +__device_inline float cross(const float2 a, const float2 b) +{ + return (a.x*b.y - a.y*b.x); +} + +#endif + +#ifndef __KERNEL_OPENCL__ + +__device_inline float len(const float2 a) +{ + return sqrtf(dot(a, a)); +} + +__device_inline float2 normalize(const float2 a) +{ + return a/len(a); +} + +__device_inline float2 normalize_len(const float2 a, float *t) +{ + *t = len(a); + return a/(*t); +} + +__device_inline bool operator==(const float2 a, const float2 b) +{ + return (a.x == b.x && a.y == b.y); +} + +__device_inline bool operator!=(const float2 a, const float2 b) +{ + return !(a == b); +} + +__device_inline float2 min(float2 a, float2 b) +{ + float2 r = {min(a.x, b.x), min(a.y, b.y)}; + return r; +} + +__device_inline float2 max(float2 a, float2 b) +{ + float2 r = {max(a.x, b.x), max(a.y, b.y)}; + return r; +} + +__device_inline float2 clamp(float2 a, float2 mn, float2 mx) +{ + return min(max(a, mn), mx); +} + +__device_inline float2 fabs(float2 a) +{ + return make_float2(fabsf(a.x), fabsf(a.y)); +} + +__device_inline float2 as_float2(const float4 a) +{ + return make_float2(a.x, a.y); +} + +#endif + +#ifndef __KERNEL_GPU__ + +__device_inline void print_float2(const char *label, const float2& a) +{ + printf("%s: %.8f %.8f\n", label, a.x, a.y); +} + +#endif + +#ifndef __KERNEL_OPENCL__ + +__device_inline float2 interp(float2 a, float2 b, float t) +{ + return a + t*(b - a); +} + +#endif + +/* Float3 Vector */ + +__device_inline bool is_zero(const float3 a) +{ + return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f); +} + +__device_inline float average(const float3 a) +{ + return (a.x + a.y + a.z)*(1.0f/3.0f); +} + +#ifndef __KERNEL_OPENCL__ + +__device_inline float3 operator-(const float3 a) +{ + float3 r = {-a.x, -a.y, -a.z}; + return r; +} + +__device_inline float3 operator*(const float3 a, const float3 b) +{ + float3 r = {a.x*b.x, a.y*b.y, a.z*b.z}; + return r; +} + +__device_inline float3 operator*(const float3 a, float f) +{ + float3 r = {a.x*f, a.y*f, a.z*f}; + return r; +} + +__device_inline float3 operator*(float f, const float3 a) +{ + float3 r = {a.x*f, a.y*f, a.z*f}; + return r; +} + +__device_inline float3 operator/(float f, const float3 a) +{ + float3 r = {f/a.x, f/a.y, f/a.z}; + return r; +} + +__device_inline float3 operator/(const float3 a, float f) +{ + float invf = 1.0f/f; + float3 r = {a.x*invf, a.y*invf, a.z*invf}; + return r; +} + +__device_inline float3 operator/(const float3 a, const float3 b) +{ + float3 r = {a.x/b.x, a.y/b.y, a.z/b.z}; + return r; +} + +__device_inline float3 operator+(const float3 a, const float3 b) +{ + float3 r = {a.x+b.x, a.y+b.y, a.z+b.z}; + return r; +} + +__device_inline float3 operator-(const float3 a, const float3 b) +{ + float3 r = {a.x-b.x, a.y-b.y, a.z-b.z}; + return r; +} + +__device_inline float3 operator+=(float3& a, const float3 b) +{ + a.x += b.x; + a.y += b.y; + a.z += b.z; + return a; +} + +__device_inline float3 operator*=(float3& a, const float3 b) +{ + a.x *= b.x; + a.y *= b.y; + a.z *= b.z; + return a; +} + +__device_inline float3 operator*=(float3& a, float f) +{ + a.x *= f; + a.y *= f; + a.z *= f; + return a; +} + +__device_inline float3 operator/=(float3& a, const float3 b) +{ + a.x /= b.x; + a.y /= b.y; + a.z /= b.z; + return a; +} + +__device_inline float3 operator/=(float3& a, float f) +{ + float invf = 1.0f/f; + a.x *= invf; + a.y *= invf; + a.z *= invf; + return a; +} + +__device_inline float dot(const float3 a, const float3 b) +{ + return a.x*b.x + a.y*b.y + a.z*b.z; +} + +__device_inline float3 cross(const float3 a, const float3 b) +{ + float3 r = {a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x}; + return r; +} + +#endif + +__device_inline float len(const float3 a) +{ + return sqrtf(dot(a, a)); +} + +#ifndef __KERNEL_OPENCL__ + +__device_inline float3 normalize(const float3 a) +{ + return a/len(a); +} + +#endif + +__device_inline float3 normalize_len(const float3 a, float *t) +{ + *t = len(a); + return a/(*t); +} + +#ifndef __KERNEL_OPENCL__ + +__device_inline bool operator==(const float3 a, const float3 b) +{ + return (a.x == b.x && a.y == b.y && a.z == b.z); +} + +__device_inline bool operator!=(const float3 a, const float3 b) +{ + return !(a == b); +} + +__device_inline float3 min(float3 a, float3 b) +{ + float3 r = {min(a.x, b.x), min(a.y, b.y), min(a.z, b.z)}; + return r; +} + +__device_inline float3 max(float3 a, float3 b) +{ + float3 r = {max(a.x, b.x), max(a.y, b.y), max(a.z, b.z)}; + return r; +} + +__device_inline float3 clamp(float3 a, float3 mn, float3 mx) +{ + return min(max(a, mn), mx); +} + +__device_inline float3 fabs(float3 a) +{ + return make_float3(fabsf(a.x), fabsf(a.y), fabsf(a.z)); +} + +__device_inline float3 as_float3(const float4& a) +{ + return make_float3(a.x, a.y, a.z); +} + +#endif + +#ifndef __KERNEL_GPU__ + +__device_inline void print_float3(const char *label, const float3& a) +{ + printf("%s: %.8f %.8f %.8f\n", label, a.x, a.y, a.z); +} + +#endif + +__device_inline float3 interp(float3 a, float3 b, float t) +{ + return a + t*(b - a); +} + +/* Float4 Vector */ + +#ifndef __KERNEL_OPENCL__ + +__device_inline bool is_zero(const float4& a) +{ + return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f && a.w == 0.0f); +} + +__device_inline float average(const float4& a) +{ + return (a.x + a.y + a.z + a.w)*(1.0f/4.0f); +} + +__device_inline float4 operator-(const float4& a) +{ + float4 r = {-a.x, -a.y, -a.z, -a.w}; + return r; +} + +__device_inline float4 operator*(const float4& a, const float4& b) +{ + float4 r = {a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w}; + return r; +} + +__device_inline float4 operator*(const float4& a, float f) +{ + float4 r = {a.x*f, a.y*f, a.z*f, a.w*f}; + return r; +} + +__device_inline float4 operator*(float f, const float4& a) +{ + float4 r = {a.x*f, a.y*f, a.z*f, a.w*f}; + return r; +} + +__device_inline float4 operator/(const float4& a, float f) +{ + float invf = 1.0f/f; + float4 r = {a.x*invf, a.y*invf, a.z*invf, a.w*invf}; + return r; +} + +__device_inline float4 operator/(const float4& a, const float4& b) +{ + float4 r = {a.x/b.x, a.y/b.y, a.z/b.z, a.w/b.w}; + return r; +} + +__device_inline float4 operator+(const float4& a, const float4& b) +{ + float4 r = {a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w}; + return r; +} + +__device_inline float4 operator-(const float4& a, const float4& b) +{ + float4 r = {a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w}; + return r; +} + +__device_inline float4 operator+=(float4& a, const float4& b) +{ + a.x += b.x; + a.y += b.y; + a.z += b.z; + a.w += b.w; + return a; +} + +__device_inline float4 operator*=(float4& a, const float4& b) +{ + a.x *= b.x; + a.y *= b.y; + a.z *= b.z; + a.w *= b.w; + return a; +} + +__device_inline float4 operator/=(float4& a, float f) +{ + float invf = 1.0f/f; + a.x *= invf; + a.y *= invf; + a.z *= invf; + a.w *= invf; + return a; +} + +__device_inline float dot(const float4& a, const float4& b) +{ + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +__device_inline float4 cross(const float4& a, const float4& b) +{ + float4 r = {a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x, 0.0f}; + return r; +} + +__device_inline float4 min(float4 a, float4 b) +{ + return make_float4(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z), min(a.w, b.w)); +} + +__device_inline float4 max(float4 a, float4 b) +{ + return make_float4(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z), max(a.w, b.w)); +} + +#endif + +#ifndef __KERNEL_GPU__ + +__device_inline void print_float4(const char *label, const float4& a) +{ + printf("%s: %.8f %.8f %.8f %.8f\n", label, a.x, a.y, a.z, a.w); +} + +#endif + +/* Int3 */ + +#ifndef __KERNEL_OPENCL__ + +__device_inline int3 max(int3 a, int3 b) +{ + int3 r = {max(a.x, b.x), max(a.y, b.y), max(a.z, b.z)}; + return r; +} + +__device_inline int3 clamp(const int3& a, int mn, int mx) +{ + int3 r = {clamp(a.x, mn, mx), clamp(a.y, mn, mx), clamp(a.z, mn, mx)}; + return r; +} + +__device_inline int3 clamp(const int3& a, int3& mn, int mx) +{ + int3 r = {clamp(a.x, mn.x, mx), clamp(a.y, mn.y, mx), clamp(a.z, mn.z, mx)}; + return r; +} + +#endif + +#ifndef __KERNEL_GPU__ + +__device_inline void print_int3(const char *label, const int3& a) +{ + printf("%s: %d %d %d\n", label, a.x, a.y, a.z); +} + +#endif + +/* Int4 */ + +#ifndef __KERNEL_OPENCL__ + +__device_inline int4 operator>=(float4 a, float4 b) +{ + return make_int4(a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w); +} + +#endif + +#ifndef __KERNEL_GPU__ + +__device_inline void print_int4(const char *label, const int4& a) +{ + printf("%s: %d %d %d %d\n", label, a.x, a.y, a.z, a.w); +} + +#endif + +/* Int/Float conversion */ + +#ifndef __KERNEL_OPENCL__ + +__device_inline unsigned int as_uint(float f) +{ + union { unsigned int i; float f; } u; + u.f = f; + return u.i; +} + +__device_inline int __float_as_int(float f) +{ + union { int i; float f; } u; + u.f = f; + return u.i; +} + +__device_inline float __int_as_float(int i) +{ + union { int i; float f; } u; + u.i = i; + return u.f; +} + +__device_inline uint __float_as_uint(float f) +{ + union { uint i; float f; } u; + u.f = f; + return u.i; +} + +__device_inline float __uint_as_float(uint i) +{ + union { uint i; float f; } u; + u.i = i; + return u.f; +} + +/* Interpolation */ + +template<class A, class B> __device_inline A lerp(const A& a, const A& b, const B& t) +{ + return (A)(a * ((B)1 - t) + b * t); +} + +/* Triangle */ + +__device_inline float triangle_area(const float3 v1, const float3 v2, const float3 v3) +{ + return len(cross(v3 - v2, v1 - v2))*0.5f; +} + +#endif + +CCL_NAMESPACE_END + +#endif /* __UTIL_MATH_H__ */ + diff --git a/intern/cycles/util/util_md5.cpp b/intern/cycles/util/util_md5.cpp new file mode 100644 index 00000000000..9fd44740531 --- /dev/null +++ b/intern/cycles/util/util_md5.cpp @@ -0,0 +1,350 @@ +/* + * Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * L. Peter Deutsch + * ghost@aladdin.com + */ + +/* Minor modifications done to remove some code and change style. */ + +#include "util_md5.h" + +#include <string.h> +#include <stdio.h> + +CCL_NAMESPACE_BEGIN + +#define T_MASK ((uint32_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + +void MD5Hash::process(const uint8_t *data /*[64]*/) +{ + uint32_t + a = abcd[0], b = abcd[1], + c = abcd[2], d = abcd[3]; + uint32_t t; + /* Define storage for little-endian or both types of CPUs. */ + uint32_t xbuf[16]; + const uint32_t *X; + + { + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if(*((const uint8_t *)&w)) /* dynamic little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if(!((data - (const uint8_t *)0) & 3)) { + /* data are properly aligned */ + X = (const uint32_t *)data; + } + else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } + else { /* dynamic big-endian */ + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const uint8_t *xp = data; + int i; + + X = xbuf; /* (dynamic only) */ + for(i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + 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;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + 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). */ +#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;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + 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). */ +#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;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + 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). */ +#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;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + 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.) */ + abcd[0] += a; + abcd[1] += b; + abcd[2] += c; + abcd[3] += d; +} + +MD5Hash::MD5Hash() +{ + count[0] = count[1] = 0; + abcd[0] = 0x67452301; + abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + abcd[3] = 0x10325476; +} + +MD5Hash::~MD5Hash() +{ +} + +void MD5Hash::append(const uint8_t *data, int nbytes) +{ + const uint8_t *p = data; + int left = nbytes; + int offset = (count[0] >> 3) & 63; + uint32_t nbits = (uint32_t)(nbytes << 3); + + if(nbytes <= 0) + return; + + /* Update the message length. */ + count[1] += nbytes >> 29; + count[0] += nbits; + if(count[0] < nbits) + count[1]++; + + /* Process an initial partial block. */ + if(offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(buf + offset, p, copy); + if(offset + copy < 64) + return; + p += copy; + left -= copy; + process(buf); + } + + /* Process full blocks. */ + for(; left >= 64; p += 64, left -= 64) + process(p); + + /* Process a final partial block. */ + if(left) + memcpy(buf, p, left); +} + +void MD5Hash::finish(uint8_t digest[16]) +{ + static const uint8_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + uint8_t data[8]; + int i; + + /* Save the length before padding. */ + for(i = 0; i < 8; ++i) + data[i] = (uint8_t)(count[i >> 2] >> ((i & 3) << 3)); + + /* Pad to 56 bytes mod 64. */ + append(pad, ((55 - (count[0] >> 3)) & 63) + 1); + /* Append the length. */ + append(data, 8); + + for(i = 0; i < 16; ++i) + digest[i] = (uint8_t)(abcd[i >> 2] >> ((i & 3) << 3)); +} + +string MD5Hash::get_hex() +{ + uint8_t digest[16]; + char buf[16*2]; + + finish(digest); + + for(int i=0; i<16; i++) + sprintf(buf + i*2, "%02X", digest[i]); + + return string(buf, sizeof(buf)); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_md5.h b/intern/cycles/util/util_md5.h new file mode 100644 index 00000000000..49f421d43d9 --- /dev/null +++ b/intern/cycles/util/util_md5.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * L. Peter Deutsch + * ghost@aladdin.com + */ + +/* MD5 + * + * Simply MD5 hash computation, used by disk cache. Adapted from external + * code, with minor code modifications done to remove some unused code and + * change code style. */ + +#ifndef __UTIL_MD5_H__ +#define __UTIL_MD5_H__ + +#include "util_string.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +class MD5Hash { +public: + MD5Hash(); + ~MD5Hash(); + + void append(const uint8_t *data, int size); + string get_hex(); + +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 */ +}; + +CCL_NAMESPACE_END + +#endif /* __UTIL_MD5_H__ */ + diff --git a/intern/cycles/util/util_opengl.h b/intern/cycles/util/util_opengl.h new file mode 100644 index 00000000000..5396f6f17be --- /dev/null +++ b/intern/cycles/util/util_opengl.h @@ -0,0 +1,35 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_OPENGL_H__ +#define __UTIL_OPENGL_H__ + +/* OpenGL header includes, used everywhere we use OpenGL, to deal with + * platform differences in one central place. */ + +#ifdef __APPLE__ +#include <GLUT/glut.h> +#include <OpenGL/gl.h> +#include <OpenGL/glu.h> +#else +#include <GL/glew.h> +#include <GL/glut.h> +#endif + +#endif /* __UTIL_OPENGL_H__ */ + diff --git a/intern/cycles/util/util_param.h b/intern/cycles/util/util_param.h new file mode 100644 index 00000000000..d1ca1b65ffb --- /dev/null +++ b/intern/cycles/util/util_param.h @@ -0,0 +1,36 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_PARAM_H__ +#define __UTIL_PARAM_H__ + +/* Parameter value lists from OpenImageIO are used to store custom properties + * on various data, which can then later be used in shaders. */ + +#include <OpenImageIO/paramlist.h> +#include <OpenImageIO/typedesc.h> +#include <OpenImageIO/ustring.h> + +CCL_NAMESPACE_BEGIN + +OIIO_NAMESPACE_USING + +CCL_NAMESPACE_END + +#endif /* __UTIL_PARAM_H__ */ + diff --git a/intern/cycles/util/util_path.cpp b/intern/cycles/util/util_path.cpp new file mode 100644 index 00000000000..4cf6cea0f69 --- /dev/null +++ b/intern/cycles/util/util_path.cpp @@ -0,0 +1,61 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "util_debug.h" +#include "util_path.h" +#include "util_string.h" + +#include <OpenImageIO/sysutil.h> +OIIO_NAMESPACE_USING + +#include <boost/filesystem.hpp> + +CCL_NAMESPACE_BEGIN + +static string cached_path = ""; + +void path_init(const string& path) +{ + cached_path = path; +} + +string path_get(const string& sub) +{ + if(cached_path == "") + cached_path = path_dirname(Sysutil::this_program_path()); + + return path_join(cached_path, sub); +} + +string path_filename(const string& path) +{ + return boost::filesystem::path(path).filename(); +} + +string path_dirname(const string& path) +{ + return boost::filesystem::path(path).parent_path().string(); +} + +string path_join(const string& dir, const string& file) +{ + return (boost::filesystem::path(dir) / boost::filesystem::path(file)).string(); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_path.h b/intern/cycles/util/util_path.h new file mode 100644 index 00000000000..b80bc0e9131 --- /dev/null +++ b/intern/cycles/util/util_path.h @@ -0,0 +1,41 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_PATH_H__ +#define __UTIL_PATH_H__ + +/* Utility functions to get paths to files distributed with the program. For + * the standalone apps, paths are relative to the executable, for dynamically + * linked libraries, the path to the library may be set with path_init, which + * then makes all paths relative to that. */ + +#include "util_string.h" + +CCL_NAMESPACE_BEGIN + +void path_init(const string& path = ""); +string path_get(const string& sub = ""); + +string path_filename(const string& path); +string path_dirname(const string& path); +string path_join(const string& dir, const string& file); + +CCL_NAMESPACE_END + +#endif + diff --git a/intern/cycles/util/util_progress.h b/intern/cycles/util/util_progress.h new file mode 100644 index 00000000000..86ab34aa7f9 --- /dev/null +++ b/intern/cycles/util/util_progress.h @@ -0,0 +1,173 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_PROGRESS_H__ +#define __UTIL_PROGRESS_H__ + +/* Progress + * + * Simple class to communicate progress status messages, timing information, + * update notifications from a job running in another thread. All methods + * except for the constructor/destructor are thread safe. */ + +#include "util_string.h" +#include "util_thread.h" + +CCL_NAMESPACE_BEGIN + +class Progress { +public: + Progress() + { + pass = 0; + total_time = 0.0f; + pass_time = 0.0f; + status = "Initializing"; + substatus = ""; + update_cb = NULL; + cancel = false; + cancel_message = ""; + cancel_cb = NULL; + } + + Progress(Progress& progress) + { + *this = progress; + } + + Progress& operator=(Progress& progress) + { + thread_scoped_lock lock(progress.progress_mutex); + + progress.get_pass(pass, total_time, pass_time); + progress.get_status(status, substatus); + + return *this; + } + + /* cancel */ + void set_cancel(const string& cancel_message_) + { + thread_scoped_lock lock(progress_mutex); + cancel_message = cancel_message_; + cancel = true; + } + + bool get_cancel() + { + if(!cancel && cancel_cb) + cancel_cb(); + + return cancel; + } + + string get_cancel_message() + { + thread_scoped_lock lock(progress_mutex); + return cancel_message; + } + + void set_cancel_callback(boost::function<void(void)> function) + { + cancel_cb = function; + } + + /* pass and timing information */ + + void set_pass(int pass_, double total_time_, double pass_time_) + { + thread_scoped_lock lock(progress_mutex); + + pass = pass_; + total_time = total_time_; + pass_time = pass_time_; + } + + void get_pass(int& pass_, double& total_time_, double& pass_time_) + { + thread_scoped_lock lock(progress_mutex); + + pass_ = pass; + total_time_ = total_time; + pass_time_ = pass_time; + } + + /* status messages */ + + void set_status(const string& status_, const string& substatus_ = "") + { + { + thread_scoped_lock lock(progress_mutex); + status = status_; + substatus = substatus_; + } + + set_update(); + } + + void set_substatus(const string& substatus_) + { + { + thread_scoped_lock lock(progress_mutex); + substatus = substatus_; + } + + set_update(); + } + + void get_status(string& status_, string& substatus_) + { + thread_scoped_lock lock(progress_mutex); + status_ = status; + substatus_ = substatus; + } + + /* callback */ + + void set_update() + { + if(update_cb) + update_cb(); + } + + void set_update_callback(boost::function<void(void)> function) + { + update_cb = function; + } + +protected: + thread_mutex progress_mutex; + boost::function<void(void)> update_cb; + boost::function<void(void)> cancel_cb; + + int pass; + + double total_time; + double pass_time; + + string status; + string substatus; + + volatile bool cancel; + string cancel_message; +}; + +CCL_NAMESPACE_END + +#endif /* __UTIL_PROGRESS_H__ */ + diff --git a/intern/cycles/util/util_set.h b/intern/cycles/util/util_set.h new file mode 100644 index 00000000000..ac310e93e80 --- /dev/null +++ b/intern/cycles/util/util_set.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_SET_H__ +#define __UTIL_SET_H__ + +#include <set> +#include <tr1/unordered_set> + +CCL_NAMESPACE_BEGIN + +using std::set; +using std::tr1::unordered_set; + +CCL_NAMESPACE_END + +#endif /* __UTIL_SET_H__ */ + diff --git a/intern/cycles/util/util_string.cpp b/intern/cycles/util/util_string.cpp new file mode 100644 index 00000000000..aaa482eec0d --- /dev/null +++ b/intern/cycles/util/util_string.cpp @@ -0,0 +1,92 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdarg.h> +#include <stdio.h> + +#include <boost/algorithm/string.hpp> + +#include "util_foreach.h" +#include "util_string.h" + +#ifdef _WIN32 +#ifndef vsnprintf +#define vsnprintf _vsnprintf +#endif +#endif + +CCL_NAMESPACE_BEGIN + +string string_printf(const char *format, ...) +{ + vector<char> str(128, 0); + + while(1) { + va_list args; + int result; + + va_start(args, format); + result = vsnprintf(&str[0], str.size(), format, args); + va_end(args); + + if(result == -1) { + /* not enough space or formatting error */ + if(str.size() > 65536) { + assert(0); + return string(""); + } + + str.resize(str.size()*2, 0); + continue; + } + else if(result >= (int)str.size()) { + /* not enough space */ + str.resize(result + 1, 0); + continue; + } + + return string(&str[0]); + } +} + +bool string_iequals(const string& a, const string& b) +{ + if(a.size() == b.size()) { + for(size_t i = 0; i < a.size(); i++) + if(toupper(a[i]) != toupper(b[i])) + return false; + + return true; + } + + return false; +} + +void string_split(vector<string>& tokens, const string& str) +{ + vector<string> split; + + boost::split(split, str, boost::is_any_of("\t "), boost::token_compress_on); + + foreach(const string& token, split) + if(token != "") + tokens.push_back(token); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_string.h b/intern/cycles/util/util_string.h new file mode 100644 index 00000000000..72b893d2b17 --- /dev/null +++ b/intern/cycles/util/util_string.h @@ -0,0 +1,49 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_STRING_H__ +#define __UTIL_STRING_H__ + +#include <string.h> +#include <string> +#include <sstream> + +#include "util_vector.h" + +CCL_NAMESPACE_BEGIN + +using std::string; +using std::stringstream; +using std::ostringstream; +using std::istringstream; + +#ifdef __GNUC__ +#define PRINTF_ATTRIBUTE __attribute__((format(printf, 1, 2))) +#else +#define PRINTF_ATTRIBUTE +#endif + +string string_printf(const char *format, ...) PRINTF_ATTRIBUTE; + +bool string_iequals(const string& a, const string& b); +void string_split(vector<string>& tokens, const string& str); + +CCL_NAMESPACE_END + +#endif /* __UTIL_STRING_H__ */ + diff --git a/intern/cycles/util/util_system.cpp b/intern/cycles/util/util_system.cpp new file mode 100644 index 00000000000..fae575873e0 --- /dev/null +++ b/intern/cycles/util/util_system.cpp @@ -0,0 +1,104 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "util_system.h" +#include "util_types.h" + +#ifdef _WIN32 +#include <intrin.h> +#include <windows.h> +#elif defined(__APPLE__) +#include <sys/sysctl.h> +#include <sys/types.h> +#else +#include <unistd.h> +#endif + +CCL_NAMESPACE_BEGIN + +int system_cpu_thread_count() +{ + static uint count = 0; + + if(count > 0) + return count; + +#ifdef _WIN32 + SYSTEM_INFO info; + GetSystemInfo(&info); + count = (uint)info.dwNumberOfProcessors; +#elif defined(__APPLE__) + size_t len = sizeof(count); + int mib[2] = { CTL_HW, HW_NCPU }; + + sysctl(mib, 2, &count, &len, NULL, 0); +#else + count = (uint)sysconf(_SC_NPROCESSORS_ONLN); +#endif + + if(count < 1) + count = 1; + + return count; +} + +#ifndef _WIN32 +static void __cpuid(int data[4], int selector) +{ + asm("cpuid" : "=a" (data[0]), "=b" (data[1]), "=c" (data[2]), "=d" (data[3]) : "a"(selector)); +} +#endif + +static void replace_string(string& haystack, const string& needle, const string& other) +{ + size_t i; + + while((i = haystack.find(needle)) != string::npos) + haystack.replace(i, needle.length(), other); +} + +string system_cpu_brand_string() +{ + char buf[48]; + int result[4]; + + __cpuid(result, 0x80000000); + + if(result[0] >= (int)0x80000004) { + __cpuid((int*)(buf+0), 0x80000002); + __cpuid((int*)(buf+16), 0x80000003); + __cpuid((int*)(buf+32), 0x80000004); + + string brand = buf; + + /* make it a bit more presentable */ + replace_string(brand, "(TM)", ""); + replace_string(brand, "(R)", ""); + + size_t i; + if((i = brand.find(" ")) != string::npos) + brand = brand.substr(0, i); + + return brand; + } + + return "Unknown CPU"; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_system.h b/intern/cycles/util/util_system.h new file mode 100644 index 00000000000..49a798acf03 --- /dev/null +++ b/intern/cycles/util/util_system.h @@ -0,0 +1,32 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_SYSTEM_H__ +#define __UTIL_SYSTEM_H__ + +#include "util_string.h" + +CCL_NAMESPACE_BEGIN + +int system_cpu_thread_count(); +string system_cpu_brand_string(); + +CCL_NAMESPACE_END + +#endif /* __UTIL_SYSTEM_H__ */ + diff --git a/intern/cycles/util/util_thread.h b/intern/cycles/util/util_thread.h new file mode 100644 index 00000000000..ad95f04b4f9 --- /dev/null +++ b/intern/cycles/util/util_thread.h @@ -0,0 +1,212 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_THREAD_H__ +#define __UTIL_THREAD_H__ + +#include <boost/thread.hpp> +#include <queue> + +CCL_NAMESPACE_BEGIN + +#if 0 + +/* Use STL for threading */ + +using std::thread; +using std::thread_mutex; +typedef std::lock_guard thread_scoped_lock; +using std::condition_variable; + +#else + +/* Use boost for threading */ + +using boost::thread; +typedef boost::mutex thread_mutex; +typedef boost::mutex::scoped_lock thread_scoped_lock; +typedef boost::condition_variable thread_condition_variable; + +#endif + +/* Thread Safe Queue to pass tasks from one thread to another. Tasks should be + * pushed into the queue, while the worker thread waits to pop the next task + * off the queue. Once all tasks are into the queue, calling stop() will stop + * the worker threads from waiting for more tasks once all tasks are done. */ + +template<typename T> class ThreadQueue +{ +public: + ThreadQueue() + { + tot = 0; + tot_done = 0; + do_stop = false; + do_cancel = false; + } + + /* Main thread functions */ + + /* push a task to be executed */ + void push(const T& value) + { + thread_scoped_lock lock(queue_mutex); + queue.push(value); + tot++; + lock.unlock(); + + queue_cond.notify_one(); + } + + /* wait until all tasks are done */ + void wait_done() + { + thread_scoped_lock lock(done_mutex); + + while(tot_done != tot) + done_cond.wait(lock); + } + + /* stop all worker threads */ + void stop() + { + clear(); + do_stop = true; + queue_cond.notify_all(); + } + + /* cancel all tasks, but keep worker threads running */ + void cancel() + { + clear(); + do_cancel = true; + wait_done(); + do_cancel = false; + } + + /* Worker thread functions + * + * while(queue.worker_wait_pop(task)) { + * for(..) { + * ... do work ... + * + * if(queue.worker_cancel()) + * break; + * } + * + * queue.worker_done(); + * } + */ + + bool worker_wait_pop(T& value) + { + thread_scoped_lock lock(queue_mutex); + + while(queue.empty() && !do_stop) + queue_cond.wait(lock); + + if(queue.empty()) + return false; + + value = queue.front(); + queue.pop(); + + return true; + } + + void worker_done() + { + thread_scoped_lock lock(done_mutex); + tot_done++; + lock.unlock(); + + assert(tot_done <= tot); + + done_cond.notify_all(); + } + + bool worker_cancel() + { + return do_cancel; + } + +protected: + void clear() + { + thread_scoped_lock lock(queue_mutex); + + while(!queue.empty()) { + thread_scoped_lock done_lock(done_mutex); + tot_done++; + done_lock.unlock(); + + queue.pop(); + } + + done_cond.notify_all(); + } + + std::queue<T> queue; + thread_mutex queue_mutex; + thread_mutex done_mutex; + thread_condition_variable queue_cond; + thread_condition_variable done_cond; + volatile bool do_stop; + volatile bool do_cancel; + volatile int tot, tot_done; +}; + +/* Thread Local Storage + * + * Boost implementation is a bit slow, and Mac OS X __thread is not supported + * but the pthreads implementation is optimized, so we use these macros. */ + +#ifdef __APPLE__ + +#define tls_ptr(type, name) \ + pthread_key_t name +#define tls_set(name, value) \ + pthread_setspecific(name, value) +#define tls_get(type, name) \ + ((type*)pthread_getspecific(name)) +#define tls_create(type, name) \ + pthread_key_create(&name, NULL) +#define tls_delete(type, name) \ + pthread_key_delete(name); + +#else + +#ifdef __WIN32 +#define __thread __declspec(thread) +#endif + +#define tls_ptr(type, name) \ + __thread type *name +#define tls_set(name, value) \ + name = value +#define tls_get(type, name) \ + name +#define tls_create(type, name) +#define tls_delete(type, name) + +#endif + +CCL_NAMESPACE_END + +#endif /* __UTIL_THREAD_H__ */ + diff --git a/intern/cycles/util/util_time.cpp b/intern/cycles/util/util_time.cpp new file mode 100644 index 00000000000..5f543fc7f91 --- /dev/null +++ b/intern/cycles/util/util_time.cpp @@ -0,0 +1,72 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdlib.h> + +#include "util_time.h" + +#ifdef _WIN32 + +#include <windows.h> + +CCL_NAMESPACE_BEGIN + +double time_dt() +{ + __int64 frequency, counter; + + QueryPerformanceFrequency((LARGE_INTEGER*)&frequency); + QueryPerformanceCounter((LARGE_INTEGER*)&counter); + + return (double)counter/(double)frequency; +} + +void time_sleep(double t) +{ + Sleep((int)(t*1000)); +} + +CCL_NAMESPACE_END + +#else + +#include <sys/time.h> +#include <unistd.h> + +CCL_NAMESPACE_BEGIN + +double time_dt() +{ + struct timeval now; + gettimeofday(&now, NULL); + + return now.tv_sec + now.tv_usec*1e-6; +} + +void time_sleep(double t) +{ + if(t >= 1.0) + sleep((int)t); + + usleep((int)(t*1e6)); +} + +CCL_NAMESPACE_END + +#endif + diff --git a/intern/cycles/util/util_time.h b/intern/cycles/util/util_time.h new file mode 100644 index 00000000000..33fa8797a69 --- /dev/null +++ b/intern/cycles/util/util_time.h @@ -0,0 +1,35 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_TIME_H__ +#define __UTIL_TIME_H__ + +CCL_NAMESPACE_BEGIN + +/* Give current time in seconds in double precision, with good accuracy. */ + +double time_dt(); + +/* Sleep for the specified number of seconds */ + +void time_sleep(double t); + +CCL_NAMESPACE_END + +#endif + diff --git a/intern/cycles/util/util_transform.cpp b/intern/cycles/util/util_transform.cpp new file mode 100644 index 00000000000..5c2f28af318 --- /dev/null +++ b/intern/cycles/util/util_transform.cpp @@ -0,0 +1,142 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* + * Adapted from code with license: + * + * Copyright (c) 2002, Industrial Light & Magic, a division of Lucas + * Digital Ltd. LLC. All rights reserved. + * + * 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 Industrial Light & Magic 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. + */ + +#include "util_math.h" +#include "util_transform.h" + +CCL_NAMESPACE_BEGIN + +static bool transform_matrix4_gj_inverse(float R[][4], float M[][4]) +{ + /* forward elimination */ + for(int i = 0; i < 4; i++) { + int pivot = i; + float pivotsize = M[i][i]; + + if(pivotsize < 0) + pivotsize = -pivotsize; + + for(int j = i + 1; j < 4; j++) { + float tmp = M[j][i]; + + if(tmp < 0) + tmp = -tmp; + + if(tmp > pivotsize) { + pivot = j; + pivotsize = tmp; + } + } + + if(pivotsize == 0) + return false; + + if(pivot != i) { + for(int j = 0; j < 4; j++) { + float tmp; + + tmp = M[i][j]; + M[i][j] = M[pivot][j]; + M[pivot][j] = tmp; + + tmp = R[i][j]; + R[i][j] = R[pivot][j]; + R[pivot][j] = tmp; + } + } + + for(int j = i + 1; j < 4; j++) { + float f = M[j][i] / M[i][i]; + + for(int k = 0; k < 4; k++) { + M[j][k] -= f*M[i][k]; + R[j][k] -= f*R[i][k]; + } + } + } + + /* backward substitution */ + for(int i = 3; i >= 0; --i) { + float f; + + if((f = M[i][i]) == 0) + return false; + + for(int j = 0; j < 4; j++) { + M[i][j] /= f; + R[i][j] /= f; + } + + for(int j = 0; j < i; j++) { + f = M[j][i]; + + for(int k = 0; k < 4; k++) { + M[j][k] -= f*M[i][k]; + R[j][k] -= f*R[i][k]; + } + } + } + + return true; +} + +Transform transform_inverse(const Transform& tfm) +{ + Transform R = transform_identity(); + Transform M = tfm; + + if(!transform_matrix4_gj_inverse((float(*)[4])&R, (float(*)[4])&M)) + return transform_identity(); + + return R; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_transform.h b/intern/cycles/util/util_transform.h new file mode 100644 index 00000000000..9cde410edc8 --- /dev/null +++ b/intern/cycles/util/util_transform.h @@ -0,0 +1,213 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_TRANSFORM_H__ +#define __UTIL_TRANSFORM_H__ + +#ifndef __KERNEL_GPU__ +#include <string.h> +#endif + +#include "util_math.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +typedef struct Transform { + float4 x, y, z, w; /* rows */ +} Transform; + +__device_inline float3 transform(const Transform *t, const float3 a) +{ + float4 b = {a.x, a.y, a.z, 1.0f}; + float3 c = {dot(t->x, b), dot(t->y, b), dot(t->z, b)}; + + return c/dot(t->w, b); +} + +__device_inline float3 transform_direction(const Transform *t, const float3 a) +{ + float4 b = {a.x, a.y, a.z, 0.0f}; + float3 c = {dot(t->x, b), dot(t->y, b), dot(t->z, b)}; + + return c; +} + +#ifndef __KERNEL_GPU__ + +__device_inline void print_transform(const char *label, const Transform& t) +{ + print_float4(label, t.x); + print_float4(label, t.y); + print_float4(label, t.z); + print_float4(label, t.w); + printf("\n"); +} + +__device_inline Transform transform_transpose(const Transform a) +{ + Transform t; + + t.x.x = a.x.x; t.x.y = a.y.x; t.x.z = a.z.x; t.x.w = a.w.x; + t.y.x = a.x.y; t.y.y = a.y.y; t.y.z = a.z.y; t.y.w = a.w.y; + t.z.x = a.x.z; t.z.y = a.y.z; t.z.z = a.z.z; t.z.w = a.w.z; + t.w.x = a.x.w; t.w.y = a.y.w; t.w.z = a.z.w; t.w.w = a.w.w; + + return t; +} + +__device_inline Transform operator*(const Transform a, const Transform b) +{ + Transform c = transform_transpose(b); + Transform t; + + t.x = make_float4(dot(a.x, c.x), dot(a.x, c.y), dot(a.x, c.z), dot(a.x, c.w)); + t.y = make_float4(dot(a.y, c.x), dot(a.y, c.y), dot(a.y, c.z), dot(a.y, c.w)); + t.z = make_float4(dot(a.z, c.x), dot(a.z, c.y), dot(a.z, c.z), dot(a.z, c.w)); + t.w = make_float4(dot(a.w, c.x), dot(a.w, c.y), dot(a.w, c.z), dot(a.w, c.w)); + + return t; +} + +__device_inline Transform make_transform(float a, float b, float c, float d, + float e, float f, float g, float h, + float i, float j, float k, float l, + float m, float n, float o, float p) +{ + Transform t; + + t.x.x = a; t.x.y = b; t.x.z = c; t.x.w = d; + t.y.x = e; t.y.y = f; t.y.z = g; t.y.w = h; + t.z.x = i; t.z.y = j; t.z.z = k; t.z.w = l; + t.w.x = m; t.w.y = n; t.w.z = o; t.w.w = p; + + return t; +} + +__device_inline Transform transform_translate(float3 t) +{ + return make_transform( + 1, 0, 0, t.x, + 0, 1, 0, t.y, + 0, 0, 1, t.z, + 0, 0, 0, 1); +} + +__device_inline Transform transform_translate(float x, float y, float z) +{ + return transform_translate(make_float3(x, y, z)); +} + +__device_inline Transform transform_scale(float3 s) +{ + return make_transform( + s.x, 0, 0, 0, + 0, s.y, 0, 0, + 0, 0, s.z, 0, + 0, 0, 0, 1); +} + +__device_inline Transform transform_scale(float x, float y, float z) +{ + return transform_scale(make_float3(x, y, z)); +} + +__device_inline Transform transform_perspective(float fov, float n, float f) +{ + Transform persp = make_transform( + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, f / (f - n), -f*n / (f - n), + 0, 0, 1, 0); + + float inv_angle = 1.0f/tanf(0.5f*fov); + + Transform scale = transform_scale(inv_angle, inv_angle, 1); + + return scale * persp; +} + +__device_inline Transform transform_rotate(float angle, float3 axis) +{ + float s = sinf(angle); + float c = cosf(angle); + float t = 1.f - c; + + axis = normalize(axis); + + return make_transform( + axis.x*axis.x*t + c, + axis.x*axis.y*t - s*axis.z, + axis.x*axis.z*t + s*axis.y, + 0.0f, + + axis.y*axis.x*t + s*axis.z, + axis.y*axis.y*t + c, + axis.y*axis.z*t - s*axis.x, + 0.0f, + + axis.z*axis.x*t - s*axis.y, + axis.z*axis.y*t + s*axis.x, + axis.z*axis.z*t + c, + 0.0f, + + 0.0f, 0.0f, 0.0f, 1.0f); +} + +__device_inline Transform transform_euler(float3 euler) +{ + return + transform_rotate(euler.x, make_float3(1.0f, 0.0f, 0.0f)) * + transform_rotate(euler.y, make_float3(1.0f, 0.0f, 0.0f)) * + transform_rotate(euler.z, make_float3(1.0f, 0.0f, 0.0f)); +} + +__device_inline Transform transform_orthographic(float znear, float zfar) +{ + return transform_scale(1.0f, 1.0f, 1.0f / (zfar-znear)) * + transform_translate(0.0f, 0.0f, -znear); +} + +__device_inline Transform transform_identity() +{ + return transform_scale(1.0f, 1.0f, 1.0f); +} + +__device_inline bool operator==(const Transform& A, const Transform& B) +{ + return memcmp(&A, &B, sizeof(Transform)) == 0; +} + +__device_inline bool operator!=(const Transform& A, const Transform& B) +{ + return !(A == B); +} + +__device_inline float3 transform_get_column(const Transform *t, int column) +{ + return make_float3(t->x[column], t->y[column], t->z[column]); +} + +Transform transform_inverse(const Transform& a); + +#endif + +CCL_NAMESPACE_END + +#endif /* __UTIL_TRANSFORM_H__ */ + diff --git a/intern/cycles/util/util_types.h b/intern/cycles/util/util_types.h new file mode 100644 index 00000000000..a0e352128d1 --- /dev/null +++ b/intern/cycles/util/util_types.h @@ -0,0 +1,266 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_TYPES_H__ +#define __UTIL_TYPES_H__ + +#ifndef __KERNEL_OPENCL__ + +#include <stdlib.h> + +#endif + +/* Qualifiers for kernel code shared by CPU and GPU */ + +#ifndef __KERNEL_GPU__ + +#define __device static inline +#define __global +#define __local +#define __shared +#define __constant +#define __device_inline static inline __attribute__((always_inline)) + +#endif + +/* SIMD Types */ + +#ifndef __KERNEL_GPU__ + +#include <emmintrin.h> +#include <xmmintrin.h> + +#endif + +#ifndef _WIN32 +#ifndef __KERNEL_GPU__ + +#include <stdint.h> + +#endif +#endif + +CCL_NAMESPACE_BEGIN + +/* Types + * + * Define simpler unsigned type names, and integer with defined number of bits. + * Also vector types, named to be compatible with OpenCL builtin types, while + * working for CUDA and C++ too. */ + +/* Shorter Unsigned Names */ + +typedef unsigned char uchar; +typedef unsigned int uint; + +#ifndef __KERNEL_GPU__ + +/* Fixed Bits Types */ + +#ifdef _WIN32 + +typedef signed char int8_t; +typedef unsigned char uint8_t; + +typedef signed short int16_t; +typedef unsigned short uint16_t; + +typedef signed int int32_t; +typedef unsigned int uint32_t; + +typedef long long int64_t; +typedef unsigned long long uint64_t; + +#endif + +/* Generic Memory Pointer */ + +typedef uint64_t device_ptr; + +/* Vector Types */ + +struct uchar2 { + uchar x, y; + + uchar operator[](int i) const { return *(&x + i); } + uchar& operator[](int i) { return *(&x + i); } +}; + +struct uchar3 { + uchar x, y, z; + + uchar operator[](int i) const { return *(&x + i); } + uchar& operator[](int i) { return *(&x + i); } +}; + +struct uchar4 { + uchar x, y, z, w; + + uchar operator[](int i) const { return *(&x + i); } + uchar& operator[](int i) { return *(&x + i); } +}; + +struct int2 { + int x, y; + + int operator[](int i) const { return *(&x + i); } + int& operator[](int i) { return *(&x + i); } +}; + +struct int3 { + int x, y, z; + + int operator[](int i) const { return *(&x + i); } + int& operator[](int i) { return *(&x + i); } +}; + +struct int4 { + int x, y, z, w; + + int operator[](int i) const { return *(&x + i); } + int& operator[](int i) { return *(&x + i); } +}; + +struct uint2 { + uint x, y; + + uint operator[](int i) const { return *(&x + i); } + uint& operator[](int i) { return *(&x + i); } +}; + +struct uint3 { + uint x, y, z; + + uint operator[](int i) const { return *(&x + i); } + uint& operator[](int i) { return *(&x + i); } +}; + +struct uint4 { + uint x, y, z, w; + + uint operator[](int i) const { return *(&x + i); } + uint& operator[](int i) { return *(&x + i); } +}; + +struct float2 { + float x, y; + + float operator[](int i) const { return *(&x + i); } + float& operator[](int i) { return *(&x + i); } +}; + +struct float3 { + float x, y, z; + + float operator[](int i) const { return *(&x + i); } + float& operator[](int i) { return *(&x + i); } +}; + +struct float4 { + float x, y, z, w; + + float operator[](int i) const { return *(&x + i); } + float& operator[](int i) { return *(&x + i); } +}; + +#endif + +#ifndef __KERNEL_GPU__ + +/* Vector Type Constructors + * + * OpenCL does not support C++ class, so we use these instead. */ + +__device uchar2 make_uchar2(uchar x, uchar y) +{ + uchar2 a = {x, y}; + return a; +} + +__device uchar3 make_uchar3(uchar x, uchar y, uchar z) +{ + uchar3 a = {x, y, z}; + return a; +} + +__device uchar4 make_uchar4(uchar x, uchar y, uchar z, uchar w) +{ + uchar4 a = {x, y, z, w}; + return a; +} + +__device int2 make_int2(int x, int y) +{ + int2 a = {x, y}; + return a; +} + +__device int3 make_int3(int x, int y, int z) +{ + int3 a = {x, y, z}; + return a; +} + +__device int4 make_int4(int x, int y, int z, int w) +{ + int4 a = {x, y, z, w}; + return a; +} + +__device uint2 make_uint2(uint x, uint y) +{ + uint2 a = {x, y}; + return a; +} + +__device uint3 make_uint3(uint x, uint y, uint z) +{ + uint3 a = {x, y, z}; + return a; +} + +__device uint4 make_uint4(uint x, uint y, uint z, uint w) +{ + uint4 a = {x, y, z, w}; + return a; +} + +__device float2 make_float2(float x, float y) +{ + float2 a = {x, y}; + return a; +} + +__device float3 make_float3(float x, float y, float z) +{ + float3 a = {x, y, z}; + return a; +} + +__device float4 make_float4(float x, float y, float z, float w) +{ + float4 a = {x, y, z, w}; + return a; +} + +#endif + +CCL_NAMESPACE_END + +#endif /* __UTIL_TYPES_H__ */ + diff --git a/intern/cycles/util/util_vector.h b/intern/cycles/util/util_vector.h new file mode 100644 index 00000000000..fb872936e3f --- /dev/null +++ b/intern/cycles/util/util_vector.h @@ -0,0 +1,137 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_VECTOR_H__ +#define __UTIL_VECTOR_H__ + +/* Vector */ + +#include <vector> + +CCL_NAMESPACE_BEGIN + +using std::vector; + +/* Array + * + * Simplified version of vector, serving two purposes: + * - somewhat faster in that it does not clear memory on resize/alloc, + * this was actually showing up in profiles quite significantly + * - if this is used, we are not tempted to use inefficient operations */ + +template<typename T> +class array +{ +public: + array() + { + data = NULL; + datasize = 0; + } + + array(size_t newsize) + { + if(newsize == 0) { + data = NULL; + datasize = 0; + } + else { + data = new T[newsize]; + datasize = newsize; + } + } + + array(const array& from) + { + *this = from; + } + + array& operator=(const array& from) + { + if(from.datasize == 0) { + data = NULL; + datasize = 0; + } + else { + data = new T[from.datasize]; + memcpy(data, from.data, from.datasize*sizeof(T)); + datasize = from.datasize; + } + + return *this; + } + + array& operator=(const vector<T>& from) + { + datasize = from.size(); + data = NULL; + + if(datasize > 0) { + data = new T[datasize]; + memcpy(data, &from[0], datasize*sizeof(T)); + } + + return *this; + } + + ~array() + { + delete [] data; + } + + void resize(size_t newsize) + { + if(newsize == 0) { + clear(); + } + else { + T *newdata = new T[newsize]; + memcpy(newdata, data, ((datasize < newsize)? datasize: newsize)*sizeof(T)); + delete [] data; + + data = newdata; + datasize = newsize; + } + } + + void clear() + { + delete [] data; + data = NULL; + datasize = 0; + } + + size_t size() const + { + return datasize; + } + + T& operator[](size_t i) const + { + return data[i]; + } + +protected: + T *data; + size_t datasize; +}; + +CCL_NAMESPACE_END + +#endif /* __UTIL_VECTOR_H__ */ + diff --git a/intern/cycles/util/util_view.cpp b/intern/cycles/util/util_view.cpp new file mode 100644 index 00000000000..75f0b92e705 --- /dev/null +++ b/intern/cycles/util/util_view.cpp @@ -0,0 +1,189 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "util_opengl.h" +#include "util_time.h" +#include "util_view.h" + +CCL_NAMESPACE_BEGIN + +/* structs */ + +struct View { + ViewInitFunc initf; + ViewExitFunc exitf; + ViewResizeFunc resize; + ViewDisplayFunc display; + ViewKeyboardFunc keyboard; + + bool first_display; + bool redraw; + + int width, height; +} V; + +/* public */ + +static void view_display_text(int x, int y, const char *text) +{ + const char *c; + + glRasterPos3f(x, y, 0); + + for(c=text; *c != '\0'; c++) + glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, *c); +} + +void view_display_info(const char *info) +{ + const int height = 20; + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glColor4f(0.1f, 0.1f, 0.1f, 0.8f); + glRectf(0.0f, V.height - height, V.width, V.height); + glDisable(GL_BLEND); + + glColor3f(0.5f, 0.5f, 0.5f); + + view_display_text(10, 7 + V.height - height, info); + + glColor3f(1.0f, 1.0f, 1.0f); +} + +static void view_display() +{ + if(V.first_display) { + if(V.initf) V.initf(); + if(V.exitf) atexit(V.exitf); + + V.first_display = false; + } + + glClearColor(0.05f, 0.05f, 0.05f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluOrtho2D(0, V.width, 0, V.height); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + glRasterPos3f(0, 0, 0); + + if(V.display) + V.display(); + + glutSwapBuffers(); +} + +static void view_reshape(int width, int height) +{ + if(width <= 0 || height <= 0) + return; + + V.width = width; + V.height = height; + + glViewport(0, 0, width, height); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + if(V.resize) + V.resize(width, height); +} + +static void view_keyboard(unsigned char key, int x, int y) +{ + if(V.keyboard) + V.keyboard(key); + + if(key == 'm') + printf("mouse %d %d\n", x, y); + if(key == 'q') { + if(V.exitf) V.exitf(); + exit(0); + } +} + +void view_idle() +{ + if(V.redraw) { + V.redraw = false; + glutPostRedisplay(); + } + + time_sleep(0.1f); +} + +void view_main_loop(const char *title, int width, int height, + ViewInitFunc initf, ViewExitFunc exitf, + ViewResizeFunc resize, ViewDisplayFunc display, + ViewKeyboardFunc keyboard) +{ + const char *name = "app"; + char *argv = (char*)name; + int argc = 1; + + memset(&V, 0, sizeof(V)); + V.width = width; + V.height = height; + V.first_display = true; + V.redraw = false; + V.initf = initf; + V.exitf = exitf; + V.resize = resize; + V.display = display; + V.keyboard = keyboard; + + glutInit(&argc, &argv); + glutInitWindowSize(width, height); + glutInitWindowPosition(0, 0); + glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH); + glutCreateWindow(title); + +#ifndef __APPLE__ + glewInit(); +#endif + + view_reshape(width, height); + + glutDisplayFunc(view_display); + glutIdleFunc(view_idle); + glutReshapeFunc(view_reshape); + glutKeyboardFunc(view_keyboard); + + glutMainLoop(); +} + +void view_redraw() +{ + V.redraw = true; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/util/util_view.h b/intern/cycles/util/util_view.h new file mode 100644 index 00000000000..c6805b5ce7c --- /dev/null +++ b/intern/cycles/util/util_view.h @@ -0,0 +1,44 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_VIEW_H__ +#define __UTIL_VIEW_H__ + +/* Functions to display a simple OpenGL window using GLUT, simplified to the + * bare minimum we need to reduce boilerplate code in tests apps. */ + +CCL_NAMESPACE_BEGIN + +typedef void (*ViewInitFunc)(void); +typedef void (*ViewExitFunc)(void); +typedef void (*ViewResizeFunc)(int width, int height); +typedef void (*ViewDisplayFunc)(void); +typedef void (*ViewKeyboardFunc)(unsigned char key); + +void view_main_loop(const char *title, int width, int height, + ViewInitFunc initf, ViewExitFunc exitf, + ViewResizeFunc resize, ViewDisplayFunc display, + ViewKeyboardFunc keyboard); + +void view_display_info(const char *info); +void view_redraw(); + +CCL_NAMESPACE_END + +#endif /*__UTIL_VIEW_H__*/ + diff --git a/intern/cycles/util/util_xml.h b/intern/cycles/util/util_xml.h new file mode 100644 index 00000000000..1e6874b7d77 --- /dev/null +++ b/intern/cycles/util/util_xml.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __UTIL_XML_H__ +#define __UTIL_XML_H__ + +/* PugiXML from OpenImageIO is used for XML parsing. */ + +#include <OpenImageIO/pugixml.hpp> + +CCL_NAMESPACE_BEGIN + +OIIO_NAMESPACE_USING + +CCL_NAMESPACE_END + +#endif /* __UTIL_XML_H__ */ + |