bool GLSLProgram::load(const std::string& vertFilePath, const std::string& fragFilePath) {
// Have OpenGL create the shaders
_vertexShader = glCreateShader(GL_VERTEX_SHADER);
if (_vertexShader == 0) {
Error::getInstance().fail(ErrorCodes::FAILED_TO_CREATE_SHADER);
return false;
}
_fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
if (_fragmentShader == 0) {
Error::getInstance().fail(ErrorCodes::FAILED_TO_CREATE_SHADER);
return false;
}
std::vector<unsigned char> vertFileContents;
std::vector<unsigned char> fragFileContents;
IOManager::getInstance().readTextFileToBuffer(vertFilePath, vertFileContents);
IOManager::getInstance().readTextFileToBuffer(fragFilePath, fragFileContents);
loadShaderSource(_vertexShader, (const char*)&(vertFileContents[0]));
loadShaderSource(_fragmentShader, (const char*)&(fragFileContents[0]));
if (compile()) {
addAttribute("vertexPos");
addAttribute("vertexColor");
addAttribute("vertexUV");
return link();
} else {
return false;
}
}
GLuint createAndLoadFragmentShaderAll()
{
const GLuint shader_handle = createFragmentShader();
if (shader_handle == 0){ return 0; }
{
const char* shader_source_file_path_list[] = {
SHADER_SOURCE_BASE_PATH "circle.frag"
};
const int shader_source_file_num = countof(shader_source_file_path_list);
const GLchar** shader_source_file_list = loadShaderSource(shader_source_file_num, shader_source_file_path_list);
if (shader_source_file_list)
{
glShaderSource(shader_handle, shader_source_file_num, shader_source_file_list, NULL);
freeShaderSource(shader_source_file_num, shader_source_file_list);
shader_source_file_list = NULL;
}
}
{
glCompileShader(shader_handle);
{
const GLint shader_compile_result = getShaderResult(shader_handle, GL_COMPILE_STATUS);
if (shader_compile_result == GL_FALSE){ return 0; }
}
}
return shader_handle;
}
// loads a source file and directly compiles it to a shader of 'shaderType' //
GLuint loadShaderFile(const char* fileName, GLenum shaderType) {
GLuint shader = glCreateShader(shaderType);
// check if operation failed //
if (shader == 0) {
std::cout << "(loadShaderFile) - Could not create shader." << std::endl;
return 0;
}
// load source code from file //
const char* shaderSrc = loadShaderSource(fileName);
if (shaderSrc == NULL) return 0;
// pass source code to new shader object //
glShaderSource(shader, 1, (const char**)&shaderSrc, NULL);
delete[] shaderSrc;
// compile shader //
glCompileShader(shader);
// log compile messages, if any //
int logMaxLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logMaxLength);
char log[logMaxLength];
int logLength = 0;
glGetShaderInfoLog(shader, logMaxLength, &logLength, log);
if (logLength > 0) {
std::cout << "(loadShaderFile) - Compiler log:\n------------------\n" << log << "\n------------------" << std::endl;
}
// return compiled shader (may have compiled WITH errors) //
return shader;
}
Shader::Shader(const char* vertPath, const char* fragPath)
{
error = false;
vertShader = glCreateShader(GL_VERTEX_SHADER);
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
unsigned long vertSourceLength = 0;
GLchar * vertShaderSource[1];
int vertSourceFetchErr = loadShaderSource(vertPath, vertShaderSource, vertSourceLength);
unsigned long fragSourceLength;
GLchar * fragShaderSource[1];
int fragSourceFetchErr = loadShaderSource(fragPath, fragShaderSource, fragSourceLength);
error = (vertSourceFetchErr != 0) || (fragSourceFetchErr != 0);
if (error)
{
errorLog = "ERROR while reading shader files";
return;
}
glShaderSource(vertShader, 1, vertShaderSource, NULL);
glShaderSource(fragShader, 1, fragShaderSource, NULL);
glCompileShader(vertShader);
error = !testCompileStatus(vertShader);
if (error) return;
glCompileShader(fragShader);
error = !testCompileStatus(fragShader);
if (error) return;
program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
error = !testLinkStatus(program);
if (error)return;
glDetachShader(program, vertShader);
glDetachShader(program, fragShader);
glDeleteShader(vertShader);
glDeleteShader(fragShader);
}
TEST(ShaderLib,failLink)
{
constexpr auto *shaderName="Test5";
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="Test5Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX );
shader->loadShaderSource(Vertex,"files/vertLinkErr.glsl");
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="Test5Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT );
shader->loadShaderSource(Fragment,"files/fragLinkErr.glsl");
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_FALSE(shader->linkProgramObject(shaderName))<<"This should not link as in and out don't match";
}
TEST(ShaderLib,loadPartsFailFragment)
{
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram("Test4",ngl::ErrorExit::OFF);
constexpr auto Fragment="Test4Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Fragment,"files/fragErr.glsl");
EXPECT_FALSE(shader->compileShader(Fragment))<<"error compiling vert shader";
}
bool ShaderProgram::addFragmentShader(aftfs::FileSystem &fileSystem, const std::string &path)
{
std::string source = loadShaderSource(fileSystem, path);
if (source.empty())
{
return false;
}
return createShader(m_attachedShaders, source, GL_FRAGMENT_SHADER, m_program);
}
ShaderObject::ShaderObject(char *vertexfile, char *fragmentfile)
{
printf("%s %s\n", vertexfile, fragmentfile);
program = glCreateProgram();
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
char** vertexShaderSource = loadShaderSource(vertexfile);
char** fragmentShaderSource = loadShaderSource(fragmentfile);
glShaderSource(vertexShader, 1, vertexShaderSource, NULL);
glShaderSource(fragmentShader, 1, fragmentShaderSource, NULL);
freeShaderSource(vertexShaderSource);
freeShaderSource(fragmentShaderSource);
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
shaderLog(vertexShader);
shaderLog(fragmentShader);
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
}
TEST(ShaderLib,loadPartsFailVertex)
{
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram("Test3",ngl::ErrorExit::OFF);
constexpr auto Vertex="Test3Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Vertex,"files/vertErr.glsl");
EXPECT_FALSE(shader->compileShader(Vertex))<<"error compiling vert shader";
}
/**
*
* @param vert Path to vertex shader
* @param frag Path to fragment shader
*/
ShaderPtr loadShader( QString vert, QString frag )
{
qDebug() << "loadShader("<< vert << "|" << frag << ")";
ShaderPtr program = std::make_shared<Shader>();
QByteArray defs = "#define USE_DESKTOP_BLEND "
#ifdef USE_DESKTOP_BLEND
"1"
#else
"0"
#endif
;
if( !program->addShaderFromSourceCode( QGLShader::Vertex,
loadShaderSource(vert, defs) ) )
{
qWarning() << "Failed to load vertex shader (" << vert << ")\n"
<< program->log();
return ShaderPtr();
}
if( !program->addShaderFromSourceCode( QGLShader::Fragment,
loadShaderSource(frag, defs) ) )
{
qWarning() << "Failed to load fragment shader (" << frag << ")\n"
<< program->log();
return ShaderPtr();
}
if( !program->link() )
{
qWarning() << "Failed to link shader (" << vert << "|" << frag << ")\n"
<< program->log();
return ShaderPtr();
}
return program;
}
bool Shader::loadFromFile(const Shader::Type type, const std::string& filename)
{
if(p_shader_id != 0)
{
glDeleteShader(p_shader_id);
}
std::string shader_source;
if(!loadShaderSource(filename, shader_source))
{
return false;
}
loadFromSource(type, shader_source);
return true;
}
void loadShader(Midori::Shader* shader, const std::string& vertex, const std::string& fragment)
{
shader->vertexShader = glCreateShader(GL_VERTEX_SHADER);
shader->fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
shader->id = glCreateProgram();
const char* vertexShaderSource = loadShaderSource(vertex.c_str());
const char* fragmentShaderSource = loadShaderSource(fragment.c_str());
if(vertexShaderSource == nullptr || fragmentShaderSource == nullptr)
cerr << " Shader loading error " << vertex << " " << fragment << cerr;
glShaderSource(shader->vertexShader,1,&vertexShaderSource,0);
glShaderSource(shader->fragmentShader,1,&fragmentShaderSource,0);
glCompileShader(shader->vertexShader);
glCompileShader(shader->fragmentShader);
glAttachShader(shader->id,shader->vertexShader);
glAttachShader(shader->id,shader->fragmentShader);
glLinkProgram(shader->id);
delete vertexShaderSource;
delete fragmentShaderSource;
}
TEST(ShaderLib,editShader)
{
auto shader = ngl::ShaderLib::instance();
auto *shaderName="Edit";
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="EditVert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Vertex,"files/EditVert.glsl");
EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe ";
EXPECT_TRUE(shader->editShader(Vertex,"@numLights","2"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="EditFrag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT,ngl::ErrorExit::OFF );
shader->loadShaderSource(Fragment,"files/EditFrag.glsl");
EXPECT_TRUE(shader->editShader(Fragment,"@numLights","2"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_TRUE(shader->linkProgramObject(shaderName))<<"First Link";
(*shader)[shaderName]->use();
EXPECT_TRUE(shader->getCurrentShaderName()==shaderName);
// Now re-edit
shader->resetEdits(Vertex);
shader->resetEdits(Fragment);
EXPECT_TRUE(shader->editShader(Vertex,"@numLights","5"))<<"edit shader 2nd";
EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe 2nd";
EXPECT_TRUE(shader->editShader(Fragment,"@numLights","5"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
EXPECT_TRUE(shader->linkProgramObject(shaderName));
}
TEST(ShaderLib,loadParts)
{
auto shader = ngl::ShaderLib::instance();
auto *shaderName="Test2";
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="Test2Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX );
shader->loadShaderSource(Vertex,"files/vert.glsl");
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="Test2Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT );
shader->loadShaderSource(Fragment,"files/frag.glsl");
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_TRUE(shader->linkProgramObject(shaderName));
(*shader)[shaderName]->use();
EXPECT_TRUE(shader->getCurrentShaderName()==shaderName);
}
void initShader(){
axesShader = glCreateShader(GL_VERTEX_SHADER);
const std::string shaderfile = "cluster.vert";
std::string shadersource;
std::cout<<"Reading shader source from file:"<<shaderfile<<std::endl;
if ( !loadShaderSource(shaderfile, shadersource) )
{
std::cout<<"Failed to load shader:"<<shaderfile<<" quiting!"<<std::endl;
exit(1);
}
std::cout<<"Loaded Shader! Its length is:" << (int)shadersource.size() <<std::endl;
GLchar *source = new GLchar[5000];
memcpy(source, shadersource.c_str(), shadersource.size());
int len = strlen(source);
// std::cout<<"SHADER SOURCE:\n"<<source<<std::endl;
glShaderSource(axesShader, 1, (const GLchar**) &source, (const GLint *) &len);
checkGlError();
std::cout<<"Compiling shader!"<<std::endl;
glCompileShader(axesShader);
checkGlError();
std::cout<<"Creating glProgram"<<std::endl;
shaderProg = glCreateProgram();
std::cout<<"\t created with handle:"<<shaderProg<<std::endl;
checkGlError();
std::cout<<"\tAttaching Shader"<<std::endl;
glAttachShader(shaderProg, axesShader);
checkGlError();
std::cout<<"Linking Shader Program"<<std::endl;
glLinkProgram(shaderProg);
checkGlError();
std::cout<<"DONE!"<<std::endl;
}
void SpikeViewer::loadAndCompileShader() {
GLuint axesShader = glCreateShader(GL_VERTEX_SHADER);
const std::string shaderfile = "cluster.vert";
std::string shadersource;
std::cout<<"Reading shader source from file:"<<shaderfile<<std::endl;
if ( !loadShaderSource(shaderfile, shadersource) )
{
std::cout<<"Failed to load shader:"<<shaderfile<<" quiting!"<<std::endl;
exit(1);
}
const int MAX_SHADER_LEN = 10000;
if (shadersource.size()>MAX_SHADER_LEN)
{
std::cout<<"Shader is too long it cannot be greater than"<<MAX_SHADER_LEN<<std::endl;
exit()
}
// loads a source file and directly compiles it to a shader of 'shaderType' //
GLuint loadShaderFile(const char* fileName, GLenum shaderType) {
GLuint shader = glCreateShader(shaderType);
// check if operation failed //
if (shader == 0) {
std::cout << "(loadShaderFile) - Could not create shader." << std::endl;
return 0;
}
// load source code from file //
const char* shaderSrc = loadShaderSource(fileName);
if (shaderSrc == NULL) return 0;
// pass source code to new shader object //
glShaderSource(shader, 1, (const char**)&shaderSrc, NULL);
delete[] shaderSrc;
// compile shader //
glCompileShader(shader);
// log compile messages, if any //
// return compiled shader (may have compiled WITH errors) //
return shader;
}
void Effect::loadShader(const QGLContext* context)
{
m_pixelShader = new QGLShader(QGLShader::Fragment);
QString source = loadShaderSource();
if(!m_pixelShader->compileSourceCode(source))
{
QMessageBox message;
message.setText("Failed to compile shader.");
message.setInformativeText("Log:\n" + m_pixelShader->log() + "\n\nSource:\n" + source);
message.exec();
}
m_program = new QGLShaderProgram(context);
m_program->addShader(m_pixelShader);
if(!m_program->link())
{
qDebug("Failed to link program.");
//qDebug((const char*)m_program->log().constData());
QString log = m_program->log();
if(log.isNull())
{
QMessageBox isNullMsg;
isNullMsg.setText("Log is null!");
isNullMsg.exec();
}
QMessageBox message;
message.setText("Failed to link shader program.\nLog:\n" + log);
message.exec();
}
// m_loaded = true;
}
GLuint Shader::loadShaderCode(const char* fileName, GLenum shaderType) {
GLuint shader = glCreateShader(shaderType);
if (shader == 0) {
return 0;
}
const char* shaderSrc = loadShaderSource(fileName);
if (shaderSrc == NULL) return 0;
glShaderSource(shader, 1, (const char**)&shaderSrc, NULL);
glCompileShader(shader);
int logMaxLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logMaxLength);
char log[logMaxLength];
int logLength = 0;
glGetShaderInfoLog(shader, logMaxLength, &logLength, log);
if (logLength > 0) {
std::cout << "(Shader::loadShaderCode) - Compiler log:\n------------------\n" << log << "\n------------------" << std::endl;
}
return shader;
}
int main()
{
glfwInit();
GLFWwindow* window;
window = glfwCreateWindow(800, 600, "TrackballTest", NULL, NULL);
glfwMakeContextCurrent(window);
// You can set the Trackball camera to another position and give it a name
cam.setPosition(glm::vec4(0.0,0.0,10.0,1.0));
cam.setName("TrackballCam");
cam.setNearFar(0.01f, 100.0f);
// Set all InputMaps and set one InputMap active
iH.setAllInputMaps(cam);
iH.changeActiveInputMap("Trackball");
// Callback
glfwSetKeyCallback(window, key_callback);
glewInit();
// Shader
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/colorShader3D.frag")));
ShaderProgram shader(vs, fs);
// Renderer
OpenGL3Context context;
Renderer renderer(context);
// Object
Teapot teapot;
teapot.loadBufferData();
// getting the start time
double startTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// You have to compute the delta time
cam.setSensitivity(glfwGetTime() - startTime);
startTime = glfwGetTime();
shader.bind();
// You have to send the uniform matrices of the Trackball camera to the shader
shader.sendMat4("viewMatrix", cam.getViewMatrix());
shader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
teapot.renderGeometry();
shader.unbind();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
int main()
{
glfwInit();
Window testWindow(50, 50, WINDOW_WIDTH, WINDOW_HEIGHT, "Deferred Shading");
glfwMakeContextCurrent(testWindow.getWindow());
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// You have to set a camera name
cam.setName("PilotviewCam");
cam.setPosition(glm::vec4(0.0, 0.5, 3.0, 1.0));
cam.setNearFar(0.01f, 100.0f);
iH.setAllInputMaps(cam);
iH.changeActiveInputMap("Pilotview");
//Callback
glfwSetKeyCallback(testWindow.getWindow(), key_callback);
glewInit();
//our shader
VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert")));
FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag")));
ShaderProgram shaderGBuffer(vsGBuffer, fsGBuffer);
//load shader here
VertexShader vsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.vert")));
FragmentShader fsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.frag")));
ShaderProgram shaderDsLightingShader(vsDsLighting, fsDsLighting);
VertexShader vsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.vert")));
FragmentShader fsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.frag")));
ShaderProgram shaderDsCompositingShader(vsDsCompositing, fsDsCompositing);
VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag")));
ShaderProgram shaderSFQ(vsSfq, fsSfq);
//our renderer
OpenGL3Context context;
Renderer renderer(context);
FBO fboGBuffer(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false);
FBO fboDeferredShading(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false);
FBO fboCompositing(WINDOW_WIDTH, WINDOW_HEIGHT, 3, false, false);
//our object
Cube cube;
Teapot teapot;
Rect plane;
Rect screenFillingQuad;
screenFillingQuad.loadBufferData();
//our textures
Texture bricks((char*)RESOURCES_PATH "/bricks_diffuse.png");
Texture bricks_normal((char*)RESOURCES_PATH "/bricks_normal.png");
Texture bricks_height((char*)RESOURCES_PATH "/bricks_height.png");
Texture chrome((char*)RESOURCES_PATH "/chrome.jpg");
Texture cvLogo((char*)RESOURCES_PATH "/cv_logo.bmp");
//Scene creation
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
//Add Camera to scenegraph
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->getCamera("PilotviewCam");
testScene.getScenegraph()->setActiveCamera("PilotviewCam");
Rect rect;
Node cube1("cube1");
cube1.addGeometry(&cube);
cube1.addTexture(&bricks);
cube1.addNormalMap(&bricks_normal);
cube1.addHeightMap(&bricks_height);
cube1.setModelMatrix(glm::translate(cube1.getModelMatrix(), glm::vec3(-1.0, 0.5, -0.5)));
cube1.setModelMatrix(glm::scale(cube1.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7)));
Node cube2("cube2");
cube2.addGeometry(&cube);
cube2.addTexture(&bricks);
cube2.addNormalMap(&bricks_normal);
cube2.setModelMatrix(glm::translate(cube2.getModelMatrix(), glm::vec3(-1, 0.5, 0.5)));
cube2.setModelMatrix(glm::scale(cube2.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7)));
Node cube3("cube3");
cube3.addGeometry(&cube);
cube3.addTexture(&bricks);
cube3.setModelMatrix(glm::translate(cube3.getModelMatrix(), glm::vec3(0, 0.5, -0.5)));
cube3.setModelMatrix(glm::scale(cube3.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7)));
Node cube4("cube4");
cube4.addGeometry(&cube);
cube4.addTexture(&bricks);
cube4.addNormalMap(&bricks_normal);
cube4.addHeightMap(&bricks_height,0.07,0.1,true);
cube4.setModelMatrix(glm::translate(cube4.getModelMatrix(), glm::vec3(0, 0.5, 0.5)));
cube4.setModelMatrix(glm::scale(cube4.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7)));
Node wallNode1("wall1");
wallNode1.addGeometry(&plane);
wallNode1.addTexture(&cvLogo);
wallNode1.setModelMatrix(glm::translate(wallNode1.getModelMatrix(), glm::vec3(0.0, 0.1, 0.2)));
wallNode1.setModelMatrix(glm::rotate(wallNode1.getModelMatrix(), 90.0f, glm::vec3(1.0, 0.0, 0.0)));
wallNode1.setModelMatrix(glm::scale(wallNode1.getModelMatrix(), glm::vec3(10.5, 10.5, 10.5)));
Node teaNode("teaNode");
teaNode.addGeometry(&teapot);
teaNode.addTexture(&chrome);
teaNode.setModelMatrix(glm::translate(teaNode.getModelMatrix(), glm::vec3(0.2, 0.4, 0.7)));
teaNode.setModelMatrix(glm::scale(teaNode.getModelMatrix(), glm::vec3(0.5, 0.5, 0.5)));
//Creating a scenegraph
testScene.getScenegraph()->getRootNode()->addChildrenNode(&wallNode1);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube1);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube2);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube3);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube4);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&teaNode);
double startTime = glfwGetTime();
//Renderloop
//create Light spheres for DS
Node lights = Node("Root");
Sphere lightSphere = Sphere();
for (int i = -4; i < 4; i++)
for (int j = -4; j < 4; j++)
{
Node *newLight = new Node(std::string("Node_"+std::to_string(i)+std::to_string(j)));
newLight->addGeometry(&lightSphere);
newLight->setModelMatrix(glm::translate(glm::mat4(1.0f), glm::vec3(i*1.5, 1.0f, j*1.5)));
//newLight.setModelMatrix(glm::translate(glm::mat4(1.0f), glm::vec3(0, 1, 1.0f)));
newLight->setModelMatrix(glm::scale(newLight->getModelMatrix(), glm::vec3(2.0, 2.0, 2.0)));
lights.addChildrenNode(newLight);
}
int outputFPS = 0;
while (!glfwWindowShouldClose(testWindow.getWindow()))
{
// You have to compute the delta time
float deltaTime = glfwGetTime() - startTime;
cam.setSensitivity(deltaTime);
//if (!(outputFPS % 20))
//std::cout << "FPS: " << static_cast<int>(1 / (glfwGetTime() - startTime)) << std::endl;
std::cout << "FPS: " << static_cast<double>(glfwGetTime() - startTime) * 100 << std::endl;
outputFPS++;
startTime = glfwGetTime();
//update Model Matrix
lights.setModelMatrix(glm::rotate(lights.getModelMatrix(), 10.0f * deltaTime, glm::vec3(0.0, 1.0, 0.0)));
fboGBuffer.bind();
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderGBuffer.bind();
shaderGBuffer.sendMat4("viewMatrix", cam.getViewMatrix());
shaderGBuffer.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shaderGBuffer);
shaderGBuffer.unbind();
fboGBuffer.unbind();
//DEFERRED SHADING TEIL============================
fboDeferredShading.bind();
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderDsLightingShader.bind();
shaderDsLightingShader.sendMat4("viewMatrix", cam.getViewMatrix());
shaderDsLightingShader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
shaderDsLightingShader.sendSampler2D("positionMap", fboGBuffer.getColorTexture(0),0);
shaderDsLightingShader.sendSampler2D("normalMap", fboGBuffer.getColorTexture(1),1);
shaderDsLightingShader.sendInt("windowWidth", testWindow.getWidth());
shaderDsLightingShader.sendInt("windowHeight", testWindow.getHeight());
shaderDsLightingShader.sendVec3("lightColor", glm::fvec3(0.7f,0.7f,0.4f));
lights.render(shaderDsLightingShader);
glDisable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glClearColor(1.0, 1.0, 1.0, 0.0);
shaderDsLightingShader.unbind();
fboDeferredShading.unbind();
//COMPOSITING TEIL ===============================
fboCompositing.bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderDsCompositingShader.bind();
shaderDsCompositingShader.sendSampler2D("colorMap", fboGBuffer.getColorTexture(2),0);
shaderDsCompositingShader.sendSampler2D("lightMap", fboDeferredShading.getColorTexture(2),1);
screenFillingQuad.renderGeometry();
shaderDsCompositingShader.unbind();
fboCompositing.unbind();
//================================================
//ScreenFillingQuad Render Pass
shaderSFQ.bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (glfwGetKey(testWindow.getWindow(), GLFW_KEY_F1))
shaderSFQ.sendSampler2D("fboTexture", fboDeferredShading.getColorTexture(2));
else
shaderSFQ.sendSampler2D("fboTexture", fboCompositing.getColorTexture(2));
screenFillingQuad.renderGeometry();
shaderSFQ.unbind();
glfwSwapBuffers(testWindow.getWindow());
glfwPollEvents();
}
glfwDestroyWindow(testWindow.getWindow());
glfwTerminate();
return 0;
}
int main()
{
glfwInit();
GLFWwindow* window;
window = glfwCreateWindow(800, 600, "ParticleSystemScene", NULL, NULL);
glfwMakeContextCurrent(window);
//CAM
cam.setKeySpeed(4.0);
iH.setAllInputMaps(cam);
glfwSetKeyCallback(window, key_callback);
cam.setFOV(50);
cam.setNearFar(1, 100);
glewInit();
//TEXTURES
Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png");
Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png");
Texture* smokeBlackTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png");
Texture* smokeBlackTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png");
Texture* snowTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/particle/snowflake.png"); //TODO better Resolution
//FINAL EMITTER SNOW
Emitter* snow = new Emitter(0, glm::vec3(0.0, 10.0, -5.0), 0.0, 0.166, 100, 30.0, true);
snow->setVelocity(0);
snow->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 1.0), 0.5f);
snow->setAreaEmitting(false, true, 10.0, 10000);
snow->addTexture(snowTex, 0.0);
snow->defineLook(true, 0.04, 2.0);
snow->setMovable(true);
//FINAL EMITTER WHITE SMOKE
Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 5.0), 0.0, 0.4, 1, 8.0, true);
smokeWhite->setVelocity(2);
smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeWhite->addTexture(smokeWhiteTex1, 1.0);
smokeWhite->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.2f };
std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f };
smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 4.0, 4.0, false, 0.3);
smokeWhite->switchToGeometryShader();
//FINAL EMITTER BLACK SMOKE
Emitter* smokeBlack = new Emitter(0, glm::vec3(0.0, 0.0, -10.0), 0.0, 0.4, 1, 8.0, true);
smokeBlack->setVelocity(2);
smokeBlack->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeBlack->addTexture(smokeBlackTex1, 1.0);
smokeBlack->addTexture(smokeBlackTex2, 0.08);
std::vector<float> smokeBlackSize{ 0.1f, 0.4f, 0.8f, 1.2f };
std::vector<float> smokeBlackTime{ 0.0f, 0.2f, 0.75f, 1.0f };
smokeBlack->defineLook(true, smokeBlackSize, smokeBlackTime, 1.0, 4.0, 4.0, false, 0.3);
smokeBlack->switchToGeometryShader();
//PARTICLE SYSTEM
Effect* sn = new Effect();
sn->addEmitter(snow);
ParticleSystem* psSnow = new ParticleSystem(glm::vec3(0, 2, -5), sn);
Node snowNode("snowNode");
snowNode.setParticleActive(true);
snowNode.setCamera(&cam);
snowNode.addParticleSystem(psSnow);
Effect* smWhi = new Effect();
smWhi->addEmitter(smokeWhite);
ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(0, 0, 3), smWhi);
Node whiteSmokeNode("whiteSmokeNode");
whiteSmokeNode.setParticleActive(true);
whiteSmokeNode.setCamera(&cam);
whiteSmokeNode.addParticleSystem(psSmokeWhite);
Effect* smBla = new Effect();
smBla->addEmitter(smokeBlack);
ParticleSystem* psSmokeBlack = new ParticleSystem(glm::vec3(0, 0, -3), smBla);
Node blackSmokeNode("blackSmokeNode");
blackSmokeNode.setParticleActive(true);
blackSmokeNode.setCamera(&cam);
blackSmokeNode.addParticleSystem(psSmokeBlack);
// Shader
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag")));
ShaderProgram shader(vs, fs);
// Renderer
OpenGL3Context context;
Renderer renderer(context);
// Object
Teapot teapot;
teapot.loadBufferData();
Node teapotNode("teapotNode");
teapotNode.addGeometry(&teapot);
teapotNode.setCamera(&cam);
teapotNode.setModelMatrix(glm::translate(teapotNode.getModelMatrix(), glm::vec3(0.0, 0.0, -7.0)));
//need scene here mainly because of input
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
//Add Camera to Scene
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("Pilotview");
//Set Input-Maps and activate one
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap("Pilotview");
//Add Objects to the Scene
testScene.getScenegraph()->getRootNode()->addChildrenNode(&teapotNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&blackSmokeNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&snowNode);
//start the ParticleSystems
psSmokeBlack->start();
psSmokeWhite->start();
psSnow->start();
// getting the start time
double startTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
cam.setSensitivity(glfwGetTime() - startTime);
startTime = glfwGetTime();
glEnable(GL_DEPTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.bind();
shader.sendMat4("modelMatrix", teapotNode.getModelMatrix());
shader.sendMat4("viewMatrix", cam.getViewMatrix());
shader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shader);
shader.unbind();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
Shader::Shader(const char *vertexFilename,
const char *fragmentFilename,
const char *geometryFilename,
const char *tesselationCTRLFilename,
const char *tesselationEVALFilename,
const char *computeFilename,
std::vector<std::string> &dynamicDefines)
{
bool errorTrigger = true;
std::string source;
if(computeFilename != NULL)//compute shader
{
computeShader = glCreateShader(GL_COMPUTE_SHADER);
if(!loadShaderSource(computeFilename, source, dynamicDefines))
{
glDeleteShader(computeShader);
return;
}
const char *src = source.c_str();
glShaderSource( computeShader, 1, &src, NULL );
source.clear();
glCompileShader(computeShader);
if(!checkShaderStatus(computeShader, computeFilename))
{
glDeleteShader(computeShader);
return;
}
program = glCreateProgram();
glAttachShader(program, computeShader);
glDeleteShader(computeShader);
}
else//no compute shader
{
if(vertexFilename!=NULL)
{
vertexShader = glCreateShader(GL_VERTEX_SHADER);
if(!loadShaderSource(vertexFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(vertexShader, 1, &src, NULL);
source.clear();
}
if(fragmentFilename != NULL)
{
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
if(!loadShaderSource(fragmentFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(fragmentShader, 1, &src, NULL);
source.clear();
}
if(geometryFilename != NULL)
{
geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
if(!loadShaderSource(geometryFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(geometryShader, 1, &src, NULL);
source.clear();
}
if(tesselationEVALFilename != NULL)
{
tesselationControlShader = glCreateShader(GL_TESS_CONTROL_SHADER);
tesselationEvaluationShader = glCreateShader(GL_TESS_EVALUATION_SHADER);
if(!loadShaderSource(tesselationCTRLFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(tesselationControlShader, 1, &src, NULL);
source.clear();
if(!loadShaderSource(tesselationEVALFilename, source, dynamicDefines))
errorTrigger=false;
src=source.c_str();
glShaderSource(tesselationEvaluationShader, 1, &src, NULL);
source.clear();
}
if(!errorTrigger)
{
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(geometryShader);
glDeleteShader(tesselationControlShader);
glDeleteShader(tesselationEvaluationShader);
return;
}
glCompileShader(vertexShader);
if(fragmentFilename != NULL)
{
glCompileShader(fragmentShader);
}
if(geometryFilename != NULL)
{
glCompileShader(geometryShader);
}
if(tesselationEVALFilename != NULL)
{
glCompileShader(tesselationControlShader);
glCompileShader(tesselationEvaluationShader);
}
if(!checkShaderStatus(vertexShader, vertexFilename))
{
errorTrigger = false;
}
if(fragmentFilename != NULL && !checkShaderStatus(fragmentShader,fragmentFilename))
{
errorTrigger = false;
}
if(geometryFilename != NULL && !checkShaderStatus(geometryShader,geometryFilename))
{
errorTrigger = false;
}
if(tesselationEVALFilename != NULL && !checkShaderStatus(tesselationEvaluationShader, tesselationEVALFilename) && !checkShaderStatus(tesselationControlShader, tesselationCTRLFilename))
{
errorTrigger = false;
}
if(!errorTrigger)
{
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(geometryShader);
glDeleteShader(tesselationEvaluationShader);
glDeleteShader(tesselationControlShader);
return;
}
program = glCreateProgram();
glAttachShader(program,vertexShader);
if(fragmentFilename!=NULL)
{
glAttachShader(program,fragmentShader);
}
if(geometryFilename!=NULL)
{
glAttachShader(program,geometryShader);
}
if(tesselationEVALFilename!=NULL)
{
glAttachShader(program, tesselationControlShader);
glAttachShader(program, tesselationEvaluationShader);
}
glDeleteShader(vertexShader);
if(fragmentFilename != NULL)
{
glDeleteShader(fragmentShader);
}
if(geometryFilename != NULL)
{
glDeleteShader(geometryShader);
}
if(tesselationEVALFilename != NULL)
{
glDeleteShader(tesselationControlShader);
glDeleteShader(tesselationEvaluationShader);
}
}
//equal for normal and compute shader
glLinkProgram(program);
GLint testVal;
glGetProgramiv(program, GL_LINK_STATUS,&testVal);
if(testVal == GL_FALSE)
{
char errorLog[1024];
glGetProgramInfoLog(program, 1024, NULL, errorLog);
if(vertexFilename != NULL)
{
QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << vertexFilename << " because of:\n "<< errorLog;
}
else
{
QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << computeFilename << " because of:\n "<< errorLog;
}
glDeleteProgram(program);
}
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments( &argc, argv );
std::string dbPath;
arguments.read("--db_path", dbPath);
std::srand ( unsigned ( std::time(0) ) );
auto board = Board(boardDefinition, boardSizeX, boardSizeY, dbPath);
auto ghostFactory = GhostFactory();
auto main_obj = make_ref<osg::Group>();
main_obj->addChild(board.draw().get());
auto ghostModel = osgDB::readNodeFile(dbPath + "/cow.osg");
auto ghostCount = 16;
while(ghostCount--)
{
main_obj->addChild(ghostFactory.drawGhost(board, ghostModel).get());
}
// init rotate
auto init_rotate = make_ref<osg::MatrixTransform>();
init_rotate->setMatrix( osg::Matrix::rotate(osg::PI * 2, osg::Vec3(1.0f, 0.0f, 0.0f)) );
// chain rotates
init_rotate->addChild(main_obj);
// Root group
auto root = make_ref<osg::Group>();
root->addChild(init_rotate);
// Setup fog
if(FogEnabled) {
osg::ref_ptr<osg::Fog> fog = new osg::Fog;
fog->setMode( osg::Fog::EXP2 );
fog->setStart( 0.0f );
fog->setEnd(board.getFieldSizeX() * 20);
fog->setDensity(0.0135);
fog->setColor( osg::Vec4(0., 0., 0., 1.0) );
root->getOrCreateStateSet()->setAttributeAndModes(fog.get());
}
// Start viewer
osgViewer::Viewer viewer;
// Set up flashlight
auto lightSource = make_ref<osg::LightSource>();
lightSource->setReferenceFrame(osg::LightSource::ABSOLUTE_RF);
auto light = lightSource->getLight();
const osg::Vec3 lightPosition{1.5, -1, -1}; // right, down, front
light->setPosition(osg::Vec4{lightPosition, 1});
light->setDirection(osg::Vec3{0, 0, -1} * 30 - lightPosition);
light->setSpotExponent(60);
light->setSpotCutoff(90);
light->setDiffuse(osg::Vec4(1, 1, 1, 1));
light->setAmbient(osg::Vec4(0.6, 0.6, 0.6, 1));
light->setSpecular(osg::Vec4(1, 1, 1, 1));
light->setLinearAttenuation(0.001);
light->setConstantAttenuation(0.5);
root->addChild(lightSource);
double height = std::min(board.getFieldSizeX(), board.getFieldSizeY()) / 1.5;
auto fpsManipulator = make_ref<FPSManipulator>(board, viewer, *light);
fpsManipulator->setHomePosition(
osg::Vec3d(board.getFieldCenterX(1), board.getFieldCenterY(10), height),
osg::Vec3d(0.0f, 0.0f, height),
osg::Vec3d(0.0f, 0.0f, 1.0f)
);
auto keySwitch = make_ref<osgGA::KeySwitchMatrixManipulator>();
keySwitch->addNumberedMatrixManipulator(make_ref<osgGA::OrbitManipulator>());
keySwitch->addNumberedMatrixManipulator(fpsManipulator);
viewer.setCameraManipulator(keySwitch);
viewer.home();
viewer.setSceneData( root );
osgViewer::Viewer::Windows windows;
viewer.getWindows(windows);
viewer.getCamera()->setClearColor(osg::Vec4{0, 0, 0, 0});
viewer.getCamera()->getView()->setLightingMode(osg::View::HEADLIGHT);
auto defaultLight = viewer.getCamera()->getView()->getLight();
defaultLight->setDiffuse(osg::Vec4(0, 0, 0, 1));
defaultLight->setAmbient(osg::Vec4(0, 0, 0, 1));
defaultLight->setSpecular(osg::Vec4(0, 0, 0, 1));
// Shaders
auto program = make_ref<osg::Program>();
auto fragmentObject = make_ref<osg::Shader>(osg::Shader::FRAGMENT);
loadShaderSource(fragmentObject, dbPath + "/shader.frag");
auto vertexObject = make_ref<osg::Shader>(osg::Shader::VERTEX);
loadShaderSource(vertexObject, dbPath + "/shader.vert");
program->addShader(vertexObject);
program->addShader(fragmentObject);
root->getOrCreateStateSet()->setAttributeAndModes(program, osg::StateAttribute::ON);
root->getOrCreateStateSet()->addUniform(new osg::Uniform("samplerName", TEXTURE_UNIT));
root->getOrCreateStateSet()->addUniform(new osg::Uniform("Shininess", BoardObjectsShininess));
root->getOrCreateStateSet()->addUniform(new osg::Uniform("FogEnabled", FogEnabled));
// Optimize
osgUtil::Optimizer optimzer;
optimzer.optimize(root);
viewer.setUpViewOnSingleScreen(0);
return viewer.run();
}
void ShaderEditOverlay::handleKeyDown(SDL_KeyboardEvent& event)
{
if (event.keysym.sym=='s' && isModEnabled(KMOD_CTRL, event.keysym.mod))
{
saveShaderSource();
}
if ('1'<=event.keysym.sym && event.keysym.sym<='3' && isModEnabled(KMOD_ALT, event.keysym.mod))
{
mActiveEditor->Command(SCI_SETFOCUS, false);
switch(event.keysym.sym)
{
case '1': mActiveEditor=&mSelectionList; break;
case '2': mActiveEditor=&mShaderEditor; break;
case '3': mActiveEditor=&mDebugOutputView; break;
}
mActiveEditor->Command(SCI_SETFOCUS, true);
}
if (event.keysym.sym==SDLK_F7 && isModEnabled(0, event.keysym.mod)&&mSelectedShader&&mSelectedProgram)
{
compileProgram();
mRequireReset = true;
}
else if (mActiveEditor==&mSelectionList)
{
switch (event.keysym.sym)
{
case SDLK_UP:
mSelectionList.Command(SCI_LINEUP);
break;
case SDLK_DOWN:
mSelectionList.Command(SCI_LINEDOWN);
break;
case SDLK_RETURN:
if (mSelectionMode==SELMODE_PROGRAM_LIST)
{
fillListWithShaders();
mSelectionMode=SELMODE_SHADER_LIST;
}
else
{
loadShaderSource();
}
break;
case SDLK_BACKSPACE:
if (mSelectionMode==SELMODE_SHADER_LIST)
{
fillListWithPrograms();
mSelectionMode=SELMODE_PROGRAM_LIST;
}
break;
}
}
else
{
int sciKey;
switch(event.keysym.sym)
{
case SDLK_DOWN: sciKey = SCK_DOWN; break;
case SDLK_UP: sciKey = SCK_UP; break;
case SDLK_LEFT: sciKey = SCK_LEFT; break;
case SDLK_RIGHT: sciKey = SCK_RIGHT; break;
case SDLK_HOME: sciKey = SCK_HOME; break;
case SDLK_END: sciKey = SCK_END; break;
case SDLK_PAGEUP: sciKey = SCK_PRIOR; break;
case SDLK_PAGEDOWN: sciKey = SCK_NEXT; break;
case SDLK_DELETE: sciKey = SCK_DELETE; break;
case SDLK_INSERT: sciKey = SCK_INSERT; break;
case SDLK_ESCAPE: sciKey = SCK_ESCAPE; break;
case SDLK_BACKSPACE: sciKey = SCK_BACK; break;
case SDLK_TAB: sciKey = SCK_TAB; break;
case SDLK_RETURN: sciKey = SCK_RETURN; break;
case SDLK_KP_PLUS: sciKey = SCK_ADD; break;
case SDLK_KP_MINUS: sciKey = SCK_SUBTRACT; break;
case SDLK_KP_DIVIDE: sciKey = SCK_DIVIDE; break;
case SDLK_LGUI: sciKey = SCK_WIN; break;
case SDLK_RGUI: sciKey = SCK_RWIN; break;
case SDLK_MENU: sciKey = SCK_MENU; break;
case SDLK_SLASH: sciKey = '/'; break;
case SDLK_ASTERISK: sciKey = '`'; break;
case SDLK_LEFTBRACKET: sciKey = '['; break;
case SDLK_BACKSLASH: sciKey = '\\'; break;
case SDLK_RIGHTBRACKET: sciKey = ']'; break;
case SDLK_LSHIFT:
case SDLK_RSHIFT:
case SDLK_LALT:
case SDLK_RALT:
case SDLK_LCTRL:
case SDLK_RCTRL:
sciKey = 0;
break;
default:
sciKey = event.keysym.sym;
}
if (sciKey)
{
bool consumed;
bool ctrlPressed = event.keysym.mod&KMOD_LCTRL || event.keysym.mod&KMOD_RCTRL;
bool altPressed = event.keysym.mod&KMOD_LALT || event.keysym.mod&KMOD_RALT;
bool shiftPressed = event.keysym.mod&KMOD_LSHIFT || event.keysym.mod&KMOD_RSHIFT;
mActiveEditor->KeyDown((SDLK_a<=sciKey && sciKey<=SDLK_z)?sciKey-'a'+'A':sciKey,
shiftPressed, ctrlPressed, altPressed,
&consumed
);
}
}
}
void initialize()
{
ChangeCurrentOpenGLContext ctx(opengl_context_ptr);
OpenGLBindings *b = new OpenGLBindings();
if (flextInit(opengl_context_ptr, b) == 0)
{
LOG_ERROR << "Failed to initialize flextGL.";
exit(-1);
}
gl(b);
input_data.allocate(352, 424 * 10);
for(int i = 0; i < 3; ++i)
stage1_data[i].allocate(512, 424);
if(do_debug) stage1_debug.allocate(512, 424);
stage1_infrared.allocate(512, 424);
for(int i = 0; i < 2; ++i)
filter1_data[i].allocate(512, 424);
filter1_max_edge_test.allocate(512, 424);
if(do_debug) filter1_debug.allocate(512, 424);
if(do_debug) stage2_debug.allocate(512, 424);
stage2_depth.allocate(512, 424);
stage2_depth_and_ir_sum.allocate(512, 424);
if(do_debug) filter2_debug.allocate(512, 424);
filter2_depth.allocate(512, 424);
stage1.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
stage1.setFragmentShader(loadShaderSource(shader_folder + "stage1.fs"));
stage1.build();
filter1.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
filter1.setFragmentShader(loadShaderSource(shader_folder + "filter1.fs"));
filter1.build();
stage2.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
stage2.setFragmentShader(loadShaderSource(shader_folder + "stage2.fs"));
stage2.build();
filter2.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
filter2.setFragmentShader(loadShaderSource(shader_folder + "filter2.fs"));
filter2.build();
if(do_debug)
{
debug.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
debug.setFragmentShader(loadShaderSource(shader_folder + "debug.fs"));
debug.build();
}
GLenum debug_attachment = do_debug ? GL_COLOR_ATTACHMENT0 : GL_NONE;
gl()->glGenFramebuffers(1, &stage1_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage1_framebuffer);
const GLenum stage1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4 };
gl()->glDrawBuffers(5, stage1_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage1_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage1_data[0].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage1_data[1].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, stage1_data[2].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT4, GL_TEXTURE_RECTANGLE, stage1_infrared.texture, 0);
gl()->glGenFramebuffers(1, &filter1_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter1_framebuffer);
const GLenum filter1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
gl()->glDrawBuffers(4, filter1_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter1_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter1_data[0].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, filter1_data[1].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, filter1_max_edge_test.texture, 0);
gl()->glGenFramebuffers(1, &stage2_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage2_framebuffer);
const GLenum stage2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 };
gl()->glDrawBuffers(3, stage2_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage2_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage2_depth.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage2_depth_and_ir_sum.texture, 0);
gl()->glGenFramebuffers(1, &filter2_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter2_framebuffer);
const GLenum filter2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1 };
gl()->glDrawBuffers(2, filter2_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter2_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter2_depth.texture, 0);
Vertex bl = {-1.0f, -1.0f, 0.0f, 0.0f }, br = { 1.0f, -1.0f, 512.0f, 0.0f }, tl = {-1.0f, 1.0f, 0.0f, 424.0f }, tr = { 1.0f, 1.0f, 512.0f, 424.0f };
Vertex vertices[] = {
bl, tl, tr, tr, br, bl
};
gl()->glGenBuffers(1, &square_vbo);
gl()->glGenVertexArrays(1, &square_vao);
gl()->glBindVertexArray(square_vao);
gl()->glBindBuffer(GL_ARRAY_BUFFER, square_vbo);
gl()->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GLint position_attr = stage1.getAttributeLocation("Position");
gl()->glVertexAttribPointer(position_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
gl()->glEnableVertexAttribArray(position_attr);
GLint texcoord_attr = stage1.getAttributeLocation("TexCoord");
gl()->glVertexAttribPointer(texcoord_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(2 * sizeof(float)));
gl()->glEnableVertexAttribArray(texcoord_attr);
}
int main()
{
glfwInit();
////our window
//GLFWwindow* window;
//window = glfwCreateWindow(800, 600, "ParticleSystemXML", NULL, NULL);
//glfwMakeContextCurrent(window);
//
////CAM
//cam.setKeySpeed(4.0);
//iH.setAllInputMaps(cam);
//glfwSetKeyCallback(window, key_callback);
//cam.setFOV(50);
//cam.setNearFar(1, 100);
Window testWindow(500, 50, 800, 600, "ParticleSystem");
glfwMakeContextCurrent(testWindow.getWindow());
// Callback
glfwSetKeyCallback(testWindow.getWindow(), key_callback);
cam.setKeySpeed(4.0);
cam.setNearFar(0.1, 100);
cam.setPosition(glm::vec4(0, 0, 8, 0));
glewInit();
//our renderer
OpenGL3Context context;
Renderer *renderer;
renderer = new Renderer(context);
//////////////////////Textures//////////////////////
Texture* fireTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/Fire2_M.png");
Texture* fireTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire1_M.png");
Texture* fireTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire3_M.png");
Texture* fireTex3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/flame02_L.png");
//Texture* fireFlickering1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_1.png");
//Texture* fireFlickering2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_2.png");
//Texture* fireFlickering3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_3.png");
//Texture* fireFlickering4 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_4.png");
Texture* fireSparkleTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle1_S.png");
Texture* fireSparkleTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle2.png");
Texture* texFireworkBlue = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_blue.png");
Texture* texFireworkRed = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_red.png");
Texture* texFireworkGreen = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_green.png");
Texture* texFireworkGold = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_gold.png");
Texture* texFireworkTail = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_tail.png");
Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png");
Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png");
Texture* smokeBlack1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png");
Texture* smokeBlack2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png");
//////////////////////Emitter//////////////////////
//Emitter explosion sparkle
Emitter* explosionSparkle = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.25, 0.01, 80, 1.25, true);
explosionSparkle->setVelocity(5);
//explosionSparkle->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.3), 3.0f);
explosionSparkle->usePhysicPointGravity(glm::vec3(0.0, 0.0, 0.0), 0.6, 10.0, 2, 4.0f, true);
explosionSparkle->addTexture(fireSparkleTex1, 1.0);
explosionSparkle->defineLook(true, 0.01, 0.0, 0.1);
//Emitter explosion fire
//TODO
//Emitter fire smoke
Emitter* fire = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.2, 2, 5.0, true);
fire->setVelocity(5);
fire->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 5.0), 0.5f);
fire->addTexture(fireTex1, 1.0);
fire->addTexture(fireTex2, 0.7);
fire->addTexture(smokeBlack2, 0.1);
//fire->addTexture(smokeBlack2, 0.1);
//fire->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> sizeF{ 0.05f, 0.5f, 0.75f, 1.0f };
std::vector<float> timeF{ 0.0f, 0.4f, 0.75f, 1.0f };
fire->defineLook(true, sizeF, timeF, 0.5, 4.0, 3.0, true, 0.3);
fire->switchToGeometryShader();
//Emitter fire flickering
Emitter* fireFlickering = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.2, 1, 2.0, true);
fireFlickering->setVelocity(5);
fireFlickering->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.5), 0.3f);
/*fireFlickering->addTexture(fireFlickering1, 1.0);
fireFlickering->addTexture(fireFlickering2, 0.7);
fireFlickering->addTexture(fireFlickering3, 0.5);
fireFlickering->addTexture(fireFlickering4, 0.3);*/
fireFlickering->defineLook(true, 0.1, 0.5, 1.0, 0.5, true, 0.3);
fireFlickering->switchToGeometryShader();
Emitter* fireSparkle = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.05, 3, 2.5, true);
fireSparkle->setVelocity(5);
fireSparkle->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.8), 0.5f);
fireSparkle->addTexture(fireSparkleTex1, 1.0);
fireSparkle->defineLook(true, 0.05, 0.5, 0.5);
//Emitter firework explosion
Emitter* fireworkExplosion = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.1, 0.01, 80, 2.0, true);
fireworkExplosion->setVelocity(6);
//fireworkExplosion->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.6), 3.0f);
fireworkExplosion->usePhysicPointGravity(glm::vec3(0.0, -2.0, 0.0), 0.9, 5.0, 2, 2.0f, true);
fireworkExplosion->addTexture(texFireworkRed, 1.0);
fireworkExplosion->defineLook(true, 0.04, 0.0, 0.5);
fireworkExplosion->setStartTime(2.0);
//Emitter firework tail
Emitter* fireworkTail = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 2.0, 0.01, 20, 0.5, true);
fireworkTail->setVelocity(5);
//fireworkTail->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 2.9), 0.2f);
fireworkTail->usePhysicPointGravity(glm::vec3(0.0, -4.0, 0.0), 30.6, 10.0, 2, 0.2f, true);
fireworkTail->addTexture(texFireworkTail, 1.0);
fireworkTail->defineLook(true, 0.001, 0.0, 0.1);
//FINAL EMITTER WHITE SMOKE
Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.4, 1, 8.0, true);
smokeWhite->setVelocity(2);
smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeWhite->addTexture(smokeWhiteTex1, 1.0);
smokeWhite->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.0f };
std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f };
smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 2.0, 1.0, false, 0.3);
smokeWhite->switchToGeometryShader();
//////////////////////Effect//////////////////////
Effect* efExplosion = new Effect();
efExplosion->addEmitter(explosionSparkle);
Effect* efFire = new Effect();
efFire->addEmitter(fire);
//efFire->addEmitter(fireFlickering);
efFire->addEmitter(fireSparkle);
efFire->saveEffect(RESOURCES_PATH "/XML/Effect_Fire.xml");
Effect* efFirework = new Effect();
efFirework->addEmitter(fireworkTail);
efFirework->addEmitter(fireworkExplosion);
//efFirework->saveEffect(RESOURCES_PATH "/XML/Effect_Firework.xml");
Effect* efFireworkTail = new Effect();
efFireworkTail->addEmitter(fireworkTail);
Effect* efFireworkExplosion = new Effect();
efFireworkExplosion->addEmitter(fireworkExplosion);
Effect* efSmWhi = new Effect();
efSmWhi->addEmitter(smokeWhite);
efSmWhi->saveEffect(RESOURCES_PATH "/XML/Effect_SmokeWhite.xml");
//////////////////////ParticleSystem//////////////////////
//ParticleSystem* psExplosion = new ParticleSystem(glm::vec3(0, -1, 0), efExplosion);
//ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), efFire);
ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), RESOURCES_PATH "/XML/Effect_Fire.xml");
ParticleSystem* psFirework = new ParticleSystem(glm::vec3(0, 0, 5), efFirework);
ParticleSystem* psFireworkTail = new ParticleSystem(glm::vec3(0, 0, 5), efFireworkTail);
ParticleSystem* psFireworkExplosion = new ParticleSystem(glm::vec3(0, 2, 5), efFireworkExplosion);
ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), efSmWhi);
//ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), RESOURCES_PATH "/XML/Effect_SmokeWhite.xml");
ParticleSystem* psFireworkRed = new ParticleSystem(glm::vec3(-6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkRed.xml");
ParticleSystem* psFireworkBlue = new ParticleSystem(glm::vec3(-2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkBlue.xml");
ParticleSystem* psFireworkGreen = new ParticleSystem(glm::vec3(2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGreen.xml");
ParticleSystem* psFireworkGold = new ParticleSystem(glm::vec3(6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGold.xml");
ParticleSystem* psComicCloud = new ParticleSystem(glm::vec3(0, -1, 3), RESOURCES_PATH "/XML/Effect_ComicCloud.xml");
//////////////////////Node//////////////////////
//Node nodeExplosion("nodeExplosion");
//nodeExplosion.setCamera(&cam);
//nodeExplosion.addParticleSystem(psExplosion);
//nodeExplosion.setParticleActive(true);
//
//Node fireNode("fireNode");
//fireNode.setCamera(&cam);
//fireNode.addParticleSystem(psFire);
//fireNode.setParticleActive(true);
//
//Node nodeFirework("fireworkNode");
//nodeFirework.setCamera(&cam);
//nodeFirework.addParticleSystem(psFirework);
//nodeFirework.setParticleActive(true);
//
//Node whiteSmokeNode("whiteSmokeNode");
//whiteSmokeNode.setCamera(&cam);
//whiteSmokeNode.addParticleSystem(psSmokeWhite);
//whiteSmokeNode.setParticleActive(true);
////Firework
//Node nodeFireworkRed("fireworkRedNode");
//nodeFireworkRed.setCamera(&cam);
//nodeFireworkRed.addParticleSystem(psFireworkRed);
//nodeFireworkRed.setParticleActive(true);
//Node nodeFireworkBlue("fireworBlueNode");
//nodeFireworkBlue.setCamera(&cam);
//nodeFireworkBlue.addParticleSystem(psFireworkBlue);
//nodeFireworkBlue.setParticleActive(true);
//Node nodeFireworkGreen("fireworkGreenNode");
//nodeFireworkGreen.setCamera(&cam);
//nodeFireworkGreen.addParticleSystem(psFireworkGreen);
//nodeFireworkGreen.setParticleActive(true);
//Node nodeFireworkGold("fireworkGoldNode");
//nodeFireworkGold.setCamera(&cam);
//nodeFireworkGold.addParticleSystem(psFireworkGold);
//nodeFireworkGold.setParticleActive(true);
// Shader
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag")));
ShaderProgram shader(vs, fs);
//need scene here mainly because of input
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
//Add Camera to Scene
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("Pilotview");
//Set Input-Maps and activate one
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap(MapType::CAMPILOTVIEW);
iH.getActiveInputMap()->update(cam);
//Object
Cube cube;
Texture bricks((char*)RESOURCES_PATH "/Wall/bricks_diffuse.png");
Node cube1("cube");
cube1.addGeometry(&cube);
cube1.addTexture(&bricks);
cube1.setModelMatrix(glm::translate(cube1.getModelMatrix(), glm::vec3(0.0, 0.0, 0.0)));
//cube1.setModelMatrix(glm::scale(cube1.getModelMatrix(), glm::vec3(0.5, 0.5, 0.5)));
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube1);
//add nodes to the scenegraph
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeExplosion);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&fireNode);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFirework);
/*testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkRed);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkBlue);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGreen);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGold);*/
//using this, the ParticleSystems get rendered in order of their distance to the camera
testScene.getScenegraph()->addParticleSystem(psFire);
testScene.getScenegraph()->addParticleSystem(psSmokeWhite);
testScene.getScenegraph()->addParticleSystem(psFireworkBlue);
testScene.getScenegraph()->addParticleSystem(psFireworkRed);
testScene.getScenegraph()->addParticleSystem(psFireworkGreen);
testScene.getScenegraph()->addParticleSystem(psFireworkGold);
//testScene.getScenegraph()->addParticleSystem(psComicCloud);
////TEST
//Emitter* etest = new Emitter(0, glm::vec3(0, 0, 0), 0, 1, 1000000, 1, true);
//etest->setVelocity(6);
//etest->usePhysicPointGravity(glm::vec3(0, 0, 0), 0.5, 20, 1, -2.5, true);
//etest->defineLook(false, 0.005);
//Effect* eftest = new Effect();
//eftest->addEmitter(etest);
//ParticleSystem* pstest = new ParticleSystem(glm::vec3(0, 2, 0), eftest);
//testScene.getScenegraph()->addParticleSystem(pstest);
//pstest->start();
//start the ParticleSystems
psFire->start();
psSmokeWhite->start();
//psExplosion->start();
//psFirework->start();
psFireworkRed->start();
psFireworkBlue->start();
psFireworkGreen->start();
psFireworkGold->start();
//psComicCloud->start();
double startTime = glfwGetTime();
double lastTime = glfwGetTime();
int nbFrames = 0;
while (!glfwWindowShouldClose(testWindow.getWindow()))
{
// Measure speed
double currentTime = glfwGetTime();
nbFrames++;
if (currentTime - lastTime >= 1.0) { // If last prinf() was more than 1 sec ago
// printf and reset timer
//printf("%f ms/frame\n", 1000.0 / double(nbFrames));
nbFrames = 0;
lastTime += 1.0;
}
double dt = glfwGetTime() - startTime;
cam.setSensitivity(dt);
startTime = glfwGetTime();
/*glEnable(GL_DEPTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.bind();
shader.sendMat4("viewMatrix", cam.getViewMatrix());
shader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shader);
testScene.renderParticleSystems();
shader.unbind();*/
//renderer->useBloom(true);
renderer->renderScene(testScene, testWindow);
//update Positions of firework ParticleSystems
glm::vec3 pos = psFireworkRed->getPosition();
psFireworkRed->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkBlue->getPosition();
psFireworkBlue->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkGreen->getPosition();
psFireworkGreen->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkGold->getPosition();
psFireworkGold->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
/*glfwSwapBuffers(testWindow.getWindow());
glfwPollEvents();*/
}
glfwDestroyWindow(testWindow.getWindow());
glfwTerminate();
return 0;
}
void MaterialTemplate::attachShader(const std::string& fname, GLenum type) {
gl::Shader shader(type);
if (loadShaderSource(fname, shader)) {
shaders.push_back(std::move(shader));
}
}
int main() {
glfwInit();
//our window
GLFWwindow* window;
window = glfwCreateWindow(800, 600, "ComputeShader", NULL, NULL);
glfwMakeContextCurrent(window);
cam.setName("PilotviewCam");
cam.setPosition(glm::vec4(0, 0, 2.0, 1.0));
cam.setNearFar(0.01f, 10.0f);
// Set all InputMaps and set one InputMap active
iH.setAllInputMaps(cam);
iH.changeActiveInputMap("Pilotview");
// Callback
glfwSetKeyCallback(window, key_callback);
glewInit();
/*MAGIC*/
ComputeShader cs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/simpleComputeShader.comp")));
ShaderProgram compute(cs);
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.frag")));
ShaderProgram render(vs, fs);
//GLuint render_vao;
//glGenVertexArrays(1, &render_vao);
//glBindVertexArray(render_vao);
GLuint position_ssbo;
glGenBuffers(1, &position_ssbo);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, position_ssbo);
glBufferData(GL_SHADER_STORAGE_BUFFER, PARTICLE_COUNT * sizeof(struct pos), NULL, GL_STATIC_DRAW);
GLint bufMask = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
struct pos* positions = (struct pos*)glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, PARTICLE_COUNT * sizeof(struct pos), bufMask);
for (int i = 0; i < PARTICLE_COUNT; i++)
{
positions[i].x = ((rand() % 100) / 100.0f) - 0.5;
positions[i].y = ((rand() % 100) / 100.0f) - 0.5;
positions[i].z = ((rand() % 100) / 100.0f) - 0.5;
positions[i].w = 1;
}
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
//glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
//glEnableVertexAttribArray(0);
//std::cout << "HIER MUSS 000 STEHEN: " << positions[1].x << positions[1].y << positions[1].z << std::endl;
/*END*/
float startCamTime = glfwGetTime();
double lastTime = glfwGetTime();
int nbFrames = 0;
while (!glfwWindowShouldClose(window))
{
// Measure speed
double currentTime = glfwGetTime();
nbFrames++;
if (currentTime - lastTime >= 1.0){ // If last prinf() was more than 1 sec ago
// printf and reset timer
printf("%f ms/frame\n", 1000.0 / double(nbFrames));
nbFrames = 0;
lastTime += 1.0;
}
cam.setSensitivity(glfwGetTime() - startCamTime);
startCamTime = cam.getSensitivity();
compute.bind();
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, position_ssbo);
compute.sendFloat("time", glfwGetTime());
glDispatchCompute(PARTICLE_GROUP_COUNT, 1, 1);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0);
glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT);
compute.unbind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
render.bind();
glBindBuffer(GL_ARRAY_BUFFER, position_ssbo);
render.sendMat4("viewMatrix", cam.getViewMatrix());
render.sendMat4("projectionMatrix", cam.getProjectionMatrix());
glVertexPointer(4, GL_FLOAT, 0, (void*)0);
glEnableClientState(GL_VERTEX_ARRAY);
//glPointSize(1.0);
glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT);
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);
render.unbind();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void Renderer::init(int windowWidth, int windowHeight)
{
m_windowWidth = windowWidth;
m_windowHeight = windowHeight;
//create ping pong fbos
m_ping = new FBO(windowWidth, windowHeight, 3, true, false);
m_pong = new FBO(windowWidth, windowHeight, 3, true, false);
m_gBuffer = new FBO(windowWidth, windowHeight, 3, true, false);
m_smFBO = new FBO(windowWidth, windowHeight, 1, true, false);
//load Shader
if (!m_shaderGBuffer)
{
VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert")));
FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag")));
m_shaderGBuffer = new ShaderProgram(vsGBuffer, fsGBuffer);
}
if (m_useDeferredShading && !m_shaderDSLighting && !m_shaderDSCompositing)
{
VertexShader vsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.vert")));
FragmentShader fsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.frag")));
m_shaderDSLighting = new ShaderProgram(vsDsLighting, fsDsLighting);
VertexShader vsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.vert")));
FragmentShader fsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.frag")));
m_shaderDSCompositing = new ShaderProgram(vsDsCompositing, fsDsCompositing);
}
if (m_useReflections && !m_shaderRLR)
{
VertexShader vsRLR(loadShaderSource(SHADERS_PATH + std::string("/RealtimeLocalReflections/RealtimeLocalReflections.vert")));
FragmentShader fsRLR(loadShaderSource(SHADERS_PATH + std::string("/RealtimeLocalReflections/RealtimeLocalReflections.frag")));
m_shaderRLR = new ShaderProgram(vsRLR, fsRLR);
}
if (!m_shaderSFQ)
{
VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag")));
m_shaderSFQ = new ShaderProgram(vsSfq, fsSfq);
}
if (m_useBloom && !m_shaderBloom)
{
VertexShader vsBloom(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsBloom(loadShaderSource(SHADERS_PATH + std::string("/Bloom/Bloom.frag")));
m_shaderBloom = new ShaderProgram(vsBloom, fsBloom);
}
if (m_useBlur && !m_shaderBlur)
{
VertexShader vsBlur(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsBlur(loadShaderSource(SHADERS_PATH + std::string("/Blur/blur1D.frag")));
m_shaderBlur = new ShaderProgram(vsBlur, fsBlur);
}
if (m_useRadialBlur && !m_shaderRadialBlur)
{
VertexShader vsBlur(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsBlur(loadShaderSource(SHADERS_PATH + std::string("/RadialBlur/RadialBlur.frag")));
m_shaderRadialBlur = new ShaderProgram(vsBlur, fsBlur);
}
if (m_useDoF && !m_shaderDoF)
{
VertexShader vsDoF(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsDoF(loadShaderSource(SHADERS_PATH + std::string("/DoF/DoF.frag")));
m_shaderDoF = new ShaderProgram(vsDoF, fsDoF);
VertexShader vsDepth(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.vert")));
FragmentShader fsDepth(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.frag")));
m_shaderDepth = new ShaderProgram(vsDepth, fsDepth);
}
if (m_useAntiAliasing && !m_shaderFXAA)
{
VertexShader vsFXAA(loadShaderSource(SHADERS_PATH + std::string("/FXAA/FXAA.vert")));
FragmentShader fsFXAA(loadShaderSource(SHADERS_PATH + std::string("/FXAA/FXAA.frag")));
m_shaderFXAA = new ShaderProgram(vsFXAA, fsFXAA);
}
if (m_useSSAO && !m_shaderSSAOcalc && !m_shaderSSAOblur && !m_shaderSSAOfinal)
{
VertexShader vsSSAO(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssao.vert")));
FragmentShader fsSSAO(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssao.frag")));
m_shaderSSAOcalc = new ShaderProgram(vsSSAO, fsSSAO);
VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsBLUR(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssaoBlur.frag")));
m_shaderSSAOblur = new ShaderProgram(vsSfq, fsBLUR);
FragmentShader fsFinal(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssaoFinal.frag")));
m_shaderSSAOfinal = new ShaderProgram(vsSfq, fsFinal);
}
if (m_useShadowMapping && !m_shaderShadowMapping)
{
VertexShader vsSM(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.vert")));
FragmentShader fsSM(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.frag")));
m_shaderShadowMapping = new ShaderProgram(vsSM, fsSM);
if(!m_smCam)
m_smCam = new Pilotview("smCam");
m_smCam->setNearFar(1.0f,30.0f);
}
}
