Untitled
unknown
plain_text
3 years ago
8.8 kB
7
Indexable
/*
Niniejszy program jest wolnym oprogramowaniem; możesz go
rozprowadzać dalej i / lub modyfikować na warunkach Powszechnej
Licencji Publicznej GNU, wydanej przez Fundację Wolnego
Oprogramowania - według wersji 2 tej Licencji lub(według twojego
wyboru) którejś z późniejszych wersji.
Niniejszy program rozpowszechniany jest z nadzieją, iż będzie on
użyteczny - jednak BEZ JAKIEJKOLWIEK GWARANCJI, nawet domyślnej
gwarancji PRZYDATNOŚCI HANDLOWEJ albo PRZYDATNOŚCI DO OKREŚLONYCH
ZASTOSOWAŃ.W celu uzyskania bliższych informacji sięgnij do
Powszechnej Licencji Publicznej GNU.
Z pewnością wraz z niniejszym programem otrzymałeś też egzemplarz
Powszechnej Licencji Publicznej GNU(GNU General Public License);
jeśli nie - napisz do Free Software Foundation, Inc., 59 Temple
Place, Fifth Floor, Boston, MA 02110 - 1301 USA
*/
#define GLM_FORCE_RADIANS
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <stdlib.h>
#include <stdio.h>
#include "constants.h"
#include "allmodels.h"
#include "lodepng.h"
#include "shaderprogram.h"
float speed = 2;
float kolor = 0.4;
float kat = 0.0f;
void drawKostka(glm::mat4 M, float a, float b, float c)
{
glm::mat4 Mk = glm::scale (M, glm::vec3(a/2,b/2,c/2));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(Mk));
Models::cube.drawSolid();
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (action == GLFW_PRESS)
{
if (key == GLFW_KEY_LEFT)
{
kat= 30.0f;
}
if (key == GLFW_KEY_RIGHT)
{
kat = -30.0f;
}
}
if (action == GLFW_RELEASE) {
if (key == GLFW_KEY_LEFT or key == GLFW_KEY_RIGHT)
{
kat = 0.0f;
}
}
}
//Procedura obsługi błędów
void error_callback(int error, const char* description) {
fputs(description, stderr);
}
//Procedura inicjująca
void initOpenGLProgram(GLFWwindow* window) {
initShaders();
//************Tutaj umieszczaj kod, który należy wykonać raz, na początku programu************
glClearColor(0.1, 0.2, 0.123, 1);
glEnable(GL_DEPTH_TEST);
}
//Zwolnienie zasobów zajętych przez program
void freeOpenGLProgram(GLFWwindow* window) {
freeShaders();
//************Tutaj umieszczaj kod, który należy wykonać po zakończeniu pętli głównej************
}
//Procedura rysująca zawartość sceny
void drawScene(GLFWwindow* window, float angle) {
//************Tutaj umieszczaj kod rysujący obraz******************
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 V = glm::lookAt(
glm::vec3(0.0f, 10.0f, -7.0f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 P = glm::perspective(50.0f * PI / 180.0f, 1.0f, 1.0f, 50.0f);
glUniformMatrix4fv(spLambert->u("P"), 1, false, glm::value_ptr(P));
glUniformMatrix4fv(spLambert->u("V"), 1, false, glm::value_ptr(V));
/*glm::mat4 M2 = glm::mat4(1.0f);
M2 = glm::translate(M2, glm::vec3(-1.045f, 0.0f, 0.0f));
M2 = glm::rotate(M2, -angle, glm::vec3(0.0f, 0.0f, 1.0f));*/
glm::mat4 M = glm::mat4(1.0f);
glUniform4f(spLambert->u("color"), 1, 0.8, 0.7, 0.1);
drawKostka(M, 1, 0.5, 1);
spLambert->use();
for (int i = 0; i < 4; i++)
{
glm::mat4 Mg = M;
Mg = glm::rotate(Mg, glm::radians(90.0f*i), glm::vec3(0.0f, 1.0f, 0.0f));
Mg = glm::translate(Mg, glm::vec3(0.5f, 0.0f, 0.0f));
Mg = glm::rotate(Mg, angle, glm::vec3(0.0f, 0.0f, 1.0f));
Mg = glm::translate(Mg, glm::vec3(1.0f, 0.0f, 0.0f));
glUniform4f(spLambert->u("color"), 1, 0.4, 0.7, 0.1);
drawKostka(Mg, 2, 0.5, 1);
glm::mat4 Mgp = Mg;
Mgp = glm::translate(Mgp, glm::vec3(1.0f, 0.0f, 0.0f));
Mgp = glm::rotate(Mgp, angle, glm::vec3(0.0f, 0.0f, 1.0f));
Mgp = glm::translate(Mgp, glm::vec3(1.0f, 0.0f, 0.0f));
glUniform4f(spLambert->u("color"), 1, 0.0, 0.0, 0.1);
drawKostka(Mgp, 2, 0.5, 1);
}
/*
glm::mat4 M1 = glm::mat4(1.0f);
M1 = glm::rotate(M1, angle, glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 Mkola = M1;
M1 = glm::scale(M1, glm::vec3(1.5f, 0.125f, 1.0f));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(M1));
glUniform4f(spLambert->u("color"), 1, 0.4, 0.7, 0.1);
Models::cube.drawSolid();
for (int i = 0; i < 4; i++)
{
int tyl = 1, bok = 1;
if (i % 2 == 0)
tyl *= -1;
if (i < 2)
bok *= -1;
glm::mat4 Mk1 = Mkola;
Mk1 = glm::translate(Mk1, glm::vec3(1.4f*tyl, 0.0f, 1.1f*bok));
Mk1 = glm::rotate(Mk1, glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));
if (i%2==0)
Mk1 = glm::rotate(Mk1, glm::radians(kat), glm::vec3(1.0f, 0.0f, 0.0f));
Mk1 = glm::rotate(Mk1, angle, glm::vec3(0.0f, 0.0f, 1.0f));
Mk1 = glm::scale(Mk1, glm::vec3(0.4f, 0.4f, 0.4f));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(Mk1));
glUniform4f(spLambert->u("color"), 1, 0.3, 0.4, 0.4);
Models::torus.drawWire();
}
*/
/*
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(M2));
glUniform4f(spLambert->u("color"), 0.1, 0.1, 0.1, 0.1);*/
//Models::torus.drawSolid();
//for (int i = 0; i < 12; i++)
//{
// glm::mat4 Mk = M2;
// Mk = glm::rotate(Mk, glm::radians(30.0f * i)+15.0f, glm::vec3(0.0f, 0.0f, 1.0f));
// Mk = glm::translate(Mk, glm::vec3(1.0f, 0.0f, 0.0f));
// Mk = glm::scale(Mk, glm::vec3(0.1f, 0.1f, 0.1f));
// glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(Mk));
// glUniform4f(spLambert->u("color"), 1, 0.4, 0.7, 0.1);
// Models::cube.drawSolid();
//}
//M = glm::rotate(M, angle, glm::vec3(0.0f, 1.0f, 0.0f));
/* Planety kreca sie wokol siebie
glm::mat4 M = glm::mat4(1.0f);
glm::mat4 V = glm::lookAt(
glm::vec3(0.0f, 0.0f, -5.0f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 P = glm::perspective(50.0f * PI / 180.0f, 1.0f, 1.0f, 50.0f);
spLambert->use();
glUniform4f(spLambert->u("color"), 1, 0.4, 0.7, 0.1);
glUniformMatrix4fv(spLambert->u("P"), 1, false, glm::value_ptr(P));
glUniformMatrix4fv(spLambert->u("V"), 1, false, glm::value_ptr(V));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(M));
mySphere2.drawSolid();
glm::mat4 Mz = M;
Mz = glm::rotate(Mz, angle, glm::vec3(0.0f, 1.0f, 0.0f));
Mz = glm::translate(Mz, glm::vec3(1.0f, 0.0f, 0.0f));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(Mz));
glUniform4f(spLambert->u("color"), 1, 0.1, 0.1, 0.1);
mySphere.drawSolid();
glm::mat4 Ms = Mz;
Ms = glm::rotate(Ms, angle, glm::vec3(0.0f, 1.0f, 0.0f));
Ms = glm::translate(Ms, glm::vec3(0.3f, 0.0f, 0.0f));
glUniformMatrix4fv(spLambert->u("M"), 1, false, glm::value_ptr(Ms));
glUniform4f(spLambert->u("color"), 1, 0.8, 0.8, 0.8);
mySphere3.drawSolid(); */
glfwSwapBuffers(window);
}
int main(void)
{
GLFWwindow* window; //Wskaźnik na obiekt reprezentujący okno
glfwSetErrorCallback(error_callback);//Zarejestruj procedurę obsługi błędów
if (!glfwInit()) { //Zainicjuj bibliotekę GLFW
fprintf(stderr, "Nie można zainicjować GLFW.\n");
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(1000, 10000, "OpenGL", NULL, NULL); //Utwórz okno 500x500 o tytule "OpenGL" i kontekst OpenGL.
glfwSetKeyCallback(window, key_callback);
if (!window) //Jeżeli okna nie udało się utworzyć, to zamknij program
{
fprintf(stderr, "Nie można utworzyć okna.\n");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window); //Od tego momentu kontekst okna staje się aktywny i polecenia OpenGL będą dotyczyć właśnie jego.
glfwSwapInterval(1); //Czekaj na 1 powrót plamki przed pokazaniem ukrytego bufora
if (glewInit() != GLEW_OK) { //Zainicjuj bibliotekę GLEW
fprintf(stderr, "Nie można zainicjować GLEW.\n");
exit(EXIT_FAILURE);
}
initOpenGLProgram(window); //Operacje inicjujące
float angle = 0;
glfwSetTime(0);
//Główna pętla
int przel = 0;
while (!glfwWindowShouldClose(window)) //Tak długo jak okno nie powinno zostać zamknięte
{
if (!przel and angle > glm::radians(50.0f))
{
przel = 1;
}
if (przel and angle<=0)
{
przel = 0;
}
if (przel)
{
angle -= speed * glfwGetTime();
}
else
{
angle += speed * glfwGetTime();
}
glfwSetTime(0);
drawScene(window, angle); //Wykonaj procedurę rysującą
glfwPollEvents(); //Wykonaj procedury callback w zalezności od zdarzeń jakie zaszły.
}
freeOpenGLProgram(window);
glfwDestroyWindow(window); //Usuń kontekst OpenGL i okno
glfwTerminate(); //Zwolnij zasoby zajęte przez GLFW
exit(EXIT_SUCCESS);
}Editor is loading...