Win32: Get 32-bit Windows build working

Also includes changes to allow simultaneous 32-bit and 64-bit Windows builds.

20 files changed, 1317 insertions, 175 deletions

diff --git a/cmake/CMakeParseArguments.cmake b/cmake/CMakeParseArguments.cmake
new file mode 100644
index 00000000..8553f38f
--- /dev/null
+++ b/cmake/CMakeParseArguments.cmake
@@ -0,0 +1,161 @@
+#.rst:
+# CMakeParseArguments
+# -------------------
+#
+#
+#
+# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords>
+# <multi_value_keywords> args...)
+#
+# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions
+# for parsing the arguments given to that macro or function.  It
+# processes the arguments and defines a set of variables which hold the
+# values of the respective options.
+#
+# The <options> argument contains all options for the respective macro,
+# i.e.  keywords which can be used when calling the macro without any
+# value following, like e.g.  the OPTIONAL keyword of the install()
+# command.
+#
+# The <one_value_keywords> argument contains all keywords for this macro
+# which are followed by one value, like e.g.  DESTINATION keyword of the
+# install() command.
+#
+# The <multi_value_keywords> argument contains all keywords for this
+# macro which can be followed by more than one value, like e.g.  the
+# TARGETS or FILES keywords of the install() command.
+#
+# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
+# keywords listed in <options>, <one_value_keywords> and
+# <multi_value_keywords> a variable composed of the given <prefix>
+# followed by "_" and the name of the respective keyword.  These
+# variables will then hold the respective value from the argument list.
+# For the <options> keywords this will be TRUE or FALSE.
+#
+# All remaining arguments are collected in a variable
+# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see
+# whether your macro was called with unrecognized parameters.
+#
+# As an example here a my_install() macro, which takes similar arguments
+# as the real install() command:
+#
+# ::
+#
+#    function(MY_INSTALL)
+#      set(options OPTIONAL FAST)
+#      set(oneValueArgs DESTINATION RENAME)
+#      set(multiValueArgs TARGETS CONFIGURATIONS)
+#      cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}"
+#                            "${multiValueArgs}" ${ARGN} )
+#      ...
+#
+#
+#
+# Assume my_install() has been called like this:
+#
+# ::
+#
+#    my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
+#
+#
+#
+# After the cmake_parse_arguments() call the macro will have set the
+# following variables:
+#
+# ::
+#
+#    MY_INSTALL_OPTIONAL = TRUE
+#    MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
+#    MY_INSTALL_DESTINATION = "bin"
+#    MY_INSTALL_RENAME = "" (was not used)
+#    MY_INSTALL_TARGETS = "foo;bar"
+#    MY_INSTALL_CONFIGURATIONS = "" (was not used)
+#    MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
+#
+#
+#
+# You can then continue and process these variables.
+#
+# Keywords terminate lists of values, e.g.  if directly after a
+# one_value_keyword another recognized keyword follows, this is
+# interpreted as the beginning of the new option.  E.g.
+# my_install(TARGETS foo DESTINATION OPTIONAL) would result in
+# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION
+# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+
+#=============================================================================
+# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
+  return()
+endif()
+set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
+
+
+function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
+  # first set all result variables to empty/FALSE
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
+    set(${prefix}_${arg_name})
+  endforeach()
+
+  foreach(option ${_optionNames})
+    set(${prefix}_${option} FALSE)
+  endforeach()
+
+  set(${prefix}_UNPARSED_ARGUMENTS)
+
+  set(insideValues FALSE)
+  set(currentArgName)
+
+  # now iterate over all arguments and fill the result variables
+  foreach(currentArg ${ARGN})
+    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+
+    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
+      if(insideValues)
+        if("${insideValues}" STREQUAL "SINGLE")
+          set(${prefix}_${currentArgName} ${currentArg})
+          set(insideValues FALSE)
+        elseif("${insideValues}" STREQUAL "MULTI")
+          list(APPEND ${prefix}_${currentArgName} ${currentArg})
+        endif()
+      else()
+        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
+      endif()
+    else()
+      if(NOT ${optionIndex} EQUAL -1)
+        set(${prefix}_${currentArg} TRUE)
+        set(insideValues FALSE)
+      elseif(NOT ${singleArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "SINGLE")
+      elseif(NOT ${multiArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "MULTI")
+      endif()
+    endif()
+
+  endforeach()
+
+  # propagate the result variables to the caller:
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
+    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
+  endforeach()
+  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
+
+endfunction()
diff --git a/cmake/FindImageMagick.cmake b/cmake/FindImageMagick.cmake
new file mode 100644
index 00000000..c0b88518
--- /dev/null
+++ b/cmake/FindImageMagick.cmake
@@ -0,0 +1,349 @@
+#.rst:
+# FindImageMagick
+# ---------------
+#
+# Find the ImageMagick binary suite.
+#
+# This module will search for a set of ImageMagick tools specified as
+# components in the FIND_PACKAGE call.  Typical components include, but
+# are not limited to (future versions of ImageMagick might have
+# additional components not listed here):
+#
+# ::
+#
+#   animate
+#   compare
+#   composite
+#   conjure
+#   convert
+#   display
+#   identify
+#   import
+#   mogrify
+#   montage
+#   stream
+#
+#
+#
+# If no component is specified in the FIND_PACKAGE call, then it only
+# searches for the ImageMagick executable directory.  This code defines
+# the following variables:
+#
+# ::
+#
+#   ImageMagick_FOUND                  - TRUE if all components are found.
+#   ImageMagick_EXECUTABLE_DIR         - Full path to executables directory.
+#   ImageMagick_<component>_FOUND      - TRUE if <component> is found.
+#   ImageMagick_<component>_EXECUTABLE - Full path to <component> executable.
+#   ImageMagick_VERSION_STRING         - the version of ImageMagick found
+#                                        (since CMake 2.8.8)
+#
+#
+#
+# ImageMagick_VERSION_STRING will not work for old versions like 5.2.3.
+#
+# There are also components for the following ImageMagick APIs:
+#
+# ::
+#
+#   Magick++
+#   MagickWand
+#   MagickCore
+#
+#
+#
+# For these components the following variables are set:
+#
+# ::
+#
+#   ImageMagick_FOUND                    - TRUE if all components are found.
+#   ImageMagick_INCLUDE_DIRS             - Full paths to all include dirs.
+#   ImageMagick_LIBRARIES                - Full paths to all libraries.
+#   ImageMagick_<component>_FOUND        - TRUE if <component> is found.
+#   ImageMagick_<component>_INCLUDE_DIRS - Full path to <component> include dirs.
+#   ImageMagick_<component>_LIBRARIES    - Full path to <component> libraries.
+#
+#
+#
+# Example Usages:
+#
+# ::
+#
+#   find_package(ImageMagick)
+#   find_package(ImageMagick COMPONENTS convert)
+#   find_package(ImageMagick COMPONENTS convert mogrify display)
+#   find_package(ImageMagick COMPONENTS Magick++)
+#   find_package(ImageMagick COMPONENTS Magick++ convert)
+#
+#
+#
+# Note that the standard FIND_PACKAGE features are supported (i.e.,
+# QUIET, REQUIRED, etc.).
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+# Copyright 2007-2008 Miguel A. Figueroa-Villanueva <miguelf at ieee dot org>
+# Copyright 2012 Rolf Eike Beer <eike@sf-mail.de>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_package(PkgConfig QUIET)
+
+function(FIND_REGISTRY)
+  if (WIN32)
+    # If a 64-bit compile, it can only appear in "[HKLM]\\software\\ImageMagick"
+    if (CMAKE_CL_64)
+    
+      set (IMAGEMAGIC_REG_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]" PARENT_SCOPE)
+      set (IMAGEMAGIC_REGINCLUDE_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/include" PARENT_SCOPE)
+      set (IMAGEMAGIC_REGLIB_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/lib" PARENT_SCOPE)
+      
+    else()
+    
+      # This is dumb, but it's the only way I've been able to get this to work.  CMake has no knowledge of the systems architecture.
+      # So, if we want to detect if we're running a 32-bit compile on a 64-bit OS, we need to manually check for the existence of
+      # ImageMagick in the WOW6432Node of the registry first.  If that fails, assume they want the 64-bit version.
+      GET_FILENAME_COMPONENT(TESTING  
+        [HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\ImageMagick\\Current;BinPath]
+        PATH)
+
+      # If a 32-bit compile on a 64-bit Windows, it appears in "[HKLM]\\software\\WOW6432Node\\ImageMagick"
+      if (TESTING STREQUAL "C:/Program Files (x86)")
+      
+        set (IMAGEMAGIC_REG_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\ImageMagick\\Current;BinPath] PARENT_SCOPE)
+        set (IMAGEMAGIC_REGINCLUDE_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\ImageMagick\\Current;BinPath]/include PARENT_SCOPE)
+        set (IMAGEMAGIC_REGLIB_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\ImageMagick\\Current;BinPath]/lib PARENT_SCOPE)
+        
+      # If a 32-bit compile on a 32-bit Windows, it appears in "[HKLM]\\software\\ImageMagick"
+      else()
+      
+        set (IMAGEMAGIC_REG_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath] PARENT_SCOPE)
+        set (IMAGEMAGIC_REGINCLUDE_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/include PARENT_SCOPE)
+        set (IMAGEMAGIC_REGLIB_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/lib PARENT_SCOPE)
+        
+      endif()
+      
+    endif()
+  else()
+  
+  message(WARNING "In FIND_REGISTRY:  LINUX_BUILD")
+    set (IMAGEMAGIC_REG_PATH "" PARENT_SCOPE)
+    set (IMAGEMAGIC_REGINCLUDE_PATH "" PARENT_SCOPE)
+    set (IMAGEMAGIC_REGLIB_PATH "" PARENT_SCOPE)
+    
+  endif()
+endfunction()
+
+
+#---------------------------------------------------------------------
+# Helper functions
+#---------------------------------------------------------------------
+function(FIND_IMAGEMAGICK_API component header)
+  set(ImageMagick_${component}_FOUND FALSE PARENT_SCOPE)
+
+  pkg_check_modules(PC_${component} QUIET ${component})
+
+  find_path(ImageMagick_${component}_INCLUDE_DIR
+    NAMES ${header}
+    HINTS
+      ${IMAGEMAGIC_REGINCLUDE_PATH}
+      ${PC_${component}_INCLUDEDIR}
+      ${PC_${component}_INCLUDE_DIRS}
+    PATHS
+      ${ImageMagick_INCLUDE_DIRS}
+      ${IMAGEMAGIC_REGINCLUDE_PATH}
+    PATH_SUFFIXES
+      ImageMagick ImageMagick-6
+    DOC "Path to the ImageMagick arch-independent include dir."
+    )
+  find_path(ImageMagick_${component}_ARCH_INCLUDE_DIR
+    NAMES magick/magick-baseconfig.h
+    HINTS
+      ${IMAGEMAGIC_REGINCLUDE_PATH}
+      ${PC_${component}_INCLUDEDIR}
+      ${PC_${component}_INCLUDE_DIRS}
+    PATHS
+      ${ImageMagick_INCLUDE_DIRS}
+      ${IMAGEMAGIC_REGINCLUDE_PATH}
+    PATH_SUFFIXES
+      ImageMagick ImageMagick-6
+    DOC "Path to the ImageMagick arch-specific include dir."
+    )
+  find_library(ImageMagick_${component}_LIBRARY
+    NAMES ${ARGN}
+    HINTS
+      ${IMAGEMAGIC_REGLIB_PATH}
+      ${PC_${component}_LIBDIR}
+      ${PC_${component}_LIB_DIRS}
+    PATHS
+      ${IMAGEMAGIC_REGLIB_PATH}
+    DOC "Path to the ImageMagick Magick++ library."
+    )
+
+  # old version have only indep dir
+  if(ImageMagick_${component}_INCLUDE_DIR AND ImageMagick_${component}_LIBRARY)
+    set(ImageMagick_${component}_FOUND TRUE PARENT_SCOPE)
+
+    # Construct per-component include directories.
+    set(ImageMagick_${component}_INCLUDE_DIRS
+      ${ImageMagick_${component}_INCLUDE_DIR}
+      )
+    if(ImageMagick_${component}_ARCH_INCLUDE_DIR)
+      list(APPEND ImageMagick_${component}_INCLUDE_DIRS
+        ${ImageMagick_${component}_ARCH_INCLUDE_DIR})
+    endif()
+    list(REMOVE_DUPLICATES ImageMagick_${component}_INCLUDE_DIRS)
+    set(ImageMagick_${component}_INCLUDE_DIRS
+      ${ImageMagick_${component}_INCLUDE_DIRS} PARENT_SCOPE)
+
+    # Add the per-component include directories to the full include dirs.
+    list(APPEND ImageMagick_INCLUDE_DIRS ${ImageMagick_${component}_INCLUDE_DIRS})
+    list(REMOVE_DUPLICATES ImageMagick_INCLUDE_DIRS)
+    set(ImageMagick_INCLUDE_DIRS ${ImageMagick_INCLUDE_DIRS} PARENT_SCOPE)
+
+    list(APPEND ImageMagick_LIBRARIES
+      ${ImageMagick_${component}_LIBRARY}
+      )
+    set(ImageMagick_LIBRARIES ${ImageMagick_LIBRARIES} PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(FIND_IMAGEMAGICK_EXE component)
+  set(_IMAGEMAGICK_EXECUTABLE
+    ${ImageMagick_EXECUTABLE_DIR}/${component}${CMAKE_EXECUTABLE_SUFFIX})
+
+  if(EXISTS ${_IMAGEMAGICK_EXECUTABLE})
+    set(ImageMagick_${component}_EXECUTABLE
+      ${_IMAGEMAGICK_EXECUTABLE}
+       PARENT_SCOPE
+       )
+    set(ImageMagick_${component}_FOUND TRUE PARENT_SCOPE)
+  else()
+    set(ImageMagick_${component}_FOUND FALSE PARENT_SCOPE)
+  endif()
+endfunction()
+
+#---------------------------------------------------------------------
+# Start Actual Work
+#---------------------------------------------------------------------
+FIND_REGISTRY()
+
+# Try to find a ImageMagick installation binary path.
+find_path(ImageMagick_EXECUTABLE_DIR
+  NAMES mogrify${CMAKE_EXECUTABLE_SUFFIX}
+  PATHS
+    ${IMAGEMAGIC_REG_PATH}
+  DOC "Path to the ImageMagick binary directory."
+  NO_DEFAULT_PATH
+  )
+find_path(ImageMagick_EXECUTABLE_DIR
+  NAMES mogrify${CMAKE_EXECUTABLE_SUFFIX}
+  )
+
+# Find each component. Search for all tools in same dir
+# <ImageMagick_EXECUTABLE_DIR>; otherwise they should be found
+# independently and not in a cohesive module such as this one.
+unset(ImageMagick_REQUIRED_VARS)
+unset(ImageMagick_DEFAULT_EXECUTABLES)
+foreach(component ${ImageMagick_FIND_COMPONENTS}
+    # DEPRECATED: forced components for backward compatibility
+    convert mogrify import montage composite
+    )
+  if(component STREQUAL "Magick++")
+    FIND_IMAGEMAGICK_API(Magick++ Magick++.h
+      Magick++ CORE_RL_Magick++_ Magick++-6.Q16 Magick++-Q16 Magick++-6.Q8 Magick++-Q8 Magick++-6.Q16HDRI Magick++-Q16HDRI Magick++-6.Q8HDRI Magick++-Q8HDRI
+      )
+    list(APPEND ImageMagick_REQUIRED_VARS ImageMagick_Magick++_LIBRARY)
+  elseif(component STREQUAL "MagickWand")
+    FIND_IMAGEMAGICK_API(MagickWand wand/MagickWand.h
+      Wand MagickWand CORE_RL_wand_ MagickWand-6.Q16 MagickWand-Q16 MagickWand-6.Q8 MagickWand-Q8 MagickWand-6.Q16HDRI MagickWand-Q16HDRI MagickWand-6.Q8HDRI MagickWand-Q8HDRI
+      )
+    list(APPEND ImageMagick_REQUIRED_VARS ImageMagick_MagickWand_LIBRARY)
+  elseif(component STREQUAL "MagickCore")
+    FIND_IMAGEMAGICK_API(MagickCore magick/MagickCore.h
+      Magick MagickCore CORE_RL_magick_ MagickCore-6.Q16 MagickCore-Q16 MagickCore-6.Q8 MagickCore-Q8 MagickCore-6.Q16HDRI MagickCore-Q16HDRI MagickCore-6.Q8HDRI MagickCore-Q8HDRI
+      )
+    list(APPEND ImageMagick_REQUIRED_VARS ImageMagick_MagickCore_LIBRARY)
+  else()
+    if(ImageMagick_EXECUTABLE_DIR)
+      FIND_IMAGEMAGICK_EXE(${component})
+    endif()
+
+    if(ImageMagick_FIND_COMPONENTS)
+      list(FIND ImageMagick_FIND_COMPONENTS ${component} is_requested)
+      if(is_requested GREATER -1)
+        list(APPEND ImageMagick_REQUIRED_VARS ImageMagick_${component}_EXECUTABLE)
+      endif()
+    elseif(ImageMagick_${component}_EXECUTABLE)
+      # if no components were requested explicitly put all (default) executables
+      # in the list
+      list(APPEND ImageMagick_DEFAULT_EXECUTABLES ImageMagick_${component}_EXECUTABLE)
+    endif()
+  endif()
+endforeach()
+
+if(NOT ImageMagick_FIND_COMPONENTS AND NOT ImageMagick_DEFAULT_EXECUTABLES)
+  # No components were requested, and none of the default components were
+  # found. Just insert mogrify into the list of the default components to
+  # find so FPHSA below has something to check
+  list(APPEND ImageMagick_REQUIRED_VARS ImageMagick_mogrify_EXECUTABLE)
+elseif(ImageMagick_DEFAULT_EXECUTABLES)
+  list(APPEND ImageMagick_REQUIRED_VARS ${ImageMagick_DEFAULT_EXECUTABLES})
+endif()
+
+set(ImageMagick_INCLUDE_DIRS ${ImageMagick_INCLUDE_DIRS})
+set(ImageMagick_LIBRARIES ${ImageMagick_LIBRARIES})
+
+if(ImageMagick_mogrify_EXECUTABLE)
+  execute_process(COMMAND ${ImageMagick_mogrify_EXECUTABLE} -version
+                  OUTPUT_VARIABLE imagemagick_version
+                  ERROR_QUIET
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(imagemagick_version MATCHES "^Version: ImageMagick ([-0-9\\.]+)")
+    set(ImageMagick_VERSION_STRING "${CMAKE_MATCH_1}")
+  endif()
+  unset(imagemagick_version)
+endif()
+
+#---------------------------------------------------------------------
+# Standard Package Output
+#---------------------------------------------------------------------
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ImageMagick
+                                  REQUIRED_VARS ${ImageMagick_REQUIRED_VARS}
+                                  VERSION_VAR ImageMagick_VERSION_STRING
+  )
+# Maintain consistency with all other variables.
+set(ImageMagick_FOUND ${IMAGEMAGICK_FOUND})
+
+#---------------------------------------------------------------------
+# DEPRECATED: Setting variables for backward compatibility.
+#---------------------------------------------------------------------
+set(IMAGEMAGICK_BINARY_PATH          ${ImageMagick_EXECUTABLE_DIR}
+    CACHE PATH "Path to the ImageMagick binary directory.")
+set(IMAGEMAGICK_CONVERT_EXECUTABLE   ${ImageMagick_convert_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's convert executable.")
+set(IMAGEMAGICK_MOGRIFY_EXECUTABLE   ${ImageMagick_mogrify_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's mogrify executable.")
+set(IMAGEMAGICK_IMPORT_EXECUTABLE    ${ImageMagick_import_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's import executable.")
+set(IMAGEMAGICK_MONTAGE_EXECUTABLE   ${ImageMagick_montage_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's montage executable.")
+set(IMAGEMAGICK_COMPOSITE_EXECUTABLE ${ImageMagick_composite_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's composite executable.")
+mark_as_advanced(
+  IMAGEMAGICK_BINARY_PATH
+  IMAGEMAGICK_CONVERT_EXECUTABLE
+  IMAGEMAGICK_MOGRIFY_EXECUTABLE
+  IMAGEMAGICK_IMPORT_EXECUTABLE
+  IMAGEMAGICK_MONTAGE_EXECUTABLE
+  IMAGEMAGICK_COMPOSITE_EXECUTABLE
+  )
diff --git a/cmake/FindPackageHandleStandardArgs.cmake b/cmake/FindPackageHandleStandardArgs.cmake
new file mode 100644
index 00000000..fe2dbeaa
--- /dev/null
+++ b/cmake/FindPackageHandleStandardArgs.cmake
@@ -0,0 +1,396 @@
+#[=======================================================================[.rst:
+FindPackageHandleStandardArgs
+-----------------------------
+
+This module provides a function intended to be used in :ref:`Find Modules`
+implementing :command:`find_package(<PackageName>)` calls.  It handles the
+``REQUIRED``, ``QUIET`` and version-related arguments of ``find_package``.
+It also sets the ``<PackageName>_FOUND`` variable.  The package is
+considered found if all variables listed contain valid results, e.g.
+valid filepaths.
+
+.. command:: find_package_handle_standard_args
+
+  There are two signatures::
+
+    find_package_handle_standard_args(<PackageName>
+      (DEFAULT_MSG|<custom-failure-message>)
+      <required-var>...
+      )
+
+    find_package_handle_standard_args(<PackageName>
+      [FOUND_VAR <result-var>]
+      [REQUIRED_VARS <required-var>...]
+      [VERSION_VAR <version-var>]
+      [HANDLE_COMPONENTS]
+      [CONFIG_MODE]
+      [FAIL_MESSAGE <custom-failure-message>]
+      )
+
+  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all
+  the variables ``<required-var>...`` are valid and any optional
+  constraints are satisfied, and ``FALSE`` otherwise.  A success or
+  failure message may be displayed based on the results and on
+  whether the ``REQUIRED`` and/or ``QUIET`` option was given to
+  the :command:`find_package` call.
+
+  The options are:
+
+  ``(DEFAULT_MSG|<custom-failure-message>)``
+    In the simple signature this specifies the failure message.
+    Use ``DEFAULT_MSG`` to ask for a default message to be computed
+    (recommended).  Not valid in the full signature.
+
+  ``FOUND_VAR <result-var>``
+    Obsolete.  Specifies either ``<PackageName>_FOUND`` or
+    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only
+    for compatibility with older versions of CMake and is now ignored.
+    Result variables of both names are always set for compatibility.
+
+  ``REQUIRED_VARS <required-var>...``
+    Specify the variables which are required for this package.
+    These may be named in the generated failure message asking the
+    user to set the missing variable values.  Therefore these should
+    typically be cache entries such as ``FOO_LIBRARY`` and not output
+    variables like ``FOO_LIBRARIES``.
+
+  ``VERSION_VAR <version-var>``
+    Specify the name of a variable that holds the version of the package
+    that has been found.  This version will be checked against the
+    (potentially) specified required version given to the
+    :command:`find_package` call, including its ``EXACT`` option.
+    The default messages include information about the required
+    version and the version which has been actually found, both
+    if the version is ok or not.
+
+  ``HANDLE_COMPONENTS``
+    Enable handling of package components.  In this case, the command
+    will report which components have been found and which are missing,
+    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``
+    if any of the required components (i.e. not the ones listed after
+    the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are
+    missing.
+
+  ``CONFIG_MODE``
+    Specify that the calling find module is a wrapper around a
+    call to ``find_package(<PackageName> NO_MODULE)``.  This implies
+    a ``VERSION_VAR`` value of ``<PackageName>_VERSION``.  The command
+    will automatically check whether the package configuration file
+    was found.
+
+  ``FAIL_MESSAGE <custom-failure-message>``
+    Specify a custom failure message instead of using the default
+    generated message.  Not recommended.
+
+Example for the simple signature:
+
+.. code-block:: cmake
+
+  find_package_handle_standard_args(LibXml2 DEFAULT_MSG
+    LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
+
+The ``LibXml2`` package is considered to be found if both
+``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid.
+Then also ``LibXml2_FOUND`` is set to ``TRUE``.  If it is not found
+and ``REQUIRED`` was used, it fails with a
+:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was
+used or not.  If it is found, success will be reported, including
+the content of the first ``<required-var>``.  On repeated CMake runs,
+the same message will not be printed again.
+
+Example for the full signature:
+
+.. code-block:: cmake
+
+  find_package_handle_standard_args(LibArchive
+    REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR
+    VERSION_VAR LibArchive_VERSION)
+
+In this case, the ``LibArchive`` package is considered to be found if
+both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid.
+Also the version of ``LibArchive`` will be checked by using the version
+contained in ``LibArchive_VERSION``.  Since no ``FAIL_MESSAGE`` is given,
+the default messages will be printed.
+
+Another example for the full signature:
+
+.. code-block:: cmake
+
+  find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
+  find_package_handle_standard_args(Automoc4  CONFIG_MODE)
+
+In this case, a ``FindAutmoc4.cmake`` module wraps a call to
+``find_package(Automoc4 NO_MODULE)`` and adds an additional search
+directory for ``automoc4``.  Then the call to
+``find_package_handle_standard_args`` produces a proper success/failure
+message.
+#]=======================================================================]
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
+
+# internal helper macro
+macro(_FPHSA_FAILURE_MESSAGE _msg)
+  if (${_NAME}_FIND_REQUIRED)
+    message(FATAL_ERROR "${_msg}")
+  else ()
+    if (NOT ${_NAME}_FIND_QUIETLY)
+      message(STATUS "${_msg}")
+    endif ()
+  endif ()
+endmacro()
+
+
+# internal helper macro to generate the failure message when used in CONFIG_MODE:
+macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
+  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
+  if(${_NAME}_CONFIG)
+    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
+  else()
+    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
+    # List them all in the error message:
+    if(${_NAME}_CONSIDERED_CONFIGS)
+      set(configsText "")
+      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
+      math(EXPR configsCount "${configsCount} - 1")
+      foreach(currentConfigIndex RANGE ${configsCount})
+        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
+        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
+        set(configsText "${configsText}    ${filename} (version ${version})\n")
+      endforeach()
+      if (${_NAME}_NOT_FOUND_MESSAGE)
+        set(configsText "${configsText}    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
+      endif()
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
+
+    else()
+      # Simple case: No Config-file was found at all:
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
+    endif()
+  endif()
+endmacro()
+
+
+function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
+
+# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
+# new extended or in the "old" mode:
+  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
+  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
+  set(multiValueArgs REQUIRED_VARS)
+  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
+  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
+
+  if(${INDEX} EQUAL -1)
+    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
+    set(FPHSA_REQUIRED_VARS ${ARGN})
+    set(FPHSA_VERSION_VAR)
+  else()
+
+    CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
+
+    if(FPHSA_UNPARSED_ARGUMENTS)
+      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    if(NOT FPHSA_FAIL_MESSAGE)
+      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
+    endif()
+  endif()
+
+# now that we collected all arguments, process them
+
+  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
+    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
+  endif()
+
+  # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
+  # when it successfully found the config-file, including version checking:
+  if(FPHSA_CONFIG_MODE)
+    list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
+    list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
+    set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
+  endif()
+
+  if(NOT FPHSA_REQUIRED_VARS)
+    message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
+  endif()
+
+  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
+
+  string(TOUPPER ${_NAME} _NAME_UPPER)
+  string(TOLOWER ${_NAME} _NAME_LOWER)
+
+  if(FPHSA_FOUND_VAR)
+    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
+      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
+    else()
+      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
+    endif()
+  else()
+    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
+  endif()
+
+  # collect all variables which were not found, so they can be printed, so the
+  # user knows better what went wrong (#6375)
+  set(MISSING_VARS "")
+  set(DETAILS "")
+  # check if all passed variables are valid
+  set(FPHSA_FOUND_${_NAME} TRUE)
+  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
+    if(NOT ${_CURRENT_VAR})
+      set(FPHSA_FOUND_${_NAME} FALSE)
+      set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
+    else()
+      set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]")
+    endif()
+  endforeach()
+  if(FPHSA_FOUND_${_NAME})
+    set(${_NAME}_FOUND TRUE)
+    set(${_NAME_UPPER}_FOUND TRUE)
+  else()
+    set(${_NAME}_FOUND FALSE)
+    set(${_NAME_UPPER}_FOUND FALSE)
+  endif()
+
+  # component handling
+  unset(FOUND_COMPONENTS_MSG)
+  unset(MISSING_COMPONENTS_MSG)
+
+  if(FPHSA_HANDLE_COMPONENTS)
+    foreach(comp ${${_NAME}_FIND_COMPONENTS})
+      if(${_NAME}_${comp}_FOUND)
+
+        if(NOT DEFINED FOUND_COMPONENTS_MSG)
+          set(FOUND_COMPONENTS_MSG "found components: ")
+        endif()
+        set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}")
+
+      else()
+
+        if(NOT DEFINED MISSING_COMPONENTS_MSG)
+          set(MISSING_COMPONENTS_MSG "missing components: ")
+        endif()
+        set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}")
+
+        if(${_NAME}_FIND_REQUIRED_${comp})
+          set(${_NAME}_FOUND FALSE)
+          set(MISSING_VARS "${MISSING_VARS} ${comp}")
+        endif()
+
+      endif()
+    endforeach()
+    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
+    set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]")
+  endif()
+
+  # version handling:
+  set(VERSION_MSG "")
+  set(VERSION_OK TRUE)
+  set(VERSION ${${FPHSA_VERSION_VAR}})
+
+  # check with DEFINED here as the requested or found version may be "0"
+  if (DEFINED ${_NAME}_FIND_VERSION)
+    if(DEFINED ${FPHSA_VERSION_VAR})
+
+      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
+        # count the dots in the version string
+        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}")
+        # add one dot because there is one dot more than there are components
+        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
+        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
+          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
+          # is at most 4 here. Therefore a simple lookup table is used.
+          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
+            set(_VERSION_REGEX "[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
+          else ()
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
+          endif ()
+          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}")
+          unset(_VERSION_REGEX)
+          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+          unset(_VERSION_HEAD)
+        else ()
+          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL VERSION)
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+        endif ()
+        unset(_VERSION_DOTS)
+
+      else()     # minimum version specified:
+        if (${_NAME}_FIND_VERSION VERSION_GREATER VERSION)
+          set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
+          set(VERSION_OK FALSE)
+        else ()
+          set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
+        endif ()
+      endif()
+
+    else()
+
+      # if the package was not found, but a version was given, add that to the output:
+      if(${_NAME}_FIND_VERSION_EXACT)
+         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
+      else()
+         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
+      endif()
+
+    endif()
+  else ()
+    if(VERSION)
+      set(VERSION_MSG "(found version \"${VERSION}\")")
+    endif()
+  endif ()
+
+  if(VERSION_OK)
+    set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]")
+  else()
+    set(${_NAME}_FOUND FALSE)
+  endif()
+
+
+  # print the result:
+  if (${_NAME}_FOUND)
+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
+  else ()
+
+    if(FPHSA_CONFIG_MODE)
+      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
+    else()
+      if(NOT VERSION_OK)
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
+      else()
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
+      endif()
+    endif()
+
+  endif ()
+
+  set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
+  set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FindPackageMessage.cmake b/cmake/FindPackageMessage.cmake
new file mode 100644
index 00000000..a0349d3d
--- /dev/null
+++ b/cmake/FindPackageMessage.cmake
@@ -0,0 +1,57 @@
+#.rst:
+# FindPackageMessage
+# ------------------
+#
+#
+#
+# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
+#
+# This macro is intended to be used in FindXXX.cmake modules files.  It
+# will print a message once for each unique find result.  This is useful
+# for telling the user where a package was found.  The first argument
+# specifies the name (XXX) of the package.  The second argument
+# specifies the message to display.  The third argument lists details
+# about the find result so that if they change the message will be
+# displayed again.  The macro also obeys the QUIET argument to the
+# find_package command.
+#
+# Example:
+#
+# ::
+#
+#   if(X11_FOUND)
+#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
+#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
+#   else()
+#    ...
+#   endif()
+
+#=============================================================================
+# Copyright 2008-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+function(FIND_PACKAGE_MESSAGE pkg msg details)
+  # Avoid printing a message repeatedly for the same find result.
+  if(NOT ${pkg}_FIND_QUIETLY)
+    string(REPLACE "\n" "" details "${details}")
+    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
+    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
+      # The message has not yet been printed.
+      message(STATUS "${msg}")
+
+      # Save the find details in the cache to avoid printing the same
+      # message again.
+      set("${DETAILS_VAR}" "${details}"
+        CACHE INTERNAL "Details about finding ${pkg}")
+    endif()
+  endif()
+endfunction()
diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt
index 8433bfd2..91e6b75b 100644
--- a/demos/CMakeLists.txt
+++ b/demos/CMakeLists.txt
@@ -13,31 +13,39 @@ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 set (LIBRARIES "vulkan-${MAJOR}")
 
 if(WIN32)
+    # For Windows, since 32-bit and 64-bit items can co-exist, we build each in its own build directory.
+    # 32-bit target data goes in build32, and 64-bit target data goes into build64.  So, include/link the
+    # appropriate data at build time.
+    if (CMAKE_CL_64)
+        set (BUILDTGT_DIR build64)
+    else ()
+        set (BUILDTGT_DIR build32)
+    endif()
+
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/tri-vert.spv
-       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/tri.vert
+       COMMAND ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/tri.vert
        COMMAND move vert.spv ${CMAKE_BINARY_DIR}/demos/tri-vert.spv
-       DEPENDS tri.vert ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       DEPENDS tri.vert ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator
        )
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/tri-frag.spv
-       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/tri.frag
+       COMMAND ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/tri.frag
        COMMAND move frag.spv ${CMAKE_BINARY_DIR}/demos/tri-frag.spv
-       DEPENDS tri.frag ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       DEPENDS tri.frag ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator
        )
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.spv
-       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.vert
+       COMMAND ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.vert
        COMMAND move vert.spv ${CMAKE_BINARY_DIR}/demos/cube-vert.spv
-       DEPENDS cube.vert ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       DEPENDS cube.vert ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator
        )
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-frag.spv
-       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.frag
+       COMMAND ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.frag
        COMMAND move frag.spv ${CMAKE_BINARY_DIR}/demos/cube-frag.spv
-       DEPENDS cube.frag ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       DEPENDS cube.frag ${GLSLANG_PREFIX}/${BUILDTGT_DIR}/install/bin/glslangValidator
        )
    file(COPY cube.vcxproj.user DESTINATION ${CMAKE_BINARY_DIR}/demos)
    file(COPY tri.vcxproj.user DESTINATION ${CMAKE_BINARY_DIR}/demos)
    file(COPY vulkaninfo.vcxproj.user DESTINATION ${CMAKE_BINARY_DIR}/demos)
-endif()
-if(NOT WIN32)
+else()
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/tri-vert.spv
        COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V -o tri-vert.spv ${PROJECT_SOURCE_DIR}/demos/tri.vert 
        DEPENDS tri.vert ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
diff --git a/demos/cube.c b/demos/cube.c
index 5de15a6b..0a706a0c 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -255,7 +255,7 @@ void dumpVec4(const char *note, vec4 vector)
     fflush(stdout);
 }
 
-VkBool32 dbgFunc(
+VKAPI_ATTR VkBool32 VKAPI_CALL dbgFunc(
     VkFlags                             msgFlags,
     VkDebugReportObjectTypeEXT          objType,
     uint64_t                            srcObject,
@@ -686,7 +686,7 @@ static void demo_draw(struct demo *demo)
     err = demo->fpAcquireNextImageKHR(demo->device, demo->swapchain,
                                       UINT64_MAX,
                                       presentCompleteSemaphore,
-                                      NULL,// TODO: Show use of fence
+                                      (VkFence)0,// TODO: Show use of fence
                                       &demo->current_buffer);
     if (err == VK_ERROR_OUT_OF_DATE_KHR) {
         // demo->swapchain is out of date (e.g. the window was resized) and
diff --git a/demos/tri.c b/demos/tri.c
index 8773e54a..03921f1c 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -105,7 +105,7 @@ struct texture_object {
     int32_t tex_width, tex_height;
 };
 
-VkBool32 dbgFunc(
+VKAPI_ATTR VkBool32 VKAPI_CALL dbgFunc(
     VkFlags                             msgFlags,
     VkDebugReportObjectTypeEXT          objType,
     uint64_t                            srcObject,
@@ -486,7 +486,7 @@ static void demo_draw(struct demo *demo)
     err = demo->fpAcquireNextImageKHR(demo->device, demo->swapchain,
                                       UINT64_MAX,
                                       presentCompleteSemaphore,
-                                      NULL,// TODO: Show use of fence
+                                      (VkFence)0,// TODO: Show use of fence
                                       &demo->current_buffer);
     if (err == VK_ERROR_OUT_OF_DATE_KHR) {
         // demo->swapchain is out of date (e.g. the window was resized) and
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index 154e7d45..a8f3bd64 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -129,8 +129,8 @@ struct app_gpu {
     struct app_dev dev;
 };
 
-VkBool32 dbg_callback(
-    VkFlags                             msgFlags,
+static VKAPI_ATTR VkBool32 VKAPI_CALL dbg_callback(
+    VkDebugReportFlagsEXT               msgFlags,
     VkDebugReportObjectTypeEXT          objType,
     uint64_t                            srcObject,
     size_t                              location,
@@ -1091,7 +1091,7 @@ static void app_gpu_dump_memory_props(const struct app_gpu *gpu)
     printf("\tmemoryHeapCount       = %u\n",                props->memoryHeapCount);
     for (uint32_t i = 0; i < props->memoryHeapCount; i++) {
         printf("\tmemoryHeaps[%u] : \n", i);
-        printf("\t\tsize          = " PRINTF_SIZE_T_SPECIFIER "\n", props->memoryHeaps[i].size);
+        printf("\t\tsize          = " PRINTF_SIZE_T_SPECIFIER "\n", (size_t)props->memoryHeaps[i].size);
     }
     fflush(stdout);
 }
@@ -1248,7 +1248,7 @@ bool SetStdOutToNewConsole()
     return true;
 }
 
-int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int nCmdShow)
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int nCmdShow)
 {
     char *argv = pCmdLine;
     consoleCreated = SetStdOutToNewConsole();
diff --git a/determine_vs_version.py b/determine_vs_version.py
index 09f16d98..4c758b8d 100644
--- a/determine_vs_version.py
+++ b/determine_vs_version.py
@@ -75,7 +75,7 @@ if __name__ == '__main__':
 	# If not found, return an invalid number but in the appropriate format so it will
 	# fail if the program above tries to use it.
 	if foundExeName == None:
-		print('00 0000 Win32')
+		print('00 0000')
 		print('Executable ' + exeName + ' not found in PATH!')		
 	else:
 		sysCallOut = os.popen(versionCall).read()
@@ -115,13 +115,6 @@ if __name__ == '__main__':
 
 		# Determine the year associated with that version
 		year = determine_year(version)
-		
-		# TODO: Add detect to deteremine the OS target of current system.
-        #       Hard-code to Win64 for now since it's all we officially support.
-		#osTarget = 'Win32'
-		#if os.environ.get('PROCESSOR_ARCHITECTURE', '') == 'AMD64':
-		#	osTarget = 'Win64'
-		osTarget = 'Win64'
         
 		# Output the string we need for Cmake to properly build for this version
-		print(str(version) + ' ' + str(year) + ' ' + osTarget)
+		print(str(version) + ' ' + str(year))
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index d50fbaa0..11972f76 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2235,15 +2235,15 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript
         binding = pWDS[i].dstBinding;
         // Make sure that layout being updated has the binding being updated
         if (pLayout->bindings.find(binding) == pLayout->bindings.end()) {
-            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, reinterpret_cast<uint64_t>(ds), __LINE__, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
-                    "Descriptor Set %" PRIu64 " does not have binding to match update binding %u for update type %s!", reinterpret_cast<uint64_t>(ds), binding, string_VkStructureType(pUpdate->sType));
+            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+                    "Descriptor Set %" PRIu64 " does not have binding to match update binding %u for update type %s!", (uint64_t)(ds), binding, string_VkStructureType(pUpdate->sType));
         } else {
             // Next verify that update falls within size of given binding
             endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate);
             if (getBindingEndIndex(pLayout, binding) < endIndex) {
                 pLayoutCI = &pLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
-                skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t) ds, __LINE__, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+                skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
                         "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str());
             } else { // TODO : should we skip update on a type mismatch or force it?
                 uint32_t startIndex;
@@ -2257,7 +2257,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript
                         GENERIC_HEADER* pNewNode = NULL;
                         skipCall |= shadowUpdateNode(my_data, device, pUpdate, &pNewNode);
                         if (NULL == pNewNode) {
-                            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t) ds, __LINE__, DRAWSTATE_OUT_OF_MEMORY, "DS",
+                            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_OUT_OF_MEMORY, "DS",
                                     "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
                         } else {
                             // Insert shadow node into LL of updates for this set
@@ -2708,7 +2708,7 @@ static VkBool32 printDSConfig(layer_data* my_data, const VkCommandBuffer cb)
         LAYOUT_NODE* pLayout = pSet->pLayout;
         // Print layout details
         skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, 0, __LINE__, DRAWSTATE_NONE, "DS",
-                "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, reinterpret_cast<uint64_t>(pLayout->layout), reinterpret_cast<uint64_t>(pSet->set));
+                "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (uint64_t)(pLayout->layout), (uint64_t)(pSet->set));
         sprintf(prefix, "  [L%u] ", index);
         string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str();
         skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, 0, __LINE__, DRAWSTATE_NONE, "DS",
@@ -3076,7 +3076,7 @@ VkBool32 ValidateCmdBufImageLayouts(VkCommandBuffer cmdBuffer) {
         auto image_data = dev_data->imageLayoutMap.find(cb_image_data.first);
         if (image_data == dev_data->imageLayoutMap.end()) {
             skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
-                                 "Cannot submit cmd buffer using deleted image %" PRIu64 ".", reinterpret_cast<uint64_t>(cb_image_data.first));
+                                 "Cannot submit cmd buffer using deleted image %" PRIu64 ".", (uint64_t)(cb_image_data.first));
         } else {
             if (dev_data->imageLayoutMap[cb_image_data.first]->layout != cb_image_data.second.initialLayout) {
                 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
@@ -3112,8 +3112,8 @@ VkBool32 validateAndIncrementResources(layer_data* my_data, GLOBAL_CB_NODE* pCB)
         for (auto buffer : drawDataElement.buffers) {
             auto buffer_data = my_data->bufferMap.find(buffer);
             if (buffer_data == my_data->bufferMap.end()) {
-                skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast<uint64_t>(buffer), __LINE__, DRAWSTATE_INVALID_BUFFER, "DS",
-                                     "Cannot submit cmd buffer using deleted buffer %" PRIu64 ".", reinterpret_cast<uint64_t>(buffer));
+                skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_INVALID_BUFFER, "DS",
+                                     "Cannot submit cmd buffer using deleted buffer %" PRIu64 ".", (uint64_t)(buffer));
             } else {
                 buffer_data->second.in_use.fetch_add(1);
             }
@@ -3225,7 +3225,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint
             } else {
                 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS",
                         "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.",
-                        reinterpret_cast<uint64_t>(queue), reinterpret_cast<uint64_t>(submit->pWaitSemaphores[i]));
+                        reinterpret_cast<uint64_t>(queue), (uint64_t)(submit->pWaitSemaphores[i]));
             }
         }
         for (uint32_t i=0; i < submit->signalSemaphoreCount; ++i) {
@@ -3284,7 +3284,7 @@ VkBool32 cleanInFlightCmdBuffer(layer_data* my_data, VkCommandBuffer cmdBuffer)
             if (my_data->eventMap[event].needsSignaled) {
                 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, 0, DRAWSTATE_INVALID_QUERY, "DS",
                                  "Cannot get query results on queryPool %" PRIu64 " with index %d which was guarded by unsignaled event %" PRIu64 ".",
-                                 reinterpret_cast<uint64_t>(queryEventsPair.first.pool), queryEventsPair.first.index, reinterpret_cast<uint64_t>(event));
+                                 (uint64_t)(queryEventsPair.first.pool), queryEventsPair.first.index, (uint64_t)(event));
             }
         }
     }
