Link against pthreads library on systems that do not include it automatically. Fixes issue 149.

Plus for safeties sake use BeginThreadAffinity()...

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: castano

.github/workflows/build.yml

@@ -1,33 +0,0 @@
-name: build
-
-on: [push, pull_request]
-
-jobs:
-  vs2017:
-    runs-on: windows-2019
-    steps:
-    - uses: actions/checkout@v2
-    - uses: microsoft/setup-msbuild@v1.0.0
-    - name: Build Debug/x64
-      run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Debug /property:Platform=x64
-    - name: Build Debug/Win32
-      run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Debug /property:Platform=Win32
-    - name: Build Release/x64
-      run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Release /property:Platform=x64
-    - name: Build Release/Win32
-      run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Release /property:Platform=Win32
-      
-  unix:
-    strategy:
-      matrix:
-        os: [ubuntu, macos]
-    name: ${{matrix.os}}
-    runs-on: ${{matrix.os}}-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: make
-      run: |
-        ./configure --debug
-        make
-        ./configure --release
-        make

.gitignore

@@ -1,17 +0,0 @@
-**/bin/
-**/obj/
-**/Debug/
-**/Release/
-**/Debug.x64/
-**/Release.x64/
-**/Debug.Win32/
-**/Release.Win32/
-**/Debug-CUDA/
-**/Release-CUDA/
-*.vcxproj.user
-*.opensdf
-*.sdf
-*.suo
-build
-.vs
-project/nvtt.sublime-workspace

CMakeLists.txt

@@ -1,63 +1,30 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.0)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6.0)
 PROJECT(NV)
 ENABLE_TESTING()
 
 SET(NV_CMAKE_DIR "${NV_SOURCE_DIR}/cmake")
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${NV_CMAKE_DIR}")
 
-# Compiler check (needs -std:c++11 flag)
+IF(WIN32)
-include(CheckCXXCompilerFlag)
+	SET(GNUWIN32 "${NV_SOURCE_DIR}/gnuwin32")
-CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+	SET(CMAKE_INCLUDE_PATH "${GNUWIN32}/include")
-if(COMPILER_SUPPORTS_CXX11)
+	SET(CMAKE_LIBRARY_PATH "${GNUWIN32}/lib")
-    set(CMAKE_CXX_STANDARD 11)
+ENDIF(WIN32)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-else()
-    message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
-endif()
 
 INCLUDE(${NV_CMAKE_DIR}/OptimalOptions.cmake)
+MESSAGE(STATUS "Setting optimal options")
+MESSAGE(STATUS "  Processor: ${NV_SYSTEM_PROCESSOR}")
+MESSAGE(STATUS "  Compiler Flags: ${CMAKE_CXX_FLAGS}")
 
-IF(CMAKE_BUILD_TYPE MATCHES "debug")
+IF(NVTT_SHARED)
-    SET(CMAKE_DEBUG_POSTFIX "_d" CACHE STRING "Postfix for debug build libraries.")
+	SET(NVCORE_SHARED TRUE)
-    ADD_DEFINITIONS(-D_DEBUG=1)
+	SET(NVMATH_SHARED TRUE)
-ENDIF()
+	SET(NVIMAGE_SHARED TRUE)
+ENDIF(NVTT_SHARED)
 
 
-ADD_SUBDIRECTORY(extern)
-
 ADD_SUBDIRECTORY(src)
 
-# These files should only be installed when creating packages.
-INSTALL(FILES 
-	LICENSE
-	README.md
-	DESTINATION share/doc/nvtt)
-
-# Add packaging support
-INCLUDE(InstallRequiredSystemLibraries)
-
-IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-	SET(CPACK_GENERATOR "TGZ;DEB")
-ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-
-SET(CPACK_PACKAGE_NAME "nvidia-texture-tools")
-SET(CPACK_PACKAGE_VERSION_MAJOR "2")
-SET(CPACK_PACKAGE_VERSION_MINOR "1")
-SET(CPACK_PACKAGE_VERSION_PATCH "2")
-SET(CPACK_PACKAGE_VERSION "2.1.2")
-SET(CPACK_PACKAGE_CONTACT "Ignacio Castaño <castano@gmail.com>")
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Texture processing tools with support for Direct3D 10 and 11 formats.")
-
-SET(CPACK_PACKAGE_DESCRIPTION_FILE "${NV_SOURCE_DIR}/README.md")
-SET(CPACK_RESOURCE_FILE_LICENSE "${NV_SOURCE_DIR}/LICENSE")
-
-# NSIS options:
 IF(WIN32)
-	SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_VENDOR}\\\\NVIDIA Texture Tools 2.1")
+	ADD_SUBDIRECTORY(gnuwin32)
-	SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_VENDOR}\\\\NVIDIA Texture Tools 2.1")
-	SET(CPACK_PACKAGE_ICON "${NV_SOURCE_DIR}\\\\project\\\\vc2017\\\\nvcompress\\\\nvidia.ico")
 ENDIF(WIN32)
-
-INCLUDE(CPack)
-

ChangeLog

@@ -1,29 +1,27 @@
-NVIDIA Texture Tools version 2.1.2
+NVIDIA Texture Tools version 2.0.9
- * Use ICBC as the main BC1 compressor.
+ * Fix invalid assert when reading paletted TGA images. Fixes issue 125.
- * Various fixes.
+ * Add support for luminance flag. Fixes issue 126.
+ * Fix the C wrapper and provide methods involving callbacks.
+ * Improve C# / .NET Wrapper
+ * Add an XNA Game Studio 3.1 Content Processor to make it easy to utilize NVIDIA Texture Tools in XNA applications.
+ * Fix single color DXT1a compressor. Fixes issue 134.
+ * Fix mirror sampling. Fixes issue 135.
+ * Fix seek bug. Fixes issue 144.
+ * Fix aliasing bug. Fixes issue 139.
 
-NVIDIA Texture Tools version 2.1.1
+NVIDIA Texture Tools version 2.0.8
- * Various fixes.
+ * Fix float to fixed image conversion. Patch provided by Alex Pfaffe. Fixes issue 121.
-
+ * ColorBlock::isSingleColor compares only RGB channels. Fixes issue 115.
-NVIDIA Texture Tools version 2.1.0
+ * Fix cmake build in msvc. Fixes issue 111.
- * Too many changes to list here.
+ * Better estimate principal component. Fixes issue 120.
- * CTX1 CUDA compressor.
- * DXT1n CUDA compressor.
- * Support alpha premultiplication by Charles Nicholson. See issue 30.
- * Improved decompressor tool submitted by Amorilia. See issue 41.
- * Add support for YCoCg color transform. Fixes issue 18.
- * Add support for linear and swizzle transforms. Fixes issue 4.
- * Fix loading of EXR files using OpenEXR.
- * Use FreeImage as primary image loading library. Fixes issue 31. Reverted.
- * Output swizzle codes like AMD's tools.
- * Added support for saving PNGs by Frank Richter. Fixes issue 79 and 80.
- * Added gnome thumbnailer by Frank Richter. Fixes issue 82.
- * Cleanup sources removing files that are not strictly required.
 
 NVIDIA Texture Tools version 2.0.7
  * Output correct exit codes. Fixes issue 92.
  * Fix thread-safety errors. Fixes issue 90.
  * Add SIMD power method. Fixes issue 94.
