int main(int argc, char** argv)
{
Display display(800, 600, "Test");
Shader shader("./shaders/basicshader");
Shader shader2("./shaders/basicshader");
Vertex vertices[] = { Vertex(glm::vec3(-0.5, -0.5, 0), glm::vec2(0.0, 0.0)),
Vertex(glm::vec3(0, 0.5, 0) , glm::vec2(0.5, 1.0)),
Vertex(glm::vec3(0.5, -0.5, 0), glm::vec2(1.0, 0.0)) };
unsigned int indices[] = { 0, 1, 2 };
Texture texture("images/test.png");
Transform transform;
Transform origin;
origin.SetPos(glm::vec3(0, 5, 0));
float counter = 0.0f;
Camera camera(glm::vec3(0, 0, -30), 70.0f, (float)WIDTH/HEIGHT , 0.01f, 1000.0f);
//Mesh mesh(vertices, sizeof(vertices)/sizeof(vertices[0]), indices, sizeof(indices)/sizeof(indices[0]));
Mesh mesh2("./images/mountainsuv.obj");
//Mesh mesh3("./images/monkey3.obj");
//Console stuff:
std::cout << " Controls:" << '\n' <<'\n'<< " W A S D = sus stanga jos dreapta"
<< '\n' << " z = zoom in"
<< '\n' << " x = zoom out"
<< '\n' << " UP ARROW = rotatie verticala sus"
<< '\n' << " DOWN ARROW = rotatie verticala jos"
<< '\n' << " LEFT ARROW = rotatie orizontala stanga"
<< '\n' << " RIGHT ARROW = rotatie verticala dreapta";
while (!display.IsClosed())
{
display.Clear(0.0f, 0.5f, 0.3f, 0.0f);
shader.Bind();
texture.Bind();
mesh2.Draw();
//mesh.Draw()
shader.Update(transform, origin, camera);
display.Update(transform);
counter += 0.001f;
}
return 0;
}
void ShaderGLTest::compile() {
#ifndef MAGNUM_TARGET_GLES
constexpr Version v = Version::GL210;
#else
constexpr Version v = Version::GLES200;
#endif
Shader shader(v, Shader::Type::Fragment);
shader.addSource("void main() {}\n");
CORRADE_VERIFY(shader.compile());
Shader shader2(v, Shader::Type::Fragment);
shader2.addSource("[fu] bleh error #:! stuff\n");
CORRADE_VERIFY(!shader2.compile());
}
ImmeubleAvecFenetre::ImmeubleAvecFenetre(int nombreEtages) {
mImmeuble=new osg::Group();
mImmeubleLow=new osg::Group();
mEmptyNode=new osg::Group();
mRoute= new osg::Group();
mNombreEtages=nombreEtages;
osg::ref_ptr<osg::StateSet> etageStateSet (etage->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> rdcStateSet (rezDeChausse->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> toitStateSet (toit->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> trotoirStateSet (trotoir->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> routeStateSet (route->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> etageLowStateSet (etageLow->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> rdcLowStateSet (rezDeChausseLow->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> toitLowStateSet (toitLow->getOrCreateStateSet());
osg::ref_ptr<osg::StateSet> lampadaireStateSet (lampadaire->getOrCreateStateSet());
//Its shader objects
osg::ref_ptr<osg::Program> shader (new osg::Program);
osg::ref_ptr<osg::Shader> capsulevertexShader(
osg::Shader::readShaderFile (osg::Shader::VERTEX, "../shaders/nuanceurSommets.glsl"));
osg::ref_ptr<osg::Shader> capsulefragShader(
osg::Shader::readShaderFile (osg::Shader::FRAGMENT, "../shaders/nuanceurFragments.glsl"));
shader->addShader(capsulevertexShader.get());
shader->addShader(capsulefragShader.get());
osg::ref_ptr<osg::Program> shader2 (new osg::Program);
osg::ref_ptr<osg::Shader> texturevertexShader(
osg::Shader::readShaderFile (osg::Shader::VERTEX, "../shaders/nuanceurSommetsTexture.glsl"));
osg::ref_ptr<osg::Shader> texturefragShader(
osg::Shader::readShaderFile (osg::Shader::FRAGMENT, "../shaders/nuanceurFragmentsTexture.glsl"));
//Binding the box shaders to its program
shader2->addShader(texturevertexShader.get());
shader2->addShader(texturefragShader.get());
etageStateSet->setAttribute(shader);
rdcStateSet->setAttribute(shader);
toitStateSet->setAttribute(shader);
trotoirStateSet->setAttribute(shader);
lampadaireStateSet->setAttribute(shader);
etageLowStateSet->setAttribute(shader2);
rdcLowStateSet->setAttribute(shader2);
toitLowStateSet->setAttribute(shader2);
routeStateSet->setAttribute(shader2);
}
void canDetachAllShaders()
{
ShaderProgram shaderProgram;
Shader shader1(Shader::VERTEX_SHADER);
Shader shader2(Shader::FRAGMENT_SHADER);
QVERIFY(shaderProgram.attach(shader1));
QVERIFY(shaderProgram.attach(shader2));
QVERIFY(shaderProgram.has(shader1));
QVERIFY(shaderProgram.has(shader2));
shaderProgram.detachAllShaders();
QVERIFY(!shaderProgram.has(shader1));
QVERIFY(!shaderProgram.has(shader2));
}
//--------------------------------------------------------------------------
void GLShadersTests::tests()
{
GLVertexShader shader1("vert");
CPPUNIT_ASSERT(shader1.name() == "vert");
CPPUNIT_ASSERT(GL_VERTEX_SHADER == shader1.target());
GLFragmentShader shader2("frag");
CPPUNIT_ASSERT(shader2.name() == "frag");
CPPUNIT_ASSERT(GL_FRAGMENT_SHADER == shader2.target());
GLGeometryShader shader3;
CPPUNIT_ASSERT(shader3.name() == "");
CPPUNIT_ASSERT(GL_GEOMETRY_SHADER == shader3.target());
//--- Check initial state
CPPUNIT_ASSERT(shader1.m_shader_code == "");
CPPUNIT_ASSERT(shader1.m_error_msg == "");
CPPUNIT_ASSERT(!shader1.m_compiled);
CPPUNIT_ASSERT(0 == shader1.m_attached);
//--- Check initial state
CPPUNIT_ASSERT(shader2.code() == "");
CPPUNIT_ASSERT(shader2.error() == "");
CPPUNIT_ASSERT(!shader2.hasErrored());
CPPUNIT_ASSERT(!shader2.compiled());
CPPUNIT_ASSERT(0 == shader2.m_attached);
//--- Load from string
shader1.fromString("foobar");
CPPUNIT_ASSERT(!shader1.hasErrored());
CPPUNIT_ASSERT(shader1.code() == "foobar");
CPPUNIT_ASSERT(shader1.loaded());
CPPUNIT_ASSERT(!shader1.compiled());
try {
shader1.throw_if_not_loaded();
} catch(...) { CPPUNIT_FAIL("Exception should have not occured"); }
try {
shader1.throw_if_already_compiled();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
shader1.fromString("");
CPPUNIT_ASSERT(!shader1.hasErrored());
CPPUNIT_ASSERT(shader1.code() == "");
CPPUNIT_ASSERT(!shader1.loaded());
CPPUNIT_ASSERT(!shader1.compiled());
//--- Load from wrong file
CPPUNIT_ASSERT(shader3.code() == "");
CPPUNIT_ASSERT(!shader3.fromFile("this_file_does_not_exist"));
CPPUNIT_ASSERT(!shader3.compiled());
CPPUNIT_ASSERT(shader3.hasErrored());
CPPUNIT_ASSERT(shader3.code() == "");
CPPUNIT_ASSERT(!shader3.compiled());
CPPUNIT_ASSERT(shader3.error() != "");
CPPUNIT_ASSERT(!shader3.hasErrored());
try {
shader3.throw_if_not_loaded();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
try {
shader3.throw_if_already_compiled();
} catch(...) { CPPUNIT_FAIL("Exception should have not occured"); }
shader3.m_need_setup = false;
try {
shader3.throw_if_already_compiled();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
//---
shader2.attachProg(0);
CPPUNIT_ASSERT_EQUAL(0u, shader2.attached());
shader2.attachProg(42);
CPPUNIT_ASSERT_EQUAL(42u, shader2.attached());
//--- Try setup
shader1.m_error_msg = "";
shader1.fromString(""); shader1.m_compiled = true;
shader1.setup();
CPPUNIT_ASSERT(shader1.hasErrored());
CPPUNIT_ASSERT(shader1.error() != "");
shader1.setup();
//--- Try setup
shader1.m_error_msg = "";
shader1.fromString("ff"); shader1.m_compiled = true;
shader1.setup();
CPPUNIT_ASSERT(shader1.hasErrored());
CPPUNIT_ASSERT(shader1.error() != "");
shader1.setup();
// TODO shader1.begin();
}
int main(int argc, char** argv){
// Set interactive mode for debugging the program when started with arguments
bool interactive = false;
if(argc > 1) interactive = true;
// Initialize GLFW
if (!glfwInit()) fatalError("GLFW could not be initialized");
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create window
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, NAME, NULL, NULL);
if (window == NULL) fatalError("Failed to create GLFW window");
glfwMakeContextCurrent(window);
// Controls
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, keycallback);
// Start GLEW
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) fatalError("Failed to initialize GLEW");
glViewport(0, 0, WIDTH, HEIGHT);
// Load shaders
Shader shader1("shaders/basic.vertex", "shaders/basic.frag");
shader1.use();
glUniform1f(glGetUniformLocation(shader1.program, "first"), FIRST);
glUniform1f(glGetUniformLocation(shader1.program, "second"), SECOND);
glUniform1f(glGetUniformLocation(shader1.program, "third"), THIRD);
Shader shader2("shaders/basic.vertex", "shaders/advanced.frag");
// Raster scene settings
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f), -90.0f, 0.0f);
GLfloat vertices[] = {
-1.0f, -1.0f, 0.0f, -1.0f, -1.0f,
1.0f, -1.0f, 0.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 0.0f, -1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f
};
GLuint indices[] = {
0, 1, 2,
2, 1, 3
};
GLuint VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*) (3* sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glGenBuffers(1, &EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glBindVertexArray(0);
// FPS counter
bool isTicking = true;
int fpscount = 0;
GLfloat fpstime = 0.0f;
// Frame timings
GLfloat timeFromStart = START;
GLfloat lastFrame = (GLfloat) glfwGetTime();
GLfloat thisFrame = (GLfloat) glfwGetTime();
GLfloat deltaTime = thisFrame - lastFrame;
Shader shader = shader1;
int shaderNum = 1;
while(!glfwWindowShouldClose(window)){
thisFrame = (GLfloat) glfwGetTime();
deltaTime = thisFrame - lastFrame;
if(isTicking){
timeFromStart += deltaTime;
fpscount++;
fpstime += deltaTime;
if(fpstime > 1.0f) {
if(FPSlog){
std::cout << "FPS: " << (GLfloat) fpscount / fpstime << std::endl;
}
fpstime = 0.0f;
fpscount = 0;
}
}
// Handle Inputs if we are in interactive mode
//if (interactive) {
glfwPollEvents();
handleKeys(window, timeFromStart, isTicking, shader);
//}
glClearColor(0.05f, 0.05f, 0.05f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 model;
model = glm::scale(model, glm::vec3(SCALE, SCALE, SCALE));
glm::mat4 view;
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
glm::mat4 proj = glm::perspective(glm::radians(45.0f), (GLfloat) WIDTH / (GLfloat) HEIGHT, 0.1f, 100.0f);
glm::mat4 trans = proj * view * model;
if(timeFromStart > 40.0f && shaderNum == 1) {
shader = shader2;
shaderNum++;
}
shader.use();
glUniform1f(glGetUniformLocation(shader.program, "time"), timeFromStart);
glUniformMatrix4fv(glGetUniformLocation(shader.program, "transform"), 1, GL_FALSE, glm::value_ptr(trans));
glBindVertexArray(VAO);
// Draw
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glfwSwapBuffers(window);
lastFrame = thisFrame;
}
glfwTerminate();
return 0;
}
