Merge branch 'master' of github.com:KrakenEngine/kraken

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "hydra"]
 	path = hydra
 	url = git@github.com:KrakenEngine/hydra.git
+[submodule "3rdparty/glslang"]
+	path = 3rdparty/glslang
+	url = git@github.com:KhronosGroup/glslang.git

.hgignore

@@ -1,4 +0,0 @@
-syntax: glob
-kraken_win\kraken.VC.db
-kraken_win/build/
-build/

.hgtags

@@ -1 +0,0 @@
-be35d62159788e03c335f8b7f3ddbde8030a3ccf Release 1.0.2

.travis.yml

@@ -3,7 +3,7 @@ compiler: clang
 
 branches:
   only:
-    - master
+    - feature-vulkan
 
 matrix:
   include:
@@ -14,7 +14,6 @@ matrix:
             - ubuntu-toolchain-r-test
           packages:
             - libc++-dev
-            - libboost-dev
     - os: osx
       osx_image: xcode9.1
 

CMakeLists.txt

@@ -1,9 +1,17 @@
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 2.8)
-set(CMAKE_CXX_STANDARD 11)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
     set(CMAKE_CXX_EXTENSIONS OFF)
+else(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    # Likely MSVC...
+    # Build with more cores
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
 
-if (NOT WIN32)
+if (NOT WIN32 AND NOT ANDROID)
   set(CMAKE_CXX_COMPILER "clang++")
 endif()
 
@@ -27,6 +35,21 @@ macro (add_sources)
     endif()
 endmacro()
 
+macro (add_standard_asset)
+    file (RELATIVE_PATH _relPath "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
+    foreach (_src ${ARGN})
+        if (_relPath)
+            list (APPEND KRAKEN_STANDARD_ASSETS "${_relPath}/${_src}")
+        else()
+            list (APPEND KRAKEN_STANDARD_ASSETS "${_src}")
+        endif()
+    endforeach()
+    if (_relPath)
+        # propagate KRAKEN_STANDARD_ASSETS to parent directory
+        set (KRAKEN_STANDARD_ASSETS ${KRAKEN_STANDARD_ASSETS} PARENT_SCOPE)
+    endif()
+endmacro()
+
 macro (add_public_header)
     file (RELATIVE_PATH _relPath "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
     foreach (_src ${ARGN})
@@ -43,6 +66,8 @@ macro (add_public_header)
 endmacro()
 
 IF(APPLE)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated -Wno-deprecated-declarations -Wno-c++11-extensions")
+   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated -Wno-deprecated-declarations -Wno-c++11-extensions")
    # SET(GUI_TYPE MACOSX_BUNDLE)
    # INCLUDE_DIRECTORIES ( /Developer/Headers/FlatCarbon )
    FIND_LIBRARY(APPKIT_LIBRARY AppKit)
@@ -73,70 +98,123 @@ add_public_header(hydra/include/vector3.h)
 add_public_header(hydra/include/vector4.h)
 add_public_header(hydra/include/vector2i.h)
 
-add_library(kraken SHARED ${SRCS} ${KRAKEN_PUBLIC_HEADERS})
+# ---- Android ----
-
+if(ANDROID)
-set(Boost_USE_STATIC_LIBS        ON) # only find static libs
+add_subdirectory(kraken_android)
-set(Boost_USE_MULTITHREADED      ON)
-set(Boost_USE_STATIC_RUNTIME    OFF)
-find_package(Boost 1.54.0)
-if(Boost_FOUND)
-  include_directories(${Boost_INCLUDE_DIRS})
-  target_link_libraries(kraken ${Boost_LIBRARIES})
 endif()
 
 # ---- Hydra ----
 add_subdirectory(hydra)
 include_directories(hydra/include)
-target_link_libraries(kraken hydra)
+list (APPEND EXTRA_LIBS hydra)
 
+# ---- Vulkan ----
+if(NOT ANDROID)
+find_package(Vulkan REQUIRED)
+list (APPEND EXTRA_LIBS Vulkan::Vulkan)
+endif()
+
+
+# ---- GLSlang ----
+if(NOT ANDROID)
+set(ENABLE_GLSLANG_BINARIES OFF)
+set(ENABLE_GLSLANG_INSTALL OFF)
+set(ENABLE_SPVREMAPPER OFF)
+add_subdirectory(3rdparty/glslang)
+include_directories(3rdparty/glslang/Public)
+list (APPEND EXTRA_LIBS "glslang")
+list (APPEND EXTRA_LIBS "SPIRV")
+endif()
 
 # ---- OpenGL ----
+if(ANDROID)
+list (APPEND EXTRA_LIBS "EGL")
+list (APPEND EXTRA_LIBS "GLESv3")
+else()
 find_package(OpenGL REQUIRED)
 include_directories( ${OPENGL_INCLUDE_DIRS} )
-target_link_libraries(kraken ${OPENGL_LIBRARIES})
+list (APPEND EXTRA_LIBS "${OPENGL_LIBRARIES}")
+endif()
 
 # ---- GLAD ----
+if(NOT ANDROID)
 set(GLAD_EXTENSIONS "GL_EXT_texture_filter_anisotropic,GL_EXT_texture_compression_s3tc, GL_S3_s3tc" CACHE STRING "Gl exts" FORCE)
 add_subdirectory(3rdparty/glad)
 include_directories(${GLAD_INCLUDE_DIRS})
-target_link_libraries(kraken glad)
+list (APPEND EXTRA_LIBS "glad")
+endif()
 
 # ---- GLFW ----
+if(NOT ANDROID)
 set(GLFW_BUILD_EXAMPLES OFF CACHE INTERNAL "Build the GLFW example programs")
 set(GLFW_BUILD_TESTS OFF CACHE INTERNAL "Build the GLFW test programs")
 set(GLFW_BUILD_DOCS OFF CACHE INTERNAL "Build the GLFW documentation")
 set(GLFW_INSTALL OFF CACHE INTERNAL "Generate installation target")
 add_subdirectory(3rdparty/glfw)
 include_directories(3rdparty/glfw/include)
-target_link_libraries(kraken glfw ${GLFW_LIBRARIES})
+list (APPEND EXTRA_LIBS "${GLFW_LIBRARIES}")
+endif()
 
+add_custom_command(
+    OUTPUT ${KRAKEN_PUBLIC_HEADERS_OUTPUT}
+//    COMMAND kraken_convert -o ${STANDARD_ASSET_BUNDLE} ${KRAKEN_STANDARD_ASSETS}
+//    DEPENDS kraken_convert ${KRAKEN_STANDARD_ASSETS}
+  COMMENT "Copying public headers"
+)
+
+add_library(kraken STATIC ${SRCS} ${KRAKEN_PUBLIC_HEADERS} ${KRAKEN_PUBLIC_HEADERS_OUTPUT})
 TARGET_LINK_LIBRARIES( kraken ${EXTRA_LIBS} )
 SET_TARGET_PROPERTIES(
   kraken
 PROPERTIES
-  FRAMEWORK ON
-  SOVERSION 0
-  VERSION 0.1.0
   PUBLIC_HEADER "${KRAKEN_PUBLIC_HEADERS}"
   PRIVATE_HEADER "${PRIVATE_HEADER_FILES}"
-  ARCHIVE_OUTPUT_DIRECTORY "archive"
+  ARCHIVE_OUTPUT_DIRECTORY "lib${LIB_SUFFIX}"
-  LIBRARY_OUTPUT_DIRECTORY "lib${LIB_SUFFIX}"
   OUTPUT_NAME kraken
 )
 
-# install(TARGETS kraken DESTINATION ${PROJECT_BINARY_DIR}/lib${LIB_SUFFIX})
-# install(FILES ${KRAKEN_PUBLIC_HEADERS} DESTINATION ${PROJECT_BINARY_DIR}/include)
-
-# INSTALL(TARGETS kraken 
-#        LIBRARY DESTINATION "lib${LIB_SUFFIX}"
-#        ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
-#        PUBLIC_HEADER DESTINATION "include"
-# )
-
-
-
 # add_custom_target(package
 #   COMMENT "Compressing..."
 #   WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/archive"
 #   COMMAND ${CMAKE_COMMAND} -E tar "cfvz" "kraken.tgz" "*"
 # )
+
+install(TARGETS kraken
+        RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/export/${CMAKE_BUILD_TYPE}/bin/win
+        PUBLIC_HEADER DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/export/include
+        ARCHIVE DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/export/${CMAKE_BUILD_TYPE}/lib/win
+        LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/export/${CMAKE_BUILD_TYPE}/lib/win
+)
+
+IF(CMAKE_BUILD_TYPE MATCHES DEBUG)
+  install (FILES $<TARGET_PDB_FILE:kraken>
+           DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/export/lib/win)
+ENDIF(CMAKE_BUILD_TYPE MATCHES DEBUG)
+
+set(KRAKEN_PUBLIC_HEADERS_OUTPUT ${KRAKEN_PUBLIC_HEADERS})
+list(TRANSFORM KRAKEN_PUBLIC_HEADERS_OUTPUT PREPEND "${CMAKE_BINARY_DIR}/output/include")
+
+add_subdirectory(standard_assets)
+
+SET(STANDARD_ASSET_BUNDLE "${CMAKE_BINARY_DIR}/output/assets/standard_assets.krbundle")
+
+add_custom_command(
+    OUTPUT ${STANDARD_ASSET_BUNDLE}
+    COMMAND kraken_convert -o ${STANDARD_ASSET_BUNDLE} ${KRAKEN_STANDARD_ASSETS}
+    DEPENDS kraken_convert ${KRAKEN_STANDARD_ASSETS}
+	WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+	COMMENT "Creating Standard Assets"
+)
+
+add_custom_target(standard_assets ALL
+    DEPENDS ${STANDARD_ASSET_BUNDLE}
+    VERBATIM
+)
+
+add_subdirectory(tests)
+add_subdirectory(tools)
+
+set_target_properties( kraken PROPERTIES
+  RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${CMAKE_BINARY_DIR}/output/lib
+  RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/output/lib
+)

CMakeSettings.json

@@ -0,0 +1,41 @@
+{
+    // See https://go.microsoft.com//fwlink//?linkid=834763 for more information about this file.
+    "configurations": [
+        {
+        "name": "x86-Debug",
+        "generator": "Visual Studio 15 2017",
+        "configurationType" : "Debug",
+        "buildRoot":  "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
+        "cmakeCommandArgs":  "",
+        "buildCommandArgs": "-m -v:minimal",
+        "ctestCommandArgs":  ""
+        },
+        {
+        "name": "x86-Release",
+        "generator": "Visual Studio 15 2017",
+        "configurationType" : "Release",
+        "buildRoot":  "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
+        "cmakeCommandArgs":  "",
+        "buildCommandArgs": "-m -v:minimal",
+        "ctestCommandArgs":  ""
+        },
+        {
+        "name": "x64-Debug",
+        "generator": "Visual Studio 15 2017 Win64",
+        "configurationType" : "Debug",
+        "buildRoot":  "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
+        "cmakeCommandArgs":  "",
+        "buildCommandArgs": "-m -v:minimal",
+        "ctestCommandArgs":  ""
+        },
+        {
+        "name": "x64-Release",
+        "generator": "Visual Studio 15 2017 Win64",
+        "configurationType" : "Release",
+        "buildRoot":  "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
+        "cmakeCommandArgs":  "",
+        "buildCommandArgs": "-m -v:minimal",
+        "ctestCommandArgs":  ""
+        }
+    ]
+}

configure_macos.sh

@@ -0,0 +1 @@
+cmake -H. -G Ninja -Bbuild -DCMAKE_TOOLCHAIN_FILE="toolchain/toolchain-x86_64-apple-darwin-clang.cmake"

configure_win64.bat

@@ -0,0 +1,2 @@
+rem call "%VSINSTALLDIR%VC\Auxiliary\Build\vcvars64.bat"
+cmake -H. -G Ninja -Bbuild -DCMAKE_TOOLCHAIN_FILE="toolchain/toolchain-x86_64-pc-windows-msvc.cmake"

configure_win64_msvc.bat

@@ -0,0 +1,2 @@
+rem call "%VSINSTALLDIR%VC\Auxiliary\Build\vcvars64.bat"
+cmake -H. -G"Visual Studio 16 2019" -Bbuild -DCMAKE_TOOLCHAIN_FILE="toolchain/toolchain-x86_64-pc-windows-msvc.cmake"

kraken/CMakeLists.txt

@@ -3,6 +3,7 @@ add_subdirectory(public)
 set(KRAKEN_PUBLIC_HEADERS "${KRAKEN_PUBLIC_HEADERS}" PARENT_SCOPE)
 
 # Private Implementation
+add_sources(kraken.cpp)
 add_sources(KRAmbientZone.cpp)
 add_sources(KRAnimation.cpp)
 add_sources(KRAnimationAttribute.cpp)
@@ -63,11 +64,16 @@ add_sources(KRResource+blend.cpp)
 # add_sources(KRResource+fbx.cpp) # TODO - Locate FBX SDK dependencies
 add_sources(KRResource+obj.cpp)
 add_sources(KRResource.cpp)
+add_sources(KRResourceManager.cpp)
 add_sources(KRReverbZone.cpp)
 add_sources(KRScene.cpp)
 add_sources(KRSceneManager.cpp)
 add_sources(KRShader.cpp)
 add_sources(KRShaderManager.cpp)
+add_sources(KRSource.cpp)
+add_sources(KRSourceManager.cpp)
+add_sources(KRPipeline.cpp)
+add_sources(KRPipelineManager.cpp)
 add_sources(KRSpotLight.cpp)
 add_sources(KRSprite.cpp)
 add_sources(KRTexture.cpp)

kraken/KRAmbientZone.cpp

@@ -96,9 +96,9 @@ void KRAmbientZone::render(KRCamera *pCamera, std::vector<KRPointLight *> &point
     if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
         Matrix4 sphereModelMatrix = getModelMatrix();
         
-        KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+        KRPipeline *pPipeline = getContext().getPipelineManager()->getPipeline("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
         
-        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pPipeline, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             
             // Enable additive blending
             GLDEBUG(glEnable(GL_BLEND));

kraken/KRAnimation.cpp

@@ -28,8 +28,6 @@
 //  authors and should not be interpreted as representing official policies, either expressed
 //  or implied, of Kearwood Gilbert.
 //
-#include <boost/tokenizer.hpp>
-#include <boost/lexical_cast.hpp>
 #include "KRAnimation.h"
 #include "KRAnimationManager.h"
 #include "KRContext.h"
@@ -291,7 +289,7 @@ KRAnimation *KRAnimation::split(const std::string &name, float start_time, float
                     KRAnimationAttribute *new_attribute = new KRAnimationAttribute(getContext());
                     KRAnimationCurve *new_curve = curve;
                     if(clone_curves) {
-                        std::string new_curve_name = name + "_curve" + boost::lexical_cast<std::string>(++new_curve_count);
+                        std::string new_curve_name = name + "_curve" + std::to_string(++new_curve_count);
                         new_curve = curve->split(new_curve_name, start_time, duration);
                     }
                     

kraken/KRAnimationCurveManager.cpp

@@ -32,7 +32,7 @@
 #include "KRAnimationCurveManager.h"
 #include "KRAnimationCurve.h"
 
-KRAnimationCurveManager::KRAnimationCurveManager(KRContext &context) : KRContextObject(context)
+KRAnimationCurveManager::KRAnimationCurveManager(KRContext &context) : KRResourceManager(context)
 {
     
 }
@@ -48,6 +48,21 @@ void KRAnimationCurveManager::deleteAnimationCurve(KRAnimationCurve *curve) {
     delete curve;
 }
 
+KRResource* KRAnimationCurveManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+    if (extension.compare("kranimationcurve") == 0) {
+        return loadAnimationCurve(name, data);
+    }
+    return nullptr;
+}
+KRResource* KRAnimationCurveManager::getResource(const std::string& name, const std::string& extension)
+{
+    if (extension.compare("kranimationcurve") == 0) {
+        return getAnimationCurve(name);
+    }
+    return nullptr;
+}
+
 KRAnimationCurve *KRAnimationCurveManager::loadAnimationCurve(const std::string &name, KRDataBlock *data) {
     KRAnimationCurve *pAnimationCurve = KRAnimationCurve::Load(*m_pContext, name, data);
     if(pAnimationCurve) {

kraken/KRAnimationCurveManager.h

@@ -34,17 +34,22 @@
 
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRAnimationCurve.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 
 using std::map;
 
-class KRAnimationCurveManager : public KRContextObject {
+class KRAnimationCurveManager : public KRResourceManager {
 public:
     KRAnimationCurveManager(KRContext &context);
     virtual ~KRAnimationCurveManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+
     KRAnimationCurve *loadAnimationCurve(const std::string &name, KRDataBlock *data);
     KRAnimationCurve *getAnimationCurve(const std::string &name);
     void addAnimationCurve(KRAnimationCurve *new_animation_curve);

kraken/KRAnimationManager.cpp

@@ -32,7 +32,7 @@
 #include "KRAnimationManager.h"
 #include "KRAnimation.h"
 
-KRAnimationManager::KRAnimationManager(KRContext &context) : KRContextObject(context)
+KRAnimationManager::KRAnimationManager(KRContext &context) : KRResourceManager(context)
 {
 
 }
@@ -81,6 +81,20 @@ void KRAnimationManager::endFrame(float deltaTime)
     
 }
 
+KRResource* KRAnimationManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("kranimation") == 0) {
+    return loadAnimation(name.c_str(), data);
+  }
+  return nullptr;
+}
+KRResource* KRAnimationManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("kranimation") == 0) {
+    return getAnimation(name.c_str());
+  }
+  return nullptr;
+}
 
 KRAnimation *KRAnimationManager::loadAnimation(const char *szName, KRDataBlock *data) {
     KRAnimation *pAnimation = KRAnimation::Load(*m_pContext, szName, data);

kraken/KRAnimationManager.h

@@ -34,17 +34,22 @@
 
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRAnimation.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 
 
 
-class KRAnimationManager : public KRContextObject {
+class KRAnimationManager : public KRResourceManager {
 public:
     KRAnimationManager(KRContext &context);
     virtual ~KRAnimationManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     KRAnimation *loadAnimation(const char *szName, KRDataBlock *data);
     KRAnimation *getAnimation(const char *szName);
     void addAnimation(KRAnimation *new_animation);

kraken/KRAudioManager.cpp

@@ -39,7 +39,7 @@
 #include "KRDSP.h"
 
 KRAudioManager::KRAudioManager(KRContext &context)
-    : KRContextObject(context)
+    : KRResourceManager(context)
     , m_initialized(false)
 {
     m_enable_audio = true;
@@ -309,7 +309,7 @@ void KRAudioManager::renderReverb()
     for(unordered_map<std::string, siren_reverb_zone_weight_info>::iterator zone_itr=m_reverb_zone_weights.begin(); zone_itr != m_reverb_zone_weights.end(); zone_itr++) {
         siren_reverb_zone_weight_info zi = (*zone_itr).second;
         if(zi.reverb_sample) {
-            int zone_sample_blocks = KRMIN(zi.reverb_sample->getFrameCount(), (int)(m_reverb_max_length * 44100.0f)) / KRENGINE_AUDIO_BLOCK_LENGTH + 1;
+            int zone_sample_blocks = KRMIN((int)zi.reverb_sample->getFrameCount(), (int)(m_reverb_max_length * 44100.0f)) / KRENGINE_AUDIO_BLOCK_LENGTH + 1;
             impulse_response_blocks = KRMAX(impulse_response_blocks, zone_sample_blocks);
         }
     }
@@ -843,7 +843,7 @@ Vector2 KRAudioManager::getNearestHRTFSample(const Vector2 &dir)
     float elev_gran = 10.0f;
 
     
-    Vector2 dir_deg = dir * (180.0f / M_PI);
+    Vector2 dir_deg = dir * (180.0f / (float)M_PI);
     float elevation = floor(dir_deg.x / elev_gran + 0.5f) * elev_gran;
     if(elevation < -40.0f) {
         elevation = -40.0f;
@@ -877,8 +877,8 @@ void KRAudioManager::getHRTFMix(const Vector2 &dir, Vector2 &dir1, Vector2 &dir2
 {
     float elev_gran = 10.0f;
     
-    float elevation = dir.x * 180.0f / M_PI;
+    float elevation = dir.x * 180.0f / (float)M_PI;
-    float azimuth = dir.y * 180.0f / M_PI;
+    float azimuth = dir.y * 180.0f / (float)M_PI;
     
     float elev1 = floor(elevation / elev_gran) * elev_gran;
     float elev2 = ceil(elevation / elev_gran) * elev_gran;
@@ -1248,6 +1248,25 @@ void KRAudioManager::add(KRAudioSample *sound)
     }
 }
 
+KRResource* KRAudioManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("mtl") == 0 ||
+      extension.compare("mp3") == 0 ||
+      extension.compare("wav") == 0) {
+    return load(name, extension, data);
+  }
+  return nullptr;
+}
+KRResource* KRAudioManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("mtl") == 0 ||
+    extension.compare("mp3") == 0 ||
+    extension.compare("wav") == 0) {
+    return get(name);
+  }
+  return nullptr;
+}
+
 KRAudioSample *KRAudioManager::load(const std::string &name, const std::string &extension, KRDataBlock *data)
 {
     KRAudioSample *Sound = new KRAudioSample(getContext(), name, extension, data);
@@ -1830,19 +1849,19 @@ void audioLimit_Mute(bool onNotOff) {
 float audioGetLimitParameters_Stereo(float *buffer, unsigned long framesize,
                                   unsigned long *attack_sample_position, float *peak)
 {
-	float limitvol = 1.0;
+	float limitvol = 1.0f;
 	long attack_position = -1;
-	*peak = 0.0;
+	*peak = 0.0f;
-	float max = 0.0;
+	float max = 0.0f;
-	float amplitude = 0.0;
+	float amplitude = 0.0f;
 	
 	float *src = buffer;
 	for (unsigned long i = 0; i < framesize * 2; i++) {
 		amplitude = fabs(*src); src++;
 		if (amplitude > max) max = amplitude;
-		if (amplitude > 0.995) if (attack_position < 0) attack_position = (i+1) / 2;
+		if (amplitude > 0.995f) if (attack_position < 0) attack_position = (i+1) / 2;
     }
-	if (max > 0.995) limitvol = 0.995 / max;
+	if (max > 0.995f) limitvol = 0.995f / max;
 	*peak = max;
 	
 	if (attack_position < 0) attack_position = framesize;

kraken/KRAudioManager.h

@@ -34,6 +34,8 @@
 
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 #include "KRAudioSource.h"
@@ -90,11 +92,14 @@ typedef struct {
     KRAudioSample *reverb_sample;
 } siren_reverb_zone_weight_info;
 
-class KRAudioManager : public KRContextObject {
+class KRAudioManager : public KRResourceManager {
 public:
     KRAudioManager(KRContext &context);
     virtual ~KRAudioManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     unordered_map<std::string, KRAudioSample *> &getSounds();
     
     void add(KRAudioSample *Sound);
@@ -238,7 +243,7 @@ private:
     unordered_map<std::string, siren_reverb_zone_weight_info> m_reverb_zone_weights;
     float m_reverb_zone_total_weight = 0.0f; // For normalizing zone weights
     
-    boost::signals2::mutex m_mutex;
+    std::mutex m_mutex;
 #ifdef __APPLE__
     mach_timebase_info_data_t m_timebase_info;
 #endif

kraken/KRAudioSample.cpp

@@ -84,7 +84,7 @@ int KRAudioSample::getChannelCount()
     return m_channelsPerFrame;
 }
 
-int KRAudioSample::getFrameCount()
+__int64_t KRAudioSample::getFrameCount()
 {
     loadInfo();
     //return (int)((__int64_t)m_totalFrames * (__int64_t)frame_rate / (__int64_t)m_frameRate);
@@ -113,7 +113,7 @@ float KRAudioSample::sample(int frame_offset, int frame_rate, int channel)
         if(buffer_index >= m_bufferCount) {
             return 0.0f; // Past the end of the recording
         } else {
-            int buffer_offset = frame_offset - buffer_index * maxFramesPerBuffer;
+            __int64_t buffer_offset = frame_offset - buffer_index * maxFramesPerBuffer;
             
             KRAudioBuffer *buffer = getContext().getAudioManager()->getBuffer(*this, buffer_index);
             if(buffer == NULL) {
@@ -132,12 +132,12 @@ void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel,
 {
     loadInfo();
     
-    m_last_frame_used = getContext().getAudioManager()->getAudioFrame();
+    m_last_frame_used = (int)getContext().getAudioManager()->getAudioFrame();
     
     if(loop) {
         int buffer_offset = 0;
         int frames_left = frame_count;
-        int sample_length = getFrameCount();
+        int sample_length = (int)getFrameCount();
         while(frames_left) {
             int next_frame = (int)(((__int64_t)frame_offset + (__int64_t)buffer_offset) % sample_length);
             if(next_frame + frames_left >= sample_length) {
@@ -160,8 +160,8 @@ void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel,
             // Range is entirely after the sample
             memset(buffer, 0, frame_count * sizeof(float));
         } else {
-            int start_frame = frame_offset < 0 ? 0 : frame_offset;
+            int start_frame = (int)(frame_offset < 0 ? 0 : frame_offset);
-            int prefix_frames = frame_offset < 0 ? -frame_offset : 0;
+            int prefix_frames = (int)(frame_offset < 0 ? -frame_offset : 0);
             if(prefix_frames > 0) {
                 // Prefix with padding of 0's
                 memset(buffer, 0, prefix_frames * sizeof(float));
@@ -386,7 +386,7 @@ KRAudioBuffer *KRAudioSample::getBuffer(int index)
 void KRAudioSample::_endFrame()
 {
     const __int64_t AUDIO_SAMPLE_EXPIRY_FRAMES = 500;
-    long current_frame = getContext().getAudioManager()->getAudioFrame();
+    __int64_t current_frame = getContext().getAudioManager()->getAudioFrame();
     if(current_frame > m_last_frame_used + AUDIO_SAMPLE_EXPIRY_FRAMES) {
         closeFile();
     }

kraken/KRAudioSample.h

@@ -56,14 +56,14 @@ public:
     
     // Siren audio engine interface
     int getChannelCount();
-    int getFrameCount();
+    __int64_t getFrameCount();
     float sample(int frame_offset, int frame_rate, int channel);
     void sample(__int64_t frame_offset, int frame_count, int channel, float *buffer, float amplitude, bool loop);
     
     void _endFrame();
 private:
     
-    long m_last_frame_used;
+    __int64_t m_last_frame_used;
     
     std::string m_extension;
     KRDataBlock *m_pData;

kraken/KRAudioSource.cpp

@@ -180,9 +180,9 @@ void KRAudioSource::render(KRCamera *pCamera, std::vector<KRPointLight *> &point
     if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
         Matrix4 sphereModelMatrix = getModelMatrix();
         
-        KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+        KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
         
-        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             
             // Enable additive blending
             GLDEBUG(glEnable(GL_BLEND));
@@ -433,7 +433,7 @@ float KRAudioSource::getAudioTime()
 void KRAudioSource::setAudioTime(float new_position)
 {
     // Sets the audio playback position with units of floating point seconds.
-    setAudioFrame(new_position * 44100.0f);
+    setAudioFrame((__int64_t)(new_position * 44100.0f));
 }
 
 void KRAudioSource::sample(int frame_count, int channel, float *buffer, float gain)

kraken/KRBehavior.h

@@ -10,6 +10,7 @@
 #define KRBEHAVIOR_H
 
 #include <map>
+#include <string>
 
 /*
 

kraken/KRBone.cpp

@@ -61,9 +61,9 @@ void KRBone::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_lights
         // Disable z-buffer test
         GLDEBUG(glDisable(GL_DEPTH_TEST));
 
-        KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+        KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
         
-        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             std::vector<KRMesh *> sphereModels = getContext().getMeshManager()->getModel("__sphere");
             if(sphereModels.size()) {
                 for(int i=0; i < sphereModels[0]->getSubmeshCount(); i++) {

kraken/KRBundle.cpp

@@ -54,14 +54,14 @@ KRBundle::KRBundle(KRContext &context, std::string name, KRDataBlock *pData) : K
     m_pData = pData;
     
     __int64_t file_pos = 0;
-    while(file_pos < m_pData->getSize()) {
+    while(file_pos < (__int64_t)m_pData->getSize()) {
         tar_header_type file_header;
-        m_pData->copy(&file_header, file_pos, sizeof(file_header));
+        m_pData->copy(&file_header, (int)file_pos, sizeof(file_header));
         size_t file_size = strtol(file_header.file_size, NULL, 8);
         file_pos += 512; // Skip past the header to the file contents
         if(file_header.file_name[0] != '\0' && file_header.file_name[0] != '.') {
             // We ignore the last two records in the tar file, which are zero'ed out tar_header structures
-            KRDataBlock *pFileData = pData->getSubBlock(file_pos, file_size);
+            KRDataBlock *pFileData = pData->getSubBlock((int)file_pos, (int)file_size);
             context.loadResource(file_header.file_name, pFileData);
         }
         file_pos += RoundUpSize(file_size);
@@ -114,7 +114,7 @@ bool KRBundle::save(KRDataBlock &data) {
     return true;
 }
 
-void KRBundle::append(KRResource &resource)
+KRDataBlock* KRBundle::append(KRResource &resource)
 {
     // Serialize resource to binary representation
     KRDataBlock resource_data;
@@ -124,7 +124,7 @@ void KRBundle::append(KRResource &resource)
     
     // Padding is added at the end of file to align next header to a 512 byte boundary.  Padding at the end of the archive includes an additional 1024 bytes -- two zero-ed out file headers that mark the end of the archive
     size_t padding_size = RoundUpSize(resource_data.getSize()) - resource_data.getSize() + KRENGINE_KRBUNDLE_HEADER_SIZE * 2;
-    
+    size_t resource_data_start = m_pData->getSize() + KRENGINE_KRBUNDLE_HEADER_SIZE;
     m_pData->expand(KRENGINE_KRBUNDLE_HEADER_SIZE + resource_data.getSize() + padding_size - KRENGINE_KRBUNDLE_HEADER_SIZE * 2); // We will overwrite the existing zero-ed out file headers that marked the end of the archive, so we don't have to include their size here
     
     m_pData->lock();
@@ -163,4 +163,7 @@ void KRBundle::append(KRResource &resource)
     sprintf(file_header->checksum, "%07o", check_sum);
     
     m_pData->unlock();
+
+    KRDataBlock *pFileData = m_pData->getSubBlock((int)resource_data_start, (int)resource_data.getSize());
+    return pFileData;
 }

kraken/KRBundle.h

@@ -44,7 +44,7 @@ public:
     virtual bool save(const std::string& path);
     virtual bool save(KRDataBlock &data);
     
-    void append(KRResource &resource);
+    KRDataBlock* append(KRResource &resource);
     
 private:
     KRDataBlock *m_pData;

kraken/KRBundleManager.cpp

@@ -33,7 +33,7 @@
 
 #include "KRBundle.h"
 
-KRBundleManager::KRBundleManager(KRContext &context) : KRContextObject(context) {
+KRBundleManager::KRBundleManager(KRContext &context) : KRResourceManager(context) {
     
 }
 
@@ -44,6 +44,21 @@ KRBundleManager::~KRBundleManager() {
     m_bundles.empty();
 }
 
+KRResource* KRBundleManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("krbundle") == 0) {
+    return loadBundle(name.c_str() , data);
+  }
+  return nullptr;
+}
+KRResource* KRBundleManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("krbundle") == 0) {
+    return getBundle(name.c_str());
+  }
+  return nullptr;
+}
+
 KRBundle *KRBundleManager::loadBundle(const char *szName, KRDataBlock *pData)
 {
     KRBundle *pBundle = new KRBundle(*m_pContext, szName, pData);
@@ -51,6 +66,14 @@ KRBundle *KRBundleManager::loadBundle(const char *szName, KRDataBlock *pData)
     return pBundle;
 }
 
+KRBundle *KRBundleManager::createBundle(const char *szName)
+{
+  // TODO: Check for name conflicts
+  KRBundle *pBundle = new KRBundle(*m_pContext, szName);
+  m_bundles[szName] = pBundle;
+  return pBundle;
+}
+
 KRBundle *KRBundleManager::getBundle(const char *szName) {
     return m_bundles[szName];
 }

kraken/KRBundleManager.h

@@ -33,6 +33,8 @@
 #ifndef KRBUNDLEMANAGER_H
 #define KRBUNDLEMANAGER_H
 
+#include "KRResourceManager.h"
+
 #include "KREngine-common.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
@@ -40,13 +42,17 @@
 class KRContext;
 class KRBundle;
 
-class KRBundleManager : public KRContextObject {
+class KRBundleManager : public KRResourceManager {
 public:
     KRBundleManager(KRContext &context);
     ~KRBundleManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     KRBundle *loadBundle(const char *szName, KRDataBlock *pData);
     KRBundle *getBundle(const char *szName);
+    KRBundle* createBundle(const char* szName);
     
     std::vector<std::string> getBundleNames();
     unordered_map<std::string, KRBundle *> getBundles();

kraken/KRCamera.cpp

@@ -113,7 +113,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
     
     //Matrix4 viewMatrix = Matrix4::Invert(getModelMatrix());
     
-    settings.setViewportSize(Vector2::Create(m_backingWidth, m_backingHeight));
+    settings.setViewportSize(Vector2::Create((float)m_backingWidth, (float)m_backingHeight));
     Matrix4 projectionMatrix;
     projectionMatrix.perspective(settings.perspective_fov, settings.m_viewportSize.x / settings.m_viewportSize.y, settings.perspective_nearz, settings.perspective_farz);
     m_viewport = KRViewport(settings.getViewportSize(), viewMatrix, projectionMatrix);
@@ -132,7 +132,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
         GL_PUSH_GROUP_MARKER("Generate Shadowmaps");
         
         scene.render(this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_GENERATE_SHADOWMAPS, false /*settings.bEnableDeferredLighting*/);
-        GLDEBUG(glViewport(0, 0, m_viewport.getSize().x, m_viewport.getSize().y));
+        GLDEBUG(glViewport(0, 0, (GLsizei)m_viewport.getSize().x, (GLsizei)m_viewport.getSize().y));
         GL_POP_GROUP_MARKER;
     }
     
@@ -184,7 +184,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
         // Set render target
         GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, lightAccumulationBuffer));
         GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, compositeDepthTexture, 0));
-        GLDEBUG(glViewport(0, 0, m_viewport.getSize().x * m_downsample.x, m_viewport.getSize().y * m_downsample.y));
+        GLDEBUG(glViewport(0, 0, (GLsizei)(m_viewport.getSize().x * m_downsample.x), (GLsizei)(m_viewport.getSize().y * m_downsample.y)));
         GLDEBUG(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
         GLDEBUG(glClear(GL_COLOR_BUFFER_BIT));
         
@@ -251,7 +251,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
         // Set render target
         GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, compositeFramebuffer));
         GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, compositeDepthTexture, 0));
-        GLDEBUG(glViewport(0, 0, m_viewport.getSize().x * m_downsample.x, m_viewport.getSize().y * m_downsample.y));
+        GLDEBUG(glViewport(0, 0, (GLsizei)(m_viewport.getSize().x * m_downsample.x), (GLsizei)(m_viewport.getSize().y * m_downsample.y)));
         
         // Disable alpha blending
         GLDEBUG(glDisable(GL_BLEND));
@@ -312,7 +312,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
     }
     
     if(m_pSkyBoxTexture) {
-        getContext().getShaderManager()->selectShader("sky_box", *this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, m_viewport, Matrix4(), false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_OPAQUE, Vector3::Zero(), 0.0f, Vector4::Zero());
+        getContext().getPipelineManager()->selectPipeline("sky_box", *this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, m_viewport, Matrix4(), false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_OPAQUE, Vector3::Zero(), 0.0f, Vector4::Zero());
 
         getContext().getTextureManager()->selectTexture(0, m_pSkyBoxTexture, 0.0f, KRTexture::TEXTURE_USAGE_SKY_CUBE);
         
@@ -419,7 +419,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
         
         GL_PUSH_GROUP_MARKER("Volumetric Lighting");
         
-        KRViewport volumetricLightingViewport = KRViewport(Vector2::Create(volumetricBufferWidth, volumetricBufferHeight), m_viewport.getViewMatrix(), m_viewport.getProjectionMatrix());
+        KRViewport volumetricLightingViewport = KRViewport(Vector2::Create((float)volumetricBufferWidth, (float)volumetricBufferHeight), m_viewport.getViewMatrix(), m_viewport.getProjectionMatrix());
         
         if(settings.volumetric_environment_downsample != 0) {
             // Set render target
@@ -431,7 +431,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
             GLDEBUG(glDisable(GL_DEPTH_TEST));
             m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture);
             
-            GLDEBUG(glViewport(0, 0, volumetricLightingViewport.getSize().x, volumetricLightingViewport.getSize().y));
+            GLDEBUG(glViewport(0, 0, (GLsizei)volumetricLightingViewport.getSize().x, (GLsizei)volumetricLightingViewport.getSize().y));
         } else {
             // Enable z-buffer test
             GLDEBUG(glEnable(GL_DEPTH_TEST));
@@ -446,7 +446,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
             GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, compositeFramebuffer));
             GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, compositeDepthTexture, 0));
             
-            GLDEBUG(glViewport(0, 0, m_viewport.getSize().x, m_viewport.getSize().y));
+            GLDEBUG(glViewport(0, 0, (GLsizei)m_viewport.getSize().x, (GLsizei)m_viewport.getSize().y));
         }
         
         GL_POP_GROUP_MARKER;
@@ -473,14 +473,14 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
         GLDEBUG(glBlendFunc(GL_ONE, GL_ONE));
         
         
-        KRShader *pVisShader = getContext().getShaderManager()->getShader("visualize_overlay", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+        KRPipeline *pVisShader = getContext().getPipelineManager()->getPipeline("visualize_overlay", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
         
         m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_3D_CUBE_VERTICES, 1.0f);
         for(unordered_map<AABB, int>::iterator itr=m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) {
             Matrix4 matModel = Matrix4();
             matModel.scale((*itr).first.size() * 0.5f);
             matModel.translate((*itr).first.center());
-            if(getContext().getShaderManager()->selectShader(*this, pVisShader, m_viewport, matModel, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+            if(getContext().getPipelineManager()->selectPipeline(*this, pVisShader, m_viewport, matModel, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero())) {
                 GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 14));
             }
         }
@@ -492,7 +492,7 @@ void KRCamera::renderFrame(GLint defaultFBO, GLint renderBufferWidth, GLint rend
     GL_POP_GROUP_MARKER;
     
 
-//    fprintf(stderr, "VBO Mem: %i Kbyte    Texture Mem: %i/%i Kbyte (active/total)     Shader Handles: %i   Visible Bounds: %i  Max Texture LOD: %i\n", (int)m_pContext->getMeshManager()->getMemUsed() / 1024, (int)m_pContext->getTextureManager()->getActiveMemUsed() / 1024, (int)m_pContext->getTextureManager()->getMemUsed() / 1024, (int)m_pContext->getShaderManager()->getShaderHandlesUsed(), (int)m_visibleBounds.size(), m_pContext->getTextureManager()->getLODDimCap());
+//    fprintf(stderr, "VBO Mem: %i Kbyte    Texture Mem: %i/%i Kbyte (active/total)     Shader Handles: %i   Visible Bounds: %i  Max Texture LOD: %i\n", (int)m_pContext->getMeshManager()->getMemUsed() / 1024, (int)m_pContext->getTextureManager()->getActiveMemUsed() / 1024, (int)m_pContext->getTextureManager()->getMemUsed() / 1024, (int)m_pContext->getPipelineManager()->getShaderHandlesUsed(), (int)m_visibleBounds.size(), m_pContext->getTextureManager()->getLODDimCap());
     GL_PUSH_GROUP_MARKER("Post Processing");
 
     GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO));
@@ -553,7 +553,7 @@ void KRCamera::createBuffers(GLint renderBufferWidth, GLint renderBufferHeight)
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
-        GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_backingWidth, m_backingHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL));
+        GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_backingWidth, m_backingHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL));
         GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, compositeColorTexture, 0));
         
         // ----- Create Depth Texture for compositeFramebuffer -----
