Cleanups for 2.1.0 release.

Fix build on VC2015 (missing typedefs)

CMakeLists.txt

@@ -1,22 +1,26 @@
-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)
 	# gnuwin32 paths:
-	SET(GNUWIN32_PATH "${NV_SOURCE_DIR}/extern/gnuwin")
+	SET(GNUWIN32_PATH "${NV_SOURCE_DIR}/extern/gnuwin32")
-	SET(CMAKE_INCLUDE_PATH "${GNUWIN32_PATH}/include")
+	SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${GNUWIN32_PATH}/include")
-	IF (NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
+	SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${GNUWIN32_PATH}/lib")
-	  SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${GNUWIN32_PATH}/lib/win64")
-	ELSE(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
-	  SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${GNUWIN32_PATH}/lib/win32")
-	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
 	
 	# Set GLUT path:
-	SET(GLUT_ROOT_PATH "${NV_SOURCE_DIR}/extern/glut")
+	SET(GLUT_ROOT_DIR "${NV_SOURCE_DIR}/extern/glut")
+
+	# Set FreeImage path:
+	SET(FREEIMAGE_ROOT_DIR "${NV_SOURCE_DIR}/extern/FreeImage")
 	
 ENDIF(WIN32)
 
@@ -25,6 +29,11 @@ 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)
@@ -37,9 +46,8 @@ ADD_SUBDIRECTORY(src)
 
 # These files should only be installed when creating packages.
 INSTALL(FILES 
-	NVIDIA_Texture_Tools_LICENSE.txt
+	LICENSE
-	NVIDIA_Texture_Tools_README.txt
+	README.md
-	ChangeLog 
 	DESTINATION share/doc/nvtt)
 
 # Add packaging support
@@ -50,14 +58,23 @@ IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 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 <icastano@nvidia.com>")
+SET(CPACK_PACKAGE_CONTACT "Ignacio Casta<74>o <castano@gmail.com>")
-SET(CPACK_PACKAGE_VENDOR "NVIDIA Corporation")
+#SET(CPACK_PACKAGE_VENDOR "NVIDIA Corporation")
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "GPU-accelerated Texture Tools with support for DirectX 10 texture formats")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Texture processing tools with support for Direct3D 10 and 11 formats.")
 
-SET(CPACK_PACKAGE_ICON "${NV_SOURCE_DIR}/project/vc8/nvcompress/nvidia.ico")
+SET(CPACK_PACKAGE_DESCRIPTION_FILE "${NV_SOURCE_DIR}/README.md")
+SET(CPACK_RESOURCE_FILE_LICENSE "${NV_SOURCE_DIR}/LICENSE")
 
-SET(CPACK_PACKAGE_DESCRIPTION_FILE "${NV_SOURCE_DIR}/NVIDIA_Texture_Tools_README.txt")
+# NSIS options:
-SET(CPACK_RESOURCE_FILE_LICENSE "${NV_SOURCE_DIR}/NVIDIA_Texture_Tools_LICENSE.txt")
+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")
+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.
@@ -12,6 +13,11 @@ NVIDIA Texture Tools version 2.1.0
  * 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.