@@ -3436,7 +3436,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPoo
                 if (queryEventElement == pCB->waitedEventsBeforeQueryReset.end()) {
                     skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__,
                                          DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which is in flight.",
-                                         reinterpret_cast<uint64_t>(queryPool), firstQuery + i);
+                                         (uint64_t)(queryPool), firstQuery + i);
                 } else {
                     for (auto event : queryEventElement->second) {
                         dev_data->eventMap[event].needsSignaled = true;
@@ -3454,18 +3454,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPoo
             if (!(((flags & VK_QUERY_RESULT_PARTIAL_BIT) || (flags & VK_QUERY_RESULT_WAIT_BIT)) && make_available)) {
                 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS",
                                      "Cannot get query results on queryPool %" PRIu64 " with index %d which is unavailable.",
-                                     reinterpret_cast<uint64_t>(queryPool), firstQuery + i);
+                                     (uint64_t)(queryPool), firstQuery + i);
             }
         // Unavailable
         } else if (queryToStateElement != dev_data->queryToStateMap.end() && !queryToStateElement->second) {
             skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS",
                                  "Cannot get query results on queryPool %" PRIu64 " with index %d which is unavailable.",
-                                 reinterpret_cast<uint64_t>(queryPool), firstQuery + i);
+                                 (uint64_t)(queryPool), firstQuery + i);
         // Unitialized
         } else if (queryToStateElement == dev_data->queryToStateMap.end()) {
             skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS",
                                  "Cannot get query results on queryPool %" PRIu64 " with index %d which is uninitialized.",
-                                 reinterpret_cast<uint64_t>(queryPool), firstQuery + i);
+                                 (uint64_t)(queryPool), firstQuery + i);
         }
     }
     if (skip_call)