@@ -579,7 +579,7 @@ void KRCamera::createBuffers(GLint renderBufferWidth, GLint renderBufferHeight)
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
         GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
-        GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_backingWidth, m_backingHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL));
+        GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_backingWidth, m_backingHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL));
         GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, lightAccumulationTexture, 0));
     }
     
@@ -618,7 +618,7 @@ void KRCamera::createBuffers(GLint renderBufferWidth, GLint renderBufferHeight)
             GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
             GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
             GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); // This is necessary for non-power-of-two textures
-            GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, volumetricBufferWidth, volumetricBufferHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL));
+            GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, volumetricBufferWidth, volumetricBufferHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL));
             GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, volumetricLightAccumulationTexture, 0));
         }
     }
@@ -690,12 +690,12 @@ void KRCamera::renderPost()
  */
 	
 
-	GLDEBUG(glViewport(0, 0, m_viewport.getSize().x, m_viewport.getSize().y));
+	GLDEBUG(glViewport(0, 0, (GLsizei)m_viewport.getSize().x, (GLsizei)m_viewport.getSize().y));
     GLDEBUG(glDisable(GL_DEPTH_TEST));
-    KRShader *postShader = m_pContext->getShaderManager()->getShader("PostShader", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+    KRPipeline *postShader = m_pContext->getPipelineManager()->getPipeline("PostShader", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
     
     Vector3 rim_color;
-    getContext().getShaderManager()->selectShader(*this, postShader, m_viewport, Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, rim_color, 0.0f, m_fade_color);
+    getContext().getPipelineManager()->selectPipeline(*this, postShader, m_viewport, Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, rim_color, 0.0f, m_fade_color);
     
     m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture);
     m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 1, compositeColorTexture);
@@ -714,13 +714,13 @@ void KRCamera::renderPost()
     
     
 //    if(bShowShadowBuffer) {
-//        KRShader *blitShader = m_pContext->getShaderManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+//        KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
 //        
 //        for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) {
 //            Matrix4 viewMatrix = Matrix4();
 //            viewMatrix.scale(0.20, 0.20, 0.20);
 //            viewMatrix.translate(-0.70, 0.70 - 0.45 * iShadow, 0.0);
-//            getContext().getShaderManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+//            getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
 //            m_pContext->getTextureManager()->selectTexture(1, NULL);
 //            m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES);
 //            m_pContext->getTextureManager()->_setActiveTexture(0);
@@ -809,7 +809,7 @@ void KRCamera::renderPost()
                     int iTexRow = 15 - (iChar - iTexCol) / 16;
                     
                     Vector2 top_left_pos = Vector2::Create(-1.0f + dScaleX * iCol, dScaleY * iRow - 1.0f);
-                    Vector2 bottom_right_pos = Vector2::Create(-1.0 + dScaleX * (iCol + 1), dScaleY * iRow + dScaleY - 1.0f);
+                    Vector2 bottom_right_pos = Vector2::Create(-1.0f + dScaleX * (iCol + 1), dScaleY * iRow + dScaleY - 1.0f);
                     top_left_pos += Vector2::Create(1.0f / 2048.0f * 0.5f, 1.0f / 1536.0f * 0.5f);
                     bottom_right_pos += Vector2::Create(1.0f / 2048.0f * 0.5f, 1.0f / 1536.0f * 0.5f);
                     Vector2 top_left_uv = Vector2::Create(dTexScale * iTexCol, dTexScale * iTexRow);
