//-----------------------------------------------------------------------
double PUNoise3D::noise(double x, double y, double z)
{
double n = 0;
double freq = _frequency;
double ampl = _amplitude;
for (unsigned short u = 0; u < _octaves; ++u)
{
n += genNoise(x * freq, y * freq, z * freq) * ampl;
freq *= 2;
ampl *= _persistence;
}
return n;
}
void drawNoise(sf::RenderWindow &window, sf::Vector2f** gradients, size_t size, float per){
for(int i = 0; i < 640; ++i){
for(int j = 0; j < 640; ++j){
float k = genNoise(sf::Vector2f(i,j), gradients, size);
//k *= per;
//if(k > 2.01 || k < 0.01) std::cout << k;
//std::cout << k << "\n";
//float k = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
//std::cout << k << std::endl;
pixels[i][j] += k;
}
}
}
void Engine::noisetest()
{
bool quit = false;
bool needsrefresh = false;
bool drawmask = false;
bool drawthreshold = false;
enum _MODES{MODE_SCALE, MODE_PERSISTENCE, MODE_OCTAVES};
int xshift = 0;
int yshift = 0;
int mode = MODE_SCALE;
float scale = 9;
float scale_unit = 0.5;
float octaves = 6;
float octaves_unit = 1.0;
float persistence = 0.7;
float persistence_unit = 0.1;
int width = m_ScreenTilesHeight;
int height = m_ScreenTilesHeight;
//find smallest dimension for mask map
int mdim = width;
int threshold = 60;
float maskintensity = 1.f; // percentage 1.0 = 100%
if(height < width) mdim = height;
sf::Vector2i mcenter(mdim/2, mdim/2);
float centerdistance = getDistance(0,0, mcenter.x, mcenter.y);
//float gradientdist = centerdistance * maskintensity;
float scaler = 255.f / centerdistance;
sf::Vector2u tiledim = m_Curses->getTileSize();
std::vector< std::vector<int> > noisemap = genNoise(width, height, 0,0, persistence, octaves, scale);
std::vector< std::vector<int> > maskmap;
//create mask map
maskmap.resize(mdim);
for(int i = 0; i < mdim; i++)
{
for(int n = 0; n < mdim; n++) maskmap[i].push_back(0);
}
//creat mask map gradient
for(int i = 0; i < mdim; i++)
{
for(int n = 0; n < mdim; n++)
{
//if(getDistance(mcenter.x, mcenter.y, n, i) > gradientdist)
maskmap[i][n] = getDistance(mcenter.x, mcenter.y, n, i) * scaler;
}
}
//draw noise loop
sf::RectangleShape tile(sf::Vector2f(tiledim.x, tiledim.y));
while(!quit)
{
m_Screen->clear();
sf::Event event;
while(m_Screen->pollEvent(event))
{
if(event.type == sf::Event::KeyPressed)
{
if(event.key.code == sf::Keyboard::Escape) quit = true;
else if(event.key.code == sf::Keyboard::Left) xshift--;
else if(event.key.code == sf::Keyboard::Right) xshift++;
else if(event.key.code == sf::Keyboard::Up) yshift--;
else if(event.key.code == sf::Keyboard::Down) yshift++;
else if(event.key.code == sf::Keyboard::S) mode = MODE_SCALE;
else if(event.key.code == sf::Keyboard::P) mode = MODE_PERSISTENCE;
else if(event.key.code == sf::Keyboard::O) mode = MODE_OCTAVES;
else if(event.key.code == sf::Keyboard::M) drawmask = !drawmask;
else if(event.key.code == sf::Keyboard::T) drawthreshold = !drawthreshold;
else if(event.key.code == sf::Keyboard::Add)
{
switch(mode)
{
case MODE_SCALE:
scale += scale_unit;
break;
case MODE_PERSISTENCE:
persistence += persistence_unit;
break;
case MODE_OCTAVES:
octaves += octaves_unit;
break;
}
}
else if(event.key.code == sf::Keyboard::Subtract)
{
switch(mode)
{
case MODE_SCALE:
scale -= scale_unit;
break;
case MODE_PERSISTENCE:
persistence -= persistence_unit;
break;
case MODE_OCTAVES:
octaves -= octaves_unit;
break;
}
}
needsrefresh = true;
}
}
if(needsrefresh)
{
std::cout << "mode = " << mode << std::endl;
std::cout << "x = " << xshift << " y = " << yshift << std::endl;
std::cout << "persistence = " << persistence << std::endl;
std::cout << "scale = " << scale << std::endl;
std::cout << "octaves = " << octaves << std::endl;
std::cout << "\n\n";
noisemap = genNoise(width, height, 0 + xshift, 0 + yshift, persistence, octaves, scale);
needsrefresh = false;
//create mask if necessary
if(drawmask)
{
for(int i = 0; i < mdim; i++)
{
for(int n = 0; n < mdim; n++)
{
noisemap[i][n] -= maskmap[i][n];
//if applying threshold
if(drawthreshold)
{
if(noisemap[i][n] < threshold) noisemap[i][n] = 0;
else noisemap[i][n] = 255;
}
}
}
}
}
//draw
for(int i = 0; i < int(noisemap.size()); i++)
{
for(int n = 0; n < int(noisemap[0].size()); n++)
{
tile.setPosition(n*tiledim.x, i*tiledim.y);
int shade = noisemap[i][n];
if(shade < 0) shade = 0;
tile.setFillColor(sf::Color(shade,shade,shade));
m_Screen->draw(tile);
}
}
//display
m_Screen->display();
}
}
//==============================================================================
void Ssao::initInternal(const ConfigSet& config)
{
m_enabled = config.get("pps.ssao.enabled");
if(!m_enabled)
{
return;
}
m_blurringIterationsCount =
config.get("pps.ssao.blurringIterationsCount");
//
// Init the widths/heights
//
const F32 quality = config.get("pps.ssao.renderingQuality");
m_width = quality * (F32)m_r->getWidth();
alignRoundUp(16, m_width);
m_height = quality * (F32)m_r->getHeight();
alignRoundUp(16, m_height);
//
// create FBOs
//
createFb(m_hblurFb, m_hblurRt);
createFb(m_vblurFb, m_vblurRt);
//
// noise texture
//
GlCommandBufferHandle cmdb;
cmdb.create(&getGlDevice());
GlClientBufferHandle noise;
noise.create(
cmdb, sizeof(Vec3) * NOISE_TEX_SIZE * NOISE_TEX_SIZE, nullptr);
genNoise((Vec3*)noise.getBaseAddress(),
(Vec3*)((U8*)noise.getBaseAddress() + noise.getSize()));
GlTextureHandle::Initializer tinit;
tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
tinit.m_target = GL_TEXTURE_2D;
tinit.m_internalFormat = GL_RGB32F;
tinit.m_format = GL_RGB;
tinit.m_type = GL_FLOAT;
tinit.m_filterType = GlTextureHandle::Filter::NEAREST;
tinit.m_repeat = true;
tinit.m_mipmapsCount = 1;
tinit.m_data[0][0] = noise;
m_noiseTex.create(cmdb, tinit);
//
// Kernel
//
String kernelStr(getAllocator());
Array<Vec3, KERNEL_SIZE> kernel;
genKernel(kernel.begin(), kernel.end());
kernelStr = "vec3[](";
for(U i = 0; i < kernel.size(); i++)
{
String tmp(getAllocator());
tmp.sprintf("vec3(%f, %f, %f) %s",
kernel[i].x(), kernel[i].y(), kernel[i].z(),
(i != kernel.size() - 1) ? ", " : ")");
kernelStr += tmp;
}
//
// Shaders
//
m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER,
sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
String pps(getAllocator());
// main pass prog
pps.sprintf(
"#define NOISE_MAP_SIZE %u\n"
"#define WIDTH %u\n"
"#define HEIGHT %u\n"
"#define KERNEL_SIZE %u\n"
"#define KERNEL_ARRAY %s\n",
NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]);
m_ssaoFrag.loadToCache(&getResourceManager(),
"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_");
m_ssaoPpline = m_r->createDrawQuadProgramPipeline(
m_ssaoFrag->getGlProgram());
// blurring progs
const char* SHADER_FILENAME =
"shaders/VariableSamplingBlurGeneric.frag.glsl";
pps.sprintf(
"#define HPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_height);
m_hblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_hblurPpline = m_r->createDrawQuadProgramPipeline(
m_hblurFrag->getGlProgram());
pps.sprintf(
"#define VPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_width);
m_vblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_vblurPpline = m_r->createDrawQuadProgramPipeline(
m_vblurFrag->getGlProgram());
cmdb.flush();
}