@@ -3477,12 +3477,12 @@ VkBool32 validateIdleBuffer(const layer_data* my_data, VkBuffer buffer) {
     VkBool32 skip_call = VK_FALSE;
     auto buffer_data = my_data->bufferMap.find(buffer);
     if (buffer_data == my_data->bufferMap.end()) {
-        skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast<uint64_t>(buffer), __LINE__, DRAWSTATE_DOUBLE_DESTROY, "DS",
-                             "Cannot free buffer %" PRIxLEAST64 " that has not been allocated.", reinterpret_cast<uint64_t>(buffer));
+        skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_DOUBLE_DESTROY, "DS",
+                             "Cannot free buffer %" PRIxLEAST64 " that has not been allocated.", (uint64_t)(buffer));
     } else {
         if (buffer_data->second.in_use.load()) {
-            skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast<uint64_t>(buffer), __LINE__, DRAWSTATE_OBJECT_INUSE, "DS",
-                                 "Cannot free buffer %" PRIxLEAST64 " that is in use by a command buffer.", reinterpret_cast<uint64_t>(buffer));
+            skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_OBJECT_INUSE, "DS",
+                                 "Cannot free buffer %" PRIxLEAST64 " that is in use by a command buffer.", (uint64_t)(buffer));
         }
     }
     return skip_call;
