// Boucle dans laquelle vit le jeu. void MainGame::gameLoop() { GLuint frameRate(1000 / 70); Uint32 startTicks(0), endTicks(0), elapsedTime(0), startFpsTicks(0), endFpsTicks(0); int steps(0); int physicalSteps(0); Engine::Shader* shader = new Engine::Shader(); PerlinNoise::initPerlinNoise(15); //Hard test /*for (int i = 0; i < _worldSize; i++) { for (int j = 0; j < _worldSize; j++) { int **heightMap; heightMap = new int*[CHUNK_SIZE + 2]; for (int i1 = 0; i1 < CHUNK_SIZE + 2; i1++) { heightMap[i1] = new int[CHUNK_SIZE + 2]; for (int j1 = 0; j1 < CHUNK_SIZE + 2; j1++) { heightMap[i1][j1] = int(1000 * PerlinNoise::getPerlinNoise(i1 + i*CHUNK_SIZE - 1, j1 + j*CHUNK_SIZE - 1, 10000) + 100 * PerlinNoise::getPerlinNoise(i1 + i*CHUNK_SIZE - 1, j1 + j*CHUNK_SIZE - 1, 200)); } } Engine::Chunk* chunk = new Engine::Chunk(glm::vec3(i*CHUNK_SIZE, j*CHUNK_SIZE, 0), heightMap); chunk->addStructure(new Ground(heightMap)); chunk->addStructure(new Rock(glm::vec3(2, 6, 0))); chunk->addStructure(new Rock(glm::vec3(7, 12, 0))); chunk->addStructure(new Tree(glm::vec3(6, 2, 0), rand()%2)); chunk->init(); _chunks.emplace_back(chunk); for (int i = 0; i < CHUNK_SIZE + 2; i++) { delete heightMap[i]; } delete heightMap; } }*/ //Soft test int **heightMap; heightMap = new int*[CHUNK_SIZE + 2]; for (int i1 = 0; i1 < CHUNK_SIZE + 2; i1++) { heightMap[i1] = new int[CHUNK_SIZE + 2]; for (int j1 = 0; j1 < CHUNK_SIZE + 2; j1++) { heightMap[i1][j1] = int(1000 * PerlinNoise::getPerlinNoise(i1 - 1, j1 - 1, 10000) + 100 * PerlinNoise::getPerlinNoise(i1 - 1, j1 - 1, 200)); } } Engine::Chunk* chunk = new Engine::Chunk(glm::vec3(0, 0, 0), heightMap); chunk->addStructure(new Ground(heightMap)); chunk->addStructure(new Source(glm::vec3(7, 7, 0), this)); chunk->init(); _chunks.emplace_back(chunk); for (int i = 0; i < CHUNK_SIZE + 2; i++) { delete heightMap[i]; } delete heightMap; //Définition et initialisation des matrices de projection glm::mat4 projection; glm::mat4 modelview; projection = glm::perspective(70.0, (double)WINDOW_WIDTH / WINDOW_HEIGHT, 1.0, 2000.0); modelview = glm::mat4(1.0); startFpsTicks = SDL_GetTicks(); //Boucle principale while (_gameState != GameState::EXIT) { startTicks = SDL_GetTicks(); //Gestion des inputs _inputManager.update(); _inputManager.processInput(); checkEnd(); _camera.update(_inputManager, modelview); //Nettoyage de l'écran glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); _scene.getShader().use(); glUniformMatrix4fv(glGetUniformLocation(_scene.getShader().getProgramID(), "modelview"), 1, GL_FALSE, value_ptr(modelview)); glUniformMatrix4fv(glGetUniformLocation(_scene.getShader().getProgramID(), "projection"), 1, GL_FALSE, value_ptr(projection)); //Hard test /*for (auto chunk : _chunks) { chunk->update(); chunk->draw(); }*/ //Soft test physicalSteps++; if (physicalSteps % 100 == 0 && physicalSteps < 601) { chunk->timeStep(); } chunk->update(); chunk->draw(); _scene.getShader().unuse(); //Actualisation de la fenêtre SDL_GL_SwapWindow(_scene.getWindow()); //Limitation des FPS endTicks = SDL_GetTicks(); elapsedTime = endTicks - startTicks; if (elapsedTime < frameRate) { SDL_Delay(frameRate - elapsedTime); } //Calcul des FPS toutes les 100 frames steps++; if (steps == 100) { endFpsTicks = SDL_GetTicks(); int fps = steps*1000 / (endFpsTicks - startFpsTicks); std::cout << "FPS : " << fps << std::endl; steps -= 100; startFpsTicks = SDL_GetTicks(); } } }
void Shader::setUniformMatrix4f(GLint uniformLocation,mat4 &value) { glUniformMatrix4fv(uniformLocation,1,GL_FALSE,value_ptr(value)); }
void SharedProgramState::updateTo(GL::Uniform& uniform) { switch (uniform.sharedID()) { case SHARED_MODEL_MATRIX: { uniform.copyFrom(value_ptr(m_modelMatrix)); return; } case SHARED_VIEW_MATRIX: { uniform.copyFrom(value_ptr(m_viewMatrix)); return; } case SHARED_PROJECTION_MATRIX: { uniform.copyFrom(value_ptr(m_projectionMatrix)); return; } case SHARED_MODELVIEW_MATRIX: { if (m_dirtyModelView) { m_modelViewMatrix = m_viewMatrix; m_modelViewMatrix *= m_modelMatrix; m_dirtyModelView = false; } uniform.copyFrom(value_ptr(m_modelViewMatrix)); return; } case SHARED_VIEWPROJECTION_MATRIX: { if (m_dirtyViewProj) { m_viewProjMatrix = m_projectionMatrix; m_viewProjMatrix *= m_viewMatrix; m_dirtyViewProj = false; } uniform.copyFrom(value_ptr(m_viewProjMatrix)); return; } case SHARED_MODELVIEWPROJECTION_MATRIX: { if (m_dirtyModelViewProj) { if (m_dirtyViewProj) { m_viewProjMatrix = m_projectionMatrix; m_viewProjMatrix *= m_viewMatrix; m_dirtyViewProj = false; } m_modelViewProjMatrix = m_viewProjMatrix; m_modelViewProjMatrix *= m_modelMatrix; m_dirtyModelViewProj = false; } uniform.copyFrom(value_ptr(m_modelViewProjMatrix)); return; } case SHARED_INVERSE_MODEL_MATRIX: { if (m_dirtyInvModel) { m_invModelMatrix = inverse(m_modelMatrix); m_dirtyInvModel = false; } uniform.copyFrom(value_ptr(m_invModelMatrix)); return; } case SHARED_INVERSE_VIEW_MATRIX: { if (m_dirtyInvView) { m_invViewMatrix = inverse(m_viewMatrix); m_dirtyInvView = false; } uniform.copyFrom(value_ptr(m_invViewMatrix)); return; } case SHARED_INVERSE_PROJECTION_MATRIX: { if (m_dirtyInvProj) { m_invProjMatrix = inverse(m_projectionMatrix); m_dirtyInvProj = false; } uniform.copyFrom(value_ptr(m_invProjMatrix)); return; } case SHARED_INVERSE_MODELVIEW_MATRIX: { if (m_dirtyInvModelView) { if (m_dirtyModelView) { m_modelViewMatrix = m_viewMatrix; m_modelViewMatrix *= m_modelMatrix; m_dirtyModelView = false; } m_invModelViewMatrix = inverse(m_modelViewMatrix); m_dirtyInvModelView = false; } uniform.copyFrom(value_ptr(m_invModelViewMatrix)); return; } case SHARED_INVERSE_VIEWPROJECTION_MATRIX: { if (m_dirtyInvViewProj) { if (m_dirtyViewProj) { m_viewProjMatrix = m_projectionMatrix; m_viewProjMatrix *= m_viewMatrix; m_dirtyViewProj = false; } m_invViewProjMatrix = inverse(m_viewProjMatrix); m_dirtyInvViewProj = false; } uniform.copyFrom(value_ptr(m_invViewProjMatrix)); return; } case SHARED_INVERSE_MODELVIEWPROJECTION_MATRIX: { if (m_dirtyInvModelViewProj) { if (m_dirtyModelViewProj) { if (m_dirtyViewProj) { m_viewProjMatrix = m_projectionMatrix; m_viewProjMatrix *= m_viewMatrix; m_dirtyViewProj = false; } m_modelViewProjMatrix = m_viewProjMatrix; m_modelViewProjMatrix *= m_modelMatrix; m_dirtyModelViewProj = false; } m_invModelViewProjMatrix = inverse(m_modelViewProjMatrix); m_dirtyInvModelViewProj = false; } uniform.copyFrom(value_ptr(m_invModelViewProjMatrix)); return; } case SHARED_CAMERA_POSITION: { uniform.copyFrom(value_ptr(m_cameraPos)); return; } case SHARED_CAMERA_NEAR_Z: { uniform.copyFrom(&m_cameraNearZ); return; } case SHARED_CAMERA_FAR_Z: { uniform.copyFrom(&m_cameraFarZ); return; } case SHARED_CAMERA_ASPECT_RATIO: { uniform.copyFrom(&m_cameraAspect); return; } case SHARED_CAMERA_FOV: { uniform.copyFrom(&m_cameraFOV); return; } case SHARED_VIEWPORT_WIDTH: { uniform.copyFrom(&m_viewportWidth); return; } case SHARED_VIEWPORT_HEIGHT: { uniform.copyFrom(&m_viewportHeight); return; } case SHARED_TIME: { uniform.copyFrom(&m_time); return; } } logError("Unknown shared uniform %s requested", uniform.name().c_str()); }
typename genType::value_type * begin(genType& v){ return value_ptr(v); }
Mesh Simulation::step(mat4x4 &matrix) { random_device rd; mt19937 gen(rd()); normal_distribution<> d(0, 1); btTransform transLast, trans; fallRigidBody->getMotionState()->getWorldTransform(transLast); dynamicsWorld->stepSimulation(1.0 / FPS); fallRigidBody->getMotionState()->getWorldTransform(trans); //if (!((uint)time%10)) // cout << trans.getOrigin().getX() << " " << trans.getOrigin().getY() << " " << trans.getOrigin().getZ() << endl; dynamicsWorld->removeRigidBody(fallRigidBody); Mesh mesh = getMesh(); fallRigidBody->setCollisionShape(fallShape); //fallRigidBody->applyImpulse(btVector3(0, 1, 0), btVector3(0, 0, 0)); double rTime = time-warmup; if (FPS == 20) rTime = time-66; colWas = false; MyContactResultCallback callback(this); dynamicsWorld->contactPairTest(fallRigidBody, groundRigidBody, callback); double yDiff = trans.getOrigin().y() - transLast.getOrigin().y(); if (colWas && yDiff>0 && rTime>0) { if (!colBefore) { //cout << "up! " << chrono::system_clock::now().time_since_epoch().count() << endl; glm::vec3 pos(minPos.x(), minPos.y(), minPos.z()); pos = glm::normalize(pos); pos *= -yDiff*1000; //cout << pos.x << " " << pos.y << " " << pos.z << endl; fallRigidBody->applyForce(btVector3(0, yDiff*500, 0), minPos); colBefore = true; } } else colBefore = false; btScalar mass = 1; btVector3 fallInertia(0, 0, 0); fallShape->calculateLocalInertia(mass, fallInertia); fallRigidBody->setMassProps(1, fallInertia); fallRigidBody->updateInertiaTensor(); /*if (rTime>0) fallRigidBody->setRollingFriction(-0.5);*/ dynamicsWorld->addRigidBody(fallRigidBody); if (rTime>0) { dynamicsWorld->removeRigidBody(groundRigidBody); //groundRigidBody->setRollingFriction(0.2); dynamicsWorld->addRigidBody(groundRigidBody); } if (rTime==0) { basePos = getPos(); } time++; /*btVector3 posV = trans.getOrigin();//fallRigidBody->getCenterOfMassPosition(); btQuaternion quat = trans.getRotation();//fallRigidBody->getOrientation(); vec3 tVec(posV.x(), posV.y(), posV.z()); glm::quat quaternion(quat.x(), quat.y(), quat.z(), quat.w()); matrix = mat4_cast(quaternion); matrix = translate(matrix, tVec);*/ trans.getOpenGLMatrix(value_ptr(matrix)); lastMatrix = matrix; return mesh; /*btSoftBodyWorldInfo m_softBodyWorldInfo; btSoftBody softBody(&m_softBodyWorldInfo); softBody.*/ }
GLM_FUNC_QUALIFIER detail::tquat<T> make_quat(T const * const ptr) { detail::tquat<T> Result; memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T>)); return Result; }
/* * Splits a node by creating two new children beneath the given node. * * Before: * +----------+ * | A ++++++ | * +----------+ * * * After: * +------------+ * | A (shadow) | * +------------+ * | | * +------+ +----+ * | | * v v * +-------+ +-------+ * | B +++ | | C +++ | * +-------+ +-------+ */ static int btree_split_beneath(struct shadow_spine *s, uint64_t key) { int r; size_t size; unsigned nr_left, nr_right; struct dm_block *left, *right, *new_parent; struct btree_node *pn, *ln, *rn; __le64 val; new_parent = shadow_current(s); r = new_block(s->info, &left); if (r < 0) return r; r = new_block(s->info, &right); if (r < 0) { /* FIXME: put left */ return r; } pn = dm_block_data(new_parent); ln = dm_block_data(left); rn = dm_block_data(right); nr_left = le32_to_cpu(pn->header.nr_entries) / 2; nr_right = le32_to_cpu(pn->header.nr_entries) - nr_left; ln->header.flags = pn->header.flags; ln->header.nr_entries = cpu_to_le32(nr_left); ln->header.max_entries = pn->header.max_entries; ln->header.value_size = pn->header.value_size; rn->header.flags = pn->header.flags; rn->header.nr_entries = cpu_to_le32(nr_right); rn->header.max_entries = pn->header.max_entries; rn->header.value_size = pn->header.value_size; memcpy(ln->keys, pn->keys, nr_left * sizeof(pn->keys[0])); memcpy(rn->keys, pn->keys + nr_left, nr_right * sizeof(pn->keys[0])); size = le32_to_cpu(pn->header.flags) & INTERNAL_NODE ? sizeof(__le64) : s->info->value_type.size; memcpy(value_ptr(ln, 0), value_ptr(pn, 0), nr_left * size); memcpy(value_ptr(rn, 0), value_ptr(pn, nr_left), nr_right * size); /* new_parent should just point to l and r now */ pn->header.flags = cpu_to_le32(INTERNAL_NODE); pn->header.nr_entries = cpu_to_le32(2); pn->header.max_entries = cpu_to_le32( calc_max_entries(sizeof(__le64), dm_bm_block_size( dm_tm_get_bm(s->info->tm)))); pn->header.value_size = cpu_to_le32(sizeof(__le64)); val = cpu_to_le64(dm_block_location(left)); __dm_bless_for_disk(&val); pn->keys[0] = ln->keys[0]; memcpy_disk(value_ptr(pn, 0), &val, sizeof(__le64)); val = cpu_to_le64(dm_block_location(right)); __dm_bless_for_disk(&val); pn->keys[1] = rn->keys[0]; memcpy_disk(value_ptr(pn, 1), &val, sizeof(__le64)); /* * rejig the spine. This is ugly, since it knows too * much about the spine */ if (s->nodes[0] != new_parent) { unlock_block(s->info, s->nodes[0]); s->nodes[0] = new_parent; } if (key < le64_to_cpu(rn->keys[0])) { unlock_block(s->info, right); s->nodes[1] = left; } else { unlock_block(s->info, left); s->nodes[1] = right; } s->count = 2; return 0; }
int main(int /*argc*/, char ** /*argv*/) { BaseApp app; ProgramObject programEnv, program; auto mainWindow = app.getMainWindow(); PerspectiveCamera cam; OrbitManipulator manipulator(&cam); manipulator.setupCallbacks(app); manipulator.setZoom(3); GLuint diffuseTexture; GLuint specularTexture; GLuint vao; GLuint vaoEmpty; GLuint vbo; int32_t sphereSizeX = 20; int32_t sphereSizeY = 20; app.addInitCallback([&]() { std::string prefix = app.getResourceDir() + "Shaders/Tutorial/"; auto vs = compileShader(GL_VERTEX_SHADER, "#version 450\n", Loader::text(prefix + "uv.vp")); auto fs = compileShader(GL_FRAGMENT_SHADER, "#version 450\n", Loader::text(prefix + "lighting.vp"), Loader::text(prefix + "uv.fp")); program = createProgram(vs, fs); std::string texPrefix = app.getResourceDir() + "Textures/Tutorial/"; diffuseTexture = Loader::texture(texPrefix + "earth.png"); specularTexture = Loader::texture(texPrefix + "earth_s.png"); glCreateBuffers(1, &vbo); const uint32_t floatsPerVertex = 6; const uint32_t vertiesPerFace = 6; float*vertices = new float[sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex]; for (int32_t y = 0; y<sphereSizeY; ++y) { for (int32_t x = 0; x<sphereSizeX; ++x) { for (uint32_t k = 0; k<vertiesPerFace; ++k) { const int32_t xOffset[] = { 0,1,0,0,1,1 }; const int32_t yOffset[] = { 0,0,1,1,0,1 }; float u = (float)(x + xOffset[k]) / sphereSizeX; float v = (float)(y + yOffset[k]) / sphereSizeY; float xAngle = -u*glm::two_pi<float>(); float yAngle = v*glm::pi<float>(); uint32_t faceId = y*sphereSizeX + x; uint32_t faceVertex = faceId*vertiesPerFace + k; vertices[faceVertex*floatsPerVertex + 0] = glm::cos(xAngle)*glm::sin(yAngle); vertices[faceVertex*floatsPerVertex + 1] = -glm::cos(yAngle); vertices[faceVertex*floatsPerVertex + 2] = glm::sin(xAngle)*glm::sin(yAngle); vertices[faceVertex*floatsPerVertex + 3] = 1; vertices[faceVertex*floatsPerVertex + 4] = u; vertices[faceVertex*floatsPerVertex + 5] = v; } } } glNamedBufferData(vbo, sizeof(float)*sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex, vertices, GL_STATIC_DRAW); delete[]vertices; glCreateVertexArrays(1, &vao); glEnableVertexArrayAttrib(vao, 0); glVertexArrayAttribFormat(vao, 0, 4, GL_FLOAT, 0, 0); glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(float)*floatsPerVertex); glEnableVertexArrayAttrib(vao, 1); glVertexArrayAttribFormat(vao, 1, 2, GL_FLOAT, 0, 0); glVertexArrayVertexBuffer(vao, 1, vbo, sizeof(float) * 4, sizeof(float)*floatsPerVertex); glClearColor(0, 0, 0, 1); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); }); app.addResizeCallback([&](int w, int h) { glViewport(0, 0, w, h); cam.setAspect(float(w) / float(h)); }); app.addDrawCallback([&]() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); program.use(); glBindTextureUnit(0, diffuseTexture); glBindTextureUnit(1, specularTexture); program.setMatrix4fv("p", value_ptr(cam.getProjection())); program.setMatrix4fv("v", value_ptr(cam.getView())); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, sphereSizeX*sphereSizeY * 6); glBindVertexArray(0); }); return app.run(); }
void Test10::Render() { glBindFramebuffer(GL_FRAMEBUFFER,m_FBO); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_GL_program->Use(); vec3 pos_llum = vec3(m_llum->GetPosition()); m_GL_program->SetUniform("pLight",value_ptr(pos_llum),3,1); //CALCULO LA POSICIO DEL QUE VISIONA EL MIRALL vec3 posicio_mirall = vec3(0.0,0.0,-40.0); CGLCamera *m_camera_pointer = CGLCamera::GetInstance(); vec3 posicio_camera= m_camera_pointer->GetPosition(); //cout<<"POS 1: "<<posicio_camera.x<<" "<<posicio_camera.y<<" "<<posicio_camera.z<<endl; posicio_camera.z=(posicio_mirall.z -posicio_camera.z); posicio_camera.z=posicio_camera.z+posicio_mirall.z; //m_posicio_camera->SetPosition(vec4(posicio_camera,1.0)); //cout<<"POS 2: "<<posicio_camera.x<<" "<<posicio_camera.y<<" "<<posicio_camera.z<<endl; //mat4 NewWorldToCamera = glm::lookAt(posicio_camera,posicio_mirall,glm::vec3(0.0,1.0,0.0)); //NewWorldToCamera= NewWorldToCamera * scale(vec3(-1.0,1.0,1.0)); mat4 NewWorldToCamera = glm::lookAt(glm::vec3(m_camera_pointer->GetPosition().x,m_camera_pointer->GetPosition().y,m_camera_pointer->GetPosition().z),m_camera_pointer->GetPositionEnd(),m_camera_pointer->GetUpVector()); m_GL_program->SetUniformMatrix("NewWorldToCamera",value_ptr(NewWorldToCamera),4,4,false,1); //RENDER DONUT m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,0.0,0.0)); mat4 identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_donut->Render(m_GL_program); //RENDER DONUT 2 m_stack.LoadIdentity(); m_stack.Translate(vec3(10.0,0.0,0.0)); m_stack.RotateX(90.0); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_donut->Render(m_GL_program); //RENDER ESFERA m_stack.LoadIdentity(); m_stack.Translate(vec3(-15.0,10.0,0.0)); m_stack.Scale(vec3(0.3,0.3,0.3)); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_esfera->Render(m_GL_program); //RENDERITZEM EL PLA D'ABAIX m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,-20.0,0.0)); m_stack.Scale(vec3(100,100,100)); //m_stack.RotateX(90.0); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_pla->Render(m_GL_program); m_llum->Render(NewWorldToCamera); //m_posicio_camera->Render(); m_GL_program->UnUse(); //FI RENDERITZAT glBindFramebuffer(GL_FRAMEBUFFER,0); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_GL_program_normal->Use(); vec3 pos_llum2 = vec3(m_llum->GetPosition()); m_GL_program_normal->SetUniform("pLight",value_ptr(pos_llum2),3,1); //RENDER DONUT m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,0.0,0.0)); mat4 identitat2 = m_stack.Top(); m_GL_program_normal->SetUniformMatrix("ModelToWorld",value_ptr(identitat2),4,4,false,1); m_mesh_donut->Render(m_GL_program_normal); //RENDER DONUT 2 m_stack.LoadIdentity(); m_stack.Translate(vec3(10.0,0.0,0.0)); m_stack.RotateX(90.0); identitat2 = m_stack.Top(); m_GL_program_normal->SetUniformMatrix("ModelToWorld",value_ptr(identitat2),4,4,false,1); m_mesh_donut->Render(m_GL_program_normal); //RENDER ESFERA m_stack.LoadIdentity(); m_stack.Translate(vec3(-15.0,10.0,0.0)); m_stack.Scale(vec3(0.3,0.3,0.3)); identitat2 = m_stack.Top(); m_GL_program_normal->SetUniformMatrix("ModelToWorld",value_ptr(identitat2),4,4,false,1); m_mesh_esfera->Render(m_GL_program_normal); //RENDERITZEM EL PLA D'ABAIX m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,-20.0,0.0)); m_stack.Scale(vec3(100,100,100)); //m_stack.RotateX(90.0); identitat2 = m_stack.Top(); m_GL_program_normal->SetUniformMatrix("ModelToWorld",value_ptr(identitat2),4,4,false,1); m_mesh_pla->Render(m_GL_program_normal); m_llum->Render(); m_GL_program_normal->UnUse(); m_GL_program_RText->Use(); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, m_FBOcolor_textura); //glBindTexture(GL_TEXTURE_2D, m_FBOdepth_textura); m_GL_program_RText->SetUniform("textura",2); if (pla_activat) { m_stack.LoadIdentity(); m_stack.Translate(posicio_mirall); m_stack.Scale(vec3(8,8,8)); m_stack.RotateX(90.0); identitat2 = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat2),4,4,false,1); m_mesh_pla->Render(m_GL_program_RText); } m_GL_program_RText->UnUse(); /* //ES EL PLA DEL MIRALL!!! glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //mat4 NewWorldToCamera = glm::lookAt(glm::vec3(posicio_camera),glm::vec3(posicio_mirall),glm::vec3(0.0,1.0,0.0)); mat4 NewWorldToCamera2 = glm::lookAt(glm::vec3(m_camera_pointer->GetPosition()),glm::vec3(0.0,0.0,0.0),glm::vec3(m_camera_pointer->GetUpVector())); m_GL_program->SetUniformMatrix("NewWorldToCamera",value_ptr(NewWorldToCamera2),4,4,false,1); m_GL_program->Use(); pos_llum = vec3(m_llum->GetPosition()); m_GL_program->SetUniform("pLight",value_ptr(pos_llum),3,1); //RENDER MESH DONUT m_stack.LoadIdentity(); //m_stack.Translate(vec3(0.0,0.0,0.0)); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_donut->Render(m_GL_program); //RENDER MESH ESFERA m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,10.0,0.0)); m_stack.Scale(vec3(0.3,0.3,0.3)); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_esfera->Render(m_GL_program); //RENDERITZEM EL PLA D'ABAIX m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,-20.0,0.0)); m_stack.Scale(vec3(100,100,100)); //m_stack.RotateX(90.0); identitat = m_stack.Top(); m_GL_program->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_pla->Render(m_GL_program); m_llum->Render(); m_posicio_camera->SetPosition(vec4(0.0,0.0,0.0,1.0)); m_posicio_camera->Render(); m_GL_program->UnUse(); /* //DEFAULT FRAMEBUFFER glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_GL_program_RText->Use(); glActiveTexture(GL_TEXTURE2); //glBindTexture(GL_TEXTURE_2D, m_FBOcolor_textura); glBindTexture(GL_TEXTURE_2D, m_FBOdepth_textura); m_GL_program_RText->SetUniform("textura",2); m_stack.LoadIdentity(); m_stack.Translate(vec3(0.0,0.0,7.0)); m_stack.RotateX(90.0); identitat = m_stack.Top(); mat4 worldtocamerainicial = m_camera_pointer->GetModelViewMatrixINICIAL(); m_GL_program_RText->SetUniformMatrix("WorldToCameraInicial",value_ptr(worldtocamerainicial),4,4,false,1); m_GL_program_RText->SetUniformMatrix("ModelToWorld",value_ptr(identitat),4,4,false,1); m_mesh_pla->Render(m_GL_program_RText); */ }
void App::drawFrame() { // Update the PFX updatePFX(frameTime); float clearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; renderer->clear(true, true, false, clearColor); // Draw the background float maxY = (float)height / (float)width * 100.0f; renderer->setup2DMode(-50.0f, 50.0f, maxY, 0.0f); renderer->reset(); ((OpenGLRenderer*)renderer)->setTexture(m_texBackground); renderer->apply(); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(-50.0f, maxY); glTexCoord2f(1.0f, 0.0f); glVertex2f(50.0f, maxY); glTexCoord2f(1.0f, 1.0f); glVertex2f(50.0f, 0.0f); glTexCoord2f(0.0f, 1.0f); glVertex2f(-50.0f, 0.0f); glEnd(); // Draw the traditional blending // Setup scissor glEnable(GL_SCISSOR_TEST); glScissor(0, 0, m_divPos, height); // Render each particle one by one, as the blend mode can change per particle uint32_t drawCallCount = 0; { auto drawQuad = [&](const Particle& p) { drawCallCount++; glBegin(GL_QUADS); vec2 offset1 = vec2(cosf(p.m_rotation), sinf(p.m_rotation)) * p.m_size; vec2 offset2 = vec2(-offset1.y, offset1.x); glTexCoord2f(0.0f, 0.0f); glVertex2fv(value_ptr(p.m_position - offset1 - offset2)); glTexCoord2f(1.0f, 0.0f); glVertex2fv(value_ptr(p.m_position + offset1 - offset2)); glTexCoord2f(1.0f, 1.0f); glVertex2fv(value_ptr(p.m_position + offset1 + offset2)); glTexCoord2f(0.0f, 1.0f); glVertex2fv(value_ptr(p.m_position - offset1 + offset2)); glEnd(); }; auto drawAdditiveMode = [&](const Particle& p) { renderer->reset(); renderer->setBlendState(m_blendModeAdditve); ((OpenGLRenderer*)renderer)->setTexture(m_texAdditve); glColor4f(p.m_alpha, p.m_alpha, p.m_alpha, 1.0f); renderer->apply(); drawQuad(p); }; auto drawMultiplyMode = [&](const Particle& p) { renderer->reset(); renderer->setBlendState(m_blendModeMultiply); ((OpenGLRenderer*)renderer)->setTexture(m_texMultiply); glColor4f(p.m_alpha, p.m_alpha, p.m_alpha, 1.0f); renderer->apply(); drawQuad(p); }; auto drawBlendMode = [&](const Particle& p) { renderer->reset(); renderer->setBlendState(m_blendModeBlend); ((OpenGLRenderer*)renderer)->setTexture(m_texBlend); glColor4f(1.0f, 1.0f, 1.0f, p.m_alpha); renderer->apply(); drawQuad(p); }; for (Particle& p : m_particles) { // Bind the appropiate blend mode and texture switch (p.m_type) { case(ParticleType::Additive): drawAdditiveMode(p); break; case(ParticleType::Multiply): drawMultiplyMode(p); break; case(ParticleType::Blend): drawBlendMode(p); break; case(ParticleType::BlendAddMul): drawBlendMode(p); drawAdditiveMode(p); drawMultiplyMode(p); break; } } } // Draw the pre-mul alpha // Setup scissor glScissor(m_divPos, 0, width, height); renderer->reset(); renderer->setBlendState(m_blendModePreMul); ((OpenGLRenderer*)renderer)->setTexture(m_texPreMul); renderer->apply(); glBegin(GL_QUADS); for (Particle& p : m_particles) { vec2 offset1 = vec2(cosf(p.m_rotation), sinf(p.m_rotation)) * p.m_size; vec2 offset2 = vec2(-offset1.y, offset1.x); float texSize = 0.5f; float texOffsetX = 0.0f; float texOffsetY = 0.0f; switch (p.m_type) { case(ParticleType::Additive): texOffsetX = 0.0f; texOffsetY = 0.0f; break; case(ParticleType::Multiply): texOffsetX = texSize; texOffsetY = 0.0f; break; case(ParticleType::Blend): texOffsetX = 0.0f; texOffsetY = texSize; break; case(ParticleType::BlendAddMul): texOffsetX = texSize; texOffsetY = texSize; break; } glColor4f(p.m_alpha, p.m_alpha, p.m_alpha, p.m_alpha); glTexCoord2f(texOffsetX, texOffsetY); glVertex2fv(value_ptr(p.m_position - offset1 - offset2)); glTexCoord2f(texOffsetX + texSize, texOffsetY); glVertex2fv(value_ptr(p.m_position + offset1 - offset2)); glTexCoord2f(texOffsetX + texSize, texOffsetY + texSize); glVertex2fv(value_ptr(p.m_position + offset1 + offset2)); glTexCoord2f(texOffsetX, texOffsetY + texSize); glVertex2fv(value_ptr(p.m_position - offset1 + offset2)); } glEnd(); // Reset the scissor glDisable(GL_SCISSOR_TEST); // Draw the dividing line renderer->reset(); renderer->setup2DMode(0, (float)width, 0, (float)height); renderer->apply(); glBegin(GL_QUADS); glColor3f(0.5f, 0.5f, 0.5f); glVertex2i(m_divPos - 1, 0); glVertex2i(m_divPos + 1, 0); glVertex2i(m_divPos + 1, height); glVertex2i(m_divPos - 1, height); glEnd(); // Draw the draw call counts { char buffer[100]; sprintf(buffer, "Draw calls = %d", drawCallCount); renderer->drawText("Mixed blend mode", 30.0f, 38.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); renderer->drawText(buffer, 30.0f, 68.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); renderer->drawText("Pre-multiply", (float)width - 200.0f, 38.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); renderer->drawText("Draw calls = 1", (float)width - 200.0f, 68.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); //#ifdef _DEBUG // float xPos = (float)width - 250.0f; // sprintf(buffer, "Alloc Count %d", g_allocRequestCount); // renderer->drawText(buffer, xPos, 138.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); // // sprintf(buffer, "Free Count %d", g_allocFreeCount); // renderer->drawText(buffer, xPos, 168.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); // // sprintf(buffer, "Working Count %d", g_allocRequestCount - g_allocFreeCount); // renderer->drawText(buffer, xPos, 198.0f, 30, 38, defaultFont, linearClamp, blendSrcAlpha, noDepthTest); //#endif // _DEBUG } }
void StaticObject::assignUniformData(char *variable, mat4 &data, ShaderObject *shader) { int index = std::find(shader->uniformReference.begin(), shader->uniformReference.end(), variable) - shader->uniformReference.begin(); glUniformMatrix4fv(shader->uniform[index], 1, GL_FALSE, value_ptr(data)); }
void Shader::updateVec4(const char* name, vec4 v) { GLint x = findUniform(name); if (x != -1) glUniform4fv(x, 1, value_ptr(v)); }
void Shader::updateMat4(const char* name, mat4 v) { GLint x = findUniform(name); if (x != -1) glUniformMatrix4fv(x, 1, GL_FALSE, value_ptr(v)); }
int dm_btree_del(struct dm_btree_info *info, dm_block_t root) { int r; struct del_stack *s; s = kmalloc(sizeof(*s), GFP_KERNEL); if (!s) return -ENOMEM; s->info = info; s->tm = info->tm; s->top = -1; r = push_frame(s, root, 0); if (r) goto out; while (unprocessed_frames(s)) { uint32_t flags; struct frame *f; dm_block_t b; r = top_frame(s, &f); if (r) goto out; if (f->current_child >= f->nr_children) { pop_frame(s); continue; } flags = le32_to_cpu(f->n->header.flags); if (flags & INTERNAL_NODE) { b = value64(f->n, f->current_child); f->current_child++; r = push_frame(s, b, f->level); if (r) goto out; } else if (is_internal_level(info, f)) { b = value64(f->n, f->current_child); f->current_child++; r = push_frame(s, b, f->level + 1); if (r) goto out; } else { if (info->value_type.dec) { unsigned i; for (i = 0; i < f->nr_children; i++) info->value_type.dec(info->value_type.context, value_ptr(f->n, i)); } pop_frame(s); } } out: kfree(s); return r; }
void CChildView::InitGL() { // Create a checkerboard pattern for (int i = 0; i < 64; i++) { for (int j = 0; j < 64; j++) { GLubyte c; c = (((i & 0x8) == 0) ^ ((j & 0x8) == 0)) * 255; image[i][j][0] = c; image[i][j][1] = c; image[i][j][2] = c; image2[i][j][0] = c; image2[i][j][1] = 0; image2[i][j][2] = c; } } colorcube(); m_program = LoadShaders( "ShaderWnd/vertex.glsl", "ShaderWnd/fragment.glsl" ); static const vec4 g_vertex_buffer_data[] = { vec4(-1.0f, -1.0f, 0.0f, 1.0f), vec4(1.0f, -1.0f, 0.0f, 1.0f), vec4(0.0f, 0.5f, 0.0f, 1.0f) }; static const vec4 g_color_buffer_data[] = { vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(0.0f, 1.0f, 0.0f, 1.0f), vec4(0.0f, 0.0f, 1.0f, 1.0f) }; //GLuint vertexbuffer; glUseProgram(m_program); GLuint vao; glGenVertexArrays( 1, &vao); glBindVertexArray( vao); /*glGenBuffers(1, &vertexbuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);*/ glGenTextures(2, textures); glBindTexture(GL_TEXTURE_2D, textures[0]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureSize,TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image); 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_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, textures[1]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureSize,TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image2); 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_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glActiveTexture( GL_TEXTURE0 ); glBindTexture( GL_TEXTURE_2D, textures[0]); glActiveTexture( GL_TEXTURE1 ); glBindTexture( GL_TEXTURE_2D, textures[1]); // Create and initialize a buffer object GLuint buffer; glGenBuffers(1, &buffer); glBindBuffer(GL_ARRAY_BUFFER, buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(tex_coords) + sizeof(normals), NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(points), value_ptr(points[0])); glBufferSubData(GL_ARRAY_BUFFER, sizeof(points), sizeof(normals), value_ptr(normals[0])); glBufferSubData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals), sizeof(tex_coords), value_ptr(tex_coords[0])); point4 light_position (-5.f, 5.f, -5.f, 0.f); color4 light_ambient (0.2f, 0.2f, 0.2f, 1.f); color4 light_diffuse (1.f, 1.f, 1.f, 1.f); color4 light_specular (1.f, 1.f, 1.f, 1.f); color4 material_ambient(.3f, .6f, .3f, 1.f); color4 material_diffuse (0.3f, .6f, 0.3f, 1.f); color4 material_specular (1.f, 1.f, 1.f, 1.f); float material_shininess = 100.0f; color4 ambient_product = light_ambient*material_ambient; color4 diffuse_product = light_diffuse*material_diffuse; color4 specular_product = light_specular*material_specular; glUniform4fv(glGetUniformLocation(m_program, "AmbientProduct"), 1, value_ptr(ambient_product)); glUniform4fv(glGetUniformLocation(m_program, "DiffuseProduct"), 1, value_ptr(diffuse_product)); glUniform4fv(glGetUniformLocation(m_program, "SpecularProduct"), 1, value_ptr(specular_product)); glUniform4fv(glGetUniformLocation(m_program, "LightPosition"), 1, value_ptr(light_position)); glUniform1f(glGetUniformLocation(m_program, "Shininess"), material_shininess); // set up vertex arrays (after shaders are loaded) GLuint vPosition = glGetAttribLocation(m_program, "vPosition"); glEnableVertexAttribArray(vPosition); glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); GLuint vNormal = glGetAttribLocation(m_program, "vNormal"); glEnableVertexAttribArray(vNormal); glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points))); GLuint vTex = glGetAttribLocation(m_program, "vTexCoord"); glEnableVertexAttribArray(vTex); glVertexAttribPointer(vTex, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points)+sizeof(normals))); // Set the value of the fragment shader texture sampler variable // ("texture") to the the appropriate texture unit. In this case, // zero, for GL_TEXTURE0 which was previously set by calling // glActiveTexture(). glUniform1i( glGetUniformLocation(m_program, "diffuse_mat"), 0); m_nPVM = glGetUniformLocation(m_program, "mPVM"); m_nVM = glGetUniformLocation(m_program, "mVM"); glClearColor(1.f,1.f,1.f,1.f); glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); }
void initProjmatrix() { proj = infinitePerspective(45.f, w / (float)h, .1f); glUniformMatrix4fv(projloc, 1, GL_FALSE, value_ptr(proj)); }
void renderGameObject(shared_ptr<GameObject> gameObject) { MVPMatrix = projMatrix*viewMatrix*gameObject->getModelMatrix(); //shared_ptr<Material> mat = gameObject->getMaterial(); if (gameObject->getShaderProgram() > 0){ currentShaderProgam = gameObject->getShaderProgram(); glUseProgram(currentShaderProgam); } GLint texture0Location = glGetUniformLocation(currentShaderProgam, "texture0"); GLint texture1Location = glGetUniformLocation(currentShaderProgam, "texture1"); if (gameObject->getDiffuseMap() > 0){ currentDiffuseMap = gameObject->getDiffuseMap(); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, currentDiffuseMap); glUniform1i(texture0Location, 0); if (gameObject->getSpecularMap() > 0){ currentSpecMap = gameObject->getSpecularMap(); } glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, currentSpecMap); glUniform1i(texture1Location, 1); GLint MVPLocation = glGetUniformLocation(currentShaderProgam, "MVP"); GLint ambientLightColourLocation = glGetUniformLocation(currentShaderProgam, "ambientLightColour"); GLint ambientMaterialColourLocation = glGetUniformLocation(currentShaderProgam, "ambientMaterialColour"); GLint diffuseLightColourLocation = glGetUniformLocation(currentShaderProgam, "diffuseLightColour"); GLint diffuseLightMaterialLocation = glGetUniformLocation(currentShaderProgam, "diffuseMaterialColour"); GLint lightDirectionLocation = glGetUniformLocation(currentShaderProgam, "lightDirection"); GLint specularLightColourLocation = glGetUniformLocation(currentShaderProgam, "specularLightColour"); GLint specularLightMaterialLocation = glGetUniformLocation(currentShaderProgam, "specularMaterialColour"); GLint specularPowerLocation = glGetUniformLocation(currentShaderProgam, "specularPower"); GLint cameraPositionLocation = glGetUniformLocation(currentShaderProgam, "cameraPosition"); GLint modelLocation = glGetUniformLocation(currentShaderProgam, "Model"); glUniformMatrix4fv(MVPLocation, 1, GL_FALSE, value_ptr(MVPMatrix)); glUniformMatrix4fv(modelLocation, 1, GL_FALSE, value_ptr(gameObject->getModelMatrix())); glUniform4fv(ambientLightColourLocation, 1, value_ptr(ambientLightColour)); glUniform4fv(ambientMaterialColourLocation, 1, value_ptr(gameObject->getAmbientMaterial())); glUniform4fv(diffuseLightColourLocation, 1, value_ptr(diffuseLightColour)); glUniform4fv(diffuseLightMaterialLocation, 1, value_ptr(gameObject->getDiffuseMaterial())); glUniform3fv(lightDirectionLocation, 1, value_ptr(lightDirection)); glUniform4fv(specularLightColourLocation, 1, value_ptr(specularLightColour)); glUniform4fv(specularLightMaterialLocation, 1, value_ptr(gameObject->getSpecularMaterial())); glUniform1f(specularPowerLocation, gameObject->getSpecularPower()); glUniform3fv(cameraPositionLocation, 1, value_ptr(cameraPosition)); glBindVertexArray(gameObject->getVertexArrayObject()); glDrawElements(GL_TRIANGLES, gameObject->getNumberOfIndices(), GL_UNSIGNED_INT, 0); for (int i = 0; i < gameObject->getNumberOfChildren(); i++) { renderGameObject(gameObject->getChild(i)); } }
void Model::BindUniforms(mat4 &mvp) { glUniformMatrix4fv(material_->shader_uniforms_->MVP, 1, GL_FALSE, value_ptr(mvp)); }
/* * Splits a node by creating a sibling node and shifting half the nodes * contents across. Assumes there is a parent node, and it has room for * another child. * * Before: * +--------+ * | Parent | * +--------+ * | * v * +----------+ * | A ++++++ | * +----------+ * * * After: * +--------+ * | Parent | * +--------+ * | | * v +------+ * +---------+ | * | A* +++ | v * +---------+ +-------+ * | B +++ | * +-------+ * * Where A* is a shadow of A. */ static int btree_split_sibling(struct shadow_spine *s, dm_block_t root, unsigned parent_index, uint64_t key) { int r; size_t size; unsigned nr_left, nr_right; struct dm_block *left, *right, *parent; struct btree_node *ln, *rn, *pn; __le64 location; left = shadow_current(s); r = new_block(s->info, &right); if (r < 0) return r; ln = dm_block_data(left); rn = dm_block_data(right); nr_left = le32_to_cpu(ln->header.nr_entries) / 2; nr_right = le32_to_cpu(ln->header.nr_entries) - nr_left; ln->header.nr_entries = cpu_to_le32(nr_left); rn->header.flags = ln->header.flags; rn->header.nr_entries = cpu_to_le32(nr_right); rn->header.max_entries = ln->header.max_entries; rn->header.value_size = ln->header.value_size; memcpy(rn->keys, ln->keys + nr_left, nr_right * sizeof(rn->keys[0])); size = le32_to_cpu(ln->header.flags) & INTERNAL_NODE ? sizeof(uint64_t) : s->info->value_type.size; memcpy(value_ptr(rn, 0), value_ptr(ln, nr_left), size * nr_right); /* * Patch up the parent */ parent = shadow_parent(s); pn = dm_block_data(parent); location = cpu_to_le64(dm_block_location(left)); __dm_bless_for_disk(&location); memcpy_disk(value_ptr(pn, parent_index), &location, sizeof(__le64)); location = cpu_to_le64(dm_block_location(right)); __dm_bless_for_disk(&location); r = insert_at(sizeof(__le64), pn, parent_index + 1, le64_to_cpu(rn->keys[0]), &location); if (r) return r; if (key < le64_to_cpu(rn->keys[0])) { unlock_block(s->info, right); s->nodes[1] = left; } else { unlock_block(s->info, left); s->nodes[1] = right; } return 0; }
SplineSegmentNode::SplineSegmentNode(const char * name, SceneNode * parent): SceneNode(name, parent) { if(m_program == 0) { std::vector<GLuint> shaderList; // Push vertex shader and fragment shader shaderList.push_back(pgr::createShader(GL_VERTEX_SHADER, strVertexShader )); shaderList.push_back(pgr::createShader(GL_FRAGMENT_SHADER, strFragmentShader)); // Create the program with two shaders m_program = pgr::createProgram(shaderList); m_PVMmatrixLoc = glGetUniformLocation( m_program, "PVMmatrix"); m_colLoc = glGetUniformLocation( m_program, "color"); m_posLoc = glGetAttribLocation( m_program, "position"); } if(m_vertexArrayObject == 0) { const size_t resoulution = 10; // number of samples per parameter step m_numberOfCurveSamples = resoulution * curveTestSize; // samples of the drawn curve glGenBuffers(1, &m_vertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject); // reserve space for control points + the curve glBufferData(GL_ARRAY_BUFFER, (curveTestSize + m_numberOfCurveSamples + 4) * sizeof(vec3), NULL, GL_STATIC_DRAW); // 4 for tangents // put given control points first glBufferSubData(GL_ARRAY_BUFFER, 0, curveTestSize * sizeof(vec3), curveTestPoints ); // put computed curve points after GLintptr offset = curveTestSize * sizeof(vec3); for( unsigned i = 0; i < m_numberOfCurveSamples; i++ ) { float t = (float)i/m_numberOfCurveSamples; vec3 position = evaluateCurveSegment( curveTestPoints[0], curveTestPoints[1], curveTestPoints[2], curveTestPoints[3], t); // one point along the curve for parameter t glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(position) ); offset += sizeof(vec3); } // tangent endpoints vec3 t0 = (curveTestPoints[2] - curveTestPoints[0]) * 0.2f; vec3 t1 = (curveTestPoints[3] - curveTestPoints[1]) * 0.2f; glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]-t0) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]+t0) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]-t1) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]+t1) ); offset += sizeof(vec3); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenVertexArrays(1, &m_vertexArrayObject ); glBindVertexArray( m_vertexArrayObject ); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject); // Control points folowed by the points along the curve glEnableVertexAttribArray(m_posLoc); glVertexAttribPointer(m_posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindVertexArray( 0 ); } }
static int btree_insert_raw(struct shadow_spine *s, dm_block_t root, struct dm_btree_value_type *vt, uint64_t key, unsigned *index) { int r, i = *index, top = 1; struct btree_node *node; for (;;) { r = shadow_step(s, root, vt); if (r < 0) return r; node = dm_block_data(shadow_current(s)); /* * We have to patch up the parent node, ugly, but I don't * see a way to do this automatically as part of the spine * op. */ if (shadow_has_parent(s) && i >= 0) { /* FIXME: second clause unness. */ __le64 location = cpu_to_le64(dm_block_location(shadow_current(s))); __dm_bless_for_disk(&location); memcpy_disk(value_ptr(dm_block_data(shadow_parent(s)), i), &location, sizeof(__le64)); } node = dm_block_data(shadow_current(s)); if (node->header.nr_entries == node->header.max_entries) { if (top) r = btree_split_beneath(s, key); else r = btree_split_sibling(s, root, i, key); if (r < 0) return r; } node = dm_block_data(shadow_current(s)); i = lower_bound(node, key); if (le32_to_cpu(node->header.flags) & LEAF_NODE) break; if (i < 0) { /* change the bounds on the lowest key */ node->keys[0] = cpu_to_le64(key); i = 0; } root = value64(node, i); top = 0; } if (i < 0 || le64_to_cpu(node->keys[i]) != key) i++; *index = i; return 0; }
inline typename genType::value_type const * begin(genType const& v) { return value_ptr(v); }
//============================================================================= // //============================================================================= static bool write_data() { data_count = data.count(); QByteArray req,ans; int len=0,tr=0,i,j,rplen,dataoff; bool ok; switch( data_type ) { case( Bits ): len = ((data_count-1)/8)+1; break; case( Bytes ): len = data_count; break; case( Words ): len = 2*data_count; break; case( DWords ): len = 4*data_count; break; case( Floats ): len = 4*data_count; break; default: break; } if( len < 1 || len > 200 ) { cerr << "Error: Data length invalid"; return 1; } req.resize(6+len); req[0] = node; req[1] = 0x43; req[2] = 0x01; req[3] = addr >> 8; req[4] = addr; req[5] = len; switch( io_type ) { case( Mikkon ): req.resize(6+len); req[0] = node; req[1] = 0x43; req[2] = 0x01; req[3] = addr >> 8; req[4] = addr; req[5] = len; dataoff = 6; rplen = dataoff + len + 2; break; case( Holding ): req.resize(7+len); req[0] = node; req[1] = 0x10; req[2] = addr >> 8; req[3] = addr; req[4] = (len / 2) >> 8; req[5] = len / 2; req[6] = len; dataoff = 7; rplen = 6 + 2; break; } for( i=0; i<data_count; i++ ) { ok = value_ptr( data[i], req.data()+dataoff, i ); if( !ok ) { cerr << "Error: Data is invalid." << endl; return 0; } } if( io_type == Mikkon && data_type == Bits ) { req[2] = data[0].toInt() ? 0x05 : 0x03; } CRC::appendCRC16( req ); ans.resize( rplen ); tr=repeats_count; while( tr-- ) { j = sp->query( req, ans ); if( verb_mode > 0 ) { QByteArray ba_ans = ans; ba_ans.resize( j ); cout << "R: " << QByteArray2QString( req ) << endl; cout << "A: " << QByteArray2QString( ba_ans ) << endl; } if( j != ans.size() ) continue; if( CRC::CRC16( ans ) ) continue; if( ans[0] != req[0] ) continue; if( ans[1] != req[1] ) continue; if( ans[2] != req[2] ) continue; if( ans[3] != req[3] ) continue; if( ans[4] != req[4] ) continue; if( ans[5] != req[5] ) continue; break; } if( tr<0 ) { return 1; } return 0; }
void CubMapStudyR::renderSkyBoxFirst() { glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); this->camera->setDeltaTime(glfwGetTime()); this->camera->DoMovement(); mat4 model(1.0f); mat4 view(1.0f); mat4 projection(1.0f); view = this->camera->GetLookAt(); projection = perspective(radians(Camera::aspect), 800.0f / 600.0f, 0.1f, 1000.0f); //绘制天空盒子 glDepthMask(GL_FALSE); skyboxShader->UseProgram(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, this->skyBoxTextureID); glUniformMatrix4fv(glGetUniformLocation(skyboxShader->getProgram(), "view"), 1, GL_FALSE, value_ptr(mat4(mat3(view)))); glUniformMatrix4fv(glGetUniformLocation(skyboxShader->getProgram(), "projection"), 1, GL_FALSE, value_ptr(projection)); glUniform1i(glGetUniformLocation(skyboxShader->getProgram(), "cubemap"), 0); glBindVertexArray(this->skyBoxVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glBindTexture(GL_TEXTURE_CUBE_MAP, 0); glDepthMask(GL_TRUE); //绘制物体 model = translate(model, vec3(0.0f, 0.0f, 0.7f)); model = scale(model, vec3(0.3f, 0.3f, 0.3f)); cubeShader->UseProgram(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, this->cubeTexutrueID); glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "view"), 1, GL_FALSE, value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "projection"), 1, GL_FALSE, value_ptr(projection)); glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "model"), 1, GL_FALSE, value_ptr(model)); glUniform1i(glGetUniformLocation(cubeShader->getProgram(), "Texture1"), 0); glBindVertexArray(this->cubeVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glBindTexture(GL_TEXTURE_2D, 0); }
void Shader::setUniform4fv(GLint uniformLocation,vec4 &value) { glUniform4fv(uniformLocation,1,value_ptr(value)); }
// Display function for GLUT void display() { glViewport(0,0,WIN_WIDTH,WIN_HEIGHT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // camera = crTrans * csTrans * ctTrans * camera; mat4 modelCam = camera * modelView; // Grab the normal matrix from the modelview matrix (upper 3x3 entries of // modelview). mat3 normalMatrix(modelCam); normalMatrix = inverse(normalMatrix); normalMatrix = transpose(normalMatrix); // Tell OpenGL which shader program we want to use. In this case, we are only // using one, but in general we might have many shader programs. glUseProgram(shader->program); // Pass the matrices and animation time to GPU glUniformMatrix4fv(shader->modelViewLoc, 1, GL_FALSE, value_ptr(modelCam)); glUniformMatrix4fv(shader->projectionLoc, 1, GL_FALSE, value_ptr(projection)); glUniformMatrix3fv(shader->normalMatrixLoc, 1, GL_FALSE, value_ptr(normalMatrix)); glUniform3fv(shader->lightPosLoc, 1, value_ptr(lightPos)); glUniform3fv(shader->viewPosLoc, 1, value_ptr(viewPos)); // Buffer vertex data glBindBuffer(GL_ARRAY_BUFFER, shader->vertexBuffer); glBufferData(GL_ARRAY_BUFFER, verts.size() * sizeof(float), verts.data(), GL_DYNAMIC_DRAW); // Enable vertex array glEnableVertexAttribArray(shader->vertexLoc); glVertexAttribPointer(shader->vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL); // Buffer normal data glBindBuffer(GL_ARRAY_BUFFER, shader->normalBuffer); glBufferData(GL_ARRAY_BUFFER, norms.size() * sizeof(float), norms.data(), GL_DYNAMIC_DRAW); // Enable normal array glEnableVertexAttribArray(shader->normalLoc); glVertexAttribPointer(shader->normalLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL); // Buffer color data glBindBuffer(GL_ARRAY_BUFFER, shader->colorBuffer); glBufferData(GL_ARRAY_BUFFER, color.size() * sizeof(float), color.data(), GL_DYNAMIC_DRAW); // Enable color array glEnableVertexAttribArray(shader->colorLoc); glVertexAttribPointer(shader->colorLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); //Bind element buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shader->indexBuffer); for (int i = 0; i < (int) shapes.size(); i++) { glDrawArrays(GL_TRIANGLE_FAN, shapes[i]->startIndex / 3, shapes[i]->numVertices()); } //----------------------------DRAW ARROW----------------------------// if(ballMoving == false){ // Update arrow rotation arrow->rotate(launchAngle); modelCam = camera * arrow->getModelTransformMatrix(); //Pass the matrix glUniformMatrix4fv(shader->modelViewLoc, 1, GL_FALSE, value_ptr(modelCam)); // Buffer vertex data glBindBuffer(GL_ARRAY_BUFFER, shader->vertexBuffer); glBufferData(GL_ARRAY_BUFFER, arrow->getVerts().size() * sizeof(glm::vec3), arrow->getVerts().data(), GL_DYNAMIC_DRAW); // Enable vertex array glEnableVertexAttribArray(shader->vertexLoc); glVertexAttribPointer(shader->vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL); // Disable normal array glDisableVertexAttribArray(shader->normalLoc); // Buffer color data glBindBuffer(GL_ARRAY_BUFFER, shader->colorBuffer); glBufferData(GL_ARRAY_BUFFER, arrow->getVertColors().size() * sizeof(glm::vec4), arrow->getVertColors().data(), GL_DYNAMIC_DRAW); // Enable color array glEnableVertexAttribArray(shader->colorLoc); glVertexAttribPointer(shader->colorLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); glDrawArrays(GL_LINES, 0, 6); } glutSwapBuffers(); }
void Obj::render( Obj* root ) // effect& eff, mat4& PV, vec3& eyeP, directional_light& light) { // flag // return and skill all children // continue extern camera* cam; /* const int numChildren = root->children.size(); for (int i = 0; i < numChildren; ++i) { Obj* child = root->children[i]; render( child ); } */ //root->myCam = cam; mat4 P = cam->get_projection(); mat4 V = cam->get_view(); vec3 eyeP = cam->get_position(); //root->mworld = mat4(1); //auto MVP = root->P * root->V * root->mworld; auto MVP = P * V * root->mworld; //// Bind effect renderer::bind(*root->eff); // Create MVP matrix //auto MVP = root->PV * root->mworld; // Set MVP matrix uniform glUniformMatrix4fv( root->eff->get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // ******************** // Set M matrix uniform // ******************** glUniformMatrix4fv(root->eff->get_uniform_location("M"), 1, GL_FALSE, value_ptr(root->mworld)); // *********************** // Set N matrix uniform // - remember - 3x3 matrix // *********************** mat3 N = root->m->get_transform().get_normal_matrix(); glUniformMatrix3fv(root->eff->get_uniform_location("N"), 1, GL_FALSE, value_ptr(N)); // ************* // Bind material // ************* renderer::bind(root->m->get_material(), "mat"); // ********** // Bind light // ********** renderer::bind(*root->light, "light"); // ************ // Bind texture // ************ renderer::bind(*root->tex, 0); // *************** // Set tex uniform // *************** glUniform1i(root->eff->get_uniform_location("tex"), 0); // ***************************** // Set eye position // - Get this from active camera // ***************************** //vec3 eyeP = root->myCam->get_position(); glUniform3f(root->eff->get_uniform_location("eye_pos"), eyeP.x, eyeP.y, eyeP.z); // Render mesh renderer::render(*root->m); for (auto &e : root->children) { Obj* child = e.second; render(child); } }
void BasicLighting::render() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); double currentTime = glfwGetTime(); mat4 model(1.0f); model = rotate(model, radians(30.0f), vec3(0.0f, 1.0f ,0.0f)); mat4 view = lookAt(vec3(0.0f, 2.0f, 5.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f)); mat4 projection = perspective(radians(45.0f), 800.0f / 600.0f, 0.1f, 1000.0f); colorShader->UseProgram(); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "model"), 1, GL_FALSE, value_ptr(model)); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "view"), 1, GL_FALSE, value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "projection"), 1, GL_FALSE, value_ptr(projection)); glUniform3f(glGetUniformLocation(colorShader->getProgram(), "objectcolor"), 1.0f, 0.5f, 0.31f); glUniform3f(glGetUniformLocation(colorShader->getProgram(), "lightcolor"), 1.0f, 1.0f, 1.0f); glUniform3f(glGetUniformLocation(colorShader->getProgram(), "lightPos"),2 * sin(currentTime), 0.0f, 2 * cos(currentTime)); glUniform3f(glGetUniformLocation(colorShader->getProgram(), "viewPos"), 0.0f, 2.0f, 5.0f); glBindVertexArray(this->ColorVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); //ƽÒÆ Ðýת Ëõ·Å model = translate(mat4(1.0f), vec3(2 * sin(currentTime), 0.0f, 2 * cos(currentTime))); model = rotate(model, radians(-30.0f), vec3(0.0f, 1.0f, 0.0f)); model = scale(model, vec3(0.5f, 0.5f, 0.5f)); lightShader->UseProgram(); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "model"), 1, GL_FALSE, value_ptr(model)); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "view"), 1, GL_FALSE, value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(colorShader->getProgram(), "projection"), 1, GL_FALSE, value_ptr(projection)); glBindVertexArray(this->LightVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); }
constexpr trivial_result_base(trivial_result_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) : has_value(rhs.has_value), storage() { if ( rhs.has_value ) { ::new(value_ptr()) T(rhs.storage.value); } else { ::new(error_ptr()) T(rhs.storage.error); } }
void ShaderProgram::setUniform(int location, const mat3 & m) { glUniformMatrix3fv(location, 1, GL_FALSE, value_ptr(m)); }