rename 2.0 tag to 2.0.0

CMakeLists.txt

@@ -1,28 +1,14 @@
-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}")
 
-# GCC check (needs -std:c++11 flag)
-#if(CMAKE_COMPILER_IS_GNUCC)
-#	ADD_DEFINITIONS("-std=c++11")
-#ENDIF(CMAKE_COMPILER_IS_GNUCC)
-set (CMAKE_CXX_STANDARD 11)
-
 IF(WIN32)
-	# gnuwin32 paths:
-	SET(GNUWIN32_PATH "${NV_SOURCE_DIR}/extern/gnuwin32")
-	SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${GNUWIN32_PATH}/include")
-	SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${GNUWIN32_PATH}/lib")
-	
-	# Set GLUT path:
-	SET(GLUT_ROOT_DIR "${NV_SOURCE_DIR}/extern/glut")
-
-	# Set FreeImage path:
-	SET(FREEIMAGE_ROOT_DIR "${NV_SOURCE_DIR}/extern/FreeImage")
-	
+	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)
@@ -30,53 +16,8 @@ MESSAGE(STATUS "Setting optimal options")
 MESSAGE(STATUS "  Processor: ${NV_SYSTEM_PROCESSOR}")
 MESSAGE(STATUS "  Compiler Flags: ${CMAKE_CXX_FLAGS}")
 
-IF(CMAKE_BUILD_TYPE MATCHES "debug")
-	SET(CMAKE_DEBUG_POSTFIX "_d" CACHE STRING "Postfix for debug build libraries.")
-    ADD_DEFINITIONS(-D_DEBUG=1)
-ENDIF()
-
-
-IF(NVTT_SHARED)
-	SET(NVCORE_SHARED TRUE)
-	SET(NVMATH_SHARED TRUE)
-	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 "0")
-SET(CPACK_PACKAGE_VERSION "2.1.0")
-SET(CPACK_PACKAGE_CONTACT "Ignacio Casta<74>o <castano@gmail.com>")
-#SET(CPACK_PACKAGE_VENDOR "NVIDIA Corporation")
-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\\\\vc8\\\\nvcompress\\\\nvidia.ico")
+	ADD_SUBDIRECTORY(gnuwin32)
 ENDIF(WIN32)
-
-INCLUDE(CPack)
-

ChangeLog

@@ -1,75 +1,3 @@
-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-2016 Ignacio Castano
-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,46 +0,0 @@
-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)
-
-Open `project/vc12/thekla.sln` using Visual Studio.
-
-Solutions for previous versions are also available, but they may not be up to date.
-
-
-### 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/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
-
-Detailed documentation of the API can be found at:
-
-http://code.google.com/p/nvidia-texture-tools/wiki/ApiDocumentation
-

VERSION

@@ -1 +1 @@
-2.1.1
+2.0.0

buildpkg

@@ -2,12 +2,6 @@
 
 tar zcvf nvidia-texture-tools-`cat VERSION`.tar.gz \
 	--exclude '.*' --exclude debian --exclude '*~' --exclude buildpkg \
-	--exclude 'build-*' --exclude data --exclude tags --exclude Makefile \
-	--exclude 'doc' --exclude 'nvidia-texture-tools-*.tar.gz' \
-    --exclude 'extern/skylight' --exclude 'extern/FreeImage' \
-    --exclude 'extern/atitc' --exclude 'extern/glew' \
-    --exclude 'extern/gnuwin32' \
-	--exclude '*.user' -s ',^,nvidia-texture-tools/,' *
-#   --exclude '*.user' --transform 's,^,nvidia-texture-tools/,' *
-#	--exclude '*.user' *
-
+	--exclude build --exclude data --exclude tags --exclude Makefile \
+	--exclude 'nvidia-texture-tools-*.tar.gz' \
+	--transform 's,^,nvidia-texture-tools/,' *

cmake/DetermineProcessor.cmake

@@ -5,68 +5,24 @@ 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)
+		EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE NV_SYSTEM_PROCESSOR RETURN_VALUE val)
 
