Exemplo n.º 1
0
// 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();
		}
	}
}
Exemplo n.º 2
0
void Shader::setUniformMatrix4f(GLint uniformLocation,mat4 &value)
{
    glUniformMatrix4fv(uniformLocation,1,GL_FALSE,value_ptr(value));
}
Exemplo n.º 3
0
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());
}
Exemplo n.º 4
0
	typename genType::value_type * begin(genType& v){
		return value_ptr(v);
	}
Exemplo n.º 5
0
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.*/
}
Exemplo n.º 6
0
	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;
	}
Exemplo n.º 7
0
/*
 * 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;
}
Exemplo n.º 8
0
Arquivo: uv.cpp Projeto: dormon/FitGL
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();
}
Exemplo n.º 9
0
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);

*/
}
Exemplo n.º 10
0
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
  }
}
Exemplo n.º 11
0
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));
}
Exemplo n.º 12
0
void Shader::updateVec4(const char* name, vec4 v)
{
  GLint x = findUniform(name);
  if (x != -1) glUniform4fv(x, 1, value_ptr(v));
}
Exemplo n.º 13
0
void Shader::updateMat4(const char* name, mat4 v)
{
  GLint x = findUniform(name);
  if (x != -1) glUniformMatrix4fv(x, 1, GL_FALSE, value_ptr(v));
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
0
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);
}
Exemplo n.º 16
0
void initProjmatrix() {
	proj = infinitePerspective(45.f, w / (float)h, .1f);

	glUniformMatrix4fv(projloc, 1, GL_FALSE, value_ptr(proj));
}
Exemplo n.º 17
0
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));
	}
}
Exemplo n.º 18
0
void Model::BindUniforms(mat4 &mvp) {
  glUniformMatrix4fv(material_->shader_uniforms_->MVP, 1, GL_FALSE, value_ptr(mvp));
}
Exemplo n.º 19
0
/*
 * 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;
}
Exemplo n.º 20
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 );
  }

}
Exemplo n.º 21
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;
}
Exemplo n.º 22
0
	inline typename genType::value_type const * begin(genType const& v)
	{
		return value_ptr(v);
	}
Exemplo n.º 23
0
//=============================================================================
//
//=============================================================================
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;
}
Exemplo n.º 24
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);
}
Exemplo n.º 25
0
void Shader::setUniform4fv(GLint uniformLocation,vec4 &value)
{
    glUniform4fv(uniformLocation,1,value_ptr(value));
}
Exemplo n.º 26
0
// 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();

}
Exemplo n.º 27
0
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);
	}

}
Exemplo n.º 28
0
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);
}
Exemplo n.º 29
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); }
 }
Exemplo n.º 30
0
void ShaderProgram::setUniform(int location, const mat3 & m)
{
	glUniformMatrix3fv(location, 1, GL_FALSE, value_ptr(m));
}