finished first version. but don't test.

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "SPIRV-Cross"]
+	path = SPIRV-Cross
+	url = https://github.com/KhronosGroup/SPIRV-Cross.git

CMakeLists.txt

@@ -4,22 +4,25 @@ SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE)
 project(GLSLCompiler)
 
 if(MSVC)
-    SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MD")
+    SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
-    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MD")
+    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
 
-    SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MD")
+    SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
-    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
+    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
     add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
-include("FindVulkan.cmake")
+include("system_bit.cmake")
+include("output_path.cmake")
 
-include_directories(${Vulkan_INCLUDE_DIRS})
+add_subdirectory(SPIRV-Cross)
-link_directories(${Vulkan_LIBRARIES_DIR})
+add_subdirectory(SPIRV-Cross/external/glslang)
+add_subdirectory(SPIRV-Cross/external/spirv-tools)
+
+include_directories(SPIRV-Cross/external)
 
 set(VULKAN_SPIRV_LIBS   GenericCodeGen
                         glslang
-                        HLSL
                         MachineIndependent
                         OGLCompiler
                         OSDependent

FindVulkan.cmake

@@ -1,87 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# FindVulkan
-# ----------
-#
-# Try to find Vulkan
-#
-# IMPORTED Targets
-# ^^^^^^^^^^^^^^^^
-#
-# This module defines :prop_tgt:`IMPORTED` target ``Vulkan::Vulkan``, if
-# Vulkan has been found.
-#
-# Result Variables
-# ^^^^^^^^^^^^^^^^
-#
-# This module defines the following variables::
-#
-#   Vulkan_FOUND          - True if Vulkan was found
-#   Vulkan_INCLUDE_DIRS   - include directories for Vulkan
-#   Vulkan_LIBRARIES      - link against this library to use Vulkan
-#
-# The module will also define two cache variables::
-#
-#   Vulkan_INCLUDE_DIR    - the Vulkan include directory
-#   Vulkan_LIBRARY        - the path to the Vulkan library
-#
-
-if(WIN32)
-  find_path(Vulkan_INCLUDE_DIR
-    NAMES vulkan/vulkan.h
-    PATHS
-      "$ENV{VULKAN_SDK}/Include"
-    )
-
-  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    find_library(Vulkan_LIBRARY
-      NAMES vulkan-1
-      PATHS
-        "$ENV{VULKAN_SDK}/Lib"
-        "$ENV{VULKAN_SDK}/Bin"
-        )
-
-    set(Vulkan_LIBRARIES_DIR $ENV{VULKAN_SDK}/Lib)
-  elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
-    find_library(Vulkan_LIBRARY
-      NAMES vulkan-1
-      PATHS
-        "$ENV{VULKAN_SDK}/Lib32"
-        "$ENV{VULKAN_SDK}/Bin32"
-        NO_SYSTEM_ENVIRONMENT_PATH
-        )
-
-    set(Vulkan_LIBRARIES_DIR $ENV{VULKAN_SDK}/Lib32)
-  endif()
-else()
-    find_path(Vulkan_INCLUDE_DIR
-      NAMES vulkan/vulkan.h
-      PATHS
-        "$ENV{VULKAN_SDK}/include")
-    find_library(Vulkan_LIBRARY
-      NAMES vulkan
-      PATHS
-        "$ENV{VULKAN_SDK}/lib")
-
-    set(Vulkan_LIBRARIES_DIR $ENV{VULKAN_SDK}/Lib)
-endif()
-
-set(Vulkan_LIBRARIES ${Vulkan_LIBRARY})
-set(Vulkan_INCLUDE_DIRS ${Vulkan_INCLUDE_DIR})
-
-#include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Vulkan
-  DEFAULT_MSG
-  Vulkan_LIBRARY Vulkan_INCLUDE_DIR)
-
-mark_as_advanced(Vulkan_INCLUDE_DIR Vulkan_LIBRARY)
-
-if(Vulkan_FOUND AND NOT TARGET Vulkan::Vulkan)
-  add_library(Vulkan::Vulkan UNKNOWN IMPORTED)
-  set_target_properties(Vulkan::Vulkan PROPERTIES
-    IMPORTED_LOCATION "${Vulkan_LIBRARIES}"
-    INTERFACE_INCLUDE_DIRECTORIES "${Vulkan_INCLUDE_DIRS}")
-endif()

