Commit 51b55711 by Denis Salem

nouveau fichier : PoC/README.md

	nouveau fichier : PoC/VoronoiNoise/Makefile
	nouveau fichier : PoC/VoronoiNoise/README.md
	nouveau fichier : PoC/VoronoiNoise/dsgl.cpp
	nouveau fichier : PoC/VoronoiNoise/dsgl.hpp
	nouveau fichier : PoC/VoronoiNoise/dsglMeshes.cpp
	nouveau fichier : PoC/VoronoiNoise/dsglMeshes.hpp
	nouveau fichier : PoC/VoronoiNoise/fragment.shader
	nouveau fichier : PoC/VoronoiNoise/gl3w.c
	nouveau fichier : PoC/VoronoiNoise/gl3wInstaller.sh
	nouveau fichier : PoC/VoronoiNoise/main.cpp
	nouveau fichier : PoC/VoronoiNoise/vertex.shader
	nouveau fichier : PoC/cubeMapping/Makefile
	nouveau fichier : PoC/cubeMapping/common.cpp
	nouveau fichier : PoC/cubeMapping/common.hpp
	nouveau fichier : PoC/cubeMapping/main.cpp
	nouveau fichier : PoC/cubeMapping/main.cpp.megamoth
	nouveau fichier : PoC/cubeMapping/png.cpp
	nouveau fichier : PoC/cubeMapping/png.hpp
	nouveau fichier : PoC/cubeMapping/realm.cpp
	nouveau fichier : PoC/cubeMapping/realm.hpp
	nouveau fichier : PoC/cubeMapping/realmMinusezed.cpp
	nouveau fichier : PoC/cubeMapping/realmMinusezed.hpp
	nouveau fichier : PoC/cubeMapping/realmMinusigrec.cpp
	nouveau fichier : PoC/cubeMapping/realmMinusigrec.hpp
	nouveau fichier : PoC/cubeMapping/realmMinusix.cpp
	nouveau fichier : PoC/cubeMapping/realmMinusix.hpp
	nouveau fichier : PoC/cubeMapping/realmPlusezed.cpp
	nouveau fichier : PoC/cubeMapping/realmPlusezed.hpp
	nouveau fichier : PoC/cubeMapping/realmPlusigrec.cpp
	nouveau fichier : PoC/cubeMapping/realmPlusigrec.hpp
	nouveau fichier : PoC/cubeMapping/realmPlusix.cpp
	nouveau fichier : PoC/cubeMapping/realmPlusix.hpp
	nouveau fichier : PoC/cubeMapping/stampCollector.cpp
	nouveau fichier : PoC/cubeMapping/stampCollector.hpp
	nouveau fichier : PoC/cubeMapping/unit-test-transitionSpace.svg
	nouveau fichier : PoC/improvedPerlinNoise/Makefile
	nouveau fichier : PoC/improvedPerlinNoise/README.md
	nouveau fichier : PoC/improvedPerlinNoise/main.c
	nouveau fichier : PoC/improvedPerlinNoise/png.c
	nouveau fichier : PoC/improvedPerlinNoise/png.h
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/Makefile
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/README.md
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/common.hpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/gl3wInstaller.sh
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/main.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/shaders/compileShader.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/shaders/fragment.shader
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/shaders/loadAndCompileShaders.hpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/shaders/loadShader.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/shaders/vertex.shader
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/renderSphere.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/renderSphere.hpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/sphere.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/sphere.hpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/vertexFactory.cpp
	nouveau fichier : PoC/proceduralPlanet0x00Sphere/sphere/vertexFactory.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/Makefile
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/README.md
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/common.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/common.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/gl3wInstaller.sh
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/main.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/shaders/compileShader.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/shaders/fragment.shader
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/shaders/loadAndCompileShaders.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/shaders/loadShader.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/shaders/vertex.shader
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/cubeMap.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/cubeMap.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/planetFactory.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/planetFactory.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/renderPlanet.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/renderPlanet.hpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/world.cpp
	nouveau fichier : PoC/proceduralPlanet0x01Displacement/world/world.hpp
	nouveau fichier : PoC/stampNoise/Makefile
	nouveau fichier : PoC/stampNoise/README.md
	nouveau fichier : PoC/stampNoise/main.faster.cpp
	nouveau fichier : PoC/stampNoise/png.cpp
	nouveau fichier : PoC/stampNoise/png.h
	nouveau fichier : PoC/transitionSpace/Makefile
	nouveau fichier : PoC/transitionSpace/dsgl.cpp
	nouveau fichier : PoC/transitionSpace/dsgl.hpp
	nouveau fichier : PoC/transitionSpace/dsglMeshes.cpp
	nouveau fichier : PoC/transitionSpace/dsglMeshes.hpp
	nouveau fichier : PoC/transitionSpace/fragment.shader
	nouveau fichier : PoC/transitionSpace/transitionSpace.cpp
	nouveau fichier : PoC/transitionSpace/vertex.shader
	nouveau fichier : README.md
