bool SceneObjectCartPole::create() {
assert(getScene() != nullptr);
// Rendering
std::shared_ptr<pge::Asset> asset;
if (!getScene()->getAssetManager("MOBJ", pge::StaticModelOBJ::assetFactory)->getAsset("resources/models/Cart.obj", asset))
return false;
_pCartModel = static_cast<pge::StaticModelOBJ*>(asset.get());
if (!getScene()->getAssetManager("MOBJ", pge::StaticModelOBJ::assetFactory)->getAsset("resources/models/Pole.obj", asset))
return false;
_pPoleModel = static_cast<pge::StaticModelOBJ*>(asset.get());
// Get reference to physics world
_physicsWorld = getScene()->getNamedCheckQueue("physWrld");
reset();
_capture = false;
_capBytes = std::make_shared<std::vector<char>>(getRenderScene()->_gBuffer.getWidth() * getRenderScene()->_gBuffer.getHeight() * 3, 0);
_show = getRenderScene()->_renderingEnabled;
_socket = std::make_shared<sf::TcpSocket>();
_socket->connect(sf::IpAddress::LocalHost, _port, sf::seconds(5.0f));
_doneLastFrame = false;
return true;
}
bool SceneObjectSurf::create() {
assert(getScene() != nullptr);
_size = 5;
_numStartBlocks = 5;
// Rendering
std::shared_ptr<pge::Asset> asset;
if (!getScene()->getAssetManager("MOBJ", pge::StaticModelOBJ::assetFactory)->getAsset("resources/models/block.obj", asset))
return false;
_pBlockModel = static_cast<pge::StaticModelOBJ*>(asset.get());
if (!getScene()->getAssetManager("MOBJ", pge::StaticModelOBJ::assetFactory)->getAsset("resources/models/bot.obj", asset))
return false;
_pAgentModel = static_cast<pge::StaticModelOBJ*>(asset.get());
reset();
_capture = false;
_capBytes = std::make_shared<std::vector<char>>(getRenderScene()->_gBuffer.getWidth() * getRenderScene()->_gBuffer.getHeight() * 3, 0);
_show = getRenderScene()->_renderingEnabled;
_socket = std::make_shared<sf::TcpSocket>();
_socket->connect(sf::IpAddress::LocalHost, _port);
return true;
}
void SceneObjectOrbitCamera::update(float dt) {
pge::SceneObjectBufferedInput* pBufferedInput = static_cast<pge::SceneObjectBufferedInput*>(_input.get());
_angle += dt * _angularVelocity;
pge::Vec3f pos = _focusPoint + pge::Vec3f(cosf(_angle) * _distance, sinf(_tilt) * _distance, sinf(_angle) * _distance);
pge::Quaternion lookDir = pge::Quaternion::getFromMatrix(pge::Matrix4x4f::cameraDirectionMatrix((_focusPoint - pos).normalized(), pge::Vec3f(0.0f, 1.0f, 0.0f)));
getRenderScene()->_logicCamera._position = pos;
getRenderScene()->_logicCamera._rotation = lookDir;
}
void SceneObjectPlayer::synchronousUpdate(float dt) {
SceneObjectGUI* pGUI = static_cast<SceneObjectGUI*>(_gui.get());
pGUI->_enabled = !_acceptingInput;
getRenderScene()->getRenderWindow()->setMouseCursorVisible(!_acceptingInput);
}
void SceneObjectCartPole::postRender() {
// Get data from effect buffer
glReadBuffer(GL_FRONT);
glReadPixels(0, 0, getRenderScene()->_gBuffer.getWidth(), getRenderScene()->_gBuffer.getHeight(), GL_RGB, GL_UNSIGNED_BYTE, _capBytes->data());
}
void SceneObjectCartPole::synchronousUpdate(float dt) {
if (_ticks >= _ticksPerAction || !getRenderScene()->_renderingEnabled) {
_ticks = 0;
std::array<char, _maxBatchSize> buffer;
std::array<char, 1 + 4 + 4> msg;
size_t received = 0;
size_t totalReceived = 0;
while (totalReceived < msg.size()) {
_socket->receive(buffer.data(), msg.size() - totalReceived, received);
for (int i = 0; i < received; i++)
msg[totalReceived + i] = buffer[i];
totalReceived += received;
}
if (msg[0] == 'A') { // Action
_action = pge::Vec2f(*reinterpret_cast<float*>(&msg[1]), *reinterpret_cast<float*>(&msg[5]));
}
else if (msg[0] == 'R') { // Reset
_action = pge::Vec2f(*reinterpret_cast<float*>(&msg[1]), *reinterpret_cast<float*>(&msg[5]));
reset();
}
else if (msg[0] == 'C') { // Capture + action
_action = pge::Vec2f(*reinterpret_cast<float*>(&msg[1]), *reinterpret_cast<float*>(&msg[5]));
_capture = true;
if (!getRenderScene()->_renderingEnabled) {
getRenderScene()->getRenderWindow()->setFramerateLimit(60);
getRenderScene()->getRenderWindow()->setVerticalSyncEnabled(true);
}
getRenderScene()->_renderingEnabled = true;
}
else if (msg[0] == 'S') { // Stop capture + action
_action = pge::Vec2f(*reinterpret_cast<float*>(&msg[1]), *reinterpret_cast<float*>(&msg[5]));
_capture = false;
if (!_show) {
if (getRenderScene()->_renderingEnabled) {
getRenderScene()->getRenderWindow()->setFramerateLimit(0);
getRenderScene()->getRenderWindow()->setVerticalSyncEnabled(false);
}
getRenderScene()->_renderingEnabled = false;
}
}
else if (msg[0] == 'X') { // Exit
getRenderScene()->_close = true;
}
_action.x = std::min(1.0f, std::max(-1.0f, _action.x));
_action.y = std::min(1.0f, std::max(-1.0f, _action.y));
act();
// Give state and reward (+ capture if is on)
// Observation (8 values)
std::vector<float> obs(8);
btVector3 pos = _pRigidBodyCart->getWorldTransform().getOrigin();
btVector3 vel = _pRigidBodyCart->getLinearVelocity();
btQuaternion rot = _pRigidBodyPole->getWorldTransform().getRotation();
btVector3 angleVel = _pRigidBodyPole->getAngularVelocity();
pge::Quaternion rotC = cons(rot);
pge::Vec3f rotE = rotC.getEulerAngles();
obs[0] = pos.getX();
obs[1] = pos.getZ();
obs[2] = vel.getX();
obs[3] = vel.getZ();
obs[4] = rotE.x;
obs[5] = rotE.z;
obs[6] = angleVel.getX();
obs[7] = angleVel.getZ();
// First add reward
int index = 0;
*reinterpret_cast<float*>(&buffer[index]) = _reward;
index += sizeof(float);
for (int i = 0; i < obs.size(); i++) {
*reinterpret_cast<float*>(&buffer[index]) = obs[i];
index += sizeof(float);
}
// Reset flag
*reinterpret_cast<int*>(&buffer[index]) = static_cast<int>(_doneLastFrame);
_doneLastFrame = false;
index += sizeof(int);
// Submit number of batches of _maxBatchSize
int numBatches = _capBytes->size() / _maxBatchSize + ((_capBytes->size() % _maxBatchSize) == 0 ? 0 : 1);
// No batches if not capturing
if (!_capture)
numBatches = 0;
*reinterpret_cast<int*>(&buffer[index]) = numBatches;
index += sizeof(int);
_socket->send(buffer.data(), index);
if (_capture) {
std::vector<char> reorganized(_capBytes->size());
int reorgIndex = 0;
for (int y = 0; y < getRenderScene()->_gBuffer.getHeight(); y++)
for (int x = 0; x < getRenderScene()->_gBuffer.getWidth(); x++) {
int start = 3 * (x + (getRenderScene()->_gBuffer.getHeight() - 1 - y) * getRenderScene()->_gBuffer.getWidth());
reorganized[reorgIndex++] = (*_capBytes)[start + 0];
reorganized[reorgIndex++] = (*_capBytes)[start + 1];
reorganized[reorgIndex++] = (*_capBytes)[start + 2];
}
int total = 0;
for (int i = 0; i < numBatches; i++) {
// Submit batch
size_t count = 0;
for (int j = 0; j < _maxBatchSize && total < _capBytes->size(); j++) {
buffer[j] = reorganized[total++];
count++;
}
_socket->send(buffer.data(), count);
}
}
}
else
_ticks++;
}
void SceneObjectPlayer::update(float dt) {
pge::SceneObjectBufferedInput* pBufferedInput = static_cast<pge::SceneObjectBufferedInput*>(_input.get());
if (pBufferedInput->isKeyPressed(sf::Keyboard::Escape)) {
_acceptingInput = !_acceptingInput;
if (_acceptingInput) {
_lastMousePosition = sf::Mouse::getPosition(*getRenderScene()->getRenderWindow());
sf::Mouse::setPosition(sf::Vector2i(128, 128), *getRenderScene()->getRenderWindow());
}
else
sf::Mouse::setPosition(_lastMousePosition, *getRenderScene()->getRenderWindow());
}
if (_acceptingInput) {
sf::Vector2i mousePosition = sf::Mouse::getPosition(*getRenderScene()->getRenderWindow()) - sf::Vector2i(128, 128);
sf::Mouse::setPosition(sf::Vector2i(128, 128), *getRenderScene()->getRenderWindow());
_angleX -= mousePosition.x * _sensitivity;
_angleY -= mousePosition.y * _sensitivity;
_angleX = std::fmodf(_angleX, pge::_piTimes2);
if (_angleY < -pge::_piOver2)
_angleY = -pge::_piOver2;
else if (_angleY > pge::_piOver2)
_angleY = pge::_piOver2;
getRenderScene()->_logicCamera._rotation = pge::Quaternion(_angleX, pge::Vec3f(0.0f, 1.0f, 0.0f)) * pge::Quaternion(_angleY, pge::Vec3f(1.0f, 0.0f, 0.0f));
if (_allowNoclipChange)
if (pBufferedInput->isKeyPressed(sf::Keyboard::N))
setNoClip(_characterController != nullptr);
if (_characterController == nullptr) {
float accel = sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) ? _noClipAcceleration * _noClipRunMultiplier : _noClipAcceleration;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
_noClipVelocity += getRenderScene()->_logicCamera._rotation * pge::Vec3f(0.0f, 0.0f, -accel * dt);
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
_noClipVelocity += getRenderScene()->_logicCamera._rotation * pge::Vec3f(0.0f, 0.0f, accel * dt);
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
_noClipVelocity += getRenderScene()->_logicCamera._rotation * pge::Vec3f(accel * dt, 0.0f, 0.0f);
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
_noClipVelocity += getRenderScene()->_logicCamera._rotation * pge::Vec3f(-accel * dt, 0.0f, 0.0f);
_noClipVelocity += -_noClipDeceleration * _noClipVelocity * dt;
getRenderScene()->_logicCamera._position += _noClipVelocity * dt;
}
else {
float accel = sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) ? _acceleration * _runMultiplier : _acceleration;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
_characterController->walk(getRenderScene()->_logicCamera._rotation * pge::Vec3f(0.0f, 0.0f, -accel * dt));
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
_characterController->walk(getRenderScene()->_logicCamera._rotation * pge::Vec3f(0.0f, 0.0f, accel * dt));
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
_characterController->walk(getRenderScene()->_logicCamera._rotation * pge::Vec3f(accel * dt, 0.0f, 0.0f));
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
_characterController->walk(getRenderScene()->_logicCamera._rotation * pge::Vec3f(-accel * dt, 0.0f, 0.0f));
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
_characterController->jump();
_characterController->_deceleration = _deceleration;
_characterController->update(dt);
getRenderScene()->_logicCamera._position = _characterController->getPosition() + pge::Vec3f(0.0f, _cameraHeightOffset, 0.0f);
}
}
}
void SceneObjectSurf::synchronousUpdate(float dt) {
if (_ticks >= _ticksPerAction || !getRenderScene()->_renderingEnabled) {
_ticks = 0;
std::array<char, _maxBatchSize> buffer;
// Receive 1 byte
size_t received = 0;
_socket->receive(buffer.data(), 1 + 4, received);
if (buffer[0] == 'A') { // Action
_action = *reinterpret_cast<int*>(&buffer[1]);
}
else if (buffer[0] == 'R') { // Reset
reset();
}
else if (buffer[0] == 'C') { // Capture + action
_action = *reinterpret_cast<int*>(&buffer[1]);
_capture = true;
getRenderScene()->_renderingEnabled = true;
}
else if (buffer[0] == 'S') { // Stop capture + action
_action = *reinterpret_cast<int*>(&buffer[1]);
_capture = false;
if (!_show) {
getRenderScene()->_renderingEnabled = false;
}
}
else if (buffer[0] == 'X') { // Exit
getRenderScene()->_close = true;
}
act();
// Give state and reward (+ capture if is on)
// Observation (values of 9 fields around agent)
std::vector<int> obs(9);
int obsIndex = 0;
int agentX = _agentPosition % _size;
int agentY = _agentPosition / _size;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
int tx = agentX + dx;
int ty = agentY + dy;
if (tx >= 0 && ty >= 0 && tx < _size && ty < _size) {
obs[obsIndex++] = _blocks[tx + ty * _size];
}
else
obs[obsIndex++] = -1; // -1 for wall
}
// First add reward
int index = 0;
*reinterpret_cast<float*>(&buffer[index]) = _reward;
index += sizeof(float);
for (int i = 0; i < obs.size(); i++) {
*reinterpret_cast<int*>(&buffer[index]) = obs[i];
index += sizeof(int);
}
// Submit number of batches of _maxBatchSize
int numBatches = _capBytes->size() / _maxBatchSize + ((_capBytes->size() % _maxBatchSize) == 0 ? 0 : 1);
// No batches if not capturing
if (!_capture)
numBatches = 0;
*reinterpret_cast<int*>(&buffer[index]) = numBatches;
index += sizeof(int);
_socket->send(buffer.data(), index);
if (_capture) {
std::vector<char> reorganized(_capBytes->size());
int reorgIndex = 0;
for (int y = 0; y < getRenderScene()->_gBuffer.getHeight(); y++)
for (int x = 0; x < getRenderScene()->_gBuffer.getWidth(); x++) {
int start = 3 * (x + (getRenderScene()->_gBuffer.getHeight() - 1 - y) * getRenderScene()->_gBuffer.getWidth());
reorganized[reorgIndex++] = (*_capBytes)[start + 0];
reorganized[reorgIndex++] = (*_capBytes)[start + 1];
reorganized[reorgIndex++] = (*_capBytes)[start + 2];
}
int total = 0;
for (int i = 0; i < numBatches; i++) {
// Submit batch
size_t count = 0;
for (int j = 0; j < _maxBatchSize && total < _capBytes->size(); j++) {
buffer[j] = reorganized[total++];
count++;
}
_socket->send(buffer.data(), count);
}
}
}
else
_ticks++;
}
void SceneObjectEntryPointSurf::onAdd() {
// Physics
std::shared_ptr<pge::SceneObjectPhysicsWorld> physicsWorld(new pge::SceneObjectPhysicsWorld());
getRenderScene()->addNamed(physicsWorld, "physWrld");
pge::SceneObjectRef lighting = getScene()->getNamed("lighting");
pge::SceneObjectLighting* pLighting = static_cast<pge::SceneObjectLighting*>(lighting.get());
pLighting->_ambientLight = pge::Vec3f(0.01f, 0.01f, 0.01f);
/*std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> light(new pge::SceneObjectDirectionalLightShadowed());
getRenderScene()->add(light);
light->create(pLighting, 2, 2048, 0.5f, 100.0f, 0.6f);
light->setDirection(pge::Vec3f(-0.4f, -1.0f, 0.6f).normalized());
light->setColor(pge::Vec3f(1.0f, 1.0f, 1.0f));*/
// GUI
/*std::shared_ptr<SceneObjectGUI> gui(new SceneObjectGUI());
getRenderScene()->addNamed(gui, "gui", false);
gui->_layer = 2.0f;*/
// Control
std::shared_ptr<SceneObjectOrbitCamera> camera(new SceneObjectOrbitCamera());
getRenderScene()->add(camera, false);
// Map
/*std::shared_ptr<pge::Map3DWS> map(new pge::Map3DWS());
map->_settings._pScene = getScene();
map->createAsset("resources/maps/horrorMap.3dw");
pge::addMapLights(*map, getScene());*/
std::shared_ptr<SceneObjectProp> prop(new SceneObjectProp());
getScene()->add(prop, true);
prop->create("resources/models/BlockGame.obj");
prop->calculateAABB();
std::shared_ptr<SceneObjectSurf> cartPole(new SceneObjectSurf());
getRenderScene()->add(cartPole, false);
cartPole->create();
cartPole->_layer = 100.0f;
std::shared_ptr<SceneObjectProp> sky(new SceneObjectProp());
getScene()->add(sky, true);
sky->create("resources/models/skybox1.obj");
sky->_transform = pge::Matrix4x4f::scaleMatrix(pge::Vec3f(100.0f, 100.0f, 100.0f));
sky->calculateAABB();
std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> directionalLight(new pge::SceneObjectDirectionalLightShadowed());
getScene()->add(directionalLight);
directionalLight->create(pLighting, 3, 2048, 0.2f, 100.0f, 0.6f);
directionalLight->setDirection(pge::Vec3f(-0.2523f, -0.9423f, -0.424f).normalized());
directionalLight->setColor(pge::Vec3f(0.7f, 0.7f, 0.7f));
// ------------------------------------------- Image Effects -------------------------------------------
std::shared_ptr<pge::SceneObjectEffectBuffer> effectBuffer(new pge::SceneObjectEffectBuffer());
getRenderScene()->addNamed(effectBuffer, "ebuf", false);
effectBuffer->create(0.5f);
std::shared_ptr<pge::Asset> assetBlurHorizontal;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontal.frag", assetBlurHorizontal);
std::shared_ptr<pge::Shader> blurShaderHorizontal = std::static_pointer_cast<pge::Shader>(assetBlurHorizontal);
std::shared_ptr<pge::Asset> assetBlurVertical;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVertical.frag", assetBlurVertical);
std::shared_ptr<pge::Shader> blurShaderVertical = std::static_pointer_cast<pge::Shader>(assetBlurVertical);
std::shared_ptr<pge::Asset> assetRenderImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImage.frag", assetRenderImage);
std::shared_ptr<pge::Shader> renderImageShader = std::static_pointer_cast<pge::Shader>(assetRenderImage);
std::shared_ptr<pge::Asset> assetRenderMultImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImageMult.frag", assetRenderMultImage);
std::shared_ptr<pge::Shader> renderImageMultShader = std::static_pointer_cast<pge::Shader>(assetRenderMultImage);
std::shared_ptr<pge::Asset> assetNoise;
getScene()->getAssetManager("tex2D", pge::Texture2D::assetFactory)->getAsset("resources/textures/noise.bmp", assetNoise);
std::shared_ptr<pge::Texture2D> noiseMap = std::static_pointer_cast<pge::Texture2D>(assetNoise);
noiseMap->bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
std::shared_ptr<pge::Asset> assetBlurHorizontalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontalEdgeAware.frag", assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderHorizontalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Asset> assetBlurVerticalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVerticalEdgeAware.frag", assetBlurVerticalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderVerticalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurVerticalEdgeAware);
// SSAO
/*std::shared_ptr<pge::Shader> ssaoShader(new pge::Shader());
ssaoShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssao.frag");
std::shared_ptr<pge::SceneObjectSSAO> ssao(new pge::SceneObjectSSAO());
getRenderScene()->add(ssao, false);
ssao->create(blurShaderHorizontal, blurShaderVertical, ssaoShader, renderImageShader, noiseMap);
ssao->_ssaoRadius = 0.1f;
ssao->_ssaoStrength = 1.0f;
ssao->_blurRadius = 0.002f;
ssao->_numBlurPasses = 1;*/
// SSR
std::shared_ptr<pge::TextureCube> cubeMap(new pge::TextureCube());
cubeMap->createAsset(
"resources/environmentmaps/skybox1/CloudyLightRaysLeft2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysRight2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysBack2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysFront2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysDown2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysUp2048.png "
);
std::shared_ptr<pge::Shader> ssrShader(new pge::Shader());
ssrShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssr.frag");
std::shared_ptr<pge::SceneObjectSSR> ssr(new pge::SceneObjectSSR());
getRenderScene()->add(ssr, false);
ssr->create(blurShaderHorizontalEdgeAware, blurShaderVerticalEdgeAware, ssrShader, renderImageShader, cubeMap, noiseMap);
ssr->_layer = 1.0f;
// Light Scattering
/*std::shared_ptr<pge::Shader> lightScatteringShader(new pge::Shader());
lightScatteringShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lightScattering.frag");
std::shared_ptr<pge::SceneObjectLightScattering> lightScattering(new pge::SceneObjectLightScattering());
getRenderScene()->add(lightScattering, false);
lightScattering->create(blurShaderHorizontal, blurShaderVertical, lightScatteringShader, renderImageShader);
lightScattering->_layer = 1.5f;
lightScattering->_lightSourcePosition = -light->getDirection() * 200.0f;
lightScattering->_lightSourceColor = pge::Vec3f(1.0f, 0.9f, 0.8f) * 0.5f;*/
// Depth of field
/*std::shared_ptr<pge::Shader> depthOfFieldBlurShaderHorizontal(new pge::Shader());
depthOfFieldBlurShaderHorizontal->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurHorizontal.frag");
std::shared_ptr<pge::Shader> depthOfFieldBlurShaderVertical(new pge::Shader());
depthOfFieldBlurShaderVertical->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurVertical.frag");
std::shared_ptr<pge::SceneObjectDepthOfField> depthOfField(new pge::SceneObjectDepthOfField());
getRenderScene()->add(depthOfField, false);
depthOfField->create(depthOfFieldBlurShaderHorizontal, depthOfFieldBlurShaderVertical, renderImageShader);
depthOfField->_layer = 1.5f;
depthOfField->_focalDistance = 9.0f;
depthOfField->_focalRange = 0.4f;
depthOfField->_blurRadius = 0.002f;
depthOfField->_numBlurPasses = 1;*/
// FXAA
std::shared_ptr<pge::Shader> lumaShader(new pge::Shader());
lumaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lumaRender.frag");
std::shared_ptr<pge::Shader> fxaaShader(new pge::Shader());
fxaaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/fxaa.frag");
std::shared_ptr<pge::SceneObjectFXAA> fxaa(new pge::SceneObjectFXAA());
getRenderScene()->add(fxaa, false);
fxaa->create(fxaaShader, lumaShader);
destroy();
}