@@ -878,8 +878,8 @@ void KRCamera::renderPost()
         GLDEBUG(glEnable(GL_BLEND));
         GLDEBUG(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
         
-        KRShader *fontShader = m_pContext->getShaderManager()->getShader("debug_font", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+        KRPipeline *fontShader = m_pContext->getPipelineManager()->getPipeline("debug_font", this, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
-        getContext().getShaderManager()->selectShader(*this, fontShader, m_viewport, Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero());
+        getContext().getPipelineManager()->selectPipeline(*this, fontShader, m_viewport, Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero());
         
         m_pContext->getTextureManager()->selectTexture(0, m_pContext->getTextureManager()->getTexture("font"), 0.0f, KRTexture::TEXTURE_USAGE_UI);
         
@@ -967,13 +967,13 @@ std::string KRCamera::getDebugText()
 #endif // defined(__APPLE__)
 
             // ---- GPU Memory ----
-            int texture_count_active = m_pContext->getTextureManager()->getActiveTextures().size();
+            size_t texture_count_active = m_pContext->getTextureManager()->getActiveTextures().size();
-            int texture_count = texture_count_active;
+            size_t texture_count = texture_count_active;
             long texture_mem_active = m_pContext->getTextureManager()->getMemActive();
             long texture_mem_used = m_pContext->getTextureManager()->getMemUsed();
             long texture_mem_throughput = m_pContext->getTextureManager()->getMemoryTransferedThisFrame();
             
-            int vbo_count_active = m_pContext->getMeshManager()->getActiveVBOCount();
+            size_t vbo_count_active = m_pContext->getMeshManager()->getActiveVBOCount();
             long vbo_mem_active = m_pContext->getMeshManager()->getMemActive();
             long vbo_mem_used = m_pContext->getMeshManager()->getMemUsed();
             long vbo_mem_throughput = m_pContext->getMeshManager()->getMemoryTransferedThisFrame();

kraken/KRCamera.h

@@ -34,7 +34,7 @@
 
 #include "KREngine-common.h"
 
-#include "KRShader.h"
+#include "KRPipeline.h"
 #include "KRContextObject.h"
 #include "KRTexture.h"
 #include "KRContext.h"

kraken/KRCollider.cpp

@@ -196,9 +196,9 @@ void KRCollider::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_li
             
             GL_PUSH_GROUP_MARKER("Debug Overlays");
             
-            KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+            KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
             
-            if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+            if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
                 
                 // Enable additive blending
                 GLDEBUG(glEnable(GL_BLEND));

kraken/KRContext.cpp

@@ -12,12 +12,18 @@
 #include "KRCamera.h"
 #include "KRAudioManager.h"
 #include "KRAudioSample.h"
+#include "KRBundle.h"
+
+#if defined(ANDROID)
+#include <chrono>
+#include <unistd.h>
+#endif
 
 #if defined(_WIN32) || defined(_WIN64)
 #include <windows.h>
 #endif
 
-int KRContext::KRENGINE_MAX_SHADER_HANDLES;
+int KRContext::KRENGINE_MAX_PIPELINE_HANDLES;
 int KRContext::KRENGINE_GPU_MEM_MAX;
 int KRContext::KRENGINE_GPU_MEM_TARGET;
 int KRContext::KRENGINE_MAX_TEXTURE_DIM;
@@ -33,6 +39,8 @@ int KRContext::KRENGINE_SYS_PAGE_SIZE;
 
 #elif defined(_WIN32) || defined(_WIN64)
 
+#elif defined(ANDROID)
+
 #else
 
 #error Unsupported Platform
@@ -47,8 +55,13 @@ const char *KRContext::extension_names[KRENGINE_NUM_EXTENSIONS] = {
 KRContext::log_callback *KRContext::s_log_callback = NULL;
 void *KRContext::s_log_callback_user_data = NULL;
 
-KRContext::KRContext() : m_streamer(*this)
+KRContext::KRContext(const KrInitializeInfo* initializeInfo)
+  : m_streamer(*this)
+  , m_vulkanInstance(VK_NULL_HANDLE)
+  , m_resourceMapSize(initializeInfo->resourceMapSize)
 {
+    m_resourceMap = (KRResource **)malloc(sizeof(KRResource*) * m_resourceMapSize);
+    memset(m_resourceMap, 0, m_resourceMapSize * sizeof(KRResource*));
     m_streamingEnabled = false;
 #ifdef __APPLE__
     mach_timebase_info(&m_timebase_info);
@@ -61,15 +74,17 @@ KRContext::KRContext() : m_streamer(*this)
     m_absolute_time = 0.0f;
     
     m_pBundleManager = new KRBundleManager(*this);
-    m_pShaderManager = new KRShaderManager(*this);
+    m_pPipelineManager = new KRPipelineManager(*this);
     m_pTextureManager = new KRTextureManager(*this);
-    m_pMaterialManager = new KRMaterialManager(*this, m_pTextureManager, m_pShaderManager);
+    m_pMaterialManager = new KRMaterialManager(*this, m_pTextureManager, m_pPipelineManager);
     m_pMeshManager = new KRMeshManager(*this);
     m_pSceneManager = new KRSceneManager(*this);
     m_pAnimationManager = new KRAnimationManager(*this);
     m_pAnimationCurveManager = new KRAnimationCurveManager(*this);
     m_pSoundManager = new KRAudioManager(*this);
     m_pUnknownManager = new KRUnknownManager(*this);
+    m_pShaderManager = new KRShaderManager(*this);
+    m_pSourceManager = new KRSourceManager(*this);
     m_streamingEnabled = true;
 
 
@@ -81,7 +96,7 @@ KRContext::KRContext() : m_streamer(*this)
     KRENGINE_SYS_ALLOCATION_GRANULARITY = winSysInfo.dwAllocationGranularity;
     KRENGINE_SYS_PAGE_SIZE = winSysInfo.dwPageSize;
 
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
 
     KRENGINE_SYS_PAGE_SIZE = getpagesize();
     KRENGINE_SYS_ALLOCATION_GRANULARITY = KRENGINE_SYS_PAGE_SIZE;
@@ -94,7 +109,6 @@ KRContext::KRContext() : m_streamer(*this)
 }
 
 KRContext::~KRContext() {
-    
     if(m_pSceneManager) {
         delete m_pSceneManager;
         m_pSceneManager = NULL;
@@ -115,9 +129,9 @@ KRContext::~KRContext() {
         m_pMaterialManager = NULL;
     }
     
-    if(m_pShaderManager) {
+    if(m_pPipelineManager) {
-        delete m_pShaderManager;
+        delete m_pPipelineManager;
-        m_pShaderManager = NULL;
+        m_pPipelineManager = NULL;
     }
     
     if(m_pAnimationManager) {
@@ -135,6 +149,11 @@ KRContext::~KRContext() {
         m_pSoundManager = NULL;
     }
 
+    if(m_pSourceManager) {
+        delete m_pSourceManager;
+        m_pSourceManager = NULL;
+    }
+
     if(m_pUnknownManager) {
         delete m_pUnknownManager;
         m_pUnknownManager = NULL;
@@ -147,6 +166,10 @@ KRContext::~KRContext() {
     }
     
     destroyDeviceContexts();
+    if (m_resourceMap) {
+        delete m_resourceMap;
+        m_resourceMap = NULL;
+    }
 }
 
 void KRContext::SetLogCallback(log_callback *log_callback, void *user_data)
@@ -187,8 +210,8 @@ KRTextureManager *KRContext::getTextureManager() {
 KRMaterialManager *KRContext::getMaterialManager() {
     return m_pMaterialManager;
 }
-KRShaderManager *KRContext::getShaderManager() {
+KRPipelineManager *KRContext::getPipelineManager() {
-    return m_pShaderManager;
+    return m_pPipelineManager;
 }
 KRMeshManager *KRContext::getMeshManager() {
     return m_pMeshManager;
@@ -202,13 +225,17 @@ KRAnimationCurveManager *KRContext::getAnimationCurveManager() {
 KRAudioManager *KRContext::getAudioManager() {
     return m_pSoundManager;
 }
+KRShaderManager *KRContext::getShaderManager() {
+    return m_pShaderManager;
+}
+KRSourceManager *KRContext::getSourceManager() {
+    return m_pSourceManager;
+}
 KRUnknownManager *KRContext::getUnknownManager() {
     return m_pUnknownManager;
 }
-
 std::vector<KRResource *> KRContext::getResources()
 {
-    
     std::vector<KRResource *> resources;
     
     for(unordered_map<std::string, KRScene *>::iterator itr = m_pSceneManager->getScenes().begin(); itr != m_pSceneManager->getScenes().end(); itr++) {
@@ -233,6 +260,20 @@ std::vector<KRResource *> KRContext::getResources()
         resources.push_back((*itr).second);
     }
 
+    unordered_map<std::string, unordered_map<std::string, KRSource *> > sources = m_pSourceManager->getSources();
+    for(unordered_map<std::string, unordered_map<std::string, KRSource *> >::iterator itr = sources.begin(); itr != sources.end(); itr++) {
+        for(unordered_map<std::string, KRSource *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
+            resources.push_back((*itr2).second);
+        }
+    }
+
+    unordered_map<std::string, unordered_map<std::string, KRShader *> > shaders = m_pShaderManager->getShaders();
+    for(unordered_map<std::string, unordered_map<std::string, KRShader *> >::iterator itr = shaders.begin(); itr != shaders.end(); itr++) {
+        for(unordered_map<std::string, KRShader *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
+            resources.push_back((*itr2).second);
+        }
+    }
+    
     unordered_map<std::string, unordered_map<std::string, KRUnknown *> > unknowns = m_pUnknownManager->getUnknowns();
     for(unordered_map<std::string, unordered_map<std::string, KRUnknown *> >::iterator itr = unknowns.begin(); itr != unknowns.end(); itr++) {
         for(unordered_map<std::string, KRUnknown *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
@@ -240,66 +281,201 @@ std::vector<KRResource *> KRContext::getResources()
         }
     }
     
-    // FINDME, TODO - Not yet exporting shaders, as they are currently only being used as standard Kraken assets.  In the future people may want their custom shaders to be exported.
-    
     return resources;
 }
 
-void KRContext::loadResource(const std::string &file_name, KRDataBlock *data) {
+KRResource* KRContext::loadResource(const std::string &file_name, KRDataBlock *data) {
     std::string name = KRResource::GetFileBase(file_name);
     std::string extension = KRResource::GetFileExtension(file_name);
 
+    KRResource *resource = nullptr;
+    
 //    fprintf(stderr, "KRContext::loadResource - Loading: %s\n", file_name.c_str());
     
     if(extension.compare("krbundle") == 0) {
-        m_pBundleManager->loadBundle(name.c_str(), data);
+        resource = m_pBundleManager->loadBundle(name.c_str(), data);
     } else if(extension.compare("krmesh") == 0) {
-        m_pMeshManager->loadModel(name.c_str(), data);
+        resource = m_pMeshManager->loadModel(name.c_str(), data);
     } else if(extension.compare("krscene") == 0) {
-        m_pSceneManager->loadScene(name.c_str(), data);
+        resource = m_pSceneManager->loadScene(name.c_str(), data);
     } else if(extension.compare("kranimation") == 0) {
-        m_pAnimationManager->loadAnimation(name.c_str(), data);
+        resource = m_pAnimationManager->loadAnimation(name.c_str(), data);
     } else if(extension.compare("kranimationcurve") == 0) {
-        m_pAnimationCurveManager->loadAnimationCurve(name.c_str(), data);
+        resource = m_pAnimationCurveManager->loadAnimationCurve(name.c_str(), data);
     } else if(extension.compare("pvr") == 0) {
-        m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
+        resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
     } else if(extension.compare("ktx") == 0) {
-        m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
+        resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
     } else if(extension.compare("tga") == 0) {
-        m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
+        resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
-    } else if(extension.compare("vsh") == 0) {
+    } else if(extension.compare("spv") == 0) {
-        m_pShaderManager->loadVertexShader(name.c_str(), data);
+        // SPIR-V shader binary
-    } else if(extension.compare("fsh") == 0) {
+        resource = m_pShaderManager->load(name, extension, data);
-        m_pShaderManager->loadFragmentShader(name.c_str(), data);
+    } else if(extension.compare("vert") == 0) {
+        // vertex shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("frag") == 0) {
+        // fragment shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("tesc") == 0) {
+        // tessellation control shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("tese") == 0) {
+        // tessellation evaluation shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("geom") == 0) {
+        // geometry shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("comp") == 0) {
+        // compute shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("mesh") == 0) {
+        // mesh shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("task") == 0) {
+        // task shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rgen") == 0) {
+        // ray generation shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rint") == 0) {
+        // ray intersection shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rahit") == 0) {
+        // ray any hit shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rchit") == 0) {
+        // ray closest hit shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rmiss") == 0) {
+        // ray miss shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("rcall") == 0) {
+        // ray callable shader
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("glsl") == 0) {
+        // glsl included by other shaders
+        resource = m_pSourceManager->load(name, extension, data);
+    } else if(extension.compare("options") == 0) {
+        // shader pre-processor options definition file
+        resource = m_pSourceManager->load(name, extension, data);
     } else if(extension.compare("mtl") == 0) {
-        m_pMaterialManager->load(name.c_str(), data);
+        resource = m_pMaterialManager->load(name.c_str(), data);
     } else if(extension.compare("mp3") == 0) {
-        m_pSoundManager->load(name.c_str(), extension, data);
+        resource = m_pSoundManager->load(name.c_str(), extension, data);
     } else if(extension.compare("wav") == 0) {
-        m_pSoundManager->load(name.c_str(), extension, data);
+        resource = m_pSoundManager->load(name.c_str(), extension, data);
     } else if(extension.compare("aac") == 0) {
-        m_pSoundManager->load(name.c_str(), extension, data);
+        resource = m_pSoundManager->load(name.c_str(), extension, data);
     } else if(extension.compare("obj") == 0) {
-        KRResource::LoadObj(*this, file_name);
+        resource = KRResource::LoadObj(*this, file_name);
 #if !TARGET_OS_IPHONE
+/*
+  // FINDME, TODO, HACK! - Uncomment
     } else if(extension.compare("fbx") == 0) {
-        KRResource::LoadFbx(*this, file_name);
+        resource = KRResource::LoadFbx(*this, file_name);
+*/
     } else if(extension.compare("blend") == 0) {
-        KRResource::LoadBlenderScene(*this, file_name);
+        resource = KRResource::LoadBlenderScene(*this, file_name);
 #endif
     } else {
-        m_pUnknownManager->load(name, extension, data);
+        resource = m_pUnknownManager->load(name, extension, data);
     }
+    return resource;
 }
 
-void KRContext::loadResource(std::string path) {
+KrResult KRContext::loadResource(const KrLoadResourceInfo* loadResourceInfo) {
-    KRDataBlock *data = new KRDataBlock();
+    if (loadResourceInfo->resourceHandle < 0 || loadResourceInfo->resourceHandle >= m_resourceMapSize) {
-    if(data->load(path)) {
+      return KR_ERROR_OUT_OF_BOUNDS;
-        loadResource(path, data);
-    } else {
-        KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KRContext::loadResource - Failed to open file: %s", path.c_str());
-        delete data;
     }
+    KRDataBlock *data = new KRDataBlock();
+    if(!data->load(loadResourceInfo->pResourcePath)) {
+      KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KRContext::loadResource - Failed to open file: %s", loadResourceInfo->pResourcePath);
+      delete data;
+      return KR_ERROR_UNEXPECTED;
+    }
+
+    KRResource *resource = loadResource(loadResourceInfo->pResourcePath, data);
+    m_resourceMap[loadResourceInfo->resourceHandle] = resource;
+    return KR_SUCCESS;
+}
+
+KrResult KRContext::unloadResource(const KrUnloadResourceInfo* unloadResourceInfo)
+{
+  if (unloadResourceInfo->resourceHandle < 0 || unloadResourceInfo->resourceHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+  KRResource* resource = m_resourceMap[unloadResourceInfo->resourceHandle];
+  if (resource == nullptr) {
+    return KR_ERROR_NOT_MAPPED;
+  }
+  // TODO - Need to implement unloading logic
+  return KR_ERROR_NOT_IMPLEMENTED;
+}
+
+KrResult KRContext::mapResource(const KrMapResourceInfo* mapResourceInfo)
+{
+  if (mapResourceInfo->resourceHandle < 0 || mapResourceInfo->resourceHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+
+/*
+  KRResource* resource = loadResource(loadResourceInfo->pResourcePath, data);
+  m_resourceMap[loadResourceInfo->resourceHandle] = resource;
+  return KR_SUCCESS;
+*/
+
+  // TODO - Need to implement mapping logic
+  return KR_ERROR_NOT_IMPLEMENTED;
+}
+
+KrResult KRContext::createBundle(const KrCreateBundleInfo* createBundleInfo)
+{
+  if (createBundleInfo->resourceHandle < 0 || createBundleInfo->resourceHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+  KRResource* bundle = m_pBundleManager->createBundle(createBundleInfo->pBundleName);
+  m_resourceMap[createBundleInfo->resourceHandle] = bundle;
+
+  return KR_SUCCESS;
+}
+
+KrResult KRContext::moveToBundle(const KrMoveToBundleInfo* moveToBundleInfo)
+{
+  if (moveToBundleInfo->bundleHandle < 0 || moveToBundleInfo->bundleHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+  if (moveToBundleInfo->resourceHandle < 0 || moveToBundleInfo->resourceHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+  KRResource* resource = m_resourceMap[moveToBundleInfo->resourceHandle];
+  if (resource == nullptr) {
+    return KR_ERROR_NOT_MAPPED;
+  }
+  KRResource* bundleResource = m_resourceMap[moveToBundleInfo->bundleHandle];
+  if (bundleResource == nullptr) {
+    return KR_ERROR_NOT_MAPPED;
+  }
+  KRBundle* bundle = dynamic_cast<KRBundle*>(bundleResource);
+  if (bundle == nullptr) {
+    return KR_ERROR_INCORRECT_TYPE;
+  }
+  return resource->moveToBundle(bundle);
+}
+
+KrResult KRContext::saveResource(const KrSaveResourceInfo* saveResourceInfo)
+{
+  if (saveResourceInfo->resourceHandle < 0 || saveResourceInfo->resourceHandle >= m_resourceMapSize) {
+    return KR_ERROR_OUT_OF_BOUNDS;
+  }
+  KRResource* resource = m_resourceMap[saveResourceInfo->resourceHandle];
+  if (resource == nullptr) {
+    return KR_ERROR_NOT_MAPPED;
+  }
+  if (resource->save(saveResourceInfo->pResourcePath)) {
+    return KR_SUCCESS;
+  }
+  return KR_ERROR_UNEXPECTED;
 }
 
 void KRContext::detectExtensions() {
@@ -343,7 +519,10 @@ float KRContext::getAbsoluteTime() const
 
 long KRContext::getAbsoluteTimeMilliseconds()
 {
-#ifdef __APPLE__
+#if defined(ANDROID)
+    return std::chrono::duration_cast< std::chrono::milliseconds >(
+            std::chrono::system_clock::now().time_since_epoch()).count();
+#elif defined(__APPLE__)
     return (long)(mach_absolute_time() / 1000 * m_timebase_info.numer / m_timebase_info.denom); // Division done first to avoid potential overflow
 #else
     return (long)GetTickCount64();
@@ -448,4 +627,48 @@ void KRContext::receivedMemoryWarning()
   m_last_memory_warning_frame = m_current_frame;
 }
 
+void
+KRContext::createDeviceContexts()
+{
+  // initialize the VkApplicationInfo structure
+  VkApplicationInfo app_info = {};
+  app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+  app_info.pNext = NULL;
+  app_info.pApplicationName = "Test"; // TODO - Change Me!
+  app_info.applicationVersion = 1;
+  app_info.pEngineName = "Kraken Engine";
+  app_info.engineVersion = 1;
+  app_info.apiVersion = VK_API_VERSION_1_0;
 
+
+  // initialize the VkInstanceCreateInfo structure
+  VkInstanceCreateInfo inst_info = {};
+  inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+  inst_info.pNext = NULL;
+  inst_info.flags = 0;
+  inst_info.pApplicationInfo = &app_info;
+  inst_info.enabledExtensionCount = 0;
+  inst_info.ppEnabledExtensionNames = NULL;
+  inst_info.enabledLayerCount = 0;
+  inst_info.ppEnabledLayerNames = NULL;
+
+  VkResult res = vkCreateInstance(&inst_info, NULL, &m_vulkanInstance);
+  if (res != VK_SUCCESS) {
+    destroyDeviceContexts();
+  }
+}
+
+void
+KRContext::destroyDeviceContexts()
+{
+  if (m_vulkanInstance != VK_NULL_HANDLE) {
+    vkDestroyInstance(m_vulkanInstance, NULL);
+    m_vulkanInstance = VK_NULL_HANDLE;
+  }
+}
+
+void
+KRContext::activateStreamerContext()
+{
+
+}

kraken/KRContext.h

@@ -14,18 +14,20 @@
 #include "KRSceneManager.h"
 #include "KRTextureManager.h"
 #include "KRMaterialManager.h"
-#include "KRShaderManager.h"
+#include "KRPipelineManager.h"
 #include "KRMeshManager.h"
 #include "KRAnimationManager.h"
 #include "KRAnimationCurveManager.h"
 #include "KRUnknownManager.h"
+#include "KRShaderManager.h"
+#include "KRSourceManager.h"
 #include "KRStreamer.h"
 
 class KRAudioManager;
 
 class KRContext {
 public:
-    static int KRENGINE_MAX_SHADER_HANDLES;
+    static int KRENGINE_MAX_PIPELINE_HANDLES;
     static int KRENGINE_GPU_MEM_MAX;
     static int KRENGINE_GPU_MEM_TARGET;
     static int KRENGINE_MAX_TEXTURE_DIM;
@@ -35,22 +37,31 @@ public:
     static int KRENGINE_SYS_PAGE_SIZE;
     
     
-    KRContext();
+    KRContext(const KrInitializeInfo* initializeInfo);
     ~KRContext();
 
-    void loadResource(const std::string &file_name, KRDataBlock *data);
+    KrResult createBundle(const KrCreateBundleInfo* createBundleInfo);
-    void loadResource(std::string path);
+    KrResult moveToBundle(const KrMoveToBundleInfo* moveToBundleInfo);
+    KrResult loadResource(const KrLoadResourceInfo* loadResourceInfo);
+    KrResult unloadResource(const KrUnloadResourceInfo* unloadResourceInfo);
+    KrResult mapResource(const KrMapResourceInfo* mapResourceInfo);
+    KrResult saveResource(const KrSaveResourceInfo* saveResourceInfo);
+
+    KRResource* loadResource(const std::string &file_name, KRDataBlock *data);
+    
     
     KRBundleManager *getBundleManager();
     KRSceneManager *getSceneManager();
     KRTextureManager *getTextureManager();
     KRMaterialManager *getMaterialManager();
-    KRShaderManager *getShaderManager();
+    KRPipelineManager *getPipelineManager();
     KRMeshManager *getMeshManager();
     KRAnimationManager *getAnimationManager();
     KRAnimationCurveManager *getAnimationCurveManager();
     KRAudioManager *getAudioManager();
     KRUnknownManager *getUnknownManager();
+    KRShaderManager *getShaderManager();
+    KRSourceManager *getSourceManager();
     
     KRCamera *createCamera(int width, int height);
     
@@ -106,12 +117,17 @@ private:
     KRSceneManager *m_pSceneManager;
     KRTextureManager *m_pTextureManager;
     KRMaterialManager *m_pMaterialManager;
-    KRShaderManager *m_pShaderManager;
+    KRPipelineManager *m_pPipelineManager;
     KRMeshManager *m_pMeshManager;
     KRAnimationManager *m_pAnimationManager;
     KRAnimationCurveManager *m_pAnimationCurveManager;
     KRAudioManager *m_pSoundManager;
     KRUnknownManager *m_pUnknownManager;
+    KRShaderManager *m_pShaderManager;
+    KRSourceManager *m_pSourceManager;
+
+    KRResource** m_resourceMap;
+    size_t m_resourceMapSize;
     
     void detectExtensions();
     bool m_bDetectedExtensions;
@@ -132,8 +148,9 @@ private:
     static void *s_log_callback_user_data;
     
     KRStreamer m_streamer;
+    VkInstance m_vulkanInstance;
     
-    static void createDeviceContexts();
+    void createDeviceContexts();
     void destroyDeviceContexts();
 };
 

kraken/KRContext_osx.mm

@@ -20,7 +20,7 @@ void KRContext::destroyDeviceContexts()
   gRenderContext = nil;
 }
 
-void KRContext::createDeviceContexts()
+void createGLDeviceContexts()
 {
     if(gRenderContext == nil) {
         
@@ -63,20 +63,20 @@ void KRContext::createDeviceContexts()
 
 void KRContext::activateStreamerContext()
 {
-    createDeviceContexts();
+    createGLDeviceContexts();
     [gStreamerContext makeCurrentContext];
 }
 
 void KRContext::activateRenderContext()
 {
-    createDeviceContexts();
+    createGLDeviceContexts();
     [gRenderContext update];
     [gRenderContext makeCurrentContext];
 }
 
 void KRContext::attachToView(void *view)
 {
-    createDeviceContexts();
+    createGLDeviceContexts();
     NSView *v = (NSView *)view;
     [gRenderContext setView: v];
     [gRenderContext update];

kraken/KRDSP_slow.cpp

@@ -54,7 +54,7 @@ void FFTWorkspace::create(size_t length)
   cos_table = new float[size];
   sin_table = new float[size];
   for (int i = 0; i < size / 2; i++) {
-    float a = 2.0f * M_PI * i / length;
+    float a = 2.0f * (float)M_PI * i / length;
     cos_table[i] = cos(a);
     sin_table[i] = sin(a);
   }
@@ -80,14 +80,14 @@ void FFTForward(const FFTWorkspace &workspace, SplitComplex *src, size_t count)
   // Only power-of-two sizes supported
   assert((count & (count - 1)) == 0);
 
-  int levels = 0;
+  unsigned int levels = 0;
-  while (1 << levels <= count) {
+  while (1 << levels <= (int)count) {
     levels++;
   }
 
   for (size_t i = 0; i < count; i++) {
     size_t j = 0;
-    for (int k = 0; k < levels; k++) {
+    for (int k = 0; k < (int)levels; k++) {
       j <<= 1;
       j |= ((i >> k) & 1);
     }

kraken/KRDataBlock.cpp

@@ -35,6 +35,10 @@
 #include "KRContext.h"
 
 #include <errno.h>
+#if defined(__APPLE__) || defined(ANDROID)
+#include <unistd.h>
+#include <sys/mman.h>
+#endif
 
 #define KRAKEN_MEM_ROUND_DOWN_PAGE(x) ((x) & ~(KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY - 1))
 #define KRAKEN_MEM_ROUND_UP_PAGE(x) ((((x) - 1) & ~(KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY - 1)) + KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY)
@@ -91,7 +95,10 @@ void KRDataBlock::unload()
 
 #if defined(_WIN32) || defined(_WIN64)
     if (m_hPackFile != INVALID_HANDLE_VALUE) {
+      // Memory mapped file
+      if (m_fileOwnerDataBlock == this) {
         CloseHandle(m_hPackFile);
+      }
       m_hPackFile = INVALID_HANDLE_VALUE;
     }
 #elif defined(__APPLE__)
@@ -136,7 +143,6 @@ bool KRDataBlock::load(const std::string &path)
     bool success = false;
     unload();
 
-    struct stat statbuf;
     m_bReadOnly = true;
 
 #if defined(_WIN32) || defined(_WIN64)
@@ -146,7 +152,7 @@ bool KRDataBlock::load(const std::string &path)
       m_fileName = KRResource::GetFileBase(path);
       FILE_STANDARD_INFO fileInfo;
       if(GetFileInformationByHandleEx(m_hPackFile, FileStandardInfo, &fileInfo, sizeof(fileInfo))) {
-        m_data_size = fileInfo.AllocationSize.QuadPart;
+        m_data_size = fileInfo.EndOfFile.QuadPart;
         m_data_offset = 0;
         success = true;
       }
@@ -156,6 +162,7 @@ bool KRDataBlock::load(const std::string &path)
     if(m_fdPackFile >= 0) {
       m_fileOwnerDataBlock = this;
       m_fileName = KRResource::GetFileBase(path);
+      struct stat statbuf;
       if(fstat(m_fdPackFile, &statbuf) >= 0) {
         m_data_size = statbuf.st_size;
         m_data_offset = 0;
@@ -177,9 +184,9 @@ KRDataBlock *KRDataBlock::getSubBlock(int start, int length)
 
     new_block->m_data_size = length;
 #if defined(_WIN32) || defined(_WIN64)
-    if(m_hPackFile) {
+    if(m_hPackFile != INVALID_HANDLE_VALUE) {
         new_block->m_hPackFile = m_hPackFile;
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
     if (m_fdPackFile) {
       new_block->m_fdPackFile = m_fdPackFile;
 #else
@@ -216,8 +223,8 @@ size_t KRDataBlock::getSize() const {
 void KRDataBlock::expand(size_t size)
 {
 #if defined(_WIN32) || defined(_WIN64)
-    if(m_data == NULL && m_hPackFile == 0) {
+    if(m_data == NULL && m_hPackFile == INVALID_HANDLE_VALUE) {
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
     if (m_data == NULL && m_fdPackFile == 0) {
 #else
 #error Unsupported
@@ -265,13 +272,13 @@ void KRDataBlock::append(void *data, size_t size) {
 
 // Copy the entire data block to the destination pointer
 void KRDataBlock::copy(void *dest) {
-    copy(dest, 0, m_data_size);
+    copy(dest, 0, (int)m_data_size);
 }
 
 // Copy a range of data to the destination pointer
 void KRDataBlock::copy(void *dest, int start, int count) {
 #if defined(_WIN32) || defined(_WIN64)
-  if (m_lockCount == 0 && m_hPackFile != 0) {
+  if (m_lockCount == 0 && m_hPackFile != INVALID_HANDLE_VALUE) {
     // Optimization: If we haven't mmap'ed or malloced the data already, pread() it directly from the file into the buffer
 
     LARGE_INTEGER distance;
@@ -290,7 +297,7 @@ void KRDataBlock::copy(void *dest, int start, int count) {
       bytes_remaining -= bytes_read;
     }
     assert(bytes_remaining == 0);
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
     if(m_lockCount == 0 && m_fdPackFile != 0) {
         // Optimization: If we haven't mmap'ed or malloced the data already, pread() it directly from the file into the buffer
         ssize_t r = pread(m_fdPackFile, dest, count, start + m_data_offset);
@@ -365,7 +372,7 @@ bool KRDataBlock::save(const std::string& path) {
 
   return success;
 
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
     int fdNewFile = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
     if(fdNewFile == -1) {
         return false;
@@ -410,6 +417,36 @@ std::string KRDataBlock::getString()
     return ret;
 }
 
+#if defined(_WIN32) || defined(_WIN64)
+void ReportWindowsLastError(LPCTSTR lpszFunction)
+{
+  LPVOID lpMsgBuf;
+  LPVOID lpDisplayBuf;
+  DWORD dw = GetLastError();
+
+  FormatMessage(
+    FORMAT_MESSAGE_ALLOCATE_BUFFER |
+    FORMAT_MESSAGE_FROM_SYSTEM |
+    FORMAT_MESSAGE_IGNORE_INSERTS,
+    NULL,
+    dw,
+    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+    (LPTSTR)&lpMsgBuf,
+    0, NULL);
+
+  // Display the error message and exit the process
+
+  lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
+  (lstrlen((LPCTSTR)lpMsgBuf) + lstrlen((LPCTSTR)lpszFunction) + 40) * sizeof(TCHAR));
+  fprintf(stderr,
+    TEXT("%s failed with error %d: %s\n"),
+    lpszFunction, dw, lpMsgBuf);
+
+  LocalFree(lpMsgBuf);
+  LocalFree(lpDisplayBuf);
+}
+#endif
+
 // Lock the memory, forcing it to be loaded into a contiguous block of address space
 void KRDataBlock::lock()
 {
@@ -417,8 +454,8 @@ void KRDataBlock::lock()
 
         // Memory mapped file; ensure data is mapped to ram
 #if defined(_WIN32) || defined(_WIN64)
-        if(m_hFileMapping) {
+        if(m_hPackFile != INVALID_HANDLE_VALUE) {
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
         if(m_fdPackFile) {
 #else
 #error Unsupported
@@ -432,11 +469,17 @@ void KRDataBlock::lock()
               assert(m_mmapData == NULL);
 #if defined(_WIN32) || defined(_WIN64)
               m_hFileMapping = CreateFileMappingFromApp(m_hPackFile, NULL, m_bReadOnly ? PAGE_READONLY : PAGE_READWRITE, m_data_size, NULL);
+              if(m_hFileMapping == NULL) {
+                ReportWindowsLastError("CreateFileMappingFromApp");
+              }
               assert(m_hFileMapping != NULL);
 
-              m_mmapData = MapViewOfFileFromApp(m_hPackFile, m_bReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, m_data_offset - alignment_offset, m_data_size + alignment_offset);
+              m_mmapData = MapViewOfFileFromApp(m_hFileMapping, m_bReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, m_data_offset - alignment_offset, m_data_size + alignment_offset);
+              if(m_mmapData == NULL) {
+                ReportWindowsLastError("MapViewOfFileFromApp");
+              }
               assert(m_mmapData != NULL);
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
                 //fprintf(stderr, "KRDataBlock::lock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount);
                 // Round m_data_offset down to the next memory page, as required by mmap
 
@@ -495,8 +538,8 @@ void KRDataBlock::unlock()
 
         // Memory mapped file; ensure data is unmapped from ram
 #if defined(_WIN32) || defined(_WIN64)
-        if (m_hPackFile) {
+        if (m_hPackFile != INVALID_HANDLE_VALUE) {
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
         if(m_fdPackFile) {
 #else
 #error Undefined
@@ -514,7 +557,7 @@ void KRDataBlock::unlock()
                   CloseHandle(m_hFileMapping);
                   m_hFileMapping = NULL;
                 }
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
                 munmap(m_mmapData, m_data_size);
 #else
 #error Undefined

kraken/KRDataBlock.h

@@ -106,7 +106,7 @@ private:
 #if defined(_WIN32) || defined(_WIN64)
     HANDLE m_hPackFile;
     HANDLE m_hFileMapping;
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(ANDROID)
     int m_fdPackFile;
 #endif
     

kraken/KRDirectionalLight.cpp

@@ -9,7 +9,7 @@
 #include "KREngine-common.h"
 
 #include "KRDirectionalLight.h"
-#include "KRShader.h"
+#include "KRPipeline.h"
 #include "KRContext.h"
 #include "assert.h"
 #include "KRStockGeometry.h"
@@ -109,12 +109,12 @@ void KRDirectionalLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &
         light_direction_view_space = Matrix4::Dot(matModelViewInverseTranspose, light_direction_view_space);
         light_direction_view_space.normalize();
         
-        KRShader *pShader = getContext().getShaderManager()->getShader("light_directional", pCamera, std::vector<KRPointLight *>(), this_light, std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+        KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("light_directional", pCamera, std::vector<KRPointLight *>(), this_light, std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
-        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), std::vector<KRPointLight *>(), this_light, std::vector<KRSpotLight *>(), 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, getModelMatrix(), std::vector<KRPointLight *>(), this_light, std::vector<KRSpotLight *>(), 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             
-            pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE, light_direction_view_space);
+            pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE, light_direction_view_space);
-            pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_COLOR, m_color);
+            pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_COLOR, m_color);
-            pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f);
+            pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f);
             
             // Disable z-buffer write
             GLDEBUG(glDepthMask(GL_FALSE));

kraken/KREngine-common.h

@@ -47,10 +47,6 @@ using namespace kraken;
 
 #endif
 
-#include <boost/tokenizer.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/signals2/mutex.hpp>
-
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -103,7 +99,20 @@ using std::unordered_map;
 using std::unordered_multimap;
 using std::hash;
 
-#if defined(_WIN32) || defined(_WIN64)
+#include <vulkan/vulkan.h>
+#if defined(ANDROID)
+#include <GLES3/gl3.h>
+#include <GLES3/gl3ext.h>
+// OpenGL ES 2.0 mapping to OpenGL ES 3.2
+#define glDeleteQueriesEXT glDeleteQueries
+#define glGenQueriesEXT glGenQueries
+#define glBeginQueryEXT glBeginQuery
+#define glEndQueryEXT glEndQuery
+#define glGetQueryObjectuivEXT glGetQueryObjectuiv
+#define glTexStorage2DEXT glTexStorage2D
+#define GL_ANY_SAMPLES_PASSED_EXT GL_ANY_SAMPLES_PASSED
+#define GL_QUERY_RESULT_EXT GL_QUERY_RESULT
+#elif defined(_WIN32) || defined(_WIN64)
 
 #include <mutex>
 #include <cstdint>

kraken/KREngine.mm

@@ -732,7 +732,7 @@ void kraken::set_debug_text(const std::string &print_text)
 -(void) setSunTemperature:(float)t
 {
     float i = [self getSunIntensity];
-    _settings.light_intensity = Vector3(
+    _settings.light_intensity.init(
         (t < 0.5f ? t * 2.0f : 1.0f) * i,
         (t < 0.5f ? t * 2.0f : (1.0f - t) * 2.0f) * i,
         (t < 0.5f ? 1.0f : (1.0f - t) * 2.0f) * i
@@ -742,7 +742,7 @@ void kraken::set_debug_text(const std::string &print_text)
 -(void) setSunIntensity:(float)i
 {
     float t = [self getSunTemperature];
-    _settings.light_intensity = Vector3(
+    _settings.light_intensity.init(
         (t < 0.5f ? t * 2.0f : 1.0f) * i,
         (t < 0.5f ? t * 2.0f : (1.0f - t) * 2.0f) * i,
         (t < 0.5f ? 1.0f : (1.0f - t) * 2.0f) * i
@@ -778,7 +778,7 @@ void kraken::set_debug_text(const std::string &print_text)
 -(void) setAmbientTemperature:(float)t
 {
     float i = [self getAmbientIntensity];
-    _settings.ambient_intensity = Vector3(
+    _settings.ambient_intensity.init(
         (t < 0.5f ? t * 2.0f : 1.0f) * i,
         (t < 0.5f ? t * 2.0f : (1.0f - t) * 2.0f) * i,
         (t < 0.5f ? 1.0f : (1.0f - t) * 2.0f) * i
@@ -788,7 +788,7 @@ void kraken::set_debug_text(const std::string &print_text)
 -(void) setAmbientIntensity:(float)i
 {
     float t = [self getAmbientTemperature];
-    _settings.ambient_intensity = Vector3(
+    _settings.ambient_intensity.init(
         (t < 0.5f ? t * 2.0f : 1.0f) * i,
         (t < 0.5f ? t * 2.0f : (1.0f - t) * 2.0f) * i,
         (t < 0.5f ? 1.0f : (1.0f - t) * 2.0f) * i

kraken/KRHelpers.h

@@ -4,10 +4,14 @@
 #include "vector2.h"
 #include "vector3.h"
 #include "matrix4.h"
+#include <string>
 
-#if defined(_WIN32) || defined(_WIN64)
+#if defined(ANDROID)
+#include <GLES3/gl3.h>
+#include <GLES3/gl3ext.h>
+#elif defined(_WIN32) || defined(_WIN64)
 #include <glad/glad.h>
-#elif defined(__linux__) || defined(__unix__) || defined(__posix__)
+#elif (defined(__linux__) || defined(__unix__) || defined(__posix__))
 #include <GL/gl.h>
 #include <GL/glu.h>
 #include <GL/glext.h>

kraken/KRLODGroup.cpp

@@ -121,12 +121,12 @@ KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport &viewport)
         if(m_use_world_units) {
             Vector3 world_reference_point = localToWorld(local_reference_point);
             sqr_distance = (world_camera_position - world_reference_point).sqrMagnitude() * (lod_bias * lod_bias);
-            sqr_prestream_distance = getContext().KRENGINE_PRESTREAM_DISTANCE * getContext().KRENGINE_PRESTREAM_DISTANCE;
+            sqr_prestream_distance = (float)(getContext().KRENGINE_PRESTREAM_DISTANCE * getContext().KRENGINE_PRESTREAM_DISTANCE);
         } else {
             sqr_distance = (local_camera_position - local_reference_point).sqrMagnitude() * (lod_bias * lod_bias);
             
             Vector3 world_reference_point = localToWorld(local_reference_point);
-            sqr_prestream_distance = worldToLocal(Vector3::Normalize(world_reference_point - world_camera_position) * getContext().KRENGINE_PRESTREAM_DISTANCE).sqrMagnitude(); // TODO, FINDME - Optimize with precalc?
+            sqr_prestream_distance = worldToLocal(Vector3::Normalize(world_reference_point - world_camera_position) * (float)getContext().KRENGINE_PRESTREAM_DISTANCE).sqrMagnitude(); // TODO, FINDME - Optimize with precalc?
             
         }
         

kraken/KRLight.cpp

@@ -14,8 +14,8 @@
 #include "KRCamera.h"
 #include "KRContext.h"
 
-#include "KRShaderManager.h"
+#include "KRPipelineManager.h"
-#include "KRShader.h"
+#include "KRPipeline.h"
 #include "KRStockGeometry.h"
 #include "KRDirectionalLight.h"
 #include "KRSpotLight.h"
@@ -191,7 +191,7 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
                 
                 float particle_range = 600.0f;
                 
-                int particle_count = m_dust_particle_density * pow(particle_range, 3);
+                int particle_count = (int)(m_dust_particle_density * pow(particle_range, 3));
                 if(particle_count > KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES) particle_count = KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES;
                 
                 // Enable z-buffer test
@@ -218,13 +218,13 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
                     this_point_light.push_back(point_light);
                 }
                 
-                KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+                KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline("dust_particle", pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
                 
-                if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, particleModelMatrix, this_point_light, this_directional_light, this_spot_light, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+                if(getContext().getPipelineManager()->selectPipeline(*pCamera, pParticleShader, viewport, particleModelMatrix, this_point_light, this_directional_light, this_spot_light, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
                     
-                    pParticleShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_COLOR, m_color * pCamera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity);
+                    pParticleShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_COLOR, m_color * pCamera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity);
-                    pParticleShader->setUniform(KRShader::KRENGINE_UNIFORM_PARTICLE_ORIGIN, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero()));
+                    pParticleShader->setUniform(KRPipeline::KRENGINE_UNIFORM_PARTICLE_ORIGIN, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero()));
-                    pParticleShader->setUniform(KRShader::KRENGINE_UNIFORM_FLARE_SIZE, m_dust_particle_size);
+                    pParticleShader->setUniform(KRPipeline::KRENGINE_UNIFORM_FLARE_SIZE, m_dust_particle_size);
                     
                     KRDataBlock particle_index_data;
                     m_pContext->getMeshManager()->bindVBO(m_pContext->getMeshManager()->getRandomParticles(), particle_index_data, (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA), true, 1.0f);
@@ -254,17 +254,17 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
             this_point_light.push_back(point_light);
         }
         
-        KRShader *pFogShader = m_pContext->getShaderManager()->getShader(shader_name, pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_ADDITIVE_PARTICLES);
+        KRPipeline *pFogShader = m_pContext->getPipelineManager()->getPipeline(shader_name, pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_ADDITIVE_PARTICLES);
         
-        if(getContext().getShaderManager()->selectShader(*pCamera, pFogShader, viewport, Matrix4(), this_point_light, this_directional_light, this_spot_light, 0, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pFogShader, viewport, Matrix4(), this_point_light, this_directional_light, this_spot_light, 0, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             int slice_count = (int)(pCamera->settings.volumetric_environment_quality * 495.0) + 5;
             
             float slice_near = -pCamera->settings.getPerspectiveNearZ();
             float slice_far = -pCamera->settings.volumetric_environment_max_distance;
             float slice_spacing = (slice_far - slice_near) / slice_count;
             
-            pFogShader->setUniform(KRShader::KRENGINE_UNIFORM_SLICE_DEPTH_SCALE, Vector2::Create(slice_near, slice_spacing));
+            pFogShader->setUniform(KRPipeline::KRENGINE_UNIFORM_SLICE_DEPTH_SCALE, Vector2::Create(slice_near, slice_spacing));
-            pFogShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_COLOR, (m_color * pCamera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f));
+            pFogShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_COLOR, (m_color * pCamera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f));
             
             KRDataBlock index_data;
             m_pContext->getMeshManager()->bindVBO(m_pContext->getMeshManager()->getVolumetricLightingVertexes(), index_data, (1 << KRMesh::KRENGINE_ATTRIB_VERTEX), true, 1.0f);
@@ -284,10 +284,10 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
                 occlusion_test_sphere_matrix *= m_parentNode->getModelMatrix();
             }
 
-            if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, occlusion_test_sphere_matrix, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+            if(getContext().getPipelineManager()->selectPipeline("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, occlusion_test_sphere_matrix, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
 
                 GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery));
-#if TARGET_OS_IPHONE
+#if TARGET_OS_IPHONE || defined(ANDROID)
                 GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery));
 #else
                 GLDEBUG(glBeginQuery(GL_SAMPLES_PASSED, m_occlusionQuery));
@@ -300,7 +300,7 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
                     }
                 }
 
-#if TARGET_OS_IPHONE
+#if TARGET_OS_IPHONE || defined(ANDROID)
                 GLDEBUG(glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT));
 #else
                 GLDEBUG(glEndQuery(GL_SAMPLES_PASSED));
@@ -330,11 +330,11 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_light
                         GLDEBUG(glDepthRangef(0.0, 1.0));
                         
                         // Render light flare on transparency pass
-                        KRShader *pShader = getContext().getShaderManager()->getShader("flare", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+                        KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("flare", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
 
-                        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+                        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
-                            pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_ALPHA, 1.0f);
+                            pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_ALPHA, 1.0f);
-                            pShader->setUniform(KRShader::KRENGINE_UNIFORM_FLARE_SIZE, m_flareSize);
+                            pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_FLARE_SIZE, m_flareSize);
                             m_pContext->getTextureManager()->selectTexture(0, m_pFlareTexture, 0.0f, KRTexture::TEXTURE_USAGE_LIGHT_FLARE);
                             m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f);
                             GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
@@ -384,7 +384,7 @@ void KRLight::allocateShadowBuffers(int cBuffers) {
             GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_EXT, GL_COMPARE_REF_TO_TEXTURE_EXT)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available
             GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_EXT, GL_LEQUAL)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available
 #endif
-            GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, viewportSize.x, viewportSize.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL));
+            GLDEBUG(glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, (GLsizei)viewportSize.x, (GLsizei)viewportSize.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL));
             
             GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowDepthTexture[iShadow], 0));
         }
@@ -421,12 +421,12 @@ void KRLight::renderShadowBuffers(KRCamera *pCamera)
             GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, shadowFramebuffer[iShadow]));
             GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowDepthTexture[iShadow], 0));
             
-            GLDEBUG(glViewport(0, 0, m_shadowViewports[iShadow].getSize().x, m_shadowViewports[iShadow].getSize().y));
+            GLDEBUG(glViewport(0, 0, (GLsizei)m_shadowViewports[iShadow].getSize().x, (GLsizei)m_shadowViewports[iShadow].getSize().y));
             
             GLDEBUG(glClearDepthf(0.0f));
             GLDEBUG(glClear(GL_DEPTH_BUFFER_BIT));
             
-            GLDEBUG(glViewport(1, 1, m_shadowViewports[iShadow].getSize().x - 2, m_shadowViewports[iShadow].getSize().y - 2));
+            GLDEBUG(glViewport(1, 1, (GLsizei)m_shadowViewports[iShadow].getSize().x - 2, (GLsizei)m_shadowViewports[iShadow].getSize().y - 2));
 
             GLDEBUG(glClearDepthf(1.0f));
             
@@ -447,9 +447,9 @@ void KRLight::renderShadowBuffers(KRCamera *pCamera)
             GLDEBUG(glDisable(GL_BLEND));
             
             // Use shader program
-            KRShader *shadowShader = m_pContext->getShaderManager()->getShader("ShadowShader", pCamera, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+            KRPipeline *shadowShader = m_pContext->getPipelineManager()->getPipeline("ShadowShader", pCamera, std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
             
-            getContext().getShaderManager()->selectShader(*pCamera, shadowShader, m_shadowViewports[iShadow], Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_SHADOWMAP, Vector3::Zero(), 0.0f, Vector4::Zero());
+            getContext().getPipelineManager()->selectPipeline(*pCamera, shadowShader, m_shadowViewports[iShadow], Matrix4(), std::vector<KRPointLight *>(), std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, KRNode::RENDER_PASS_SHADOWMAP, Vector3::Zero(), 0.0f, Vector4::Zero());
             
             
             getScene().render(pCamera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], KRNode::RENDER_PASS_SHADOWMAP, true);

kraken/KRLocator.cpp

@@ -34,7 +34,22 @@ void KRLocator::loadXML(tinyxml2::XMLElement *e)
     KRNode::loadXML(e);
 }
 
-unordered_map<std::string, boost::variant<int, double, bool, std::string> > &KRLocator::getUserAttributes()
+unordered_map<std::string, int> &KRLocator::getUserIntAttributes()
 {
-    return m_userAttributes;
+    return m_userIntAttributes;
+}
+
+unordered_map<std::string, double> &KRLocator::getUserDoubleAttributes()
+{
+    return m_userDoubleAttributes;
+}
+
+unordered_map<std::string, bool> &KRLocator::getUserBoolAttributes()
+{
+    return m_userBoolAttributes;
+}
+
+unordered_map<std::string, std::string> &KRLocator::getUserStringAttributes()
+{
+    return m_userStringAttributes;
 }

kraken/KRLocator.h

@@ -13,8 +13,6 @@
 #include "KRNode.h"
 #include "KRTexture.h"
 
-#include "boost/variant.hpp"
-
 class KRLocator : public KRNode {
 public:
     KRLocator(KRScene &scene, std::string name);
@@ -22,10 +20,16 @@ public:
     virtual std::string getElementName();
     virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent);
     virtual void loadXML(tinyxml2::XMLElement *e);
-    unordered_map<std::string, boost::variant<int, double, bool, std::string> > &getUserAttributes();
+    unordered_map<std::string, int> &getUserIntAttributes();
+    unordered_map<std::string, double> &getUserDoubleAttributes();
+    unordered_map<std::string, bool> &getUserBoolAttributes();
+    unordered_map<std::string, std::string> &getUserStringAttributes();
     
 private:
-    unordered_map<std::string, boost::variant<int, double, bool, std::string> > m_userAttributes;
+    unordered_map<std::string, int> m_userIntAttributes;
+    unordered_map<std::string, double> m_userDoubleAttributes;
+    unordered_map<std::string, bool> m_userBoolAttributes;
+    unordered_map<std::string, std::string> m_userStringAttributes;
 };
 
 

kraken/KRMaterial.cpp

@@ -319,16 +319,16 @@ bool KRMaterial::bind(KRCamera *pCamera, std::vector<KRPointLight *> &point_ligh
     bool bAlphaTest = (m_alpha_mode == KRMATERIAL_ALPHA_MODE_TEST) && bDiffuseMap;
     bool bAlphaBlend = (m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDONESIDE) || (m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE);
     
-    KRShader *pShader = getContext().getShaderManager()->getShader("ObjectShader", pCamera, point_lights, directional_lights, spot_lights, bones.size(), bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_normalMapScale != default_scale && bNormalMap, m_reflectionMapScale != default_scale && bReflectionMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_normalMapOffset != default_offset && bNormalMap, m_reflectionMapOffset != default_offset && bReflectionMap, bAlphaTest, bAlphaBlend, renderPass, rim_power != 0.0f);
+    KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("ObjectShader", pCamera, point_lights, directional_lights, spot_lights, (int)bones.size(), bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_normalMapScale != default_scale && bNormalMap, m_reflectionMapScale != default_scale && bReflectionMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_normalMapOffset != default_offset && bNormalMap, m_reflectionMapOffset != default_offset && bReflectionMap, bAlphaTest, bAlphaBlend, renderPass, rim_power != 0.0f);
 
     
     Vector4 fade_color;
-    if(!getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, matModel, point_lights, directional_lights, spot_lights, 0, renderPass, rim_color, rim_power, fade_color)) {
+    if(!getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, matModel, point_lights, directional_lights, spot_lights, 0, renderPass, rim_color, rim_power, fade_color)) {
         return false;
     }
     
     // Bind bones
-    if(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
+    if(pShader->m_uniforms[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
         GLfloat bone_mats[256 * 16];
         GLfloat *bone_mat_component = bone_mats;
         for(int bone_index=0; bone_index < bones.size(); bone_index++) {
@@ -355,40 +355,40 @@ bool KRMaterial::bind(KRCamera *pCamera, std::vector<KRPointLight *> &point_ligh
                 *bone_mat_component++ = t[i];
             }
         }
-        if(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
+        if(pShader->m_uniforms[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
-            glUniformMatrix4fv(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_BONE_TRANSFORMS], bones.size(), GL_FALSE, bone_mats);
+            glUniformMatrix4fv(pShader->m_uniforms[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS], (GLsizei)bones.size(), GL_FALSE, bone_mats);
         }
     }
 
     
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_AMBIENT, m_ambientColor + pCamera->settings.ambient_intensity);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_AMBIENT, m_ambientColor + pCamera->settings.ambient_intensity);
     
     if(renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
         // We pre-multiply the light color with the material color in the forward renderer
-        pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, Vector3::Create(m_diffuseColor.x * pCamera->settings.light_intensity.x, m_diffuseColor.y * pCamera->settings.light_intensity.y, m_diffuseColor.z * pCamera->settings.light_intensity.z));
+        pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, Vector3::Create(m_diffuseColor.x * pCamera->settings.light_intensity.x, m_diffuseColor.y * pCamera->settings.light_intensity.y, m_diffuseColor.z * pCamera->settings.light_intensity.z));
     } else {
-        pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, m_diffuseColor);
+        pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, m_diffuseColor);
     }
     
     if(renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
         // We pre-multiply the light color with the material color in the forward renderer
-        pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR, Vector3::Create(m_specularColor.x * pCamera->settings.light_intensity.x, m_specularColor.y * pCamera->settings.light_intensity.y, m_specularColor.z * pCamera->settings.light_intensity.z));
+        pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_SPECULAR, Vector3::Create(m_specularColor.x * pCamera->settings.light_intensity.x, m_specularColor.y * pCamera->settings.light_intensity.y, m_specularColor.z * pCamera->settings.light_intensity.z));
     } else {
-        pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR, m_specularColor);
+        pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_SPECULAR, m_specularColor);
     }
     
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_SHININESS, m_ns);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_SHININESS, m_ns);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_REFLECTION, m_reflectionColor);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_REFLECTION, m_reflectionColor);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE, m_diffuseMapScale);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE, m_diffuseMapScale);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE, m_specularMapScale);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE, m_specularMapScale);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE, m_reflectionMapScale);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE, m_reflectionMapScale);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_SCALE, m_normalMapScale);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_NORMALTEXTURE_SCALE, m_normalMapScale);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET, m_diffuseMapOffset);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET, m_diffuseMapOffset);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET, m_specularMapOffset);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET, m_specularMapOffset);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET, m_reflectionMapOffset);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET, m_reflectionMapOffset);
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET, m_normalMapOffset);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET, m_normalMapOffset);
 
-    pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_tr);
+    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_tr);
     
     if(bDiffuseMap) {
         m_pContext->getTextureManager()->selectTexture(0, m_pDiffuseMap, lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);

kraken/KRMaterial.h

@@ -32,8 +32,8 @@
 #include "KREngine-common.h"
 
 #include "KRTexture.h"
-#include "KRShaderManager.h"
+#include "KRPipelineManager.h"
-#include "KRShader.h"
+#include "KRPipeline.h"
 #include "KRCamera.h"
 #include "KRResource.h"
 #include "KRScene.h"

kraken/KRMaterialManager.cpp

@@ -33,16 +33,34 @@
 #include "KRMaterialManager.h"
 
 
-KRMaterialManager::KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRShaderManager *pShaderManager) : KRContextObject(context)
+KRMaterialManager::KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRPipelineManager *pPipelineManager) : KRResourceManager(context)
 {
     m_pTextureManager = pTextureManager;
-    m_pShaderManager = pShaderManager;
+    m_pPipelineManager = pPipelineManager;
 }
 
 KRMaterialManager::~KRMaterialManager() {
 
 }
 
+KRResource* KRMaterialManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("mtl") == 0) {
+    return load(name.c_str(), data);
+  }
+  return nullptr;
+}
+
+KRResource* KRMaterialManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("mtl") == 0) {
+    // TODO - This is not correct -- there are multiple materials emitted in a single mtl file.
+    //        We should treat "mtl" files as source files, managed by KRSource, which output
+    //        material resources when compiled.
+    return m_materials[name];
+  }
+  return nullptr;
+}
 
 unordered_map<std::string, KRMaterial *> &KRMaterialManager::getMaterials()
 {
@@ -97,7 +115,7 @@ void KRMaterialManager::add(KRMaterial *new_material) {
     m_materials[lowerName] = new_material;
 }
 
-bool KRMaterialManager::load(const char *szName, KRDataBlock *data) {
+KRMaterial* KRMaterialManager::load(const char *szName, KRDataBlock *data) {
     KRMaterial *pMaterial = NULL;
     char szSymbol[16][256];
     data->lock();
@@ -284,5 +302,5 @@ bool KRMaterialManager::load(const char *szName, KRDataBlock *data) {
     }
     data->unlock();
     delete data;
-    return true;
+    return pMaterial;
 }

kraken/KRMaterialManager.h

@@ -32,11 +32,10 @@
 #ifndef KRMATERIALMANAGER_H
 #define KRMATERIALMANAGER_H
 
-
-
-
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRMaterial.h"
 #include "KRTextureManager.h"
 #include "KRMaterialManager.h"
@@ -44,12 +43,15 @@
 
 using std::map;
 
-class KRMaterialManager : public KRContextObject {
+class KRMaterialManager : public KRResourceManager {
 public:
-    KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRShaderManager *pShaderManager);
+    KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRPipelineManager *pPipelineManager);
     virtual ~KRMaterialManager();
 
-    bool load(const char *szName, KRDataBlock *data);
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
+    KRMaterial* load(const char *szName, KRDataBlock *data);
     void add(KRMaterial *new_material);
     KRMaterial *getMaterial(const std::string &name);
     
@@ -61,7 +63,7 @@ public:
 private:
     unordered_map<std::string, KRMaterial *> m_materials;
     KRTextureManager *m_pTextureManager;
-    KRShaderManager *m_pShaderManager;
+    KRPipelineManager *m_pPipelineManager;
 
 };
 

kraken/KRMesh.cpp

@@ -34,8 +34,8 @@
 
 #include "KRMesh.h"
 
-#include "KRShader.h"
+#include "KRPipeline.h"
-#include "KRShaderManager.h"
+#include "KRPipelineManager.h"
 #include "KRContext.h"
 #include "../3rdparty/forsyth/forsyth.h"
 
@@ -61,9 +61,11 @@ KRMesh::KRMesh(KRContext &context, std::string name, KRDataBlock *data) : KRReso
     loadPack(data);
 }
 
-void KRMesh::setName(const std::string name) {
+
-    m_lodCoverage = 100;
+void KRMesh::parseName(const std::string& name, std::string& lodBaseName, int& lodCoverage)
-    m_lodBaseName = name;
+{
+  lodCoverage = 100;
+  lodBaseName = name;
 
   size_t last_underscore_pos = name.find_last_of('_');
   if (last_underscore_pos != std::string::npos) {
@@ -74,12 +76,17 @@ void KRMesh::setName(const std::string name) {
       char* end = NULL;
       int c = (int)strtol(lod_level_string.c_str(), &end, 10);
       if (c >= 0 && c <= 100 && *end == '\0') {
-                m_lodCoverage = c;
+        lodCoverage = c;
-                m_lodBaseName = name.substr(0, last_underscore_pos);
+        lodBaseName = name.substr(0, last_underscore_pos);
+      }
     }
   }
 }
 
+void KRMesh::setName(const std::string name) {
+  parseName(name, m_lodBaseName, m_lodCoverage);
+  m_lodCoverage = 100;
+  m_lodBaseName = name;
 }
 
 int KRMesh::GetLODCoverage(const std::string &name)
@@ -196,7 +203,7 @@ void KRMesh::preStream(float lodCoverage)
         (*mat_itr)->preStream(lodCoverage);
     }
     