parents
![](http://universe.tuxfamily.org/public/galerie/logo.svg "")
# Preuves de Concept
Ce répertoire contient des expérimentations ainsi que des démonstrations des algorithmes mit en oeuvre dans UNIVERSE.
default:
g++ main.cpp dsgl.cpp dsglMeshes.cpp gl3w.c -o VoronoiNoise -lglfw -lGL -ldl -D DSGL_DEBUG -D DSGL_GLFW -D DSGL_GL3W -std=c++11 -O2
crack:
g++ -D VORONOI_CRACK main.cpp dsgl.cpp dsglMeshes.cpp gl3w.c -o VoronoiNoise -lglfw -lGL -ldl -D DSGL_DEBUG -D DSGL_GLFW -D DSGL_GL3W -std=c++11 -O2
jelly:
g++ -D VORONOI_JELLY main.cpp dsgl.cpp dsglMeshes.cpp gl3w.c -o VoronoiNoise -lglfw -lGL -ldl -D DSGL_DEBUG -D DSGL_GLFW -D DSGL_GL3W -std=c++11 -O2
# VORONOI NOISE
Ce PoC génére une heightmap construire à l'aide de plusieurs diagrammes de Voronoï.
La surface ainsi généré est affiché dans une fenêtre OpenGL.
## Prérequis
Pour compiler et lancer ce PoC vous devez installer [glfw](http://www.glfw.org/).
Le mieux est d'installer cette librairie depuis les dépots
officiels de votre distribution.
Votre carte graphique doit également pouvoir supporter
OpenGL 3.3 et GLSL 3.3 au minimum. Pour vous en assurer
rien de plus simple! Dans un terminal tapez
$ glxinfo | grep "version"
Normalement ce devrait être le cas, mais assurez vous d'avoir
la suite d'utilitaires Mesa installé. Cette suite contient
notamment les commandes glxinfo et glxgears.
Inutile de préciser qu'il faut idéalement que vos pilotes
soient à jour.
## Compilation
Avant de compiler il faut télécharger et installer [gl3w](http://github.com/skaslev/gl3w), un chargeur d'extentions OpenGL.
Le PoC est fournit avec un installateur qui va cloner le
dépot et créer et installer les fichiers nécessaires. Pour
ça vous aurez besoin de python version 2.6 au minimum.
Avec les priviléges root, dans un terminal et dans le répertoire du PoC
$ ./gl3wInstaller.sh
Les en-tête de gl3w seront installés dans votre système
/usr/include/GL/gl3w.h
/usr/include/GL/glcorearb.h
Un fichier source gl3w.c est également ajouté aux sources
du PoC. Pour compiler le PoC, enfin, tapez dans un terminal
en étant un utilisateur normal.
$ make
le fichier exécutable VoronoiNoise est maintenant crée :)
Il y a deux options de compilation possible:
$ make crack
et
$ mage jelly
Chacune des options produit un exécutable qui génère une heightmap d'apparence très différente.
## Nettoyage
Pour enlever gl3w supprimez manuellement les deux fichiers
/usr/include/GL/gl3w.h
/usr/include/GL/glcorearb.h
## Usage
Dans un terminal tapez
$ ./VoronoiNoise
#include <cstdio>
#include <ctime>
#include <cstring>
#include <memory>
#include <iostream>
#include <fstream>
#if defined(DSGL_GL3W)
#include <GL/gl3w.h>
#else
/* INCLUDE ALTERNATIVE LIBRARY HERE */
#endif
#if defined(DSGL_GLFW)
#include <GLFW/glfw3.h>
#endif
#ifndef DSGL_CORE_INCLUDED
#define DSGL_CORE_INCLUDED
#define DSGL_TRACE { std::cerr << "glError: " << glGetError() << ",\t" << __FILE__ << ", " << __LINE__ << "\n"; }
#define DSGL_VERSION "0.0.0"
#define DSGL_CLEAN_SHADERS_ONLY true
#define DSGL_CLEAN_ALL false
#define DSGL_FBO_NO_DEPTH false
#define DSGL_FBO_DEPTH true
#define DSGL_READ_FROM_STRING 1
#define DSGL_READ_FROM_FILE 0
#define DSGL_SHADER_ERROR_LENGTH 2048
#define DSGL_END_NICELY 0
#define DSGL_GLFW_INIT_FAILED -1
#define DSGL_WINDOW_POINTER_NULL -2
#define DSGL_GL3W_INIT_FAILED -3
#define DSGL_CANNOT_READ_SHADER_SOURCE -4
#define DSGL_ERROR_AT_SHDR_COMPILE_TIME -5
#define DSGL_CANNOT_CREATE_SHADER -6
#define DSGL_CANNOT_CREATE_PROGRAM -7
#define DSGL_ID_DOESNT_NAME_A_PROGRAM -8
#define DSGL_VAO_DOESNT_EXIST -9
#define DSGL_VBO_DOESNT_EXIST -10
#define DSGL_IBO_DOESNT_EXIST -11
#define DSGL_CANNOT_CREATE_VAO -12
#define DSGL_CANNOT_CREATE_VBO -13
#define DSGL_CANNOT_CREATE_IBO -14
#define DSGL_VBO_IS_NULL -15
#define DSGL_IBO_IS_NULL -16
#define DSGL_INSTANCES_IS_NULL -17
#define DSGL_INSTANCES_DOESNT_EXIST -18
#define DSGL_UNIFORM_LOCATION_DOESNT_EXISTS -19
#define DSGL_CANNOT_CREATE_FBO -20
#define DSGL_CANNOT_CREATE_TEXTURE -21
#define DSGL_CANNOT_CREATE_DEPTH_BUFFER -22
#define DSGL_FBO_DOESNT_EXIST -23
#define DSGL_IMAGES_CANNOT_OPEN_IMAGE_FILE -24
#define DSGL_IMAGES_INPUT_IMAGE_CORRUPTED -25
#define DSGL_IMAGES_UNSUPPORTED_BIT_DEPTH -26
#define DSGL_IMAGES_UNSUPPORTED_COLOR_TYPE -27
#define DSGL_IMAGES_UNSUPPORTED_PIXEL_FORMAT -28
#define DSGL_IMAGES_ERROR_WHILE_READING -29
#define DSGL_CANNOT_READ_FILE -30
#define DSGL_CANNOT_CREATE_TEXTURE_BUFFER -31
#define DSGL_MSG_GLFW_INIT_FAILED "DSGL: GLFW initialization failed."
#define DSGL_MSG_GL3W_INIT_FAILED "DSGL: GL3W initialization failed."
#define DSGL_MSG_WINDOW_POINTER_NULL "DSGL: Window pointer is null."
#define DSGL_MSG_VBO_IS_NULL "DSGL: Vertex Buffer name is null."
#define DSGL_MSG_UNIFORM_LOCATION_DOESNT_EXISTS "DSGL: Uniform location doesn't exist."
#define DSGL_MSG_CANNOT_CREATE_FBO "DSGL: Cannot create frame buffer object."
#define DSGL_MSG_CANNOT_CREATE_VBO "DSGL: VBO creation failed."
#define DSGL_MSG_CANNOT_CREATE_SHADER "DSGL: Cannot create shader."
#define DSGL_MSG_CANNOT_CREATE_DEPTH_BUFFER "DSGL: Cannot create depth buffer."
#define DSGL_MSG_ERROR_AT_SHDR_COMPILE_TIME "DSGL: Cannot compile shader."
#define DSGL_MSG_CANNOT_CREATE_TEXTURE "DSGL: Cannot create texture."
#define DSGL_MSG_VBO_DOESNT_EXIST "DSGL: VBO doesn't exist."
#define DSGL_MSG_ID_DOESNT_NAME_A_PROGRAM "DSGL: ID doesn't name a program."
#define DSGL_MSG_FBO_DOESNT_EXIST "DSGL: FBO doesn't exist."
#define DSGL_IMAGES_MSG_CANNOT_OPEN_IMAGE_FILE "DSGL: Cannot open image file."
#define DSGL_IMAGES_MSG_INPUT_IMAGE_CORRUPTED "DSGL: Input image is corrupted"
#define DSGL_IMAGES_MSG_UNSUPPORTED_BIT_DEPTH "DSGL: Unsupported Bit depth."
#define DSGL_IMAGES_MSG_UNSUPPORTED_COLOR_TYPE "DSGL: Unsupported Color Type."
#define DSGL_IMAGES_MSG_UNSUPPORTED_PIXEL_FORMAT "DSGL: Unsupported Pixel Format."
#define DSGL_IMAGES_MSG_ERROR_WHILE_READING "DSGL: Error while reading input image."
#define DSGL_MSG_CANNOT_READ_FILE "DSGL: Cannot read file."
#define DSGL_MSG_CANNOT_CREATE_TEXTURE_BUFFER "DSGL: Cannot create texture buffer."
namespace DSGL {
void PrintNicelyWorkGroupsCapabilities();
struct Exception {
Exception(int code, const char * msg);
Exception(int code, const char * msg, const char * ressource);
int code;
std::string msg;
std::string ressource;
};
struct Context {
Context(const char * name, int width, int height, int glMajorVersion, int glMinorVersion);
Context(int width, int height, int glMajorVersion, int glMinorVersion);
~Context();
void InitSimpleWindow();
int width;
int height;
int glMajorVersion;
int glMinorVersion;
std::string name;
#if defined(DSGL_GLFW)
GLFWwindow * window;
#else
void * window;
#endif
};
struct FrameBufferObject {
FrameBufferObject(GLuint width, GLuint height);
FrameBufferObject(GLuint width, GLuint height, bool option, GLenum buffertype);
void DrawBind();
void Bind();
static void DrawUnbind();
static void Unbind();
GLuint ID;
GLuint textureID;
GLuint depthBufferID;
GLuint width;
GLuint height;
};
struct VertexBufferObject {
VertexBufferObject(GLsizeiptr size, const GLvoid * data);
VertexBufferObject(GLsizeiptr size, const GLvoid * data, GLenum usage);
~VertexBufferObject();
void Bind();
static void Unbind();
GLuint ID;
};
struct TextureBuffer {
TextureBuffer();
TextureBuffer(GLsizeiptr size, const GLvoid * data, GLenum usage);
TextureBuffer(GLsizeiptr size, const GLvoid * data, GLenum usage, GLenum gpuSideFormat);
~TextureBuffer();
void Bind();
void Bind(GLuint unit);
void Unbind();
GLsizeiptr size;
GLenum usage;
GLint gpuSideFormat;
GLuint textureID;
GLuint bufferID;
};
struct Texture {
Texture(GLenum target);
Texture(GLenum target, GLuint width, GLuint height, GLvoid * rawData);
Texture(GLenum target, GLuint width, GLuint height, GLvoid * rawData, GLenum cpuSideFormat, GLenum cpuSidetype);
Texture(GLenum target, GLuint width, GLuint height, GLvoid * rawData, GLenum cpuSideFormat, GLenum cpuSidetype, GLint gpuSideFormat);
~Texture();
void Bind();
void Bind(GLuint unit);
void Unbind();
GLuint ID;
int width;
int height;
GLenum target;
GLint gpuSideFormat;
GLenum cpuSideFormat;
GLenum cpuSideType;
GLvoid * rawData;
};
struct VertexArrayObject {
VertexArrayObject();
VertexArrayObject(GLuint IBO, GLuint VBO);
VertexArrayObject(GLuint IBO, GLuint VBO, GLuint instances);
~VertexArrayObject();
void Bind();
void SetVertex(GLuint vertex);
void SetElements(GLuint elements);
void SetInstances(GLuint instance);
void AttribPointer(GLuint index,GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
void AttribPointer(GLuint buffer, GLuint index,GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
void InstancesAttribPointer(GLuint index,GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer, GLuint divisor);
GLuint ID;
GLuint IBO;
GLuint VBO;
GLuint instances;
};
struct Elements {
Elements(GLsizeiptr size,const GLvoid * data, GLenum usage);
Elements(GLsizeiptr size,const GLvoid * data);
~Elements();
void Bind();
GLuint ID;
};
class Shader {
public:
Shader(const char * inputShader, GLuint shaderType, int option);
Shader(const char * inputShader, GLuint shaderType);
~Shader();
void ReadFromFile(const char * shaderFilename);
int GetFileSize(const char * inputFilePath);
std::string shaderSource;
int shaderSourceSize;
GLuint ID;
GLint Result;
private:
char * shaderErrorMessages = NULL;
};
class ShaderProgram {
public:
void Uniformui(const char * uniformName, GLuint v0);
void Uniformf(const char * uniformName, GLfloat v0);
void Uniformf(const char * uniformName, GLfloat v0, GLfloat v1);
void Uniformf(const char * uniformName, GLfloat v0, GLfloat v1, GLfloat v2);
void Uniform4fv(const char * uniformName, int size, GLfloat * array);
void Uniform3fv(const char * uniformName, int size, GLfloat * array);
virtual void Use() = 0;
GLuint ID;
GLint Result;
char * programErrorMessages = NULL;
};
class PipelineProgram : public ShaderProgram {
public:
PipelineProgram(const char * inputVertexShader, const char * inputFragmentShader);
PipelineProgram(
const char * inputVertexShader,
const char * inputTesselationControlShader,
const char * inputTesselationEvaluationShader,
const char * inputGeometryShader,
const char * inputFragmentShader
);
~PipelineProgram();
void Use();
void Clean(bool shadersOnly);
std::shared_ptr<Shader> vertex;
std::shared_ptr<Shader> tesselationControl;
std::shared_ptr<Shader> tesselationEvaluation;
std::shared_ptr<Shader> geometry;
std::shared_ptr<Shader> fragment;
};
class ComputeProgram : public ShaderProgram {
public:
ComputeProgram(const char * inputShader);
ComputeProgram(const char * inputShader, int option);
~ComputeProgram();
void Use();
void Use(GLuint x, GLuint y, GLuint z);
std::shared_ptr<Shader> compute;
};
}
#endif
#include "dsglMeshes.hpp"
namespace DSGL {
namespace Meshes {
Triangle::Triangle() : Triangle(.0,.0,.0) {}
Triangle::Triangle(GLfloat x, GLfloat y, GLfloat z) {
this->vertex[0] = x+0.0;
this->vertex[1] = y+1.0;
this->vertex[2] = z+0.0;
this->vertex[3] = x-1.0;
this->vertex[4] = y-1.0;
this->vertex[5] = z+0.0;
this->vertex[6] = x+1.0;
this->vertex[7] = y-1.0;
this->vertex[8] = z+0.0;
this->index[0] = 0;
this->index[1] = 1;
this->index[2] = 2;
}
Quad::Quad() : Quad(.0,.0,.0) {}
Quad::Quad(GLfloat x, GLfloat y, GLfloat z) {
this->vertex[0] = x-1.0;
this->vertex[1] = y+1.0;
this->vertex[2] = z+0.0;
this->vertex[3] = x-1.0;
this->vertex[4] = y-1.0;
this->vertex[5] = z+0.0;
this->vertex[6] = x+1.0;
this->vertex[7] = y+1.0;
this->vertex[8] = z+0.0;
this->vertex[9] = x+1.0;
this->vertex[10] = y-1.0;
this->vertex[11] = z+0.0;
this->index[0] = 0;
this->index[1] = 1;
this->index[2] = 2;
this->index[3] = 3;
this->texCoords[0] = 0.0f;
this->texCoords[1] = 0.0f;
this->texCoords[2] = 0.0f;
this->texCoords[3] = 1.0f;
this->texCoords[4] = 1.0f;
this->texCoords[5] = 0.0f;
this->texCoords[6] = 1.0f;
this->texCoords[7] = 1.0f;
}
}
}
#if defined(DSGL_GL3W)
#include <GL/gl3w.h>
#else
/* INCLUDE ALTERNATIVE LIBRARY HERE */
#endif
#ifndef DSGL_MESHES_INCLUDED
#define DSGL_MESHES_INCLUDED
namespace DSGL {
namespace Meshes {
struct Triangle {
Triangle();
Triangle(GLfloat x, GLfloat y, GLfloat z);
GLfloat vertex[9];
GLuint index[3];
};
struct Quad {
Quad();
Quad(GLfloat x, GLfloat y, GLfloat z);
GLfloat vertex[12];
GLfloat texCoords[8];
GLuint index[4];
};
}
}
#endif
#version 330
in vec2 TexCoord;
out vec4 color;
uniform sampler2D currentTexture;
void main() {
color = vec4(texture(currentTexture, TexCoord).x);
}
This source diff could not be displayed because it is too large. You can view the blob instead.
#! /bin/bash
echo "Installing gl3w..."
if type "git" &> /dev/null; then
git clone "http://github.com/skaslev/gl3w"
cd gl3w/
./gl3w_gen.py
cp -v include/GL/* /usr/include/GL
cp -v src/gl3w.c ..
chmod +w ../gl3w.c
cd ..
rm -rf gl3w/
else
echo "git not found..."
echo "Aborting..."
fi
#include <iostream>
#include <random>
#include <chrono>
#include <functional>
#include <cmath>
#include "dsgl.hpp"
#include "dsglMeshes.hpp"
#if defined(WIN32) || defined(_WIN32)
#include <Windows.h>
#else
#include <unistd.h>
#endif
const int limit = 4096 / sizeof(unsigned int) - 1;
const int scale = 512;
const int modScale = 511;
const int depth = 4;
int seedsNumber = 16;
int seedOffset = 0;
GLfloat VoronoiCell(int x, int y, unsigned char * seeds) {
GLfloat tmp, dx, dy;
GLfloat minDist = 16581375.0;
for (int i = 0; i < seedsNumber; i++) {
dx = (x - (((int*)seeds)[(seedOffset+i*2) & limit ] & modScale));
dy = (y - (((int*)seeds)[(seedOffset+i*2+1) & limit] & modScale));
tmp = dx*dx+dy*dy;
if (tmp < minDist) {
minDist = tmp;
}
}
return sqrt(minDist);
}
GLfloat VoronoiCrack(int x, int y, unsigned char * seeds) {
GLfloat tmp, dx, dy;
GLfloat minDist1 = 16581375.0;
GLfloat minDist2 = 16581375.0;
for (int i = 0; i < seedsNumber; i++) {
dx = (x - (((int*)seeds)[(seedOffset+i*2) & limit ] & modScale));
dy = (y - (((int*)seeds)[(seedOffset+i*2+1) & limit] & modScale));
tmp = dx*dx+dy*dy;
if (tmp < minDist2) {
if (tmp < minDist1) {
minDist2 = minDist1;
minDist1 = tmp;
}
else {
minDist2 = tmp;
}
}
}
return - sqrt(minDist2) + sqrt(minDist1);
}
GLfloat VoronoiJelly(int x, int y, unsigned char * seeds) {
GLfloat tmp, dx, dy;
GLfloat minDist1 = 16581375.0;
GLfloat minDist2 = 16581375.0;
for (int i = 0; i < seedsNumber; i++) {
dx = (x - (((int*)seeds)[(seedOffset+i*2) & limit ] & modScale));
dy = (y - (((int*)seeds)[(seedOffset+i*2+1) & limit] & modScale));
tmp = dx*dx+dy*dy;
if (tmp < minDist2) {
if (tmp < minDist1) {
minDist2 = minDist1;
minDist1 = tmp;
}
else {
minDist2 = tmp;
}
}
}
return -sqrt(minDist2) * sqrt(minDist1);
}
int main(int argc, char ** argv) {
GLfloat * surface = new GLfloat[scale*scale]();
auto time = std::chrono::high_resolution_clock::now();
auto count = time.time_since_epoch().count();
std::default_random_engine generator;
std::uniform_int_distribution<int> distribution(0,4294967295);
generator.seed(std::default_random_engine::result_type(count));
auto dice = std::bind ( distribution, generator );
unsigned char * seeds = new unsigned char[4096];
for (int i = 0; i < limit; i++) {
((unsigned int*) seeds)[i] = (unsigned int) dice();
}
GLfloat min = 16581375.0;
GLfloat max = -16581375.0;
std::chrono::high_resolution_clock::time_point t1,t2;
t1 = std::chrono::high_resolution_clock::now();
GLfloat persistence;
for (int octave = 1; octave <= depth; octave++) {
seedsNumber *= 4;
persistence = (1.0 / (GLfloat) (1 << octave));
for (int x = 0; x < scale; x++) {
for (int y = 0; y < scale; y++) {
#ifdef VORONOI_CRACK
surface[x + y * scale] += persistence * VoronoiCrack(x, y, seeds);
#else
#ifdef VORONOI_JELLY
surface[x + y * scale] += persistence * VoronoiJelly(x, y, seeds);
#else
surface[x + y * scale] += persistence * VoronoiCell(x, y, seeds);
#endif
#endif
if(surface[x + y * scale] < min) {
min = surface[x + y * scale];
}
if(surface[x + y * scale] > max) {
max = surface[x + y * scale];
}
}
}
seedOffset += seedsNumber;
}
t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();
std::cout << "Surface duration: " << float(duration) / 1000000.0 << "s\n";
GLfloat depth;
for (int x = 0; x < scale; x++) {
for (int y = 0; y < scale; y++) {
depth = 1.0 - ((surface[x+scale*y] - min) / (max - min));
surface[x+scale*y] = depth;
}
}
/* OpenGL context */
DSGL::Context context("VORONOÏ NOISE WITH DSGL", 512, 512, 4, 4);
context.InitSimpleWindow();
/* Regular and compute shaders */
DSGL::PipelineProgram pipelineProgram("vertex.shader","fragment.shader");
/* Create buffers */
DSGL::Meshes::Quad quad;
DSGL::Texture texture(GL_TEXTURE_2D, 512,512, surface, GL_RED, GL_FLOAT, GL_RGBA32F);
DSGL::Elements elements(4 * sizeof(GLuint), quad.index);
DSGL::VertexBufferObject VBO(sizeof(GLfloat) * 12, quad.vertex);
DSGL::VertexBufferObject texCoords(sizeof(GLfloat) * 8, quad.texCoords);
DSGL::VertexArrayObject VAO(elements.ID, VBO.ID);