@@ -4238,7 +4238,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer com
         } else {
             skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
                                 (uint64_t) pipeline, __LINE__, DRAWSTATE_INVALID_PIPELINE, "DS",
-                                "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(pipeline));
+                                "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (uint64_t)(pipeline));
         }
     }
     if (VK_FALSE == skipCall)
@@ -5310,7 +5310,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBu
             QueryObject query = {queryPool, firstQuery + i};
             if(!pCB->queryToStateMap[query]) {
                 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS",
-                                    "Requesting a copy from query to buffer with invalid query: queryPool %" PRIu64 ", index %d", reinterpret_cast<uint64_t>(queryPool), firstQuery + i);
+                                    "Requesting a copy from query to buffer with invalid query: queryPool %" PRIu64 ", index %d", (uint64_t)(queryPool), firstQuery + i);
             }
         }
         if (pCB->state == CB_RECORDING) {
@@ -6026,7 +6026,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
             } else {
                 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS",
                         "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.",
-                        reinterpret_cast<uint64_t>(queue), reinterpret_cast<uint64_t>(bindInfo.pWaitSemaphores[i]));
+                        reinterpret_cast<uint64_t>(queue), (uint64_t)(bindInfo.pWaitSemaphores[i]));
             }
         }
         for (uint32_t i=0; i < bindInfo.signalSemaphoreCount; ++i) {
diff --git a/layers/draw_state.h b/layers/draw_state.h
index dca0d8b5..903f678d 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -469,7 +469,7 @@ namespace std {
 template <>
 struct hash<QueryObject> {
     size_t operator()(QueryObject query) const throw() {
-        return hash<uint64_t>()(reinterpret_cast<uint64_t>(query.pool)) ^ hash<uint32_t>()(query.index);
+        return hash<uint64_t>()((uint64_t)(query.pool)) ^ hash<uint32_t>()(query.index);
     }
 };
 }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index a29a6a4d..6bc775ea 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -469,19 +469,19 @@ add_mem_obj_info(
 
 static VkBool32 validate_memory_is_valid(layer_data *my_data, VkDeviceMemory mem, const char* functionName, VkImage image = VK_NULL_HANDLE) {
     if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
-        MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
+        MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
         if (pBindInfo && !pBindInfo->valid) {
             return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
-                reinterpret_cast<uint64_t>(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM",
-                "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.", functionName, reinterpret_cast<uint64_t>(image));
+                (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM",
+                "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(image));
         }
     }
     else {
         MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem);
         if (pMemObj && !pMemObj->valid) {
             return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
-                reinterpret_cast<uint64_t>(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM",
-                "%s: Cannot read invalid memory %" PRIx64 ", please fill the memory before using.", functionName, reinterpret_cast<uint64_t>(mem));
+                (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM",
+                "%s: Cannot read invalid memory %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(mem));
         }
     }
     return false;
@@ -489,7 +489,7 @@ static VkBool32 validate_memory_is_valid(layer_data *my_data, VkDeviceMemory mem
 
 static void set_memory_valid(layer_data *my_data, VkDeviceMemory mem, bool valid, VkImage image = VK_NULL_HANDLE) {
     if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
-        MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
+        MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
         if (pBindInfo) {
             pBindInfo->valid = valid;
         }
@@ -967,7 +967,7 @@ print_mem_list(
         log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM",
             "    ===MemObjInfo at %p===", (void*)pInfo);
         log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM",
-                "    Mem object: %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pInfo->mem));
+                "    Mem object: %#" PRIxLEAST64, (uint64_t)(pInfo->mem));
         log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM",
                 "    Ref Count: %u", pInfo->refCount);
         if (0 != pInfo->allocInfo.allocationSize) {
@@ -1032,7 +1032,7 @@ printCBList(
             continue;
         for (list<VkDeviceMemory>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
             log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM",
-                    "      Mem obj %" PRIu64, reinterpret_cast<uint64_t>(*it));
+                    "      Mem obj %" PRIu64, (uint64_t)(*it));
         }
     }
 }
@@ -1233,7 +1233,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
                 // Valid Usage: All child objects created on device must have been destroyed prior to destroying device
                 skipCall |= log_msg(my_device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) pInfo->mem, __LINE__, MEMTRACK_MEMORY_LEAK, "MEM",
                                  "Mem Object %" PRIu64 " has not been freed. You should clean up this memory by calling "
-                                 "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", reinterpret_cast<uint64_t>(pInfo->mem), reinterpret_cast<uint64_t>(pInfo->mem));
+                                 "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", (uint64_t)(pInfo->mem), (uint64_t)(pInfo->mem));
             }
         }
     }