+ * Fix compilation error in Snow Leopard reported by Huahang Liu.
+ * Interact better with applications that already use CUDA.
+ * Faster CPU compression.
 
 NVIDIA Texture Tools version 2.0.6
  * Fix dll version checking.

NVIDIA_Texture_Tools_LICENSE.txt

@@ -1,7 +1,6 @@
-NVIDIA Texture Tools is licensed under the MIT license.
+NVIDIA Texture Tools 2.0 is licensed under the MIT license.
 
-Copyright (c) 2009-2020 Ignacio Castaño
+Copyright (c) 2007 NVIDIA Corporation
-Copyright (c) 2007-2009 NVIDIA Corporation
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

NVIDIA_Texture_Tools_README.txt

@@ -0,0 +1,167 @@
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+NVIDIA Texture Tools
+README.txt
+Version 2.0
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+--------------------------------------------------------------------------------
+TABLE OF CONTENTS
+--------------------------------------------------------------------------------
+I.   Instructions
+II.  Contents
+III. Compilation Instructions
+IV.  Using NVIDIA Texture Tools in your own applications
+V.   Known Issues
+VI.  Frequently Asked Questions
+--------------------------------------------------------------------------------
+
+I.   Introduction
+--------------------------------------------------------------------------------
+
+This is our first alpha release of our new Texture Tools. The main highlights of 
+this release are support for all DX10 texture formats, higher speed and improved
+compression quality.
+
+In addition to that it also comes with a hardware accelerated compressor that 
+uses CUDA to compress blocks in parallel on the GPU and runs around 10 times 
+faster than the CPU counterpart.
+
+You can obtain CUDA from our developer site at:
+
+http://developer.nvidia.com/object/cuda.html
+
+The source code of the Texture Tools is being released under the terms of 
+the MIT license.
+
+
+II.  Contents
+--------------------------------------------------------------------------------
+
+This release contains only the source code of the texture compression library
+and an example commandline application that shows its use.
+
+
+III. Compilation Instructions
+--------------------------------------------------------------------------------
+
+The compression library and the example can be compiled with Visual Studio 8 on 
+Windows using the following solution file:
+
+project\vc8\nvtt.sln
+
+On most other platforms you can also use cmake. For more information about 
+cmake, visit:
+
+http://www.cmake.org/
+
+On unix systems you can use the standard build procedure (assuming cmake is 
+installed on your system):
+
+$ ./configure
+$ make
+$ sudo make install
+
+
+IV.  Using NVIDIA Texture Tools
+--------------------------------------------------------------------------------
+
+To use the NVIDIA Texture Tools in your own applications you just have to
+include the following header file:
+
+src/nvimage/nvtt/nvtt.h
+
+And include the nvtt library in your projects. 
+
+The following file contains a simple example that shows how to use the library:
+
+src/nvimage/nvtt/compress.cpp
+
+The usage of the commandline tool is the following:
+
+$ nvcompress [options] infile [outfile]
+
+where 'infile' is and TGA, PNG, PSD, DDS or JPG file, 'outfile' is a DDS file
+and 'options' is one or more of the following:
+
+Input options:
+  -color   	The input image is a color map (default).
+  -normal  	The input image is a normal map.
+  -tonormal	Convert input to normal map.
+  -clamp   	Clamp wrapping mode (default).
+  -repeat  	Repeat wrapping mode.
+  -nomips  	Disable mipmap generation.
+
+Compression options:
+  -fast    	Fast compression.
+  -nocuda  	Do not use cuda compressor.
+  -rgb     	RGBA format
+  -bc1     	BC1 format (DXT1)
+  -bc2     	BC2 format (DXT3)
+  -bc3     	BC3 format (DXT5)
+  -bc3n    	BC3 normal map format (DXT5n/RXGB)
+  -bc4     	BC4 format (ATI1)
+  -bc5     	BC5 format (3Dc/ATI2)
+
+In order to run the compiled example on a PC that doesn't have Microsoft Visual 
+Studio 2003 installed, you will have to install the Microsoft Visual Studio 2003
+redistributable package that you can download at:
+
+http://go.microsoft.com/fwlink/?linkid=65127&clcid=0x409
+
+
+V.   Known Issues
+--------------------------------------------------------------------------------
+
+None so far. Please send suggestions and bug reports to:
+
+TextureTools@nvidia.com
+
+or report them at:
+
+http://code.google.com/p/nvidia-texture-tools/issues/list
+
+
+VI.  Frequently Asked Questions
+--------------------------------------------------------------------------------
+
+- Do the NVIDIA Texture Tools work on OSX?
+It currently compiles and runs properly, but it has not been tested extensively.
+In particular there may be endiannes errors in the code.
+
+
+- Do the NVIDIA Texture Tools work on Linux?
+Yes.
+
+
+- Do the NVIDIA Texture Tools work on Vista?
+Yes, but note that CUDA is not supported on Vista yet, so the tool is not hardware 
+accelerated.
+
+
+- Is CUDA required?
+No. The Visual Studio solution file contains a configuration that allows you
+to compile the texture tools without CUDA support. The cmake scripts automatically
+detect the CUDA installation and use it only when available.
+
+
+- Where can I get CUDA?
+http://developer.nvidia.com/object/cuda.html
+
+
+- Why is feature XYZ not supported?
+In order to keep the code small and reduce maintenance costs we have limited the 
+features available in our new texture tools. We also have open sourced the code, so
+that people can modify it and add their own favourite features.
+
+
+- Can I use the NVIDIA Texture Tools in my commercial application?
+Yes, the NVIDIA Texture Tools are licensed under the MIT license.
+
+
+- Can I use the NVIDIA Texture Tools in my GPL application?
+Yes, the MIT license is compatible with the GPL and LGPL licenses.
+
+
+

README.md