@@ -22,6 +28,9 @@ NVIDIA Texture Tools version 2.0.6
  * 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.

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,187 +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
---------------------------------------------------------------------------------
-
-The NVIDIA Texture Tools is a collection of image processing and texture 
-manipulation tools, designed to be integrated in game tools and asset 
-conditioning pipelines.
-
-The primary features of the library are mipmap and normal map generation, format 
-conversion and DXT compression.
-
-DXT compression is based on Simon Brown's squish library. The library also 
-contains an alternative GPU-accelerated compressor that uses CUDA and on some
-GPUs is one order of magnitude faster.
-
-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.
-
-The latest installer is available at the official website:
-
-http://developer.nvidia.com/object/texture_tools.html
-
-Documentation and additional information can be found at the development site:
-
-http://code.google.com/p/nvidia-texture-tools/
-
-
-II.  Contents
---------------------------------------------------------------------------------
-
-This release contains only the source code of the texture compression library
-and several command line applications that serve as examples of how to use the
-library. 
-
-Documentation for the texture compression library is available at:
-
-http://code.google.com/p/nvidia-texture-tools/wiki/ApiDocumentation
-
-A brief description of the command line tools can be found at:
-
-http://code.google.com/p/nvidia-texture-tools/wiki/CommandLineTools
-
-
-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
-
-Detailed documentation of the API can be found at:
-
-http://code.google.com/p/nvidia-texture-tools/wiki/ApiDocumentation
-
-The usage of the commandline compression 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).
-  -alpha     	The input image has an alpha channel used for transparency.
-  -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.
-  -premula   	Premultiply alpha into color channel.
-  -mipfilter 	Mipmap filter. One of the following: box, triangle, kaiser.
-
-Compression options:
-  -fast    	Fast compression.
-  -nocuda  	Do not use cuda compressor.
-  -rgb     	RGBA format
-  -bc1     	BC1 format (DXT1)
-  -bc1n    	BC1 normal map format (DXT1nm)
-  -bc1a    	BC1 format with binary alpha (DXT1a)
-  -bc2     	BC2 format (DXT3)
-  -bc3     	BC3 format (DXT5)
-  -bc3n    	BC3 normal map format (DXT5nm)
-  -bc4     	BC4 format (ATI1)
-  -bc5     	BC5 format (3Dc/ATI2)
-
-Output options:
-  -silent  	Do not output progress messages
-  -dds10   	Use DirectX 10 DDS format
-
-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 file suggestions and bug reports at:
-
-http://code.google.com/p/nvidia-texture-tools/issues/list
-
-or contact us directly:
-
-TextureTools@nvidia.com
-
-
-
-VI.  Frequently Asked Questions
---------------------------------------------------------------------------------
-
-=== Where can I ask questions? How can I get support? ===
-You can ask questions about the usage of the Texture Tools at the [http://developer.nvidia.com/forums/index.php?showforum=9 NVIDIA developer forums]. You can report bugs and request new features in our [http://code.google.com/p/nvidia-texture-tools/issues/list issue database]. If you are a developer and have questions about the API or the source code, feel free to drop by the [http://groups.google.com/group/nvidia-texture-tools developer's mailing list]. If you would like to contact us privately, please send an email to [mailto:TextureTools@nvidia.com TextureTools@nvidia.com].
-
-=== 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. For this reason, we have also open sourced the code, so that people can modify it and add their own custom features.
-
-=== What platforms do the NVIDIA Texture Tools support? ===
-The tools are compiled and tested regularly on Linux, OSX, and Windows. Some platforms are tested more frequently than others and there may be bugs on some uncommon configurations.
-
-=== 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.
-
-Even if the texture tools are compiled with CUDA support it's possible to use them on systems that do not support CUDA or that do not have a valid CUDA driver installed.
-
-=== Where can I get CUDA? ===
-At [http://developer.nvidia.com/object/cuda.html]
-
-=== 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.
-
-=== Can I use the NVIDIA Texture Tools in the US? Do I have to obtain a license of the S3TC patent (US patent 5,956,431)? ===
-NVIDIA has a license of the S3TC patent that covers all our products, including our Texture Tools. You don't have to obtain a license of the S3TC patent to use any of NVIDIA's products, but certain uses of NVIDIA Texture Tools source code cannot be considered NVIDIA products anymore. Keep in mind that the NVIDIA Texture Tools are licensed under the MIT license and thus are provided without warranty of any kind.

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

@@ -3,5 +3,8 @@
 tar zcvf nvidia-texture-tools-`cat VERSION`.tar.gz \
 	--exclude '.*' --exclude debian --exclude '*~' --exclude buildpkg \
 	--exclude 'build-*' --exclude data --exclude tags --exclude Makefile \
-	--exclude qtcreator-build --exclude 'nvidia-texture-tools-*.tar.gz' \
+	--exclude 'doc' --exclude 'nvidia-texture-tools-*.tar.gz' \
-	--exclude '*.user' --transform 's,^,nvidia-texture-tools/,' *
+	--exclude '*.user' -s ',^,nvidia-texture-tools/,' *
+#   --exclude '*.user' --transform 's,^,nvidia-texture-tools/,' *
+#	--exclude '*.user' *
+

cmake/DetermineProcessor.cmake

@@ -5,30 +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:
+#~ 	# Get extended processor information from /proc/cpuinfo
-	# `cat /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)
     # 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 "AMD64")
+      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,164 +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
-	DOC "The directory where CUDA headers reside")
-
-FIND_PATH (CUTIL_INCLUDE_PATH cutil.h
-	"$ENV{NVSDKCUDA_ROOT}/common/inc"
-	"$ENV{PROGRAMFILES}/NVIDIA Corporation/NVIDIA CUDA SDK/common/inc"
-	DOC "The directory where the CUTIL 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")
-
-FIND_LIBRARY (CUTIL_LIBRARY
-	NAMES cutil32 cutil64
-	PATHS
-	"$ENV{NVSDKCUDA_ROOT}/common/lib"
-	"$ENV{PROGRAMFILES}/NVIDIA Corporation/NVIDIA CUDA SDK/common/lib"
-	DOC "The CUTIL 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)
-
-
-IF (CUTIL_INCLUDE_PATH AND CUTIL_LIBRARY)
-	SET (CUTIL_FOUND 1 CACHE STRING "Set to 1 if CUDA is found, 0 otherwise")
-ELSE (CUTIL_INCLUDE_PATH AND CUTIL_LIBRARY)
-	SET (CUTIL_FOUND 0 CACHE STRING "Set to 1 if CUDA is found, 0 otherwise")
-ENDIF (CUTIL_INCLUDE_PATH AND CUTIL_LIBRARY)
-
-SET (CUTIL_LIBRARIES ${CUTIL_LIBRARY})
-
-MARK_AS_ADVANCED (CUTIL_FOUND)
-
-
-#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,7 +3,7 @@
 # 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)
@@ -21,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}
       )
 