@@ -1552,9 +1552,10 @@ initializeAndTrackMemory(
             if (size == VK_WHOLE_SIZE) {
                 size = mem_element->second.allocInfo.allocationSize;
             }
-            mem_element->second.pData = malloc(2 * size);
-            memset(mem_element->second.pData, NoncoherentMemoryFillValue, 2 * size);
-            *ppData = static_cast<char*>(mem_element->second.pData) + (size / 2);
+            size_t convSize = (size_t)(size);
+            mem_element->second.pData = malloc(2 * convSize);
+            memset(mem_element->second.pData, NoncoherentMemoryFillValue, 2 * convSize);
+            *ppData = static_cast<char*>(mem_element->second.pData) + (convSize / 2);
         }
     }
 }
@@ -1652,14 +1653,14 @@ validateAndCopyNoncoherentMemoryToDriver(
                                             __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory);
                     }
                 }
-                memcpy(mem_element->second.pDriverData, static_cast<void*>(data + half_size), size);
+                memcpy(mem_element->second.pDriverData, static_cast<void*>(data + (size_t)(half_size)), (size_t)(size));
             }
         }
     }
     return skipCall;
 }
 
-VK_LAYER_EXPORT VkResult vkFlushMappedMemoryRanges(
+VK_LAYER_EXPORT VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
     VkDevice                   device,
     uint32_t                   memRangeCount,
     const VkMappedMemoryRange *pMemRanges)
