///Обработка события изменения размеров окна
void OnSizeChanged (unsigned int width, unsigned int height)
{
try
{
UpdateSizes (width, height);
if (signals [WindowEvent_OnResize].empty ())
return;
if (color_buffer)
{
color_buffer->Resize (width, height);
depth_stencil_buffer->Resize (width, height);
}
Window window = Wrappers::Wrap<Window> (owner);
signals [WindowEvent_OnResize] (window);
}
catch (std::exception& e)
{
log.Printf ("%s\n at render::manager::WindowImpl::Impl::OnResize", e.what ());
}
catch (...)
{
log.Printf ("unknown exception\n at render::manager::WindowImpl::Impl::OnResize");
}
}
///Обработчик события изменения области вывода
void OnViewportChanged (const Rect& viewport)
{
try
{
log.Printf ("Window viewport changed: x=%d, y=%d, width=%u, height=%u", viewport.x, viewport.y, viewport.width, viewport.height);
if (color_buffer)
{
color_buffer->Resize (viewport.width, viewport.height);
color_buffer->SetViewportOffset (math::vec2ui (viewport.x, viewport.y));
}
if (depth_stencil_buffer)
{
depth_stencil_buffer->Resize (viewport.width, viewport.height);
depth_stencil_buffer->SetViewportOffset (math::vec2ui (viewport.x, viewport.y));
}
}
catch (std::exception& e)
{
log.Printf ("%s\n at render::manager::WindowImpl::Impl::OnChangeViewport", e.what ());
}
catch (...)
{
log.Printf ("unknown exception\n at render::manager::WindowImpl::Impl::OnChangeViewport");
}
}
void PostEffect_SSAO::Render(RenderSystemPtr pRenderer, RenderTargetPtr pInput, RenderTargetPtr pOutput)
{
pRenderer->SetRenderTarget(m_pGBlurTarget);
pRenderer->ClearRenderTarget(m_pGBlurTarget, 0, math::Color4(0, 0, 0,0));
m_pMaterial->SetGBuffer(pRenderer->GetGBuffer());
m_pMaterial->SetVectorByName("g_screen_size", math::Vector2(pRenderer->GetFrameBufferWidth(), pRenderer->GetFrameBufferHeight()));
m_pMaterial->SetFloatByName("g_scale", m_scale);
m_pMaterial->SetFloatByName("g_random_size", m_randomTexSize);
m_pMaterial->SetFloatByName("g_sample_rad", m_sampleRad);
m_pMaterial->SetFloatByName("g_bias", m_bias);
m_pMaterial->SetFloatByName("g_intensity", m_intensity);
pRenderer->DrawFullScreenQuad(m_pMaterial);
pRenderer->SetRenderTarget(pOutput);
pRenderer->ClearRenderTarget(pOutput, 0, math::Color4(0, 0, 0,0));
m_pGBlurMaterial->SetGBuffer(pRenderer->GetGBuffer());
m_pGBlurMaterial->SetTextureByName("tex_ao", m_pGBlurTarget->AsTexture(0));
m_pGBlurMaterial->SetVectorByName("g_input_size", math::Vector2(pRenderer->GetFrameBufferWidth(), pRenderer->GetFrameBufferHeight()));
m_pGBlurMaterial->SetTextureByName("tex_input", pInput->AsTexture(0));
pRenderer->DrawFullScreenQuad(m_pGBlurMaterial);
}
void D3D11EffectMaterial::SetABuffer(RenderTargetPtr pABuffer)
{
if(m_semantics.m_pABuffer == nullptr)
{
return;
}
D3D11Texture* pTex1 = (D3D11Texture*)(pABuffer->AsTexture(0).get());
m_semantics.m_pABuffer->SetResource(pTex1->GetShaderResourceView());
}
void PostEffect_GaussianBlur::Render(RenderSystemPtr pRenderer, RenderTargetPtr pInput, RenderTargetPtr pOutput)
{
pRenderer->SetRenderTarget(pOutput);
pRenderer->ClearRenderTarget(pOutput, 0, math::Color4(0, 0, 0,0));
m_pMaterial->SetTextureByName("tex_input", pInput->AsTexture(0));
m_pMaterial->SetVectorByName("g_input_size", math::Vector2(pRenderer->GetFrameBufferWidth(), pRenderer->GetFrameBufferHeight()));
pRenderer->DrawFullScreenQuad(m_pMaterial);
}
void GraphicsDriver::ClearRenderTarget(RenderTargetPtr inRenderTarget, const Vector3& inColor, float inAlpha)
{
float color[4];
color[0] = inColor.x;
color[1] = inColor.y;
color[2] = inColor.z;
color[3] = inAlpha;
// Clear the back buffer
g_pImmediateContext->ClearRenderTargetView( inRenderTarget.get(), color );
}
void D3D11EffectMaterial::SetGBuffer(RenderTargetPtr pGBuffer)
{
if(m_semantics.m_pGBuffer == nullptr)
{
return;
}
D3D11Texture* pTex1 = (D3D11Texture*)(pGBuffer->AsTexture(0).get());
D3D11Texture* pTex2 = (D3D11Texture*)(pGBuffer->AsTexture(1).get());
D3D11Texture* pTex3 = (D3D11Texture*)(pGBuffer->AsTexture(2).get());
ID3D11ShaderResourceView* pBuffers[3] = {
pTex1->GetShaderResourceView(),
pTex2->GetShaderResourceView(),
pTex3->GetShaderResourceView(),
};
m_semantics.m_pGBuffer->SetResourceArray(pBuffers, 0, 3);
}
//---------------------------------------------------------------------------
void SkySphere::CreateSharedEnvRT(){
if (!sRT)
{
RenderTargetParam param;
param.mEveryFrame = false;
param.mSize = Vec2I(ENV_SIZE, ENV_SIZE);
param.mPixelFormat = PIXEL_FORMAT_R8G8B8A8_UNORM;
param.mShaderResourceView = true;
param.mMipmap = true;
param.mCubemap = true;
param.mWillCreateDepth = false;
param.mUsePool = true;
auto& renderer = Renderer::GetInstance();
sRT = renderer.CreateRenderTarget(param);
sScene = Scene::Create("SkySphereScene");
sRT->RegisterScene(sScene);
sRenderStrategy = RenderStrategyMinimum::Create();
sRT->SetRenderStrategy(sRenderStrategy);
}
}
void TargetRenderer::render() {
for (RenderJobMap::iterator it = m_targets.begin(); it != m_targets.end(); ++it) {
if (it->second.ndraws != -1) {
if (it->second.ndraws == it->second.lasttime_draw) {
RenderTargetPtr rt = it->second.target;
m_renderbackend->attachRenderTarget(rt->m_target, it->second.discard);
rt->render();
m_renderbackend->detachRenderTarget();
if(it->second.ndraws == 0) {
it->second.ndraws = -1;
} else {
it->second.lasttime_draw = 0;
}
} else {
++it->second.lasttime_draw;
}
}
}
}
TexturePtr LinearGradient::createAsTexture(int width, int height)
{
const float w = static_cast<float>(width);
const float h = static_cast<float>(height);
const float sa = std::abs(std::sin(-angle_ / 180.0f * static_cast<float>(M_PI)));
const float ca = std::abs(std::cos(-angle_ / 180.0f * static_cast<float>(M_PI)));
//const float length = std::min(ca < FLT_EPSILON ? FLT_MAX : width / ca, sa < FLT_EPSILON ? FLT_MAX : height / sa);
//const float length = std::min(ca < FLT_EPSILON ? w : 2.0f * ca * w, sa < FLT_EPSILON ? h : 2.0f * sa * h);
WindowPtr wnd = WindowManager::getMainWindow();
CameraPtr cam = std::make_shared<Camera>("ortho_lg", 0, width, 0, height);
auto grad = createRenderable();
grad->setCamera(cam);
grad->setScale(ca < FLT_EPSILON ? w : 2.0f * w / ca, sa < FLT_EPSILON ? h : 2.0f * h / sa);
grad->setPosition(w/2.0f, h/2.0f);
RenderTargetPtr rt = RenderTarget::create(width, height);
rt->getTexture()->setFiltering(-1, Texture::Filtering::LINEAR, Texture::Filtering::LINEAR, Texture::Filtering::POINT);
rt->getTexture()->setAddressModes(-1, Texture::AddressMode::CLAMP, Texture::AddressMode::CLAMP);
rt->setCentre(Blittable::Centre::TOP_LEFT);
rt->setClearColor(Color(0,0,0,0));
{
RenderTarget::RenderScope rs(rt, rect(0, 0, width, height));
grad->preRender(wnd);
wnd->render(grad.get());
}
return rt->getTexture();
}
///Обработка события смены оконного дескриптора
void OnHandleChanged (void* handle)
{
try
{
log.Printf ("Swap chain handle changed (handle=%p)", handle);
swap_chain = 0;
if (!handle)
return;
CreateSwapChain (handle);
try
{
CreateRenderTargets ();
}
catch (...)
{
swap_chain = 0;
if (color_buffer) color_buffer->SetTarget (0);
if (depth_stencil_buffer) depth_stencil_buffer->SetTarget (0);
throw;
}
}
catch (std::exception& e)
{
log.Printf ("%s\n at render::manager::WindowImpl::Impl::OnChangeHandle", e.what ());
}
catch (...)
{
log.Printf ("unknown exception\n at render::manager::WindowImpl::Impl::OnChangeHandle");
}
}
void UpdateEnvironmentMap(const Vec3& origin){
if (!sRT)
{
Logger::Log(FB_ERROR_LOG_ARG, "No render target found.");
return;
}
auto& renderer = Renderer::GetInstance();
TexturePtr pTexture = sRT->GetRenderTargetTexture();
pTexture->Unbind();
SceneManager::GetInstance().CopyDirectionalLight(sRT->GetScene(), 0, renderer.GetMainRenderTarget()->GetScene(), 0);
sRT->GetScene()->AttachSky(mSelfPtr.lock());
sRT->GetCamera()->SetPosition(origin);
sRT->GetCamera()->SetFOV(HALF_PI);
sRT->GetCamera()->SetAspectRatio(1.0f);
Vec3 dirs[] = {
Vec3(1, 0, 0), Vec3(-1, 0, 0),
Vec3(0, 0, 1), Vec3(0, 0, -1),
Vec3(0, 1, 0), Vec3(0, -1, 0),
};
for (int i = 0; i < 6; i++)
{
sRT->GetCamera()->SetDirection(dirs[i]);
sRT->Render(i);
}
// this is for unbind the environment map from the output slot.
renderer.GetMainRenderTarget()->BindTargetOnly(false);
pTexture->GenerateMips();
//pTexture->SaveToFile("environment.dds");
// for bight test.
//ITexture* textureFile = gFBEnv->pRenderer->CreateTexture("data/textures/brightEnv.jpg");
renderer.SetEnvironmentTexture(pTexture);
sRT->GetScene()->DetachSky();
}
///Создание целей рендеринга
void CreateRenderTargets ()
{
try
{
if (!swap_chain)
throw xtl::format_operation_exception ("", "Null swap chain");
log.Printf ("Initialize render targets for swap chain");
LowLevelTexturePtr color_texture (device_manager->Device ().CreateRenderTargetTexture (swap_chain.get (), swap_chain_desc.buffers_count - 1), false),
depth_stencil_texture (device_manager->Device ().CreateDepthStencilTexture (swap_chain.get ()), false);
if (!color_buffer)
{
RenderTargetPtr new_color_buffer (new RenderTargetImpl (device_manager, color_texture.get ()), false),
new_depth_stencil_buffer (new RenderTargetImpl (device_manager, depth_stencil_texture.get ()), false);
color_buffer = new_color_buffer;
depth_stencil_buffer = new_depth_stencil_buffer;
}
else
{
try
{
color_buffer->SetTarget (color_texture.get ());
depth_stencil_buffer->SetTarget (depth_stencil_texture.get ());
}
catch (...)
{
color_buffer->SetTarget (0);
depth_stencil_buffer->SetTarget (0);
throw;
}
}
color_buffer->Resize (width, height);
depth_stencil_buffer->Resize (width, height);
log.Printf ("...render targets for swap chain created");
}
catch (xtl::exception& e)
{
e.touch ("render::manager::WindowImpl::Impl::CreateRenderTargets");
throw;
}
}
void UGraphicsDevice::SetRenderTarget(RenderTargetPtr inRenderTarget, DepthStencilViewPtr inDepthStencil)
{
auto renderTarget = inRenderTarget.get();
mD3dDeviceCtx->OMSetRenderTargets(1, &renderTarget, inDepthStencil.get());
}
void RenderToTextureTest::Init()
{
camera->setDepthField(10, 1320);
camera->setView(Vec3(0, -340, 57), Vec3(0, 30, 20), Vec3(0, 0, 1));
camera->setQueueCullFunc([](int queue) {
if (queue == 50) {
return true;
}
return false;
});
renderManager = &(SceneManager::instance().getRenderManager());
renderer = &(renderManager->getRenderer());
TextureParser::instance().addTextures("Textures/NormalMap", "png|jpg");
auto texture = TextureManager::instance().getTexture("diffuse");
GeometryPtr geometry = nullptr;
MeshPtr mesh = nullptr;
geometry = ShapeGenerater::instance().CreateCylinder(50, 50, 100, 10, 10);
cylinderNode = CreateMeshEntity();
SetMeshData(cylinderNode, geometry, texture);
cylinderNode->getComponent<RenderElement>()->getMaterial()->setQueueID(52);
rootNode->addChild(cylinderNode->getNode());
// create a render target
renderTarget = Create<RenderTarget>();
renderTarget->setHasDepthBuffer(true);
renderTarget->setHasStencilBuffer(false);
renderer->setupRenderTarget(*renderTarget);
auto size = renderTarget->getSize();
auto presCamera = CreateNode<Camera>();
presCamera->setViewport(size.width, size.height);
presCamera->setDepthField(10, 1320);
presCamera->setView(Vec3(0, -340, 57), Vec3(0, 30, 20), Vec3(0, 0, 1));
presCamera->setQueueCullFunc([](int queue) {
if (queue == 52) {
return true;
}
return false;
});
presCamera->setRenderTarget(renderTarget);
presCamera->setClearColor(Color(169.0/255, 74.0/255, 174.0/255, 1));
SceneManager::instance().getRenderManager().addCamera(presCamera);
SceneManager::instance().addRootNode(presCamera->getNode());
// create the normal geometry
geometry = ShapeGenerater::instance().CreateBox(100, 10, 100, 20, 20, 20);
boxNode = CreateMeshEntity();
SetMeshData(boxNode, geometry, renderTarget->getTexture());
rootNode->addChild(boxNode->getNode());
}
void GraphicsDriver::ClearRenderTarget( RenderTargetPtr inRenderTarget, const XMVECTORF32& inColor )
{
// Clear the back buffer
g_pImmediateContext->ClearRenderTargetView( inRenderTarget.get(), inColor );
}
void UGraphicsDevice::ClearRenderTarget(RenderTargetPtr inRenderTarget, const float inClearColor[4])
{
mD3dDeviceCtx->ClearRenderTargetView(inRenderTarget.get(), inClearColor);
}
int main(int argc, char *argv[])
{
#ifdef _MSC_VER
SetProcessDPIAware();
#endif
std::list<double> smoothed_time;
double cumulative_time = 0.0;
int cnt = 0;
using namespace KRE;
SDL::SDL_ptr manager(new SDL::SDL());
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
WindowManager wm("SDL");
variant_builder hints;
hints.add("renderer", "opengl");
hints.add("dpi_aware", true);
hints.add("use_vsync", true);
int neww = 1600, newh = 900;
//if(!autoWindowSize(neww, newh)) {
// LOG_DEBUG("Couldn't get automatic window size. Defaulting to " << neww << "x" << newh);
//}
LOG_DEBUG("Creating window of size: " << neww << "x" << newh);
auto main_wnd = wm.createWindow(neww, newh, hints.build());
main_wnd->enableVsync(true);
const float aspect_ratio = static_cast<float>(neww) / newh;
std::map<std::string, std::string> font_paths;
#if defined(__linux__)
LOG_DEBUG("setting image file filter to 'images/'");
Surface::setFileFilter(FileFilterType::LOAD, [](const std::string& fname) { return "images/" + fname; });
Surface::setFileFilter(FileFilterType::SAVE, [](const std::string& fname) { return "images/" + fname; });
font_paths["FreeSans.ttf"] = "data/fonts/FreeSans.ttf";
#else
LOG_DEBUG("setting image file filter to '../images/'");
Surface::setFileFilter(FileFilterType::LOAD, [](const std::string& fname) { return "../images/" + fname; });
Surface::setFileFilter(FileFilterType::SAVE, [](const std::string& fname) { return "../images/" + fname; });
font_paths["FreeSans.ttf"] = "../data/fonts/FreeSans.ttf";
#endif
Font::setAvailableFonts(font_paths);
/*auto surf = Surface::create("test_image.png");
for(auto col : *surf) {
LOG_DEBUG(col.red << "," << col.green << "," << col.blue << "," << col.alpha);
}*/
set_alpha_masks();
// XXX should a scenegraph be created from a specific window? It'd solve a couple of issues
SceneGraphPtr scene = SceneGraph::create("main");
SceneNodePtr root = scene->getRootNode();
root->setNodeName("root_node");
/*auto scenecam = std::make_shared<Camera>("cam0", 0, neww, 0, newh);
scenecam->attachFrustum(std::make_shared<Frustum>());
root->attachCamera(scenecam);
auto sunlight = std::make_shared<Light>("the_sun", glm::vec3(1.0f, 1.0f, 1.0f));
sunlight->setAmbientColor(Color(1.0f,1.0f,1.0f,1.0f));
root->attachLight(0, sunlight);*/
DisplayDevice::getCurrent()->setDefaultCamera(std::make_shared<Camera>("ortho1", 0, neww, 0, newh));
auto rman = std::make_shared<RenderManager>();
auto rq = rman->addQueue(0, "opaques");
/*SquareRenderablePtr square(std::make_shared<SquareRenderable>());
square->setPosition(600.0f, 400.0f);
square->setScale(2.0f,2.0f);
root->attachObject(square);
auto cairo_canvas = Vector::Context::CreateInstance("cairo", 512, 512);
cairo_canvas->SetSourceColor(0.0, 1.0, 0.0);
cairo_canvas->Paint();
cairo_canvas->Fill();
auto path = cairo_canvas->NewPath();
path->Circle(256, 256, 100);
cairo_canvas->AddPath(path);
cairo_canvas->SetSourceColor(0.0, 0.0, 1.0);
cairo_canvas->Fill();
auto text = cairo_canvas->NewPath();
text->MoveTo(10, 10);
text->TextPath("ABCDabcde");
cairo_canvas->AddPath(text);
cairo_canvas->Fill();
cairo_canvas->setOrder(5);
cairo_canvas->setPosition(256.0f,256.0f);
cairo_canvas->setColor(1.0f,1.0f,1.0f,1.0f);
root->attachObject(cairo_canvas);*/
#if defined(__linux__)
//std::string psys_test_file = "data/psystem1.cfg";
std::string psys_test_file = "data/psystem2.cfg";
#else
//std::string psys_test_file = "../data/psystem1.cfg";
std::string psys_test_file = "../data/psystem4.cfg";
#endif
try {
auto psystem = scene->createNode("particle_system_container", json::parse_from_file(psys_test_file));
//auto particle_cam = std::make_shared<Camera>("particle_cam");
//particle_cam->lookAt(glm::vec3(0.0f, 10.0f, 20.0f), glm::vec3(0.0f), glm::vec3(0.0f,1.0f,0.0f));
//psystem->attachCamera(particle_cam);
//root->attachNode(psystem);
//auto rt = DisplayDevice::RenderTargetInstance(400, 300);
//rt->SetClearColor(0.0f,0.0f,0.0f,0.0f);
//rt->SetDrawRect(rect(400,300,400,300));
//rt->Create();
//psystem->AttachRenderTarget(rt);
//root->AttachObject(rt);
} catch(json::parse_error& e) {
LOG_ERROR("parse error: " << e.what());
throw(e);
}
#if defined(__linux__)
std::string shader_test_file = "data/shaders.cfg";
#else
std::string shader_test_file = "../data/shaders.cfg";
#endif
ShaderProgram::loadFromVariant(json::parse_from_file(shader_test_file));
/* auto tex = std::make_shared<SimpleTextureHolder>("card-back.png");
tex->setDrawRect(rectf(0.0f,0.0f,146.0f,260.0f));
tex->setPosition(146.0f/2.0f, newh-130.0f);
tex->setOrder(10);
root->attachObject(tex);
// test cloning
auto new_tex = std::make_shared<SimpleTextureHolder>(*tex);
new_tex->setOrder(tex->getOrder()+1);
new_tex->setPosition(neww/2.0f, newh/2.0f);
root->attachObject(new_tex);
auto free_surf = Surface::create("editor-tools.png", SurfaceFlags::NO_ALPHA_FILTER);
//auto free_tex = std::make_shared<FreeTextureHolder>("editor-tools.png");
auto free_tex = std::make_shared<FreeTextureHolder>(free_surf);
free_tex->setDrawRect(rectf(0.0f,0.0f,256.0f,256.0f));
free_tex->setPosition(neww - 256.0f, 0.0f);
// Test that cache surfaces and textures is working.
std::vector<std::shared_ptr<FreeTextureHolder>> texture_list;
for(int n = 0; n != 100; ++n) {
auto surf2 = Surface::create("editor-tools.png");
auto tex1 = std::make_shared<FreeTextureHolder>(surf2);
texture_list.emplace_back(tex1);
}
auto fnt_surf = Font::getInstance()->renderText("test", Color::colorOrange(), 20, false, "FreeSans.ttf");
auto text_tex = std::make_shared<FreeTextureHolder>(fnt_surf);
//text_tex->setDrawRect(rect(0, 0, fnt_surf->surfaceWidth(), fnt_surf->surfaceHeight()));
text_tex->setPosition(fnt_surf->surfaceWidth()/2, fnt_surf->surfaceHeight()/2);
//text_tex->setPosition(fnt_surf->surfaceWidth()/2, fnt_surf->surfaceHeight()/2);
//text_tex->setDrawRect(rectf(0.0f, 0.0f, fnt_surf->surfaceWidth(), fnt_surf->surfaceHeight()));
//text_tex->setDrawRect(rectf(0.0f,0.0f,256.0f,256.0f));
//text_tex->setPosition(128.0f,128.0f);
float angle = 1.0f;
float angle_step = 0.5f;
auto canvas = Canvas::getInstance();
canvas->setDimensions(800, static_cast<int>(800/aspect_ratio));
auto canvas_texture = Texture::createTexture("widgets.png");
canvas_texture->setFiltering(-1, Texture::Filtering::LINEAR, Texture::Filtering::LINEAR, Texture::Filtering::NONE);
texture_packing_test();
// render target test.
auto rt1 = RenderTarget::create(300, 300);
{
RenderTarget::RenderScope render_scope(rt1);
//rt1->setClearColor(Color::colorRed());
rt1->setClearColor(Color(0,0,0,0));
rt1->clear();
canvas->setDimensions(300, 300);
std::vector<glm::u8vec4> circle_colors2;
generate_color_wheel(60, &circle_colors2, Color(0,0,0,0), 0.8f, 0.8f);
canvas->drawSolidCircle(point(150, 150), 150.0f, circle_colors2);
canvas->drawSolidRect(rect(50, 50, 200, 200), Color::colorGrey());
canvas->drawSolidCircle(point(150, 150), 20.0f, Color::colorCyan());
rt1->setCentre(Blittable::Centre::TOP_LEFT);
rt1->preRender(main_wnd);
canvas->setDimensions(800, static_cast<int>(800/aspect_ratio));//(neww, newh);
}
auto test1 = std::make_shared<FreeTextureHolder>("cave2.png");
test1->setPosition(0,512);
auto palette_tex = std::make_shared<FreeTextureHolder>("cave2.png");
palette_tex->getTexture()->addPalette(1, Surface::create("cave_pearl.png"));
palette_tex->getTexture()->addPalette(2, Surface::create("cave_mossy.png"));
//auto test1 = std::make_shared<FreeTextureHolder>("sand.png");
//test1->setPosition(0,512);
//auto palette_tex = std::make_shared<FreeTextureHolder>("sand.png");
//palette_tex->getTexture()->addPalette(Surface::create("seaside_stormy.png"));
palette_tex->getTexture()->setPalette(0);
//auto palette_tex = std::make_shared<FreeTextureHolder>("checkerboard1.png");
//palette_tex->getTexture()->addPalette(Surface::create("checkerboard-palette.png"));
palette_tex->setPosition(0, 0);
auto palette_cam = std::make_shared<Camera>("palette_cam", 0, 800, 0, 800);
palette_tex->setCamera(palette_cam);
test1->setCamera(palette_cam);
//auto rt2 = RenderTarget::create(palette_tex->getTexture()->width(), palette_tex->getTexture()->height());
//rt2->setCentre(Blittable::Centre::TOP_LEFT);
// Test code for setting shader uniforms.
auto water_shader = ShaderProgram::getProgram("water_distort");
water_distort_uniforms wd;
uniform_mapping wd_mapping;
UniformBuffer<water_distort_uniforms> water_uniforms("anura_uniforms", wd);
wd_mapping["u_anura_tex_map"] = offsetof(water_distort_uniforms, texture);
wd_mapping["u_anura_mvp_matrix"] = offsetof(water_distort_uniforms, mvp);
wd_mapping["u_anura_cycle"] = offsetof(water_distort_uniforms, cycle);
wd_mapping["u_anura_sprite_area"] = offsetof(water_distort_uniforms, sprite_area);
wd_mapping["u_anura_draw_area"] = offsetof(water_distort_uniforms, draw_area);
wd_mapping["u_intensity"] = offsetof(water_distort_uniforms, intensity);
wd_mapping["u_water_area"] = offsetof(water_distort_uniforms, water_area);
water_uniforms.setMapping(&wd_mapping);
auto water_tex = SimpleTextureHolder("checkerboard1.png");
water_tex.setPosition(neww/2, newh/2);
water_tex.setShader(water_shader);
water_tex.addUniformBuffer(std::move(water_uniforms));
*/
variant_builder tmxvar;
tmxvar.add("tmx", "data/isometric_grass_and_water.tmx");
auto tiled_map = scene->createNode("tiled_map", tmxvar.build());
tiled_map->setPosition(main_wnd->width() / 2, 0);
//tiled::TmxReader tmx_reader(std::dynamic_pointer_cast<tiled::Map>(tiled_map));
//tmx_reader.parseFile("data/isometric_grass_and_water.tmx");
//tmx_reader.parseFile("data/hex-mini.tmx");
//tmx_reader.parseFile("data/sewer_tileset.tmx");
//tmx_reader.parseFile("data/small_isometric_staggered_grass_and_water.tmx");
//root->attachNode(tiled_map);
//auto blue_box = std::make_shared<BlurredBlittable>("blue_box3.png");
//const int bbox_w = blue_box->getTexture()->width();
//const int bbox_h = blue_box->getTexture()->height();
//blue_box->setCentre(Blittable::Centre::TOP_LEFT);
//blue_box->setPosition(0, 0);
//blue_box->setCamera(std::make_shared<Camera>("ortho999", 0, bbox_w, 0, bbox_h));
const int bbox_w = 512;
const int bbox_h = 256;
auto sr = std::make_shared<SimpleRenderable>(rect(24, 24, bbox_w-48, bbox_h-48), Color(0, 0, 0, 255));
CameraPtr box_cam = std::make_shared<Camera>("ortho999", 0, bbox_w, 0, bbox_h);
sr->setCamera(box_cam);
RenderTargetPtr rt = RenderTarget::create(bbox_w, bbox_h);
rt->getTexture()->setFiltering(-1, Texture::Filtering::LINEAR, Texture::Filtering::LINEAR, Texture::Filtering::POINT);
rt->getTexture()->setAddressModes(-1, Texture::AddressMode::CLAMP, Texture::AddressMode::CLAMP);
rt->setCentre(Blittable::Centre::TOP_LEFT);
rt->setClearColor(Color(128,128,128,0));
rt->apply(rect(0, 0, bbox_w, bbox_h));
rt->clear();
//blue_box->preRender(main_wnd);
//main_wnd->render(blue_box.get());
sr->preRender(main_wnd);
main_wnd->render(sr.get());
rt->unapply();
//root->attachObject(rt);
auto shader_blur = ShaderProgram::getProgram("blur2");
rt->setShader(shader_blur);
const int blur_two = shader_blur->getUniform("texel_width_offset");
const int blur_tho = shader_blur->getUniform("texel_height_offset");
const int u_gaussian = shader_blur->getUniform("gaussian");
std::vector<float> gaussian = generate_gaussian(20.0f, 7);//{ 0.05f, 0.09f, 0.12f, 0.15f, 0.16f, 0.15f, 0.12f, 0.09f, 0.05f };
shader_blur->setUniformDrawFunction([blur_two, blur_tho, bbox_h, gaussian, u_gaussian](ShaderProgramPtr shader){
shader->setUniformValue(u_gaussian, &gaussian[0]);
shader->setUniformValue(blur_two, 0.0f);
shader->setUniformValue(blur_tho, 1.0f / (bbox_h - 1.0f));
});
//rt->setOrder(1);
RenderTargetPtr rt2 = RenderTarget::create(bbox_w, bbox_h);
rt2->setCentre(Blittable::Centre::TOP_LEFT);
rt2->setClearColor(Color(0,0,0,0));
{
rt->setCamera(box_cam);
RenderTarget::RenderScope rs(rt2, rect(0, 0, bbox_w, bbox_h));
rt->preRender(main_wnd);
main_wnd->render(rt.get());
rt2->setShader(shader_blur);
const int blur_two = shader_blur->getUniform("texel_width_offset");
const int blur_tho = shader_blur->getUniform("texel_height_offset");
shader_blur->setUniformDrawFunction([blur_two, blur_tho, bbox_w](ShaderProgramPtr shader){
shader->setUniformValue(blur_two, 1.0f / (bbox_w - 1.0f));
shader->setUniformValue(blur_tho, 0.0f);
});
//rt->setOrder(1);
//shader_blur->makeActive();
//shader_blur->setUniformValue(blur_two, 1.0f / (bbox_w - 1.0f));
//shader_blur->setUniformValue(blur_tho, 0.0f);
}
rt2->setOrder(1);
root->attachObject(rt2);
auto sr_blue = std::make_shared<SimpleRenderable>(rect(32, 32, bbox_w-64, bbox_h-64), Color::colorBlue());
sr_blue->setOrder(999);
root->attachObject(sr_blue);
//auto bb2 = std::make_shared<SimpleTextureHolder>("blue_box2.png");
//root->attachObject(bb2);
{
//"deephelm-explorer.png"
//root->attachObject(blue_box);
//auto shader = ShaderProgram::getProgram("blur2");
//int two = shader->getUniform("texel_width_offset");
//int tho = shader->getUniform("texel_height_offset");
//rt->setShader(shader);
//shader->setUniformValue(two, 0.0f);
//shader->setUniformValue(tho, 1.0f/(bbox_h-1));
}
Uint32 last_tick_time = SDL_GetTicks();
SDL_Event e;
bool done = false;
profile::timer timer;
while(!done) {
timer.start();
while(SDL_PollEvent(&e)) {
if(e.type == SDL_KEYUP && e.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
done = true;
} else if(e.type == SDL_KEYDOWN) {
LOG_DEBUG("KEY PRESSED: " << SDL_GetKeyName(e.key.keysym.sym) << " : " << e.key.keysym.sym << " : " << e.key.keysym.scancode);
} else if(e.type == SDL_QUIT) {
done = true;
}
}
main_wnd->setClearColor(KRE::Color(255, 255, 255, 255));
main_wnd->clear(ClearFlags::ALL);
// Called once a cycle before rendering.
Uint32 current_tick_time = SDL_GetTicks();
scene->process((current_tick_time - last_tick_time) / 1000.0f);
last_tick_time = current_tick_time;
/*tex->setRotation(angle, glm::vec3(0.0f,0.0f,1.0f));
new_tex->setRotation(360.0f - angle, glm::vec3(0.0f,0.0f,1.0f));
cairo_canvas->setRotation(angle, glm::vec3(0.0f,0.0f,1.0f));
angle += angle_step;
while(angle >= 360.0f) {
angle -= 360.0f;
}
canvas->blitTexture(rt1->getTexture(), 0.0f, 800-rt1->getTexture()->surfaceWidth(), 0);
{
//RenderTarget::RenderScope render_scope(rt2);
//rt2->setClearColor(Color(0,0,0,0));
//rt2->clear();
palette_tex->preRender(main_wnd);
main_wnd->render(palette_tex.get());
test1->preRender(main_wnd);
main_wnd->render(test1.get());
}
//rt2->preRender(main_wnd);
//canvas->blitTexture(rt2->getTexture(), 0.0f, 0, 0);
static int counter_pal = 0;
static int pal = -1;
if(++counter_pal >= 60*2) {
counter_pal = 0;
if(++pal >= 2) {
pal = -1;
}
palette_tex->getTexture()->setPalette(pal);
}
water_tex.preRender(main_wnd);
main_wnd->render(&water_tex);*/
//tiled_map->draw(main_wnd);
//ModelManager2D mm(400,300);
scene->renderScene(rman);
rman->render(main_wnd);
/*free_tex->preRender(main_wnd);
main_wnd->render(free_tex.get());
text_tex->preRender(main_wnd);
main_wnd->render(text_tex.get());*/
//canvas->drawSolidCircle(point(canvas->width()/2, canvas->height()/2), 50.0f, Color::colorGold());
//canvas->drawHollowCircle(pointf(400.0f, 400.0f), 150.0f, 150.0f-1.0f,Color::colorAqua());
//std::vector<glm::u8vec4> circle_colors;
//generate_color_wheel(60, &circle_colors, Color(0,0,0,0), 0.1f, 0.1f);
//canvas->drawSolidCircle(point(400, 300), 150.0f, circle_colors);
/*{
Canvas::ModelManager mm(0, 0, 10.0f, 1.0f);
canvas->drawSolidRect(rect(600, 400, 100, 100), Color::colorCoral());
{
Canvas::ModelManager mm(500, 300, 20.0f, 3.0f);*/
/*mm.setIdentity();
mm.translate(700, 500);
mm.translate(-200, -200);
mm.rotate(20);
mm.scale(1.5f);
mm.scale(2.0f);*/
/*canvas->drawSolidRect(rect(0, 0, 100, 100), Color::colorChartreuse());
}
}*/
/*canvas->blitTexture(canvas_texture,
rect(3,4,56,22),
0.0f,
//rect(800-56, 0, 56, 22),
rect(0,0,112,44),
Color(1.0f,1.0f,1.0f,0.5f));
canvas->drawSolidRect(rect(100, 100, 100, 100), Color("red"));
canvas->drawHollowRect(rect(125, 125, 50, 50), Color("blue"));
canvas->drawLine(point(95,95), point(205,205), Color("yellow"));
std::vector<glm::vec2> varray;
//varray.emplace_back(400, 400);
//varray.emplace_back(500, 500);
varray.emplace_back(400, 400);
varray.emplace_back(500, 400);
varray.emplace_back(400, 400);
varray.emplace_back(500, 500);
varray.emplace_back(400, 400);
varray.emplace_back(400, 500);
canvas->drawLines(varray, 10.0f, Color("pink"));*/
double t1 = timer.check();
if(t1 < 1.0/50.0) {
// SDL_Delay(Uint32((1.0/50.0-t1)*1000.0));
}
double t = timer.check();
smoothed_time.push_back(t);
cumulative_time += t;
if(++cnt > 10) {
cnt = 0;
//LOG_DEBUG("FPS: " << (smoothed_time.size()/cumulative_time) << ", Time: " << t1*1000.0);
LOG_DEBUG("Draw Time: " << (t * 1000000.0) << " us.");
}
if(smoothed_time.size() > 50) {
cumulative_time -= smoothed_time.front();
smoothed_time.pop_front();
}
main_wnd->swap();
}
return 0;
}