-		#IF("${val}" GREATER 0 OR NV_SYSTEM_PROCESSOR STREQUAL "unknown")
+		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")
-
-		IF(NV_SYSTEM_PROCESSOR STREQUAL "Power Macintosh")
-			SET(NV_SYSTEM_PROCESSOR "powerpc")
-		ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "Power Macintosh")
+		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 from /proc/cpuinfo
-#~ 	IF(EXISTS "/proc/cpuinfo")
-
-#~ 		FILE(READ /proc/cpuinfo PROC_CPUINFO)
-
-#~ 		SET(VENDOR_ID_RX "vendor_id[ \t]*:[ \t]*([a-zA-Z]+)\n")
-#~ 		STRING(REGEX MATCH "${VENDOR_ID_RX}" VENDOR_ID "${PROC_CPUINFO}")
-#~ 		STRING(REGEX REPLACE "${VENDOR_ID_RX}" "\\1" VENDOR_ID "${VENDOR_ID}")
-
-#~ 		SET(CPU_FAMILY_RX "cpu family[ \t]*:[ \t]*([0-9]+)")
-#~ 		STRING(REGEX MATCH "${CPU_FAMILY_RX}" CPU_FAMILY "${PROC_CPUINFO}")
-#~ 		STRING(REGEX REPLACE "${CPU_FAMILY_RX}" "\\1" CPU_FAMILY "${CPU_FAMILY}")
-
-#~ 		SET(MODEL_RX "model[ \t]*:[ \t]*([0-9]+)")
-#~ 		STRING(REGEX MATCH "${MODEL_RX}" MODEL "${PROC_CPUINFO}")
-#~ 		STRING(REGEX REPLACE "${MODEL_RX}" "\\1" MODEL "${MODEL}")
-
-#~ 		SET(FLAGS_RX "flags[ \t]*:[ \t]*([a-zA-Z0-9 _]+)\n")
-#~ 		STRING(REGEX MATCH "${FLAGS_RX}" FLAGS "${PROC_CPUINFO}")
-#~ 		STRING(REGEX REPLACE "${FLAGS_RX}" "\\1" FLAGS "${FLAGS}")
-
-#~ 		# Debug output.
-#~ 		IF(LINUX_CPUINFO)
-#~ 			MESSAGE(STATUS "LinuxCPUInfo.cmake:")
-#~ 			MESSAGE(STATUS "VENDOR_ID : ${VENDOR_ID}")
-#~ 			MESSAGE(STATUS "CPU_FAMILY : ${CPU_FAMILY}")
-#~ 			MESSAGE(STATUS "MODEL : ${MODEL}")
-#~ 			MESSAGE(STATUS "FLAGS : ${FLAGS}")
-#~ 		ENDIF(LINUX_CPUINFO)
-
-#~ 	ENDIF(EXISTS "/proc/cpuinfo")
-
-#~		# Information on how to decode CPU_FAMILY and MODEL:
-#~		# http://balusc.xs4all.nl/srv/har-cpu-int-pm.php
+	# Get extended processor information with:
+	# `cat /proc/cpuinfo`
 
 ELSE(UNIX)
-
   IF(WIN32)
-    # It's not OK to trust $ENV{PROCESSOR_ARCHITECTURE}: its value depends on the type of executable being run,
-	# so a 32-bit cmake (the default binary distribution) will always say "x86" regardless of the actual target.
-	IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
-      SET (NV_SYSTEM_PROCESSOR "x86_64")
-	ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)
-	  SET (NV_SYSTEM_PROCESSOR "x86")
-	ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    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

@@ -3,13 +3,14 @@
 # Once done this will define
 #
 # CG_FOUND =system has NVIDIA Cg and it can be used. 
-# CG_INCLUDE_DIR = directory where cg.h resides
+# 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)
@@ -21,7 +22,7 @@ IF (APPLE)
     ENDFOREACH(dir)
 
     # Find the include  dir
-    FIND_PATH(CG_INCLUDE_DIR cg.h
+    FIND_PATH(CG_INCLUDE_PATH cg.h
       ${CG_FRAMEWORK_INCLUDES}
       )
 
@@ -37,25 +38,13 @@ IF (APPLE)
     )
 ELSE (APPLE)
   IF (WIN32)
