void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, GL_TRUE);
if(action == GLFW_PRESS)
actionPress = GLFW_PRESS;
else if(action == GLFW_RELEASE)
actionPress = 0;
if (key == GLFW_KEY_W && action == GLFW_PRESS){
keys = GLFW_KEY_W;
doMovement();
}
if (key == GLFW_KEY_S && action == GLFW_PRESS){
keys = GLFW_KEY_S;
doMovement();
}
if (key == GLFW_KEY_A && action == GLFW_PRESS){
keys = GLFW_KEY_A;
doMovement();
}
if (key == GLFW_KEY_D && action == GLFW_PRESS){
keys = GLFW_KEY_D;
doMovement();
}
if(action == GLFW_RELEASE)
keys = 0;
if (key == GLFW_KEY_R && action == GLFW_PRESS){
if(stopRotation == 0)
stopRotation = 1;
else
stopRotation = 0;
}
}
void AMobileEnemy::Tick(float DeltaSeconds) {
DeltaSeconds = TimeManager::Instance()->GetDeltaTime(DeltaSeconds);
m_lastPosition = GetActorLocation();
m_nextPosition = m_lastPosition;
EnemyAnimationMesh->bPauseAnims = TimeManager::Instance()->IsPaused();
if (!m_player) {
for (TActorIterator< APawn > ActorItr(GetWorld()); ActorItr; ++ActorItr) {
if (ActorItr->ActorHasTag("Player")) {
m_player = (APlayerOvi*)*ActorItr;
m_jumpSpeed = m_player->JumpSpeed;
m_accelerationJump = m_player->AccelerationJump;
break;
}
}
}
m_tickCounter++;
if (!HasTrigger || (HasTrigger && m_initMovement)) {
CheckCollision();
doMovement(DeltaSeconds);
CalculateGravity(DeltaSeconds);
CheckCollision();
SetActorLocation(m_nextPosition);
}
}
extern "C" __declspec(dllexport) void DoStep(StepInfo* _stepInfo)
{
this_step_info = _stepInfo;
me = getMyself();
if (this_step_info->stepNumber == 1)
{
closest_charge = getClosestEnStation();
doMovement(closest_charge);
}
else
if (me.x == closest_charge.first && me.y == closest_charge.second) //still not reached
{
doAttackAttempt();
}
else
{
doMovement(closest_charge);
}
}
void AMobilePlatform::Tick(float DeltaSeconds) {
DeltaSeconds = TimeManager::Instance()->GetDeltaTime(DeltaSeconds);
Super::Tick(DeltaSeconds);
if (Enabled) {
if (!m_player)
for (TActorIterator< APawn > ActorItr(GetWorld()); ActorItr; ++ActorItr)
if (ActorItr->ActorHasTag("Player")){
m_player = (APlayerOvi*)*ActorItr;
//break;
}
m_controlOff = false;
doMovement(DeltaSeconds);
if (m_player && m_isPlayerOn)
m_player->OnMobilePlatform(this, m_movement);
} else {
if (!m_controlOff) {
m_controlOff = true;
MobilePlatformMaterial->SetVectorParameterValue("Color", ColorDisabled); // I think this functions is worst than an 'if'
}
}
}
int main()
{
if( !initFrameworks() )
{
std::cout << "Failed to init frameworkd!" << std::endl;
}
initScene();
while( !glfwWindowShouldClose(window) )
{
glfwPollEvents();
doMovement();
render();
glfwSwapBuffers( window );
}
clean();
return 0;
}
void Game_Idle(void) {
List *l;
List *p;
int i;
int dt;
int t;
switch(game2->mode) {
case GAME_SINGLE:
#ifdef RECORD
case GAME_SINGLE_RECORD:
#endif
/* check for fast finish */
if (gSettingsCache.fast_finish == 1) {
int factors[4] = { 4, 6, 12, 25 };
int threshold[4] = { 0, 300, 600, 800 };
int factor = 1;
for(i = 0; i < 4; i++) {
if(game2->rules.grid_size > threshold[i])
factor = factors[i];
}
for (i = 0; i < game->players; i++) {
if (game->player[i].ai->active != AI_COMPUTER &&
gPlayerVisuals[i].exp_radius < EXP_RADIUS_MAX) {
factor = 1;
}
}
dt = game2->time.dt * factor;
} else {
dt = game2->time.dt;
}
while(dt > 0) {
if(dt > PHYSICS_RATE) t = PHYSICS_RATE;
else t = dt;
/* run AI */
for(i = 0; i < game->players; i++)
if(game->player[i].ai != NULL)
if(game->player[i].ai->active == AI_COMPUTER &&
PLAYER_IS_ACTIVE(&game->player[i])) {
doComputer(i, 0);
}
/* process any outstanding events (turns, etc) */
for(p = &(game2->events); p->next != NULL; p = p->next) {
if(processEvent((GameEvent*) p->data)) return;
}
/* free events */
p = game2->events.next;
while(p != NULL) {
l = p;
p = p->next;
free(l);
}
game2->events.next = NULL;
l = doMovement(1, t); /* this can generate new events */
if(l != NULL) {
for(p = l; p->next != NULL; p = p->next) {
if(processEvent((GameEvent*) p->data));
}
}
/* free list */
p = l;
while(p != NULL) {
l = p;
p = p->next;
free(l);
}
dt -= PHYSICS_RATE;
}
break;
#ifdef RECORD
case GAME_PLAY_NETWORK:
/* fall through to GAME_PLAY */
case GAME_PLAY:
getEvents();
l = doMovement(0, game2->time.dt); /* this won't generate new events */
if(l != NULL) {
fprintf(stderr, "something is seriously wrong - ignoring events\n");
}
break;
#endif /* RECORD */
}
doCameraMovement();
doRecognizerMovement();
}
/*! The mouseMove is called by the viewer when the mouse is moved in the
viewer and this handle is the active one.
\param x the x-pos of the mouse (pixel)
\param y the y-pos of the mouse (pixel)
*/
void Manipulator::mouseMove(const Int16 x,
const Int16 y)
{
//SLOG << "Manipulator::mouseMove() enter\n" << std::flush;
// get the beacon's core (must be ComponentTransform) and it's center
if( getTarget() != NULL )
{
// get transformation of beacon
Transform *t = dynamic_cast<Transform *>(getTarget()->getCore());
if( t != NULL )
{
UInt16 coord(0); // active coordinate: X=0, Y=1, Z=2
Int16 xDiff; // the mousepos x delta
Int16 yDiff; // the mousepos y delta
Vec3f centerV; // center of beacon
Vec3f handleCenterV; // center of subhandle
Vec2f mouseScreenV; // mouse move vector
Vec2f handleScreenV; // handle vec in (cc)
Real32 handleScreenVLen; // len of handle vec in (cc)
Vec3f translation; // for matrix decomposition
Quaternion rotation;
Vec3f scaleFactor;
Quaternion scaleOrientation;
// TODO: das ist ja schon ein wenig haesslich
static const Vec3f coordVector[3] = {
Vec3f(1.0f, 0.0f, 0.0f),
Vec3f(0.0f, 1.0f, 0.0f),
Vec3f(0.0f, 0.0f, 1.0f)
};
// check for the active handle
if( getActiveSubHandle() == getHandleXNode())
{
coord = 0;
}
else if(getActiveSubHandle() == getHandleYNode())
{
coord = 1;
}
else if(getActiveSubHandle() == getHandleZNode())
{
coord = 2;
}
// TODO: only for debugging, -> FDEBUG
//SLOG << "moving " << ( coord == 0 ? "x\n" :
// coord == 1 ? "y\n" :
// "z\n" )
// << std::flush;
// calculate diffs between current and last mouse position
xDiff = x - Int16(getLastMousePos()[0]);
yDiff = y - Int16(getLastMousePos()[1]);
// set the vector resulting from user mouse movement and calc its length
mouseScreenV.setValues(xDiff, -yDiff);
t->getMatrix().getTransform(translation, rotation, scaleFactor,
scaleOrientation);
// calculate the camera coordinate of the center
centerV = translation;
Pnt2f centerPixPos = calcScreenProjection(centerV.addToZero(),
getViewport());
// calculate the camera coordinate of the handle center
handleCenterV = centerV + coordVector[coord]*getLength()[coord];
Pnt2f handleCenterPixPos = calcScreenProjection(handleCenterV.addToZero(),
getViewport());
handleScreenV = handleCenterPixPos - centerPixPos;
handleScreenVLen = handleScreenV.length();
Real32 s = handleScreenV.dot(mouseScreenV) / handleScreenVLen;
doMovement(t, coord, s * getLength()[coord] * 0.01, translation,
rotation, scaleFactor, scaleOrientation);
}
else
{
SWARNING << "handled object has no parent transform!\n";
}
callExternalUpdateHandler();
}
else
{
SWARNING << "Handle has no target.\n";
}
setLastMousePos(Pnt2f(Real32(x), Real32(y)));
updateHandleTransform();
//SLOG << "Manipulator::mouseMove() leave\n" << std::flush;
}
void idleGame( void ) {
list *l;
list *p;
int i;
int dt;
int t;
#ifdef SOUND
// Audio_Idle();
soundIdle();
#endif
if(updateTime() == 0) return;
switch(game2->mode) {
case GAME_NETWORK_RECORD:
#ifdef NETWORK
updateNet();
#endif
/* fall through */
case GAME_SINGLE:
case GAME_SINGLE_RECORD:
/* check for fast finish */
if(game->settings->fast_finish == 1) {
int factor = 4;
for(i = 0; i < game->players; i++) {
if(game->player[i].ai->active != 1 &&
game->player[i].data->exp_radius < EXP_RADIUS_MAX)
factor = 1;
}
dt = game2->time.dt * factor;
} else
dt = game2->time.dt;
while(dt > 0) {
if(dt > PHYSICS_RATE) t = PHYSICS_RATE;
else t = dt;
/* run AI */
for(i = 0; i < game->players; i++)
if(game->player[i].ai != NULL)
if(game->player[i].ai->active == 1 &&
game->player[i].data->speed > 0) {
if(game->settings->ai_level < 2)
doComputer(i, 0);
else
doComputer2(i, 0);
}
/* process any outstanding events (turns, etc) */
for(p = &(game2->events); p->next != NULL; p = p->next) {
if(processEvent((GameEvent*) p->data)) return;
}
/* free events */
p = game2->events.next;
while(p != NULL) {
l = p;
p = p->next;
free(l);
}
game2->events.next = NULL;
l = doMovement(1, t); /* this can generate new events */
if(l != NULL) {
for(p = l; p->next != NULL; p = p->next) {
if(processEvent((GameEvent*) p->data));
}
}
/* free list */
p = l;
while(p != NULL) {
l = p;
p = p->next;
free(l);
}
dt -= PHYSICS_RATE;
}
break;
case GAME_PLAY_NETWORK:
#ifdef NETWORK
updateNet();
/* broadCast any outstanding events (turns, etc) */
for(p = &(game2->events); p->next != NULL; p = p->next) {
sendNetEvent((GameEvent*) p->data);
}
#endif
/* fall through to GAME_PLAY */
case GAME_PLAY:
getEvents();
l = doMovement(0, game2->time.dt); /* this won't generate new events */
if(l != NULL) {
fprintf(stderr, "something is seriously wrong - ignoring events\n");
}
break;
}
doCameraMovement();
recognizerMovement();
SystemPostRedisplay();
/* fprintf(stderr, "game time: %.3f\n", game2->time.current / 1000.0); */
}
int main()
{
EinApplication::setErrorCallback(onError);
EinApplication *app = new EinApplication();
EinWindow* window = new EinWindow(WIN_WIDTH, WIN_HEIGHT, "cgBentRendering", false);
Camera* mainCamera = new Camera(glm::vec3(0.0f, 0.0f, 3.0f));
GLfloat quadVertices[] = { // Vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
// Positions // TexCoords
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.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
};
// Setup screenQuad VAO
GLuint quadVAO, quadVBO;
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat)));
glBindVertexArray(0);
Shader modelGbuffer("shaders/modelGbuffer.vert", "shaders/modelGbuffer.frag");
modelGbuffer.Link();
// Shader bentNormalsShader("shaders/quad.vert", "shaders/bent_normals.frag");
// bentNormalsShader.Link();
// // algorithm params
// Params params;
// params.sampleRadius = 1.0f;
// params.maxDistance = params.sampleRadius * 1.6f;
// params.numRayMarchingSteps = 3;
// params.patternSize = 8;
// params.sampleCount = 8;
// params.rayMarchingBias = params.sampleRadius / float(params.numRayMarchingSteps) / 1000.0f;
//
// glUniform1f(glGetUniformLocation(bentNormalsShader.Program, "sampleRadius"), params.sampleRadius);
// glUniform1f(glGetUniformLocation(bentNormalsShader.Program, "maxDistance"), params.maxDistance);
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "patternSize"), params.patternSize);
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "sampleCount"), params.sampleCount);
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "numRayMarchingSteps"), params.numRayMarchingSteps);
//
// int kernelSize = 32;
// glm::vec3 *kernel = new glm::vec3[kernelSize];
// srandTimeSeed();
// for (int i = 0; i < kernelSize; i++) {
// kernel[i] = glm::vec3(
// randMToN(-1.0f, 1.0f),
// randMToN(-1.0f, 1.0f),
// randMToN(0.0f, 1.0f));
// kernel[i] = glm::normalize(kernel[i]);
//
// float scale = (float)i / (float)kernelSize;
// kernel[i] *= lerp(0.1f, 1.0f, scale * scale);
// }
//
// for (int i = 0; i< kernelSize; i++) {
// std::cerr << kernel[i].x << " " << kernel[i].y << " " << kernel[i].z << std::endl;
// }
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "uKernelSize"), kernelSize);
// glUniform3fv(glGetUniformLocation(bentNormalsShader.Program, "uKernelOffsets"), kernelSize, (const GLfloat*)glm::value_ptr(kernel[0]));
//
// int ssaoNoiseSize = 8;
// int noiseDataSize = ssaoNoiseSize * ssaoNoiseSize;
// glm::vec3 *noiseData = new glm::vec3[noiseDataSize];
// srandTimeSeed();
// for (int i = 0; i < noiseDataSize; i++) {
// noiseData[i] = glm::vec3(
// randMToN(-1.0f, 1.0f),
// randMToN(-1.0f, 1.0f),
// 0.0f);
// noiseData[i] = glm::normalize(noiseData[i]);
// }
// Texture noiseTex;
//
// noiseTex.Bind();
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ssaoNoiseSize, ssaoNoiseSize, 0, GL_RGB, GL_FLOAT, noiseData);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// noiseTex.Unbind();
Shader lightingShader("shaders/quad.vert", "shaders/lighting.frag");
lightingShader.Link();
Shader simpleShader("shaders/simple.vert", "shaders/simple.frag");
simpleShader.Link();
// Load models
Model demonHeadModel("models/bake/monkeyright.obj");
Texture bentNormalsTexture("models/bake/nice_bent_normals.png", GL_REPEAT, GL_REPEAT, GL_NEAREST, GL_NEAREST);
// Setup gBuffer
Framebuffer *gBuffer = new Framebuffer();
gBuffer->BindFb();
gBuffer->addTextureAttachment(TexAttachmentType::DEPTH, window->GetFramebufferSize());
gBuffer->addTextureAttachment(TexAttachmentType::RGBA, window->GetFramebufferSize(), "position");
gBuffer->addTextureAttachment(TexAttachmentType::RGB, window->GetFramebufferSize(), "normal");
gBuffer->addTextureAttachment(TexAttachmentType::RGB, window->GetFramebufferSize(), "bentNormal");
gBuffer->addTextureAttachment(TexAttachmentType::RGB, window->GetFramebufferSize(), "color");
gBuffer->setupMRT();
if(!gBuffer->isReady())
std::cerr << "Gbuffer incomplete" << std::endl;
gBuffer->UnbindFb();
// Get textures from gBuffer
Texture depthTex = gBuffer->getTextureAttachment(DEPTH);
Texture positionTex = gBuffer->getTextureAttachment("position");
Texture normalTex = gBuffer->getTextureAttachment("normal");
Texture bentNormalsTex = gBuffer->getTextureAttachment("bentNormal");
Texture colorTex = gBuffer->getTextureAttachment("color");
// // Setup bent_normalsBuffer
// Framebuffer *bentNormalsBuffer = new Framebuffer();
// bentNormalsBuffer->BindFb();
// bentNormalsBuffer->addTextureAttachment(TexAttachmentType::RGBA, window->GetFramebufferSize(), "bent_normals");
// if(!bentNormalsBuffer->isReady())
// std::cerr << "Bent normals buffer incomplete" << std::endl;
// bentNormalsBuffer->UnbindFb();
// // Get bent normals texture
// Texture bentNormalsTex = bentNormalsBuffer->getTextureAttachment("bent_normals");
bool useBentNormals = false;
float bentNormalsInfluence = 0.3f;
EinInputManager *inputManager = window->GetInputManager();
while(!window->ShouldClose())
{
// Set frame time
GLfloat currentFrame = app->GetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Pool events
inputManager->pollEvents();
if(inputManager->isExit(KeyActionType::KEY_UP)) {
window->SetShouldClose(true);
}
if(inputManager->isKey(GLFW_KEY_T, KeyActionType::KEY_UP)) {
if (useBentNormals)
useBentNormals = false;
else
useBentNormals = true;
}
if(inputManager->isKey(GLFW_KEY_Y, KeyActionType::KEY_DOWN)) {
bentNormalsInfluence -= 0.01f;
if(bentNormalsInfluence < 0.0f)
bentNormalsInfluence = 0.0f;
}
if(inputManager->isKey(GLFW_KEY_U, KeyActionType::KEY_DOWN)) {
bentNormalsInfluence += 0.01f;
if(bentNormalsInfluence > 1.0f)
bentNormalsInfluence = 1.0f;
}
// Handle camera movements
doMovement(window->GetInputManager(), mainCamera);
// Bind gBuffer
gBuffer->BindFb();
// Setup OpenGL options
// Clear the screen to black
glEnable(GL_DEPTH_TEST);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Activate shader
modelGbuffer.Use();
// Create transformations
glm::mat4 view = mainCamera->GetViewMatrix();
glm::mat4 projection = glm::perspective(mainCamera->zoomQuantity, (float)(window->GetWindowSize().width)/(float)(window->GetWindowSize().height), 0.1f, 10.0f);
glm::mat4 model;
// model = glm::rotate(model, -90.0f, glm::vec3(1.0, 0.0, 0.0));
// Get the uniform locations
GLint modelLoc = glGetUniformLocation(modelGbuffer.Program, "model");
GLint viewLoc = glGetUniformLocation(modelGbuffer.Program, "view");
GLint projLoc = glGetUniformLocation(modelGbuffer.Program, "projection");
// Pass the matrices to the shader
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glActiveTexture(GL_TEXTURE0);
bentNormalsTexture.Bind();
glUniform1i(glGetUniformLocation(modelGbuffer.Program, "normalMap"), 0);
demonHeadModel.Draw(modelGbuffer);
gBuffer->UnbindFb();
// bentNormalsBuffer->BindFb();
// glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// glClear(GL_COLOR_BUFFER_BIT);
// glDisable(GL_DEPTH_TEST);
//
// bentNormalsShader.Use();
// glBindVertexArray(quadVAO);
// GLint viewMatrixLoc = glGetUniformLocation(bentNormalsShader.Program, "viewMatrix");
// GLint viewProjectionMatrixLoc = glGetUniformLocation(bentNormalsShader.Program, "projectionMatrix");
// // Pass the matrices to the shader
// glUniformMatrix4fv(viewMatrixLoc, 1, GL_FALSE, glm::value_ptr(view));
// glUniformMatrix4fv(viewProjectionMatrixLoc, 1, GL_FALSE, glm::value_ptr(projection));
//
// glActiveTexture(GL_TEXTURE0);
// positionTex.Bind();
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "positionTexture"), 0);
//
// glActiveTexture(GL_TEXTURE1);
// normalTex.Bind();
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "normalTexture"), 1);
//
// glActiveTexture(GL_TEXTURE2);
// depthTex.Bind();
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "depthTexture"), 2);
//
// glActiveTexture(GL_TEXTURE3);
// noiseTex.Bind();
// glUniform1i(glGetUniformLocation(bentNormalsShader.Program, "uNoiseTex"), 3);
// glDrawArrays(GL_TRIANGLES, 0, 6);
// glBindVertexArray(0);
// bentNormalsBuffer->UnbindFb();
// Activate shader
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
lightingShader.Use();
glBindVertexArray(quadVAO);
glActiveTexture(GL_TEXTURE0);
positionTex.Bind();
glUniform1i(glGetUniformLocation(lightingShader.Program, "tPosition"), 0);
glActiveTexture(GL_TEXTURE1);
normalTex.Bind();
glUniform1i(glGetUniformLocation(lightingShader.Program, "tNormals"), 1);
glActiveTexture(GL_TEXTURE2);
colorTex.Bind();
glUniform1i(glGetUniformLocation(lightingShader.Program, "tDiffuse"), 2);
glActiveTexture(GL_TEXTURE3);
bentNormalsTex.Bind();
glUniform1i(glGetUniformLocation(lightingShader.Program, "tBentNormals"), 3);
GLint lightPosLoc = glGetUniformLocation(lightingShader.Program, "lightPos");
GLint viewerPosLoc = glGetUniformLocation(lightingShader.Program, "viewerPos");
glUniform3f(viewerPosLoc, mainCamera->position.x, mainCamera->position.y, mainCamera->position.z);
glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
glUniform1i(glGetUniformLocation(lightingShader.Program, "useBentNormals"), useBentNormals);
glUniform1f(glGetUniformLocation(lightingShader.Program, "bentNormalsInfluence"), bentNormalsInfluence);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
// Swap screen buffer
window->SwapBuffers();
showFPS(window);
}
// Clean up resources
lightingShader.Delete();
modelGbuffer.Delete();
glDeleteVertexArrays(1, &quadVAO);
delete window;
delete mainCamera;
delete app;
}
int main(int argc, char *argv[])
{
chdir("/Users/tjgreen/Documents/OpenGL/Sol");
GLFWwindow *window = setupGLFW();
GLuint skyboxTexture = initCubemap();
//GLFWwindow* window2 = glfwCreateWindow(500, 500, "SolarSystem", NULL, NULL);
//glfwMakeContextCurrent(window2);
/*Cross platform compatibility stuff uncomment if not on mac
GLenum err = glewInit();
if (GLEW_OK != err)
{
printf(stderr, "Error: %s\n", glewGetErrorString(err));
}*/
sunTexture = loadTexture("include/textures/Planets/sun2.jpg");
sunNormal = loadTexture("include/textures/Planets/sunNormal.png");
planetBuilder();
init();
createPerspectiveMatrix();
initializePlanetButtons();
glEnable(GL_CULL_FACE);
glEnable(GL_MULTISAMPLE);
glCullFace(GL_BACK);
attachGUIShaders();
float fpsFrames= 0;
float lastTime = 0;
while(!glfwWindowShouldClose(window))
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
fpsFrames++;
if(currentFrame - lastTime >= 1.0)
{
//printf("%f\n", 1000/fpsFrames);
fpsFrames = 0;
lastTime += 1.0;
}
glfwPollEvents();
doMovement();
glfwPollEvents();
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, WIDTH, HEIGHT);
drawSkybox(skyboxTexture);
drawSun();
drawPlanet();
//glFrontFace(GL_CW);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
drawAtmosphere();
glDisable(GL_BLEND);
//glFrontFace(GL_CCW);
drawObj();
drawMoon();
//drawButton(button1);
//drawPlanetButtons();
if(stopRotation == 0){
for(int i = 0; i < 11; i++)
{
orbitSpeedArray[i] += 0.1/planetInstanceArray[i].orbit;
}
for(int i = 0; i < 11; i++)
{
rotationSpeedArray[i] += 0.1/planetInstanceArray[i].day;
}
thetaY += 0.1;
}
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &planetVAO);
glDeleteBuffers(1, &planetVBO);
glfwTerminate();
return 0;
}
int main()
{
glfwInit();
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);
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
if (window == nullptr)
{
std::cout << "Failed to Create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, key_callback);
//register mouse callback function
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetCursorPosCallback(window, mouse_callback);
//scroll callback function
glfwSetScrollCallback(window, scroll_callback);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
std::cout << "Failed to initialize GLEW" << std::endl;
return -1;
}
glViewport(0, 0, WIDTH, HEIGHT);
Shader shader = Shader("shaders\\vertexShader.vshader", "shaders\\fragment.fshader");
//deal with vertices
GLfloat vertices1[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f
};
/*
//vertices //texture coords
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f
0.55f, 0.55f,
0.55f, 0.45f,
0.45f, 0.45f,
0.45f, 0.55f
*/
GLuint indices[] = {
0,1,3,
1,2,3
};
/* */
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);
/*
*/
GLuint EBO;
glGenBuffers(1, &EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //**** MUST NOT have this line!!! ****
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
/*
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
*/
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
//unbind VBO VAO
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
//Load Texture
GLint width, height;
unsigned char* image = SOIL_load_image("src/container.jpg", &width, &height, 0, SOIL_LOAD_RGB);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
GLuint texture_2;
glGenTextures(1, &texture_2);
glBindTexture(GL_TEXTURE_2D, texture_2);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
image = SOIL_load_image("src/awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
glEnable(GL_DEPTH_TEST);
//cube location arrays
glm::vec3 cubePositions[] = {
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3(2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3(1.3f, -2.0f, -2.5f),
glm::vec3(1.5f, 2.0f, -2.5f),
glm::vec3(1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
while (!glfwWindowShouldClose(window))
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastTime;
lastTime = currentFrame;
glfwPollEvents();
doMovement();
//rendering command
glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
shader.Use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
GLuint textLocation = glGetUniformLocation(shader.ProgramID, "ourTexture");
glUniform1i(textLocation, 0);
/*
*/
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture_2);
textLocation = glGetUniformLocation(shader.ProgramID, "ourTexture2");
glUniform1i(textLocation, 1);
glUniform1f(glGetUniformLocation(shader.ProgramID, "mixrate"), g_mixrate);
/*
*/
glBindVertexArray(VAO);
for (int i = 0; i < 10; ++i)
{
glm::mat4 model, view, projection;
model = glm::translate(model, cubePositions[i]);
GLfloat angle = 20.0f * i;
if (i % 3 == 0){
angle *= glfwGetTime();
}
model = glm::rotate(model, glm::radians(angle), glm::vec3(0.5f, 1.0f, 0.0f));
view = camera.GetViewMatrix();
projection = glm::perspective(camera.Zoom, (float)WIDTH / (float)HEIGHT, 0.1f, 100.0f);
glUniformMatrix4fv(glGetUniformLocation(shader.ProgramID, "model"), 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(glGetUniformLocation(shader.ProgramID, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shader.ProgramID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
//glDrawArrays(GL_TRIANGLES, 0, 3);
//swap buffer avoid flert-prob
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glfwTerminate();
return 0;
}
//----------------------------------------------------------------------------------------------------------------------
void NGLDraw::doSelection(const int _x, const int _y)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int numberOfSquads = m_gameworld->getSquads().size();
for(int i=0; i < numberOfSquads; i++)
{
Squad* currentSquad = m_gameworld->getSquads()[i];
currentSquad->selectionDraw(m_cam, m_mouseGlobalTX);
currentSquad->setSquadDrawColour(currentSquad->getSquadColour());
}
ngl::Vec3 pixel;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
glReadPixels(_x, viewport[3] - _y , 1, 1, GL_RGB, GL_FLOAT, &pixel);
bool newSelection = false;
for(int i=0; i < numberOfSquads; i++)
{
Squad* currentSquad = m_gameworld->getSquads()[i];
if(currentSquad->checkSelectionColour(pixel) == true)
{
currentSquad->setSquadDrawColour(currentSquad->getSquadSelectedColour());
//set selected squad colour
if(m_selected == true)
{
m_selected = true;
m_selectedSquad = currentSquad;
m_selectedSquadID = currentSquad->getID();
newSelection = true;
break;
}
else
{
m_selected = true;
m_selectedSquad = currentSquad;
m_selectedSquadID = currentSquad->getID();
newSelection = true;
break;
}
}
}
if(newSelection == false && m_selected == true)
{
doMovement(_x, _y);
m_selected = false;
m_selectedSquad= NULL;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
int main()
{
std::cout << "Starting GLFW context, OpenGL 3.3.." << std::endl;
if (!glfwInit())
{
std::cout << "Failed to initialize GLFW" << std::endl;
return -1;
}
glfwWindowHint(GLFW_SAMPLES, 4);
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);
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "Tutorial", NULL, NULL);
if (window == NULL)
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glViewport(0, 0, WIDTH, HEIGHT);
glEnable(GL_DEPTH_TEST);
glfwSetKeyCallback(window, keyCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwSetScrollCallback(window, scrollCallback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
//--------------------
glewExperimental = true; // So GLEW uses more modern techniques for managing OpenGL functionality.
if (glewInit() != GLEW_OK)
{
fprintf(stderr, "Failed to initialize GLEW!\n");
return -1;
}
Shader ourShader("VertexShader.txt", "FragmentShader.txt");
Shader lightShader("LampVertexShader.txt", "LampFragmentShader.txt");
//--------------------
GLfloat vertices[] = {
// Positions // Normals // Texture Coords
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
GLfloat lampVertices[] = {
-0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, 0.5f, -0.5f,
0.5f, 0.5f, -0.5f,
-0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, -0.5f,
-0.5f, 0.5f, -0.5f,
0.5f, 0.5f, -0.5f,
0.5f, 0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, -0.5f
};
//glm::vec3 cubePositions[] = {
// glm::vec3(0.0f, 0.0f, 0.0f),
// glm::vec3(2.0f, 5.0f, -5.0f),
// glm::vec3(-1.5f, -2.2f, -2.5f),
// glm::vec3(-3.8f, -2.0f, 6.3f),
// glm::vec3(2.4f, -0.4f, 3.5f),
// glm::vec3(-1.7f, 3.0f, -7.5f),
// glm::vec3(1.3f, -2.0f, 2.5f),
// glm::vec3(1.5f, 2.0f, -2.5f),
// glm::vec3(1.5f, 0.2f, 1.5f),
// glm::vec3(-1.3f, 1.0f, -1.5f)
//};
glm::vec3 cubePositions[] = {
glm::vec3(-12.0f, 0.0f, 0.0f),
glm::vec3(-10.0f, 0.0f, 0.0f),
glm::vec3(-8.0f, 0.0f, 0.0f),
glm::vec3(-6.0f, 0.0f, 0.0f),
glm::vec3(-4.0f, 0.0f, 0.0f),
glm::vec3(-2.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(2.0f, 0.0f, 0.0f),
glm::vec3(4.0f, 0.0f, 0.0f),
glm::vec3(6.0f, 0.0f, 0.0f),
};
GLuint vertexBufferObject, vertexArrayObject, elementBufferObject;
glGenVertexArrays(1, &vertexArrayObject);
glGenBuffers(1, &vertexBufferObject);
glBindVertexArray(vertexArrayObject);
glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Position attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
// Normal vectors
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*) (3*sizeof(GLfloat)));
glEnableVertexAttribArray(1);
// Texture coordinate attribute
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
// Color attribute
//glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
//glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
//-------------------- COLOR
GLuint lightVAO, lightVBO;
glGenVertexArrays(1, &lightVAO);
glGenBuffers(1, &lightVBO);
glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(lampVertices), lampVertices, GL_STATIC_DRAW);
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
//-------------------- TEXTURE
std::vector<unsigned char> file;
std::vector<unsigned char> pixels;
GLuint width, height;
GLuint diffuseMap;
glGenTextures(1, &diffuseMap);
glBindTexture(GL_TEXTURE_2D, diffuseMap); // All upcoming GL_TEXTURE_2D operations now have effect on this texture object
// Set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT (usually basic wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load image, create texture and generate mipmaps
lodepng::load_file(file, "container2.png");
lodepng::decode(pixels, width, height, file.data(), file.size());
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture when done, so we won't accidentily mess up our texture.
//--------------------
GLuint specularMap;
file.clear();
pixels.clear();
glGenTextures(1, &specularMap);
glBindTexture(GL_TEXTURE_2D, specularMap);
lodepng::load_file(file, "container2_specular2.png");
lodepng::decode(pixels, width, height, file.data(), file.size());
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
//--------------------
do
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glfwPollEvents();
doMovement();
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lightPos.x = 1.0f + sin(glfwGetTime()) * 6.0f;
lightPos.y = cos(glfwGetTime() / 2.0f) * 1.0f;
//--------------------
ourShader.Use();
GLint lightColorLoc = glGetUniformLocation(ourShader.Program, "lightColor");
GLint lightPosLoc = glGetUniformLocation(ourShader.Program, "light.position");
GLint viewPosLoc = glGetUniformLocation(ourShader.Program, "viewPos");
glUniform3f(lightColorLoc, 1.0f, 0.5f, 1.0f);
glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
//----------
//GLint matAmbientLoc = glGetUniformLocation(ourShader.Program, "material.ambient");
//GLint matDiffuseLoc = glGetUniformLocation(ourShader.Program, "material.diffuse");
//GLint matSpecularLoc = glGetUniformLocation(ourShader.Program, "material.specular");
GLint matShineLoc = glGetUniformLocation(ourShader.Program, "material.shininess");
//glUniform3f(matAmbientLoc, 0.19225f, 0.19225f, 0.19225f);
//glUniform3f(matDiffuseLoc, 0.50754f, 0.50754f, 0.50754f);
glUniform1i(glGetUniformLocation(ourShader.Program, "material.diffuse"), 0);
//glUniform3f(matSpecularLoc, 0.8f, 0.8f, 0.8f);
glUniform1i(glGetUniformLocation(ourShader.Program, "material.specular"), 1);
glUniform1f(matShineLoc, 128.0f * 0.2f);
//----------
glm::vec3 lightColor;
lightColor.x = sin(glfwGetTime() * 2.0f);
lightColor.y = sin(glfwGetTime() * 0.7f);
lightColor.z = sin(glfwGetTime() * 1.3f);
glm::vec3 diffuseColor = lightColor * glm::vec3(1.0f);
glm::vec3 ambientColor = diffuseColor * glm::vec3(1.0f);
GLint lightAmbientLoc = glGetUniformLocation(ourShader.Program, "light.ambient");
GLint lightDiffuseLoc = glGetUniformLocation(ourShader.Program, "light.diffuse");
GLint lightSpecularLoc = glGetUniformLocation(ourShader.Program, "light.specular");
//glUniform3f(lightAmbientLoc, ambientColor.x, ambientColor.y, ambientColor.z);
//glUniform3f(lightDiffuseLoc, diffuseColor.x, diffuseColor.y, diffuseColor.z);
glUniform3f(lightAmbientLoc, 0.3f, 0.3f, 0.3f);
glUniform3f(lightDiffuseLoc, 1.0f, 1.0f, 1.0f);
glUniform3f(lightSpecularLoc, 1.0f, 1.0f, 1.0f);
//--------------------
glm::mat4 view;
view = camera.GetViewMatrix();
glm::mat4 projection;
projection = glm::perspective(glm::radians(camera.Zoom), (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
GLint viewLoc = glGetUniformLocation(ourShader.Program, "view");
GLint projLoc = glGetUniformLocation(ourShader.Program, "projection");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture1"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);
/*GLfloat timeValue = glfwGetTime();
GLfloat greenValue = (sin(timeValue) / 2) + 0.5;
GLint vertexColorLocation = glGetUniformLocation(ourShader.Program, "ourColor");
glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.4f, 1.0f);*/
glBindVertexArray(vertexArrayObject);
GLint modelLoc = glGetUniformLocation(ourShader.Program, "model");
for (GLuint i = 0; i < 10; i++)
{
glm::mat4 model;
model = glm::translate(model, cubePositions[i]);
GLfloat angle = 50.0f;
//model = glm::rotate(model, i * (GLfloat)sin(glfwGetTime() / 10.0f), glm::vec3(1.0f, 0.2f * i, i));
//model = glm::scale(model, glm::vec3(0.1f * i));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
lightShader.Use();
// Get location objects for the matrices on the lamp shader (these could be different on a different shader)
modelLoc = glGetUniformLocation(lightShader.Program, "model");
viewLoc = glGetUniformLocation(lightShader.Program, "view");
projLoc = glGetUniformLocation(lightShader.Program, "projection");
// Set matrices
glm::mat4 model;
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
model = glm::mat4();
model = glm::translate(model, lightPos);
model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
// Draw the light object (using light's vertex attributes)
glBindVertexArray(lightVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glfwSwapBuffers(window);
} while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS &&
glfwWindowShouldClose(window) == 0);
glfwTerminate();
return 0;
}
int main(){
//create widnow and context
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); //using open gl 3.3
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//idk what this does
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow * window = glfwCreateWindow(m_screenWidth, m_screenHeight, "OPEN GL LIGHTS", nullptr, nullptr);
if(window == nullptr){
std::cout << "failed to create GLFW window"<<std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK){
std::cout<< "failed to init GLEW"<<std::endl;
}
glViewport(0,0, m_screenWidth, m_screenHeight);
glEnable(GL_DEPTH_TEST);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
//shader init
Shader ourShader( "vertex_shader.vertex", "fragmentShader.fragment");
Shader lampShader( "lamp_vertex_shader.vertex", "lamp_fragment_shader.fragment");
//view spaces
m_camera = Camera();
projection = glm::perspective(m_aspect, m_screenWidth/m_screenHeight, 0.1f, 100.0f);
//create cube data
GLuint VAO;//remember to delete these
GLuint VBO;
createCube(&VAO, &VBO);
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
// We only need to bind to the VBO, the container's VBO's data already contains the correct data.
glBindBuffer(GL_ARRAY_BUFFER, VBO);
// Set the vertex attributes (only position data for our lamp)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (GLvoid*)0);//pos
glEnableVertexAttribArray(0);
glBindVertexArray(0);
//game loop
while(!glfwWindowShouldClose(window)){
glfwPollEvents();
glClearColor(0.2f, 0.2f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat currentFrame = glfwGetTime();
m_deltaTime = currentFrame - m_lastFrame;
m_lastFrame = currentFrame;
doMovement();
model = glm::mat4();
useShader(ourShader);
GLint viewPosLoc = glGetUniformLocation(*ourShader.getProgram(), "viewPos");
glUniform3f(viewPosLoc, m_camera.getPosition().x, m_camera.getPosition().y, m_camera.getPosition().z);
GLint lightPosLoc = glGetUniformLocation(*ourShader.getProgram(), "lightPos");
glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
GLint objectColorLoc = glGetUniformLocation(*ourShader.getProgram(), "objectColor");
GLint lightColorLoc = glGetUniformLocation(*ourShader.getProgram(), "lightColor");
glUniform3f(objectColorLoc, 1.0f, 0.5f, 0.31f);
glUniform3f(lightColorLoc, 1.0f, 1.0f, 1.0f);
glBindVertexArray(VAO);//use cube data
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);//stop using cube data
model = glm::mat4();
//model = glm::rotate(model, currentFrame * 50.0f, glm::vec3(0.0f, 0.0f, 1.0f));
lightPos.x = 1.0f + sin(glfwGetTime()) * 2.0f;
lightPos.y = sin(glfwGetTime() / 2.0f) * 1.0f;
model = glm::translate(model, lightPos);
model = glm::scale(model, glm::vec3(0.2f));
useShader(lampShader);
glBindVertexArray(lightVAO);//use lamp data
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);//stop using lamp data
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glfwTerminate();
return 0;
}
