Cleanups for 2.1.0 release.

Fix build on VC2015 (missing typedefs)

CMakeLists.txt

@@ -1,14 +1,27 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6.0)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.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)
+
 IF(WIN32)
-	SET(GNUWIN32 "${NV_SOURCE_DIR}/extern/gnuwin32")
-	SET(CMAKE_INCLUDE_PATH "${GNUWIN32}/include")
-	SET(CMAKE_LIBRARY_PATH "${GNUWIN32}/lib")
+	# 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")
+	
 ENDIF(WIN32)
 
 INCLUDE(${NV_CMAKE_DIR}/OptimalOptions.cmake)
@@ -16,15 +29,52 @@ 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.")
+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)
-	ADD_SUBDIRECTORY(extern/gnuwin32)
+	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")
 ENDIF(WIN32)
+
+INCLUDE(CPack)
+

ChangeLog

@@ -1,4 +1,5 @@
 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.
@@ -8,7 +9,35 @@ NVIDIA Texture Tools version 2.1.0
  * 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.

LICENSE

@@ -1,6 +1,7 @@
-NVIDIA Texture Tools 2.0 is licensed under the MIT license.
+NVIDIA Texture Tools is licensed under the MIT license.
 
-Copyright (c) 2007 NVIDIA Corporation
+Copyright (c) 2009-2016 Ignacio Castano
+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

@@ -1,167 +0,0 @@
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
-NVIDIA Texture Tools
-README.txt
-Version 2.1
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
-
---------------------------------------------------------------------------------
-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

@@ -0,0 +1,46 @@
+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
+

buildpkg

@@ -2,6 +2,9 @@
 
 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/,' *
+	--exclude 'build-*' --exclude data --exclude tags --exclude Makefile \
+	--exclude 'doc' --exclude 'nvidia-texture-tools-*.tar.gz' \
+	--exclude '*.user' -s ',^,nvidia-texture-tools/,' *
+#   --exclude '*.user' --transform 's,^,nvidia-texture-tools/,' *
+#	--exclude '*.user' *
+

cmake/DetermineProcessor.cmake

@@ -5,24 +5,68 @@ 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")
+		#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")
 
 		# 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`
+#~ 	# 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
 
 ELSE(UNIX)
+
   IF(WIN32)