- 
-    # When compiling 64-bit programs, the binaries and libs are in bin.x64 and lib.x64 directories,
-	
-	# This will have only effect for 64bit versions of cmake, when running the default 32bit version
-	# both ProgramFiles and ProgramFiles(x86) point to the same place in Win64
-	SET(PFx86_VARNAME "ProgramFiles(x86)")
-    SET(PFx86 $ENV{${PFx86_VARNAME}})
-	
-	# Let's play safe in case we are cross compiling to 64 bit: for cgc it doesn't really matter
     FIND_PROGRAM( CG_COMPILER cgc
-      $ENV{CG_BIN64_PATH}
       $ENV{CG_BIN_PATH}
       $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/bin
-	  $ENV{PFx86}/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)
@@ -63,7 +52,7 @@ ELSE (APPLE)
       SET (CG_COMPILER_DIR .)
       SET (CG_COMPILER_SUPER_DIR ..)
     ENDIF (CG_COMPILER)
-    FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
+    FIND_PATH( CG_INCLUDE_PATH Cg/cg.h
       $ENV{CG_INC_PATH}
       $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/include
       $ENV{PROGRAMFILES}/Cg
@@ -72,35 +61,6 @@ ELSE (APPLE)
       ${CG_COMPILER_DIR}
       DOC "The directory where Cg/cg.h resides"
       )