-    int cSubmeshes = m_submeshes.size();
+    int cSubmeshes = (int)m_submeshes.size();
     for(int iSubmesh=0; iSubmesh<cSubmeshes; iSubmesh++) {
         for(auto vbo_data_itr = m_submeshes[iSubmesh]->vbo_data_blocks.begin(); vbo_data_itr != m_submeshes[iSubmesh]->vbo_data_blocks.end(); vbo_data_itr++) {
             (*vbo_data_itr)->resetPoolExpiry(lodCoverage);
@@ -210,7 +217,7 @@ void KRMesh::load()
     getSubmeshes();
     getMaterials();
     
-    int cSubmeshes = m_submeshes.size();
+    int cSubmeshes = (int)m_submeshes.size();
     for(int iSubmesh=0; iSubmesh<cSubmeshes; iSubmesh++) {
         for(auto vbo_data_itr = m_submeshes[iSubmesh]->vbo_data_blocks.begin(); vbo_data_itr != m_submeshes[iSubmesh]->vbo_data_blocks.end(); vbo_data_itr++) {
             (*vbo_data_itr)->resetPoolExpiry(1.0f);
@@ -230,7 +237,7 @@ kraken_stream_level KRMesh::getStreamLevel()
     }
     bool all_vbo_data_loaded = true;
     bool vbo_data_loaded = false;
-    int cSubmeshes = m_submeshes.size();
+    int cSubmeshes = (int)m_submeshes.size();
     for(int iSubmesh=0; iSubmesh<cSubmeshes; iSubmesh++) {
         for(auto vbo_data_itr = m_submeshes[iSubmesh]->vbo_data_blocks.begin(); vbo_data_itr != m_submeshes[iSubmesh]->vbo_data_blocks.end(); vbo_data_itr++) {
             if((*vbo_data_itr)->isVBOReady()) {
@@ -260,7 +267,7 @@ void KRMesh::render(const std::string &object_name, KRCamera *pCamera, std::vect
             getSubmeshes();
             getMaterials();
             
-            int cSubmeshes = m_submeshes.size();
+            int cSubmeshes = (int)m_submeshes.size();
             if(renderPass == KRNode::RENDER_PASS_SHADOWMAP) {
                 for(int iSubmesh=0; iSubmesh<cSubmeshes; iSubmesh++) {
                     KRMaterial *pMaterial = m_materials[iSubmesh];
@@ -283,7 +290,7 @@ void KRMesh::render(const std::string &object_name, KRCamera *pCamera, std::vect
                         if(pMaterial != NULL && pMaterial == (*mat_itr)) {
                             if((!pMaterial->isTransparent() && renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) {
                                 std::vector<Matrix4> bone_bind_poses;
-                                for(int i=0; i < bones.size(); i++) {
+                                for(int i=0; i < (int)bones.size(); i++) {
                                     bone_bind_poses.push_back(getBoneBindPose(i));
                                 }
                                 if(pMaterial->bind(pCamera, point_lights, directional_lights, spot_lights, bones, bone_bind_poses, viewport, matModel, pLightMap, renderPass, rim_color, rim_power, lod_coverage)) {
@@ -352,13 +359,13 @@ void KRMesh::getSubmeshes() {
 
 void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t)
 {
-    int cSubmeshes = m_submeshes.size();
+    int cSubmeshes = (int)m_submeshes.size();
     for(int iSubmesh=0; iSubmesh < cSubmeshes; iSubmesh++) {
     
         Submesh *pSubmesh = m_submeshes[iSubmesh];
         int cVertexes = pSubmesh->vertex_count;
-        int vertex_data_offset = getVertexDataOffset();
+        int vertex_data_offset =(int)getVertexDataOffset();
-        int index_data_offset = getIndexDataOffset();
+        int index_data_offset = (int)getIndexDataOffset();
         pack_header *pHeader = getHeader();
         int32_t vertex_attrib_flags = pHeader->vertex_attrib_flags;
         int32_t vertex_count = pHeader->vertex_count;
@@ -373,7 +380,7 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t)
                 int start_index_offset, start_vertex_offset, index_count, vertex_count;
                 getIndexedRange(index_group++, start_index_offset, start_vertex_offset, index_count, vertex_count);
                 
-                if(m_submeshes[iSubmesh]->vertex_data_blocks.size() <= vbo_index) {
+                if((int)m_submeshes[iSubmesh]->vertex_data_blocks.size() <= vbo_index) {
                     KRDataBlock *vertex_data_block = m_pData->getSubBlock(vertex_data_offset + start_vertex_offset * m_vertex_size, vertex_count * m_vertex_size);
                     KRDataBlock *index_data_block = m_pData->getSubBlock(index_data_offset + start_index_offset * 2, index_count * 2);
                     KRMeshManager::KRVBOData *vbo_data_block = new KRMeshManager::KRVBOData(getContext().getMeshManager(), *vertex_data_block, *index_data_block, vertex_attrib_flags, true, t);
@@ -399,7 +406,7 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t)
                 GLsizei cBufferVertexes = iBuffer < cBuffers - 1 ? MAX_VBO_SIZE : vertex_count % MAX_VBO_SIZE;
                 int vertex_size = m_vertex_size;
                 
-                if(m_submeshes[iSubmesh]->vertex_data_blocks.size() <= vbo_index) {
+                if((int)m_submeshes[iSubmesh]->vertex_data_blocks.size() <= vbo_index) {
                     KRDataBlock *index_data_block = NULL;
                     KRDataBlock *vertex_data_block = m_pData->getSubBlock(vertex_data_offset + iBuffer * MAX_VBO_SIZE * vertex_size, vertex_size * cBufferVertexes);
                     KRMeshManager::KRVBOData *vbo_data_block = new KRMeshManager::KRVBOData(getContext().getMeshManager(), *vertex_data_block, *index_data_block, vertex_attrib_flags, true, t);
@@ -630,8 +637,8 @@ void KRMesh::LoadData(const KRMesh::mesh_info &mi, bool calculate_normals, bool
     
     bool bFirstVertex = true;
     
-    memset(getVertexData(), 0, m_vertex_size * mi.vertices.size());
+    memset(getVertexData(), 0, m_vertex_size * (int)mi.vertices.size());
-    for(int iVertex=0; iVertex < mi.vertices.size(); iVertex++) {
+    for(int iVertex=0; iVertex < (int)mi.vertices.size(); iVertex++) {
         Vector3 source_vertex = mi.vertices[iVertex];
         setVertexPosition(iVertex, source_vertex);
         if(mi.bone_names.size()) {
@@ -652,16 +659,16 @@ void KRMesh::LoadData(const KRMesh::mesh_info &mi, bool calculate_normals, bool
             if(source_vertex.y > m_maxPoint.y) m_maxPoint.y = source_vertex.y;
             if(source_vertex.z > m_maxPoint.z) m_maxPoint.z = source_vertex.z;
         }
-        if(mi.uva.size() > iVertex) {
+        if((int)mi.uva.size() > iVertex) {
             setVertexUVA(iVertex, mi.uva[iVertex]);
         }
-        if(mi.uvb.size() > iVertex) {
+        if((int)mi.uvb.size() > iVertex) {
             setVertexUVB(iVertex, mi.uvb[iVertex]);
         }
-        if(mi.normals.size() > iVertex) {
+        if((int)mi.normals.size() > iVertex) {
             setVertexNormal(iVertex, Vector3::Normalize(mi.normals[iVertex]));
         }
-        if(mi.tangents.size() > iVertex) {
+        if((int)mi.tangents.size() > iVertex) {
             setVertexTangent(iVertex, Vector3::Normalize(mi.tangents[iVertex]));
         }
     }
@@ -690,7 +697,7 @@ void KRMesh::LoadData(const KRMesh::mesh_info &mi, bool calculate_normals, bool
         //cout << "  Calculate surface normals and tangents\n";
         if(calculate_normals || calculate_tangents) {
             // NOTE: This will not work properly if the vertices are already indexed
-            for(int iVertex=0; iVertex < mi.vertices.size(); iVertex+= 3) {
+            for(int iVertex=0; iVertex < (int)mi.vertices.size(); iVertex+= 3) {
                 Vector3 p1 = getVertexPosition(iVertex);
                 Vector3 p2 = getVertexPosition(iVertex+1);
                 Vector3 p3 = getVertexPosition(iVertex+2);
@@ -723,7 +730,7 @@ void KRMesh::LoadData(const KRMesh::mesh_info &mi, bool calculate_normals, bool
                         
                         Vector2 st1 = Vector2::Create(uv1.x - uv0.x, uv1.y - uv0.y);
                         Vector2 st2 = Vector2::Create(uv2.x - uv0.x, uv2.y - uv0.y);
-                        double coef = 1/ (st1.x * st2.y - st2.x * st1.y);
+                        float coef = 1/ (st1.x * st2.y - st2.x * st1.y);
                         
                         Vector3 tangent = Vector3::Create(
                                           coef * ((v1.x * st2.y)  + (v2.x * -st1.y)),
@@ -915,9 +922,9 @@ void KRMesh::setVertexPosition(int index, const Vector3 &v)
 {
     if(has_vertex_attribute(KRENGINE_ATTRIB_VERTEX_SHORT)) {
         short *vert = (short *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_VERTEX_SHORT]);
-        vert[0] = v.x * 32767.0f;
+        vert[0] = (short)(v.x * 32767.0f);
-        vert[1] = v.y * 32767.0f;
+        vert[1] = (short)(v.y * 32767.0f);
-        vert[2] = v.z * 32767.0f;
+        vert[2] = (short)(v.z * 32767.0f);
     } else if(has_vertex_attribute(KRENGINE_ATTRIB_VERTEX)) {
         float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_VERTEX]);
         vert[0] = v.x;
@@ -930,9 +937,9 @@ void KRMesh::setVertexNormal(int index, const Vector3 &v)
 {
     if(has_vertex_attribute(KRENGINE_ATTRIB_NORMAL_SHORT)) {
         short *vert = (short *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_NORMAL_SHORT]);
-        vert[0] = v.x * 32767.0f;
+        vert[0] = (short)(v.x * 32767.0f);
-        vert[1] = v.y * 32767.0f;
+        vert[1] = (short)(v.y * 32767.0f);
-        vert[2] = v.z * 32767.0f;
+        vert[2] = (short)(v.z * 32767.0f);
     } else if(has_vertex_attribute(KRENGINE_ATTRIB_NORMAL)) {
         float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_NORMAL]);
         vert[0] = v.x;
@@ -945,9 +952,9 @@ void KRMesh::setVertexTangent(int index, const Vector3 & v)
 {
     if(has_vertex_attribute(KRENGINE_ATTRIB_TANGENT_SHORT)) {
         short *vert = (short *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TANGENT_SHORT]);
-        vert[0] = v.x * 32767.0f;
+        vert[0] = (short)(v.x * 32767.0f);
-        vert[1] = v.y * 32767.0f;
+        vert[1] = (short)(v.y * 32767.0f);
-        vert[2] = v.z * 32767.0f;
+        vert[2] = (short)(v.z * 32767.0f);
     } else if(has_vertex_attribute(KRENGINE_ATTRIB_TANGENT)) {
         float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TANGENT]);
         vert[0] = v.x;
@@ -960,8 +967,8 @@ void KRMesh::setVertexUVA(int index, const Vector2 &v)
 {
     if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVA_SHORT)) {
         short *vert = (short *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVA_SHORT]);
-        vert[0] = v.x * 32767.0f;
+        vert[0] = (short)(v.x * 32767.0f);
-        vert[1] = v.y * 32767.0f;
+        vert[1] = (short)(v.y * 32767.0f);
     } else if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVA)) {
         float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVA]);
         vert[0] = v.x;
@@ -973,8 +980,8 @@ void KRMesh::setVertexUVB(int index, const Vector2 &v)
 {
     if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVB_SHORT)) {
         short *vert = (short *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVB_SHORT]);
-        vert[0] = v.x * 32767.0f;
+        vert[0] = (short)(v.x * 32767.0f);
-        vert[1] = v.y * 32767.0f;
+        vert[1] = (short)(v.y * 32767.0f);
     } else if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVB)) {
         float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVB]);
         vert[0] = v.x;
@@ -1053,15 +1060,15 @@ void KRMesh::updateAttributeOffsets()
 {
     pack_header *header = getHeader();
     int mask = 0;
-    for(int i=0; i < KRENGINE_NUM_ATTRIBUTES; i++) {
+    for(size_t i=0; i < KRENGINE_NUM_ATTRIBUTES; i++) {
         if(has_vertex_attribute((vertex_attrib_t)i)) {
-            m_vertex_attribute_offset[i] = VertexSizeForAttributes(header->vertex_attrib_flags & mask);
+            m_vertex_attribute_offset[i] = (int)VertexSizeForAttributes(header->vertex_attrib_flags & mask);
         } else {
             m_vertex_attribute_offset[i] = -1;
         }
         mask = (mask << 1) | 1;
     }
-    m_vertex_size = VertexSizeForAttributes(header->vertex_attrib_flags);
+    m_vertex_size = (int)VertexSizeForAttributes(header->vertex_attrib_flags);
 }
 
 size_t KRMesh::AttributeOffset(__int32_t vertex_attrib, __int32_t vertex_attrib_flags)
@@ -1310,10 +1317,10 @@ void KRMesh::convertToIndexed()
         if(submesh_index == 0 || vertex_index_offset + vertex_count > 0xffff) {
             mi.vertex_index_bases.push_back(std::pair<int, int>((int)mi.vertex_indexes.size(), (int)mi.vertices.size()));
             vertex_index_offset = 0;
-            vertex_index_base_start_vertex = mi.vertices.size();
+            vertex_index_base_start_vertex = (int)mi.vertices.size();
         }
         
-        mi.submesh_starts.push_back(mi.vertex_index_bases.size() - 1 + (vertex_index_offset << 16));
+        mi.submesh_starts.push_back((int)mi.vertex_index_bases.size() - 1 + (vertex_index_offset << 16));
         mi.submesh_lengths.push_back(vertexes_remaining);
         int source_index = getSubmesh(submesh_index)->start_vertex;
         
@@ -1400,7 +1407,7 @@ void KRMesh::convertToIndexed()
                 */
                 int found_index = -1;
                 if(prev_indexes.count(vertex_key) == 0) {
-                    found_index = mi.vertices.size() - vertex_index_base_start_vertex;
+                    found_index = (int)mi.vertices.size() - vertex_index_base_start_vertex;
                     if(has_vertex_attribute(KRENGINE_ATTRIB_VERTEX) || has_vertex_attribute(KRENGINE_ATTRIB_VERTEX_SHORT)) {
                         mi.vertices.push_back(vertex_position);
                     }
@@ -1446,7 +1453,7 @@ void KRMesh::convertToIndexed()
             if(vertex_index_offset + vertex_count > 0xffff) {
                 mi.vertex_index_bases.push_back(std::pair<int, int>((int)mi.vertex_indexes.size(), (int)mi.vertices.size()));
                 vertex_index_offset = 0;
-                vertex_index_base_start_vertex = mi.vertices.size();
+                vertex_index_base_start_vertex = (int)mi.vertices.size();
             }
         }
     }

kraken/KRMesh.h

@@ -60,8 +60,7 @@ class KRNode;
 class KRMesh : public KRResource {
 
 public:
-
+    static void parseName(const std::string& name, std::string& lodBaseName, int& lodCoverage);
-
 
     KRMesh(KRContext &context, std::string name, KRDataBlock *data);
     KRMesh(KRContext &context, std::string name);

kraken/KRMeshCube.cpp

@@ -55,7 +55,7 @@ KRMeshCube::KRMeshCube(KRContext &context) : KRMesh(context, "__cube")
     
     
     mi.submesh_starts.push_back(0);
-    mi.submesh_lengths.push_back(mi.vertices.size());
+    mi.submesh_lengths.push_back((int)mi.vertices.size());
     mi.material_names.push_back("");
     mi.format = KRENGINE_MODEL_FORMAT_STRIP;
 

kraken/KRMeshManager.cpp

@@ -38,23 +38,20 @@
 #include "KRMeshQuad.h"
 #include "KRMeshSphere.h"
 
-KRMeshManager::KRMeshManager(KRContext &context) : KRContextObject(context) {
+KRMeshManager::KRMeshManager(KRContext &context) : KRResourceManager(context) {
     m_currentVBO = NULL;
     m_vboMemUsed = 0;
     m_memoryTransferredThisFrame = 0;
     m_first_frame = true;
     m_streamerComplete = true;
     
-    addModel(new KRMeshCube(context)); // FINDME - HACK!  This needs to be fixed, as it currently segfaults
+    addModel(new KRMeshCube(context));
-    addModel(new KRMeshQuad(context)); // FINDME - HACK!  This needs to be fixed, as it currently segfaults
+    addModel(new KRMeshQuad(context));
     addModel(new KRMeshSphere(context));
     m_draw_call_logging_enabled = false;
     m_draw_call_log_used = false;
     
-    
-    
     // ----  Initialize stock models ----
-    
     static const GLfloat _KRENGINE_VBO_3D_CUBE_VERTEX_DATA[] = {
         1.0, 1.0, 1.0,
         -1.0, 1.0, 1.0,
@@ -105,6 +102,29 @@ KRMeshManager::~KRMeshManager() {
     m_models.empty();
 }
 
+KRResource* KRMeshManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("krmesh") == 0) {
+    return loadModel(name.c_str(), data);
+  }
+  return nullptr;
+}
+KRResource* KRMeshManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("krmesh") == 0) {
+    std::string lodBaseName;
+    int lodCoverage;
+    KRMesh::parseName(name, lodBaseName, lodCoverage);
+    std::vector<KRMesh*> models = getModel(lodBaseName.c_str());
+    for (KRMesh* mesh : models) {
+      if (mesh->getLODCoverage() == lodCoverage) {
+        return mesh;
+      }
+    }
+  }
+  return nullptr;
+}
+
 KRMesh *KRMeshManager::loadModel(const char *szName, KRDataBlock *pData) {
     KRMesh *pModel = new KRMesh(*m_pContext, szName, pData);
     addModel(pModel);
@@ -401,32 +421,32 @@ KRDataBlock &KRMeshManager::getVolumetricLightingVertexes()
         for(int iPlane=0; iPlane < KRENGINE_MAX_VOLUMETRIC_PLANES; iPlane++) {
             vertex_data[iVertex].vertex.x = -1.0f;
             vertex_data[iVertex].vertex.y = -1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
             
             vertex_data[iVertex].vertex.x = 1.0f;
             vertex_data[iVertex].vertex.y = -1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
             
             vertex_data[iVertex].vertex.x = -1.0f;
             vertex_data[iVertex].vertex.y = 1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
             
             vertex_data[iVertex].vertex.x = -1.0f;
             vertex_data[iVertex].vertex.y = 1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
             
             vertex_data[iVertex].vertex.x = 1.0f;
             vertex_data[iVertex].vertex.y = -1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
             
             vertex_data[iVertex].vertex.x = 1.0f;
             vertex_data[iVertex].vertex.y = 1.0f;
-            vertex_data[iVertex].vertex.z = iPlane;
+            vertex_data[iVertex].vertex.z = (GLfloat)iPlane;
             iVertex++;
 
         }
@@ -481,7 +501,7 @@ long KRMeshManager::getMemoryTransferedThisFrame()
 }
 
 
-int KRMeshManager::getActiveVBOCount()
+size_t KRMeshManager::getActiveVBOCount()
 {
     return m_vbosActive.size();
 }

kraken/KRMeshManager.h

@@ -33,6 +33,8 @@
 #define KRMESHMANAGER_H
 
 #include "KREngine-common.h"
+
+#include "KRResourceManager.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 #include "KRNode.h"
@@ -40,7 +42,7 @@
 class KRContext;
 class KRMesh;
 
-class KRMeshManager : public KRContextObject {
+class KRMeshManager : public KRResourceManager {
 public:
     static const int KRENGINE_MAX_VOLUMETRIC_PLANES=500;
     static const int KRENGINE_MAX_RANDOM_PARTICLES=150000;
@@ -48,6 +50,9 @@ public:
     KRMeshManager(KRContext &context);
     virtual ~KRMeshManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     void startFrame(float deltaTime);
     void endFrame(float deltaTime);
     void firstFrame();
@@ -88,7 +93,7 @@ public:
         KRVBOData(const KRVBOData& o) = delete;
         KRVBOData& operator=(const KRVBOData& o) = delete;
         
-        long getSize() { return m_size; }
+        long getSize() { return (long)m_size; }
         
         void resetPoolExpiry(float lodCoverage);
         long getLastFrameUsed() { return m_last_frame_used; }
@@ -150,7 +155,7 @@ public:
     
     long getMemoryTransferedThisFrame();
 
-    int getActiveVBOCount();
+    size_t getActiveVBOCount();
     
     struct draw_call_info {
         KRNode::RenderPass pass;

kraken/KRMeshQuad.cpp

@@ -50,7 +50,7 @@ KRMeshQuad::KRMeshQuad(KRContext &context) : KRMesh(context, "__quad")
     
     
     mi.submesh_starts.push_back(0);
-    mi.submesh_lengths.push_back(mi.vertices.size());
+    mi.submesh_lengths.push_back((int)mi.vertices.size());
     mi.material_names.push_back("");
     mi.format = KRENGINE_MODEL_FORMAT_STRIP;
     

kraken/KRMeshSphere.cpp

@@ -42,22 +42,9 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
     // Based on algorithm from Paul Bourke: http://paulbourke.net/miscellaneous/sphere_cylinder/
     
     int iterations = 3;
-    int facet_count = pow(4, iterations) * 8;
+    int facet_count = (int)(pow(4, iterations) * 8.0f);
     
-    class Facet3 {
+    std::vector<Triangle3> f = std::vector<Triangle3>(facet_count);
-    public:
-        Facet3() {
-            
-        }
-        ~Facet3() {
-            
-        }
-        Vector3 p1;
-        Vector3 p2;
-        Vector3 p3;
-    };
-    
-    std::vector<Facet3> f = std::vector<Facet3>(facet_count);
     
     int i,it;
     float a;
@@ -74,54 +61,54 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
     int nt = 0,ntold;
     
     /* Create the level 0 object */
-    a = 1 / sqrt(2.0);
+    a = 1.0f / sqrtf(2.0f);
     for (i=0;i<6;i++) {
         p[i].x *= a;
         p[i].y *= a;
     }
-    f[0].p1 = p[0]; f[0].p2 = p[3]; f[0].p3 = p[4];
+    f[0][0] = p[0]; f[0][1] = p[3]; f[0][2] = p[4];
-    f[1].p1 = p[0]; f[1].p2 = p[4]; f[1].p3 = p[5];
+    f[1][0] = p[0]; f[1][1] = p[4]; f[1][2] = p[5];
-    f[2].p1 = p[0]; f[2].p2 = p[5]; f[2].p3 = p[2];
+    f[2][0] = p[0]; f[2][1] = p[5]; f[2][2] = p[2];
-    f[3].p1 = p[0]; f[3].p2 = p[2]; f[3].p3 = p[3];
+    f[3][0] = p[0]; f[3][1] = p[2]; f[3][2] = p[3];
-    f[4].p1 = p[1]; f[4].p2 = p[4]; f[4].p3 = p[3];
+    f[4][0] = p[1]; f[4][1] = p[4]; f[4][2] = p[3];
-    f[5].p1 = p[1]; f[5].p2 = p[5]; f[5].p3 = p[4];
+    f[5][0] = p[1]; f[5][1] = p[5]; f[5][2] = p[4];
-    f[6].p1 = p[1]; f[6].p2 = p[2]; f[6].p3 = p[5];
+    f[6][0] = p[1]; f[6][1] = p[2]; f[6][2] = p[5];
-    f[7].p1 = p[1]; f[7].p2 = p[3]; f[7].p3 = p[2];
+    f[7][0] = p[1]; f[7][1] = p[3]; f[7][2] = p[2];
     nt = 8;
     
     /* Bisect each edge and move to the surface of a unit sphere */
     for (it=0;it<iterations;it++) {
         ntold = nt;
         for (i=0;i<ntold;i++) {
-            pa.x = (f[i].p1.x + f[i].p2.x) / 2;
+            pa.x = (f[i][0].x + f[i][1].x) / 2;
-            pa.y = (f[i].p1.y + f[i].p2.y) / 2;
+            pa.y = (f[i][0].y + f[i][1].y) / 2;
-            pa.z = (f[i].p1.z + f[i].p2.z) / 2;
+            pa.z = (f[i][0].z + f[i][1].z) / 2;
-            pb.x = (f[i].p2.x + f[i].p3.x) / 2;
+            pb.x = (f[i][1].x + f[i][2].x) / 2;
-            pb.y = (f[i].p2.y + f[i].p3.y) / 2;
+            pb.y = (f[i][1].y + f[i][2].y) / 2;
-            pb.z = (f[i].p2.z + f[i].p3.z) / 2;
+            pb.z = (f[i][1].z + f[i][2].z) / 2;
-            pc.x = (f[i].p3.x + f[i].p1.x) / 2;
+            pc.x = (f[i][2].x + f[i][0].x) / 2;
-            pc.y = (f[i].p3.y + f[i].p1.y) / 2;
+            pc.y = (f[i][2].y + f[i][0].y) / 2;
-            pc.z = (f[i].p3.z + f[i].p1.z) / 2;
+            pc.z = (f[i][2].z + f[i][0].z) / 2;
             pa.normalize();
             pb.normalize();
             pc.normalize();
-            f[nt].p1 = f[i].p1; f[nt].p2 = pa; f[nt].p3 = pc; nt++;
+            f[nt][0] = f[i][0]; f[nt][1] = pa; f[nt][2] = pc; nt++;
-            f[nt].p1 = pa; f[nt].p2 = f[i].p2; f[nt].p3 = pb; nt++;
+            f[nt][0] = pa; f[nt][1] = f[i][1]; f[nt][2] = pb; nt++;
-            f[nt].p1 = pb; f[nt].p2 = f[i].p3; f[nt].p3 = pc; nt++;
+            f[nt][0] = pb; f[nt][1] = f[i][2]; f[nt][2] = pc; nt++;
-            f[i].p1 = pa;
+            f[i][0] = pa;
-            f[i].p2 = pb;
+            f[i][1] = pb;
-            f[i].p3 = pc;
+            f[i][2] = pc;
         }
     }
     
     for(int facet_index=0; facet_index < facet_count; facet_index++) {
-        mi.vertices.push_back(f[facet_index].p1);
+        mi.vertices.push_back(f[facet_index][0]);
-        mi.vertices.push_back(f[facet_index].p2);
+        mi.vertices.push_back(f[facet_index][1]);
-        mi.vertices.push_back(f[facet_index].p3);
+        mi.vertices.push_back(f[facet_index][2]);
     }
     
     mi.submesh_starts.push_back(0);
-    mi.submesh_lengths.push_back(mi.vertices.size());
+    mi.submesh_lengths.push_back((int)mi.vertices.size());
     mi.material_names.push_back("");
     
 

kraken/KRNode.cpp

@@ -125,13 +125,13 @@ tinyxml2::XMLElement *KRNode::saveXML(tinyxml2::XMLNode *parent) {
     e->SetAttribute("name", m_name.c_str());
     kraken::setXMLAttribute("translate", e, m_localTranslation, Vector3::Zero());
     kraken::setXMLAttribute("scale", e, m_localScale, Vector3::One());
-    kraken::setXMLAttribute("rotate", e, (m_localRotation * (180.0f / M_PI)), Vector3::Zero());
+    kraken::setXMLAttribute("rotate", e, (m_localRotation * (180.0f / (float)M_PI)), Vector3::Zero());
     kraken::setXMLAttribute("rotate_offset", e, m_rotationOffset, Vector3::Zero());
     kraken::setXMLAttribute("scale_offset", e, m_scalingOffset, Vector3::Zero());
     kraken::setXMLAttribute("rotate_pivot", e, m_rotationPivot, Vector3::Zero());
     kraken::setXMLAttribute("scale_pivot", e, m_scalingPivot, Vector3::Zero());
-    kraken::setXMLAttribute("pre_rotate", e, (m_preRotation * (180.0f / M_PI)), Vector3::Zero());
+    kraken::setXMLAttribute("pre_rotate", e, (m_preRotation * (180.0f / (float)M_PI)), Vector3::Zero());
-    kraken::setXMLAttribute("post_rotate", e, (m_postRotation * (180.0f / M_PI)), Vector3::Zero());
+    kraken::setXMLAttribute("post_rotate", e, (m_postRotation * (180.0f / (float)M_PI)), Vector3::Zero());
     
     for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
         KRNode *child = (*itr);
@@ -145,11 +145,11 @@ void KRNode::loadXML(tinyxml2::XMLElement *e) {
     m_localTranslation = kraken::getXMLAttribute("translate", e, Vector3::Zero());
     m_localScale = kraken::getXMLAttribute("scale", e, Vector3::One());
     m_localRotation = kraken::getXMLAttribute("rotate", e, Vector3::Zero());
-    m_localRotation *= M_PI / 180.0f; // Convert degrees to radians
+    m_localRotation *= (float)M_PI / 180.0f; // Convert degrees to radians
     m_preRotation = kraken::getXMLAttribute("pre_rotate", e, Vector3::Zero());
-    m_preRotation *= M_PI / 180.0f; // Convert degrees to radians
+    m_preRotation *= (float)M_PI / 180.0f; // Convert degrees to radians
     m_postRotation = kraken::getXMLAttribute("post_rotate", e, Vector3::Zero());
-    m_postRotation *= M_PI / 180.0f; // Convert degrees to radians
+    m_postRotation *= (float)M_PI / 180.0f; // Convert degrees to radians
 
     m_rotationOffset = kraken::getXMLAttribute("rotate_offset", e, Vector3::Zero());
     m_scalingOffset = kraken::getXMLAttribute("scale_offset", e, Vector3::Zero());
@@ -763,7 +763,7 @@ void KRNode::SetAttribute(node_attribute_type attrib, float v)
 {
     if(m_animation_mask[attrib]) return;
     
-    const float DEGREES_TO_RAD = M_PI / 180.0f;
+    const float DEGREES_TO_RAD = (float)M_PI / 180.0f;
     
     //printf("%s - ", m_name.c_str());
     switch(attrib) {

kraken/KRNode.h

@@ -21,7 +21,7 @@ class Matrix4;
 class AABB;
 } // namespace kraken
 class KRCamera;
-class KRShaderManager;
+class KRPipelineManager;
 class KRMeshManager;
 class KRMaterialManager;
 class KRTextureManager;

kraken/KROctreeNode.cpp

@@ -53,7 +53,7 @@ void KROctreeNode::beginOcclusionQuery()
 {
     if(!m_occlusionTested){
         GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery));
-#if TARGET_OS_IPHONE
+#if TARGET_OS_IPHONE || defined(ANDROID)
         GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery));
 #else
         GLDEBUG(glBeginQuery(GL_SAMPLES_PASSED, m_occlusionQuery));
@@ -67,7 +67,7 @@ void KROctreeNode::endOcclusionQuery()
 {
     if(m_activeQuery) {
         // Only end a query if we started one
-#if TARGET_OS_IPHONE
+#if TARGET_OS_IPHONE || defined(ANDROID)
         GLDEBUG(glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT));
 #else
         GLDEBUG(glEndQuery(GL_SAMPLES_PASSED));

kraken/KRParticleSystemNewtonian.cpp

@@ -74,11 +74,11 @@ void KRParticleSystemNewtonian::render(KRCamera *pCamera, std::vector<KRPointLig
             
             int particle_count = 10000;
             
-            KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+            KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline("dust_particle", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
             
-            Vector3 rim_color; Vector4 fade_color;
+            // Vector3 rim_color; Vector4 fade_color;
-            if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+            if(getContext().getPipelineManager()->selectPipeline(*pCamera, pParticleShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
-                pParticleShader->setUniform(KRShader::KRENGINE_UNIFORM_FLARE_SIZE, 1.0f);
+                pParticleShader->setUniform(KRPipeline::KRENGINE_UNIFORM_FLARE_SIZE, 1.0f);
 
                 KRDataBlock index_data;
                 m_pContext->getMeshManager()->bindVBO(m_pContext->getMeshManager()->getRandomParticles(), index_data, (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA), false, 1.0f);

kraken/KRPipeline.cpp

@@ -0,0 +1,581 @@
+//
+//  KRPipeline.cpp
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//  
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//  
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//  
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//  
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//  
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+#include "KRPipeline.h"
+#include "assert.h"
+#include "KRLight.h"
+#include "KRDirectionalLight.h"
+#include "KRSpotLight.h"
+#include "KRPointLight.h"
+
+
+const char *KRPipeline::KRENGINE_UNIFORM_NAMES[] = {
+    "material_ambient", // KRENGINE_UNIFORM_MATERIAL_AMBIENT
+    "material_diffuse", // KRENGINE_UNIFORM_MATERIAL_DIFFUSE
+    "material_specular", // KRENGINE_UNIFORM_MATERIAL_SPECULAR
+    "material_reflection", // KRENGINE_UNIFORM_MATERIAL_REFLECTION
+    "material_alpha", // KRENGINE_UNIFORM_MATERIAL_ALPHA
+    "material_shininess", // KRENGINE_UNIFORM_MATERIAL_SHININESS
+    "light_position", // KRENGINE_UNIFORM_LIGHT_POSITION
+    "light_direction_model_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE
+    "light_direction_view_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE
+    "light_color", //    KRENGINE_UNIFORM_LIGHT_COLOR
+    "light_decay_start", //    KRENGINE_UNIFORM_LIGHT_DECAY_START
+    "light_cutoff", //    KRENGINE_UNIFORM_LIGHT_CUTOFF
+    "light_intensity", //    KRENGINE_UNIFORM_LIGHT_INTENSITY
+    "flare_size", //    KRENGINE_UNIFORM_FLARE_SIZE
+    "view_space_model_origin", //    KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN
+    "mvp_matrix", //    KRENGINE_UNIFORM_MVP
+    "inv_projection_matrix", //    KRENGINE_UNIFORM_INVP
+    "inv_mvp_matrix", //    KRENGINE_UNIFORM_INVMVP
+    "inv_mvp_matrix_no_translate", //    KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE
+    "model_view_inverse_transpose_matrix", //    KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE
+    "model_inverse_transpose_matrix", //    KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE
+    "model_view_matrix", //    KRENGINE_UNIFORM_MODEL_VIEW
+    "model_matrix", //    KRENGINE_UNIFORM_MODEL_MATRIX
+    "projection_matrix", //    KRENGINE_UNIFORM_PROJECTION_MATRIX
+    "camera_position_model_space", //    KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE
+    "viewport", //    KRENGINE_UNIFORM_VIEWPORT
+    "viewport_downsample", //     KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE
+    "diffuseTexture", //    KRENGINE_UNIFORM_DIFFUSETEXTURE
+    "specularTexture", //    KRENGINE_UNIFORM_SPECULARTEXTURE
+    "reflectionCubeTexture", //    KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE
+    "reflectionTexture", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE
+    "normalTexture", //    KRENGINE_UNIFORM_NORMALTEXTURE
+    "diffuseTexture_Scale", //    KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE
+    "specularTexture_Scale", //    KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE
+    "reflectionTexture_Scale", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE
+    "normalTexture_Scale", //    KRENGINE_UNIFORM_NORMALTEXTURE_SCALE
+    "normalTexture_Scale", //    KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE
+    "diffuseTexture_Offset", //    KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET
+    "specularTexture_Offset", //    KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET
+    "reflectionTexture_Offset", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET
+    "normalTexture_Offset", //    KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET
+    "ambientTexture_Offset", //    KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET
+    "shadow_mvp1", //    KRENGINE_UNIFORM_SHADOWMVP1
+    "shadow_mvp2", //    KRENGINE_UNIFORM_SHADOWMVP2
+    "shadow_mvp3", //    KRENGINE_UNIFORM_SHADOWMVP3
+    "shadowTexture1", //    KRENGINE_UNIFORM_SHADOWTEXTURE1
+    "shadowTexture2", //    KRENGINE_UNIFORM_SHADOWTEXTURE2
+    "shadowTexture3", //    KRENGINE_UNIFORM_SHADOWTEXTURE3
+    "lightmapTexture", //    KRENGINE_UNIFORM_LIGHTMAPTEXTURE
+    "gbuffer_frame", //    KRENGINE_UNIFORM_GBUFFER_FRAME
+    "gbuffer_depth", //    KRENGINE_UNIFORM_GBUFFER_DEPTH
+    "depthFrame", //    KRENGINE_UNIFORM_DEPTH_FRAME
+    "volumetricEnvironmentFrame", //    KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME
+    "renderFrame", //    KRENGINE_UNIFORM_RENDER_FRAME
+    "time_absolute", //    KRENGINE_UNIFORM_ABSOLUTE_TIME
+    "fog_near", //    KRENGINE_UNIFORM_FOG_NEAR
+    "fog_far", //    KRENGINE_UNIFORM_FOG_FAR
+    "fog_density", //    KRENGINE_UNIFORM_FOG_DENSITY
+    "fog_color", //    KRENGINE_UNIFORM_FOG_COLOR
+    "fog_scale", //    KRENGINE_UNIFORM_FOG_SCALE
+    "fog_density_premultiplied_exponential", //    KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL
+    "fog_density_premultiplied_squared", //    KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED
+    "slice_depth_scale", //    KRENGINE_UNIFORM_SLICE_DEPTH_SCALE
+    "particle_origin", //    KRENGINE_UNIFORM_PARTICLE_ORIGIN
+    "bone_transforms", //    KRENGINE_UNIFORM_BONE_TRANSFORMS
+    "rim_color", // KRENGINE_UNIFORM_RIM_COLOR
+    "rim_power", // KRENGINE_UNIFORM_RIM_POWER
+    "fade_color", // KRENGINE_UNIFORM_FADE_COLOR
+};
+
+KRPipeline::KRPipeline(KRContext &context, char *szKey, std::string options, std::string vertShaderSource, const std::string fragShaderSource) : KRContextObject(context)
+{
+    strcpy(m_szKey, szKey);
+    m_iProgram = 0;
+    
+    
+    GLuint vertexShader = 0, fragShader = 0;
+
+    const GLchar *vertSource[2] = {options.c_str(), vertShaderSource.c_str()};
+    const GLchar *fragSource[2] = {options.c_str(), fragShaderSource.c_str()};
+    
+    // Create shader program.
+    GLDEBUG(m_iProgram = glCreateProgram());
+    
+    // Create and compile vertex shader.
+    GLDEBUG(vertexShader = glCreateShader(GL_VERTEX_SHADER));
+    GLDEBUG(glShaderSource(vertexShader, 2, vertSource, NULL));
+    GLDEBUG(glCompileShader(vertexShader));
+    
+    // Report any compile issues to stderr
+    GLint logLength = 0;
+    GLDEBUG(glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength));
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength + 1);
+        assert(log != NULL);
+        log[0] = '\0'; // In case glGetShaderInfoLog fails
+        GLDEBUG(glGetShaderInfoLog(vertexShader, logLength, &logLength, log));
+        log[logLength] = '\0';
+        KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile vertex shader: %s\nShader compile log:\n%s", szKey, log);
+        free(log);
+    }
+
+    
+    // Create and compile vertex shader.
+    GLDEBUG(fragShader = glCreateShader(GL_FRAGMENT_SHADER));
+    GLDEBUG(glShaderSource(fragShader, 2, fragSource, NULL));
+    GLDEBUG(glCompileShader(fragShader));
+    
+    // Report any compile issues to stderr
+    logLength = 0; // In case glGetShaderiv fails
+    GLDEBUG(glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength));
+    if (logLength > 0) {
+        GLchar *log = (GLchar *)malloc(logLength + 1);
+        assert(log != NULL);
+        log[0] = '\0'; // In case glGetShaderInfoLog fails
+        GLDEBUG(glGetShaderInfoLog(fragShader, logLength, &logLength, log));
+        log[logLength] = '\0';
+        KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile fragment shader: %s\nShader compile log:\n%s", szKey, log);
+        free(log);
+    }
+    
+    // Attach vertex shader to program.
+    GLDEBUG(glAttachShader(m_iProgram, vertexShader));
+    
+    // Attach fragment shader to program.
+    GLDEBUG(glAttachShader(m_iProgram, fragShader));
+    
+    // Bind attribute locations.
+    // This needs to be done prior to linking.
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_VERTEX, "vertex_position"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_NORMAL, "vertex_normal"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TANGENT, "vertex_tangent"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVA, "vertex_uv"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEINDEXES, "bone_indexes"));
+    GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEWEIGHTS, "bone_weights"));
+    
+    // Link program.
+    GLDEBUG(glLinkProgram(m_iProgram));
+    
+    GLint link_success = GL_FALSE;
+    GLDEBUG(glGetProgramiv(m_iProgram, GL_LINK_STATUS, &link_success));
+    
+    if(link_success != GL_TRUE) {
+        // Report any linking issues to stderr
+        KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to link shader program: %s", szKey);
+        logLength = 0; // In case glGetProgramiv fails
+        GLDEBUG(glGetProgramiv(m_iProgram, GL_INFO_LOG_LENGTH, &logLength));
+        if (logLength > 0)
+        {
+            GLchar *log = (GLchar *)malloc(logLength + 1);
+            assert(log != NULL);
+            log[0] = '\0'; // In case glGetProgramInfoLog fails
+            GLDEBUG(glGetProgramInfoLog(m_iProgram, logLength, &logLength, log));
+            log[logLength] = '\0';
+            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Program link log:\n%s", log);
+            free(log);
+        }
+        GLDEBUG(glDeleteProgram(m_iProgram));
+        m_iProgram = 0;
+    } else {
+    
+        // Get uniform locations
+        for(int i=0; i < KRENGINE_NUM_UNIFORMS; i++ ){
+            GLDEBUG(m_uniforms[i] = glGetUniformLocation(m_iProgram, KRENGINE_UNIFORM_NAMES[i]));
+            m_uniform_value_index[i] = -1;
+        }
+    }
+
+    // Release vertex and fragment shaders.
+    if (vertexShader) {
+        GLDEBUG(glDeleteShader(vertexShader));
+	}
+    if (fragShader) {
+        GLDEBUG(glDeleteShader(fragShader));
+	}
+}
+
+KRPipeline::~KRPipeline() {
+    if(m_iProgram) {
+        GLDEBUG(glDeleteProgram(m_iProgram));
+        if(getContext().getPipelineManager()->m_active_pipeline == this) {
+            getContext().getPipelineManager()->m_active_pipeline = NULL;
+        }
+    }
+}
+
+void KRPipeline::setUniform(int location, float value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_float.size();
+            m_uniform_value_float.push_back(value);
+        } else if(m_uniform_value_float[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_float[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniform1f(m_uniforms[location], value));
+        }
+    }
+}
+void KRPipeline::setUniform(int location, int value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_int.size();
+            m_uniform_value_int.push_back(value);
+        } else if(m_uniform_value_int[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_int[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniform1i(m_uniforms[location], value));
+        }
+    }
+}
+
+void KRPipeline::setUniform(int location, const Vector2 &value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_vector2.size();
+            m_uniform_value_vector2.push_back(value);
+        } else if(m_uniform_value_vector2[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_vector2[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniform2f(m_uniforms[location], value.x, value.y));
+        }
+    }
+}
+void KRPipeline::setUniform(int location, const Vector3 &value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_vector3.size();
+            m_uniform_value_vector3.push_back(value);
+        } else if(m_uniform_value_vector3[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_vector3[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniform3f(m_uniforms[location], value.x, value.y, value.z));
+        }
+    }
+}
+void KRPipeline::setUniform(int location, const Vector4 &value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_vector4.size();
+            m_uniform_value_vector4.push_back(value);
+        } else if(m_uniform_value_vector4[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_vector4[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniform4f(m_uniforms[location], value.x, value.y, value.z, value.w));
+        }
+    }
+}
+
+void KRPipeline::setUniform(int location, const Matrix4 &value)
+{
+    if(m_uniforms[location] != -1) {
+        int value_index = m_uniform_value_index[location];
+        bool needs_update = true;
+        if(value_index == -1) {
+            m_uniform_value_index[location] = (int)m_uniform_value_mat4.size();
+            m_uniform_value_mat4.push_back(value);
+        } else if(m_uniform_value_mat4[value_index] == value) {
+            needs_update = false;
+        } else {
+            m_uniform_value_mat4[value_index] = value;
+        }
+        if(needs_update) {
+            GLDEBUG(glUniformMatrix4fv(m_uniforms[location], 1, GL_FALSE, value.c));
+        }
+    }
+}
+
+bool KRPipeline::bind(KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color) {
+    if(m_iProgram == 0) {
+        return false;
+    }
+    
+    bool shander_changed = false;
+    if(getContext().getPipelineManager()->m_active_pipeline != this) {
+        getContext().getPipelineManager()->m_active_pipeline = this;
+        GLDEBUG(glUseProgram(m_iProgram));
+        shander_changed = true;
+    }
+    
+    
+    setUniform(KRENGINE_UNIFORM_ABSOLUTE_TIME, getContext().getAbsoluteTime());
+    
+    int light_directional_count = 0;
+    //int light_point_count = 0;
+    //int light_spot_count = 0;
+    // TODO - Need to support multiple lights and more light types in forward rendering
+    if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
+        
+        
+        for(std::vector<KRDirectionalLight *>::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) {
+            KRDirectionalLight *directional_light = (*light_itr);
+            if(light_directional_count == 0) {
+                int cShadowBuffers = directional_light->getShadowBufferCount();
+                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE1] != -1 && cShadowBuffers > 0) {
+                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 3, directional_light->getShadowTextures()[0])) {
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+                    }
+                    
+                    m_pContext->getTextureManager()->_setWrapModeS(3, GL_CLAMP_TO_EDGE);
+                    m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE);
+                }
+                
+                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE2] != -1 && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) {
+                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 4, directional_light->getShadowTextures()[1])) {
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+                    }
+                    m_pContext->getTextureManager()->_setWrapModeS(4, GL_CLAMP_TO_EDGE);
+                    m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE);
+                }
+                
+                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE3] != -1 && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) {
+                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 5, directional_light->getShadowTextures()[2])) {
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+                    }
+                    m_pContext->getTextureManager()->_setWrapModeS(5, GL_CLAMP_TO_EDGE);
+                    m_pContext->getTextureManager()->_setWrapModeT(5, GL_CLAMP_TO_EDGE);
+                }
+                
+                Matrix4 matBias;
+                matBias.translate(1.0, 1.0, 1.0);
+                matBias.scale(0.5);
+                for(int iShadow=0; iShadow < cShadowBuffers; iShadow++) {
+                    setUniform(KRENGINE_UNIFORM_SHADOWMVP1 + iShadow, matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias);
+                }
+                
+                if(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE] != -1) {
+                    Matrix4 inverseModelMatrix = matModel;
+                    inverseModelMatrix.invert();
+                    
+                    // Bind the light direction vector
+                    Vector3 lightDirObject = Matrix4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection());
+                    lightDirObject.normalize();
+                    setUniform(KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE, lightDirObject);
+                }
+            }
+            
+            light_directional_count++;
+        }
+
+        //light_point_count = point_lights.size();
+        //light_spot_count = spot_lights.size();
+    }
+    
+
+    
+    if(m_uniforms[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE] != -1) {
+        Matrix4 inverseModelMatrix = matModel;
+        inverseModelMatrix.invert();
+        
+        if(m_uniforms[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE] != -1) {
+            // Transform location of camera to object space for calculation of specular halfVec
+            Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition());
+            setUniform(KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, cameraPosObject);
+        }
+    }
+    
+    if(m_uniforms[KRENGINE_UNIFORM_MVP] != -1 || m_uniforms[KRPipeline::KRENGINE_UNIFORM_INVMVP] != -1) {
+        // Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
+        Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix();
+        setUniform(KRENGINE_UNIFORM_MVP, mvpMatrix);
+        
+        if(m_uniforms[KRPipeline::KRENGINE_UNIFORM_INVMVP] != -1) {
+            setUniform(KRPipeline::KRENGINE_UNIFORM_INVMVP, Matrix4::Invert(mvpMatrix));
+        }
+    }
+    
+    if(m_uniforms[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] != -1 || m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] != -1 || m_uniforms[KRPipeline::KRENGINE_UNIFORM_MODEL_VIEW] != -1) {
+        Matrix4 matModelView = matModel * viewport.getViewMatrix();
+        setUniform(KRENGINE_UNIFORM_MODEL_VIEW, matModelView);
+        
+        
+        if(m_uniforms[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] != -1) {
+            Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position.  No perspective, so no w divide required
+            setUniform(KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin);
+        }
+        
+        if(m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] != -1) {
+            Matrix4 matModelViewInverseTranspose = matModelView;
+            matModelViewInverseTranspose.transpose();
+            matModelViewInverseTranspose.invert();
+            setUniform(KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE, matModelViewInverseTranspose);
+        }
+    }
+    
+    if(m_uniforms[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE] != -1) {
+        Matrix4 matModelInverseTranspose = matModel;
+        matModelInverseTranspose.transpose();
+        matModelInverseTranspose.invert();
+        setUniform(KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, matModelInverseTranspose);
+    }
+    
+    if(m_uniforms[KRPipeline::KRENGINE_UNIFORM_INVP] != -1) {
+        setUniform(KRENGINE_UNIFORM_INVP, viewport.getInverseProjectionMatrix());
+    }
+    
+    if(m_uniforms[KRPipeline::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE] != -1) {
+        Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();;
+        // Remove the translation
+        matInvMVPNoTranslate.getPointer()[3] = 0;
+        matInvMVPNoTranslate.getPointer()[7] = 0;
+        matInvMVPNoTranslate.getPointer()[11] = 0;
+        matInvMVPNoTranslate.getPointer()[12] = 0;
+        matInvMVPNoTranslate.getPointer()[13] = 0;
+        matInvMVPNoTranslate.getPointer()[14] = 0;
+        matInvMVPNoTranslate.getPointer()[15] = 1.0;
+        matInvMVPNoTranslate = matInvMVPNoTranslate * viewport.getProjectionMatrix();
+        matInvMVPNoTranslate.invert();
+        setUniform(KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE, matInvMVPNoTranslate);
+    }
+    
+    setUniform(KRENGINE_UNIFORM_MODEL_MATRIX, matModel);
+    if(m_uniforms[KRENGINE_UNIFORM_PROJECTION_MATRIX] != -1) {
+        setUniform(KRENGINE_UNIFORM_PROJECTION_MATRIX, viewport.getProjectionMatrix());
+    }
+    
+    if(m_uniforms[KRENGINE_UNIFORM_VIEWPORT] != -1) {
+        setUniform(KRENGINE_UNIFORM_VIEWPORT, Vector4::Create(
+                (GLfloat)0.0,
+                (GLfloat)0.0,
+                (GLfloat)viewport.getSize().x,
+                (GLfloat)viewport.getSize().y
+            )
+        );
+    }
+    
+    if(m_uniforms[KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE] != -1) {
+        setUniform(KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, camera.getDownsample());
+    }
+    
+    // Rim highlighting parameters
+    setUniform(KRENGINE_UNIFORM_RIM_COLOR, rim_color);
+    setUniform(KRENGINE_UNIFORM_RIM_POWER, rim_power);
+    
+    // Fade parameters
+    setUniform(KRENGINE_UNIFORM_FADE_COLOR, fade_color);
+    
+    // Fog parameters
+    setUniform(KRENGINE_UNIFORM_FOG_NEAR, camera.settings.fog_near);
+    setUniform(KRENGINE_UNIFORM_FOG_FAR, camera.settings.fog_far);
+    setUniform(KRENGINE_UNIFORM_FOG_DENSITY, camera.settings.fog_density);
+    setUniform(KRENGINE_UNIFORM_FOG_COLOR, camera.settings.fog_color);
+    
+    if(m_uniforms[KRENGINE_UNIFORM_FOG_SCALE] != -1) {
+        setUniform(KRENGINE_UNIFORM_FOG_SCALE, 1.0f / (camera.settings.fog_far - camera.settings.fog_near));
+    }
+    if(m_uniforms[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL] != -1) {
+        setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2)
+    }
+    if(m_uniforms[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED] != -1) {
+        setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2)
+    }
+    
+    // Sets the diffuseTexture variable to the first texture unit
+    setUniform(KRENGINE_UNIFORM_DIFFUSETEXTURE, 0);
+    
+    // Sets the specularTexture variable to the second texture unit
+    setUniform(KRENGINE_UNIFORM_SPECULARTEXTURE, 1);
+    
+    // Sets the normalTexture variable to the third texture unit
+    setUniform(KRENGINE_UNIFORM_NORMALTEXTURE, 2);
+    
+    // Sets the shadowTexture variable to the fourth texture unit
+    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE1, 3);
+    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE2, 4);
+    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE3, 5);
+    setUniform(KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE, 4);
+    setUniform(KRENGINE_UNIFORM_LIGHTMAPTEXTURE, 5);
+    setUniform(KRENGINE_UNIFORM_GBUFFER_FRAME, 6);
+    setUniform(KRENGINE_UNIFORM_GBUFFER_DEPTH, 7); // Texture unit 7 is used for reading the depth buffer in gBuffer pass #2 and in post-processing pass
+    setUniform(KRENGINE_UNIFORM_REFLECTIONTEXTURE, 7); // Texture unit 7 is used for the reflection map textures in gBuffer pass #3 and when using forward rendering
+    setUniform(KRENGINE_UNIFORM_DEPTH_FRAME, 0);
+    setUniform(KRENGINE_UNIFORM_RENDER_FRAME, 1);
+    setUniform(KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME, 2);
+    
+#if defined(DEBUG)
+    if(shander_changed) { // FINDME!! KIP!! HACK!!
+        GLint logLength;
+        
+        GLint validate_status = GL_FALSE;
+        GLDEBUG(glValidateProgram(m_iProgram));
+        GLDEBUG(glGetProgramiv(m_iProgram, GL_VALIDATE_STATUS, &validate_status));
+        if(validate_status != GL_TRUE) {
+            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to validate shader program: %s", m_szKey);
+            logLength = 0; // In case glGetProgramiv fails
+            GLDEBUG(glGetProgramiv(m_iProgram, GL_INFO_LOG_LENGTH, &logLength));
+            if (logLength > 0)
+            {
+                GLchar *log = (GLchar *)malloc(logLength + 1);
+                assert(log != NULL);
+                log[0] = '\0'; // In case glGetProgramInfoLog fails
+                GLDEBUG(glGetProgramInfoLog(m_iProgram, logLength, &logLength, log));
+                log[logLength] = '\0';
+                KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Program validate log:\n%s", log);
+                free(log);
+                
+            }
+            return false;
+        }
+    }
+#endif
+
+    return true;
+}
+
+const char *KRPipeline::getKey() const {
+    return m_szKey;
+}

