SkysphereAspect::SkysphereAspect()
{
vertexBufferID = -1;
indexBufferID = -1;
amount = 0;
generateSphere();
}
void testApp::generateWireframe()
{
if (g_vertex_buffer_data != NULL)
delete[] g_vertex_buffer_data;
if (g_element_buffer_data != NULL)
delete[] g_element_buffer_data;
// TODO
switch (shape)
{
case SHAPE_PLANE:
generatePlane();
break;
case SHAPE_SPHERE:
generateSphere();
break;
case SHAPE_CYLINDER_X:
generateCylinderX();
break;
case SHAPE_CYLINDER_Y:
generateCylinderY();
break;
default:
cout << "ERROR: Invalid shape" << endl;
break;
}
}
void init() {
/*select clearing (background) color*/
glClearColor(1.0, 1.0, 1.0, 1.0);
//populate our arrays
spherevertcount = generateSphere(2, 10);
// Load shaders and use the resulting shader program
program1 = InitShader( "vshader-lighting.glsl", "fshader-lighting.glsl" );
program2 = InitShader( "vshader-phongshading.glsl", "fshader-phongshading.glsl" );
program3 = InitShader( "vshader-celshading.glsl", "fshader-celshading.glsl" );
// Create a vertex array object
glGenVertexArrays( 1, &vao[0] );
// Create and initialize any buffer objects
glBindVertexArray( vao[0] );
glGenBuffers( 2, &vbo[0] );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, spherevertcount*sizeof(vec4), sphere_verts, GL_STATIC_DRAW);
//and now our colors for each vertex
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, spherevertcount*sizeof(vec3), sphere_normals, GL_STATIC_DRAW );
setupShader(program1);
//Only draw the things in the front layer
glEnable(GL_DEPTH_TEST);
}
Sphere::Sphere(const D3DXVECTOR3& position, int level, float radius, uint32_t color, bool randomColor, IDirect3DDevice9 *d3dDevice, IDirect3DVertexShader9 *shader):
Object(d3dDevice), m_vertexBuffer(0), m_indexBuffer(0), m_shader(shader), m_morphTime(0)
{
uint16_t *indices;
Vertex *vertices;
m_timeVector[0] = 0.0f; m_timeVector[1] = 0.0f; m_timeVector[2] = 0.0f; m_timeVector[3] = 0.0f;
generateSphere(level, color, randomColor, &indices, &vertices, m_indexCount, m_vertexCount);
for(unsigned int i = 0; i < m_vertexCount; i++)
{
float length = sqrt(vertices[i].x * vertices[i].x + vertices[i].y * vertices[i].y + vertices[i].z * vertices[i].z);
vertices[i].nx = vertices[i].x / length;
vertices[i].ny = vertices[i].y / length;
vertices[i].nz = vertices[i].z / length;
vertices[i].x = vertices[i].x / length * radius;
vertices[i].y = vertices[i].y / length * radius;
vertices[i].z = vertices[i].z / length * radius;
}
if(0 != m_d3dDevice)
{
if(!FAILED(m_d3dDevice->CreateVertexBuffer(m_vertexCount * sizeof(Vertex), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_vertexBuffer, 0)))
{
void *vertexPointer;
if(!FAILED(m_vertexBuffer->Lock(0, m_vertexCount * sizeof(Vertex), (void**)&vertexPointer, 0)))
{
memcpy(vertexPointer, vertices, m_vertexCount * sizeof(Vertex));
}
if(FAILED(m_vertexBuffer->Unlock()))
{
m_vertexBuffer = 0;
}
}
if(!FAILED(m_d3dDevice->CreateIndexBuffer(m_indexCount * sizeof(uint16_t), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_indexBuffer, 0)))
{
void *indexPointer;
if(!FAILED(m_indexBuffer->Lock(0, m_indexCount * sizeof(uint16_t), (void**)&indexPointer, 0)))
{
memcpy(indexPointer, indices, m_indexCount * sizeof(uint16_t));
}
if(FAILED(m_indexBuffer->Unlock()))
{
m_indexBuffer = 0;
}
}
}
setColor(color);
delete[] indices;
delete[] vertices;
setPosition(position);
}
// Performs most of the OpenGL intialization -- change these with care, if you must.
void myinit(void)
{
#ifndef EMSCRIPTEN
GLuint program = InitShader( "../my code/vshader.glsl", "../my code/fshader.glsl" ); // Load shaders and use the resulting shader program
#else
GLuint program = InitShader( "vshader.glsl", "fshader.glsl" ); // Load shaders and use the resulting shader program
#endif
glUseProgram(program);
// Generate vertex arrays for geometric shapes
generateCube(program, &cubeData);
generateSphere(program, &sphereData);
generateCone(program, &coneData);
generateCylinder(program, &cylData);
uModelView = glGetUniformLocation( program, "ModelView" );
uProjection = glGetUniformLocation( program, "Projection" );
uView = glGetUniformLocation( program, "View" );
glClearColor( 0.1, 0.1, 0.2, 1.0 ); // dark blue background
uAmbient = glGetUniformLocation( program, "AmbientProduct" );
uDiffuse = glGetUniformLocation( program, "DiffuseProduct" );
uSpecular = glGetUniformLocation( program, "SpecularProduct" );
uLightPos = glGetUniformLocation( program, "LightPosition" );
uShininess = glGetUniformLocation( program, "Shininess" );
uTex = glGetUniformLocation( program, "Tex" );
uEnableTex = glGetUniformLocation( program, "EnableTex" );
glUniform4f(uAmbient, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uDiffuse, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform4f(uSpecular, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uLightPos, 15.0f, 15.0f, 30.0f, 0.0f);
glUniform1f(uShininess, 100.0f);
glEnable(GL_DEPTH_TEST);
Arcball = new BallData;
Ball_Init(Arcball);
Ball_Place(Arcball,qOne,0.75);
}
// The MAIN function, from here we start the application and run the game loop
int main() {
//////////////////////////////////////// BULLET ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// create the world parameters
btBroadphaseInterface * broadphase = new btDbvtBroadphase();
btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);
btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;
btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
dynamicsWorld->setGravity(btVector3(0., GRAVITY, 0));
// Set up the sides
btRigidBody* sides [6];
sides[0] = makeSide(dynamicsWorld, btVector3(0, 1, 0), btVector3(0, 0, 0));
sides[1] = makeSide(dynamicsWorld, btVector3(1, 0, 0), btVector3(-20, 0, 0));
sides[2] = makeSide(dynamicsWorld, btVector3(-1, 0, 0), btVector3(20, 0, 0));
sides[3] = makeSide(dynamicsWorld, btVector3(0, -1, 0), btVector3(0, 40, 0));
sides[4] = makeSide(dynamicsWorld, btVector3(0, 0, -1), btVector3(0, 0, 20));
sides[5] = makeSide(dynamicsWorld, btVector3(0, 0, 1), btVector3(0, 0, -20));
btRigidBody* sphere1 = makeSphere(dynamicsWorld, 1, 1, btVector3(0, 40, 0));
btRigidBody* sphere2 = makeSphere(dynamicsWorld, 1, 1, btVector3(0, 40, 0));
btRigidBody* cube = makeSphere(dynamicsWorld, 1, 1, btVector3(0, 35, 0));
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// start glfw and glew with default settings
bool test = start_gl();
assert(test);
// Build and compile our shader program
Shader sphereShader("shaders/shader.vs", "shaders/shader.frag");
Shader cubeShader("shaders/shader.vs", "shaders/lamp.frag");
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GLuint container_VAO, container_VBO, container_EBO;
GLfloat verts[] = {
-0.5f, -0.5f, 0.5f, // A 0
-0.5f, -0.5f, -0.5f, // B 1
0.5f, -0.5f, -0.5f, // C 2
0.5f, -0.5f, 0.5f, // D 3
-0.5f, 0.5f, 0.5f, // E 4
-0.5f, 0.5f, -0.5f, // F 5
0.5f, 0.5f, -0.5f, // G 6
0.5f, 0.5f, 0.5f // H 7
};
GLuint idx[] = {
0, 1, 2, 3, 0,
4, 7, 3,
2, 6, 7,
6, 5, 4,
5, 1, 0,
};
std::vector<GLfloat> container_verts = std::vector<GLfloat>(verts, verts + sizeof verts / sizeof verts[0]);
std::vector<GLint> container_idx = std::vector<GLint>(idx, idx + sizeof idx / sizeof idx[0]);
/////// Sphere vertices, normals and indices generation //////////////////////////////////////////
std::vector<GLfloat> sphere_verts;
std::vector<GLint> sphere_idx;
generateSphere( &sphere_verts, &sphere_idx, stacks, slices, radius);
///////////////// DECLARATIONS ////////////////////////
GLuint sphere_VBO, sphere_VAO, sphere_EBO;
///////////////// GET VAO READY ////////////////////////
GLuint aLoc[3] = {0, 1, 2};
GLint size[3] = {3, 3, 2};
GLsizei vStride[3] = {8 * sizeof(GLfloat), 8 * sizeof(GLfloat), 8 * sizeof(GLfloat)};
const void* vOffset[3] = {(GLvoid*)0, (GLvoid*)(3 * sizeof(GLfloat)), (GLvoid*)(6 * sizeof(GLfloat))};
prepareVAO(&sphere_VAO, &sphere_VBO, &sphere_EBO, sphere_verts, sphere_idx, 2, aLoc, size, vStride, vOffset);
aLoc[0] = 0;
size[0] = 3;
vStride[0] = 3 * sizeof(GLfloat);
vOffset[0] = (GLvoid*)0;
prepareVAO(&container_VAO, &container_VBO, &container_EBO, container_verts, container_idx, 1, aLoc, size, vStride, vOffset);
///////////////// The positions for the spheres in q4 ////////////////////////
// where the cubes will appear in the world space
glm::vec3 cubePositions[] = {
glm::vec3(1.5f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)
};
///////////////// Uniform variables for MVP in VS ////////////////////////
GLint modelLoc = glGetUniformLocation(sphereShader.Program, "model");
GLint viewLoc = glGetUniformLocation(sphereShader.Program, "view");
GLint projLoc = glGetUniformLocation(sphereShader.Program, "projection");
// uniforms for lighting
GLint objectColorLoc = glGetUniformLocation(sphereShader.Program, "objectColor");
GLint lightColorLoc = glGetUniformLocation(sphereShader.Program, "lightColor");
GLint lightPosLoc = glGetUniformLocation(sphereShader.Program, "lightPos");
GLint viewPosLoc = glGetUniformLocation(sphereShader.Program, "viewPos");
ofstream myfile;
myfile.open ("velocity.log");
btTransform trans;
// Main loop
while (!glfwWindowShouldClose(window)) {
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check if any events have been activated (key pressed, mouse moved)
glfwPollEvents();
do_movement();
// Clear the color buffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawSphere(&cubeShader, &container_VAO, &sphereShader, &sphere_VAO, (GLint)sphere_idx.size(), 17,
&objectColorLoc, &lightColorLoc, &lightPosLoc, &viewPosLoc,
2, cubePositions, &modelLoc, &viewLoc, &projLoc,
dynamicsWorld, sphere1, sphere2, cube);
sphere1->getMotionState()->getWorldTransform(trans);
myfile << trans.getOrigin().getX() << " " << trans.getOrigin().getY() << " " << trans.getOrigin().getZ() << ":";
sphere2->getMotionState()->getWorldTransform(trans);
myfile << trans.getOrigin().getX() << " " << trans.getOrigin().getY() << " " << trans.getOrigin().getZ() << ":";
cube->getMotionState()->getWorldTransform(trans);
myfile << trans.getOrigin().getX() << " " << trans.getOrigin().getY() << " " << trans.getOrigin().getZ() << "\n";
// Swap the screen buffers
glfwSwapBuffers(window);
}
// Deallocate
glDeleteVertexArrays(1, &sphere_VAO);
glDeleteBuffers(1, &sphere_VBO);
glDeleteBuffers(1, &sphere_EBO);
// Terminate GLFW
glfwDestroyWindow(window);
glfwTerminate();
myfile.close();
for(int i=0; i<6; i++){
dynamicsWorld->removeRigidBody(sides[i]);
delete sides[i]->getMotionState();
delete sides[i];
}
delete dynamicsWorld;
delete solver;
delete dispatcher;
delete collisionConfiguration;
delete broadphase;
return EXIT_SUCCESS;
}
OpenGL3DSphereRenderer::OpenGL3DSphereRenderer( const unsigned num_subdivs )
: m_sphere_verts()
, m_sphere_normals()
{
generateSphere( num_subdivs );
}
int main()
{
// SFML window that will host our OpenGL magic
sf::Window window(sf::VideoMode(1920, 1080), "OpenGL", sf::Style::Default, sf::ContextSettings(32));
window.setVerticalSyncEnabled(true);
window.setMouseCursorVisible(false);
sf::View view;
sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window);
glewInit();
Player player;
programInit(shaderMap, modelMap, textureMap, normalMap);
initPresetSystem(shaderMap, modelMap, textureMap, normalMap, presetMap);
Editor editor(modelMap, shaderMap, textureMap, normalMap, presetMap);
GLInit();
// ---------------------- MODELS -------------------------------
Model sphereModel, unitSquareModel;
generateSphere(&sphereModel, 50); sphereModel.upload();
myLoadObj("Models/unitSquare.obj", &unitSquareModel); unitSquareModel.upload();
loadNoise();
// Add terrain information to earth
cv::Mat earthBumpMap = cv::imread("Textures/earthBumpMap.jpg");
earthBumpMap.convertTo(earthBumpMap, CV_32F);
int height = earthBumpMap.rows;
int width = earthBumpMap.cols;
std::cout << "Dims: " << height << ", " << width << std::endl;
std::cout << "Dims: " << *earthBumpMap.row(height-1).col(5).ptr<float>() << std::endl;
// ---------------------- OBJECTS -------------------------------
// Initiation of all objects in the program
// ShaderParameters = (ambientCoeff, diffuseCoeff, specularCoeff, specularExponent)
cv::Vec4f standardShaderParameters(0.2f, 0.5f, 0.8f, 10);
Object squareNormalMap, squareSpecularityMap;
GLuint earthNormalMap, earthSpecularityMap, earthTextureDay, earthTextureNight;
GLuint normalMapShader, specularityMapShader;
shaderInit(&phongNoTex, "Shaders/phongNoTex.vert", "Shaders/phongNoTex.frag");
shaderInit(&normalMapShader, "Shaders/normalMap.vert", "Shaders/normalMap.frag");
shaderInit(&specularityMapShader, "Shaders/specularityMap.vert", "Shaders/specularityMap.frag");
LoadTGATextureSimple("Textures/earthTextureDay.tga", &earthTextureDay);
LoadTGATextureSimple("Textures/earthTextureNight.tga", &earthTextureNight);
LoadTGATextureSimple("Textures/earthNormalMap.tga", &earthNormalMap);
LoadTGATextureSimple("Textures/earthSpecularityMap.tga", &earthSpecularityMap);
//squareNormalMap.init(&unitSquareModel, phongNoTex, standardShaderParameters, 0, 0, 0, earthNormalMap);
squareNormalMap.init(&unitSquareModel, normalMapShader, standardShaderParameters, 0, 0, 0, earthNormalMap);
squareSpecularityMap.init(&unitSquareModel, specularityMapShader, standardShaderParameters, earthTextureDay, earthTextureNight, earthSpecularityMap, earthNormalMap);
squareNormalMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1);
squareSpecularityMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1);
// ---------------------- SKYSPHERE -------------------------------
Object skysphere;
GLuint skysphereTexture, skyboxShader;
LoadTGATextureSimple("Textures/spaceBox6.tga", &skysphereTexture);
shaderInit(&skyboxShader, "Shaders/skybox.vert", "Shaders/skybox.frag");
skysphere.init(&sphereModel, skyboxShader, standardShaderParameters, skysphereTexture);
skysphere.set(player.position, cv::Vec3f(1,1,1), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
int item;
// SFML built-in clock
sf::Clock clock;
states[RUNNING] = true;
states[EDITOR] = true;
states[STARTUP] = true;
/*
bool running = true;
bool runningEditor = true;
bool startup = true;
bool selectObject = false;
bool cooldown = false;
*/
Object* currentObject = NULL;
Object* playerObject = NULL;
while (states[RUNNING])
{
dt = clock.getElapsedTime().asSeconds();
if(states[EDITOR])
{
window.setVisible(false);
if(states[SELECTOBJECT])
{
solsystem.getObjects(&allObjects);
currentObject = getSelectedObject(&allObjects, &player);
allObjects.clear();
}
editor.edit(solsystem, states, currentObject);
states[STARTUP] = false;
sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window);
clock.restart();
window.setActive();
states[SELECTOBJECT] = false;
currentObject = NULL;
states[EDITOR] = false;
window.setVisible(true);
}
else
{
clock.restart();
if (playerObject != NULL)
{
std::cout << player.position << std::endl;
player.move(playerObject->position);
//player.position = playerObject->position;
std::cout << playerObject->position << std::endl;
}
handleEvents(&window, states, &item, playerObject, &player, dt);
player.lookAtUpdate(dt);
// Plocka ut all planeters positioner
std::list<Object*> allObjects;
solsystem.getObjects(&allObjects);
std::vector<cv::Vec3f> positionVector;
std::vector<cv::Vec3f> radiusVector;
std::list<Object*>::iterator i = allObjects.begin();
for (i++ ; i != allObjects.end(); ++i)
{
positionVector.push_back((*i)->position);
radiusVector.push_back((*i)->scale);
//std::cout << "Scale: " << (*i)->scale << std::endl;
}
int numberOfPlanets = positionVector.size();
GLfloat* positions = makeArray(positionVector);
GLfloat* radius = makeArray(radiusVector);
///////////////////////////////// SKYBOX /////////////////////////////////////////
window.setActive();
//drawSkybox(&player, &skyboxModel, skyboxShader, skyboxTexture);
glDisable(GL_DEPTH_TEST);
//skybox.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
//skybox.draw(&player);
skysphere.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
skysphere.draw(&player, 0, dt);
glEnable(GL_DEPTH_TEST);
///////////////////////////////// ALX /////////////////////////////////////////
if (states[NORMALMAP])
{
squareNormalMap.draw(&player, dt, numberOfPlanets, positions, radius);
}
if (states[SPECULARITYMAP])
{
squareSpecularityMap.draw(&player, dt, numberOfPlanets, positions, radius);
}
///////////////////////////////// ALX /////////////////////////////////////////
if(!states[COOLDOWN] && item == 1)
{
Object* newItem = presetMap["Earth"]->clone();
newItem->set(player.position, cv::Vec3f(0.25,0.25,0.25), cv::Vec3f(0,0,0), 10*player.getLookAtDirection(), 1);
solsystem.addItem(newItem);
std::cout << 10*normalize(player.position - player.lookAtVector) << std::endl;
states[COOLDOWN] = true;
}
item = 0;
if(states[ENABLEGRAVITY] && playerObject == NULL)
{
playerObject = presetMap["Earth"]->clone();
playerObject->set(player.position, cv::Vec3f(1.25,1.25,1.25), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
solsystem.addPlayerItem(playerObject);
states[ENABLEGRAVITY] = false;
}
if(states[DISABLEGRAVITY] && playerObject != NULL)
{
solsystem.removePlayerItem();
playerObject = NULL;
states[DISABLEGRAVITY] = false;
}
solsystem.update(physEngine, dt*0.5);
solsystem.draw(&player, accTime);
accTime += dt;
window.display();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
cv::waitKey(0);
}
// release resources...
glDeleteVertexArrays(1, &sphereModel.VAO);
//glDeleteVertexArrays(1, &skyboxModel.VAO);
//glDeleteVertexArrays(1, &unitSquareModel.VAO);
//glDeleteVertexArrays(1, &groundModel.VAO);
return 0;
}
void myinit(void)
{
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader.glsl", "fshader.glsl" );
glUseProgram(program);
// Generate vertex arrays for geometric shapes
generateCube(program, &cubeData);
generateSphere(program, &sphereData);
generateCone(program, &coneData);
generateCylinder(program, &cylData);
generatePyramid(program, &pyramidData);
uModelView = glGetUniformLocation( program, "ModelView" );
uProjection = glGetUniformLocation( program, "Projection" );
uView = glGetUniformLocation( program, "View" );
glClearColor( .1, .1, .6, 1.0 ); // dark blue background
uAmbient = glGetUniformLocation( program, "AmbientProduct" );
uDiffuse = glGetUniformLocation( program, "DiffuseProduct" );
uSpecular = glGetUniformLocation( program, "SpecularProduct" );
uLightPos = glGetUniformLocation( program, "LightPosition" );
uShininess = glGetUniformLocation( program, "Shininess" );
uTex = glGetUniformLocation( program, "Tex" );
uEnableTex = glGetUniformLocation( program, "EnableTex" );
glUniform4f(uAmbient, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uDiffuse, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform4f(uSpecular, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uLightPos, 15.0f, 15.0f, 30.0f, 0.0f);
glUniform1f(uShininess, 100.0f);
glEnable(GL_DEPTH_TEST);
TgaImage coolImage;
if (!coolImage.loadTGA("dirt.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage earthImage;
if (!earthImage.loadTGA("earth.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage roofImage;
if (!roofImage.loadTGA("roof.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage treeImage;
if (!treeImage.loadTGA("tree.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage skyImage;
if (!skyImage.loadTGA("sky.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage stoneImage;
if (!stoneImage.loadTGA("stone.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage leafImage;
if (!leafImage.loadTGA("leaf.tga"))
{
printf("Error loading image file\n");
exit(1);
}
glGenTextures( 1, &texture_cube );
glBindTexture( GL_TEXTURE_2D, texture_cube );
glTexImage2D(GL_TEXTURE_2D, 0, 4, coolImage.width, coolImage.height, 0,
(coolImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, coolImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glGenTextures( 1, &texture_earth );
glBindTexture( GL_TEXTURE_2D, texture_earth );
glTexImage2D(GL_TEXTURE_2D, 0, 4, earthImage.width, earthImage.height, 0,
(earthImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, earthImage.data );
//roof
glGenTextures( 1, &texture_roof );
glBindTexture( GL_TEXTURE_2D, texture_roof );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D(GL_TEXTURE_2D, 0, 4, roofImage.width, roofImage.height, 0,
(roofImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, roofImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glGenTextures( 1, &texture_trees );
glBindTexture( GL_TEXTURE_2D, texture_trees );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D(GL_TEXTURE_2D, 0, 4, treeImage.width, treeImage.height, 0,
(treeImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, treeImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glGenTextures( 1, &texture_leaf );
glBindTexture( GL_TEXTURE_2D, texture_leaf );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D(GL_TEXTURE_2D, 0, 4, leafImage.width, leafImage.height, 0,
(leafImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, leafImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glGenTextures( 1, &texture_stone );
glBindTexture( GL_TEXTURE_2D, texture_stone );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D(GL_TEXTURE_2D, 0, 4, stoneImage.width, stoneImage.height, 0,
(stoneImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, stoneImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// Set texture sampler variable to texture unit 0
// (set in glActiveTexture(GL_TEXTURE0))
glUniform1i( uTex, 0);
Arcball = new BallData;
Ball_Init(Arcball);
Ball_Place(Arcball,qOne,0.75);
}
// The MAIN function, from here we start the application and run the game loop
int main() {
// start glfw and glew with default settings
assert(start_gl());
// Build and compile our shader program
Shader sphereShader("shaders/shader.vs", "shaders/shader.frag");
Shader lampShader("shaders/shader.vs", "shaders/lamp.frag");
/////// Sphere vertices, normals and indices generation //////////////////////////////////////////
std::vector<GLfloat> sphere_verts, q2Verts, cone_verts;
std::vector<GLint> sphere_idx;
generateCone(&cone_verts, stacks, slices);
generateSphere( &sphere_verts, &q2Verts, &sphere_idx, stacks, slices, radius);
std::vector<GLint> cone_idx(sphere_idx);
///////////////// DECLARATIONS ////////////////////////
GLuint sphere_VBO, sphere_VAO, sphere_EBO, normal_VAO, normal_VBO, cone_VAO, cone_VBO, cone_EBO;
///////////////// GET VAO READY FOR CONE ////////////////////////////////////////////////////////
GLuint aLoc[3] = {0};
GLint size[3] = {3};
GLsizei vStride[3] = {3 * sizeof(GLfloat)};
const void* vOffset[3] = {(GLvoid*)0};
prepareVAO(&cone_VAO, &cone_VBO, &cone_EBO, cone_verts, cone_idx, 1, aLoc, size, vStride, vOffset);
///////////////// GET VAO READY FOR SPHERE //////////////////////////////////////////////////////
aLoc[0] = 0; aLoc[1] = 1; aLoc[2] = 2;
size[0] = size[1] = 3; size[2] = 2;
vStride[0] = vStride[1] = vStride[2] = 8 * sizeof(GLfloat);
vOffset[0] = (GLvoid*)0; vOffset[1] = (GLvoid*)(3 * sizeof(GLfloat)); vOffset[2] = (GLvoid*)(6 * sizeof(GLfloat));
prepareVAO(&sphere_VAO, &sphere_VBO, &sphere_EBO, sphere_verts, sphere_idx, 3, aLoc, size, vStride, vOffset);
///////////////// GET VAO READY FOR NORMALS (Q2) ////////////////////////////////////////////////
aLoc[0] = 0;
size[0] = 3;
vStride[0] = 3 * sizeof(GLfloat);
vOffset[0] = (GLvoid*)0;
prepareVAO(&normal_VAO, &normal_VBO, nullptr, q2Verts, std::vector<GLint>() , 1, aLoc, size, vStride, vOffset);
///////////////// GET Textures ready ////////////////////////////////////////////////////////////
GLuint texture1;
int width, height, comp;
prepareTexture(&texture1, "images/earth.jpg", &width, &height, &comp);
///////////////// The positions for the spheres in q4 ////////////////////////////////////////////
// where the cubes will appear in the world space
glm::vec3 cubePositions[] = {
glm::vec3(1.5f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)
};
///////////////// Uniform variables for MVP in VS /////////////////////////////////////////////////
GLint modelLoc = glGetUniformLocation(sphereShader.Program, "model");
GLint viewLoc = glGetUniformLocation(sphereShader.Program, "view");
GLint projLoc = glGetUniformLocation(sphereShader.Program, "projection");
// The question number to switch
GLint q = glGetUniformLocation(sphereShader.Program, "q");
// uniforms for lighting
GLint objectColorLoc = glGetUniformLocation(sphereShader.Program, "objectColor");
GLint lightColorLoc = glGetUniformLocation(sphereShader.Program, "lightColor");
GLint lightPosLoc = glGetUniformLocation(sphereShader.Program, "lightPos");
GLint viewPosLoc = glGetUniformLocation(sphereShader.Program, "viewPos");
// Main loop
while (!glfwWindowShouldClose(window)) {
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check if any events have been activated (key pressed, mouse moved)
glfwPollEvents();
do_movement();
// Clear the color buffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lightPos.x = sin(glfwGetTime()) * 0.1;
lightPos.y = cos(glfwGetTime()) * 0.1;
drawSphere(&sphereShader, &sphere_VAO, &sphere_idx,
&normal_VAO, &sphere_verts,
&cone_VAO, &cone_verts, &cone_idx,
&lampShader,
&objectColorLoc, &lightColorLoc, &lightPosLoc, &viewPosLoc,
&q, &texture1,
2, cubePositions, &modelLoc, &viewLoc, &projLoc);
// Swap the screen buffers
glfwSwapBuffers(window);
}
// Deallocate
glDeleteVertexArrays(1, &sphere_VAO);
glDeleteBuffers(1, &sphere_VBO);
glDeleteBuffers(1, &sphere_EBO);
glDeleteVertexArrays(1, &normal_VAO);
glDeleteVertexArrays(1, &normal_VBO);
glDeleteVertexArrays(1, &cone_VAO);
glDeleteBuffers(1, &cone_VBO);
glDeleteBuffers(1, &cone_EBO);
// Terminate GLFW
glfwDestroyWindow(window);
glfwTerminate();
return EXIT_SUCCESS;
}
void initPrimitives(GLuint program) {
generateCube ( program, &cubeData );
generateSphere ( program, &sphereData );
generateCone ( program, &coneData );
generateCylinder( program, &cylData );
}
void myinit(void)
{
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader.glsl", "fshader.glsl" );
glUseProgram(program);
// Generate vertex arrays for geometric shapes
generateGrass(program, &grassData);
generateHeart(program, &heartData);
generateCube(program, &cubeData);
generateSphere(program, &sphereData);
generateCone(program, &coneData);
generateCylinder(program, &cylData);
uModelView = glGetUniformLocation( program, "ModelView" );
uProjection = glGetUniformLocation( program, "Projection" );
uView = glGetUniformLocation( program, "View" );
glClearColor( 0.5, 0.5, 1.0, 1.0 ); // dark blue background
uAmbient = glGetUniformLocation( program, "AmbientProduct" );
uDiffuse = glGetUniformLocation( program, "DiffuseProduct" );
uSpecular = glGetUniformLocation( program, "SpecularProduct" );
uLightPos = glGetUniformLocation( program, "LightPosition" );
uShininess = glGetUniformLocation( program, "Shininess" );
uTex = glGetUniformLocation( program, "Tex" );
uEnableTex = glGetUniformLocation( program, "EnableTex" );
glUniform4f(uAmbient, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uDiffuse, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform4f(uSpecular, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uLightPos, 15.0f, 15.0f, 30.0f, 0.0f);
glUniform1f(uShininess, 100.0f);
glEnable(GL_DEPTH_TEST);
TgaImage coolImage;
if (!coolImage.loadTGA("challenge.tga"))
{
printf("Error loading image file\n");
exit(1);
}
GLuint texture;
glGenTextures( 1, &texture );
glBindTexture( GL_TEXTURE_2D, texture );
glTexImage2D(GL_TEXTURE_2D, 0, 4, coolImage.width, coolImage.height, 0,
(coolImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, coolImage.data );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, texture );
// Set texture sampler variable to texture unit 0
// (set in glActiveTexture(GL_TEXTURE0))
glUniform1i( uTex, 0 );
Arcball = new BallData ;
Ball_Init(Arcball);
Ball_Place(Arcball,qOne,0.75);
}
