objReader::objReader(const std::string &file, GLuint texture)
{
loadObj(file);
m_textures.push_back(texture);
}
bool load(const Path &path, std::vector<Vertex> &verts, std::vector<TriangleI> &tris)
{
if (path.testExtension("wo3"))
return loadWo3(path, verts, tris);
else if (path.testExtension("obj"))
return loadObj(path, verts, tris);
return false;
}
StaticObject::StaticObject(char* url,vec3 position,vec3 rotation,vec3 scale){
mat4 t_normalizeMatrix = loadObj(url);
this->speed = vec3(0);
this->position = position;
this->rotation = rotation;
this->scale = scale;
calculateModelMatrix();
}
Direct3D10Mesh* loadObj(ID3D10Device& device, const std::string& fileName, const D3DXCOLOR& color, float scale)
{
vector<Vertex> vertices;
loadObj(fileName, color, scale, vertices, 0, 0, 0, 0);
return new Direct3D10Mesh(device, vertices);
}
int main(int argc, char **argv) {
if (argc < 2) {
fprintf(stderr, "usage: %s objfilename[s]\n", argv[0]);
return -1;
}
XYZ minP, maxP;
int i;
for (i = 1; i < argc; i++) {
OBJ_STRUCT *obj; // = loadObj(argv[argc -i], "null", 1, 1, 1, 1);
char *ext = argv[argc-i] + strlen(argv[argc-i]) - 3;
if (!strncmp(ext, "obj", 3)) {
obj = loadObj(argv[argc-i], "null", 1,1,1,1);
} else if (!strncmp(ext, "stl", 3)) {
obj = loadObjFromSTL(argv[argc-i], "null", 1,1,1,1);
} else {
fprintf(stderr, "Cannot load file '%s'.\n", argv[argc-i]);
exit(-1);
}
if (i == 1) {
minP = obj->minP;
maxP = obj->maxP;
} else {
if (obj->minP.x < minP.x) {
minP.x = obj->minP.x;
}
if (obj->minP.y < minP.y) {
minP.y = obj->minP.y;
}
if (obj->minP.z < minP.z) {
minP.z = obj->minP.z;
}
if (obj->maxP.x > maxP.x) {
maxP.x = obj->maxP.x;
}
if (obj->maxP.y > maxP.y) {
maxP.y = obj->maxP.y;
}
if (obj->maxP.z > maxP.z) {
maxP.z = obj->maxP.z;
}
}
}
// offset all model parts
XYZ mid = VectorAdd(minP, maxP);
mid = VectorMul(mid, 0.5);
fprintf(stderr, "OBJ vertex range: (%f,%f,%f) -> (%f,%f,%f)\n", minP.x, minP.y, minP.z,
maxP.x, maxP.y, maxP.z);
fprintf(stderr, "OBJ vertex midpoint: (%f,%f,%f)\n", mid.x, mid.y, mid.z);
return 0;
}
int main(void) {
char* fname="data/teddy.obj";
int vertices = count('v',fname);
int faces = count('f',fname);
printf("%d %d",vertices,faces);
GLfloat vertex_buffer_data[vertices*3];
GLfloat color_buffer_data[vertices*3];
GLushort index_buffer_data[faces*3];
loadObj(vertex_buffer_data, color_buffer_data, index_buffer_data, vertices, faces, fname);
}
static PyObject* pyLoadObj(PyObject *self, PyObject *args) {
char* filename;
if(!PyArg_ParseTuple(args, "s", &filename))
return NULL;
// Load obj & print info
int id = createObj();
loadObj(filename, id);
printf("Loaded: %i\n", id);
return Py_BuildValue("i", id);
}
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1280, 720);
glutInitWindowPosition(20, 20);
glutCreateWindow("ObjLoader");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
loadObj("Bugatti-Veyron.obj");
glutMainLoop();
return 0;
}
Mesh::Mesh(char *fileName, Material material)
{
m_fileName = fileName;
m_material = material;
if (loadObj() != 0)
{
std::cerr << "Mesh: Error loading " << m_fileName << std::endl;
std::exit(1);
}
std::cout << "Mesh: " << m_fileName << " has been loaded succesfully." << std::endl;
}
void init() {
camera.position[2] = 15;
libpng_version();
light0.slot = GL_LIGHT0;
light0.setDiffuse(1.0, 1.0, 1.0, 1.0);
light0.setPosition(0.0, 0.0, 1.0, 0.0);
light0.load();
light0.enable();
glewInit();
loadObj((char*) "models/350z.obj", &mesh);
VBOfromMesh(vbo, mesh);
vbo.generate();
int w, h;
test_texture = texture_bank.findOrReg((char*) "textures/350z/vinyls.png");
//test_texture = PNG_load((const char*) "textures/vinyls.png", &w, &h);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, test_texture);
programID = loadShaders("shaders/vertex.glsl", "shaders/fragment.glsl");
glUseProgram(programID);
uTex = glGetUniformLocation(programID, "texDiff");
glUniform1i(uTex, 0);
uProjection = glGetUniformLocation(programID, "projection");
uView = glGetUniformLocation(programID, "view");
uModel = glGetUniformLocation(programID, "model");
uLightPos = glGetUniformLocation(programID, "lightPos");
uLightDiff = glGetUniformLocation(programID, "lightDiff");
uLightSpec = glGetUniformLocation(programID, "lightSpec");
uCameraPosition = glGetUniformLocation(programID, "cameraPosition");
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_DEPTH_TEST);
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(800,450);
glutInitWindowPosition(20,20);
glutCreateWindow("ObjLoader");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
loadObj("untitled.obj");//replace porsche.obj with radar.obj or any other .obj to display it
glutMainLoop();
return 0;
}
/* function main()
* Description:
* - this is the main function
* - does initialization and then calls glutMainLoop() to start the event handler
*/
int main(int argc, char **argv)
{
/* initialize the window and OpenGL properly */
glutInit(&argc, argv);
glutInitWindowSize(windowWidth, windowHeight);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutCreateWindow("Supercool dope title game");
/* set up our function callbacks */
glutDisplayFunc(DisplayCallbackFunction);
glutKeyboardFunc(KeyboardCallbackFunction);
glutKeyboardUpFunc(KeyboardUpCallbackFunction);
glutReshapeFunc(WindowReshapeCallbackFunction);
glutMouseFunc(MouseClickCallbackFunction);
glutMotionFunc(MouseMotionCallbackFunction);
glutPassiveMotionFunc(MousePassiveMotionCallbackFunction);
glutTimerFunc(1, TimerCallbackFunction, 0);
/* Call some OpenGL parameters */
glEnable(GL_CULL_FACE);
//glFrontFace(GL_CCW);
//glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
/* Turn on the lights! */
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
///glShademodel(GL_SMOOTH);
/* Init Image Library */
glEnable(GL_TEXTURE_2D);
//replace the parameters in loadObj with what you want to load
loadObj("C:\\Users\\100550931\\Documents\\intro to graphics tutorials\\Tutorial3Package\\Tutorial3Package\\Tutorial1IntroGraphics\\obj.txt");
ilInit();
iluInit();
ilutRenderer(ILUT_OPENGL);
/* Load a texture */
textureHandle = ilutGLLoadImage("..//img//win.png");
glBindTexture(GL_TEXTURE_2D, textureHandle);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glBindTexture(GL_TEXTURE_2D, NULL);
/* start the event handler */
glutMainLoop();
return 0;
}
void init(void)
{
srand(static_cast <unsigned> (time(NULL)));
glClearColor(0.0, 0.0, 0.0, 0.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
loadObj();
// findBoundingBox();
initLighting();
glEnable(GL_TEXTURE_2D);
glDepthRange(0.0, 1.0); /* The default z mapping */
}
objReader::objReader(const std::string &file, const char* texture)
: m_vertices(), m_normals(), m_texCoord(), m_faces(), m_textures()
{
loadObj(file);
//computeNormals();
if (texture) {
m_textures.push_back(TextureManager::loadTexture(texture, texture));
}
std::cout<<"Read "<<m_vertices.size()<<" vertices, "<<m_texCoord.size()
<<" texcoord, "<<m_normals.size()<<" normals, "<<m_faces.size()<<" faces.\n"
<<m_textures.size()<<" textures files were loaded\n";
}
bool loadObj(Geometry &geom, const std::string &filename, float scale, int flags)
{
std::vector<Geometry> geomList;
loadObj(geomList,filename,scale,flags);
geom.clear();
// Pack all Geometry into one.
for(unsigned int i=0; i<geomList.size(); ++i)
{
geom.addGeometry(geomList[i]);
}
return 0;
}
// initilize scene
// load obj files, set lights, camera
void initScene(const std::string& textureName)
{
// for loading triangle mesh
Matrix4x4 matrix;
loadObj(objName.c_str(), vertices, normals, texcoord, mesh);
matrix.m[2][3] = -9.f;
matrix.m[1][3] = 0.f;
Transform* tr = new Transform(matrix);
trfList.push_back(tr);
Mesh* newmesh = new Mesh(tr, &vertices, &normals, &mesh);
objList.push_back(newmesh);
// object initialize, for sphere
/*Matrix4x4 mat;
mat.m[2][3] = -16.f;
Transform* tr2 = new Transform(mat);
trfList.push_back(tr2);
Sphere *sphere1 = new Sphere(tr2, 6.f);
objList.push_back(sphere1);*/
// initialize image plane
intensity = new float[WINX * WINY * 3];
memset(intensity, 0, WINX*WINY * 3 * sizeof(float));
// set up the camera
Point camCenter, camLookAt(0.f, 0.f, -1.f);
Vector camUp(0.f, 1.f, 0.f);
float fovy = 60.f;
camera = new PerspectiveCamera(camCenter, camLookAt, camUp, fovy);
// set up the projectionLight
Point e(-1.5f, 3.f, 15.f), gaze(-1.2f, 1.3f, 0.f);
Vector up(0.f, 0.9f, 0.43589f);
/* For sphere ray tracing test */
/*Point e(0.f, 0.f, 7.f), gaze(.0f, 0.f, -1.f);
Vector up(0.f, 1.f, 0.f);*/
Transform light2world = LookAt(e, gaze, up);
//string texname("grid.jpg");
float projFovy = 20.0;
ProjectionLight *projector = new ProjectionLight(Inverse(light2world), textureName, projFovy);
// set up the sampler
sampler = new SimpleSampler(WINX, WINY);
scene = new Scene(sampler, camera, &objList, projector, WINX, WINY);
}
struct Model * loadModel(char * directory,char * modelname)
{
struct Model * mod = ( struct Model * ) malloc(sizeof(struct Model));
if ( mod == 0 ) { fprintf(stderr,"Could not allocate enough space for model %s \n",modelname); return 0; }
memset(mod , 0 , sizeof(struct Model));
if ( strstr(modelname,".obj") != 0 )
{
mod->type = OBJMODEL;
mod->model = (struct OBJ_Model * ) loadObj(directory,modelname);
}
if (mod->model ==0 ) { free(mod); return 0 ;}
return mod;
}
bool
TriangleMesh::load(char* file, const Matrix4x4& ctm)
{
FILE *fp = fopen(file, "rb");
if (!fp)
{
error("Cannot open \"%s\" for reading\n",file);
return false;
}
debug("Loading \"%s\"...\n", file);
loadObj(fp, ctm);
debug("Loaded \"%s\" with %d triangles\n",file,m_numTris);
fclose(fp);
return true;
}
Model::Model(const QString &filePath)
: m_fileName(QFileInfo(filePath).fileName())
{
QFile file(filePath);
if (!file.open(QIODevice::ReadOnly))
return;
if (filePath.endsWith(".stl", Qt::CaseInsensitive)) {
loadStl(file);
} else if (filePath.endsWith(".obj", Qt::CaseInsensitive)) {
loadObj(file);
} else if (filePath.endsWith(".gcode", Qt::CaseInsensitive)) {
loadGCode(filePath.toStdString());
}
m_transform.setToIdentity();
}
dpBinary* dpLoader::load(const char *path)
{
size_t len = strlen(path);
if(len>=4) {
if (_stricmp(&path[len-4], ".obj")==0) {
return loadObj(path);
}
else if(_stricmp(&path[len-4], ".lib")==0) {
return loadLib(path);
}
else if(_stricmp(&path[len-4], ".dll")==0 || _stricmp(&path[len-4], ".exe")==0) {
return loadDll(path);
}
}
dpPrintError("unrecognized file %s\n", path);
return nullptr;
}
void Model::load()
{
loadObj( model_path, vertices, normals );
glGenBuffers( 2, vbo );
glGenVertexArrays( 1, vao );
glBindBuffer( GL_ARRAY_BUFFER, vbo[ 0 ] );
glBufferData( GL_ARRAY_BUFFER, vertices.size() * sizeof( glm::vec3 ), &vertices[ 0 ], GL_STATIC_DRAW );
glBindVertexArray( vao[ 0 ] );
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, sizeof( glm::vec3 ), (const GLvoid*) 0 );
glBindBuffer( GL_ARRAY_BUFFER, vbo[ 1 ] );
glBufferData( GL_ARRAY_BUFFER, normals.size() * sizeof( glm::vec3 ), &normals[ 0 ], GL_STATIC_DRAW );
glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, sizeof( glm::vec3 ), (const GLvoid*) 0 );
glEnableVertexAttribArray( 1 );
}
int main(int argc, char* argv[])
{
int timestoload = 1;
if(argc == 1)
{
printf("usage testobjloader filename.obj 5\n");
return 0;
}
if(argc == 3)
{
sscanf(argv[2], "%20i", ×toload);
}
printf("starting to load %s %i times\n", argv[1], timestoload);
timespec start, stop;
clock_gettime(CLOCK_REALTIME, &start);
double calltime;
for(int i = 0; i < timestoload; i++)
{
obj* testmesh = loadObj(argv[1]);
for(int j=0;j<testmesh->numfaces;j++)
{
fprintf(stdout,"%i %i %i\n",testmesh->faces[j].verts[0],testmesh->faces[j].verts[1],testmesh->faces[j].verts[2]);
}
obj* testmesh2 = ObjMakeUniqueFullVerts(testmesh);
for(int j=0;j<testmesh2->numfaces;j++)
{
fprintf(stdout,"%i %i %i\n",testmesh2->faces[j].verts[0],testmesh2->faces[j].verts[1],testmesh2->faces[j].verts[2]);
}
delete testmesh;
delete testmesh2;
}
clock_gettime(CLOCK_REALTIME, &stop);
calltime = (stop.tv_sec - start.tv_sec) + (stop.tv_nsec - start.tv_nsec) / 1000000000.0;
printf("done loading file %lfseconds\n", calltime / timestoload);
return 0;
}
MeshManager :: MeshManager(ofVec3f s, int d, bool hf, char* fname){
hasfile = hf;
current = 0;
depth = d;
limit_depth = d;
filename = fname;
scale.set(1.,1.,1.);
if(hasfile) meshes.push_back(loadObj());
else meshes.push_back(loadMesh());
vector<Delta*> changes;
for(int i = 1; i < depth; i++) meshes.push_back(new Mesh(i, meshes.back(), changes));
}
Mesh::Mesh(string filename, bool ccw):
mRot(0,0,0),
mPos(0,0,0),
mAABB(BVL_SIZE(BVL)),
mAABBTriangles(BVL_SIZE(BVL)),
mSphere(BVL_SIZE(BVL)),
mSphereTriangles(BVL_SIZE(BVL))
{
clock_t t = clock();
loadObj(filename, mVertices, mTriangles, ccw);
createTriangleLists();
createBoundingVolHierarchy();
centerAlign();
createNormals();
calculateVolume();
printf ("Mesh loading took:\t%4.2f sec | %d triangles \n", ((float)clock()-t)/CLOCKS_PER_SEC, mTriangles.size());
for (int blevel=0; blevel<=BVL; blevel++)
printf("Coverage Level %d: AABB %4.2f%%, Sphere %4.2f%% \n", blevel, 100*AABBCover[blevel], 100*sphereCover[blevel]);
}
int main(int argc, char *argv[]) {
if (argc != 2) {
std::cout << "usage: ./ObjLoader.out <Target Object Path>\n";
exit(1);
}
if (!loadObj(std::string(argv[1]), mesh))
std::cout << "Could not load obj\n";
mesh.print();
mesh.movetoCenter();
mesh.fittoUnitSphere();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(50, 25);
glutInitWindowSize(900, 620); // w h
glutCreateWindow("OpenGL Window");
glClearColor(.9, .9, .9, 0.0);
initializeGL();
// GLUT Display Function
glutDisplayFunc(renderScene);
glutReshapeFunc(resize);
// Keyboard handlers
glutKeyboardFunc(keyboardDown);
// Mouse handlers
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
// GLUT Main Lopp
glutMainLoop();
return 0;
}
//--------------------------------------------------------------------
Status MeshManager::mLoad(std::shared_ptr<Mesh> mesh, const std::string& sid) const {
//try to load from the cache
if (mesh->hasCache()) {
return mLoad(mesh, sid,
mesh->positions,
mesh->uvs,
mesh->flatNormals,
mesh->vertexIndices);
}
//otherwise load from the file
// stores elements as they comes from .obj
std::vector<glm::vec3> positions;
std::vector<glm::vec2> uvs;
std::vector<glm::vec3> flatNormals;
// map one UV & one p per vertex object
std::vector<VertexIndices> vertexIndices;
//filename, deduced from SID
std::string path = mLocalDir + sid + ".obj";
//load positions uvs and their indices from the obj file
if (loadObj(path, positions, uvs, flatNormals, vertexIndices) != STATUS_OK) {
Log::error(TAG, "Unable to load obj %s", path.c_str());
return STATUS_KO;
}
//update the cache if any
mesh->positions = positions;
mesh->uvs = uvs;
mesh->flatNormals = flatNormals;
mesh->vertexIndices = vertexIndices;
return mLoad(mesh, sid, positions, uvs, flatNormals, vertexIndices);
}
Direct3D10Mesh* loadObj(ID3D10Device& device, const string& fileName, const D3DXCOLOR& color)
{
return loadObj(device, fileName, color, 1.0f);
}
int main()
{
lightDir.x=0.5;
lightDir.y=.7;
lightDir.z=-0.5;
kmVec3Normalize(&lightDir,&lightDir);
// creates a window and GLES context
// create a window and GLES context
if (!glfwInit())
exit(EXIT_FAILURE);
window = glfwCreateWindow(width, height, "I N V A D E R S ! ! !", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetWindowSizeCallback(window,window_size_callback);
glfwMakeContextCurrent(window);
// all the shaders have at least texture unit 0 active so
// activate it now and leave it active
glActiveTexture(GL_TEXTURE0);
// The obj shapes and their textures are loaded
cubeTex = loadPNG("resources/textures/dice.png");
loadObj(&cubeObj, "resources/models/cube.gbo",
"resources/shaders/textured.vert", "resources/shaders/textured.frag");
shipTex = loadPNG("resources/textures/shipv2.png");
loadObjCopyShader(&shipObj,"resources/models/ship.gbo",&cubeObj);
alienTex = loadPNG("resources/textures/alien.png");
loadObjCopyShader(&alienObj, "resources/models/alien.gbo", &cubeObj);
shotTex = loadPNG("resources/textures/shot.png");
loadObjCopyShader(&shotObj, "resources/models/shot.gbo", &cubeObj);
expTex = loadPNG("resources/textures/explosion.png");
playerPos.x = 0;
playerPos.y = 0;
playerPos.z = 0;
kmMat4Identity(&view);
pEye.x = 0;
pEye.y = 2;
pEye.z = 4;
pCenter.x = 0;
pCenter.y = 0;
pCenter.z = -5;
pUp.x = 0;
pUp.y = 1;
pUp.z = 0;
kmMat4LookAt(&view, &pEye, &pCenter, &pUp);
// projection matrix, as distance increases
// the way the model is drawn is effected
kmMat4Identity(&projection);
kmMat4PerspectiveProjection(&projection, 45,
(float)width/ height, 0.1, 1000);
glViewport(0, 0, width,height);
// these two matrices are pre combined for use with each model render
kmMat4Assign(&vp, &projection);
kmMat4Multiply(&vp, &vp, &view);
// initialises glprint's matrix shader and texture
initGlPrint(width,height);
font1=createFont("resources/textures/font.png",0,256,16,16,16);
font2=createFont("resources/textures/bigfont.png",32,512,9.5,32,48);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND); // only used by glprintf
glEnable(GL_DEPTH_TEST);
int num_frames = 0;
bool quit = false;
resetAliens();
for (int n = 0; n < MAX_PLAYER_SHOTS; n++) {
playerShots[n].alive = false;
}
initPointClouds("resources/shaders/particle.vert",
"resources/shaders/particle.frag",(float)width/24.0);
for (int n = 0; n < MAX_ALIENS; n++) {
aliens[n].explosion=createPointCloud(40);
resetExposion(aliens[n].explosion); // sets initials positions
}
glClearColor(0, .5, 1, 1);
while (!quit) { // the main loop
clock_gettime(0,&ts); // note the time BEFORE we start to render the current frame
glfwPollEvents();
if (glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS || glfwWindowShouldClose(window))
quit = true;
float rad; // radians rotation based on frame counter
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
frame++;
rad = frame * (0.0175f * 2);
//kmMat4Identity(&model);
kmMat4Translation(&model, playerPos.x, playerPos.y, playerPos.z);
playerCroll +=
(PIDcal(playerRoll, playerCroll, &playerPre_error, &playerIntegral)
/ 2);
// kmMat4RotationPitchYawRoll(&model, 0, 3.1416, playerCroll * 3); //
kmMat4RotationYawPitchRoll(&rot,0,3.1416,-playerCroll*3);
kmMat4Multiply(&model, &model, &rot);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, shipTex);
drawObj(&shipObj, &mvp, &mv, lightDir, viewDir);
glPrintf(50 + sinf(rad) * 16, 240 + cosf(rad) * 16,
font2,"frame=%i", frame);
kmVec3 tmp;
playerFireCount--;
if (glfwGetKey(window,GLFW_KEY_LEFT_CONTROL)==GLFW_PRESS && playerFireCount < 0) {
struct playerShot_t *freeShot;
freeShot = getFreeShot();
if (freeShot != 0) {
playerFireCount = 15;
freeShot->alive = true;
kmVec3Assign(&freeShot->pos, &playerPos);
}
}
for (int n = 0; n < MAX_PLAYER_SHOTS; n++) {
if (playerShots[n].alive) {
playerShots[n].pos.z -= .08;
if (playerShots[n].pos.z < -10)
playerShots[n].alive = false;
//kmMat4Identity(&model);
kmMat4Translation(&model, playerShots[n].pos.x,
playerShots[n].pos.y,
playerShots[n].pos.z);
//kmMat4RotationPitchYawRoll(&model, rad * 4, 0,
// -rad * 4);
kmMat4RotationYawPitchRoll(&rot,rad*4,0,-rad*4);
kmMat4Multiply(&model,&model,&rot);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, shotTex);
drawObj(&shotObj, &mvp, &mv, lightDir, viewDir);
}
}
playerRoll = 0;
if (glfwGetKey(window,GLFW_KEY_LEFT)==GLFW_PRESS && playerPos.x > -10) {
playerPos.x -= 0.1;
playerRoll = .2;
}
if (glfwGetKey(window,GLFW_KEY_RIGHT)==GLFW_PRESS && playerPos.x < 10) {
playerPos.x += 0.1;
playerRoll = -.2;
}
pEye.x = playerPos.x * 1.25;
pCenter.x = playerPos.x;
pCenter.y = playerPos.y + 1;
pCenter.z = playerPos.z;
int deadAliens;
deadAliens = 0;
for (int n = 0; n < MAX_ALIENS; n++) {
if (aliens[n].alive == true) {
//kmMat4Identity(&model);
kmMat4Translation(&model, aliens[n].pos.x,
aliens[n].pos.y, aliens[n].pos.z);
//kmMat4RotationPitchYawRoll(&model, -.4, 0, 0);
kmMat4RotationYawPitchRoll(&rot,.2,0,0);
kmMat4Multiply(&model,&model,&rot);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, alienTex);
drawObj(&alienObj, &mvp, &mv, lightDir, viewDir);
kmVec3 d;
for (int i = 0; i < MAX_PLAYER_SHOTS; i++) {
kmVec3Subtract(&d, &aliens[n].pos,
&playerShots[i].pos);
if (kmVec3Length(&d) < .7
&& playerShots[i].alive) {
aliens[n].alive = false;
playerShots[i].alive = false;
aliens[n].exploding = true;
resetExposion(aliens[n].explosion);
}
}
}
if (aliens[n].alive != true && aliens[n].exploding != true) {
deadAliens++;
}
}
if (deadAliens == MAX_ALIENS) {
resetAliens();
}
// draw explosions after ALL aliens
for (int n = 0; n < MAX_ALIENS; n++) {
if (aliens[n].exploding==true) {
kmMat4Identity(&model);
kmMat4Translation(&model, aliens[n].pos.x,
aliens[n].pos.y, aliens[n].pos.z);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
glBindTexture(GL_TEXTURE_2D, expTex);
drawPointCloud(aliens[n].explosion, &mvp);
aliens[n].explosion->tick=aliens[n].explosion->tick+0.05;
if (aliens[n].explosion->tick>1.25) {
aliens[n].exploding=false;
} else {
// update the explosion
for (int i=0; i<aliens[n].explosion->totalPoints; i++) {
float t;
t=aliens[n].explosion->tick;
if (i>aliens[n].explosion->totalPoints/2) t=t/2.0;
aliens[n].explosion->pos[i*3]=aliens[n].explosion->vel[i*3] * t;
aliens[n].explosion->pos[i*3+1]=aliens[n].explosion->vel[i*3+1] * t;
aliens[n].explosion->pos[i*3+2]=aliens[n].explosion->vel[i*3+2] * t;
}
}
}
}
// move camera
kmMat4LookAt(&view, &pEye, &pCenter, &pUp);
kmMat4Assign(&vp, &projection);
kmMat4Multiply(&vp, &vp, &view);
kmVec3Subtract(&viewDir,&pEye,&pCenter);
kmVec3Normalize(&viewDir,&viewDir);
// dump values
glPrintf(100, 280, font1,"eye %3.2f %3.2f %3.2f ", pEye.x, pEye.y, pEye.z);
glPrintf(100, 296, font1,"centre %3.2f %3.2f %3.2f ", pCenter.x, pCenter.y,
pCenter.z);
glPrintf(100, 340, font1,"frame %i %i ", frame, frame % 20);
glfwSwapBuffers(window);
ts.tv_nsec+=20000000; // 1000000000 / 50 = 50hz less time to render the frame
//thrd_sleep(&ts,NULL); // tinycthread
usleep(20000); // while I work out why tinycthread that was working isnt.... :/
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void loadModels() {
model=loadObj(AUTO_MODEL_DIR, AUTO_MATERIAL_DIR);
loaded=loadObj(TRACK_MODEL_DIR, TRACK_MATERIAL_DIR);
}
Polyline* loadPolyline(const std::string& filename){
unsigned int vbo, ibo, vao, count;
loadObj(filename, vao, vbo, ibo, count);
Polyline *p = new Polyline(vbo, ibo, vao, count);
return p;
}
