rename 2.0 tag to 2.0.0

.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,23 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.0)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.4.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)
-include(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
-if(COMPILER_SUPPORTS_CXX11)
-    set(CMAKE_CXX_STANDARD 11)
-    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()
+IF(WIN32)
+	SET(GNUWIN32 "${NV_SOURCE_DIR}/gnuwin32")
+	SET(CMAKE_INCLUDE_PATH "${GNUWIN32}/include")
+	SET(CMAKE_LIBRARY_PATH "${GNUWIN32}/lib")
+ENDIF(WIN32)
 
 INCLUDE(${NV_CMAKE_DIR}/OptimalOptions.cmake)
-
-IF(CMAKE_BUILD_TYPE MATCHES "debug")
-    SET(CMAKE_DEBUG_POSTFIX "_d" CACHE STRING "Postfix for debug build libraries.")
-    ADD_DEFINITIONS(-D_DEBUG=1)
-ENDIF()
-
-
-ADD_SUBDIRECTORY(extern)
+MESSAGE(STATUS "Setting optimal options")
+MESSAGE(STATUS "  Processor: ${NV_SYSTEM_PROCESSOR}")
+MESSAGE(STATUS "  Compiler Flags: ${CMAKE_CXX_FLAGS}")
 
 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<74>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")
-	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")
+	ADD_SUBDIRECTORY(gnuwin32)
 ENDIF(WIN32)
-
-INCLUDE(CPack)
-

ChangeLog

@@ -1,79 +1,3 @@
-NVIDIA Texture Tools version 2.1.2
- * Use ICBC as the main BC1 compressor.
- * Various fixes.
-
-NVIDIA Texture Tools version 2.1.1
- * Various fixes.
-
-NVIDIA Texture Tools version 2.1.0
- * Too many changes to list here.
- * 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.
-
-NVIDIA Texture Tools version 2.0.6
- * Fix dll version checking.
- * Detect CUDA 2.1 and future CUDA versions correctly.
- * Print CUDA detection message in nvcompress.
- * Select the fastest CUDA device.
- * Compile squish with -fPIC. Fixes issue 74.
- * Fix warnings under gcc 4.3.2.
- * Fix nvzoom option typo by Frank Richter. Fixes issue 81.
- * Do not use CUDA to compress small mipmaps. Fixes issue 76.
- * Compute mipmaps of semi-transparent images correctly.
- * Shutdown CUDA properly. Fixes issue 83.
- * Fix pixel format converions. Fixes issue 87.
- * Update single color compression tables. Fixes issue 85.
-
-NVIDIA Texture Tools version 2.0.5
- * Fix error in single color compressor. Fixes issue 66.
- * Detect mismatch between CUDA runtime and driver, and disable CUDA in that case.
- * Fix cmake files when compiling NVTT as a shared library.
- * When linking nvtt dynamically on unix, link all libraries dynamically.
- * Select fastest CUDA device.
-
-NVIDIA Texture Tools version 2.0.4
- * Fix error in RGB format output; reported by jonsoh. See issue 49.
- * Added support RGB format dithering by jonsoh. Fixes issue 50 and 51.
- * Prevent infinite loop in indexMirror when width equal 1. Fixes issue 65.
- * Implement general scale filter, including upsampling.
-
-NVIDIA Texture Tools version 2.0.3
- * More accurate DXT3 compressor. Fixes issue 38.
- * Remove legacy compressors. Fix issue 34.
- * Check for single color in all compressors. Fixes issue 43.
- * Fix error in fast downsample filter, reported by Noel Llopis.
-
-NVIDIA Texture Tools version 2.0.2
- * Fix copy ctor error reported by Richard Sim.
- * Fix indexMirror error reported by Chris Lambert.
- * Fix vc8 post build command, reported by Richard Sim.
- * Fix RGBA modes with less than 32 bpp by Viktor Linder.
- * Fix alpha decompression by Amorilia. See issue 40.
- * Avoid default-initialized constructors for POD types, reported by Jim Tilander.
- * Add single color compresor for DXT1a.
- * Set swizzle code to ATI2 files. See issue 41.
-
-NVIDIA Texture Tools version 2.0.1
- * Fix memory leaks.
- * Pre-allocate device memory for CUDA compressor.
- * Add single color compressor. Thanks to Amir Ebrahimi.
- * Better CUDA error checking.
-
 NVIDIA Texture Tools version 2.0.0
  * Fixed PSNR formula in nvimgdiff.
  * Added support for arbitrary RGB formats.

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-2009 NVIDIA Corporation
+Copyright (c) 2007 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.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,43 +0,0 @@
-# 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.0

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 1 CACHE STRING "Set to 1 if CUDA is found, 0 otherwise")
+ELSE (CUDA_INCLUDE_PATH AND CUDA_RUNTIME_LIBRARY)
+	SET (CUDA_FOUND 0 CACHE STRING "Set to 1 if CUDA is found, 0 otherwise")
+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 "")
+
+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.c)
+
+		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,79 @@
+#
+# 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} ${ZLIB_LIBRARY} CACHE STRING "The libraries needed to use OpenEXR")
+
+	IF(OPENEXR_ILMTHREAD_LIBRARY)
+		SET(OPENEXR_LIBRARIES ${OPENEXR_LIBRARIES} ${OPENEXR_ILMTHREAD_LIBRARY})
+	ENDIF(OPENEXR_ILMTHREAD_LIBRARY)
+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")
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-ENDIF()
+IF(CMAKE_COMPILER_IS_GNUCXX)
+
+	IF(NV_SYSTEM_PROCESSOR STREQUAL "i586")
+		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" ;;
-		--release )				build="release" ;;
+		--debug )				build="Debug" ;;
+		--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
-cd ./build-$build
-$CMAKE .. -DNVTT_SHARED=0 -DCMAKE_BUILD_TYPE=$build -DCMAKE_INSTALL_PREFIX=$prefix -G "Unix Makefiles" || exit 1
+mkdir -p ./build
+cd ./build
+$CMAKE .. -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/
-package:
-	@+make package --no-print-directory -C build-$build/
-test:
-	@+make test --no-print-directory -C build-$build/
+	@make install --no-print-directory -C 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;
-}
-