@@ -63,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
@@ -73,7 +73,7 @@ ELSE (APPLE)
       DOC "The directory where Cg/cg.h resides"
       )
 	
-	IF (NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
+	IF (NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
       FIND_LIBRARY( CG_LIBRARY
         NAMES Cg
         PATHS
@@ -100,7 +100,7 @@ ELSE (APPLE)
         ${CG_COMPILER_DIR}
         DOC "The Cg GL runtime library (64-bit)"
         )
-	ELSE(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
+	ELSE(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
       FIND_LIBRARY( CG_LIBRARY
         NAMES Cg
         PATHS
@@ -123,7 +123,7 @@ ELSE (APPLE)
         ${CG_COMPILER_DIR}
         DOC "The Cg GL runtime library"
         )
-	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
+	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
 
   ELSE (WIN32)
     FIND_PROGRAM( CG_COMPILER cgc
@@ -133,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
@@ -163,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

@@ -13,25 +13,13 @@ IF (WIN32)
 		${GLEW_ROOT_DIR}/include
 		DOC "The directory where GL/glew.h resides")
 
-	IF (NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
+    FIND_LIBRARY( GLEW_LIBRARY
-		FIND_LIBRARY( GLEW_LIBRARY
+        NAMES glew GLEW glew32 glew32s
-			NAMES glew64 glew64s
+        PATHS
-			PATHS
+        $ENV{PROGRAMFILES}/GLEW/lib
-			$ENV{PROGRAMFILES}/GLEW/lib
+        ${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
-			${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
+        ${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
-	    	${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
+        DOC "The GLEW library")
-			DOC "The GLEW library (64-bit)"
-		)
-	ELSE(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
-		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"
-		)
-	ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "AMD64")
 ELSE (WIN32)
 	FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
 		/usr/include
@@ -41,8 +29,9 @@ ELSE (WIN32)
 		${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
@@ -59,4 +48,3 @@ IF (GLEW_INCLUDE_PATH AND GLEW_LIBRARY)
 	SET(GLEW_LIBRARIES ${GLEW_LIBRARY})
 	SET(GLEW_FOUND "YES")
 ENDIF (GLEW_INCLUDE_PATH AND GLEW_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")
+	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")
-
-	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

@@ -35,11 +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" ;;
+		--debug )				build="debug" ;;
-		--release )				build="Release" ;;
+		--release )				build="release" ;;
-		--prefix=* )			prefix="${i#--prefix=}" ;;
 		--prefix=* )			prefix="${i#--prefix=}" ;;
 		* )						echo "Unrecognised argument $i" ;;
 	esac
@@ -53,7 +52,7 @@ echo "-- Configuring nvidia-texture-tools "`cat VERSION`
 
 mkdir -p ./build-$build
 cd ./build-$build
-$CMAKE .. -DNVTT_SHARED=1 -DCMAKE_BUILD_TYPE=$build -DCMAKE_INSTALL_PREFIX=$prefix -G "Unix Makefiles" || exit 1
+$CMAKE .. -DNVTT_SHARED=0 -DCMAKE_BUILD_TYPE=$build -DCMAKE_INSTALL_PREFIX=$prefix -G "Unix Makefiles" || exit 1
 cd ..
 
 echo ""
@@ -62,15 +61,15 @@ echo ""
 
 cat > Makefile << EOF
 all:
-	@make --no-print-directory -C build-$build/
+	@+make --no-print-directory -C build-$build/
 install:
-	@make install --no-print-directory -C build-$build/
+	@+make install --no-print-directory -C build-$build/
 package:
-	@make package --no-print-directory -C build-$build/
+	@+make package --no-print-directory -C build-$build/
 test:
-	@make test --no-print-directory -C build-$build/
+	@+make test --no-print-directory -C build-$build/
 clean:
-	@make clean --no-print-directory -C build-$build/
+	@+make clean --no-print-directory -C build-$build/
 distclean:
 	@rm -Rf build-$build/
 EOF