kraken/KRPipeline.h

@@ -0,0 +1,161 @@
+//
+//  KRPipeline.h
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//  
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//  
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//  
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//  
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//  
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+
+
+#ifndef KRPIPELINE_H
+#define KRPIPELINE_H
+
+#include "KREngine-common.h"
+#include "KRPipeline.h"
+#include "KRCamera.h"
+#include "KRNode.h"
+#include "KRViewport.h"
+
+class KRPipeline  : public KRContextObject {
+public:
+    KRPipeline(KRContext &context, char *szKey, std::string options, std::string vertShaderSource, const std::string fragShaderSource);
+    virtual ~KRPipeline();
+    const char *getKey() const;
+    
+    bool bind(KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
+    
+    enum {
+        KRENGINE_UNIFORM_MATERIAL_AMBIENT = 0,
+        KRENGINE_UNIFORM_MATERIAL_DIFFUSE,
+        KRENGINE_UNIFORM_MATERIAL_SPECULAR,
+        KRENGINE_UNIFORM_MATERIAL_REFLECTION,
+        KRENGINE_UNIFORM_MATERIAL_ALPHA,
+        KRENGINE_UNIFORM_MATERIAL_SHININESS,
+        KRENGINE_UNIFORM_LIGHT_POSITION,
+        KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE,
+        KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE,
+        KRENGINE_UNIFORM_LIGHT_COLOR,
+        KRENGINE_UNIFORM_LIGHT_DECAY_START,
+        KRENGINE_UNIFORM_LIGHT_CUTOFF,
+        KRENGINE_UNIFORM_LIGHT_INTENSITY,
+        KRENGINE_UNIFORM_FLARE_SIZE,
+        KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN,
+        KRENGINE_UNIFORM_MVP,
+        KRENGINE_UNIFORM_INVP,
+        KRENGINE_UNIFORM_INVMVP,
+        KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE,
+        KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE,
+        KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE,
+        KRENGINE_UNIFORM_MODEL_VIEW,
+        KRENGINE_UNIFORM_MODEL_MATRIX,
+        KRENGINE_UNIFORM_PROJECTION_MATRIX,
+        KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE,
+        KRENGINE_UNIFORM_VIEWPORT,
+        KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE,
+        KRENGINE_UNIFORM_DIFFUSETEXTURE,
+        KRENGINE_UNIFORM_SPECULARTEXTURE,
+        KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE,
+        KRENGINE_UNIFORM_REFLECTIONTEXTURE,
+        KRENGINE_UNIFORM_NORMALTEXTURE,
+        KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE,
+        KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE,
+        KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE,
+        KRENGINE_UNIFORM_NORMALTEXTURE_SCALE,
+        KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE,
+        KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET,
+        KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET,
+        KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET,
+        KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET,
+        KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET,
+        KRENGINE_UNIFORM_SHADOWMVP1,
+        KRENGINE_UNIFORM_SHADOWMVP2,
+        KRENGINE_UNIFORM_SHADOWMVP3,
+        KRENGINE_UNIFORM_SHADOWTEXTURE1,
+        KRENGINE_UNIFORM_SHADOWTEXTURE2,
+        KRENGINE_UNIFORM_SHADOWTEXTURE3,
+        KRENGINE_UNIFORM_LIGHTMAPTEXTURE,
+        KRENGINE_UNIFORM_GBUFFER_FRAME,
+        KRENGINE_UNIFORM_GBUFFER_DEPTH,
+        KRENGINE_UNIFORM_DEPTH_FRAME,
+        KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME,
+        KRENGINE_UNIFORM_RENDER_FRAME,
+        KRENGINE_UNIFORM_ABSOLUTE_TIME,
+        KRENGINE_UNIFORM_FOG_NEAR,
+        KRENGINE_UNIFORM_FOG_FAR,
+        KRENGINE_UNIFORM_FOG_DENSITY,
+        KRENGINE_UNIFORM_FOG_COLOR,
+        KRENGINE_UNIFORM_FOG_SCALE,
+        KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL,
+        KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED,
+        KRENGINE_UNIFORM_SLICE_DEPTH_SCALE,
+        KRENGINE_UNIFORM_PARTICLE_ORIGIN,
+        KRENGINE_UNIFORM_BONE_TRANSFORMS,
+        KRENGINE_UNIFORM_RIM_COLOR,
+        KRENGINE_UNIFORM_RIM_POWER,
+        KRENGINE_UNIFORM_FADE_COLOR,
+        KRENGINE_NUM_UNIFORMS
+    };
+    /*
+    typedef enum {
+        KRENGINE_UNIFORM_TYPE_UNKNOWN,
+        KRENGINE_UNIFORM_TYPE_FLOAT,
+        KRENGINE_UNIFORM_TYPE_INT,
+        KRENGINE_UNIFORM_TYPE_VECTOR2,
+        KRENGINE_UNIFORM_TYPE_VECTOR3,
+        KRENGINE_UNIFORM_TYPE_VECTOR4,
+        KRENGINE_UNIFORM_TYPE_MAT4
+    } uniform_type_t;
+     uniform_type_t m_uniform_type[KRENGINE_NUM_UNIFORMS];
+     */
+    
+    static const char *KRENGINE_UNIFORM_NAMES[];
+    GLint m_uniforms[KRENGINE_NUM_UNIFORMS];
+    
+    int m_uniform_value_index[KRENGINE_NUM_UNIFORMS];
+    
+    std::vector<float> m_uniform_value_float;
+    std::vector<int> m_uniform_value_int;
+    std::vector<Vector2> m_uniform_value_vector2;
+    std::vector<Vector3> m_uniform_value_vector3;
+    std::vector<Vector4> m_uniform_value_vector4;
+    std::vector<Matrix4> m_uniform_value_mat4;
+    
+    
+    char m_szKey[256];
+    
+    void setUniform(int location, float value);
+    void setUniform(int location, int value);
+    void setUniform(int location, const Vector2 &value);
+    void setUniform(int location, const Vector3 &value);
+    void setUniform(int location, const Vector4 &value);
+    void setUniform(int location, const Matrix4 &value);
+    
+private:
+    GLuint m_iProgram;
+};
+
+#endif

kraken/KRPipelineManager.cpp

@@ -0,0 +1,273 @@
+//
+//  KRPipelineManager.cpp
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//  
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//  
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//  
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//  
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//  
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+#include "KREngine-common.h"
+
+#include "KRPipelineManager.h"
+#include "KRLight.h"
+#include "KRDirectionalLight.h"
+#include "KRSpotLight.h"
+#include "KRPointLight.h"
+
+#ifndef ANDROID
+#include "glslang/Public/ShaderLang.h"
+#endif
+
+using namespace std;
+
+KRPipelineManager::KRPipelineManager(KRContext &context) : KRContextObject(context) {
+    m_active_pipeline = NULL;
+#ifndef ANDROID
+    bool success = glslang::InitializeProcess();
+    if (success) {
+      printf("GLSLang Initialized.\n");
+    }
+    else {
+      printf("Failed to initialize GLSLang.\n");
+    }
+#endif // ANDROID
+}
+
+KRPipelineManager::~KRPipelineManager() {
+#ifndef ANDROID
+  glslang::FinalizeProcess();
+#endif // ANDROID
+}
+
+
+KRPipeline *KRPipelineManager::getPipeline(const std::string &pipeline_name, KRCamera *pCamera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, bool bRimColor) {
+    
+    int iShadowQuality = 0; // FINDME - HACK - Placeholder code, need to iterate through lights and dynamically build shader
+
+
+    int light_directional_count = 0;
+    int light_point_count = 0;
+    int light_spot_count = 0;
+    if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
+        light_directional_count = (int)directional_lights.size();
+        light_point_count = (int)point_lights.size();
+        light_spot_count = (int)spot_lights.size();
+        for(std::vector<KRDirectionalLight *>::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) {
+            KRDirectionalLight *directional_light =(*light_itr);
+            iShadowQuality = directional_light->getShadowBufferCount();
+        }
+    }
+    
+    if(iShadowQuality > pCamera->settings.m_cShadowBuffers) {
+        iShadowQuality = pCamera->settings.m_cShadowBuffers;
+    }
+    
+    bool bFadeColorEnabled = pCamera->getFadeColor().w >= 0.0f;
+    
+    std::pair<std::string, std::vector<int> > key;
+    key.first = pipeline_name;
+    key.second.push_back(light_directional_count);
+    key.second.push_back(light_point_count);
+    key.second.push_back(light_spot_count);
+    key.second.push_back(pCamera->settings.fog_type);
+    key.second.push_back(pCamera->settings.bEnablePerPixel);
+    key.second.push_back(bAlphaTest);
+    key.second.push_back(bAlphaBlend);
+    key.second.push_back(bDiffuseMap);
+    key.second.push_back(bNormalMap);
+    key.second.push_back(bSpecMap);
+    key.second.push_back(bReflectionMap);
+    key.second.push_back(bone_count);
+    key.second.push_back(bSpecMap);
+    key.second.push_back(bReflectionMap);
+    key.second.push_back(bReflectionCubeMap);
+    key.second.push_back(pCamera->settings.bDebugPSSM);
+    key.second.push_back(iShadowQuality);
+    key.second.push_back(pCamera->settings.bEnableAmbient);
+    key.second.push_back(pCamera->settings.bEnableDiffuse);
+    key.second.push_back(pCamera->settings.bEnableSpecular);
+    key.second.push_back(bLightMap);
+    key.second.push_back(bDiffuseMapScale);
+    key.second.push_back(bSpecMapScale);
+    key.second.push_back(bReflectionMapScale);
+    key.second.push_back(bNormalMapScale);
+    key.second.push_back(bDiffuseMapOffset);
+    key.second.push_back(bSpecMapOffset);
+    key.second.push_back(bReflectionMapOffset);
+    key.second.push_back(bNormalMapOffset);
+    key.second.push_back(pCamera->settings.volumetric_environment_enable);
+    key.second.push_back(pCamera->settings.volumetric_environment_downsample != 0);
+    key.second.push_back(renderPass);
+    key.second.push_back(pCamera->settings.dof_quality);
+    key.second.push_back(pCamera->settings.bEnableFlash);
+    key.second.push_back(pCamera->settings.bEnableVignette);
+    key.second.push_back((int)(pCamera->settings.dof_depth * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.dof_falloff * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.flash_depth * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.flash_falloff * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.flash_intensity * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.vignette_radius * 1000.0f));
+    key.second.push_back((int)(pCamera->settings.vignette_falloff * 1000.0f));
+    key.second.push_back(bRimColor);
+    key.second.push_back(bFadeColorEnabled);
+              
+                         
+    KRPipeline *pPipeline = m_pipelines[key];
+    
+    
+    if(pPipeline == NULL) {
+        if(m_pipelines.size() > KRContext::KRENGINE_MAX_PIPELINE_HANDLES) {
+            // Keep the size of the pipeline cache reasonable
+            std::map<std::pair<std::string, std::vector<int> > , KRPipeline *>::iterator itr = m_pipelines.begin();
+            delete (*itr).second;
+            m_pipelines.erase(itr);
+            KRContext::Log(KRContext::LOG_LEVEL_INFORMATION, "Swapping pipelines...\n");
+        }
+        
+        stringstream stream;
+        stream.precision(std::numeric_limits<long double>::digits10);
+
+#if TARGET_OS_IPHONE
+#else
+        stream << "\n#version 150";
+        stream << "\n#define lowp";
+        stream << "\n#define mediump";
+        stream << "\n#define highp";
+#endif
+        
+        stream << "\n#define LIGHT_DIRECTIONAL_COUNT " << light_directional_count;
+        stream << "\n#define LIGHT_POINT_COUNT " << light_point_count;
+        stream << "\n#define LIGHT_SPOT_COUNT " << light_spot_count;
+        stream << "\n#define BONE_COUNT " << bone_count;
+        
+        stream << "\n#define HAS_DIFFUSE_MAP " << (bDiffuseMap ? "1" : "0");
+        stream << "\n#define HAS_DIFFUSE_MAP_SCALE " << (bDiffuseMapScale ? "1" : "0");
+        stream << "\n#define HAS_DIFFUSE_MAP_OFFSET " << (bDiffuseMapOffset ? "1" : "0");
+        
+        stream << "\n#define HAS_SPEC_MAP " << (bSpecMap ? "1" : "0");
+        stream << "\n#define HAS_SPEC_MAP_SCALE " << (bSpecMapScale ? "1" : "0");
+        stream << "\n#define HAS_SPEC_MAP_OFFSET " << (bSpecMapOffset ? "1" : "0");
+        
+        stream << "\n#define HAS_NORMAL_MAP " << (bNormalMap ? "1" : "0");
+        stream << "\n#define HAS_NORMAL_MAP_SCALE " << (bNormalMapScale ? "1" : "0");
+        stream << "\n#define HAS_NORMAL_MAP_OFFSET " << (bNormalMapOffset ? "1" : "0");
+        
+        stream << "\n#define HAS_REFLECTION_MAP " << (bReflectionMap ? "1" : "0");
+        stream << "\n#define HAS_REFLECTION_MAP_SCALE " << (bReflectionMapScale ? "1" : "0");
+        stream << "\n#define HAS_REFLECTION_MAP_OFFSET " << (bReflectionMapOffset ? "1" : "0");
+        
+        stream << "\n#define HAS_LIGHT_MAP " << (bLightMap ? "1" : "0");
+        stream << "\n#define HAS_REFLECTION_CUBE_MAP " << (bReflectionCubeMap ? "1" : "0");
+        
+        stream << "\n#define ALPHA_TEST " << (bAlphaTest ? "1" : "0");
+        stream << "\n#define ALPHA_BLEND " << (bAlphaBlend ? "1" : "0");
+        
+        stream << "\n#define ENABLE_PER_PIXEL " << (pCamera->settings.bEnablePerPixel ? "1" : "0");
+        stream << "\n#define DEBUG_PSSM " << (pCamera->settings.bDebugPSSM ? "1" : "0");
+        stream << "\n#define SHADOW_QUALITY " << iShadowQuality;
+        stream << "\n#define ENABLE_AMBIENT " << (pCamera->settings.bEnableAmbient ? "1" : "0");
+        stream << "\n#define ENABLE_DIFFUSE " << (pCamera->settings.bEnableDiffuse ? "1" : "0");
+        stream << "\n#define ENABLE_SPECULAR " << (pCamera->settings.bEnableSpecular ? "1" : "0");
+        stream << "\n#define ENABLE_RIM_COLOR " << (bRimColor ? "1" : "0");
+        stream << "\n#define ENABLE_FADE_COLOR " << (bFadeColorEnabled ? "1" : "0");
+        stream << "\n#define FOG_TYPE " << pCamera->settings.fog_type;
+        switch(renderPass) {
+            case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
+                stream << "\n#define GBUFFER_PASS " << 1;
+                break;
+            case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
+                stream << "\n#define GBUFFER_PASS " << 2;
+                break;
+            case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
+                stream << "\n#define GBUFFER_PASS " << 3;
+                break;
+            default:
+                stream << "\n#define GBUFFER_PASS " << 0;
+                break;
+        }
+
+        stream << "\n#define DOF_QUALITY " << pCamera->settings.dof_quality;
+        stream << "\n#define ENABLE_FLASH " << (pCamera->settings.bEnableFlash ? "1" : "0");
+        stream << "\n#define ENABLE_VIGNETTE " << (pCamera->settings.bEnableVignette ? "1" : "0");
+        stream << "\n#define VOLUMETRIC_ENVIRONMENT_DOWNSAMPLED " << (pCamera->settings.volumetric_environment_enable && pCamera->settings.volumetric_environment_downsample != 0 ? "1" : "0");
+        
+        
+        stream.setf(ios::fixed,ios::floatfield);
+        
+        stream.precision(std::numeric_limits<long double>::digits10);
+        
+        stream << "\n#define DOF_DEPTH " << pCamera->settings.dof_depth;
+        stream << "\n#define DOF_FALLOFF " << pCamera->settings.dof_falloff;
+        stream << "\n#define FLASH_DEPTH " << pCamera->settings.flash_depth;
+        stream << "\n#define FLASH_FALLOFF " << pCamera->settings.flash_falloff;
+        stream << "\n#define FLASH_INTENSITY " << pCamera->settings.flash_intensity;
+        stream << "\n#define VIGNETTE_RADIUS " << pCamera->settings.vignette_radius;
+        stream << "\n#define VIGNETTE_FALLOFF " << pCamera->settings.vignette_falloff;
+        
+        stream << "\n";
+        std::string options = stream.str();
+
+        KRSourceManager *sourceManager = m_pContext->getSourceManager();
+        KRSource *vertSource = sourceManager->get(pipeline_name.c_str(), "vert");
+        KRSource *fragSource = sourceManager->get(pipeline_name.c_str(), "frag");
+        
+        if(vertSource == nullptr) {
+            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Vertex Shader Missing: %s", pipeline_name.c_str());
+        }
+        if(fragSource == nullptr) {
+            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Fragment Shader Missing: %s", pipeline_name.c_str());
+        }
+        
+        Vector4 fade_color = pCamera->getFadeColor();
+        
+        char szKey[256];
+        sprintf(szKey, "%i_%i_%i_%i_%i_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%i_%s_%i_%d_%d_%f_%f_%f_%f_%f_%f_%f_%f_%f_%f_%f", light_directional_count, light_point_count, light_spot_count, bone_count, pCamera->settings.fog_type, pCamera->settings.bEnablePerPixel,bAlphaTest, bAlphaBlend, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, pCamera->settings.bDebugPSSM, iShadowQuality, pCamera->settings.bEnableAmbient, pCamera->settings.bEnableDiffuse, pCamera->settings.bEnableSpecular, bLightMap, bDiffuseMapScale, bSpecMapScale, bReflectionMapScale, bNormalMapScale, bDiffuseMapOffset, bSpecMapOffset, bReflectionMapOffset, bNormalMapOffset,pCamera->settings.volumetric_environment_enable && pCamera->settings.volumetric_environment_downsample != 0, renderPass, pipeline_name.c_str(),pCamera->settings.dof_quality,pCamera->settings.bEnableFlash,pCamera->settings.bEnableVignette,pCamera->settings.dof_depth,pCamera->settings.dof_falloff,pCamera->settings.flash_depth,pCamera->settings.flash_falloff,pCamera->settings.flash_intensity,pCamera->settings.vignette_radius,pCamera->settings.vignette_falloff, fade_color.x, fade_color.y, fade_color.z, fade_color.w);
+        
+        pPipeline = new KRPipeline(getContext(), szKey, options, vertSource->getData()->getString(), fragSource->getData()->getString());
+
+        m_pipelines[key] = pPipeline;
+    }
+    return pPipeline;
+}
+
+bool KRPipelineManager::selectPipeline(const std::string &pipeline_name, KRCamera &camera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRViewport &viewport, const Matrix4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color)
+{
+    KRPipeline *pPipeline = getPipeline(pipeline_name, &camera, point_lights, directional_lights, spot_lights, bone_count, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, bDiffuseMapScale, bSpecMapScale, bNormalMapScale, bReflectionMapScale, bDiffuseMapOffset, bSpecMapOffset, bNormalMapOffset, bReflectionMapOffset, bAlphaTest, bAlphaBlend, renderPass, rim_power != 0.0f);
+    return selectPipeline(camera, pPipeline, viewport, matModel, point_lights, directional_lights, spot_lights, bone_count, renderPass, rim_color, rim_power, fade_color);
+}
+
+bool KRPipelineManager::selectPipeline(KRCamera &camera, KRPipeline *pPipeline, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color)
+{
+    if(pPipeline) {
+        return pPipeline->bind(camera, viewport, matModel, point_lights, directional_lights, spot_lights, renderPass, rim_color, rim_power, fade_color);
+    } else {
+        return false;
+    }
+}
+
+size_t KRPipelineManager::getPipelineHandlesUsed() {
+    return m_pipelines.size();
+}