@@ -1,83 +0,0 @@
-# NVTT is discontinued
-
-After more than 14 years maintaining and updating this library on my spare time, I've decided to officially discontinue it and focus my energy on other projects.
-
-When I released NVTT there was very little public information about compression for GPU texture formats. Existing codecs were closed-source, encumbered by patents, and not particularly efficient or high quality. A lot has changed since then. NVTT doesn't support the latest formats anymore, some of its codecs are outdated, and it's source code has aged. Today most IHVs maintain their own open source codecs and several companies develop high quality commercial products around texture compression. 
-
-If you are looking for alternative texture compression tools and processing algorithms I recommend you check these out:
-
-## Open Source Encoders
-
-* I still maintain [A High Quality SIMD BC1 Encoder](https://github.com/castano/icbc).
-* [rgbcx](https://github.com/richgel999/bc7enc/blob/master/rgbcx.h) is another high-performance (but scalar) BC1-5 encoder.
-* [stb_dxt](https://github.com/nothings/stb/blob/master/stb_dxt.h) is a single header library that provides low quality, but fast BC1-5 encoders.
-* [Binomial](https://www.binomial.info/) is an image and texture compression company that develops [Basis a universal texture codec](https://github.com/BinomialLLC/basis_universal) and also has [other open source codecs](https://github.com/BinomialLLC).
-* [Intel ISPC Texture Compressor](https://github.com/GameTechDev/ISPCTextureCompressor) is a set of set of open source SIMD texture encoders that are very fast, but low quality.
-* [AMD Compressonator](https://gpuopen.com/compressonator/) offers various open source encoders that also run on the GPU.
-* [Betsy](https://github.com/darksylinc/betsy/) is a compressor for various GPU formats using compute shaders.
-* For ETC encoders see Google's [Etc2Comp](https://github.com/google/etc2comp), Bartosz Taudul's [etcpak](https://github.com/wolfpld/etcpak) and Rich Geldreich's [rg-etc1](https://github.com/richgel999/rg-etc1).
-* [ARM ASTC Encoder](https://github.com/ARM-software/astc-encoder) is an excellent ASTC encoder.
-* This is [a good overview of the state of texture encoders in 2020](https://aras-p.info/blog/2020/12/08/Texture-Compression-in-2020/).
-
-## Image Processing and IO
-
-* [stb_image_resize](https://github.com/nothings/stb/blob/master/stb_image_resize.h) provides polyphase image resize filters that are similar to what NVTT supports.
-* [Dario Manesku's cube map filtering tool](https://github.com/dariomanesku/cmft) seems like a good alternative for the cube map filtering functions in NVTT.
-* [CubeMapGen](https://gpuopen.com/archived/cubemapgen/) is another source of information for cubemap filtering algorithms, but is now unsupported as well.
-* Deano Calver supports [three tiny libraries](https://deanoc.com/2019/09/tiny) that provide support for DDS and KTX file formats, and pixel format conversion.
-* [stb_image](https://github.com/nothings/stb/blob/master/stb_image.h) and [stb_image_write](https://github.com/nothings/stb/blob/master/stb_image_write.h) are two handy single header libraries to read and write images in various formats.
-* https://github.com/syoyo/tinyexr
-* https://lodev.org/lodepng/
-* [texturec](https://bkaradzic.github.io/bgfx/tools.html#texture-compiler-texturec) is a handy command line tool similar to `nvcompress`, built on top of [bimg](https://github.com/bkaradzic/bimg).
-* The venerable [ImageMagick](https://imagemagick.org/) still provides many valuable tools and utilities.
-
-## Commercial Libraries
-
-* [Oodle Texture](http://www.radgametools.com/oodletexture.htm) is a suite of commercial RDO texture codecs.
-* [NVIDIA Texture Tools exporter](https://developer.nvidia.com/nvidia-texture-tools-exporter) is based on a private fork of this project and offers additional GPU accelerated codecs, but it's not open source.
-
--------------------------------
-
-# NVIDIA Texture Tools [![Actions Status](https://github.com/castano/nvidia-texture-tools/workflows/build/badge.svg)](https://github.com/castano/nvidia-texture-tools/actions) ![MIT](https://img.shields.io/badge/license-MIT-blue.svg) [![GitHub](https://img.shields.io/badge/repo-github-green.svg)](https://github.com/castano/nvidia-texture-tools)
-
-The NVIDIA Texture Tools is a collection of image processing and texture 
-manipulation tools, designed to be integrated in game tools and asset 
-processing pipelines.
-
-The primary features of the library are mipmap and normal map generation, format 
-conversion, and DXT compression.
-
-
-### How to build (Windows)
-
-Use the provided Visual Studio 2017 solution `project/vc2017/thekla.sln`.
-
-
-### How to build (Linux/OSX)
-
-Use [cmake](http://www.cmake.org/) and the provided configure script:
-
-```bash
-$ ./configure
-$ make
-$ sudo make install
-```
-
-
-### Using NVIDIA Texture Tools
-
-To use the NVIDIA Texture Tools in your own applications you just have to
-include the following header file:
-
-[src/nvtt/nvtt.h](https://github.com/castano/nvidia-texture-tools/blob/master/src/nvtt/nvtt.h)
-
-And include the nvtt library in your projects. 
-
-The following file contains a simple example that shows how to use the library:
-
-[src/nvtt/tools/compress.cpp](https://github.com/castano/nvidia-texture-tools/blob/master/src/nvtt/tools/compress.cpp)
-
-Detailed documentation of the API can be found at:
-
-https://github.com/castano/nvidia-texture-tools/wiki/ApiDocumentation
-

VERSION

@@ -1 +1 @@
-2.1.2
+2.0.8

buildpkg

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+tar zcvf nvidia-texture-tools-`cat VERSION`.tar.gz \
+	--exclude '.*' --exclude debian --exclude '*~' --exclude buildpkg \
+	--exclude build --exclude data --exclude tags --exclude Makefile \
+	--exclude 'nvidia-texture-tools-*.tar.gz' \
+	--transform 's,^,nvidia-texture-tools/,' *

cmake/DetermineProcessor.cmake

@@ -0,0 +1,28 @@
+
+# Assume i586 by default.
+SET(NV_SYSTEM_PROCESSOR "i586")
+
+IF(UNIX)
+	FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
+	IF(CMAKE_UNAME)
+		EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE NV_SYSTEM_PROCESSOR RETURN_VALUE val)
+
+		IF("${val}" GREATER 0 OR NV_SYSTEM_PROCESSOR STREQUAL "unknown")
+			EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE NV_SYSTEM_PROCESSOR RETURN_VALUE val)
+		ENDIF("${val}" GREATER 0 OR NV_SYSTEM_PROCESSOR STREQUAL "unknown")
+
+		# processor may have double quote in the name, and that needs to be removed
+		STRING(REGEX REPLACE "\"" "" NV_SYSTEM_PROCESSOR "${NV_SYSTEM_PROCESSOR}")
+		STRING(REGEX REPLACE "/" "_" NV_SYSTEM_PROCESSOR "${NV_SYSTEM_PROCESSOR}")
+	ENDIF(CMAKE_UNAME)
+
+	# Get extended processor information with:
+	# `cat /proc/cpuinfo`
+
+ELSE(UNIX)
+  IF(WIN32)
+    SET (NV_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
+  ENDIF(WIN32)
+ENDIF(UNIX)
+
+

cmake/FindCUDA.cmake

@@ -0,0 +1,142 @@
+#
+# Try to find CUDA compiler, runtime libraries, and include path.
+# Once done this will define
+#
+# CUDA_FOUND
+# CUDA_INCLUDE_PATH
+# CUDA_RUNTIME_LIBRARY
+# CUDA_COMPILER
+#
+# It will also define the following macro:
+#
+# WRAP_CUDA
+#
+
+IF (WIN32)
+	FIND_PROGRAM (CUDA_COMPILER nvcc.exe
+		$ENV{CUDA_BIN_PATH}
+		DOC "The CUDA Compiler")
+ELSE(WIN32)
+	FIND_PROGRAM (CUDA_COMPILER nvcc
+		$ENV{CUDA_BIN_PATH}
+		/usr/local/cuda/bin
+		DOC "The CUDA Compiler")
+ENDIF(WIN32)
+
+IF (CUDA_COMPILER)
+	GET_FILENAME_COMPONENT (CUDA_COMPILER_DIR ${CUDA_COMPILER} PATH)
+	GET_FILENAME_COMPONENT (CUDA_COMPILER_SUPER_DIR ${CUDA_COMPILER_DIR} PATH)
+ELSE (CUDA_COMPILER)
+	SET (CUDA_COMPILER_DIR .)
+	SET (CUDA_COMPILER_SUPER_DIR ..)
+ENDIF (CUDA_COMPILER)
+
+FIND_PATH (CUDA_INCLUDE_PATH cuda_runtime.h
+	$ENV{CUDA_INC_PATH}
+	${CUDA_COMPILER_SUPER_DIR}/include
+	${CUDA_COMPILER_DIR}
+	DOC "The directory where CUDA headers reside")
+
+FIND_LIBRARY (CUDA_RUNTIME_LIBRARY
+	NAMES cudart
+	PATHS
+	$ENV{CUDA_LIB_PATH}
+	${CUDA_COMPILER_SUPER_DIR}/lib
+	${CUDA_COMPILER_DIR}
+	DOC "The CUDA runtime library")
+
+IF (CUDA_INCLUDE_PATH AND CUDA_RUNTIME_LIBRARY)
+	SET (CUDA_FOUND TRUE)
+ELSE (CUDA_INCLUDE_PATH AND CUDA_RUNTIME_LIBRARY)
+	SET (CUDA_FOUND FALSE)
+ENDIF (CUDA_INCLUDE_PATH AND CUDA_RUNTIME_LIBRARY)
+
+SET (CUDA_LIBRARIES ${CUDA_RUNTIME_LIBRARY})
+
+MARK_AS_ADVANCED (CUDA_FOUND CUDA_COMPILER CUDA_RUNTIME_LIBRARY)
+
+
+#SET(CUDA_OPTIONS "-ncfe")
+SET(CUDA_OPTIONS "--host-compilation=C")
+
+IF (CUDA_EMULATION)
+	SET (CUDA_OPTIONS "${CUDA_OPTIONS} -deviceemu")
+ENDIF (CUDA_EMULATION)
+
+
+# Get include directories.
+MACRO(GET_CUDA_INC_DIRS _cuda_INC_DIRS)
+	SET(${_cuda_INC_DIRS})
+	GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
+
+	FOREACH(_current ${_inc_DIRS})
+		SET(${_cuda_INC_DIRS} ${${_cuda_INC_DIRS}} "-I" ${_current})
+	ENDFOREACH(_current ${_inc_DIRS})
+	
+	SET(${_cuda_INC_DIRS} ${${_cuda_INC_DIRS}} "-I" ${CUDA_INCLUDE_PATH})
+
+#	IF (CMAKE_SYTEM_INCLUDE_PATH)
+#		SET(${_cuda_INC_DIRS} ${${_cuda_INC_DIRS}} "-I" ${CMAKE_SYSTEM_INCLUDE_PATH})
+#	ENDIF (CMAKE_SYTEM_INCLUDE_PATH)
+#	IF (CMAKE_INCLUDE_PATH)
+#		SET(${_cuda_INC_DIRS} ${${_cuda_INC_DIRS}} "-I" ${CMAKE_INCLUDE_PATH})
+#	ENDIF (CMAKE_INCLUDE_PATH)
+
+ENDMACRO(GET_CUDA_INC_DIRS)
+
+
+# Get file dependencies.
+MACRO (GET_CUFILE_DEPENDENCIES dependencies file)
+	GET_FILENAME_COMPONENT(filepath ${file} PATH)
+	
+	#  parse file for dependencies
+	FILE(READ "${file}" CONTENTS)
+	#STRING(REGEX MATCHALL "#[ \t]*include[ \t]+[<\"][^>\"]*" DEPS "${CONTENTS}")
+	STRING(REGEX MATCHALL "#[ \t]*include[ \t]+\"[^\"]*" DEPS "${CONTENTS}")
+	
+	SET(${dependencies})
+	
+	FOREACH(DEP ${DEPS})
+		STRING(REGEX REPLACE "#[ \t]*include[ \t]+\"" "" DEP "${DEP}")
+
+		FIND_PATH(PATH_OF_${DEP} ${DEP}
+			${filepath})
+
+		IF(NOT ${PATH_OF_${DEP}} STREQUAL PATH_OF_${DEP}-NOTFOUND)
+			#MESSAGE("${file} : ${PATH_OF_${DEP}}/${DEP}")
+			SET(${dependencies} ${${dependencies}} ${PATH_OF_${DEP}}/${DEP})
+		ENDIF(NOT ${PATH_OF_${DEP}} STREQUAL PATH_OF_${DEP}-NOTFOUND)
+		
+	ENDFOREACH(DEP)
+
+ENDMACRO (GET_CUFILE_DEPENDENCIES)
+
+
+# WRAP_CUDA(outfile ...)
+MACRO (WRAP_CUDA outfiles)
+	GET_CUDA_INC_DIRS(cuda_includes)
+	#MESSAGE(${cuda_includes})
+
+	FOREACH (CUFILE ${ARGN})
+		GET_FILENAME_COMPONENT (CUFILE ${CUFILE} ABSOLUTE)
+		GET_FILENAME_COMPONENT (CFILE ${CUFILE} NAME_WE)
+		SET (CFILE ${CMAKE_CURRENT_BINARY_DIR}/${CFILE}.gen.cpp)
+
+		GET_CUFILE_DEPENDENCIES(CUDEPS ${CUFILE})
+		#MESSAGE("${CUDEPS}")
+
+		ADD_CUSTOM_COMMAND (
+			OUTPUT ${CFILE}
+			COMMAND ${CUDA_COMPILER}
+			ARGS -cuda ${cuda_includes} ${CUDA_OPTIONS} -o ${CFILE} ${CUFILE}
+			MAIN_DEPENDENCY ${CUFILE}
+			DEPENDS ${CUDEPS})
+
+		#MACRO_ADD_FILE_DEPENDENCIES(${CUFILE} ${CFILE})
+
+		SET (${outfiles} ${${outfiles}} ${CFILE})
+	ENDFOREACH (CUFILE)
+	
+	SET_SOURCE_FILES_PROPERTIES(${outfiles} PROPERTIES GENERATED 1)
+	
+ENDMACRO (WRAP_CUDA)

cmake/FindCg.cmake

@@ -0,0 +1,129 @@
+#
+# Try to find NVIDIA's Cg compiler, runtime libraries, and include path.
+# Once done this will define
+#
+# CG_FOUND =system has NVIDIA Cg and it can be used. 
+# CG_INCLUDE_PATH = directory where cg.h resides
+# CG_LIBRARY = full path to libCg.so (Cg.DLL on win32)
+# CG_GL_LIBRARY = full path to libCgGL.so (CgGL.dll on win32)
+# CG_COMPILER = full path to cgc (cgc.exe on win32)
+# 
+
+# On OSX default to using the framework version of Cg.
+
+IF (APPLE)
+  INCLUDE(${CMAKE_ROOT}/Modules/CMakeFindFrameworks.cmake)
+  SET(CG_FRAMEWORK_INCLUDES)
+  CMAKE_FIND_FRAMEWORKS(Cg)
+  IF (Cg_FRAMEWORKS)
+    FOREACH(dir ${Cg_FRAMEWORKS})
+      SET(CG_FRAMEWORK_INCLUDES ${CG_FRAMEWORK_INCLUDES}
+        ${dir}/Headers ${dir}/PrivateHeaders)
+    ENDFOREACH(dir)
+
+    # Find the include  dir
+    FIND_PATH(CG_INCLUDE_PATH cg.h
+      ${CG_FRAMEWORK_INCLUDES}
+      )
+
+    # Since we are using Cg framework, we must link to it.
+	# Note, we use weak linking, so that it works even when Cg is not available.
+    SET(CG_LIBRARY "-weak_framework Cg" CACHE STRING "Cg library")
+    SET(CG_GL_LIBRARY "-weak_framework Cg" CACHE STRING "Cg GL library")
+  ENDIF (Cg_FRAMEWORKS)
+  FIND_PROGRAM(CG_COMPILER cgc
+    /usr/bin
+    /usr/local/bin
+    DOC "The Cg compiler"
+    )
+ELSE (APPLE)
+  IF (WIN32)
+    FIND_PROGRAM( CG_COMPILER cgc
+      $ENV{CG_BIN_PATH}
+      $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/bin
+      $ENV{PROGRAMFILES}/Cg
+      ${PROJECT_SOURCE_DIR}/../Cg
+      DOC "The Cg Compiler"
+      )
+    IF (CG_COMPILER)
+      GET_FILENAME_COMPONENT(CG_COMPILER_DIR ${CG_COMPILER} PATH)
+      GET_FILENAME_COMPONENT(CG_COMPILER_SUPER_DIR ${CG_COMPILER_DIR} PATH)
+    ELSE (CG_COMPILER)
+      SET (CG_COMPILER_DIR .)
+      SET (CG_COMPILER_SUPER_DIR ..)
+    ENDIF (CG_COMPILER)
+    FIND_PATH( CG_INCLUDE_PATH Cg/cg.h
+      $ENV{CG_INC_PATH}
+      $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/include
+      $ENV{PROGRAMFILES}/Cg
+      ${PROJECT_SOURCE_DIR}/../Cg
+      ${CG_COMPILER_SUPER_DIR}/include
+      ${CG_COMPILER_DIR}
+      DOC "The directory where Cg/cg.h resides"
+      )
+    FIND_LIBRARY( CG_LIBRARY
+      NAMES Cg
+      PATHS
+      $ENV{CG_LIB_PATH}
+      $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib
+      $ENV{PROGRAMFILES}/Cg
+      ${PROJECT_SOURCE_DIR}/../Cg
+      ${CG_COMPILER_SUPER_DIR}/lib
+      ${CG_COMPILER_DIR}
+      DOC "The Cg runtime library"
+      )
+    FIND_LIBRARY( CG_GL_LIBRARY
+      NAMES CgGL
+      PATHS
+      $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib
+      $ENV{PROGRAMFILES}/Cg
+      ${PROJECT_SOURCE_DIR}/../Cg
+      ${CG_COMPILER_SUPER_DIR}/lib
+      ${CG_COMPILER_DIR}
+      DOC "The Cg runtime library"
+      )
+  ELSE (WIN32)
+    FIND_PROGRAM( CG_COMPILER cgc
+      /usr/bin
+      /usr/local/bin
+      DOC "The Cg Compiler"
+      )
+    GET_FILENAME_COMPONENT(CG_COMPILER_DIR "${CG_COMPILER}" PATH)
+    GET_FILENAME_COMPONENT(CG_COMPILER_SUPER_DIR "${CG_COMPILER_DIR}" PATH)
+    FIND_PATH( CG_INCLUDE_PATH Cg/cg.h
+      /usr/include
+      /usr/local/include
+      ${CG_COMPILER_SUPER_DIR}/include
+      DOC "The directory where Cg/cg.h resides"
+      )
+    FIND_LIBRARY( CG_LIBRARY Cg
+      PATHS
+      /usr/lib64
+      /usr/lib
+      /usr/local/lib64
+      /usr/local/lib
+      ${CG_COMPILER_SUPER_DIR}/lib64
+      ${CG_COMPILER_SUPER_DIR}/lib
+      DOC "The Cg runtime library"
+      )
+	SET(CG_LIBRARY ${CG_LIBRARY} -lpthread)
+    FIND_LIBRARY( CG_GL_LIBRARY CgGL
+      PATHS
+      /usr/lib64
+      /usr/lib
+      /usr/local/lib64
+      /usr/local/lib
+      ${CG_COMPILER_SUPER_DIR}/lib64
+      ${CG_COMPILER_SUPER_DIR}/lib
+      DOC "The Cg runtime library"
+      )
+  ENDIF (WIN32)
+ENDIF (APPLE)
+
+IF (CG_INCLUDE_PATH)
+  SET( CG_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
+ELSE (CG_INCLUDE_PATH)
+  SET( CG_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
+ENDIF (CG_INCLUDE_PATH)
+
+MARK_AS_ADVANCED( CG_FOUND )

cmake/FindDirectX.cmake

@@ -0,0 +1,38 @@
+
+IF (WIN32)
+
+	FIND_PATH(DX9_INCLUDE_PATH d3d9.h
+		PATHS
+			"$ENV{DXSDK_DIR}/Include"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Include"
+		DOC "The directory where D3D9.h resides")
+
+	FIND_PATH(DX10_INCLUDE_PATH D3D10.h
+		PATHS
+			"$ENV{DXSDK_DIR}/Include"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Include"
+		DOC "The directory where D3D10.h resides")
+
+	FIND_LIBRARY(D3D10_LIBRARY d3d10.lib
+		PATHS
+			"$ENV{DXSDK_DIR}/Lib/x86"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Lib/x86"
+		DOC "The directory where d3d10.lib resides")
+
+	FIND_LIBRARY(D3DX10_LIBRARY d3dx10.lib
+		PATHS
+			"$ENV{DXSDK_DIR}/Lib/x86"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Lib/x86"
+		DOC "The directory where d3dx10.lib resides")
+
+	SET(DX10_LIBRARIES ${D3D10_LIBRARY} ${D3DX10_LIBRARY})
+
+ENDIF (WIN32)
+
+IF (DX10_INCLUDE_PATH)
+	SET( DX10_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
+ELSE (DX10_INCLUDE_PATH)
+	SET( DX10_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
+ENDIF (DX10_INCLUDE_PATH)
+
+MARK_AS_ADVANCED( DX10_FOUND )

cmake/FindGLEW.cmake

@@ -0,0 +1,47 @@
+#
+# Try to find GLEW library and include path.
+# Once done this will define
+#
+# GLEW_FOUND
+# GLEW_INCLUDE_PATH
+# GLEW_LIBRARY
+# 
+
+IF (WIN32)
+	FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
+		$ENV{PROGRAMFILES}/GLEW/include
+		${PROJECT_SOURCE_DIR}/src/nvgl/glew/include
+		DOC "The directory where GL/glew.h resides")
+	FIND_LIBRARY( GLEW_LIBRARY
+		NAMES glew GLEW glew32 glew32s
+		PATHS
+		$ENV{PROGRAMFILES}/GLEW/lib
+		${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
+		${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
+		DOC "The GLEW library")
+ELSE (WIN32)
+	FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
+		/usr/include
+		/usr/local/include
+		/sw/include
+		/opt/local/include
+		DOC "The directory where GL/glew.h resides")
+	FIND_LIBRARY( GLEW_LIBRARY
+		NAMES GLEW glew
+		PATHS
+		/usr/lib64
+		/usr/lib
+		/usr/local/lib64
+		/usr/local/lib
+		/sw/lib
+		/opt/local/lib
+		DOC "The GLEW library")
+ENDIF (WIN32)
+
+IF (GLEW_INCLUDE_PATH)
+	SET( GLEW_FOUND 1 CACHE STRING "Set to 1 if GLEW is found, 0 otherwise")
+ELSE (GLEW_INCLUDE_PATH)
+	SET( GLEW_FOUND 0 CACHE STRING "Set to 1 if GLEW is found, 0 otherwise")
+ENDIF (GLEW_INCLUDE_PATH)
+
+MARK_AS_ADVANCED( GLEW_FOUND )

cmake/FindGLUT.cmake

@@ -0,0 +1,127 @@
+# - try to find glut library and include files
+#  GLUT_INCLUDE_DIR, where to find GL/glut.h, etc.
+#  GLUT_LIBRARIES, the libraries to link against
+#  GLUT_FOUND, If false, do not try to use GLUT.
+# Also defined, but not for general use are:
+#  GLUT_glut_LIBRARY = the full path to the glut library.
+#  GLUT_Xmu_LIBRARY  = the full path to the Xmu library.
+#  GLUT_Xi_LIBRARY   = the full path to the Xi Library.
+
+IF (WIN32)
+
+  IF(CYGWIN)
+
+    FIND_PATH( GLUT_INCLUDE_DIR GL/glut.h
+      /usr/include
+    )
+
+    FIND_LIBRARY( GLUT_glut_LIBRARY glut32
+      ${OPENGL_LIBRARY_DIR}
+      /usr/lib
+      /usr/lib/w32api
+      /usr/local/lib
+      /usr/X11R6/lib
+    )
+
+
+  ELSE(CYGWIN)
+
+#    FIND_PATH( GLUT_INCLUDE_DIR GL/glut.h
+#     ${GLUT_ROOT_PATH}/include
+#   )
+
+#   FIND_LIBRARY( GLUT_glut_LIBRARY glut32
+#     ${GLUT_ROOT_PATH}/lib
+#     ${OPENGL_LIBRARY_DIR}
+#   )
+
+	FIND_PATH( GLUT_INCLUDE_DIR GL/glut.h
+		${GLUT_ROOT_PATH}/include
+		${PROJECT_SOURCE_DIR}/src/nvgl/glut/include
+		DOC "The directory where GL/glut.h resides")
+	FIND_LIBRARY( GLUT_glut_LIBRARY
+		NAMES glut GLUT glut32 glut32s
+		PATHS
+		${GLUT_ROOT_PATH}/lib
+		${PROJECT_SOURCE_DIR}/src/nvgl/glut/bin
+		${PROJECT_SOURCE_DIR}/src/nvgl/glut/lib
+		${OPENGL_LIBRARY_DIR}
+		DOC "The GLUT library")
+
+  ENDIF(CYGWIN)
+
+ELSE (WIN32)
+
+  IF (APPLE)
+# These values for Apple could probably do with improvement.
+    FIND_PATH( GLUT_INCLUDE_DIR glut.h
+      /System/Library/Frameworks/GLUT.framework/Versions/A/Headers
+      ${OPENGL_LIBRARY_DIR}
+    )
+    SET(GLUT_glut_LIBRARY "-framework Glut" CACHE STRING "GLUT library for OSX") 
+    SET(GLUT_cocoa_LIBRARY "-framework Cocoa" CACHE STRING "Cocoa framework for OSX")
+  ELSE (APPLE)
+
+    FIND_PATH( GLUT_INCLUDE_DIR GL/glut.h
+      /usr/include
+      /usr/include/GL
+      /usr/local/include
+      /usr/openwin/share/include
+      /usr/openwin/include
+      /usr/X11R6/include
+      /usr/include/X11
+      /opt/graphics/OpenGL/include
+      /opt/graphics/OpenGL/contrib/libglut
+    )
+
+    FIND_LIBRARY( GLUT_glut_LIBRARY glut
+      /usr/lib
+      /usr/local/lib
+      /usr/openwin/lib
+      /usr/X11R6/lib
+    )
+
+    FIND_LIBRARY( GLUT_Xi_LIBRARY Xi
+      /usr/lib
+      /usr/local/lib
+      /usr/openwin/lib
+      /usr/X11R6/lib
+    )
+
+    FIND_LIBRARY( GLUT_Xmu_LIBRARY Xmu
+      /usr/lib
+      /usr/local/lib
+      /usr/openwin/lib
+      /usr/X11R6/lib
+    )
+
+  ENDIF (APPLE)
+
+ENDIF (WIN32)
+
+SET( GLUT_FOUND "NO" )
+IF(GLUT_INCLUDE_DIR)
+  IF(GLUT_glut_LIBRARY)
+    # Is -lXi and -lXmu required on all platforms that have it?
+    # If not, we need some way to figure out what platform we are on.
+    SET( GLUT_LIBRARIES
+      ${GLUT_glut_LIBRARY}
+      ${GLUT_Xmu_LIBRARY}
+      ${GLUT_Xi_LIBRARY} 
+      ${GLUT_cocoa_LIBRARY}
+    )
+    SET( GLUT_FOUND "YES" )
+
+#The following deprecated settings are for backwards compatibility with CMake1.4
+    SET (GLUT_LIBRARY ${GLUT_LIBRARIES})
+    SET (GLUT_INCLUDE_PATH ${GLUT_INCLUDE_DIR})
+
+  ENDIF(GLUT_glut_LIBRARY)
+ENDIF(GLUT_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(
+  GLUT_INCLUDE_DIR
+  GLUT_glut_LIBRARY
+  GLUT_Xmu_LIBRARY
+  GLUT_Xi_LIBRARY
+)

cmake/FindMaya.cmake

@@ -0,0 +1,67 @@
+
+
+
+IF (WIN32)
+
+	# Maya plugins can only be compiled with msvc
+	IF (MSVC)
+
+		FIND_PATH(MAYA_INCLUDE_PATH maya/MTypes.h
+			PATHS
+				"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/include"
+				"$ENV{MAYA_LOCATION}/include"
+			DOC "The directory where MTypes.h resides")
+
+		# Find maya version!
+
+		FIND_LIBRARY(MAYA_FOUNDATION_LIBRARY Foundation
+			PATHS
+				"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
+				"$ENV{MAYA_LOCATION}/lib"
+			DOC "The directory where Foundation.lib resides")
+
+		FIND_LIBRARY(MAYA_OPENMAYA_LIBRARY OpenMaya
+			PATHS
+				"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
+				"$ENV{MAYA_LOCATION}/lib"
+			DOC "The directory where OpenMaya.lib resides")
+
+		FIND_LIBRARY(MAYA_OPENMAYAANIM_LIBRARY OpenMayaAnim
+			PATHS
+				"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
+				"$ENV{MAYA_LOCATION}/lib"
+			DOC "The directory where OpenMayaAnim.lib resides")
+
+		SET(MAYA_LIBRARIES 
+			${MAYA_FOUNDATION_LIBRARY}
+			${MAYA_OPENMAYA_LIBRARY}
+			${MAYA_OPENMAYAANIM_LIBRARY})
+
+		SET(MAYA_EXTENSION ".mll")
+
+	ENDIF (MSVC)
+ELSE (WIN32)
+
+	# On linux, check gcc version.
+
+	# OSX and Linux
+
+	FIND_PATH(MAYA_INCLUDE_PATH maya/MTypes.h
+		PATHS
+			/usr/autodesk/maya/include
+			$ENV{MAYA_LOCATION}/include
+		DOC "The directory where MTypes.h resides")
+
+# TODO
+
+ENDIF (WIN32)
+
+
+
+IF (MAYA_INCLUDE_PATH)
+	SET( MAYA_FOUND 1 CACHE STRING "Set to 1 if Maya is found, 0 otherwise")
+ELSE (MAYA_INCLUDE_PATH)
+	SET( MAYA_FOUND 0 CACHE STRING "Set to 1 if Maya is found, 0 otherwise")
+ENDIF (MAYA_INCLUDE_PATH)
+
+MARK_AS_ADVANCED( MAYA_FOUND )

cmake/FindOpenEXR.cmake

@@ -0,0 +1,75 @@
+#
+# Try to find OpenEXR's libraries, and include path.
+# Once done this will define:
+#
+# OPENEXR_FOUND = OpenEXR found. 
+# OPENEXR_INCLUDE_PATHS = OpenEXR include directories.
+# OPENEXR_LIBRARIES = libraries that are needed to use OpenEXR.
+# 
+
+INCLUDE(FindZLIB)
+
+
+IF(ZLIB_FOUND)
+
+	SET(LIBRARY_PATHS 
+		/usr/lib
+		/usr/local/lib
+		/sw/lib
+		/opt/local/lib
+		$ENV{PROGRAM_FILES}/OpenEXR/lib/static)
+
+	FIND_PATH(OPENEXR_INCLUDE_PATH ImfRgbaFile.h
+		PATH_SUFFIXES OpenEXR
+		/usr/include
+		/usr/local/include
+		/sw/include
+		/opt/local/include)
+
+	FIND_LIBRARY(OPENEXR_HALF_LIBRARY 
+		NAMES Half
+		PATHS ${LIBRARY_PATHS})
+  
+	FIND_LIBRARY(OPENEXR_IEX_LIBRARY 
+		NAMES Iex
+		PATHS ${LIBRARY_PATHS})
+ 
+	FIND_LIBRARY(OPENEXR_IMATH_LIBRARY
+		NAMES Imath
+		PATHS ${LIBRARY_PATHS})
+  
+	FIND_LIBRARY(OPENEXR_ILMIMF_LIBRARY
+		NAMES IlmImf
+		PATHS ${LIBRARY_PATHS})
+
+	FIND_LIBRARY(OPENEXR_ILMTHREAD_LIBRARY
+		NAMES IlmThread
+		PATHS ${LIBRARY_PATHS})
+
+ENDIF(ZLIB_FOUND)
+
+#MESSAGE(STATUS ${OPENEXR_IMATH_LIBRARY} ${OPENEXR_ILMIMF_LIBRARY} ${OPENEXR_IEX_LIBRARY} ${OPENEXR_HALF_LIBRARY} ${OPENEXR_ILMTHREAD_LIBRARY} ${ZLIB_LIBRARY})
+
+IF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY)
+	SET(OPENEXR_FOUND TRUE)
+	SET(OPENEXR_INCLUDE_PATHS ${OPENEXR_INCLUDE_PATH} CACHE STRING "The include paths needed to use OpenEXR")
+	SET(OPENEXR_LIBRARIES ${OPENEXR_IMATH_LIBRARY} ${OPENEXR_ILMIMF_LIBRARY} ${OPENEXR_IEX_LIBRARY} ${OPENEXR_HALF_LIBRARY} ${OPENEXR_ILMTHREAD_LIBRARY} ${ZLIB_LIBRARY} CACHE STRING "The libraries needed to use OpenEXR")
+ENDIF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY)
+
+IF(OPENEXR_FOUND)
+	IF(NOT OPENEXR_FIND_QUIETLY)
+		MESSAGE(STATUS "Found OpenEXR: ${OPENEXR_ILMIMF_LIBRARY}")
+	ENDIF(NOT OPENEXR_FIND_QUIETLY)
+ELSE(OPENEXR_FOUND)
+	IF(OPENEXR_FIND_REQUIRED)
+		MESSAGE(FATAL_ERROR "Could not find OpenEXR library")
+	ENDIF(OPENEXR_FIND_REQUIRED)
+ENDIF(OPENEXR_FOUND)
+
+MARK_AS_ADVANCED(
+	OPENEXR_INCLUDE_PATHS
+	OPENEXR_LIBRARIES
+	OPENEXR_ILMIMF_LIBRARY
+	OPENEXR_IMATH_LIBRARY
+	OPENEXR_IEX_LIBRARY
+	OPENEXR_HALF_LIBRARY)

cmake/OptimalOptions.cmake

@@ -1,11 +1,35 @@
 
+INCLUDE(${NV_CMAKE_DIR}/DetermineProcessor.cmake)
+
 # Set optimal options for gcc:
-if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+IF(CMAKE_COMPILER_IS_GNUCXX)
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+	IF(NV_SYSTEM_PROCESSOR STREQUAL "i586")
-ENDIF()
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=i586")
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "i586")
+
+	IF(NV_SYSTEM_PROCESSOR STREQUAL "i686")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=i686")
+		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=sse -mtune=i686 -msse3")
+		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=pentium4")
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "i686")
+
+	IF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=athlon64")
+		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=athlon64 -msse3")
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
+
+	IF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=powerpc -maltivec -mabi=altivec -mpowerpc-gfxopt")
+		
+		# ibook G4:
+		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=7450 -mtune=7450 -maltivec -mabi=altivec -mpowerpc-gfxopt")
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
+
+ENDIF(CMAKE_COMPILER_IS_GNUCXX)
 
 IF(MSVC)
+	# @@ Some of these might only be available in VC8.
 	# Code generation flags.
 #	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:SSE2 /fp:fast")
 #	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2 /fp:fast")

configure

@@ -18,7 +18,7 @@ fi
 
 
 help=false
-build="debug"	# release
+build="Debug"	# release
 prefix=/usr/local
 
 # Parse the args
@@ -26,8 +26,9 @@ for i in "$@"
 do
 	case $i in
 		--help )				help=true ;;
-		--debug )				build="debug" ;;
+		--debug )				build="Debug" ;;
-		--release )				build="release" ;;
+		--release )				build="Release" ;;
+		--prefix=* )			prefix="${i#--prefix=}" ;;
 		--prefix=* )			prefix="${i#--prefix=}" ;;
 		* )						echo "Unrecognised argument $i" ;;
 	esac
@@ -50,9 +51,9 @@ fi
 
 echo "-- Configuring nvidia-texture-tools "`cat VERSION`
 
-mkdir -p ./build-$build
+mkdir -p ./build
-cd ./build-$build
+cd ./build
-$CMAKE .. -DNVTT_SHARED=0 -DCMAKE_BUILD_TYPE=$build -DCMAKE_INSTALL_PREFIX=$prefix -G "Unix Makefiles" || exit 1
+$CMAKE .. -DNVTT_SHARED=1 -DCMAKE_BUILD_TYPE=$build -DCMAKE_INSTALL_PREFIX=$prefix -G "Unix Makefiles" || exit 1
 cd ..
 
 echo ""
@@ -61,15 +62,11 @@ echo ""
 
 cat > Makefile << EOF
 all:
-	@+make --no-print-directory -C build-$build/
+	@make --no-print-directory -C build/
 install:
-	@+make install --no-print-directory -C build-$build/
+	@make install --no-print-directory -C build/
-package:
-	@+make package --no-print-directory -C build-$build/
-test:
-	@+make test --no-print-directory -C build-$build/
 clean:
-	@+make clean --no-print-directory -C build-$build/
+	@make clean --no-print-directory -C build/
 distclean:
-	@rm -Rf build-$build/
+	@rm -Rf build/
 EOF

data/bugs/85/tables.cpp

@@ -1,95 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef unsigned char uint8;
-
-
-static int Mul8Bit(int a, int b)
-{
-	int t = a * b + 128;
-	return (t + (t >> 8)) >> 8;
-}
-
-// this exactly matches the (fm*2 + to)/3
-static inline int Lerp13_16bit(int fm, int to)
-{
-	int t = fm * (2 * 0xAAAB) + to * 0xAAAB;
-	return t >> 17;
-}
-
-static inline int Lerp13(int fm, int to)
-{
-	return (fm * 2 + to) / 3;
-}
-
-
-static void PrepareOptTable(uint8 * Table, const uint8 * expand, int size)
-{
-	for (int i = 0; i < 256; i++)
-	{
-		float bestErr = 256;
-
-		for (int min = 0; min < size; min++)
-		{
-			for (int max = 0; max < size; max++)
-			{
-				int mine = expand[min];
-				int maxe = expand[max];
-				//if (maxe - mine < 32)
-				{
-					//printf("%d <-> %d\n", maxe + Mul8Bit(mine-maxe, 0x55), Lerp13(maxe, mine));
-					//int err = abs(Lerp13_16bit(mine, maxe) - i);
-					//int err = abs(maxe + Mul8Bit(mine-maxe, 0x55) - i);
-					float err = abs(Lerp13(maxe, mine) - i);
-					//err += 0.03f * abs(maxe - mine);
-					err += 0.03f * abs(max - min);
-
-					if (err < bestErr)
-					{
-						Table[i*2+0] = max;
-						Table[i*2+1] = min;
-						bestErr = err;
-					}
-				}
-			}
-		}
-		printf("%d: %f %d\n", i, bestErr, abs(Table[i*2+0] - Table[i*2+1]));
-	}
-}
-
-
-int main()
-{
-	uint8 OMatch5[256*2];
-	uint8 OMatch6[256*2];
-	
-	uint8 Expand5[32];
-	uint8 Expand6[64];
-
-	for (int i=0; i<32; i++)
-		Expand5[i] = (i<<3)|(i>>2);
-
-	for (int i=0; i<64; i++)
-		Expand6[i] = (i<<2)|(i>>4);
-
-	PrepareOptTable(OMatch5, Expand5, 32);
-	PrepareOptTable(OMatch6, Expand6, 64);
-
-	printf("const static uint8 OMatch5[256][2] = {\n");
-	for (int i = 0; i < 256; i++)
-	{
-		printf("\t{0x%.2X, 0x%.2X},\n", OMatch5[2*i+0], OMatch5[2*i+1]);
-	}
-	printf("}\n");
-
-	printf("const static uint8 OMatch6[256][2] = {\n");
-	for (int i = 0; i < 256; i++)
-	{
-		printf("\t{0x%.2X, 0x%.2X},\n", OMatch6[2*i+0], OMatch6[2*i+1]);
-	}
-	printf("}\n");
-
-	return 0;
-}
-