自学教程：C++ value_ptr函数代码示例

// 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();//.........这里部分代码省略.........

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;      }//.........这里部分代码省略.........

	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);//.........这里部分代码省略.........

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));//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

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));}

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));//.........这里部分代码省略.........

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;  }//.........这里部分代码省略.........

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 GLUTvoid 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);	//
C++ value_type函数代码示例
C++ value_contents函数代码示例