kraken/KRPipelineManager.h

@@ -0,0 +1,69 @@
+//
+//  KRPipelineManager.h
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//  
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//  
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//  
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//  
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//  
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+
+#include "KREngine-common.h"
+
+#include "KRCamera.h"
+#include "KRDataBlock.h"
+#include "KRNode.h"
+
+using std::map;
+using std::vector;
+
+#include "KRPipeline.h"
+
+#ifndef KRPIPELINEMANAGER_H
+#define KRPIPELINEMANAGER_H
+
+class KRPipeline;
+class KRCamera;
+
+class KRPipelineManager : public KRContextObject {
+public:
+    KRPipelineManager(KRContext &context);
+    virtual ~KRPipelineManager();
+    
+    KRPipeline *getPipeline(const std::string &pipeline_name, KRCamera *pCamera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, bool bRimColor = false);
+    
+    bool selectPipeline(KRCamera &camera, KRPipeline *pPipeline, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
+    
+    bool selectPipeline(const std::string &pipeline_name, KRCamera &camera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRViewport &viewport, const Matrix4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
+    
+    size_t getPipelineHandlesUsed();
+    
+    KRPipeline *m_active_pipeline;
+
+private:
+    std::map<std::pair<std::string, std::vector<int> >, KRPipeline *> m_pipelines;
+};
+
+#endif

kraken/KRPointLight.cpp

@@ -67,15 +67,15 @@ void KRPointLight::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_
             
             bool bInsideLight = view_light_position.sqrMagnitude() <= (influence_radius + pCamera->settings.getPerspectiveNearZ()) * (influence_radius + pCamera->settings.getPerspectiveNearZ());
             
-            KRShader *pShader = getContext().getShaderManager()->getShader(bVisualize ? "visualize_overlay" : (bInsideLight ? "light_point_inside" : "light_point"), pCamera, this_light, std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+            KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(bVisualize ? "visualize_overlay" : (bInsideLight ? "light_point_inside" : "light_point"), pCamera, this_light, std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
-            if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, this_light, std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+            if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, sphereModelMatrix, this_light, std::vector<KRDirectionalLight *>(), std::vector<KRSpotLight *>(), 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
                 
                 
-                pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_COLOR, m_color);
+                pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_COLOR, m_color);
-                pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f);
+                pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f);
-                pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_DECAY_START, getDecayStart());
+                pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_DECAY_START, getDecayStart());
-                pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_CUTOFF, KRLIGHT_MIN_INFLUENCE);                
+                pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_CUTOFF, KRLIGHT_MIN_INFLUENCE);                
-                pShader->setUniform(KRShader::KRENGINE_UNIFORM_LIGHT_POSITION, light_position);
+                pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_LIGHT_POSITION, light_position);
 
                 
                 if(bVisualize) {
@@ -127,7 +127,7 @@ void KRPointLight::generateMesh() {
     // Based on algorithm from Paul Bourke: http://paulbourke.net/miscellaneous/sphere_cylinder/
     
     int iterations = 3;
-    int facet_count = pow(4, iterations) * 8;
+    int facet_count = (int)(pow(4, iterations) * 8);
     
     if(m_cVertices != facet_count * 3) {
         if(m_sphereVertices) {

kraken/KRResource+blend.cpp

@@ -13,10 +13,8 @@
 #include "KRResource+blend.h"
 
 
-std::vector<KRResource *> KRResource::LoadBlenderScene(KRContext &context, const std::string& path) {
+KRScene* KRResource::LoadBlenderScene(KRContext &context, const std::string& path) {
-    std::vector<KRResource *> resources;
     KRScene *pScene = new KRScene(context, KRResource::GetFileBase(path));
-    resources.push_back(pScene);
     
     KRDataBlock data;
     
@@ -24,7 +22,7 @@ std::vector<KRResource *> KRResource::LoadBlenderScene(KRContext &context, const
         //KRBlendFile blend_file = KRBlendFile(pFile);
     }
     
-    return resources;
+    return pScene;
 }
 
 

kraken/KRResource+fbx.cpp

@@ -7,9 +7,6 @@
 //
 
 #include "KREngine-common.h"
-#include <boost/tokenizer.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/variant.hpp>
 #include "fbxsdk.h"
 
 

kraken/KRResource+obj.cpp

@@ -11,12 +11,9 @@
 #include "KRResource.h"
 #include "KRMesh.h"
 
-std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::string& path)
+KRMesh* KRResource::LoadObj(KRContext &context, const std::string& path)
 {    
-    std::vector<KRResource *> resources;
-    
     KRMesh *new_mesh = new KRMesh(context, KRResource::GetFileBase(path));
-    resources.push_back(new_mesh);
     
     KRMesh::mesh_info mi;
     
@@ -216,7 +213,7 @@ std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::str
                 } else if(strcmp(szSymbol[0], "usemtl") == 0) {
                     // Use Material (usemtl)
                     if(pFace - pMaterialFaces > 1) {
-                        *pMaterialFaces = pFace - pMaterialFaces - 1;
+                        *pMaterialFaces = (int)(pFace - pMaterialFaces - 1);
                         pMaterialFaces = pFace++;
                     }
                 }
@@ -224,7 +221,7 @@ std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::str
         }
         
         
-        *pMaterialFaces = pFace - pMaterialFaces - 1;
+        *pMaterialFaces = (int)(pFace - pMaterialFaces - 1);
         *pFace++ = 0;
         
         
@@ -235,7 +232,7 @@ std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::str
         KRMesh::pack_material *pMaterial = new KRMesh::pack_material();
         pMaterial->start_vertex = iVertex;
         pMaterial->vertex_count = 0;
-        memset(pMaterial->szName, 256, 0);
+        memset(pMaterial->szName, 0, 256);
         if(material_itr < material_names_t.end()) {
             strncpy(pMaterial->szName, (*material_itr++).c_str(), 256);
         }
@@ -301,7 +298,7 @@ std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::str
                 pMaterial = new KRMesh::pack_material();
                 pMaterial->start_vertex = iVertex;
                 pMaterial->vertex_count = 0;
-                memset(pMaterial->szName, 256, 0);
+                memset(pMaterial->szName, 0, 256);
                 
                 if(material_itr < material_names_t.end()) {
                     strncpy(pMaterial->szName, (*material_itr++).c_str(), 256);
@@ -337,5 +334,5 @@ std::vector<KRResource *> KRResource::LoadObj(KRContext &context, const std::str
         free(pFaces);
     }
     
-    return resources;
+    return new_mesh;
 }

kraken/KRResource.cpp

@@ -8,6 +8,7 @@
 
 #include "KREngine-common.h"
 #include "KRResource.h"
+#include "KRBundle.h"
 
 KRResource::KRResource(KRContext &context, std::string name) : KRContextObject(context) {
     m_name = name;
@@ -33,6 +34,10 @@ std::string KRResource::GetFileExtension(const std::string& name)
 std::string KRResource::GetFileBase(const std::string& name)
 {
     std::string f = name;
+
+    // Normalize Windows Paths
+    std::replace(f.begin(), f.end(), '\\', '/');
+
     // Strip off directory
     if(f.find_last_of("/") != std::string::npos) {
         f = f.substr(f.find_last_of("/") + 1);
@@ -64,3 +69,14 @@ bool KRResource::save(const std::string& path)
         return false;
     }
 }
+
+KrResult KRResource::moveToBundle(KRBundle* bundle)
+{
+  KRDataBlock* data = bundle->append(*this);
+  if (data == nullptr) {
+    return KR_ERROR_UNEXPECTED;
+  }
+  // TODO(kearwood) - We must re-attach the KRResource to the returned KRDataBlock
+  delete data;
+  return KR_SUCCESS;
+}

kraken/KRResource.h

@@ -12,7 +12,9 @@
 
 #ifndef KRRESOURCE_H
 #define KRRESOURCE_H
-
+class KRBundle;
+class KRScene;
+class KRMesh;
 class KRResource : public KRContextObject
 {
 public:
@@ -21,17 +23,18 @@ public:
     virtual bool save(const std::string& path);
     virtual bool save(KRDataBlock &data) = 0;
 
+    KrResult moveToBundle(KRBundle* bundle);
+    
     static std::string GetFileExtension(const std::string& name);
     static std::string GetFileBase(const std::string& name);
     static std::string GetFilePath(const std::string& name);
     
     virtual ~KRResource();
     
-    
+    static KRMesh* LoadObj(KRContext &context, const std::string& path);
-    static std::vector<KRResource *> LoadObj(KRContext &context, const std::string& path);
 #if !TARGET_OS_IPHONE
-    static void LoadFbx(KRContext &context, const std::string& path);
+//    static KRScene* LoadFbx(KRContext &context, const std::string& path); TODO, FINDME, HACK! - Uncomment
-    static std::vector<KRResource *> LoadBlenderScene(KRContext &context, const std::string& path);
+    static KRScene* LoadBlenderScene(KRContext &context, const std::string& path);
 #endif
    
 protected:

kraken/KRResourceManager.cpp

@@ -1,8 +1,8 @@
 //
-//  flare.fsh
+//  KRResourceManager.cpp
 //  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -29,6 +29,15 @@
 //  or implied, of Kearwood Gilbert.
 //
 
-void main() {
+#include "KRResourceManager.h"
-    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+#include "KREngine-common.h"
+
+KRResourceManager::KRResourceManager(KRContext &context) : KRContextObject(context)
+{
+    
+}
+
+KRResourceManager::~KRResourceManager()
+{
+
 }

kraken/KRResourceManager.h

@@ -1,7 +1,8 @@
 //
-//  sky_box.vsh
+//  KRResourceManager.h
 //  KREngine
 //
+//
 //  Copyright 2012 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
@@ -28,22 +29,22 @@
 //  authors and should not be interpreted as representing official policies, either expressed
 //  or implied, of Kearwood Gilbert.
 //
-//
 
-attribute vec4 vertex_position;
+#ifndef KRRESOURCEMANAGER_H
-//attribute lowp vec4 vertex_uv;
+#define KRRESOURCEMANAGER_H
-//
+#include "KREngine-common.h"
-//varying mediump vec2 textureCoordinate;
 
-varying mediump vec3    texCoord;
+#include "KRResource.h"
-uniform highp mat4      inv_mvp_matrix_no_translate; // Inverse of the model-view-projection matrix, without view translation component
+#include "KRContextObject.h"
-uniform mediump vec4 viewport;
+#include "KRDataBlock.h"
 
-void main()
+class KRResourceManager : public KRContextObject {
-{
+public:
-	gl_Position = vec4(vertex_position.xy, 1.0, 1.0);
+    KRResourceManager(KRContext &context);
+    virtual ~KRResourceManager();
     
-    vec4 t = inv_mvp_matrix_no_translate * vec4(vertex_position.xy, 1.0, 1.0);
+    virtual KRResource* loadResource(const std::string &name, const std::string &extension, KRDataBlock *data) = 0;
-    t *= 1.0 / t.w;
+    virtual KRResource* getResource(const std::string &name, const std::string &extension) = 0;
-    texCoord = vec3(t);
+};
-}
+
+#endif // KRRESOURCEMANAGER_H

kraken/KRReverbZone.cpp

@@ -95,9 +95,9 @@ void KRReverbZone::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_
     if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
         Matrix4 sphereModelMatrix = getModelMatrix();
         
-        KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+        KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
         
-        if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+        if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
             
             // Enable additive blending
             GLDEBUG(glEnable(GL_BLEND));

kraken/KRScene.cpp

@@ -298,7 +298,7 @@ void KRScene::render(KROctreeNode *pOctreeNode, unordered_map<AABB, int> &visibl
                         GLDEBUG(glDepthMask(GL_FALSE));
                     }
                     
-                    if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, matModel, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+                    if(getContext().getPipelineManager()->selectPipeline("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, matModel, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, Vector3::Zero(), 0.0f, Vector4::Zero())) {
                         GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 14));
                         m_pContext->getMeshManager()->log_draw_call(renderPass, "octree", "occlusion_test", 14);
                     }
@@ -565,7 +565,7 @@ void KRScene::addDefaultLights()
 {
     KRDirectionalLight *light1 = new KRDirectionalLight(*this, "default_light1");
     
-    light1->setLocalRotation((Quaternion::Create(Vector3::Create(0.0f, M_PI * 0.10f, 0.0f)) * Quaternion::Create(Vector3::Create(0.0f, 0.0f, -M_PI * 0.15f))).eulerXYZ());
+    light1->setLocalRotation((Quaternion::Create(Vector3::Create(0.0f, (float)M_PI * 0.10f, 0.0f)) * Quaternion::Create(Vector3::Create(0.0f, 0.0f, (float)-M_PI * 0.15f))).eulerXYZ());
     m_pRootNode->addChild(light1);
 }
 

kraken/KRSceneManager.cpp

@@ -32,7 +32,7 @@
 #include "KRSceneManager.h"
 #include "KRScene.h"
 
-KRSceneManager::KRSceneManager(KRContext &context) : KRContextObject(context){
+KRSceneManager::KRSceneManager(KRContext &context) : KRResourceManager(context){
 }
 
 KRSceneManager::~KRSceneManager() {
@@ -42,6 +42,21 @@ KRSceneManager::~KRSceneManager() {
     m_scenes.empty();
 }
 
+KRResource* KRSceneManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("krscene") == 0) {
+    return loadScene(name, data);
+  }
+  return nullptr;
+}
+KRResource* KRSceneManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("krscene") == 0) {
+    return getScene(name);
+  }
+  return nullptr;
+}
+
 KRScene *KRSceneManager::loadScene(const std::string &name, KRDataBlock *data) {
     std::string lowerName = name;
     std::transform(lowerName.begin(), lowerName.end(),

kraken/KRSceneManager.h

@@ -33,17 +33,22 @@
 #define KRENGINE_KRSCENEMANAGER_H
 
 #include "KREngine-common.h"
+
+#include "KRResourceManager.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 
 class KRScene;
 
 
-class KRSceneManager : public KRContextObject {
+class KRSceneManager : public KRResourceManager {
 public:
     KRSceneManager(KRContext &context);
     virtual ~KRSceneManager();
     
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+
     void add(KRScene *scene);
     KRScene *loadScene(const std::string &name, KRDataBlock *data);
 

kraken/KRShader.cpp

@@ -2,7 +2,7 @@
 //  KRShader.cpp
 //  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -30,567 +30,36 @@
 //
 
 #include "KRShader.h"
-#include "assert.h"
-#include "KRLight.h"
-#include "KRDirectionalLight.h"
-#include "KRSpotLight.h"
-#include "KRPointLight.h"
 
-
+KRShader::KRShader(KRContext &context, std::string name, std::string extension) : KRResource(context, name)
-const char *KRShader::KRENGINE_UNIFORM_NAMES[] = {
-    "material_ambient", // KRENGINE_UNIFORM_MATERIAL_AMBIENT
-    "material_diffuse", // KRENGINE_UNIFORM_MATERIAL_DIFFUSE
-    "material_specular", // KRENGINE_UNIFORM_MATERIAL_SPECULAR
-    "material_reflection", // KRENGINE_UNIFORM_MATERIAL_REFLECTION
-    "material_alpha", // KRENGINE_UNIFORM_MATERIAL_ALPHA
-    "material_shininess", // KRENGINE_UNIFORM_MATERIAL_SHININESS
-    "light_position", // KRENGINE_UNIFORM_LIGHT_POSITION
-    "light_direction_model_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE
-    "light_direction_view_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE
-    "light_color", //    KRENGINE_UNIFORM_LIGHT_COLOR
-    "light_decay_start", //    KRENGINE_UNIFORM_LIGHT_DECAY_START
-    "light_cutoff", //    KRENGINE_UNIFORM_LIGHT_CUTOFF
-    "light_intensity", //    KRENGINE_UNIFORM_LIGHT_INTENSITY
-    "flare_size", //    KRENGINE_UNIFORM_FLARE_SIZE
-    "view_space_model_origin", //    KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN
-    "mvp_matrix", //    KRENGINE_UNIFORM_MVP
-    "inv_projection_matrix", //    KRENGINE_UNIFORM_INVP
-    "inv_mvp_matrix", //    KRENGINE_UNIFORM_INVMVP
-    "inv_mvp_matrix_no_translate", //    KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE
-    "model_view_inverse_transpose_matrix", //    KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE
-    "model_inverse_transpose_matrix", //    KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE
-    "model_view_matrix", //    KRENGINE_UNIFORM_MODEL_VIEW
-    "model_matrix", //    KRENGINE_UNIFORM_MODEL_MATRIX
-    "projection_matrix", //    KRENGINE_UNIFORM_PROJECTION_MATRIX
-    "camera_position_model_space", //    KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE
-    "viewport", //    KRENGINE_UNIFORM_VIEWPORT
-    "viewport_downsample", //     KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE
-    "diffuseTexture", //    KRENGINE_UNIFORM_DIFFUSETEXTURE
-    "specularTexture", //    KRENGINE_UNIFORM_SPECULARTEXTURE
-    "reflectionCubeTexture", //    KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE
-    "reflectionTexture", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE
-    "normalTexture", //    KRENGINE_UNIFORM_NORMALTEXTURE
-    "diffuseTexture_Scale", //    KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE
-    "specularTexture_Scale", //    KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE
-    "reflectionTexture_Scale", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE
-    "normalTexture_Scale", //    KRENGINE_UNIFORM_NORMALTEXTURE_SCALE
-    "normalTexture_Scale", //    KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE
-    "diffuseTexture_Offset", //    KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET
-    "specularTexture_Offset", //    KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET
-    "reflectionTexture_Offset", //    KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET
-    "normalTexture_Offset", //    KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET
-    "ambientTexture_Offset", //    KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET
-    "shadow_mvp1", //    KRENGINE_UNIFORM_SHADOWMVP1
-    "shadow_mvp2", //    KRENGINE_UNIFORM_SHADOWMVP2
-    "shadow_mvp3", //    KRENGINE_UNIFORM_SHADOWMVP3
-    "shadowTexture1", //    KRENGINE_UNIFORM_SHADOWTEXTURE1
-    "shadowTexture2", //    KRENGINE_UNIFORM_SHADOWTEXTURE2
-    "shadowTexture3", //    KRENGINE_UNIFORM_SHADOWTEXTURE3
-    "lightmapTexture", //    KRENGINE_UNIFORM_LIGHTMAPTEXTURE
-    "gbuffer_frame", //    KRENGINE_UNIFORM_GBUFFER_FRAME
-    "gbuffer_depth", //    KRENGINE_UNIFORM_GBUFFER_DEPTH
-    "depthFrame", //    KRENGINE_UNIFORM_DEPTH_FRAME
-    "volumetricEnvironmentFrame", //    KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME
-    "renderFrame", //    KRENGINE_UNIFORM_RENDER_FRAME
-    "time_absolute", //    KRENGINE_UNIFORM_ABSOLUTE_TIME
-    "fog_near", //    KRENGINE_UNIFORM_FOG_NEAR
-    "fog_far", //    KRENGINE_UNIFORM_FOG_FAR
-    "fog_density", //    KRENGINE_UNIFORM_FOG_DENSITY
-    "fog_color", //    KRENGINE_UNIFORM_FOG_COLOR
-    "fog_scale", //    KRENGINE_UNIFORM_FOG_SCALE
-    "fog_density_premultiplied_exponential", //    KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL
-    "fog_density_premultiplied_squared", //    KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED
-    "slice_depth_scale", //    KRENGINE_UNIFORM_SLICE_DEPTH_SCALE
-    "particle_origin", //    KRENGINE_UNIFORM_PARTICLE_ORIGIN
-    "bone_transforms", //    KRENGINE_UNIFORM_BONE_TRANSFORMS
-    "rim_color", // KRENGINE_UNIFORM_RIM_COLOR
-    "rim_power", // KRENGINE_UNIFORM_RIM_POWER
-    "fade_color", // KRENGINE_UNIFORM_FADE_COLOR
-};
-
-KRShader::KRShader(KRContext &context, char *szKey, std::string options, std::string vertShaderSource, const std::string fragShaderSource) : KRContextObject(context)
 {
-    strcpy(m_szKey, szKey);
+    m_pData = new KRDataBlock();
-    m_iProgram = 0;
+    m_extension = extension;
-    
-    
-    GLuint vertexShader = 0, fragShader = 0;
-    try {
-        const GLchar *vertSource[2] = {options.c_str(), vertShaderSource.c_str()};
-        const GLchar *fragSource[2] = {options.c_str(), fragShaderSource.c_str()};
-        
-        // Create shader program.
-        GLDEBUG(m_iProgram = glCreateProgram());
-        
-        // Create and compile vertex shader.
-        GLDEBUG(vertexShader = glCreateShader(GL_VERTEX_SHADER));
-        GLDEBUG(glShaderSource(vertexShader, 2, vertSource, NULL));
-        GLDEBUG(glCompileShader(vertexShader));
-        
-        // Report any compile issues to stderr
-        GLint logLength = 0;
-        GLDEBUG(glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength));
-        if (logLength > 0) {
-            GLchar *log = (GLchar *)malloc(logLength + 1);
-            assert(log != NULL);
-            log[0] = '\0'; // In case glGetShaderInfoLog fails
-            GLDEBUG(glGetShaderInfoLog(vertexShader, logLength, &logLength, log));
-            log[logLength] = '\0';
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile vertex shader: %s\nShader compile log:\n%s", szKey, log);
-            free(log);
 }
 
-        
+KRShader::KRShader(KRContext &context, std::string name, std::string extension, KRDataBlock *data) : KRResource(context, name)
-        // Create and compile vertex shader.
-        GLDEBUG(fragShader = glCreateShader(GL_FRAGMENT_SHADER));
-        GLDEBUG(glShaderSource(fragShader, 2, fragSource, NULL));
-        GLDEBUG(glCompileShader(fragShader));
-        
-        // Report any compile issues to stderr
-        logLength = 0; // In case glGetShaderiv fails
-        GLDEBUG(glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength));
-        if (logLength > 0) {
-            GLchar *log = (GLchar *)malloc(logLength + 1);
-            assert(log != NULL);
-            log[0] = '\0'; // In case glGetShaderInfoLog fails
-            GLDEBUG(glGetShaderInfoLog(fragShader, logLength, &logLength, log));
-            log[logLength] = '\0';
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile fragment shader: %s\nShader compile log:\n%s", szKey, log);
-            free(log);
-        }
-        
-        // Attach vertex shader to program.
-        GLDEBUG(glAttachShader(m_iProgram, vertexShader));
-        
-        // Attach fragment shader to program.
-        GLDEBUG(glAttachShader(m_iProgram, fragShader));
-        
-        // Bind attribute locations.
-        // This needs to be done prior to linking.
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_VERTEX, "vertex_position"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_NORMAL, "vertex_normal"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TANGENT, "vertex_tangent"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVA, "vertex_uv"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEINDEXES, "bone_indexes"));
-        GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEWEIGHTS, "bone_weights"));
-        
-        // Link program.
-        GLDEBUG(glLinkProgram(m_iProgram));
-        
-        GLint link_success = GL_FALSE;
-        GLDEBUG(glGetProgramiv(m_iProgram, GL_LINK_STATUS, &link_success));
-        
-        if(link_success != GL_TRUE) {
-            // Report any linking issues to stderr
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to link shader program: %s", szKey);
-            logLength = 0; // In case glGetProgramiv fails
-            GLDEBUG(glGetProgramiv(m_iProgram, GL_INFO_LOG_LENGTH, &logLength));
-            if (logLength > 0)
 {
-                GLchar *log = (GLchar *)malloc(logLength + 1);
+    m_pData = data;
-                assert(log != NULL);
+    m_extension = extension;
-                log[0] = '\0'; // In case glGetProgramInfoLog fails
-                GLDEBUG(glGetProgramInfoLog(m_iProgram, logLength, &logLength, log));
-                log[logLength] = '\0';
-                KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Program link log:\n%s", log);
-                free(log);
-            }
-            GLDEBUG(glDeleteProgram(m_iProgram));
-            m_iProgram = 0;
-        } else {
-        
-            // Get uniform locations
-            for(int i=0; i < KRENGINE_NUM_UNIFORMS; i++ ){
-                GLDEBUG(m_uniforms[i] = glGetUniformLocation(m_iProgram, KRENGINE_UNIFORM_NAMES[i]));
-                m_uniform_value_index[i] = -1;
-            }
 }
 
-    } catch(...) {
+KRShader::~KRShader()
-        if(vertexShader) {
-            GLDEBUG(glDeleteShader(vertexShader));
-            vertexShader = 0;
-        }
-        if(fragShader) {
-            GLDEBUG(glDeleteShader(fragShader));
-            fragShader = 0;
-        }
-        if(m_iProgram) {
-            GLDEBUG(glDeleteProgram(m_iProgram));
-            m_iProgram = 0;
-        }
-    }
-    
-    // Release vertex and fragment shaders.
-    if (vertexShader) {
-        GLDEBUG(glDeleteShader(vertexShader));
-	}
-    if (fragShader) {
-        GLDEBUG(glDeleteShader(fragShader));
-	}
-}
-
-KRShader::~KRShader() {
-    if(m_iProgram) {
-        GLDEBUG(glDeleteProgram(m_iProgram));
-        if(getContext().getShaderManager()->m_active_shader == this) {
-            getContext().getShaderManager()->m_active_shader = NULL;
-        }
-    }
-}
-
-void KRShader::setUniform(int location, float value)
 {
-    if(m_uniforms[location] != -1) {
+    delete m_pData;
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_float.size();
-            m_uniform_value_float.push_back(value);
-        } else if(m_uniform_value_float[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_float[value_index] = value;
 }
-        if(needs_update) {
+
-            GLDEBUG(glUniform1f(m_uniforms[location], value));
+std::string KRShader::getExtension()
-        }
-    }
-}
-void KRShader::setUniform(int location, int value)
 {
-    if(m_uniforms[location] != -1) {
+    return m_extension;
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_int.size();
-            m_uniform_value_int.push_back(value);
-        } else if(m_uniform_value_int[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_int[value_index] = value;
-        }
-        if(needs_update) {
-            GLDEBUG(glUniform1i(m_uniforms[location], value));
-        }
-    }
 }
 
-void KRShader::setUniform(int location, const Vector2 &value)
+bool KRShader::save(KRDataBlock &data)
 {
-    if(m_uniforms[location] != -1) {
+    data.append(*m_pData);
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_vector2.size();
-            m_uniform_value_vector2.push_back(value);
-        } else if(m_uniform_value_vector2[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_vector2[value_index] = value;
-        }
-        if(needs_update) {
-            GLDEBUG(glUniform2f(m_uniforms[location], value.x, value.y));
-        }
-    }
-}
-void KRShader::setUniform(int location, const Vector3 &value)
-{
-    if(m_uniforms[location] != -1) {
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_vector3.size();
-            m_uniform_value_vector3.push_back(value);
-        } else if(m_uniform_value_vector3[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_vector3[value_index] = value;
-        }
-        if(needs_update) {
-            GLDEBUG(glUniform3f(m_uniforms[location], value.x, value.y, value.z));
-        }
-    }
-}
-void KRShader::setUniform(int location, const Vector4 &value)
-{
-    if(m_uniforms[location] != -1) {
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_vector4.size();
-            m_uniform_value_vector4.push_back(value);
-        } else if(m_uniform_value_vector4[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_vector4[value_index] = value;
-        }
-        if(needs_update) {
-            GLDEBUG(glUniform4f(m_uniforms[location], value.x, value.y, value.z, value.w));
-        }
-    }
-}
-
-void KRShader::setUniform(int location, const Matrix4 &value)
-{
-    if(m_uniforms[location] != -1) {
-        int value_index = m_uniform_value_index[location];
-        bool needs_update = true;
-        if(value_index == -1) {
-            m_uniform_value_index[location] = m_uniform_value_mat4.size();
-            m_uniform_value_mat4.push_back(value);
-        } else if(m_uniform_value_mat4[value_index] == value) {
-            needs_update = false;
-        } else {
-            m_uniform_value_mat4[value_index] = value;
-        }
-        if(needs_update) {
-            GLDEBUG(glUniformMatrix4fv(m_uniforms[location], 1, GL_FALSE, value.c));
-        }
-    }
-}
-
-bool KRShader::bind(KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color) {
-    if(m_iProgram == 0) {
-        return false;
-    }
-    
-    bool shander_changed = false;
-    if(getContext().getShaderManager()->m_active_shader != this) {
-        getContext().getShaderManager()->m_active_shader = this;
-        GLDEBUG(glUseProgram(m_iProgram));
-        shander_changed = true;
-    }
-    
-    
-    setUniform(KRENGINE_UNIFORM_ABSOLUTE_TIME, getContext().getAbsoluteTime());
-    
-    int light_directional_count = 0;
-    //int light_point_count = 0;
-    //int light_spot_count = 0;
-    // TODO - Need to support multiple lights and more light types in forward rendering
-    if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
-        
-        
-        for(std::vector<KRDirectionalLight *>::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) {
-            KRDirectionalLight *directional_light = (*light_itr);
-            if(light_directional_count == 0) {
-                int cShadowBuffers = directional_light->getShadowBufferCount();
-                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE1] != -1 && cShadowBuffers > 0) {
-                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 3, directional_light->getShadowTextures()[0])) {
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-                    }
-                    
-                    m_pContext->getTextureManager()->_setWrapModeS(3, GL_CLAMP_TO_EDGE);
-                    m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE);
-                }
-                
-                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE2] != -1 && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) {
-                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 4, directional_light->getShadowTextures()[1])) {
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-                    }
-                    m_pContext->getTextureManager()->_setWrapModeS(4, GL_CLAMP_TO_EDGE);
-                    m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE);
-                }
-                
-                if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE3] != -1 && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) {
-                    if(m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 5, directional_light->getShadowTextures()[2])) {
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-                        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-                    }
-                    m_pContext->getTextureManager()->_setWrapModeS(5, GL_CLAMP_TO_EDGE);
-                    m_pContext->getTextureManager()->_setWrapModeT(5, GL_CLAMP_TO_EDGE);
-                }
-                
-                Matrix4 matBias;
-                matBias.translate(1.0, 1.0, 1.0);
-                matBias.scale(0.5);
-                for(int iShadow=0; iShadow < cShadowBuffers; iShadow++) {
-                    setUniform(KRENGINE_UNIFORM_SHADOWMVP1 + iShadow, matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias);
-                }
-                
-                if(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE] != -1) {
-                    Matrix4 inverseModelMatrix = matModel;
-                    inverseModelMatrix.invert();
-                    
-                    // Bind the light direction vector
-                    Vector3 lightDirObject = Matrix4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection());
-                    lightDirObject.normalize();
-                    setUniform(KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE, lightDirObject);
-                }
-            }
-            
-            light_directional_count++;
-        }
-
-        //light_point_count = point_lights.size();
-        //light_spot_count = spot_lights.size();
-    }
-    
-
-    
-    if(m_uniforms[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE] != -1) {
-        Matrix4 inverseModelMatrix = matModel;
-        inverseModelMatrix.invert();
-        
-        if(m_uniforms[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE] != -1) {
-            // Transform location of camera to object space for calculation of specular halfVec
-            Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition());
-            setUniform(KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, cameraPosObject);
-        }
-    }
-    
-    if(m_uniforms[KRENGINE_UNIFORM_MVP] != -1 || m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP] != -1) {
-        // Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
-        Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix();
-        setUniform(KRENGINE_UNIFORM_MVP, mvpMatrix);
-        
-        if(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP] != -1) {
-            setUniform(KRShader::KRENGINE_UNIFORM_INVMVP, Matrix4::Invert(mvpMatrix));
-        }
-    }
-    
-    if(m_uniforms[KRShader::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] != -1 || m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] != -1 || m_uniforms[KRShader::KRENGINE_UNIFORM_MODEL_VIEW] != -1) {
-        Matrix4 matModelView = matModel * viewport.getViewMatrix();
-        setUniform(KRENGINE_UNIFORM_MODEL_VIEW, matModelView);
-        
-        
-        if(m_uniforms[KRShader::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] != -1) {
-            Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position.  No perspective, so no w divide required
-            setUniform(KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin);
-        }
-        
-        if(m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] != -1) {
-            Matrix4 matModelViewInverseTranspose = matModelView;
-            matModelViewInverseTranspose.transpose();
-            matModelViewInverseTranspose.invert();
-            setUniform(KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE, matModelViewInverseTranspose);
-        }
-    }
-    
-    if(m_uniforms[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE] != -1) {
-        Matrix4 matModelInverseTranspose = matModel;
-        matModelInverseTranspose.transpose();
-        matModelInverseTranspose.invert();
-        setUniform(KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, matModelInverseTranspose);
-    }
-    
-    if(m_uniforms[KRShader::KRENGINE_UNIFORM_INVP] != -1) {
-        setUniform(KRENGINE_UNIFORM_INVP, viewport.getInverseProjectionMatrix());
-    }
-    
-    if(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE] != -1) {
-        Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();;
-        // Remove the translation
-        matInvMVPNoTranslate.getPointer()[3] = 0;
-        matInvMVPNoTranslate.getPointer()[7] = 0;
-        matInvMVPNoTranslate.getPointer()[11] = 0;
-        matInvMVPNoTranslate.getPointer()[12] = 0;
-        matInvMVPNoTranslate.getPointer()[13] = 0;
-        matInvMVPNoTranslate.getPointer()[14] = 0;
-        matInvMVPNoTranslate.getPointer()[15] = 1.0;
-        matInvMVPNoTranslate = matInvMVPNoTranslate * viewport.getProjectionMatrix();
-        matInvMVPNoTranslate.invert();
-        setUniform(KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE, matInvMVPNoTranslate);
-    }
-    
-    setUniform(KRENGINE_UNIFORM_MODEL_MATRIX, matModel);
-    if(m_uniforms[KRENGINE_UNIFORM_PROJECTION_MATRIX] != -1) {
-        setUniform(KRENGINE_UNIFORM_PROJECTION_MATRIX, viewport.getProjectionMatrix());
-    }
-    
-    if(m_uniforms[KRENGINE_UNIFORM_VIEWPORT] != -1) {
-        setUniform(KRENGINE_UNIFORM_VIEWPORT, Vector4::Create(
-                (GLfloat)0.0,
-                (GLfloat)0.0,
-                (GLfloat)viewport.getSize().x,
-                (GLfloat)viewport.getSize().y
-            )
-        );
-    }
-    
-    if(m_uniforms[KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE] != -1) {
-        setUniform(KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, camera.getDownsample());
-    }
-    
-    // Rim highlighting parameters
-    setUniform(KRENGINE_UNIFORM_RIM_COLOR, rim_color);
-    setUniform(KRENGINE_UNIFORM_RIM_POWER, rim_power);
-    
-    // Fade parameters
-    setUniform(KRENGINE_UNIFORM_FADE_COLOR, fade_color);
-    
-    // Fog parameters
-    setUniform(KRENGINE_UNIFORM_FOG_NEAR, camera.settings.fog_near);
-    setUniform(KRENGINE_UNIFORM_FOG_FAR, camera.settings.fog_far);
-    setUniform(KRENGINE_UNIFORM_FOG_DENSITY, camera.settings.fog_density);
-    setUniform(KRENGINE_UNIFORM_FOG_COLOR, camera.settings.fog_color);
-    
-    if(m_uniforms[KRENGINE_UNIFORM_FOG_SCALE] != -1) {
-        setUniform(KRENGINE_UNIFORM_FOG_SCALE, 1.0f / (camera.settings.fog_far - camera.settings.fog_near));
-    }
-    if(m_uniforms[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL] != -1) {
-        setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2)
-    }
-    if(m_uniforms[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED] != -1) {
-        setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2)
-    }
-    
-    // Sets the diffuseTexture variable to the first texture unit
-    setUniform(KRENGINE_UNIFORM_DIFFUSETEXTURE, 0);
-    
-    // Sets the specularTexture variable to the second texture unit
-    setUniform(KRENGINE_UNIFORM_SPECULARTEXTURE, 1);
-    
-    // Sets the normalTexture variable to the third texture unit
-    setUniform(KRENGINE_UNIFORM_NORMALTEXTURE, 2);
-    
-    // Sets the shadowTexture variable to the fourth texture unit
-    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE1, 3);
-    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE2, 4);
-    setUniform(KRENGINE_UNIFORM_SHADOWTEXTURE3, 5);
-    setUniform(KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE, 4);
-    setUniform(KRENGINE_UNIFORM_LIGHTMAPTEXTURE, 5);
-    setUniform(KRENGINE_UNIFORM_GBUFFER_FRAME, 6);
-    setUniform(KRENGINE_UNIFORM_GBUFFER_DEPTH, 7); // Texture unit 7 is used for reading the depth buffer in gBuffer pass #2 and in post-processing pass
-    setUniform(KRENGINE_UNIFORM_REFLECTIONTEXTURE, 7); // Texture unit 7 is used for the reflection map textures in gBuffer pass #3 and when using forward rendering
-    setUniform(KRENGINE_UNIFORM_DEPTH_FRAME, 0);
-    setUniform(KRENGINE_UNIFORM_RENDER_FRAME, 1);
-    setUniform(KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME, 2);
-    
-#if defined(DEBUG)
-    if(shander_changed) { // FINDME!! KIP!! HACK!!
-        GLint logLength;
-        
-        GLint validate_status = GL_FALSE;
-        GLDEBUG(glValidateProgram(m_iProgram));
-        GLDEBUG(glGetProgramiv(m_iProgram, GL_VALIDATE_STATUS, &validate_status));
-        if(validate_status != GL_TRUE) {
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to validate shader program: %s", m_szKey);
-            logLength = 0; // In case glGetProgramiv fails
-            GLDEBUG(glGetProgramiv(m_iProgram, GL_INFO_LOG_LENGTH, &logLength));
-            if (logLength > 0)
-            {
-                GLchar *log = (GLchar *)malloc(logLength + 1);
-                assert(log != NULL);
-                log[0] = '\0'; // In case glGetProgramInfoLog fails
-                GLDEBUG(glGetProgramInfoLog(m_iProgram, logLength, &logLength, log));
-                log[logLength] = '\0';
-                KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Program validate log:\n%s", log);
-                free(log);
-                
-            }
-            return false;
-        }
-    }
-#endif
-
     return true;
 }
 
