727 lines
31 KiB
C++
727 lines
31 KiB
C++
#include "behavior.h"
|
|
|
|
#include <uf/utils/time/time.h>
|
|
#include <uf/utils/io/iostream.h>
|
|
#include <uf/utils/math/vector.h>
|
|
#include <uf/utils/math/transform.h>
|
|
#include <uf/utils/window/window.h>
|
|
#include <uf/utils/graphic/graphic.h>
|
|
|
|
#include <uf/utils/audio/audio.h>
|
|
#include <uf/utils/thread/thread.h>
|
|
#include <uf/utils/camera/camera.h>
|
|
#include <uf/utils/math/physics.h>
|
|
|
|
#include <uf/engine/asset/asset.h>
|
|
#include <uf/engine/asset/masterdata.h>
|
|
|
|
#include <uf/utils/renderer/renderer.h>
|
|
#include <uf/utils/noise/noise.h>
|
|
|
|
#include <uf/ext/gltf/gltf.h>
|
|
|
|
#include <uf/utils/math/collision.h>
|
|
|
|
#include "../light/behavior.h"
|
|
#include "../../ext.h"
|
|
#include "../../gui/gui.h"
|
|
|
|
UF_BEHAVIOR_REGISTER_CPP(ext::ExtSceneBehavior)
|
|
#define this ((uf::Scene*) &self)
|
|
void ext::ExtSceneBehavior::initialize( uf::Object& self ) {
|
|
uf::Asset& assetLoader = this->getComponent<uf::Asset>();
|
|
uf::Serializer& metadataJson = this->getComponent<uf::Serializer>();
|
|
|
|
this->addHook( "system:Quit.%UID%", [&](ext::json::Value& json){
|
|
std::cout << json << std::endl;
|
|
ext::ready = false;
|
|
});
|
|
|
|
this->addHook( "world:Music.LoadPrevious.%UID%", [&](ext::json::Value& json){
|
|
|
|
if ( metadataJson["previous bgm"]["filename"] == "" ) return;
|
|
|
|
std::string filename = metadataJson["previous bgm"]["filename"].as<std::string>();
|
|
float timestamp = metadataJson["previous bgm"]["timestamp"].as<float>();
|
|
|
|
uf::Audio& audio = this->getComponent<uf::Audio>();
|
|
if ( audio.playing() ) {
|
|
metadataJson["previous bgm"]["filename"] = audio.getFilename();
|
|
metadataJson["previous bgm"]["timestamp"] = audio.getTime();
|
|
audio.stop();
|
|
}
|
|
audio.load(filename);
|
|
audio.setVolume(metadataJson["volumes"]["bgm"].as<float>());
|
|
audio.setTime(timestamp);
|
|
audio.play();
|
|
});
|
|
this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
|
|
std::string filename = json["filename"].as<std::string>();
|
|
std::string category = json["category"].as<std::string>();
|
|
if ( category != "" && category != "audio" ) return;
|
|
if ( category == "" && uf::io::extension(filename) != "ogg" ) return;
|
|
const uf::Audio* audioPointer = NULL;
|
|
if ( !assetLoader.has<uf::Audio>(filename) ) return;
|
|
audioPointer = &assetLoader.get<uf::Audio>(filename);
|
|
if ( !audioPointer ) return;
|
|
|
|
uf::Audio& audio = this->getComponent<uf::Audio>();
|
|
if ( audio.playing() ) audio.stop();
|
|
|
|
audio.load(filename);
|
|
audio.setVolume(metadataJson["volumes"]["bgm"].as<float>());
|
|
audio.play();
|
|
});
|
|
|
|
this->addHook( "menu:Pause", [&](ext::json::Value& json){
|
|
static uf::Timer<long long> timer(false);
|
|
if ( !timer.running() ) timer.start( uf::Time<>(-1000000) );
|
|
if ( timer.elapsed().asDouble() < 1 ) return;
|
|
timer.reset();
|
|
|
|
uf::Object* manager = (uf::Object*) this->globalFindByName("Gui Manager");
|
|
if ( !manager ) return;
|
|
uf::Serializer payload;
|
|
std::string config = metadataJson["menus"]["pause"].is<std::string>() ? metadataJson["menus"]["pause"].as<std::string>() : "/scenes/worldscape/gui/pause/menu.json";
|
|
uf::Object& gui = manager->loadChild(config, false);
|
|
payload["uid"] = gui.getUid();
|
|
|
|
uf::Serializer& metadataJson = gui.getComponent<uf::Serializer>();
|
|
metadataJson["menu"] = json["menu"];
|
|
|
|
gui.initialize();
|
|
// return payload;
|
|
});
|
|
this->addHook( "world:Entity.LoadAsset", [&](ext::json::Value& json){
|
|
std::string asset = json["asset"].as<std::string>();
|
|
std::string uid = json["uid"].as<std::string>();
|
|
|
|
assetLoader.load(asset, "asset:Load." + uid);
|
|
});
|
|
this->addHook( "shader:Update.%UID%", [&](ext::json::Value& _json){
|
|
uf::Serializer json = _json;
|
|
json["mode"] = json["mode"].as<size_t>() | metadataJson["system"]["renderer"]["shader"]["mode"].as<size_t>();
|
|
metadataJson["system"]["renderer"]["shader"]["mode"] = json["mode"];
|
|
metadataJson["system"]["renderer"]["shader"]["parameters"] = json["parameters"];
|
|
});
|
|
/* store viewport size */
|
|
this->addHook( "window:Resized", [&](ext::json::Value& json){
|
|
pod::Vector2ui size; {
|
|
size.x = json["window"]["size"]["x"].as<size_t>();
|
|
size.y = json["window"]["size"]["y"].as<size_t>();
|
|
}
|
|
|
|
metadataJson["system"]["window"] = json["system"]["window"];
|
|
ext::gui::size.current = size;
|
|
});
|
|
// lock control
|
|
{
|
|
uf::Serializer payload;
|
|
payload["state"] = false;
|
|
uf::hooks.call("window:Mouse.CursorVisibility", payload);
|
|
uf::hooks.call("window:Mouse.Lock");
|
|
}
|
|
|
|
// initialize perlin noise
|
|
#if UF_USE_VULKAN
|
|
{
|
|
auto& texture = this->getComponent<uf::renderer::Texture3D>();
|
|
texture.sampler.descriptor.addressMode = {
|
|
uf::renderer::enums::AddressMode::MIRRORED_REPEAT,
|
|
uf::renderer::enums::AddressMode::MIRRORED_REPEAT,
|
|
uf::renderer::enums::AddressMode::MIRRORED_REPEAT
|
|
};
|
|
|
|
auto& noiseGenerator = this->getComponent<uf::PerlinNoise>();
|
|
noiseGenerator.seed(rand());
|
|
|
|
float high = std::numeric_limits<float>::min();
|
|
float low = std::numeric_limits<float>::max();
|
|
float amplitude = metadataJson["noise"]["amplitude"].is<float>() ? metadataJson["noise"]["amplitude"].as<float>() : 1.5;
|
|
pod::Vector3ui size = uf::vector::decode(metadataJson["noise"]["size"], pod::Vector3ui{256, 256, 256});
|
|
pod::Vector3d coefficients = uf::vector::decode(metadataJson["noise"]["coefficients"], pod::Vector3d{3.0, 3.0, 3.0});
|
|
|
|
std::vector<uint8_t> pixels(size.x * size.y * size.z);
|
|
std::vector<float> perlins(size.x * size.y * size.z);
|
|
#pragma omp parallel for
|
|
for ( size_t z = 0; z < size.z; ++z ) {
|
|
for ( size_t y = 0; y < size.y; ++y ) {
|
|
for ( size_t x = 0; x < size.x; ++x ) {
|
|
float nx = (float) x / (float) size.x;
|
|
float ny = (float) y / (float) size.y;
|
|
float nz = (float) z / (float) size.z;
|
|
|
|
float n = amplitude * noiseGenerator.noise(coefficients.x * nx, coefficients.y * ny, coefficients.z * nz);
|
|
high = std::max( high, n );
|
|
low = std::min( low, n );
|
|
perlins[x + y * size.x + z * size.x * size.y] = n;
|
|
}
|
|
}
|
|
}
|
|
for ( size_t i = 0; i < perlins.size(); ++i ) {
|
|
float n = perlins[i];
|
|
n = n - floor(n);
|
|
float normalized = (n - low) / (high - low);
|
|
if ( normalized >= 1.0f ) normalized = 1.0f;
|
|
pixels[i] = static_cast<uint8_t>(floor(normalized * 255));
|
|
}
|
|
texture.fromBuffers( (void*) pixels.data(), pixels.size(), uf::renderer::enums::Format::R8_UNORM, size.x, size.y, size.z, 1 );
|
|
}
|
|
// initialize cubemap
|
|
{
|
|
std::vector<std::string> filenames = {
|
|
uf::io::root+"/textures/skybox/front.png",
|
|
uf::io::root+"/textures/skybox/back.png",
|
|
uf::io::root+"/textures/skybox/up.png",
|
|
uf::io::root+"/textures/skybox/down.png",
|
|
uf::io::root+"/textures/skybox/right.png",
|
|
uf::io::root+"/textures/skybox/left.png",
|
|
};
|
|
uf::Image::container_t pixels;
|
|
std::vector<uf::Image> images(filenames.size());
|
|
|
|
pod::Vector2ui size = {0,0};
|
|
auto& texture = this->getComponent<uf::renderer::TextureCube>();
|
|
for ( size_t i = 0; i < filenames.size(); ++i ) {
|
|
auto& filename = filenames[i];
|
|
auto& image = images[i];
|
|
image.open(filename);
|
|
image.flip();
|
|
|
|
if ( size.x == 0 && size.y == 0 ) {
|
|
size = image.getDimensions();
|
|
} else if ( size != image.getDimensions() ) {
|
|
std::cout << "ERROR: MISMATCH CUBEMAP FACE SIZE" << std::endl;
|
|
}
|
|
|
|
auto& p = image.getPixels();
|
|
pixels.reserve( pixels.size() + p.size() );
|
|
pixels.insert( pixels.end(), p.begin(), p.end() );
|
|
}
|
|
texture.mips = 0;
|
|
texture.fromBuffers( (void*) pixels.data(), pixels.size(), uf::renderer::enums::Format::R8G8B8A8_UNORM, size.x, size.y, 1, filenames.size() );
|
|
}
|
|
#endif
|
|
|
|
auto& metadata = this->getComponent<ext::ExtSceneBehavior::Metadata>();
|
|
metadata.max.textures = metadataJson["system"]["config"]["engine"]["scenes"]["textures"]["max"].as<size_t>();
|
|
metadata.max.lights = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
|
|
metadata.light.enabled = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["enabled"].as<bool>() && metadataJson["light"]["should"].as<bool>();
|
|
metadata.light.shadowSamples = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow samples"].as<size_t>();
|
|
metadata.light.shadowThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow threshold"].as<size_t>();
|
|
metadata.light.updateThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["update threshold"].as<size_t>();
|
|
metadata.light.ambient = uf::vector::decode( metadataJson["light"]["ambient"], pod::Vector4f{ 1, 1, 1, 1 } );
|
|
metadata.light.specular = uf::vector::decode( metadataJson["light"]["specular"], pod::Vector4f{ 1, 1, 1, 1 } );
|
|
metadata.fog.color = uf::vector::decode( metadataJson["light"]["fog"]["color"], pod::Vector3f{ 1, 1, 1 } );
|
|
metadata.fog.stepScale = metadataJson["light"]["fog"]["step scale"].as<float>();
|
|
metadata.fog.absorbtion = metadataJson["light"]["fog"]["absorbtion"].as<float>();
|
|
metadata.fog.range = uf::vector::decode( metadataJson["light"]["fog"]["range"], pod::Vector2f{ 0, 0 } );
|
|
metadata.fog.density.offset = uf::vector::decode( metadataJson["light"]["fog"]["density"]["offset"], pod::Vector4f{ 0, 0, 0, 0 } );
|
|
metadata.fog.density.timescale = metadataJson["light"]["fog"]["density"]["timescale"].as<float>();
|
|
metadata.fog.density.threshold = metadataJson["light"]["fog"]["density"]["threshold"].as<float>();
|
|
metadata.fog.density.multiplier = metadataJson["light"]["fog"]["density"]["multiplier"].as<float>();
|
|
metadata.fog.density.scale = metadataJson["light"]["fog"]["density"]["scale"].as<float>();
|
|
}
|
|
void ext::ExtSceneBehavior::tick( uf::Object& self ) {
|
|
auto& metadata = this->getComponent<ext::ExtSceneBehavior::Metadata>();
|
|
auto& metadataJson = this->getComponent<uf::Serializer>();
|
|
/* Regain control if nothing requests it */ {
|
|
if ( !this->globalFindByName("Gui: Menu") ) {
|
|
uf::Serializer payload;
|
|
payload["state"] = false;
|
|
uf::hooks.call("window:Mouse.CursorVisibility", payload);
|
|
uf::hooks.call("window:Mouse.Lock");
|
|
} else {
|
|
uf::Serializer payload;
|
|
payload["state"] = true;
|
|
uf::hooks.call("window:Mouse.CursorVisibility", payload);
|
|
}
|
|
}
|
|
#if 0
|
|
uf::hooks.call("game:Frame.Start");
|
|
|
|
uf::Serializer& metadata = this->getComponent<uf::Serializer>();
|
|
uf::Asset& assetLoader = this->getComponent<uf::Asset>();
|
|
/* Print World Tree */ {
|
|
TIMER(1, uf::Window::isKeyPressed("U") && ) {
|
|
std::function<void(uf::Entity*, int)> filter = []( uf::Entity* entity, int indent ) {
|
|
for ( int i = 0; i < indent; ++i ) uf::iostream << "\t";
|
|
uf::iostream << uf::string::toString(entity->as<uf::Object>()) << " ";
|
|
if ( entity->hasComponent<pod::Transform<>>() ) {
|
|
pod::Transform<> t = uf::transform::flatten(entity->getComponent<pod::Transform<>>());
|
|
uf::iostream << uf::string::toString(t.position) << " " << uf::string::toString(t.orientation);
|
|
}
|
|
uf::iostream << "\n";
|
|
};
|
|
for ( uf::Scene* scene : uf::scene::scenes ) {
|
|
if ( !scene ) continue;
|
|
uf::iostream << "Scene: " << scene->getName() << ": " << scene << "\n";
|
|
scene->process(filter, 1);
|
|
}
|
|
}
|
|
}
|
|
/* Print World Tree */ {
|
|
TIMER(1, uf::Window::isKeyPressed("U") && false && ) {
|
|
std::function<void(uf::Entity*, int)> filter = []( uf::Entity* entity, int indent ) {
|
|
for ( int i = 0; i < indent; ++i ) uf::iostream << "\t";
|
|
uf::iostream << uf::string::toString(entity->as<uf::Object>()) << " [";
|
|
for ( auto& behavior : entity->getBehaviors() ) {
|
|
uf::iostream << uf::instantiator::behaviors->names[behavior.type] << ", ";
|
|
}
|
|
uf::iostream << "]\n";
|
|
};
|
|
for ( uf::Scene* scene : uf::scene::scenes ) {
|
|
if ( !scene ) continue;
|
|
uf::iostream << "Scene: " << scene->getName() << ": " << scene << "\n";
|
|
scene->process(filter, 1);
|
|
}
|
|
uf::Serializer instantiator;
|
|
{
|
|
int i = 0;
|
|
for ( auto& pair : uf::instantiator::objects->names ) {
|
|
instantiator["objects"][i++] = pair.second;
|
|
}
|
|
}
|
|
{
|
|
int i = 0;
|
|
for ( auto& pair : uf::instantiator::behaviors->names ) {
|
|
instantiator["behaviors"][i++] = pair.second;
|
|
}
|
|
}
|
|
uf::iostream << instantiator << "\n";
|
|
}
|
|
}
|
|
#endif
|
|
#if UF_USE_OPENAL
|
|
auto& assetLoader = this->getComponent<uf::Asset>();
|
|
/* check if audio needs to loop */ {
|
|
auto& bgm = this->getComponent<uf::Audio>();
|
|
float current = bgm.getTime();
|
|
float end = bgm.getDuration();
|
|
float epsilon = 0.005f;
|
|
if ( current + epsilon >= end || !bgm.playing() ) {
|
|
// intro to main transition
|
|
std::string filename = bgm.getFilename();
|
|
filename = assetLoader.getOriginal(filename);
|
|
if ( filename.find("_intro") != std::string::npos ) {
|
|
assetLoader.load(uf::string::replace( filename, "_intro", "" ), this->formatHookName("asset:Load.%UID%"));
|
|
// loop
|
|
} else {
|
|
bgm.setTime(0);
|
|
if ( !bgm.playing() ) bgm.play();
|
|
}
|
|
}
|
|
}
|
|
/* Updates Sound Listener */ {
|
|
auto& controller = this->getController();
|
|
// copy
|
|
pod::Transform<> transform = controller.getComponent<pod::Transform<>>();
|
|
if ( controller.hasComponent<uf::Camera>() ) {
|
|
auto& camera = controller.getComponent<uf::Camera>();
|
|
transform.position += camera.getTransform().position;
|
|
transform = uf::transform::reorient( transform );
|
|
}
|
|
transform.forward *= -1;
|
|
ext::oal.listener( "POSITION", { transform.position.x, transform.position.y, transform.position.z } );
|
|
ext::oal.listener( "VELOCITY", { 0, 0, 0 } );
|
|
ext::oal.listener( "ORIENTATION", { transform.forward.x, transform.forward.y, transform.forward.z, transform.up.x, transform.up.y, transform.up.z } );
|
|
}
|
|
#endif
|
|
|
|
#if UF_ENTITY_METADATA_USE_JSON
|
|
metadata.max.textures = metadataJson["system"]["config"]["engine"]["scenes"]["textures"]["max"].as<size_t>();
|
|
metadata.max.lights = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
|
|
metadata.light.enabled = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["enabled"].as<bool>() && metadataJson["light"]["should"].as<bool>();
|
|
metadata.light.shadowSamples = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow samples"].as<size_t>();
|
|
metadata.light.shadowThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow threshold"].as<size_t>();
|
|
metadata.light.updateThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["update threshold"].as<size_t>();
|
|
metadata.light.ambient = uf::vector::decode( metadataJson["light"]["ambient"], pod::Vector4f{ 1, 1, 1, 1 } );
|
|
metadata.light.specular = uf::vector::decode( metadataJson["light"]["specular"], pod::Vector4f{ 1, 1, 1, 1 } );
|
|
metadata.fog.color = uf::vector::decode( metadataJson["light"]["fog"]["color"], pod::Vector3f{ 1, 1, 1 } );
|
|
metadata.fog.stepScale = metadataJson["light"]["fog"]["step scale"].as<float>();
|
|
metadata.fog.absorbtion = metadataJson["light"]["fog"]["absorbtion"].as<float>();
|
|
metadata.fog.range = uf::vector::decode( metadataJson["light"]["fog"]["range"], pod::Vector2f{ 0, 0 } );
|
|
metadata.fog.density.offset = uf::vector::decode( metadataJson["light"]["fog"]["density"]["offset"], pod::Vector4f{ 0, 0, 0, 0 } );
|
|
metadata.fog.density.timescale = metadataJson["light"]["fog"]["density"]["timescale"].as<float>();
|
|
metadata.fog.density.threshold = metadataJson["light"]["fog"]["density"]["threshold"].as<float>();
|
|
metadata.fog.density.multiplier = metadataJson["light"]["fog"]["density"]["multiplier"].as<float>();
|
|
metadata.fog.density.scale = metadataJson["light"]["fog"]["density"]["scale"].as<float>();
|
|
#else
|
|
if ( !metadata.max.textures ) metadata.max.textures = metadataJson["system"]["config"]["engine"]["scenes"]["textures"]["max"].as<size_t>();
|
|
if ( !metadata.max.lights ) metadata.max.lights = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
|
|
if ( !metadata.light.enabled ) metadata.light.enabled = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["enabled"].as<bool>() && metadataJson["light"]["should"].as<bool>();
|
|
if ( !metadata.light.shadowSamples ) metadata.light.shadowSamples = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow samples"].as<size_t>();
|
|
if ( !metadata.light.shadowThreshold ) metadata.light.shadowThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["shadow threshold"].as<size_t>();
|
|
if ( !metadata.light.updateThreshold ) metadata.light.updateThreshold = metadataJson["system"]["config"]["engine"]["scenes"]["lights"]["update threshold"].as<size_t>();
|
|
#endif
|
|
|
|
/* Update lights */ if ( metadata.light.enabled ) {
|
|
auto& scene = uf::scene::getCurrentScene();
|
|
auto& controller = scene.getController();
|
|
auto& camera = controller.getComponent<uf::Camera>();
|
|
auto& renderMode = uf::renderer::getRenderMode("", true);
|
|
auto& controllerMetadata = controller.getComponent<uf::Serializer>();
|
|
auto& controllerTransform = controller.getComponent<pod::Transform<>>();
|
|
std::vector<uf::Graphic*> blitters = renderMode.getBlitters();
|
|
|
|
#if UF_USE_OPENGL
|
|
struct LightInfo {
|
|
uf::Entity* entity = NULL;
|
|
pod::Vector4f position = {0,0,0,1};
|
|
pod::Vector4f color = {0,0,0,1};
|
|
float distance = 0;
|
|
float power = 0;
|
|
};
|
|
std::vector<LightInfo> entities;
|
|
if ( uf::scene::useGraph ) {
|
|
auto graph = uf::scene::generateGraph();
|
|
for ( auto entity : graph ) {
|
|
if ( entity == &controller || entity == this ) continue;
|
|
if ( entity->getName() != "Light" && !entity->hasComponent<ext::LightBehavior::Metadata>() ) continue;
|
|
auto& metadata = entity->getComponent<ext::LightBehavior::Metadata>();
|
|
if ( metadata.power <= 0 ) continue;
|
|
LightInfo& info = entities.emplace_back();
|
|
auto& transform = entity->getComponent<pod::Transform<>>();
|
|
auto flatten = uf::transform::flatten( transform );
|
|
info.entity = entity;
|
|
info.position = flatten.position;
|
|
info.position.w = 1;
|
|
info.color = metadata.color;
|
|
info.color.w = 1;
|
|
info.distance = uf::vector::magnitude( uf::vector::subtract( flatten.position, controllerTransform.position ) );
|
|
info.power = metadata.power;
|
|
}
|
|
} else {
|
|
this->process([&]( uf::Entity* entity ) { if ( !entity ) return;
|
|
if ( entity == &controller || entity == this ) return;
|
|
if ( entity->getName() != "Light" && !entity->hasComponent<ext::LightBehavior::Metadata>() ) return;
|
|
auto& metadata = entity->getComponent<ext::LightBehavior::Metadata>();
|
|
if ( metadata.power <= 0 ) return;
|
|
LightInfo& info = entities.emplace_back();
|
|
auto& transform = entity->getComponent<pod::Transform<>>();
|
|
auto flatten = uf::transform::flatten( transform );
|
|
info.entity = entity;
|
|
info.position = flatten.position;
|
|
info.position.w = 1;
|
|
info.color = metadata.color;
|
|
info.color.w = 1;
|
|
info.distance = uf::vector::magnitude( uf::vector::subtract( flatten.position, controllerTransform.position ) );
|
|
info.power = metadata.power;
|
|
});
|
|
}
|
|
std::sort( entities.begin(), entities.end(), [&]( LightInfo& l, LightInfo& r ){
|
|
return l.distance < r.distance;
|
|
});
|
|
|
|
static GLint glMaxLights = 0;
|
|
if ( !glMaxLights ) glGetIntegerv(GL_MAX_LIGHTS, &glMaxLights);
|
|
metadata.max.lights = std::min( (size_t) glMaxLights, metadata.max.lights );
|
|
|
|
// add lighting
|
|
{
|
|
size_t i = 0;
|
|
for ( ; i < entities.size() && i < metadata.max.lights; ++i ) {
|
|
auto& info = entities[i];
|
|
uf::Entity* entity = info.entity;
|
|
GLenum target = GL_LIGHT0+i;
|
|
GL_ERROR_CHECK(glEnable(target));
|
|
GL_ERROR_CHECK(glLightfv(target, GL_AMBIENT, &metadata.light.ambient[0]));
|
|
GL_ERROR_CHECK(glLightfv(target, GL_SPECULAR, &metadata.light.specular[0]));
|
|
GL_ERROR_CHECK(glLightfv(target, GL_DIFFUSE, &info.color[0]));
|
|
GL_ERROR_CHECK(glLightfv(target, GL_POSITION, &info.position[0]));
|
|
GL_ERROR_CHECK(glLightf(target, GL_CONSTANT_ATTENUATION, 0.0f));
|
|
GL_ERROR_CHECK(glLightf(target, GL_LINEAR_ATTENUATION, 0));
|
|
GL_ERROR_CHECK(glLightf(target, GL_QUADRATIC_ATTENUATION, 1.0f / info.power));
|
|
}
|
|
for ( ; i < metadata.max.lights; ++i ) GL_ERROR_CHECK(glDisable(GL_LIGHT0+i));
|
|
}
|
|
#elif UF_USE_VULKAN
|
|
size_t maxTextures = metadata.max.textures;
|
|
struct UniformDescriptor {
|
|
struct Matrices {
|
|
alignas(16) pod::Matrix4f view[2];
|
|
alignas(16) pod::Matrix4f projection[2];
|
|
alignas(16) pod::Matrix4f iView[2];
|
|
alignas(16) pod::Matrix4f iProjection[2];
|
|
alignas(16) pod::Matrix4f iProjectionView[2];
|
|
} matrices;
|
|
struct Mode {
|
|
alignas(8) pod::Vector2ui type;
|
|
alignas(8) pod::Vector2ui padding;
|
|
alignas(16) pod::Vector4f parameters;
|
|
} mode;
|
|
struct {
|
|
alignas(16) pod::Vector4f color; // w: stepScale
|
|
alignas(16) pod::Vector4f offset; // w: densityScale
|
|
alignas(4) float densityThreshold;
|
|
alignas(4) float densityMultiplier;
|
|
|
|
alignas(4) float absorbtion;
|
|
alignas(4) float padding1;
|
|
|
|
alignas(8) pod::Vector2f range;
|
|
alignas(4) float padding2;
|
|
alignas(4) float padding3;
|
|
} fog;
|
|
struct {
|
|
alignas(4) uint32_t lights = 0;
|
|
alignas(4) uint32_t materials = 0;
|
|
alignas(4) uint32_t textures = 0;
|
|
alignas(4) uint32_t drawCalls = 0;
|
|
} lengths;
|
|
alignas(16) pod::Vector4f ambient;
|
|
// alignas(16) pod::Vector4f position;
|
|
|
|
alignas(4) uint32_t msaa;
|
|
alignas(4) uint32_t poissonSamples;
|
|
alignas(4) uint32_t padding1;
|
|
alignas(4) uint32_t padding2;
|
|
};
|
|
struct SpecializationConstant {
|
|
uint32_t maxTextures = 512;
|
|
} specializationConstants;
|
|
specializationConstants.maxTextures = maxTextures;
|
|
|
|
struct LightInfo {
|
|
uf::Entity* entity = NULL;
|
|
pod::Vector4f color = {0,0,0,0};
|
|
pod::Vector3f position = {0,0,0};
|
|
float power = 0;
|
|
float distance = 0;
|
|
float bias = 0;
|
|
bool shadows = false;
|
|
size_t type = 0;
|
|
};
|
|
std::vector<LightInfo> entities;
|
|
std::vector<pod::Graph*> graphs;
|
|
if ( uf::scene::useGraph ) {
|
|
auto graph = uf::scene::generateGraph();
|
|
for ( auto entity : graph ) {
|
|
if ( entity == &controller || entity == this ) continue;
|
|
if ( entity->hasComponent<pod::Graph>() ) graphs.emplace_back(&entity->getComponent<pod::Graph>());
|
|
if ( entity->getName() != "Light" && !entity->hasComponent<ext::LightBehavior::Metadata>() ) continue;
|
|
auto& metadata = entity->getComponent<ext::LightBehavior::Metadata>();
|
|
if ( entity->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
|
|
auto& renderMode = entity->getComponent<uf::renderer::RenderTargetRenderMode>();
|
|
if ( metadata.renderer.mode == "in-range" ) renderMode.execute;
|
|
}
|
|
if ( metadata.power <= 0 ) continue;
|
|
LightInfo& info = entities.emplace_back();
|
|
auto& transform = entity->getComponent<pod::Transform<>>();
|
|
auto flatten = uf::transform::flatten( transform );
|
|
info.entity = entity;
|
|
info.position = flatten.position;
|
|
info.color = metadata.color;
|
|
info.color.w = metadata.power;
|
|
info.distance = uf::vector::magnitude( uf::vector::subtract( flatten.position, controllerTransform.position ) );
|
|
info.shadows = metadata.shadows;
|
|
info.bias = metadata.bias;
|
|
info.type = metadata.type;
|
|
}
|
|
} else {
|
|
this->process([&]( uf::Entity* entity ) { if ( !entity ) return;
|
|
if ( entity == &controller || entity == this ) return;
|
|
if ( entity->hasComponent<pod::Graph>() ) graphs.emplace_back(&entity->getComponent<pod::Graph>());
|
|
if ( entity->getName() != "Light" && !entity->hasComponent<ext::LightBehavior::Metadata>() ) return;
|
|
auto& metadata = entity->getComponent<ext::LightBehavior::Metadata>();
|
|
if ( entity->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
|
|
auto& renderMode = entity->getComponent<uf::renderer::RenderTargetRenderMode>();
|
|
if ( metadata.renderer.mode == "in-range" ) renderMode.execute;
|
|
}
|
|
if ( metadata.power <= 0 ) return;
|
|
LightInfo& info = entities.emplace_back();
|
|
auto& transform = entity->getComponent<pod::Transform<>>();
|
|
auto flatten = uf::transform::flatten( transform );
|
|
info.entity = entity;
|
|
info.position = flatten.position;
|
|
info.color = metadata.color;
|
|
info.color.w = metadata.power;
|
|
info.distance = uf::vector::magnitude( uf::vector::subtract( flatten.position, controllerTransform.position ) );
|
|
info.shadows = metadata.shadows;
|
|
info.bias = metadata.bias;
|
|
info.type = metadata.type;
|
|
});
|
|
}
|
|
std::sort( entities.begin(), entities.end(), [&]( LightInfo& l, LightInfo& r ){
|
|
return l.distance < r.distance;
|
|
});
|
|
|
|
int& shadowSamples = metadata.light.shadowSamples;
|
|
int& shadowThreshold = metadata.light.shadowThreshold;
|
|
if ( shadowSamples <= 0 ) shadowSamples = 16;
|
|
if ( shadowThreshold <= 0 ) shadowThreshold = std::numeric_limits<int>::max();
|
|
{
|
|
std::vector<LightInfo> scratch;
|
|
scratch.reserve(entities.size());
|
|
for ( size_t i = 0; i < entities.size(); ++i ) {
|
|
auto& info = entities[i];
|
|
if ( info.shadows && --shadowThreshold <= 0 ) info.shadows = false;
|
|
scratch.emplace_back(info);
|
|
}
|
|
entities = scratch;
|
|
}
|
|
|
|
for ( auto* blitter : blitters ) {
|
|
auto& graphic = *blitter;
|
|
auto& shader = graphic.material.getShader("fragment");
|
|
auto& uniform = shader.getUniform("UBO");
|
|
uint8_t* buffer = (uint8_t*) (void*) uniform;
|
|
|
|
UniformDescriptor* uniforms = (UniformDescriptor*) buffer;
|
|
|
|
for ( std::size_t i = 0; i < 2; ++i ) {
|
|
uniforms->matrices.view[i] = camera.getView( i );
|
|
uniforms->matrices.projection[i] = camera.getProjection( i );
|
|
uniforms->matrices.iView[i] = uf::matrix::inverse( uniforms->matrices.view[i] );
|
|
uniforms->matrices.iProjection[i] = uf::matrix::inverse( uniforms->matrices.projection[i] );
|
|
uniforms->matrices.iProjectionView[i] = uf::matrix::inverse( uniforms->matrices.projection[i] * uniforms->matrices.view[i] );
|
|
}
|
|
|
|
uniforms->ambient = metadata.light.ambient;
|
|
uniforms->msaa = ext::vulkan::settings::msaa;
|
|
uniforms->poissonSamples = shadowSamples;
|
|
|
|
uniforms->fog.color = metadata.fog.color;
|
|
uniforms->fog.color.w = metadata.fog.stepScale;
|
|
|
|
float timescale = metadata.fog.density.timescale;
|
|
uniforms->fog.offset = metadata.fog.density.offset * uf::physics::time::current * timescale;
|
|
uniforms->fog.offset.w = metadata.fog.density.scale;
|
|
|
|
uniforms->fog.densityThreshold = metadata.fog.density.threshold;
|
|
uniforms->fog.densityMultiplier = metadata.fog.density.multiplier;
|
|
uniforms->fog.absorbtion = metadata.fog.absorbtion;
|
|
|
|
uniforms->fog.range = metadata.fog.range;
|
|
|
|
uniforms->mode.type.x = metadataJson["system"]["renderer"]["shader"]["mode"].as<size_t>();
|
|
uniforms->mode.type.y = metadataJson["system"]["renderer"]["shader"]["scalar"].as<size_t>();
|
|
uniforms->mode.parameters = uf::vector::decode( metadataJson["system"]["renderer"]["shader"]["parameters"], uniforms->mode.parameters );
|
|
if ( metadataJson["system"]["renderer"]["shader"]["parameters"][3].as<std::string>() == "time" ) {
|
|
uniforms->mode.parameters.w = uf::physics::time::current;
|
|
}
|
|
|
|
std::vector<VkImage> previousTextures;
|
|
for ( auto& texture : graphic.material.textures ) previousTextures.emplace_back(texture.image);
|
|
|
|
graphic.material.textures.clear();
|
|
graphic.material.textures.emplace_back().aliasTexture(this->getComponent<uf::renderer::Texture3D>());
|
|
graphic.material.textures.emplace_back().aliasTexture(this->getComponent<uf::renderer::TextureCube>());
|
|
|
|
size_t& updateThreshold = metadata.light.updateThreshold;
|
|
size_t textureSlot = 0;
|
|
|
|
std::vector<pod::Light::Storage> lights;
|
|
lights.reserve( metadata.max.lights );
|
|
|
|
std::vector<pod::Material::Storage> materials;
|
|
materials.reserve(maxTextures);
|
|
materials.emplace_back().colorBase = {0,0,0,0};
|
|
|
|
std::vector<pod::Texture::Storage> textures;
|
|
textures.reserve(maxTextures);
|
|
|
|
std::vector<pod::DrawCall::Storage> drawCalls;
|
|
drawCalls.reserve(maxTextures);
|
|
|
|
// add materials
|
|
for ( auto* entity : graphs ) {
|
|
auto& graph = *entity;
|
|
|
|
drawCalls.emplace_back(pod::DrawCall::Storage{
|
|
materials.size(),
|
|
graph.materials.size(),
|
|
textures.size(),
|
|
graph.textures.size()
|
|
});
|
|
|
|
for ( auto& material : graph.materials ) materials.emplace_back( material.storage );
|
|
for ( auto& texture : graph.textures ) textures.emplace_back( texture.storage );
|
|
|
|
for ( auto& texture : graph.textures ) {
|
|
if ( !texture.texture.device ) continue;
|
|
|
|
graphic.material.textures.emplace_back().aliasTexture(texture.texture);
|
|
++textureSlot;
|
|
|
|
if ( graph.atlas ) break;
|
|
}
|
|
}
|
|
|
|
uniforms->lengths.materials = std::min( materials.size(), maxTextures );
|
|
uniforms->lengths.textures = std::min( textures.size(), maxTextures );
|
|
uniforms->lengths.drawCalls = std::min( drawCalls.size(), maxTextures );
|
|
// add lighting
|
|
for ( size_t i = 0; i < entities.size() && lights.size() < metadata.max.lights; ++i ) {
|
|
auto& info = entities[i];
|
|
uf::Entity* entity = info.entity;
|
|
|
|
auto& transform = entity->getComponent<pod::Transform<>>();
|
|
auto& metadata = entity->getComponent<ext::LightBehavior::Metadata>();
|
|
auto& camera = entity->getComponent<uf::Camera>();
|
|
metadata.renderer.rendered = true;
|
|
|
|
pod::Light::Storage light;
|
|
light.position = info.position;
|
|
|
|
light.color = info.color;
|
|
light.type = info.type;
|
|
light.mapIndex = -1;
|
|
|
|
light.depthBias = info.bias;
|
|
if ( info.shadows && entity->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
|
|
auto& renderMode = entity->getComponent<uf::renderer::RenderTargetRenderMode>();
|
|
if ( metadata.renderer.mode == "in-range" && --updateThreshold > 0 ) {
|
|
renderMode.execute = true;
|
|
}
|
|
size_t view = 0;
|
|
for ( auto& attachment : renderMode.renderTarget.attachments ) {
|
|
if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ) continue;
|
|
if ( attachment.descriptor.layout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ) continue;
|
|
|
|
graphic.material.textures.emplace_back().aliasAttachment(attachment);
|
|
|
|
light.mapIndex = textureSlot++;
|
|
light.view = camera.getView(view);
|
|
light.projection = camera.getProjection(view);
|
|
lights.emplace_back(light);
|
|
|
|
++view;
|
|
}
|
|
light.mapIndex = -1;
|
|
} else {
|
|
lights.emplace_back(light);
|
|
}
|
|
}
|
|
{
|
|
uniforms->lengths.lights = std::min( lights.size(), metadata.max.lights );
|
|
bool shouldUpdate = graphic.material.textures.size() != previousTextures.size();
|
|
for ( size_t i = 0; !shouldUpdate && i < previousTextures.size() && i < graphic.material.textures.size(); ++i ) {
|
|
if ( previousTextures[i] != graphic.material.textures[i].image )
|
|
shouldUpdate = true;
|
|
}
|
|
|
|
size_t lightBufferIndex = renderMode.metadata["lightBufferIndex"].as<size_t>();
|
|
graphic.updateBuffer( (void*) lights.data(), uniforms->lengths.lights * sizeof(pod::Light::Storage), lightBufferIndex, false );
|
|
|
|
if ( shouldUpdate ) {
|
|
size_t materialBufferIndex = renderMode.metadata["materialBufferIndex"].as<size_t>();
|
|
graphic.updateBuffer( (void*) materials.data(), uniforms->lengths.materials * sizeof(pod::Material::Storage), materialBufferIndex, false );
|
|
|
|
size_t textureBufferIndex = renderMode.metadata["textureBufferIndex"].as<size_t>();
|
|
graphic.updateBuffer( (void*) textures.data(), uniforms->lengths.textures * sizeof(pod::Texture::Storage), textureBufferIndex, false );
|
|
|
|
size_t drawCallBufferIndex = renderMode.metadata["drawCallBufferIndex"].as<size_t>();
|
|
graphic.updateBuffer( (void*) drawCalls.data(), uniforms->lengths.drawCalls * sizeof(pod::DrawCall::Storage), drawCallBufferIndex, false );
|
|
|
|
graphic.updatePipelines();
|
|
}
|
|
shader.updateUniform( "UBO", uniform );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
void ext::ExtSceneBehavior::render( uf::Object& self ) {}
|
|
void ext::ExtSceneBehavior::destroy( uf::Object& self ) {}
|
|
#undef this |