Shader.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
 
#include "Shader.h"
 
#ifdef __ANDROID__
#include <android/log.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
//#include "JniUtils.h"
#include <android/window.h> // for AWINDOW_FLAG_KEEP_SCREEN_ON
#include <android/native_window_jni.h> // for native window JNI
#else
#include <fstream>
#endif
 
#if !defined(ALOGV) && __ANDROID__
#define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, "Framework_Vulkan", __VA_ARGS__)
#endif
 
#ifdef __ANDROID__
void ShadersList::readShader(AAssetManager* assetManager, std::string shaderName){
    ALOGV("Loading %s", shaderName.c_str());
    Shader shad;
    std::string filename = "shaders/"+shaderName+".spv";
    ALOGV("File %s", filename.c_str());
    AAsset* file = AAssetManager_open(assetManager,filename.c_str(), AASSET_MODE_BUFFER);
    shad.size = AAsset_getLength(file);
    ALOGV("Shader File Size: %d", shad.size);
    shad.source = new char[shad.size];
    AAsset_read(file,shad.source, shad.size);
 
    m_shaders.insert(std::pair<std::string, Shader>(shaderName,shad));
}
 
void ShadersList::loadShaders(android_app *app) {
    AAssetManager* assetManager = app->activity->assetManager;
 
    //synthesis shader
    readShader(assetManager,"synthesis.vert");
    readShader(assetManager,"synthesis.geom");
    readShader(assetManager,"synthesis.frag");
 
    readShader(assetManager,"shader.vert");
    readShader(assetManager,"shader.frag");
 
    readShader(assetManager,"blending.vert");
    readShader(assetManager,"blending.frag");
    readShader(assetManager, "blendingFinal.frag");
    readShader(assetManager, "blendingFirst.frag");
    readShader(assetManager, "blendingFirstFinal.frag");
 
}
 
#else
void ShadersList::loadShaders()
{
 
    for (auto & shaderName : namesList) {
        readShader(shaderName);
    }
}
void ShadersList::readShader(std::string & shaderName)
{
    Shader shad;
#ifndef NDEBUG
    shad.name = shaderName;
#endif // !NDEBUG
 
    std::string filename = "./shaders/" + shaderName + ".spv";
    std::ifstream file(filename, std::ios::ate | std::ios::binary);
 
    if (!file.is_open()) {
        throw std::runtime_error("failed to open file!: " + filename + "\n");
    }
 
    size_t fileSize = (size_t)file.tellg();
    shad.size = fileSize;
    shad.source = new char[shad.size];
    file.seekg(0);
    file.read(shad.source, shad.size);
    m_shaders.insert(std::pair<std::string, Shader>(shaderName, shad));
    file.close();
}
#endif
 
ShadersList &ShadersList::getInstance() {
    static ShadersList singleton;
    return singleton;
}
Shader const& ShadersList::operator () (const char* name) const
{
    return m_shaders.at(name);
}
 
ShadersList::ShadersList() {
 
}