-const char *KRShader::getKey() const {
+KRDataBlock *KRShader::getData()
-    return m_szKey;
+{
+    return m_pData;
 }

kraken/KRShader.h

@@ -2,7 +2,7 @@
 //  KRShader.h
 //  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -29,133 +29,31 @@
 //  or implied, of Kearwood Gilbert.
 //
 
-
-
 #ifndef KRSHADER_H
 #define KRSHADER_H
 
 #include "KREngine-common.h"
-#include "KRShader.h"
+#include "KRContextObject.h"
-#include "KRCamera.h"
+#include "KRDataBlock.h"
-#include "KRNode.h"
+#include "KRResource.h"
-#include "KRViewport.h"
+
+class KRShader : public KRResource {
     
-class KRShader  : public KRContextObject {
 public:
-    KRShader(KRContext &context, char *szKey, std::string options, std::string vertShaderSource, const std::string fragShaderSource);
+    KRShader(KRContext &context, std::string name, std::string extension);
+    KRShader(KRContext &context, std::string name, std::string extension, KRDataBlock *data);
     virtual ~KRShader();
-    const char *getKey() const;
     
-    bool bind(KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
+    virtual std::string getExtension();
     
-    enum {
+    virtual bool save(KRDataBlock &data);
-        KRENGINE_UNIFORM_MATERIAL_AMBIENT = 0,
-        KRENGINE_UNIFORM_MATERIAL_DIFFUSE,
-        KRENGINE_UNIFORM_MATERIAL_SPECULAR,
-        KRENGINE_UNIFORM_MATERIAL_REFLECTION,
-        KRENGINE_UNIFORM_MATERIAL_ALPHA,
-        KRENGINE_UNIFORM_MATERIAL_SHININESS,
-        KRENGINE_UNIFORM_LIGHT_POSITION,
-        KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE,
-        KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE,
-        KRENGINE_UNIFORM_LIGHT_COLOR,
-        KRENGINE_UNIFORM_LIGHT_DECAY_START,
-        KRENGINE_UNIFORM_LIGHT_CUTOFF,
-        KRENGINE_UNIFORM_LIGHT_INTENSITY,
-        KRENGINE_UNIFORM_FLARE_SIZE,
-        KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN,
-        KRENGINE_UNIFORM_MVP,
-        KRENGINE_UNIFORM_INVP,
-        KRENGINE_UNIFORM_INVMVP,
-        KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE,
-        KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE,
-        KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE,
-        KRENGINE_UNIFORM_MODEL_VIEW,
-        KRENGINE_UNIFORM_MODEL_MATRIX,
-        KRENGINE_UNIFORM_PROJECTION_MATRIX,
-        KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE,
-        KRENGINE_UNIFORM_VIEWPORT,
-        KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE,
-        KRENGINE_UNIFORM_DIFFUSETEXTURE,
-        KRENGINE_UNIFORM_SPECULARTEXTURE,
-        KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE,
-        KRENGINE_UNIFORM_REFLECTIONTEXTURE,
-        KRENGINE_UNIFORM_NORMALTEXTURE,
-        KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE,
-        KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE,
-        KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE,
-        KRENGINE_UNIFORM_NORMALTEXTURE_SCALE,
-        KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE,
-        KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET,
-        KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET,
-        KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET,
-        KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET,
-        KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET,
-        KRENGINE_UNIFORM_SHADOWMVP1,
-        KRENGINE_UNIFORM_SHADOWMVP2,
-        KRENGINE_UNIFORM_SHADOWMVP3,
-        KRENGINE_UNIFORM_SHADOWTEXTURE1,
-        KRENGINE_UNIFORM_SHADOWTEXTURE2,
-        KRENGINE_UNIFORM_SHADOWTEXTURE3,
-        KRENGINE_UNIFORM_LIGHTMAPTEXTURE,
-        KRENGINE_UNIFORM_GBUFFER_FRAME,
-        KRENGINE_UNIFORM_GBUFFER_DEPTH,
-        KRENGINE_UNIFORM_DEPTH_FRAME,
-        KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME,
-        KRENGINE_UNIFORM_RENDER_FRAME,
-        KRENGINE_UNIFORM_ABSOLUTE_TIME,
-        KRENGINE_UNIFORM_FOG_NEAR,
-        KRENGINE_UNIFORM_FOG_FAR,
-        KRENGINE_UNIFORM_FOG_DENSITY,
-        KRENGINE_UNIFORM_FOG_COLOR,
-        KRENGINE_UNIFORM_FOG_SCALE,
-        KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL,
-        KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED,
-        KRENGINE_UNIFORM_SLICE_DEPTH_SCALE,
-        KRENGINE_UNIFORM_PARTICLE_ORIGIN,
-        KRENGINE_UNIFORM_BONE_TRANSFORMS,
-        KRENGINE_UNIFORM_RIM_COLOR,
-        KRENGINE_UNIFORM_RIM_POWER,
-        KRENGINE_UNIFORM_FADE_COLOR,
-        KRENGINE_NUM_UNIFORMS
-    };
-    /*
-    typedef enum {
-        KRENGINE_UNIFORM_TYPE_UNKNOWN,
-        KRENGINE_UNIFORM_TYPE_FLOAT,
-        KRENGINE_UNIFORM_TYPE_INT,
-        KRENGINE_UNIFORM_TYPE_VECTOR2,
-        KRENGINE_UNIFORM_TYPE_VECTOR3,
-        KRENGINE_UNIFORM_TYPE_VECTOR4,
-        KRENGINE_UNIFORM_TYPE_MAT4
-    } uniform_type_t;
-     uniform_type_t m_uniform_type[KRENGINE_NUM_UNIFORMS];
-     */
     
-    static const char *KRENGINE_UNIFORM_NAMES[];
+    KRDataBlock *getData();
-    GLint m_uniforms[KRENGINE_NUM_UNIFORMS];
-    
-    int m_uniform_value_index[KRENGINE_NUM_UNIFORMS];
-    
-    std::vector<float> m_uniform_value_float;
-    std::vector<int> m_uniform_value_int;
-    std::vector<Vector2> m_uniform_value_vector2;
-    std::vector<Vector3> m_uniform_value_vector3;
-    std::vector<Vector4> m_uniform_value_vector4;
-    std::vector<Matrix4> m_uniform_value_mat4;
-    
-    
-    char m_szKey[256];
-    
-    void setUniform(int location, float value);
-    void setUniform(int location, int value);
-    void setUniform(int location, const Vector2 &value);
-    void setUniform(int location, const Vector3 &value);
-    void setUniform(int location, const Vector4 &value);
-    void setUniform(int location, const Matrix4 &value);
 
 private:
-    GLuint m_iProgram;
+    
+    std::string m_extension;
+    KRDataBlock *m_pData;
 };
 
-#endif
+#endif /* defined(KRSHADER_H) */

kraken/KRShaderManager.cpp

@@ -1,8 +1,8 @@
 //
-//  KRShaderManager.cpp
+//  ShaderManager.cpp
 //  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -29,255 +29,89 @@
 //  or implied, of Kearwood Gilbert.
 //
 
+#include "KRShaderManager.h"
 #include "KREngine-common.h"
 
-#include "KRShaderManager.h"
+KRShaderManager::KRShaderManager(KRContext &context) : KRResourceManager(context)
-#include "KRLight.h"
-#include "KRDirectionalLight.h"
-#include "KRSpotLight.h"
-#include "KRPointLight.h"
-
-using namespace std;
-
-KRShaderManager::KRShaderManager(KRContext &context) : KRContextObject(context) {
-    m_active_shader = NULL;
-}
-
-KRShaderManager::~KRShaderManager() {
-
-}
-
-
-KRShader *KRShaderManager::getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, bool bRimColor) {
-    
-    int iShadowQuality = 0; // FINDME - HACK - Placeholder code, need to iterate through lights and dynamically build shader
-
-    
-    int light_directional_count = 0;
-    int light_point_count = 0;
-    int light_spot_count = 0;
-    if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
-        light_directional_count = directional_lights.size();
-        light_point_count = point_lights.size();
-        light_spot_count = spot_lights.size();
-        for(std::vector<KRDirectionalLight *>::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) {
-            KRDirectionalLight *directional_light =(*light_itr);
-            iShadowQuality = directional_light->getShadowBufferCount();
-        }
-    }
-    
-    if(iShadowQuality > pCamera->settings.m_cShadowBuffers) {
-        iShadowQuality = pCamera->settings.m_cShadowBuffers;
-    }
-    
-    bool bFadeColorEnabled = pCamera->getFadeColor().w >= 0.0f;
-    
-    std::pair<std::string, std::vector<int> > key;
-    key.first = shader_name;
-    key.second.push_back(light_directional_count);
-    key.second.push_back(light_point_count);
-    key.second.push_back(light_spot_count);
-    key.second.push_back(pCamera->settings.fog_type);
-    key.second.push_back(pCamera->settings.bEnablePerPixel);
-    key.second.push_back(bAlphaTest);
-    key.second.push_back(bAlphaBlend);
-    key.second.push_back(bDiffuseMap);
-    key.second.push_back(bNormalMap);
-    key.second.push_back(bSpecMap);
-    key.second.push_back(bReflectionMap);
-    key.second.push_back(bone_count);
-    key.second.push_back(bSpecMap);
-    key.second.push_back(bReflectionMap);
-    key.second.push_back(bReflectionCubeMap);
-    key.second.push_back(pCamera->settings.bDebugPSSM);
-    key.second.push_back(iShadowQuality);
-    key.second.push_back(pCamera->settings.bEnableAmbient);
-    key.second.push_back(pCamera->settings.bEnableDiffuse);
-    key.second.push_back(pCamera->settings.bEnableSpecular);
-    key.second.push_back(bLightMap);
-    key.second.push_back(bDiffuseMapScale);
-    key.second.push_back(bSpecMapScale);
-    key.second.push_back(bReflectionMapScale);
-    key.second.push_back(bNormalMapScale);
-    key.second.push_back(bDiffuseMapOffset);
-    key.second.push_back(bSpecMapOffset);
-    key.second.push_back(bReflectionMapOffset);
-    key.second.push_back(bNormalMapOffset);
-    key.second.push_back(pCamera->settings.volumetric_environment_enable);
-    key.second.push_back(pCamera->settings.volumetric_environment_downsample != 0);
-    key.second.push_back(renderPass);
-    key.second.push_back(pCamera->settings.dof_quality);
-    key.second.push_back(pCamera->settings.bEnableFlash);
-    key.second.push_back(pCamera->settings.bEnableVignette);
-    key.second.push_back(pCamera->settings.dof_depth * 1000.0f);
-    key.second.push_back(pCamera->settings.dof_falloff * 1000.0f);
-    key.second.push_back(pCamera->settings.flash_depth * 1000.0f);
-    key.second.push_back(pCamera->settings.flash_falloff * 1000.0f);
-    key.second.push_back(pCamera->settings.flash_intensity * 1000.0f);
-    key.second.push_back(pCamera->settings.vignette_radius * 1000.0f);
-    key.second.push_back(pCamera->settings.vignette_falloff * 1000.0f);
-    key.second.push_back(bRimColor);
-    key.second.push_back(bFadeColorEnabled);
-              
-                         
-    KRShader *pShader = m_shaders[key];
-    
-    
-    if(pShader == NULL) {
-        if(m_shaders.size() > KRContext::KRENGINE_MAX_SHADER_HANDLES) {
-            // Keep the size of the shader cache reasonable
-            std::map<std::pair<std::string, std::vector<int> > , KRShader *>::iterator itr = m_shaders.begin();
-            delete (*itr).second;
-            m_shaders.erase(itr);
-            KRContext::Log(KRContext::LOG_LEVEL_INFORMATION, "Swapping shaders...\n");
-        }
-        
-        
-        std::string platform_shader_name = shader_name;
-#if TARGET_OS_IPHONE
-        platform_shader_name = shader_name;
-#else
-        platform_shader_name = shader_name + "_osx";
-#endif
-        
-        stringstream stream;
-        stream.precision(std::numeric_limits<long double>::digits10);
-
-#if TARGET_OS_IPHONE
-#else
-        stream << "\n#version 150";
-        stream << "\n#define lowp";
-        stream << "\n#define mediump";
-        stream << "\n#define highp";
-#endif
-        
-        stream << "\n#define LIGHT_DIRECTIONAL_COUNT " << light_directional_count;
-        stream << "\n#define LIGHT_POINT_COUNT " << light_point_count;
-        stream << "\n#define LIGHT_SPOT_COUNT " << light_spot_count;
-        stream << "\n#define BONE_COUNT " << bone_count;
-        
-        stream << "\n#define HAS_DIFFUSE_MAP " << (bDiffuseMap ? "1" : "0");
-        stream << "\n#define HAS_DIFFUSE_MAP_SCALE " << (bDiffuseMapScale ? "1" : "0");
-        stream << "\n#define HAS_DIFFUSE_MAP_OFFSET " << (bDiffuseMapOffset ? "1" : "0");
-        
-        stream << "\n#define HAS_SPEC_MAP " << (bSpecMap ? "1" : "0");
-        stream << "\n#define HAS_SPEC_MAP_SCALE " << (bSpecMapScale ? "1" : "0");
-        stream << "\n#define HAS_SPEC_MAP_OFFSET " << (bSpecMapOffset ? "1" : "0");
-        
-        stream << "\n#define HAS_NORMAL_MAP " << (bNormalMap ? "1" : "0");
-        stream << "\n#define HAS_NORMAL_MAP_SCALE " << (bNormalMapScale ? "1" : "0");
-        stream << "\n#define HAS_NORMAL_MAP_OFFSET " << (bNormalMapOffset ? "1" : "0");
-        
-        stream << "\n#define HAS_REFLECTION_MAP " << (bReflectionMap ? "1" : "0");
-        stream << "\n#define HAS_REFLECTION_MAP_SCALE " << (bReflectionMapScale ? "1" : "0");
-        stream << "\n#define HAS_REFLECTION_MAP_OFFSET " << (bReflectionMapOffset ? "1" : "0");
-        
-        stream << "\n#define HAS_LIGHT_MAP " << (bLightMap ? "1" : "0");
-        stream << "\n#define HAS_REFLECTION_CUBE_MAP " << (bReflectionCubeMap ? "1" : "0");
-        
-        stream << "\n#define ALPHA_TEST " << (bAlphaTest ? "1" : "0");
-        stream << "\n#define ALPHA_BLEND " << (bAlphaBlend ? "1" : "0");
-        
-        stream << "\n#define ENABLE_PER_PIXEL " << (pCamera->settings.bEnablePerPixel ? "1" : "0");
-        stream << "\n#define DEBUG_PSSM " << (pCamera->settings.bDebugPSSM ? "1" : "0");
-        stream << "\n#define SHADOW_QUALITY " << iShadowQuality;
-        stream << "\n#define ENABLE_AMBIENT " << (pCamera->settings.bEnableAmbient ? "1" : "0");
-        stream << "\n#define ENABLE_DIFFUSE " << (pCamera->settings.bEnableDiffuse ? "1" : "0");
-        stream << "\n#define ENABLE_SPECULAR " << (pCamera->settings.bEnableSpecular ? "1" : "0");
-        stream << "\n#define ENABLE_RIM_COLOR " << (bRimColor ? "1" : "0");
-        stream << "\n#define ENABLE_FADE_COLOR " << (bFadeColorEnabled ? "1" : "0");
-        stream << "\n#define FOG_TYPE " << pCamera->settings.fog_type;
-        switch(renderPass) {
-            case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
-                stream << "\n#define GBUFFER_PASS " << 1;
-                break;
-            case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
-                stream << "\n#define GBUFFER_PASS " << 2;
-                break;
-            case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
-                stream << "\n#define GBUFFER_PASS " << 3;
-                break;
-            default:
-                stream << "\n#define GBUFFER_PASS " << 0;
-                break;
-        }
-
-        stream << "\n#define DOF_QUALITY " << pCamera->settings.dof_quality;
-        stream << "\n#define ENABLE_FLASH " << (pCamera->settings.bEnableFlash ? "1" : "0");
-        stream << "\n#define ENABLE_VIGNETTE " << (pCamera->settings.bEnableVignette ? "1" : "0");
-        stream << "\n#define VOLUMETRIC_ENVIRONMENT_DOWNSAMPLED " << (pCamera->settings.volumetric_environment_enable && pCamera->settings.volumetric_environment_downsample != 0 ? "1" : "0");
-        
-        
-        stream.setf(ios::fixed,ios::floatfield);
-        
-        stream.precision(std::numeric_limits<long double>::digits10);
-        
-        stream << "\n#define DOF_DEPTH " << pCamera->settings.dof_depth;
-        stream << "\n#define DOF_FALLOFF " << pCamera->settings.dof_falloff;
-        stream << "\n#define FLASH_DEPTH " << pCamera->settings.flash_depth;
-        stream << "\n#define FLASH_FALLOFF " << pCamera->settings.flash_falloff;
-        stream << "\n#define FLASH_INTENSITY " << pCamera->settings.flash_intensity;
-        stream << "\n#define VIGNETTE_RADIUS " << pCamera->settings.vignette_radius;
-        stream << "\n#define VIGNETTE_FALLOFF " << pCamera->settings.vignette_falloff;
-        
-        stream << "\n";
-        std::string options = stream.str();
-        
-        std::string vertShaderSource = m_vertShaderSource[platform_shader_name];
-        std::string fragShaderSource = m_fragShaderSource[platform_shader_name];
-        
-        if(vertShaderSource.length() == 0) {
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Vertex Shader Missing: %s", platform_shader_name.c_str());
-        }
-        if(fragShaderSource.length() == 0) {
-            KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Fragment Shader Missing: %s", platform_shader_name.c_str());
-        }
-        
-        Vector4 fade_color = pCamera->getFadeColor();
-        
-        char szKey[256];
-        sprintf(szKey, "%i_%i_%i_%i_%i_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%i_%s_%i_%d_%d_%f_%f_%f_%f_%f_%f_%f_%f_%f_%f_%f", light_directional_count, light_point_count, light_spot_count, bone_count, pCamera->settings.fog_type, pCamera->settings.bEnablePerPixel,bAlphaTest, bAlphaBlend, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, pCamera->settings.bDebugPSSM, iShadowQuality, pCamera->settings.bEnableAmbient, pCamera->settings.bEnableDiffuse, pCamera->settings.bEnableSpecular, bLightMap, bDiffuseMapScale, bSpecMapScale, bReflectionMapScale, bNormalMapScale, bDiffuseMapOffset, bSpecMapOffset, bReflectionMapOffset, bNormalMapOffset,pCamera->settings.volumetric_environment_enable && pCamera->settings.volumetric_environment_downsample != 0, renderPass, shader_name.c_str(),pCamera->settings.dof_quality,pCamera->settings.bEnableFlash,pCamera->settings.bEnableVignette,pCamera->settings.dof_depth,pCamera->settings.dof_falloff,pCamera->settings.flash_depth,pCamera->settings.flash_falloff,pCamera->settings.flash_intensity,pCamera->settings.vignette_radius,pCamera->settings.vignette_falloff, fade_color.x, fade_color.y, fade_color.z, fade_color.w);
-        
-        pShader = new KRShader(getContext(), szKey, options, vertShaderSource, fragShaderSource);
-
-        m_shaders[key] = pShader;
-    }
-    return pShader;
-}
-
-bool KRShaderManager::selectShader(const std::string &shader_name, KRCamera &camera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRViewport &viewport, const Matrix4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color)
 {
-    KRShader *pShader = getShader(shader_name, &camera, point_lights, directional_lights, spot_lights, bone_count, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, bDiffuseMapScale, bSpecMapScale, bNormalMapScale, bReflectionMapScale, bDiffuseMapOffset, bSpecMapOffset, bNormalMapOffset, bReflectionMapOffset, bAlphaTest, bAlphaBlend, renderPass, rim_power != 0.0f);
+    
-    return selectShader(camera, pShader, viewport, matModel, point_lights, directional_lights, spot_lights, bone_count, renderPass, rim_color, rim_power, fade_color);
 }
 
-bool KRShaderManager::selectShader(KRCamera &camera, KRShader *pShader, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color)
+KRShaderManager::~KRShaderManager()
 {
-    if(pShader) {
+    for(unordered_map<std::string, unordered_map<std::string, KRShader *> >::iterator extension_itr = m_shaders.begin(); extension_itr != m_shaders.end(); extension_itr++) {
-        return pShader->bind(camera, viewport, matModel, point_lights, directional_lights, spot_lights, renderPass, rim_color, rim_power, fade_color);
+        for(unordered_map<std::string, KRShader *>::iterator name_itr=(*extension_itr).second.begin(); name_itr != (*extension_itr).second.end(); name_itr++) {
+            delete (*name_itr).second;
+        }
+    }
+}
+
+KRResource* KRShaderManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("spv") == 0) {
+    return load(name, extension, data);
+  }
+  return nullptr;
+}
+KRResource* KRShaderManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("spv") == 0) {
+    return get(name, extension);
+  }
+  return nullptr;
+}
+
+unordered_map<std::string, unordered_map<std::string, KRShader *> > &KRShaderManager::getShaders()
+{
+    return m_shaders;
+}
+
+void KRShaderManager::add(KRShader *shader)
+{
+    std::string lower_name = shader->getName();
+    std::string lower_extension = shader->getExtension();
+    
+    std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    
+    unordered_map<std::string, unordered_map<std::string, KRShader *> >::iterator extension_itr = m_shaders.find(lower_extension);
+    if(extension_itr == m_shaders.end()) {
+        m_shaders[lower_extension] = unordered_map<std::string, KRShader *>();
+        extension_itr = m_shaders.find(lower_extension);
+    }
+    
+    unordered_map<std::string, KRShader *>::iterator name_itr = (*extension_itr).second.find(lower_name);
+    if(name_itr != (*extension_itr).second.end()) {
+        delete (*name_itr).second;
+        (*name_itr).second = shader;
     } else {
-        return false;
+        (*extension_itr).second[lower_name] = shader;
     }
 }
 