-    SET (NV_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
+    # 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)
   ENDIF(WIN32)
+
 ENDIF(UNIX)
 
 

cmake/FindCUDA.cmake

@@ -1,142 +0,0 @@
-#
-# 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 (CPPFILE ${CUFILE} NAME_WE)
-		SET (CPPFILE ${CMAKE_CURRENT_BINARY_DIR}/${CPPFILE}.gen.cpp)
-
-		GET_CUFILE_DEPENDENCIES(CUDEPS ${CUFILE})
-		#MESSAGE("${CUDEPS}")
-
-		ADD_CUSTOM_COMMAND (
-			OUTPUT ${CPPFILE}
-			COMMAND ${CUDA_COMPILER}
-			ARGS -cuda ${cuda_includes} ${CUDA_OPTIONS} -o ${CPPFILE} ${CUFILE}
-			MAIN_DEPENDENCY ${CUFILE}
-			DEPENDS ${CUDEPS})
-
-		#MACRO_ADD_FILE_DEPENDENCIES(${CUFILE} ${CPPFILE})
-
-		SET (${outfiles} ${${outfiles}} ${CPPFILE})
-	ENDFOREACH (CUFILE)
-	
-	SET_SOURCE_FILES_PROPERTIES(${outfiles} PROPERTIES GENERATED 1)
-	
-ENDMACRO (WRAP_CUDA)

cmake/FindCg.cmake

@@ -3,14 +3,13 @@
 # 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_INCLUDE_DIR = 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)
@@ -22,7 +21,7 @@ IF (APPLE)
     ENDFOREACH(dir)
 
     # Find the include  dir
-    FIND_PATH(CG_INCLUDE_PATH cg.h
+    FIND_PATH(CG_INCLUDE_DIR cg.h
       ${CG_FRAMEWORK_INCLUDES}
       )
 
@@ -38,13 +37,25 @@ IF (APPLE)
     )
 ELSE (APPLE)
   IF (WIN32)
-    FIND_PROGRAM( CG_COMPILER cgc
-      $ENV{CG_BIN_PATH}
+ 
+    # 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)
@@ -52,7 +63,7 @@ ELSE (APPLE)
       SET (CG_COMPILER_DIR .)
       SET (CG_COMPILER_SUPER_DIR ..)
     ENDIF (CG_COMPILER)
-    FIND_PATH( CG_INCLUDE_PATH Cg/cg.h
+    FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
       $ENV{CG_INC_PATH}
       $ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/include
       $ENV{PROGRAMFILES}/Cg
@@ -61,27 +72,59 @@ ELSE (APPLE)
       ${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"
-      )
+	
+	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
+        $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{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"
+        )
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
+
   ELSE (WIN32)
     FIND_PROGRAM( CG_COMPILER cgc
       /usr/bin
@@ -90,7 +133,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_PATH Cg/cg.h
+    FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
       /usr/include
       /usr/local/include
       ${CG_COMPILER_SUPER_DIR}/include
@@ -120,10 +163,10 @@ ELSE (APPLE)
   ENDIF (WIN32)
 ENDIF (APPLE)
 
-IF (CG_INCLUDE_PATH)
+IF (CG_INCLUDE_DIR)
   SET( CG_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
-ELSE (CG_INCLUDE_PATH)
+ELSE (CG_INCLUDE_DIR)
   SET( CG_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
-ENDIF (CG_INCLUDE_PATH)
+ENDIF (CG_INCLUDE_DIR)
 
 MARK_AS_ADVANCED( CG_FOUND )

cmake/FindFreeImage.cmake

@@ -9,12 +9,14 @@
 
 IF (WIN32)
 	FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
-		${PROJECT_SOURCE_DIR}/extern/FreeImage
+		${FREEIMAGE_ROOT_DIR}/include
+		${FREEIMAGE_ROOT_DIR}
 		DOC "The directory where FreeImage.h resides")
 	FIND_LIBRARY( FREEIMAGE_LIBRARY
 		NAMES FreeImage freeimage
 		PATHS
-		${PROJECT_SOURCE_DIR}/FreeImage
+		${FREEIMAGE_ROOT_DIR}/lib
+		${FREEIMAGE_ROOT_DIR}
 		DOC "The FreeImage library")
 ELSE (WIN32)
 	FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
@@ -38,9 +40,9 @@ ENDIF (WIN32)
 SET(FREEIMAGE_LIBRARIES ${FREEIMAGE_LIBRARY})
 
 IF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
-	SET( FREEIMAGE_FOUND TRUE CACHE BOOL "Set to TRUE if GLEW is found, FALSE otherwise")
+	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 GLEW is found, FALSE otherwise")
+	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(

cmake/FindGLEW.cmake

@@ -10,24 +10,28 @@
 IF (WIN32)
 	FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
 		$ENV{PROGRAMFILES}/GLEW/include
-		${PROJECT_SOURCE_DIR}/src/nvgl/glew/include
+		${GLEW_ROOT_DIR}/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")
+
+    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
+		${GLEW_ROOT_DIR}/include
 		DOC "The directory where GL/glew.h resides")
+
+	# Prefer the static library.
 	FIND_LIBRARY( GLEW_LIBRARY
-		NAMES GLEW glew
+		NAMES libGLEW.a GLEW
 		PATHS
 		/usr/lib64
 		/usr/lib
@@ -35,13 +39,12 @@ ELSE (WIN32)
 		/usr/local/lib
 		/sw/lib
 		/opt/local/lib
+		${GLEW_ROOT_DIR}/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 )
+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)

cmake/FindGLUT.cmake

@@ -1,127 +0,0 @@
-# - 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,11 +53,7 @@ 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} ${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)
+	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)

cmake/OptimalOptions.cmake

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

data/bugs/85/tables.cpp

@@ -0,0 +1,95 @@
+
+#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;
+}
+