-	
-	IF (NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
-      FIND_LIBRARY( CG_LIBRARY
-        NAMES Cg
-        PATHS
-        $ENV{CG_LIB64_PATH}
-        $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib.x64
-		$ENV{PFx86}/NVIDIA\ Corporation/Cg/lib.x64
-        $ENV{PROGRAMFILES}/Cg
-        $ENV{PFx86}/Cg
-        ${PROJECT_SOURCE_DIR}/../Cg
-        ${CG_COMPILER_SUPER_DIR}/lib.x64
-        ${CG_COMPILER_DIR}
-        DOC "The Cg runtime library (64-bit)"
-        )
-      FIND_LIBRARY( CG_GL_LIBRARY
-        NAMES CgGL
-        PATHS
-		$ENV{CG_LIB64_PATH}
-        $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib.x64
-		$ENV{PFx86}/NVIDIA\ Corporation/Cg/lib.x64
-        $ENV{PROGRAMFILES}/Cg
-		$ENV{PFx86}/Cg
-        ${PROJECT_SOURCE_DIR}/../Cg
-        ${CG_COMPILER_SUPER_DIR}/lib.x64
-        ${CG_COMPILER_DIR}
-        DOC "The Cg GL runtime library (64-bit)"
-        )
-	ELSE(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
     FIND_LIBRARY( CG_LIBRARY
       NAMES Cg
       PATHS
@@ -115,16 +75,13 @@ ELSE (APPLE)
     FIND_LIBRARY( CG_GL_LIBRARY
       NAMES CgGL
       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 GL runtime library"
+      DOC "The Cg runtime library"
       )
-	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
-
   ELSE (WIN32)
     FIND_PROGRAM( CG_COMPILER cgc
       /usr/bin
@@ -133,7 +90,7 @@ ELSE (APPLE)
       )
     GET_FILENAME_COMPONENT(CG_COMPILER_DIR "${CG_COMPILER}" PATH)
     GET_FILENAME_COMPONENT(CG_COMPILER_SUPER_DIR "${CG_COMPILER_DIR}" PATH)
-    FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
+    FIND_PATH( CG_INCLUDE_PATH Cg/cg.h
       /usr/include
       /usr/local/include
       ${CG_COMPILER_SUPER_DIR}/include
@@ -163,10 +120,10 @@ ELSE (APPLE)
   ENDIF (WIN32)
 ENDIF (APPLE)
 
-IF (CG_INCLUDE_DIR)
+IF (CG_INCLUDE_PATH)
   SET( CG_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
-ELSE (CG_INCLUDE_DIR)
+ELSE (CG_INCLUDE_PATH)
   SET( CG_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
-ENDIF (CG_INCLUDE_DIR)
+ENDIF (CG_INCLUDE_PATH)
 
 MARK_AS_ADVANCED( CG_FOUND )

cmake/FindFreeImage.cmake

@@ -1,53 +0,0 @@
-#
-# Try to find the FreeImage library and include path.
-# Once done this will define
-#
-# FREEIMAGE_FOUND
-# FREEIMAGE_INCLUDE_PATH
-# FREEIMAGE_LIBRARY
-# 
-
-IF (WIN32)
-	FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
-		${FREEIMAGE_ROOT_DIR}/include
-		${FREEIMAGE_ROOT_DIR}
-		DOC "The directory where FreeImage.h resides")
-	FIND_LIBRARY( FREEIMAGE_LIBRARY
-		NAMES FreeImage freeimage
-		PATHS
-		${FREEIMAGE_ROOT_DIR}/lib
-		${FREEIMAGE_ROOT_DIR}
-		DOC "The FreeImage library")
-ELSE (WIN32)
-	FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
-		/usr/include
-		/usr/local/include
-		/sw/include
-		/opt/local/include
-		DOC "The directory where FreeImage.h resides")
-	FIND_LIBRARY( FREEIMAGE_LIBRARY
-		NAMES FreeImage freeimage
-		PATHS
-		/usr/lib64
-		/usr/lib
-		/usr/local/lib64
-		/usr/local/lib
-		/sw/lib
-		/opt/local/lib
-		DOC "The FreeImage library")
-ENDIF (WIN32)
-
-SET(FREEIMAGE_LIBRARIES ${FREEIMAGE_LIBRARY})
-
-IF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
-	SET( FREEIMAGE_FOUND TRUE CACHE BOOL "Set to TRUE if FreeImage is found, FALSE otherwise")
-ELSE (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
-	SET( FREEIMAGE_FOUND FALSE CACHE BOOL "Set to TRUE if FreeImage is found, FALSE otherwise")
-ENDIF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
-
-MARK_AS_ADVANCED(
-	FREEIMAGE_FOUND 
-	FREEIMAGE_LIBRARY
-	FREEIMAGE_LIBRARIES
-	FREEIMAGE_INCLUDE_PATH)
-

cmake/FindGLEW.cmake

@@ -10,9 +10,8 @@
 IF (WIN32)
 	FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
 		$ENV{PROGRAMFILES}/GLEW/include
-		${GLEW_ROOT_DIR}/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
@@ -26,12 +25,9 @@ ELSE (WIN32)
 		/usr/local/include
 		/sw/include
 		/opt/local/include
-		${GLEW_ROOT_DIR}/include
 		DOC "The directory where GL/glew.h resides")
-
-	# Prefer the static library.
 	FIND_LIBRARY( GLEW_LIBRARY
-		NAMES libGLEW.a GLEW
+		NAMES GLEW glew
 		PATHS
 		/usr/lib64
 		/usr/lib
@@ -39,12 +35,13 @@ ELSE (WIN32)
 		/usr/local/lib
 		/sw/lib
 		/opt/local/lib
-		${GLEW_ROOT_DIR}/lib
 		DOC "The GLEW library")
 ENDIF (WIN32)
 
-SET(GLEW_FOUND "NO")
-IF (GLEW_INCLUDE_PATH AND GLEW_LIBRARY)
-	SET(GLEW_LIBRARIES ${GLEW_LIBRARY})
-	SET(GLEW_FOUND "YES")
-ENDIF (GLEW_INCLUDE_PATH AND GLEW_LIBRARY)
+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/FindOpenEXR.cmake

@@ -53,7 +53,11 @@ ENDIF(ZLIB_FOUND)
 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")
+	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)

cmake/OptimalOptions.cmake

@@ -9,10 +9,9 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
 	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} -march=i686")
 		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=sse -mtune=i686 -msse3")
 		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=pentium4")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=prescott")
 	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "i686")
 
 	IF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
@@ -21,30 +20,12 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
 	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
 
 	IF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=powerpc -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
+		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 -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
-
-		# G5
-		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=G5 -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
-
+		#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=7450 -mtune=7450 -maltivec -mabi=altivec -mpowerpc-gfxopt")
 	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
 
-#	IF(DARWIN)
-#		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk")
-#		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk")
-#	ENDIF(DARWIN)
-	IF(APPLE)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -arch i586 -arch x86_64 -msse3 -mmacosx-version-min=10.5")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -arch i586 -arch x86_64 -msse3 -mmacosx-version-min=10.5")
-	ENDIF(APPLE)
-
-	IF(CMAKE_BUILD_TYPE STREQUAL "debug")
-		ADD_DEFINITIONS(-D_DEBUG)
-	ENDIF(CMAKE_BUILD_TYPE STREQUAL "debug")
-
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 ENDIF(CMAKE_COMPILER_IS_GNUCXX)
 
 IF(MSVC)

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;
-}
-