-void KRShaderManager::loadFragmentShader(const std::string &name, KRDataBlock *data) {
+KRShader *KRShaderManager::load(const std::string &name, const std::string &extension, KRDataBlock *data)
-    m_fragShaderSource[name] = data->getString();
+{
-    delete data;
+    KRShader *shader = new KRShader(getContext(), name, extension, data);
+    if(shader) add(shader);
+    return shader;
 }
 
-void KRShaderManager::loadVertexShader(const std::string &name, KRDataBlock *data) {
+KRShader *KRShaderManager::get(const std::string &name, const std::string &extension)
-    m_vertShaderSource[name] = data->getString();
+{
-    delete data;
+    std::string lower_name = name;
+    std::string lower_extension = extension;
+    
+    std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    
+    return m_shaders[lower_extension][lower_name];
 }
 
-const std::string &KRShaderManager::getFragShaderSource(const std::string &name) {
+
-    return m_fragShaderSource[name];
+const unordered_map<std::string, KRShader *> &KRShaderManager::get(const std::string &extension)
+{
+    std::string lower_extension = extension;
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    return m_shaders[lower_extension];
 }
 
-const std::string &KRShaderManager::getVertShaderSource(const std::string &name) {
-    return m_vertShaderSource[name];
-}
-
-long KRShaderManager::getShaderHandlesUsed() {
-    return m_shaders.size();
-}

kraken/KRShaderManager.h

@@ -1,8 +1,8 @@
 //
-//  KRShaderManager.h
+//  ShaderManager.h
 //  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -29,51 +29,37 @@
 //  or implied, of Kearwood Gilbert.
 //
 
+#ifndef KRSHADER_MANAGER_H
+#define KRSHADER_MANAGER_H
 
 #include "KREngine-common.h"
 
-#include "KRCamera.h"
+#include "KRResourceManager.h"
-#include "KRDataBlock.h"
-#include "KRNode.h"
-
-using std::map;
-using std::vector;
 
 #include "KRShader.h"
+#include "KRContextObject.h"
+#include "KRDataBlock.h"
 
-#ifndef KRSHADERMANAGER_H
+class KRShaderManager : public KRResourceManager {
-#define KRSHADERMANAGER_H
-
-class KRShader;
-class KRCamera;
-
-class KRShaderManager : public KRContextObject {
 public:
     KRShaderManager(KRContext &context);
     virtual ~KRShaderManager();
 
-    void loadFragmentShader(const std::string &name, KRDataBlock *data);
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
-    void loadVertexShader(const std::string &name, KRDataBlock *data);
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
-    const std::string &getFragShaderSource(const std::string &name);
+    
-    const std::string &getVertShaderSource(const std::string &name);
+    void add(KRShader *shader);
+    
+    KRShader *load(const std::string &name, const std::string &extension, KRDataBlock *data);
+    KRShader *get(const std::string &name, const std::string &extension);
     
 
-    KRShader *getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, bool bRimColor = false);
+    const unordered_map<std::string, KRShader *> &get(const std::string &extension);
     
-    bool selectShader(KRCamera &camera, KRShader *pShader, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRNode::RenderPass &renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
+    unordered_map<std::string, unordered_map<std::string, KRShader *> > &getShaders();
-    
-    bool selectShader(const std::string &shader_name, KRCamera &camera, const std::vector<KRPointLight *> &point_lights, const std::vector<KRDirectionalLight *> &directional_lights, const std::vector<KRSpotLight *>&spot_lights, int bone_count, const KRViewport &viewport, const Matrix4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass, const Vector3 &rim_color, float rim_power, const Vector4 &fade_color);
-    
-    long getShaderHandlesUsed();
-    
-    KRShader *m_active_shader;
     
 private:
-    //unordered_map<std::string, KRShader *> m_shaders;
+    unordered_map<std::string, unordered_map<std::string, KRShader *> > m_shaders;
-    std::map<std::pair<std::string, std::vector<int> >, KRShader *> m_shaders;
-    
-    unordered_map<std::string, std::string> m_fragShaderSource;
-    unordered_map<std::string, std::string> m_vertShaderSource;
 };
 
-#endif
+#endif /* defined(KRUNKNOWN_MANAGER_H) */

kraken/KRSource.cpp

@@ -0,0 +1,65 @@
+//
+//  KRSource.cpp
+//  KREngine
+//
+//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+#include "KRSource.h"
+
+KRSource::KRSource(KRContext &context, std::string name, std::string extension) : KRResource(context, name)
+{
+    m_pData = new KRDataBlock();
+    m_extension = extension;
+}
+
+KRSource::KRSource(KRContext &context, std::string name, std::string extension, KRDataBlock *data) : KRResource(context, name)
+{
+    m_pData = data;
+    m_extension = extension;
+}
+
+KRSource::~KRSource()
+{
+    delete m_pData;
+}
+
+std::string KRSource::getExtension()
+{
+    return m_extension;
+}
+
+bool KRSource::save(KRDataBlock &data)
+{
+    data.append(*m_pData);
+    return true;
+}
+
+KRDataBlock *KRSource::getData()
+{
+    return m_pData;
+}

kraken/KRSource.h

@@ -1,5 +1,5 @@
 //
-//  dust_particle.fsh
+//  KRSource.h
 //  KREngine
 //
 //  Copyright 2012 Kearwood Gilbert. All rights reserved.
@@ -29,15 +29,31 @@
 //  or implied, of Kearwood Gilbert.
 //
 
-#extension GL_EXT_shadow_samplers : require
+#ifndef KRSOURCE_H
+#define KRSOURCE_H
 
-varying mediump vec2 texCoord;
+#include "KREngine-common.h"
+#include "KRContextObject.h"
+#include "KRDataBlock.h"
+#include "KRResource.h"
 
-varying mediump vec4        shadowMapCoord1;
+class KRSource : public KRResource {
-uniform sampler2DShadow     shadowTexture1;
-uniform mediump vec3        light_color;
-varying lowp float          intensity_modulate;
     
-void main() {
+public:
-    gl_FragColor = vec4(light_color, 1.0) * shadow2DProjEXT(shadowTexture1, shadowMapCoord1) * max(1.0 - texCoord.x*texCoord.x-texCoord.y*texCoord.y, 0.0) * intensity_modulate;
+    KRSource(KRContext &context, std::string name, std::string extension);
-}
+    KRSource(KRContext &context, std::string name, std::string extension, KRDataBlock *data);
+    virtual ~KRSource();
+    
+    virtual std::string getExtension();
+    
+    virtual bool save(KRDataBlock &data);
+    
+    KRDataBlock *getData();
+
+private:
+    
+    std::string m_extension;
+    KRDataBlock *m_pData;
+};
+
+#endif /* defined(KRSOURCE_H) */

kraken/KRSourceManager.cpp

@@ -0,0 +1,148 @@
+//
+//  SourceManager.cpp
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+#include "KRSourceManager.h"
+#include "KREngine-common.h"
+
+KRSourceManager::KRSourceManager(KRContext &context) : KRResourceManager(context)
+{
+    
+}
+
+KRSourceManager::~KRSourceManager()
+{
+    for(unordered_map<std::string, unordered_map<std::string, KRSource *> >::iterator extension_itr = m_sources.begin(); extension_itr != m_sources.end(); extension_itr++) {
+        for(unordered_map<std::string, KRSource *>::iterator name_itr=(*extension_itr).second.begin(); name_itr != (*extension_itr).second.end(); name_itr++) {
+            delete (*name_itr).second;
+        }
+    }
+}
+
+unordered_map<std::string, unordered_map<std::string, KRSource *> > &KRSourceManager::getSources()
+{
+    return m_sources;
+}
+
+void KRSourceManager::add(KRSource *source)
+{
+    std::string lower_name = source->getName();
+    std::string lower_extension = source->getExtension();
+    
+    std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    
+    unordered_map<std::string, unordered_map<std::string, KRSource *> >::iterator extension_itr = m_sources.find(lower_extension);
+    if(extension_itr == m_sources.end()) {
+        m_sources[lower_extension] = unordered_map<std::string, KRSource *>();
+        extension_itr = m_sources.find(lower_extension);
+    }
+    
+    unordered_map<std::string, KRSource *>::iterator name_itr = (*extension_itr).second.find(lower_name);
+    if(name_itr != (*extension_itr).second.end()) {
+        delete (*name_itr).second;
+        (*name_itr).second = source;
+    } else {
+        (*extension_itr).second[lower_name] = source;
+    }
+}
+
+KRResource* KRSourceManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  if (extension.compare("vert") == 0 ||
+      extension.compare("frag") == 0 ||
+      extension.compare("tesc") == 0 ||
+      extension.compare("tese") == 0 ||
+      extension.compare("geom") == 0 ||
+      extension.compare("comp") == 0 ||
+      extension.compare("mesh") == 0 ||
+      extension.compare("task") == 0 ||
+      extension.compare("rgen") == 0 ||
+      extension.compare("rint") == 0 ||
+      extension.compare("rahit") == 0 ||
+      extension.compare("rchit") == 0 ||
+      extension.compare("rmiss") == 0 ||
+      extension.compare("rcall") == 0 ||
+      extension.compare("glsl") == 0 ||
+      extension.compare("options") == 0) {
+    return load(name, extension, data);
+  }
+  return nullptr;
+}
+
+KRResource* KRSourceManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("vert") == 0 ||
+      extension.compare("frag") == 0 ||
+      extension.compare("tesc") == 0 ||
+      extension.compare("tese") == 0 ||
+      extension.compare("geom") == 0 ||
+      extension.compare("comp") == 0 ||
+      extension.compare("mesh") == 0 ||
+      extension.compare("task") == 0 ||
+      extension.compare("rgen") == 0 ||
+      extension.compare("rint") == 0 ||
+      extension.compare("rahit") == 0 ||
+      extension.compare("rchit") == 0 ||
+      extension.compare("rmiss") == 0 ||
+      extension.compare("rcall") == 0 ||
+      extension.compare("glsl") == 0 ||
+      extension.compare("options") == 0) {
+    return get(name, extension);
+  }
+  return nullptr;
+}
+
+KRSource *KRSourceManager::load(const std::string &name, const std::string &extension, KRDataBlock *data)
+{
+    KRSource *source = new KRSource(getContext(), name, extension, data);
+    if(source) add(source);
+    return source;
+}
+
+KRSource *KRSourceManager::get(const std::string &name, const std::string &extension)
+{
+    std::string lower_name = name;
+    std::string lower_extension = extension;
+    
+    std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    
+    return m_sources[lower_extension][lower_name];
+}
+
+
+const unordered_map<std::string, KRSource *> &KRSourceManager::get(const std::string &extension)
+{
+    std::string lower_extension = extension;
+    std::transform(lower_extension.begin(), lower_extension.end(), lower_extension.begin(), ::tolower);
+    return m_sources[lower_extension];
+}
+

kraken/KRSourceManager.h

@@ -0,0 +1,63 @@
+//
+//  SourceManager.h
+//  KREngine
+//
+//  Copyright 2019 Kearwood Gilbert. All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without modification, are
+//  permitted provided that the following conditions are met:
+//
+//  1. Redistributions of source code must retain the above copyright notice, this list of
+//  conditions and the following disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list
+//  of conditions and the following disclaimer in the documentation and/or other materials
+//  provided with the distribution.
+//
+//  THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
+//  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+//  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+//  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+//  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//  The views and conclusions contained in the software and documentation are those of the
+//  authors and should not be interpreted as representing official policies, either expressed
+//  or implied, of Kearwood Gilbert.
+//
+
+#ifndef KRSOURCE_MANAGER_H
+#define KRSOURCE_MANAGER_H
+
+#include "KREngine-common.h"
+
+#include "KRResourceManager.h"
+#include "KRSource.h"
+#include "KRContextObject.h"
+#include "KRDataBlock.h"
+
+class KRSourceManager : public KRResourceManager {
+public:
+    KRSourceManager(KRContext &context);
+    virtual ~KRSourceManager();
+
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
+    void add(KRSource *source);
+    
+    KRSource *load(const std::string &name, const std::string &extension, KRDataBlock *data);
+    KRSource *get(const std::string &name, const std::string &extension);
+
+    const unordered_map<std::string, KRSource *> &get(const std::string &extension);
+    
+    unordered_map<std::string, unordered_map<std::string, KRSource *> > &getSources();
+    
+private:
+    unordered_map<std::string, unordered_map<std::string, KRSource *> > m_sources;
+};
+
+#endif /* defined(KRUNKNOWN_MANAGER_H) */

kraken/KRSprite.cpp

@@ -14,8 +14,8 @@
 #include "KRCamera.h"
 #include "KRContext.h"
 
-#include "KRShaderManager.h"
+#include "KRPipelineManager.h"
-#include "KRShader.h"
+#include "KRPipeline.h"
 #include "KRStockGeometry.h"
 #include "KRDirectionalLight.h"
 #include "KRSpotLight.h"
@@ -127,9 +127,9 @@ void KRSprite::render(KRCamera *pCamera, std::vector<KRPointLight *> &point_ligh
                 GLDEBUG(glDepthRangef(0.0, 1.0));
                 
                 // Render light sprite on transparency pass
-                KRShader *pShader = getContext().getShaderManager()->getShader("sprite", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
+                KRPipeline *pShader = getContext().getPipelineManager()->getPipeline("sprite", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
-                if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
+                if(getContext().getPipelineManager()->selectPipeline(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass, Vector3::Zero(), 0.0f, Vector4::Zero())) {
-                    pShader->setUniform(KRShader::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_spriteAlpha);
+                    pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_spriteAlpha);
                     m_pContext->getTextureManager()->selectTexture(0, m_pSpriteTexture, 0.0f, KRTexture::TEXTURE_USAGE_SPRITE);
                     m_pContext->getMeshManager()->bindVBO(&m_pContext->getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f);
                     GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));

kraken/KRStreamer.cpp

@@ -42,7 +42,9 @@ KRStreamer::~KRStreamer()
 void KRStreamer::run()
 {
 
-#if defined(_WIN32) || defined(_WIN64)
+#if defined(ANDROID)
+    // TODO - Set thread names on Android
+#elif defined(_WIN32) || defined(_WIN64)
     // TODO - Set thread names on windows
 #else
    pthread_setname_np("Kraken - Streamer");

kraken/KRTexture.cpp

@@ -72,7 +72,7 @@ void KRTexture::resize(int max_dim)
             m_iNewHandle = 0;
         } else {
             int target_dim = max_dim;
-            if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
+            if(target_dim < (int)m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
 
             if(m_new_lod_max_dim != target_dim || (m_iHandle == 0 && m_iNewHandle == 0)) {
                 assert(m_newTextureMemUsed == 0);
@@ -116,9 +116,9 @@ kraken_stream_level KRTexture::getStreamLevel(KRTexture::texture_usage_t texture
 {
     if(m_current_lod_max_dim == 0) {
         return kraken_stream_level::STREAM_LEVEL_OUT;
-    } else if(m_current_lod_max_dim == KRMIN(getContext().KRENGINE_MAX_TEXTURE_DIM, m_max_lod_max_dim)) {
+    } else if(m_current_lod_max_dim == KRMIN(getContext().KRENGINE_MAX_TEXTURE_DIM, (int)m_max_lod_max_dim)) {
         return kraken_stream_level::STREAM_LEVEL_IN_HQ;
-    } else if(m_current_lod_max_dim >= KRMAX(getContext().KRENGINE_MIN_TEXTURE_DIM, m_min_lod_max_dim)) {
+    } else if(m_current_lod_max_dim >= KRMAX(getContext().KRENGINE_MIN_TEXTURE_DIM, (int)m_min_lod_max_dim)) {
         return kraken_stream_level::STREAM_LEVEL_IN_LQ;
     } else {
         return kraken_stream_level::STREAM_LEVEL_OUT;

kraken/KRTextureAnimated.cpp

@@ -43,13 +43,13 @@ KRTextureAnimated::KRTextureAnimated(KRContext &context, std::string name) : KRT
     //       - yy is the framerate
     
     // TODO - Add error handling for mal-formatted animated texture formats
-    int first_comma_pos = name.find(",");
+    size_t first_comma_pos = name.find(",");
-    int second_comma_pos = name.find(",", first_comma_pos + 1);
+    size_t second_comma_pos = name.find(",", first_comma_pos + 1);
     
     
     m_texture_base_name = name.substr(8, first_comma_pos - 8);
     m_frame_count = atoi(name.substr(first_comma_pos+1, second_comma_pos - first_comma_pos -1).c_str());
-    m_frame_rate = atof(name.substr(second_comma_pos+1).c_str());
+    m_frame_rate = (float)atof(name.substr(second_comma_pos+1).c_str());
     
     m_max_lod_max_dim = 2048;
     m_min_lod_max_dim = 64;
@@ -57,8 +57,8 @@ KRTextureAnimated::KRTextureAnimated(KRContext &context, std::string name) : KRT
     for(int i=0; i<m_frame_count; i++) {
         KRTexture2D *frame_texture = textureForFrame(i);
         if(frame_texture) {
-            if(frame_texture->getMaxMipMap() < m_max_lod_max_dim) m_max_lod_max_dim = frame_texture->getMaxMipMap();
+            if(frame_texture->getMaxMipMap() < (int)m_max_lod_max_dim) m_max_lod_max_dim = frame_texture->getMaxMipMap();
-            if(frame_texture->getMinMipMap() > m_min_lod_max_dim) m_min_lod_max_dim = frame_texture->getMinMipMap();
+            if(frame_texture->getMinMipMap() > (int)m_min_lod_max_dim) m_min_lod_max_dim = frame_texture->getMinMipMap();
         }
     }
 }
@@ -106,7 +106,7 @@ void KRTextureAnimated::bind(GLuint texture_unit)
 {
     resetPoolExpiry(0.0f, TEXTURE_USAGE_NONE); // TODO - Need to set parameters here for streaming priority?
     KRTexture::bind(texture_unit);
-    int frame_number = (int)floor(fmodf(getContext().getAbsoluteTime() * m_frame_rate,m_frame_count));
+    int frame_number = (int)floor(fmodf(getContext().getAbsoluteTime() * m_frame_rate, (float)m_frame_count));
     KRTexture2D *frame_texture = textureForFrame(frame_number);
     if(frame_texture) {
         frame_texture->bind(texture_unit);

kraken/KRTextureCube.cpp

@@ -44,8 +44,8 @@ KRTextureCube::KRTextureCube(KRContext &context, std::string name) : KRTexture(c
         std::string faceName = getName() + SUFFIXES[i];
         m_textures[i] = (KRTexture2D *)getContext().getTextureManager()->getTexture(faceName);
         if(m_textures[i]) {
-            if(m_textures[i]->getMaxMipMap() < m_max_lod_max_dim) m_max_lod_max_dim = m_textures[i]->getMaxMipMap();
+            if(m_textures[i]->getMaxMipMap() < (int)m_max_lod_max_dim) m_max_lod_max_dim = m_textures[i]->getMaxMipMap();
-            if(m_textures[i]->getMinMipMap() > m_min_lod_max_dim) m_min_lod_max_dim = m_textures[i]->getMinMipMap();
+            if(m_textures[i]->getMinMipMap() > (int)m_min_lod_max_dim) m_min_lod_max_dim = m_textures[i]->getMinMipMap();
         } else {
             assert(false);
         }
@@ -94,7 +94,7 @@ bool KRTextureCube::createGLTexture(int lod_max_dim)
 long KRTextureCube::getMemRequiredForSize(int max_dim)
 {
     int target_dim = max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
+    if(target_dim < (int)m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
     
     long memoryRequired = 0;
     for(int i=0; i<6; i++) {

kraken/KRTextureKTX.cpp

@@ -59,7 +59,7 @@ KRTextureKTX::KRTextureKTX(KRContext &context, KRDataBlock *data, std::string na
     uint32_t blockStart = sizeof(KTXHeader) + m_header.bytesOfKeyValueData;
     uint32_t width = m_header.pixelWidth, height = m_header.pixelHeight;
     
-    for(int mipmap_level=0; mipmap_level < KRMAX(m_header.numberOfMipmapLevels, 1); mipmap_level++) {
+    for(int mipmap_level=0; mipmap_level < (int)KRMAX(m_header.numberOfMipmapLevels, 1); mipmap_level++) {
         uint32_t blockLength;
         data->copy(&blockLength, blockStart, 4);
         blockStart += 4;
@@ -126,7 +126,7 @@ KRTextureKTX::~KRTextureKTX() {
 long KRTextureKTX::getMemRequiredForSize(int max_dim)
 {
     int target_dim = max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = target_dim;
+    if(target_dim < (int)m_min_lod_max_dim) target_dim = target_dim;
     
     // Determine how much memory will be consumed
     
@@ -137,7 +137,7 @@ long KRTextureKTX::getMemRequiredForSize(int max_dim)
     for(std::list<KRDataBlock *>::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) {
         KRDataBlock *block = *itr;
         if(width <= target_dim && height <= target_dim) {
-            memoryRequired += block->getSize();
+            memoryRequired += (long)block->getSize();
         }
 		
         width = width >> 1;
@@ -156,7 +156,7 @@ long KRTextureKTX::getMemRequiredForSize(int max_dim)
 bool KRTextureKTX::uploadTexture(GLenum target, int lod_max_dim, int &current_lod_max_dim, bool compress, bool premultiply_alpha)
 {
     int target_dim = lod_max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
+    if(target_dim < (int)m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
     
     if(m_blocks.size() == 0) {
         return false;
@@ -239,9 +239,9 @@ bool KRTextureKTX::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
             GLDEBUG(glCompressedTexImage2D(target, destination_level, (GLenum)m_header.glInternalFormat, width, height, 0, (GLsizei)block->getSize(), block->getStart()));
 #endif
             block->unlock();
-            memoryTransferred += block->getSize(); // memoryTransferred does not include throughput of mipmap levels copied through glCopyTextureLevelsAPPLE
+            memoryTransferred += (long)block->getSize(); // memoryTransferred does not include throughput of mipmap levels copied through glCopyTextureLevelsAPPLE
 #endif
-            memoryRequired += block->getSize();
+            memoryRequired += (long)block->getSize();
             //
             //            err = glGetError();
             //            if (err != GL_NO_ERROR) {

kraken/KRTextureManager.cpp

@@ -40,7 +40,7 @@
 #include "KRTextureAnimated.h"
 #include "KRContext.h"
 
-KRTextureManager::KRTextureManager(KRContext &context) : KRContextObject(context) {
+KRTextureManager::KRTextureManager(KRContext &context) : KRResourceManager(context) {
     m_textureMemUsed = 0;
 
     for(int iTexture=0; iTexture<KRENGINE_MAX_TEXTURE_UNITS; iTexture++) {
@@ -90,11 +90,13 @@ void KRTextureManager::_setWrapModeS(GLuint i, GLuint wrap_mode)
 
 void KRTextureManager::_setMaxAnisotropy(int i, float max_anisotropy)
 {
+#if !defined(ANDROID)
     if(m_maxAnisotropy[i] != max_anisotropy) {
         _setActiveTexture(i);
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
         m_maxAnisotropy[i] = max_anisotropy;
     }
+#endif
 }
 
 void KRTextureManager::setMaxAnisotropy(float max_anisotropy)
@@ -113,6 +115,41 @@ void KRTextureManager::_setWrapModeT(GLuint i, GLuint wrap_mode)
     }
 }
 
+
+KRResource* KRTextureManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  /*
+  
+      } else if(extension.compare("pvr") == 0) {
+        resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
+    } else if(extension.compare("ktx") == 0) {
+        resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
+    } else if(extension.compare("tga") == 0) {
+  
+  */
+  if (extension.compare("pvr") == 0 ||
+    extension.compare("ktx") == 0 ||
+    extension.compare("tga") == 0) {
+    return loadTexture(name.c_str(), extension.c_str(), data);
+  }
+  return nullptr;
+}
+
+KRResource* KRTextureManager::getResource(const std::string& name, const std::string& extension)
+{
+  if (extension.compare("pvr") == 0 ||
+      extension.compare("ktx") == 0 ||
+      extension.compare("tga") == 0) {
+    // TODO - Currently textures must have a unique name, without consideration
+    //        of extensions.  When textures are compressed, the uncompressed versions
+    //        are removed.  Both compressed and un-compressed textures should co-exist
+    //        with the renderer prioritizing as necessary.  This will facilitate more
+    //        ergonomic usage within toolchain and editor GUI.
+    return getTexture(name);
+  }
+  return nullptr;
+}
+
 KRTexture *KRTextureManager::loadTexture(const char *szName, const char *szExtension, KRDataBlock *data) {
     KRTexture *pTexture = NULL; 
     

kraken/KRTextureManager.h

@@ -34,6 +34,8 @@
 
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRTexture.h"
 #include "KRContextObject.h"
 #include "KREngine-common.h"
@@ -41,11 +43,14 @@
 #include "KRContext.h"
 #include "KRStreamer.h"
 
-class KRTextureManager : public KRContextObject {
+class KRTextureManager : public KRResourceManager {
 public:
     KRTextureManager(KRContext &context);
     virtual ~KRTextureManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     void selectTexture(int iTextureUnit, KRTexture *pTexture, float lod_coverage, KRTexture::texture_usage_t textureUsage);
     bool selectTexture(GLenum target, int iTextureUnit, int iTextureHandle);
     

kraken/KRTexturePVR.cpp

@@ -147,7 +147,7 @@ KRTexturePVR::~KRTexturePVR() {
 long KRTexturePVR::getMemRequiredForSize(int max_dim)
 {
     int target_dim = max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = target_dim;
+    if(target_dim < (int)m_min_lod_max_dim) target_dim = target_dim;
     
     // Determine how much memory will be consumed
 	int width = m_iWidth;
@@ -157,7 +157,7 @@ long KRTexturePVR::getMemRequiredForSize(int max_dim)
     for(std::list<KRDataBlock *>::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) {
         KRDataBlock *block = *itr;
         if(width <= target_dim && height <= target_dim) {
-            memoryRequired += block->getSize();
+            memoryRequired += (long)block->getSize();
         }
 		
         width = width >> 1;
@@ -176,7 +176,7 @@ long KRTexturePVR::getMemRequiredForSize(int max_dim)
 bool KRTexturePVR::uploadTexture(GLenum target, int lod_max_dim, int &current_lod_max_dim, bool compress, bool premultiply_alpha)
 {    
     int target_dim = lod_max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
+    if(target_dim < (int)m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
     
     if(m_blocks.size() == 0) {
         return false;
@@ -256,12 +256,12 @@ bool KRTexturePVR::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
     #if GL_EXT_texture_storage
             GLDEBUG(glCompressedTexSubImage2D(target, destination_level, 0, 0, width, height, m_internalFormat, block->getSize(), block->getStart()));
     #else
-            GLDEBUG(glCompressedTexImage2D(target, destination_level, m_internalFormat, width, height, 0, block->getSize(), block->getStart()));
+            GLDEBUG(glCompressedTexImage2D(target, destination_level, m_internalFormat, width, height, 0, (GLsizei)block->getSize(), block->getStart()));
     #endif
             block->unlock();
-            memoryTransferred += block->getSize(); // memoryTransferred does not include throughput of mipmap levels copied through glCopyTextureLevelsAPPLE
+            memoryTransferred += (long)block->getSize(); // memoryTransferred does not include throughput of mipmap levels copied through glCopyTextureLevelsAPPLE
 #endif
-            memoryRequired += block->getSize();
+            memoryRequired += (long)block->getSize();
 //            
 //            err = glGetError();
 //            if (err != GL_NO_ERROR) {

kraken/KRTextureTGA.cpp

@@ -98,7 +98,7 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
     
     GLenum internal_format = GL_RGBA;
     
-#if !TARGET_OS_IPHONE
+#if !TARGET_OS_IPHONE && !defined(ANDROID)
     if(compress) {
         internal_format = pHeader->bitsperpixel == 24 ? GL_COMPRESSED_RGB_S3TC_DXT1_EXT : GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
     }
@@ -124,15 +124,15 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                         unsigned char *pDest = converted_image;
                         unsigned char *pEnd = pData + pHeader->height * pHeader->width * 3;
                         while(pSource < pEnd) {
-                            *pDest++ = pSource[0];
-                            *pDest++ = pSource[1];
                             *pDest++ = pSource[2];
+                            *pDest++ = pSource[1];
+                            *pDest++ = pSource[0];
                             *pDest++ = 0xff;
                             pSource += 3;
                         }
                         assert(pSource <= m_pData->getEnd());
 //#endif
-                        GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
+                        GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
                         GLDEBUG(glFinish());
                         free(converted_image);
 
@@ -148,20 +148,34 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                             unsigned char *pDest = converted_image;
                             unsigned char *pEnd = pData + pHeader->height * pHeader->width * 3;
                             while(pSource < pEnd) {
-                                *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
-                                *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
                                 *pDest++ = (__uint32_t)pSource[2] * (__uint32_t)pSource[3] / 0xff;
+                                *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
+                                *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
                                 *pDest++ = pSource[3];
                                 pSource += 4;
                             }
                             assert(pSource <= m_pData->getEnd());
                             
-                            GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
+                            GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
                             GLDEBUG(glFinish());
                             free(converted_image);
                         } else {
-                            GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid *)pData));
+                            unsigned char *converted_image = (unsigned char *)malloc(pHeader->width * pHeader->height * 4);
+
+                            unsigned char *pSource = pData;
+                            unsigned char *pDest = converted_image;
+                            unsigned char *pEnd = pData + pHeader->height * pHeader->width * 3;
+                            while(pSource < pEnd) {
+                                *pDest++ = (__uint32_t)pSource[2];
+                                *pDest++ = (__uint32_t)pSource[1];
+                                *pDest++ = (__uint32_t)pSource[0];
+                                *pDest++ = pSource[3];
+                                pSource += 4;
+                            }
+                            assert(pSource <= m_pData->getEnd());
+                            GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)pData));
                             GLDEBUG(glFinish());
+                            free(converted_image);
                         }
                         
                         current_lod_max_dim = m_max_lod_max_dim;
@@ -187,9 +201,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                                 // RLE Packet
                                 pSource++;
                                 while(count--) {
-                                    *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
-                                    *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
                                     *pDest++ = (__uint32_t)pSource[2] * (__uint32_t)pSource[3] / 0xff;
+                                    *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
+                                    *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
                                     *pDest++ = pSource[3];
                                 }
                                 pSource += 4;
@@ -197,9 +211,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                                 // RAW Packet
                                 pSource++;
                                 while(count--) {
-                                    *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
-                                    *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
                                     *pDest++ = (__uint32_t)pSource[2] * (__uint32_t)pSource[3] / 0xff;
+                                    *pDest++ = (__uint32_t)pSource[1] * (__uint32_t)pSource[3] / 0xff;
+                                    *pDest++ = (__uint32_t)pSource[0] * (__uint32_t)pSource[3] / 0xff;
                                     *pDest++ = pSource[3];
                                     pSource += 4;
                                 }
@@ -214,9 +228,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                                 // RLE Packet
                                 pSource++;
                                 while(count--) {
-                                    *pDest++ = pSource[0];
-                                    *pDest++ = pSource[1];
                                     *pDest++ = pSource[2];
+                                    *pDest++ = pSource[1];
+                                    *pDest++ = pSource[0];
                                     *pDest++ = pSource[3];
                                 }
                                 pSource += 4;
@@ -224,9 +238,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                                 // RAW Packet
                                 pSource++;
                                 while(count--) {
-                                    *pDest++ = pSource[0];
-                                    *pDest++ = pSource[1];
                                     *pDest++ = pSource[2];
+                                    *pDest++ = pSource[1];
+                                    *pDest++ = pSource[0];
                                     *pDest++ = pSource[3];
                                     pSource += 4;
                                 }
@@ -235,7 +249,7 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                         assert(pSource <= m_pData->getEnd());
                         assert(pDest == pEnd);
                     }
-                    GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
+                    GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
                     GLDEBUG(glFinish());
                     free(converted_image);
                     current_lod_max_dim = m_max_lod_max_dim;
@@ -253,9 +267,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                             // RLE Packet
                             pSource++;
                             while(count--) {
-                                *pDest++ = pSource[0];
-                                *pDest++ = pSource[1];
                                 *pDest++ = pSource[2];
+                                *pDest++ = pSource[1];
+                                *pDest++ = pSource[0];
                                 *pDest++ = 0xff;
                             }
                             pSource += 3;
@@ -263,9 +277,9 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                             // RAW Packet
                             pSource++;
                             while(count--) {
-                                *pDest++ = pSource[0];
-                                *pDest++ = pSource[1];
                                 *pDest++ = pSource[2];
+                                *pDest++ = pSource[1];
+                                *pDest++ = pSource[0];
                                 *pDest++ = 0xff;
                                 pSource += 3;
                             }
@@ -273,7 +287,7 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
                     }
                     assert(pSource <= m_pData->getEnd());
                     assert(pDest == pEnd);
-                    GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
+                    GLDEBUG(glTexImage2D(target, 0, internal_format, pHeader->width, pHeader->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)converted_image));
                     GLDEBUG(glFinish());
                     free(converted_image);
                     current_lod_max_dim = m_max_lod_max_dim;
@@ -293,7 +307,7 @@ bool KRTextureTGA::uploadTexture(GLenum target, int lod_max_dim, int &current_lo
     return true;
 }
 
-#if !TARGET_OS_IPHONE
+#if !TARGET_OS_IPHONE && !defined(ANDROID)
 
 KRTexture *KRTextureTGA::compress(bool premultiply_alpha)
 {

kraken/KRTextureTGA.h

@@ -20,7 +20,7 @@ public:
     
     bool uploadTexture(GLenum target, int lod_max_dim, int &current_lod_max_dim, bool compress = false, bool premultiply_alpha = false);
     
-#if !TARGET_OS_IPHONE
+#if !TARGET_OS_IPHONE && !defined(ANDROID)
     virtual KRTexture *compress(bool premultiply_alpha = false);
 #endif
     

kraken/KRUnknownManager.cpp

@@ -32,7 +32,7 @@
 #include "KRUnknownManager.h"
 #include "KREngine-common.h"
 
-KRUnknownManager::KRUnknownManager(KRContext &context) : KRContextObject(context)
+KRUnknownManager::KRUnknownManager(KRContext &context) : KRResourceManager(context)
 {
     
 }
@@ -74,6 +74,19 @@ void KRUnknownManager::add(KRUnknown *unknown)
     }
 }
 
+
+KRResource* KRUnknownManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
+{
+  // KRUnknown's can have any extension
+  return load(name, extension, data);
+}
+
+KRResource* KRUnknownManager::getResource(const std::string& name, const std::string& extension)
+{
+  // KRUnknown's can have any extension
+  return get(name, extension);
+}
+
 KRUnknown *KRUnknownManager::load(const std::string &name, const std::string &extension, KRDataBlock *data)
 {
     KRUnknown *unknown = new KRUnknown(getContext(), name, extension, data);

kraken/KRUnknownManager.h

@@ -34,15 +34,20 @@
 
 #include "KREngine-common.h"
 
+#include "KRResourceManager.h"
+
 #include "KRUnknown.h"
 #include "KRContextObject.h"
 #include "KRDataBlock.h"
 
-class KRUnknownManager : public KRContextObject {
+class KRUnknownManager : public KRResourceManager {
 public:
     KRUnknownManager(KRContext &context);
     virtual ~KRUnknownManager();
 
+    virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
+    virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
+    
     void add(KRUnknown *unknown);
     
     KRUnknown *load(const std::string &name, const std::string &extension, KRDataBlock *data);

kraken/kraken.cpp

@@ -0,0 +1,80 @@
+#include "public/kraken.h"
+
+#include "KRContext.h"
+#include "KRBundle.h"
+
+namespace {
+
+KRContext* sContext = nullptr;
+
+}; // anonysmous namespace
+
+KrResult KrInitialize(const KrInitializeInfo* pInitializeInfo)
+{
+  if (!sContext) {
+    sContext = new KRContext(pInitializeInfo);
+  }
+  return KR_SUCCESS;
+}
+
+KrResult KrShutdown()
+{
+  if (sContext) {
+    delete sContext;
+    sContext = nullptr;
+  }
+  return KR_SUCCESS;
+}
+
+KrResult KrLoadResource(const KrLoadResourceInfo* pLoadResourceInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->loadResource(pLoadResourceInfo);
+}
+
+KrResult KrUnloadResource(const KrUnloadResourceInfo* pUnloadResourceInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->unloadResource(pUnloadResourceInfo);
+}
+
+KrResult KrSaveResource(const KrSaveResourceInfo* pSaveResourceInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->saveResource(pSaveResourceInfo);
+}
+
+KrResult KrMapResource(const KrMapResourceInfo* pMapResourceInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->mapResource(pMapResourceInfo);
+}
+
+KrResult KrUnmapResource(const KrUnmapResourceInfo* pUnmapResourceInfo)
+{
+  return KR_ERROR_NOT_IMPLEMENTED;
+}
+
+KrResult KrCreateBundle(const KrCreateBundleInfo* pCreateBundleInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->createBundle(pCreateBundleInfo);
+}
+
+KrResult KrMoveToBundle(const KrMoveToBundleInfo* pMoveToBundleInfo)
+{
+  if (!sContext) {
+    return KR_ERROR_NOT_INITIALIZED;
+  }
+  return sContext->moveToBundle(pMoveToBundleInfo);
+}

kraken/kraken.h

@@ -1,19 +0,0 @@
-//
-//  kraken.h
-//  kraken
-//
-//  Created by Kearwood Gilbert on 2015-11-06.
-//  Copyright © 2015 Kearwood Software. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-
-//! Project version number for kraken.
-FOUNDATION_EXPORT double krakenVersionNumber;
-
-//! Project version string for kraken.
-FOUNDATION_EXPORT const unsigned char krakenVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <kraken/PublicHeader.h>
-
-

kraken/public/context.h

@@ -1,8 +1,7 @@
 //
-//  visualize_overlay.vsh
+//  Kraken
-//  KREngine
 //
-//  Copyright 2012 Kearwood Gilbert. All rights reserved.
+//  Copyright 2018 Kearwood Gilbert. All rights reserved.
 //
 //  Redistribution and use in source and binary forms, with or without modification, are
 //  permitted provided that the following conditions are met:
@@ -29,10 +28,23 @@
 //  or implied, of Kearwood Gilbert.
 //
 
-attribute vec4 vertex_position;
+#ifndef KRAKEN_CONTEXT_H
-uniform highp mat4 mvp_matrix; // mvp_matrix is the result of multiplying the model, view, and projection matrices
+#define KRAKEN_CONTEXT_H
 
-void main()
+namespace kraken {
+
+class Context
 {
-	gl_Position = mvp_matrix * vertex_position;
+class impl;
-}
+public:
+  static Context* Get();
+  bool loadResource(const char* szPath);
+private:
+  Context();
+  ~Context();
+  impl* mImpl;
+};
+
+} // namepsace kraken
+
+#endif // KRAKEN_CONTEXT_H