@@ -1676,7 +1677,7 @@ VK_LAYER_EXPORT VkResult vkFlushMappedMemoryRanges(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult vkInvalidateMappedMemoryRanges(
+VK_LAYER_EXPORT VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
     VkDevice                   device,
     uint32_t                   memRangeCount,
     const VkMappedMemoryRange *pMemRanges)
@@ -1797,7 +1798,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    uint64_t buffer_handle = reinterpret_cast<uint64_t>(buffer);
+    uint64_t buffer_handle = (uint64_t)(buffer);
     VkBool32 skipCall = set_mem_binding(my_data, device, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
     add_object_binding_info(my_data, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, mem);
     {
@@ -1823,7 +1824,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    uint64_t image_handle = reinterpret_cast<uint64_t>(image);
+    uint64_t image_handle = (uint64_t)(image);
     VkBool32 skipCall = set_mem_binding(my_data, device, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
     add_object_binding_info(my_data, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, mem);
     {
@@ -2210,7 +2211,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
         if (VK_FALSE == commandBufferComplete) {
             skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(*it), __LINE__,
                                 MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Destroying Command Pool 0x%" PRIxLEAST64 " before "
-                                "its command buffer (0x%" PRIxLEAST64 ") has completed.", reinterpret_cast<uint64_t>(commandPool),
+                                "its command buffer (0x%" PRIxLEAST64 ") has completed.", (uint64_t)(commandPool),
                                 reinterpret_cast<uint64_t>(*it));
         }
     }
@@ -2378,7 +2379,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
     VkBool32 skip_call = false;
     for (uint32_t i = 0; i < bindingCount; ++i) {
         VkDeviceMemory mem;
-        skip_call |= get_mem_binding_from_object(my_data, commandBuffer, reinterpret_cast<uint64_t>(pBuffers[i]),
+        skip_call |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(pBuffers[i]),
             VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
         auto cb_data = my_data->cbMap.find(commandBuffer);
         if (cb_data != my_data->cbMap.end()) {
@@ -2399,7 +2400,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
-    VkBool32 skip_call = get_mem_binding_from_object(my_data, commandBuffer, reinterpret_cast<uint64_t>(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
+    VkBool32 skip_call = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
     auto cb_data = my_data->cbMap.find(commandBuffer);
     if (cb_data != my_data->cbMap.end()) {
         std::function<VkBool32()> function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdBindIndexBuffer()"); };
@@ -2953,7 +2954,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
             if (mismatch) {
                 // TODO: Verify against Valid Usage section of extension
                 log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, (uint64_t) swapchain, __LINE__, MEMTRACK_NONE, "SWAP_CHAIN",
-                        "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", reinterpret_cast<uint64_t>(swapchain));
+                        "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", (uint64_t)(swapchain));
             }
         }
     }
@@ -3000,7 +3001,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
     for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) {
         MT_SWAP_CHAIN_INFO *pInfo = my_data->swapchainMap[pPresentInfo->pSwapchains[i]];
         VkImage image = pInfo->images[pPresentInfo->pImageIndices[i]];
-        skip_call |= get_mem_binding_from_object(my_data, queue, reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
+        skip_call |= get_mem_binding_from_object(my_data, queue, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
         skip_call |= validate_memory_is_valid(my_data, mem, "vkQueuePresentKHR()", image);
     }
     if (!skip_call) {
@@ -3067,7 +3068,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
             continue;
         }
         MT_FB_ATTACHMENT_INFO fb_info;
-        get_mem_binding_from_object(my_data, device, reinterpret_cast<uint64_t>(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &fb_info.mem);
+        get_mem_binding_from_object(my_data, device, (uint64_t)(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &fb_info.mem);
         fb_info.image = view_data->second.image;
         my_data->fbMap[*pFramebuffer].attachments.push_back(fb_info);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -3154,7 +3155,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
             MT_PASS_INFO& pass_info = pass_data->second;
             pass_info.fb = pRenderPassBegin->framebuffer;
             auto cb_data = my_data->cbMap.find(cmdBuffer);
-            for (int i = 0; i < pass_info.attachments.size(); ++i) {
+            for (size_t i = 0; i < pass_info.attachments.size(); ++i) {
                 MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i];
                 if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) {
                     if (cb_data != my_data->cbMap.end()) {
@@ -3165,7 +3166,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
                     if (attachment_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL ||
                         attachment_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
                         skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                                             reinterpret_cast<uint64_t>(pRenderPassBegin->renderPass), __LINE__, MEMTRACK_INVALID_LAYOUT, "MEM",
+                                             (uint64_t)(pRenderPassBegin->renderPass), __LINE__, MEMTRACK_INVALID_LAYOUT, "MEM",
                                              "Cannot clear attachment %d with invalid first layout %d.", pass_info.attachments[i].attachment, attachment_layout);
                     }
                 } else if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_DONT_CARE) {
@@ -3205,7 +3206,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
         auto pass_data = my_data->passMap.find(cb_data->second.pass);
         if (pass_data != my_data->passMap.end()) {
             MT_PASS_INFO& pass_info = pass_data->second;
-            for (int i = 0; i < pass_info.attachments.size(); ++i) {
+            for (size_t i = 0; i < pass_info.attachments.size(); ++i) {
                 MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i];
                 if (pass_info.attachments[i].store_op == VK_ATTACHMENT_STORE_OP_STORE) {
                     if (cb_data != my_data->cbMap.end()) {
diff --git a/layers/object_tracker.h b/layers/object_tracker.h
index b1b550da..caa6573b 100644
--- a/layers/object_tracker.h
+++ b/layers/object_tracker.h
@@ -390,7 +390,7 @@ validate_status(
             char str[1024];
             log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, vkObj, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
                 "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkObjectType(objType),
-                 reinterpret_cast<uint64_t>(vkObj), fail_msg);
+                static_cast<uint64_t>(vkObj), fail_msg);
             return VK_FALSE;
         }
         return VK_TRUE;
@@ -399,7 +399,7 @@ validate_status(
         // If we do not find it print an error
         log_msg(mdd(dispatchable_object), msg_flags, (VkObjectType) 0, vkObj, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
             "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",
-            reinterpret_cast<uint64_t>(vkObj), string_VkObjectType(objType));
+            static_cast<uint64_t>(vkObj), string_VkObjectType(objType));
         return VK_FALSE;
     }
 }
@@ -488,15 +488,15 @@ static VkBool32 set_status(VkQueue dispatchable_object, VkFence object, VkDebugR
 {
     VkBool32 skipCall = VK_FALSE;
     if (object != VK_NULL_HANDLE) {
-        if (VkFenceMap.find(reinterpret_cast<uint64_t>(object)) != VkFenceMap.end()) {
-            OBJTRACK_NODE* pNode = VkFenceMap[reinterpret_cast<uint64_t>(object)];
+        if (VkFenceMap.find((uint64_t)(object)) != VkFenceMap.end()) {
+            OBJTRACK_NODE* pNode = VkFenceMap[(uint64_t)(object)];
             pNode->status |= status_flag;
         }
         else {
             // If we do not find it print an error
             skipCall |= log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, (uint64_t) object, __LINE__, OBJTRACK_NONE, "OBJTRACK",
                 "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
-                reinterpret_cast<uint64_t>(object), string_VkDebugReportObjectTypeEXT(objType));
+                (uint64_t)(object), string_VkDebugReportObjectTypeEXT(objType));
         }
     }
     return skipCall;
@@ -521,14 +521,14 @@ static void create_physical_device(VkInstance dispatchable_object, VkPhysicalDev
 static void create_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR vkObj, VkDebugReportObjectTypeEXT objType)
 {
     // TODO: Add tracking of surface objects
-    log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, reinterpret_cast<uint64_t>(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",
+    log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, (uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType),
-        reinterpret_cast<uint64_t>(vkObj));
+        (uint64_t)(vkObj));
 
     OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
     pNewObjNode->objType = objType;
     pNewObjNode->status  = OBJSTATUS_NONE;
-    pNewObjNode->vkObj   = reinterpret_cast<uint64_t>(vkObj);
+    pNewObjNode->vkObj   = (uint64_t)(vkObj);
     VkSurfaceKHRMap[(uint64_t)vkObj] = pNewObjNode;
     uint32_t objIndex = objTypeToIndex(objType);
     numObjs[objIndex]++;
@@ -537,7 +537,7 @@ static void create_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR vkOb
 
 static void destroy_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR object)
 {
-    uint64_t object_handle = reinterpret_cast<uint64_t>(object);
+    uint64_t object_handle = (uint64_t)(object);
     if (VkSurfaceKHRMap.find(object_handle) != VkSurfaceKHRMap.end()) {
         OBJTRACK_NODE* pNode = VkSurfaceKHRMap[(uint64_t)object];
         uint32_t objIndex = objTypeToIndex(pNode->objType);
@@ -547,7 +547,7 @@ static void destroy_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR obj
         numObjs[objIndex]--;
         log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK",
            "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",
-            string_VkDebugReportObjectTypeEXT(pNode->objType), reinterpret_cast<uint64_t>(object), numTotalObjs, numObjs[objIndex],
+            string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex],
             string_VkDebugReportObjectTypeEXT(pNode->objType));
         delete pNode;
         VkSurfaceKHRMap.erase(object_handle);
@@ -585,10 +585,10 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo
     if (VkCommandBufferMap.find(object_handle) != VkCommandBufferMap.end()) {
         OBJTRACK_NODE* pNode = VkCommandBufferMap[(uint64_t)commandBuffer];
 
-       if (pNode->parentObj != reinterpret_cast<uint64_t>(commandPool)) {
+       if (pNode->parentObj != (uint64_t)(commandPool)) {
            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_COMMAND_POOL_MISMATCH, "OBJTRACK",
                "FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64 " belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
-               reinterpret_cast<uint64_t>(commandBuffer), pNode->parentObj, reinterpret_cast<uint64_t>(commandPool));
+               reinterpret_cast<uint64_t>(commandBuffer), pNode->parentObj, (uint64_t)(commandPool));
        } else {
 
             uint32_t objIndex = objTypeToIndex(pNode->objType);
@@ -612,14 +612,14 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo
 
 static void alloc_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSet vkObj, VkDebugReportObjectTypeEXT objType)
 {
-    log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, reinterpret_cast<uint64_t>(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",
+    log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, (uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType),
-        reinterpret_cast<uint64_t>(vkObj));
+        (uint64_t)(vkObj));
 
     OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
     pNewObjNode->objType   = objType;
     pNewObjNode->status    = OBJSTATUS_NONE;
-    pNewObjNode->vkObj     = reinterpret_cast<uint64_t>(vkObj);
+    pNewObjNode->vkObj     = (uint64_t)(vkObj);
     pNewObjNode->parentObj = (uint64_t) descriptorPool;
     VkDescriptorSetMap[(uint64_t)vkObj] = pNewObjNode;
     uint32_t objIndex = objTypeToIndex(objType);
@@ -629,14 +629,14 @@ static void alloc_descriptor_set(VkDevice device, VkDescriptorPool descriptorPoo
 
 static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSet descriptorSet)
 {
-    uint64_t object_handle = reinterpret_cast<uint64_t>(descriptorSet);
+    uint64_t object_handle = (uint64_t)(descriptorSet);
     if (VkDescriptorSetMap.find(object_handle) != VkDescriptorSetMap.end()) {
         OBJTRACK_NODE* pNode = VkDescriptorSetMap[(uint64_t)descriptorSet];
 
-        if (pNode->parentObj != reinterpret_cast<uint64_t>(descriptorPool)) {
+        if (pNode->parentObj != (uint64_t)(descriptorPool)) {
             log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_DESCRIPTOR_POOL_MISMATCH, "OBJTRACK",
                 "FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64 " belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
-                reinterpret_cast<uint64_t>(descriptorSet), pNode->parentObj, reinterpret_cast<uint64_t>(descriptorPool));
+                (uint64_t)(descriptorSet), pNode->parentObj, (uint64_t)(descriptorPool));
         } else {
             uint32_t objIndex = objTypeToIndex(pNode->objType);
             assert(numTotalObjs > 0);
@@ -645,7 +645,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool
             numObjs[objIndex]--;
             log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK",
                "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",
-                string_VkDebugReportObjectTypeEXT(pNode->objType), reinterpret_cast<uint64_t>(descriptorSet), numTotalObjs, numObjs[objIndex],
+                string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(descriptorSet), numTotalObjs, numObjs[objIndex],
                 string_VkDebugReportObjectTypeEXT(pNode->objType));
             delete pNode;
             VkDescriptorSetMap.erase(object_handle);
@@ -676,14 +676,14 @@ static void create_swapchain_image_obj(VkDevice dispatchable_object, VkImage vkO
 {
     log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t) vkObj, __LINE__, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, "SwapchainImage",
-        reinterpret_cast<uint64_t>(vkObj));
+        (uint64_t)(vkObj));
 
     OBJTRACK_NODE* pNewObjNode             = new OBJTRACK_NODE;
     pNewObjNode->objType                   = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT;
     pNewObjNode->status                    = OBJSTATUS_NONE;
     pNewObjNode->vkObj                     = (uint64_t) vkObj;
     pNewObjNode->parentObj                 = (uint64_t) swapchain;
-    swapchainImageMap[reinterpret_cast<uint64_t>(vkObj)] = pNewObjNode;
+    swapchainImageMap[(uint64_t)(vkObj)] = pNewObjNode;
 }
 
 //
@@ -984,7 +984,7 @@ explicit_DestroySwapchainKHR(
     unordered_map<uint64_t, OBJTRACK_NODE*>::iterator itr = swapchainImageMap.begin();
     while (itr != swapchainImageMap.end()) {
         OBJTRACK_NODE* pNode = (*itr).second;
-        if (pNode->parentObj == reinterpret_cast<uint64_t>(swapchain)) {
+        if (pNode->parentObj == (uint64_t)(swapchain)) {
            swapchainImageMap.erase(itr++);
         } else {
            ++itr;
@@ -1056,8 +1056,8 @@ explicit_DestroyDescriptorPool(
     while (itr != VkDescriptorSetMap.end()) {
         OBJTRACK_NODE* pNode = (*itr).second;
         auto del_itr = itr++;
-        if (pNode->parentObj == reinterpret_cast<uint64_t>(descriptorPool)) {
-            destroy_descriptor_set(device, reinterpret_cast<VkDescriptorSet>((*del_itr).first));
+        if (pNode->parentObj == (uint64_t)(descriptorPool)) {
+            destroy_descriptor_set(device, (VkDescriptorSet)((*del_itr).first));
         }
     }
     destroy_descriptor_pool(device, descriptorPool);
@@ -1087,7 +1087,7 @@ explicit_DestroyCommandPool(
     while (itr != VkCommandBufferMap.end()) {
         OBJTRACK_NODE* pNode = (*itr).second;
         del_itr = itr++;
-        if (pNode->parentObj == reinterpret_cast<uint64_t>(commandPool)) {
+        if (pNode->parentObj == (uint64_t)(commandPool)) {
             destroy_command_buffer(reinterpret_cast<VkCommandBuffer>((*del_itr).first),
                                    reinterpret_cast<VkCommandBuffer>((*del_itr).first));
         }
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index cc192b87..107c7dee 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -141,7 +141,7 @@ static void writePPM( const char *filename, VkImage image1)
     VkImage image2;
     VkResult err;
     bool pass;
-    int x, y;
+    uint32_t x, y;
     const char *ptr;
     VkDeviceMemory mem2;
     VkCommandBuffer commandBuffer;
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index e199472d..5c7fdf17 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -336,7 +336,7 @@ static inline VKAPI_ATTR VkBool32 VKAPI_CALL win32_debug_output_msg(
 
     print_msg_flags(msgFlags, msg_flags);
     _snprintf(buf, sizeof(buf) - 1, "%s (%s): object: 0x%" PRIxPTR " type: %d location: " PRINTF_SIZE_T_SPECIFIER " msgCode: %d: %s\n",
-             pLayerPrefix, msg_flags, srcObject, objType, location, msgCode, pMsg);
+             pLayerPrefix, msg_flags, (size_t)srcObject, objType, location, msgCode, pMsg);
 
     OutputDebugString(buf);
 #endif
diff --git a/loader/debug_report.c b/loader/debug_report.c
index 9a581688..4345b4ec 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -259,7 +259,7 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDebugReportCallback(
  * This is the instance chain terminator function
  * for DestroyDebugReportCallback
  */
-VKAPI_ATTR void loader_DestroyDebugReportCallback(VkInstance instance,
+VKAPI_ATTR void VKAPI_CALL loader_DestroyDebugReportCallback(VkInstance instance,
         VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
 {
     uint32_t storage_idx;
diff --git a/loader/loader.c b/loader/loader.c
index 0ffc5102..83f1f5a5 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -276,15 +276,9 @@ static char *loader_get_registry_files(const struct loader_instance *inst, char
         access_flags = KEY_QUERY_VALUE;
         rtn_value = RegOpenKeyEx(hive, loc, 0, access_flags, &key);
         if (rtn_value != ERROR_SUCCESS) {
-            // We didn't find the key.  Try the 32-bit hive (where we've seen the
-            // key end up on some people's systems):
-            access_flags |= KEY_WOW64_32KEY;
-            rtn_value = RegOpenKeyEx(hive, loc, 0, access_flags, &key);
-            if (rtn_value != ERROR_SUCCESS) {
-                // We still couldn't find the key, so give up:
-                loc = next;
-                continue;
-            }
+            // We still couldn't find the key, so give up:
+            loc = next;
+            continue;
         }
 
         while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE) &value, &value_size)) == ERROR_SUCCESS) {
@@ -1570,7 +1564,7 @@ static cJSON *loader_get_json(const struct loader_instance *inst, const char *fi
     FILE *file;
     char *json_buf;
     cJSON *json;
-    uint64_t len;
+    size_t len;
     file = fopen(filename,"rb");
     if (!file) {
         loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Couldn't open JSON file %s", filename);
diff --git a/loader/wsi.c b/loader/wsi.c
index 584e3e69..d482d54f 100644
--- a/loader/wsi.c
+++ b/loader/wsi.c
@@ -203,7 +203,7 @@ VKAPI_ATTR void VKAPI_CALL loader_DestroySurfaceKHR(
 {
     struct loader_instance *ptr_instance = loader_get_instance(instance);
 
-    loader_heap_free(ptr_instance, surface);
+    loader_heap_free(ptr_instance, (void *)surface);
 }
 
 /*
diff --git a/update_external_sources.bat b/update_external_sources.bat
index 9d528681..55e7cc61 100755
--- a/update_external_sources.bat
+++ b/update_external_sources.bat
@@ -24,6 +24,13 @@ echo Detected MSBuild target as %MSBUILD_MACHINE_TARGET%
 REM Cleanup the file we used to collect the VS version output since it's no longer needed.

 del /Q /F vsversion.tmp

 

+REM Determine if SVN exists, this is a requirement for LunarGLASS

+set SVN_EXE_FOUND=0

+for %%X in (svn.exe) do (set FOUND=%%~$PATH:X)

+if defined FOUND (

+ set SVN_EXE_FOUND=1

+)

+

 setlocal EnableDelayedExpansion

 set errorCode=0

 set BUILD_DIR=%~dp0

@@ -109,14 +116,18 @@ REM // ======== Parameter parsing ======== //
 

       if "%1" == "--all" (

          set sync-glslang=1

-         set sync-LunarGLASS=1

          set sync-spirv-tools=1

          set build-glslang=1

-         set build-LunarGLASS=1

          set build-spirv-tools=1

-         set check-LunarGLASS-fetch-dependencies=1

          set check-glslang-build-dependencies=1

-         set check-LunarGLASS-build-dependencies=1

+         

+         REM Only attempt to build LunarGLASS if we find SVN

+         if %SVN_EXE_FOUND% equ 1 (

+             set sync-LunarGLASS=1

+             set build-LunarGLASS=1

+             set check-LunarGLASS-fetch-dependencies=1

+             set check-LunarGLASS-build-dependencies=1

+         )

          shift

          goto:parameterLoop

       )

@@ -141,8 +152,7 @@ REM // ======== Dependency checking ======== //
    )

 

    if %check-LunarGLASS-fetch-dependencies% equ 1 (

-      for %%X in (svn.exe) do (set FOUND=%%~$PATH:X)

-      if not defined FOUND (

+      if %SVN_EXE_FOUND% equ 0 (

          echo Dependency check failed:

          echo   svn.exe not found

          echo   Get Subversion for Windows here:  http://sourceforge.net/projects/win32svn/

@@ -422,25 +432,66 @@ goto:eof
    echo.

    echo Building %GLSLANG_DIR%

    cd  %GLSLANG_DIR%

-   mkdir build

-   set GLSLANG_BUILD_DIR=%GLSLANG_DIR%\build

+

+   REM Cleanup any old directories lying around.

+   rmdir /s /q build32

+   rmdir /s /q build64

+   

+   echo Making 32-bit glslang

+   echo *************************

+   mkdir build32

+   set GLSLANG_BUILD_DIR=%GLSLANG_DIR%\build32

+   cd %GLSLANG_BUILD_DIR%

+

+   echo Generating 32-bit Glslang CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 32-bit Glslang: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %GLSLANG_BUILD_DIR%\glslang\Debug\glslang.lib (

+      echo.

+      echo glslang 32-bit Debug build failed!

+      set errorCode=1

+   )

+   echo Building Glslang: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

+   

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %GLSLANG_BUILD_DIR%\glslang\Release\glslang.lib (

+      echo.

+      echo glslang 32-bit Release build failed!

+      set errorCode=1

+   )

+   

+   cd ..

+ 

+   echo Making 64-bit glslang

+   echo *************************

+   mkdir build64

+   set GLSLANG_BUILD_DIR=%GLSLANG_DIR%\build64

    cd %GLSLANG_BUILD_DIR%

-   echo Generating Glslang CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

-   cmake -G"Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

-   echo Building Glslang: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

-   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

+

+   echo Generating 64-bit Glslang CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION% Win64" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 64-bit Glslang: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   

    REM Check for existence of one lib, even though we should check for all results

    if not exist %GLSLANG_BUILD_DIR%\glslang\Debug\glslang.lib (

       echo.

-      echo glslang Debug build failed!

+      echo glslang 64-bit Debug build failed!

       set errorCode=1

    )

-   echo Building Glslang: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

-   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

+   echo Building Glslang: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   

    REM Check for existence of one lib, even though we should check for all results

    if not exist %GLSLANG_BUILD_DIR%\glslang\Release\glslang.lib (

       echo.

-      echo glslang Release build failed!

+      echo glslang 64-bit Release build failed!

       set errorCode=1

    )

 goto:eof

@@ -450,56 +501,145 @@ goto:eof
    echo Building %LUNARGLASS_DIR%

    set LLVM_DIR=%LUNARGLASS_DIR%\Core\LLVM\llvm-3.4

    cd %LLVM_DIR%

-   mkdir build

-   set LLVM_BUILD_DIR=%LLVM_DIR%\build

+

+   REM Cleanup any old directories lying around.

+   rmdir /s /q build32

+   rmdir /s /q build64

+   

+   echo Making 32-bit LLVM

+   echo *************************

+   mkdir build32

+   set LLVM_BUILD_DIR=%LLVM_DIR%\build32

    cd %LLVM_BUILD_DIR%

-   echo Generating LLVM CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

-   cmake -G"Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

-   echo Building LLVM: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

-   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

+

+   echo Generating 32-bit LLVM CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 32-bit LLVM: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

    REM Check for existence of one lib, even though we should check for all results

    if not exist %LLVM_BUILD_DIR%\lib\Release\LLVMCore.lib (

       echo.

-      echo LLVM Release build failed!

+      echo LLVM 32-bit Release build failed!

       set errorCode=1

       goto:eof

    )

    REM disable Debug build of LLVM until LunarGLASS cmake files are updated to

    REM handle Debug and Release builds of glslang simultaneously, instead of

-   REM whatever last lands in "./build/install"

-   REM   echo Building LLVM: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

-   REM   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

+   REM whatever last lands in "./build32/install"

+   REM   echo Building 32-bit LLVM: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   REM   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   REM Check for existence of one lib, even though we should check for all results

+   REM   if not exist %LLVM_BUILD_DIR%\lib\Debug\LLVMCore.lib (

+   REM      echo.

+   REM      echo LLVM 32-bit Debug build failed!

+   REM      set errorCode=1

+   REM      goto:eof

+   REM   )

+   

+   cd ..

+ 

+   echo Making 64-bit LLVM

+   echo *************************

+   mkdir build64

+   set LLVM_BUILD_DIR=%LLVM_DIR%\build64

+   cd %LLVM_BUILD_DIR%

+

+   echo Generating 64-bit LLVM CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION% Win64" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 64-bit LLVM: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %LLVM_BUILD_DIR%\lib\Release\LLVMCore.lib (

+      echo.

+      echo LLVM 64-bit Release build failed!

+      set errorCode=1

+      goto:eof

+   )

+   REM disable Debug build of LLVM until LunarGLASS cmake files are updated to

+   REM handle Debug and Release builds of glslang simultaneously, instead of

+   REM whatever last lands in "./build32/install"

+   REM   echo Building 64-bit LLVM: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   REM   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

    REM Check for existence of one lib, even though we should check for all results

    REM   if not exist %LLVM_BUILD_DIR%\lib\Debug\LLVMCore.lib (

    REM      echo.

-   REM      echo LLVM Debug build failed!

+   REM      echo LLVM 64-bit Debug build failed!

    REM      set errorCode=1

    REM      goto:eof

    REM   )

+

    cd %LUNARGLASS_DIR%

-   mkdir build

-   set LUNARGLASS_BUILD_DIR=%LUNARGLASS_DIR%\build

+

+   REM Cleanup any old directories lying around.

+   rmdir /s /q build32

+   rmdir /s /q build64

+   

+   echo Making 32-bit LunarGLASS

+   echo *************************

+   mkdir build32

+   set LUNARGLASS_BUILD_DIR=%LUNARGLASS_DIR%\build32

+   cd %LUNARGLASS_BUILD_DIR%

+   

+   echo Generating 32-bit LunarGlass CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 32-bit LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Release

+   

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %LUNARGLASS_BUILD_DIR%\Core\Release\core.lib (

+      echo.

+      echo LunarGLASS 32-bit Release build failed!

+      set errorCode=1

+      goto:eof

+   )

+   

+   REM disable Debug build of LunarGLASS until its cmake file can be updated to

+   REM handle Debug and Release builds of glslang simultaneously, instead of

+   REM whatever last lands in "./build/install"

+   REM   echo Building 32-bit LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   REM   msbuild INSTALL.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   REM Check for existence of one lib, even though we should check for all results

+   REM  if not exist %LUNARGLASS_BUILD_DIR%\Core\Debug\core.lib (

+   REM     echo.

+   REM     echo LunarGLASS 32-bit Debug build failed!

+   REM     set errorCode=1

+   REM     goto:eof

+   REM  )

+   

+   cd ..

+   

+   echo Making 64-bit LunarGLASS

+   echo *************************

+   mkdir build64

+   set LUNARGLASS_BUILD_DIR=%LUNARGLASS_DIR%\build64

    cd %LUNARGLASS_BUILD_DIR%

-   echo Generating LunarGlass CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

-   cmake -G"Visual Studio %VS_VERSION%" -DCMAKE_INSTALL_PREFIX=install ..

-   echo Building LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

-   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

+   

+   echo Generating 64-bit LunarGlass CMake files for Visual Studio %VS_VERSION% -DCMAKE_INSTALL_PREFIX=install ..

+   cmake -G "Visual Studio %VS_VERSION% Win64" -DCMAKE_INSTALL_PREFIX=install ..

+   

+   echo Building 64-bit LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Release

+   

    REM Check for existence of one lib, even though we should check for all results

    if not exist %LUNARGLASS_BUILD_DIR%\Core\Release\core.lib (

       echo.

-      echo LunarGLASS build failed!

+      echo LunarGLASS 64-bit Release build failed!

       set errorCode=1

       goto:eof

    )

+   

    REM disable Debug build of LunarGLASS until its cmake file can be updated to

    REM handle Debug and Release builds of glslang simultaneously, instead of

    REM whatever last lands in "./build/install"

-   REM   echo Building LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

-   REM   msbuild INSTALL.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

+   REM   echo Building 64-bit LunarGlass: MSBuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   REM   msbuild INSTALL.vcxproj /p:Platform=x64 /p:Configuration=Debug

    REM Check for existence of one lib, even though we should check for all results

    REM  if not exist %LUNARGLASS_BUILD_DIR%\Core\Debug\core.lib (

    REM     echo.

-   REM     echo LunarGLASS build failed!

+   REM     echo LunarGLASS 64-bit Debug build failed!

    REM     set errorCode=1

    REM     goto:eof

    REM  )

@@ -509,25 +649,68 @@ goto:eof
    echo.

    echo Building %SPIRV_TOOLS_DIR%

    cd  %SPIRV_TOOLS_DIR%

-   mkdir build

-   set SPIRV_TOOLS_BUILD_DIR=%SPIRV_TOOLS_DIR%\build

+

+   REM Cleanup any old directories lying around.

+   rmdir /s /q build32

+   rmdir /s /q build64

+   

+   echo Making 32-bit spirv-tools

+   echo *************************

+   mkdir build32

+   set SPIRV_TOOLS_BUILD_DIR=%SPIRV_TOOLS_DIR%\build32

    cd %SPIRV_TOOLS_BUILD_DIR%

-   echo Generating Spirv-tools CMake files for Visual Studio %VS_VERSION% ..

+   

+   echo Generating 32-bit spirv-tools CMake files for Visual Studio %VS_VERSION% ..

    cmake -G "Visual Studio %VS_VERSION%" ..

-   echo Building Spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

-   msbuild ALL_BUILD.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Debug

+   

+   echo Building 32-bit spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   msbuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Debug

+   

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %SPIRV_TOOLS_BUILD_DIR%\Debug\SPIRV-Tools.lib (

+      echo.

+      echo spirv-tools 32-bit Debug build failed!

+      set errorCode=1

+   )

+   

+   echo Building 32-bit spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Release

+   msbuild ALL_BUILD.vcxproj /p:Platform=x86 /p:Configuration=Release

+

+   REM Check for existence of one lib, even though we should check for all results

+   if not exist %SPIRV_TOOLS_BUILD_DIR%\Release\SPIRV-Tools.lib (

+      echo.

+      echo spirv-tools 32-bit Release build failed!

+      set errorCode=1

+   )

+   

+   cd ..

+ 

+   echo Making 64-bit spirv-tools  

+   echo *************************

+   mkdir build64

+   set SPIRV_TOOLS_BUILD_DIR=%SPIRV_TOOLS_DIR%\build64

+   cd %SPIRV_TOOLS_BUILD_DIR%

+   

+   echo Generating 64-bit spirv-tools CMake files for Visual Studio %VS_VERSION% ..

+   cmake -G "Visual Studio %VS_VERSION% Win64" ..

+   

+   echo Building 64-bit spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   msbuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Debug

+   

    REM Check for existence of one lib, even though we should check for all results

    if not exist %SPIRV_TOOLS_BUILD_DIR%\Debug\SPIRV-Tools.lib (

       echo.

-      echo spirv-tools Debug build failed!

+      echo spirv-tools 64-bit Debug build failed!

       set errorCode=1

    )

-   echo Building Spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

-   msbuild ALL_BUILD.vcxproj /p:Platform=%MSBUILD_MACHINE_TARGET% /p:Configuration=Release

+   

+   echo Building 64-bit spirv-tools: MSBuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Release

+   msbuild ALL_BUILD.vcxproj /p:Platform=x64 /p:Configuration=Release

+

    REM Check for existence of one lib, even though we should check for all results

    if not exist %SPIRV_TOOLS_BUILD_DIR%\Release\SPIRV-Tools.lib (

       echo.

-      echo spirv-tools Release build failed!

+      echo spirv-tools 64-bit Release build failed!

       set errorCode=1

    )

 goto:eof

diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index d7317e42..ba8470c9 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1437,14 +1437,14 @@ class ObjectTrackerSubcommand(Subcommand):
             else:
                 procs_txt.append('static void create_%s(VkDevice dispatchable_object, %s vkObj, VkDebugReportObjectTypeEXT objType)' % (name, o))
             procs_txt.append('{')
-            procs_txt.append('    log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, reinterpret_cast<uint64_t>(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",')
+            procs_txt.append('    log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK",')
             procs_txt.append('        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType),')
-            procs_txt.append('        reinterpret_cast<uint64_t>(vkObj));')
+            procs_txt.append('        (uint64_t)(vkObj));')
             procs_txt.append('')
             procs_txt.append('    OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;')
             procs_txt.append('    pNewObjNode->objType = objType;')
             procs_txt.append('    pNewObjNode->status  = OBJSTATUS_NONE;')
-            procs_txt.append('    pNewObjNode->vkObj  = reinterpret_cast<uint64_t>(vkObj);')
+            procs_txt.append('    pNewObjNode->vkObj  = (uint64_t)(vkObj);')
             procs_txt.append('    %sMap[(uint64_t)vkObj] = pNewObjNode;' % (o))
             procs_txt.append('    uint32_t objIndex = objTypeToIndex(objType);')
             procs_txt.append('    numObjs[objIndex]++;')
@@ -1457,7 +1457,7 @@ class ObjectTrackerSubcommand(Subcommand):
             else:
                 procs_txt.append('static void destroy_%s(VkDevice dispatchable_object, %s object)' % (name, o))
             procs_txt.append('{')
-            procs_txt.append('    uint64_t object_handle = reinterpret_cast<uint64_t>(object);')
+            procs_txt.append('    uint64_t object_handle = (uint64_t)(object);')
             procs_txt.append('    if (%sMap.find(object_handle) != %sMap.end()) {' % (o, o))
             procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[(uint64_t)object];' % (o))
             procs_txt.append('        uint32_t objIndex = objTypeToIndex(pNode->objType);')
@@ -1467,7 +1467,7 @@ class ObjectTrackerSubcommand(Subcommand):
             procs_txt.append('        numObjs[objIndex]--;')
             procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK",')
             procs_txt.append('           "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",')
-            procs_txt.append('            string_VkDebugReportObjectTypeEXT(pNode->objType), reinterpret_cast<uint64_t>(object), numTotalObjs, numObjs[objIndex],')
+            procs_txt.append('            string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex],')
             procs_txt.append('            string_VkDebugReportObjectTypeEXT(pNode->objType));')
             procs_txt.append('        delete pNode;')
             procs_txt.append('        %sMap.erase(object_handle);' % (o))
@@ -1485,7 +1485,7 @@ class ObjectTrackerSubcommand(Subcommand):
                 procs_txt.append('static VkBool32 set_%s_status(VkDevice dispatchable_object, %s object, VkDebugReportObjectTypeEXT objType, ObjectStatusFlags status_flag)' % (name, o))
             procs_txt.append('{')
             procs_txt.append('    if (object != VK_NULL_HANDLE) {')
-            procs_txt.append('        uint64_t object_handle = reinterpret_cast<uint64_t>(object);')
+            procs_txt.append('        uint64_t object_handle = (uint64_t)(object);')
             procs_txt.append('        if (%sMap.find(object_handle) != %sMap.end()) {' % (o, o))
             procs_txt.append('            OBJTRACK_NODE* pNode = %sMap[object_handle];' % (o))
             procs_txt.append('            pNode->status |= status_flag;')
@@ -1513,7 +1513,7 @@ class ObjectTrackerSubcommand(Subcommand):
             procs_txt.append('    OBJECT_TRACK_ERROR  error_code,')
             procs_txt.append('    const char         *fail_msg)')
             procs_txt.append('{')
-            procs_txt.append('    uint64_t object_handle = reinterpret_cast<uint64_t>(object);')
+            procs_txt.append('    uint64_t object_handle = (uint64_t)(object);')
             procs_txt.append('    if (%sMap.find(object_handle) != %sMap.end()) {' % (o, o))
             procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object_handle];' % (o))
             procs_txt.append('        if ((pNode->status & status_mask) != status_flag) {')
@@ -1539,7 +1539,7 @@ class ObjectTrackerSubcommand(Subcommand):
             else:
                 procs_txt.append('static VkBool32 reset_%s_status(VkDevice dispatchable_object, %s object, VkDebugReportObjectTypeEXT objType, ObjectStatusFlags status_flag)' % (name, o))
             procs_txt.append('{')
-            procs_txt.append('    uint64_t object_handle = reinterpret_cast<uint64_t>(object);')
+            procs_txt.append('    uint64_t object_handle = (uint64_t)(object);')
             procs_txt.append('    if (%sMap.find(object_handle) != %sMap.end()) {' % (o, o))
             procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object_handle];' % (o))
             procs_txt.append('        pNode->status &= ~status_flag;')
@@ -1569,8 +1569,8 @@ class ObjectTrackerSubcommand(Subcommand):
             procs_txt.append('    if (null_allowed && (object == VK_NULL_HANDLE))')
             procs_txt.append('        return VK_FALSE;')
             procs_txt.append('    if (%sMap.find((uint64_t)object) == %sMap.end()) {' % (do, do))
-            procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, reinterpret_cast<uint64_t>(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
-            procs_txt.append('            "Invalid %s Object 0x%%" PRIx64 ,reinterpret_cast<uint64_t>(object));' % do)
+            procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+            procs_txt.append('            "Invalid %s Object 0x%%" PRIx64 ,(uint64_t)(object));' % do)
             procs_txt.append('    }')
             procs_txt.append('    return VK_FALSE;')
             procs_txt.append('}')
@@ -1591,8 +1591,8 @@ class ObjectTrackerSubcommand(Subcommand):
                     procs_txt.append('        (swapchainImageMap.find((uint64_t)object) == swapchainImageMap.end())) {')
                 else:
                     procs_txt.append('    if (%sMap.find((uint64_t)object) == %sMap.end()) {' % (o, o))
-                procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, reinterpret_cast<uint64_t>(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
-                procs_txt.append('            "Invalid %s Object 0x%%" PRIx64, reinterpret_cast<uint64_t>(object));' % o)
+                procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Invalid %s Object 0x%%" PRIx64, (uint64_t)(object));' % o)
                 procs_txt.append('    }')
                 procs_txt.append('    return VK_FALSE;')
                 procs_txt.append('}')
@@ -1603,7 +1603,7 @@ class ObjectTrackerSubcommand(Subcommand):
     def generate_destroy_instance(self):
         gedi_txt = []
         gedi_txt.append('%s' % self.lineinfo.get())
-        gedi_txt.append('void vkDestroyInstance(')
+        gedi_txt.append('VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(')
         gedi_txt.append('VkInstance instance,')
         gedi_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedi_txt.append('{')
@@ -1652,7 +1652,7 @@ class ObjectTrackerSubcommand(Subcommand):
     def generate_destroy_device(self):
         gedd_txt = []
         gedd_txt.append('%s' % self.lineinfo.get())
-        gedd_txt.append('void vkDestroyDevice(')
+        gedd_txt.append('VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(')
         gedd_txt.append('VkDevice device,')
         gedd_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedd_txt.append('{')
@@ -2316,7 +2316,7 @@ class ThreadingSubcommand(Subcommand):
     def generate_useObject(self, ty):
         obj_type = self.thread_check_object_types[ty]
         key = "object"
-        msg_object = "reinterpret_cast<uint64_t>(object)"
+        msg_object = "(uint64_t)(object)"
         header_txt = []
         header_txt.append('%s' % self.lineinfo.get())
         header_txt.append('static void use%s(const void* dispatchable_object, %s object)' % (ty, ty))