SPIRV-Cross

@@ -0,0 +1 @@
+Subproject commit f0fe4442e32a900f49140f8597d54fefb4ba32d0

glsl2spv.cpp

@@ -1,9 +1,34 @@
-#include<vulkan/vulkan.h>
+#include<glslang/SPIRV/GlslangToSpv.h>
-#include<glslang/SPIRV/GlslangToSpv.h>
 #include<glslang/Include/ResourceLimits.h>
 #include<vector>
 #include<iostream>
 
+typedef enum VkShaderStageFlagBits {
+    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
+    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+    VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,
+    VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,
+    VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,
+    VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,
+    VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,
+    VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
+    VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
+    VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
+    VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
+    VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
+    VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
+    VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,
+    VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
+    VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
+    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderStageFlagBits;
+
 static TBuiltInResource default_build_in_resource;
 
 void init_default_build_in_resource() 
@@ -146,21 +171,76 @@ EShLanguage FindLanguage(const VkShaderStageFlagBits shader_type)
 
 extern "C" 
 {
-    bool InitShaderCompiler()
+#ifdef WIN32
+    #define EXPORT_FUNC __declspec(dllexport)
+#else
+    #define EXPORT_FUNC 
+#endif
+
+    EXPORT_FUNC bool InitShaderCompiler()
     {
         init_default_build_in_resource();
 
         return glslang::InitializeProcess();
     }
 
-    void CloseShaderCompiler()
+    EXPORT_FUNC void CloseShaderCompiler()
     {
         glslang::FinalizeProcess();
     }
 
-    bool GLSL2SPV(const VkShaderStageFlagBits shader_type,const char *shader_source,std::vector<uint32_t> &spirv)
+    struct SPVData
     {
-        EShLanguage stage = FindLanguage(shader_type);
+        bool result;
+        char *log;
+        char *debug_log;
+
+        uint32_t *spv_data;
+        uint32_t spv_length;
+
+    public:
+
+        SPVData(const char *l,const char *dl)
+        {
+            result=false;
+
+            log=new char[strlen(l)+1];
+            strcpy(log,l);
+
+            debug_log=new char[strlen(dl)+1];
+            strcpy(debug_log,dl);
+
+            spv_data=nullptr;
+        }
+
+        SPVData(const std::vector<uint32_t> &spirv)
+        {
+            result=true;
+
+            log=nullptr;
+            debug_log=nullptr;
+
+            spv_length=spirv.size();
+            spv_data=new uint32_t[spv_length];
+            memcpy(spv_data,spirv.data(),spv_length*sizeof(uint32_t));
+        }
+
+        ~SPVData()
+        {
+            delete[] log;
+            delete[] debug_log;
+            delete[] spv_data;
+        }
+    };//struct SPVData
+
+    EXPORT_FUNC void FreeSPVData(SPVData *spv)
+    {
+        delete spv;
+    }
+
+    EXPORT_FUNC SPVData *GLSL2SPV(const uint32_t shader_type,const char *shader_source)
+    {
+        EShLanguage stage = FindLanguage((VkShaderStageFlagBits)shader_type);
 
         glslang::TShader shader(stage);
         glslang::TProgram program;
@@ -175,11 +255,7 @@ extern "C"
         shader.setStrings(shaderStrings, 1);
 
         if (!shader.parse(&Resources, 100, false, messages))
-        {
+            return(new SPVData(shader.getInfoLog(),shader.getInfoDebugLog()));
-            puts(shader.getInfoLog());
-            puts(shader.getInfoDebugLog());
-            return false;  // something didn't work
-        }
 
         program.addShader(&shader);
 
@@ -189,17 +265,18 @@ extern "C"
 
         if (!program.link(messages)) 
         {
-            puts(shader.getInfoLog());
-            puts(shader.getInfoDebugLog());
             fflush(stdout);            
-            return false;
+            return(new SPVData(shader.getInfoLog(),shader.getInfoDebugLog()));
         }
 
+        std::vector<uint32_t> spirv;
+
         glslang::GlslangToSpv(*program.getIntermediate(stage),spirv);
-        return(true);
+        
+        return(new SPVData(spirv));
     }
         
-    VkShaderStageFlagBits GetShaderStageFlagByExtName(const char *ext_name)
+    EXPORT_FUNC uint32_t GetShaderStageFlagByExtName(const char *ext_name)
     {
         if (stricmp(ext_name,"vert") == 0)return VK_SHADER_STAGE_VERTEX_BIT; else
         if (stricmp(ext_name,"tesc") == 0)return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; else
@@ -210,7 +287,7 @@ extern "C"
         if (stricmp(ext_name,"task") == 0)return VK_SHADER_STAGE_TASK_BIT_NV; else
         if (stricmp(ext_name,"mesh") == 0)return VK_SHADER_STAGE_MESH_BIT_NV; else
         {
-            return (VkShaderStageFlagBits)0;
+            return 0;
         }
     }
 }//extern "C"

output_path.cmake

@@ -0,0 +1,40 @@
+IF(ANDROID)
+    SET(OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/out/android/${ANDROID_ABI})
+ELSEIF(IOS)
+    SET(OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/out/iOS/${IOS_PLATFORM})
+ELSE()
+    IF(WIN32)
+        SET(USE_GUI ON)
+    ENDIF()
+
+    SET(OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/out/${CMAKE_SYSTEM_NAME}_${HGL_BITS})
+ENDIF()
+
+MESSAGE("SYSTEM NAME: " ${CMAKE_SYSTEM_NAME})
+MESSAGE("OUTPUT DIRECTORY: " ${OUTPUT_DIRECTORY})
+
+SET(OUTPUT_DIRECTORY_DEBUG ${OUTPUT_DIRECTORY}_Debug)
+SET(OUTPUT_DIRECTORY_RELEASE ${OUTPUT_DIRECTORY}_Release)
+SET(OUTPUT_DIRECTORY_MINSIZEREL ${OUTPUT_DIRECTORY}_MinSizeRel)
+SET(OUTPUT_DIRECTORY_RELWITHDEBINFO ${OUTPUT_DIRECTORY}_RelWithDebInfo)
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY})
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY})
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${OUTPUT_DIRECTORY_DEBUG})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${OUTPUT_DIRECTORY_DEBUG})
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${OUTPUT_DIRECTORY_DEBUG})
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${OUTPUT_DIRECTORY_RELEASE})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${OUTPUT_DIRECTORY_RELEASE})
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OUTPUT_DIRECTORY_RELEASE})
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${OUTPUT_DIRECTORY_MINSIZEREL})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_MINSIZEREL ${OUTPUT_DIRECTORY_MINSIZEREL})
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL ${OUTPUT_DIRECTORY_MINSIZEREL})
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${OUTPUT_DIRECTORY_RELWITHDEBINFO})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO ${OUTPUT_DIRECTORY_RELWITHDEBINFO})
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO ${OUTPUT_DIRECTORY_RELWITHDEBINFO})
+

system_bit.cmake

@@ -0,0 +1,28 @@
+IF(APPLE)
+    SET(HGL_BITS 64)
+ELSE()
+    IF(ANDROID)
+        if(ANDROID_ABI MATCHES ".*64.*")
+            SET(HGL_BITS 64)
+        else()
+            SET(HGL_BITS 32)
+        endif()
+    ELSE()
+        IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
+            SET(HGL_BITS 64)
+        ELSE()
+            SET(HGL_BITS 32)
+        ENDIF()
+    endif()
+endif()
+
+IF(HGL_BITS EQUAL 32)
+    add_definitions(-DHGL_32_BITS)
+    add_definitions(-DHGL_POINTER_UINT=uint32)
+ELSE()
+    add_definitions(-DHGL_64_BITS)
+    add_definitions(-DHGL_POINTER_UINT=uint64)
+ENDIF()
+
+Message("System is ${HGL_BITS} Bit")
+