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

void ApplicationOverlay::renderDomainConnectionStatusBorder(RenderArgs* renderArgs) {    auto geometryCache = DependencyManager::get<GeometryCache>();    static std::once_flag once;    std::call_once(once, [&] {        QVector<vec2> points;        static const float B = 0.99f;        points.push_back(vec2(-B));        points.push_back(vec2(B, -B));        points.push_back(vec2(B));        points.push_back(vec2(-B, B));        points.push_back(vec2(-B));        geometryCache->updateVertices(_domainStatusBorder, points, CONNECTION_STATUS_BORDER_COLOR);    });    auto nodeList = DependencyManager::get<NodeList>();    if (nodeList && !nodeList->getDomainHandler().isConnected()) {        gpu::Batch& batch = *renderArgs->_batch;        auto geometryCache = DependencyManager::get<GeometryCache>();        geometryCache->useSimpleDrawPipeline(batch);        batch.setProjectionTransform(mat4());        batch.setModelTransform(Transform());        batch.setViewTransform(Transform());        batch.setResourceTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());        // FIXME: THe line width of CONNECTION_STATUS_BORDER_LINE_WIDTH is not supported anymore, we ll need a workaround        // TODO animate the disconnect border for some excitement while not connected?        //double usecs = usecTimestampNow();        //double secs = usecs / 1000000.0;        //float scaleAmount = 1.0f + (0.01f * sin(secs * 5.0f));        //batch.setModelTransform(glm::scale(mat4(), vec3(scaleAmount)));        geometryCache->renderVertices(batch, gpu::LINE_STRIP, _domainStatusBorder);    }}

void SkeletonModel::renderJointConstraints(gpu::Batch& batch, int jointIndex) {    if (jointIndex == -1 || jointIndex >= _jointStates.size()) {        return;    }    const FBXGeometry& geometry = _geometry->getFBXGeometry();    const float BASE_DIRECTION_SIZE = 0.3f;    float directionSize = BASE_DIRECTION_SIZE * extractUniformScale(_scale);    batch._glLineWidth(3.0f);    do {        const FBXJoint& joint = geometry.joints.at(jointIndex);        const JointState& jointState = _jointStates.at(jointIndex);        glm::vec3 position = _rotation * jointState.getPosition() + _translation;        glm::quat parentRotation = (joint.parentIndex == -1) ? _rotation : _rotation * _jointStates.at(joint.parentIndex).getRotation();        float fanScale = directionSize * 0.75f;                Transform transform = Transform();        transform.setTranslation(position);        transform.setRotation(parentRotation);        transform.setScale(fanScale);        batch.setModelTransform(transform);                const int AXIS_COUNT = 3;        auto geometryCache = DependencyManager::get<GeometryCache>();        for (int i = 0; i < AXIS_COUNT; i++) {            if (joint.rotationMin[i] <= -PI + EPSILON && joint.rotationMax[i] >= PI - EPSILON) {                continue; // unconstrained            }            glm::vec3 axis;            axis[i] = 1.0f;                        glm::vec3 otherAxis;            if (i == 0) {                otherAxis.y = 1.0f;            } else {                otherAxis.x = 1.0f;            }            glm::vec4 color(otherAxis.r, otherAxis.g, otherAxis.b, 0.75f);            QVector<glm::vec3> points;            points << glm::vec3(0.0f, 0.0f, 0.0f);            const int FAN_SEGMENTS = 16;            for (int j = 0; j < FAN_SEGMENTS; j++) {                glm::vec3 rotated = glm::angleAxis(glm::mix(joint.rotationMin[i], joint.rotationMax[i],                    (float)j / (FAN_SEGMENTS - 1)), axis) * otherAxis;                points << rotated;            }            // TODO: this is really inefficient constantly recreating these vertices buffers. It would be            // better if the skeleton model cached these buffers for each of the joints they are rendering            geometryCache->updateVertices(_triangleFanID, points, color);            geometryCache->renderVertices(batch, gpu::TRIANGLE_FAN, _triangleFanID);                    }                renderOrientationDirections(jointIndex, position, _rotation * jointState.getRotation(), directionSize);        jointIndex = joint.parentIndex;            } while (jointIndex != -1 && geometry.joints.at(jointIndex).isFree);}

void PerlinFace::update() {    if (!_initialized) {        init();    }    updatePositions();    updateVertices();    glBindBuffer(GL_ARRAY_BUFFER, _vboID);    glBufferData(GL_ARRAY_BUFFER,                 FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE  * _trianglesCount * sizeof(GLfloat),                 _triangles,                 GL_DYNAMIC_DRAW);    glBindBuffer(GL_ARRAY_BUFFER, _nboID);    glBufferData(GL_ARRAY_BUFFER,                 FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE  * _trianglesCount * sizeof(GLfloat),                 _normals,                 GL_DYNAMIC_DRAW);    glBindBuffer(GL_ARRAY_BUFFER, _cboID);    glBufferData(GL_ARRAY_BUFFER,                 FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE  * _trianglesCount * sizeof(GLubyte),                 _colors,                 GL_DYNAMIC_DRAW);}

void wySpriteEx::updateTransform() {    if(!m_useBatchNode) {        LOGW("This func only applies to sprite using batchnode");        return;    }    if(!m_texDirty && !m_colorDirty && !m_transformDirty) {        return;    }    if(m_texDirty || m_transformDirty) {        if(m_transformDirty) {            wyAffineTransform t = getNodeToBatchNodeTransform();            updateVertices(t);        }        if(m_texDirty)            updateTextureCoords();        m_batchNode->m_atlas->updateQuad(m_texCoords, m_vertices, m_atlasIndex);    }    if(m_colorDirty) {        updateColor();    }    m_texDirty = m_colorDirty = m_transformDirty = false;}

void MetaballParticleSystem::render(sf::RenderTarget &renderTarget) {	updateVertices();	if (m_particles->countAlive <= 0) return;	sf::RenderStates states = sf::RenderStates::Default;	states.blendMode = sf::BlendAdd;	states.texture = m_texture;	const sf::Vertex *ver = &m_vertices[0];	sf::View oldView = renderTarget.getView();	sf::View defaultView = renderTarget.getDefaultView();	m_renderTexture.setView(oldView);	m_renderTexture.clear(sf::Color(0, 0, 0, 0));	m_renderTexture.draw(ver, m_particles->countAlive * 4, sf::Quads, states);	m_renderTexture.display();	m_sprite.setTexture(m_renderTexture.getTexture());	sf::Glsl::Vec4 colorVec = sf::Glsl::Vec4(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);	m_shader.setUniform("customColor", colorVec);	m_shader.setUniform("threshold", threshold);		renderTarget.setView(defaultView);	renderTarget.draw(m_sprite, &m_shader);	renderTarget.setView(oldView);}

CircleRB::CircleRB(float xPosition, float yPosition,						 float xVelocity, float yVelocity,						 float radius,						 float angularPosition, float angularVelocity,						 float m, float frictionCoeff, float gravityResistance,						 float elasticity,						 RungeKuttaODESolver *odeSolver) {							 r = radius;							 criticalRadius = radius;							 xPos = xPosition; yPos = yPosition;							 xVel = xVelocity; yVel = yVelocity;							 angularPos = angularPosition; angularVel = angularVelocity;							 mass = m; friction = frictionCoeff; gravityScale = gravityResistance;							 e = elasticity;							 momentOfInertia = mass*(2.0f*r*r)/12.0f;							 oneOverMass = 1.0f/mass; oneOverI = 1.0f/momentOfInertia;							 Tx = 0.0f; Ty = 0.0f; Rx = 0.0f; Ry = 0.0f;							 solver = odeSolver;							 nVertices = nVert+1;							 vertices = vector<float>(nVertices*2,0.0f);							 updateVertices();							 color[0] = 0.1;							 color[1] = 0.6;							 color[2] = 0.8;}

void Particle::step(float dtime){	m_time += dtime;	if (m_collisiondetection)	{		core::aabbox3d<f32> box = m_collisionbox;		v3f p_pos = m_pos*BS;		v3f p_velocity = m_velocity*BS;		v3f p_acceleration = m_acceleration*BS;		collisionMoveSimple(m_env, m_gamedef,			BS*0.5, box,			0, dtime,			p_pos, p_velocity, p_acceleration);		m_pos = p_pos/BS;		m_velocity = p_velocity/BS;		m_acceleration = p_acceleration/BS;	}	else	{		m_velocity += m_acceleration * dtime;		m_pos += m_velocity * dtime;	}	// Update lighting	updateLight();	// Update model	updateVertices();}

void Particle::step(float dtime){	m_time += dtime;	if (m_collisiondetection) {		aabb3f box = m_collisionbox;		v3f p_pos = m_pos * BS;		v3f p_velocity = m_velocity * BS;		collisionMoveResult r = collisionMoveSimple(m_env,			m_gamedef, BS * 0.5, box, 0, dtime, &p_pos,			&p_velocity, m_acceleration * BS);		if (m_collision_removal && r.collides) {			// force expiration of the particle			m_expiration = -1.0;		} else {			m_pos = p_pos / BS;			m_velocity = p_velocity / BS;		}	} else {		m_velocity += m_acceleration * dtime;		m_pos += m_velocity * dtime;	}	// Update lighting	updateLight();	// Update model	updateVertices();}

Vector3 FlexAirfoil::flexit(){	Vector3 center;	if (smanager->getShadowTechnique()==SHADOWTYPE_STENCIL_MODULATIVE || smanager->getShadowTechnique()==SHADOWTYPE_STENCIL_ADDITIVE)	{		center=updateShadowVertices();		//find the binding		unsigned posbinding=msh->sharedVertexData->vertexDeclaration->findElementBySemantic(VES_POSITION)->getSource();		HardwareVertexBufferSharedPtr pbuf=msh->sharedVertexData->vertexBufferBinding->getBuffer(posbinding);		//pbuf->lock(HardwareBuffer::HBL_NORMAL);		pbuf->writeData(0, pbuf->getSizeInBytes(), shadowposvertices, true);		//pbuf->unlock();		//find the binding		unsigned norbinding=msh->sharedVertexData->vertexDeclaration->findElementBySemantic(VES_NORMAL)->getSource();		HardwareVertexBufferSharedPtr nbuf=msh->sharedVertexData->vertexBufferBinding->getBuffer(norbinding);		//nbuf->lock(HardwareBuffer::HBL_NORMAL);		nbuf->writeData(0, nbuf->getSizeInBytes(), shadownorvertices, true);		//nbuf->unlock();		EdgeData * 	ed=msh->getEdgeList();		ed->updateFaceNormals(0, pbuf);	}		else	{		center=updateVertices();		//vbuf->lock(HardwareBuffer::HBL_NORMAL);		vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true);		//vbuf->unlock();		//msh->sharedVertexData->vertexBufferBinding->getBuffer(0)->writeData(0, vbuf->getSizeInBytes(), vertices, true);	}	return center;}

void Rectangle3DOverlay::render(RenderArgs* args) {    if (!_visible) {        return; // do nothing if we're not visible    }    float alpha = getAlpha();    xColor color = getColor();    const float MAX_COLOR = 255.0f;    glm::vec4 rectangleColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);    glm::vec3 position = getPosition();    glm::vec2 dimensions = getDimensions();    glm::vec2 halfDimensions = dimensions * 0.5f;    glm::quat rotation = getRotation();    auto batch = args->_batch;    if (batch) {        Transform transform;        transform.setTranslation(position);        transform.setRotation(rotation);        batch->setModelTransform(transform);        auto geometryCache = DependencyManager::get<GeometryCache>();        if (getIsSolid()) {            glm::vec3 topLeft(-halfDimensions.x, -halfDimensions.y, 0.0f);            glm::vec3 bottomRight(halfDimensions.x, halfDimensions.y, 0.0f);            geometryCache->bindSimpleProgram(*batch);            geometryCache->renderQuad(*batch, topLeft, bottomRight, rectangleColor);        } else {            geometryCache->bindSimpleProgram(*batch, false, false, false, true, true);            if (getIsDashedLine()) {                glm::vec3 point1(-halfDimensions.x, -halfDimensions.y, 0.0f);                glm::vec3 point2(halfDimensions.x, -halfDimensions.y, 0.0f);                glm::vec3 point3(halfDimensions.x, halfDimensions.y, 0.0f);                glm::vec3 point4(-halfDimensions.x, halfDimensions.y, 0.0f);                geometryCache->renderDashedLine(*batch, point1, point2, rectangleColor);                geometryCache->renderDashedLine(*batch, point2, point3, rectangleColor);                geometryCache->renderDashedLine(*batch, point3, point4, rectangleColor);                geometryCache->renderDashedLine(*batch, point4, point1, rectangleColor);            } else {                if (halfDimensions != _previousHalfDimensions) {                    QVector<glm::vec3> border;                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);                    border << glm::vec3(halfDimensions.x, -halfDimensions.y, 0.0f);                    border << glm::vec3(halfDimensions.x, halfDimensions.y, 0.0f);                    border << glm::vec3(-halfDimensions.x, halfDimensions.y, 0.0f);                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);                    geometryCache->updateVertices(_geometryCacheID, border, rectangleColor);                    _previousHalfDimensions = halfDimensions;                }                geometryCache->renderVertices(*batch, gpu::LINE_STRIP, _geometryCacheID);            }        }    }}

inline void vertex_buffer_object<Ta, Te>::update(){    updateVertices();    updateNormals();    updateColors();    updateTexCoords();    updateElements();}

bool BoneNode::init(){    _rackLength = 50;    _rackWidth = 20;    updateVertices();    updateColor();    setGLProgramState(cocos2d::GLProgramState::getOrCreateWithGLProgramName(cocos2d::GLProgram::SHADER_NAME_POSITION_COLOR_NO_MVP));    return true;}

void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& color, int x, int y, int n, int offset, const QByteArray* byteArray) {    int16_t sample;    int16_t* samples = ((int16_t*) byteArray->data()) + offset;    int numSamplesToAverage = _framesPerScope / DEFAULT_FRAMES_PER_SCOPE;    int count = (n - offset) / numSamplesToAverage;    int remainder = (n - offset) % numSamplesToAverage;    y += SCOPE_HEIGHT / 2;        auto geometryCache = DependencyManager::get<GeometryCache>();    QVector<glm::vec2> points;        // Compute and draw the sample averages from the offset position    for (int i = count; --i >= 0; ) {        sample = 0;        for (int j = numSamplesToAverage; --j >= 0; ) {            sample += *samples++;        }        sample /= numSamplesToAverage;        points << glm::vec2(x++, y - sample);    }    // Compute and draw the sample average across the wrap boundary    if (remainder != 0) {        sample = 0;        for (int j = remainder; --j >= 0; ) {            sample += *samples++;        }            samples = (int16_t*) byteArray->data();        for (int j = numSamplesToAverage - remainder; --j >= 0; ) {            sample += *samples++;        }        sample /= numSamplesToAverage;        points << glm::vec2(x++, y - sample);    } else {        samples = (int16_t*) byteArray->data();    }    // Compute and draw the sample average from the beginning to the offset    count = (offset - remainder) / numSamplesToAverage;    for (int i = count; --i >= 0; ) {        sample = 0;        for (int j = numSamplesToAverage; --j >= 0; ) {            sample += *samples++;        }        sample /= numSamplesToAverage;        points << glm::vec2(x++, y - sample);    }            geometryCache->updateVertices(id, points, color);    geometryCache->renderVertices(batch, gpu::LINE_STRIP, id);}

Particle::Particle(	IGameDef *gamedef,	scene::ISceneManager* smgr,	LocalPlayer *player,	ClientEnvironment *env,	v3f pos,	v3f velocity,	v3f acceleration,	float expirationtime,	float size,	bool collisiondetection,	bool collision_removal,	bool vertical,	video::ITexture *texture,	v2f texpos,	v2f texsize):	scene::ISceneNode(smgr->getRootSceneNode(), smgr){	// Misc	m_gamedef = gamedef;	m_env = env;	// Texture	m_material.setFlag(video::EMF_LIGHTING, false);	m_material.setFlag(video::EMF_BACK_FACE_CULLING, false);	m_material.setFlag(video::EMF_BILINEAR_FILTER, false);	m_material.setFlag(video::EMF_FOG_ENABLE, true);	m_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;	m_material.setTexture(0, texture);	m_texpos = texpos;	m_texsize = texsize;	// Particle related	m_pos = pos;	m_velocity = velocity;	m_acceleration = acceleration;	m_expiration = expirationtime;	m_time = 0;	m_player = player;	m_size = size;	m_collisiondetection = collisiondetection;	m_collision_removal = collision_removal;	m_vertical = vertical;	// Irrlicht stuff	m_collisionbox = aabb3f			(-size/2,-size/2,-size/2,size/2,size/2,size/2);	this->setAutomaticCulling(scene::EAC_OFF);	// Init lighting	updateLight();	// Init model	updateVertices();}

void RenderablePolyLineEntityItem::update(const quint64& now) {    PolyLineUniforms uniforms;    uniforms.color = toGlm(getXColor());    memcpy(&_uniformBuffer.edit<PolyLineUniforms>(), &uniforms, sizeof(PolyLineUniforms));    if (_pointsChanged || _strokeWidthsChanged || _normalsChanged) {        updateVertices();        updateGeometry();    }}

/** * Update the modl state */void Dodecahedron::update(){	radius = 300 * get( "radius" );	modelRotation = 64 * Vec3f( get( "rotationX" ) , get( "rotationY" ) , get( "rotationZ" ) );	edgesColor = ColorAf( get( "edgeColorR" ) , get( "edgeColorG" ) , get( "edgeColorB" ) );		updateVertices();	calcWallCenters();	calcWallCoordinateSystems();}

 void updateVertices(const QTransform &t, ShaderType type)  {             if (shader[type] != currentShader)         currentShader = shader[type];          updateVertices(t);     if (!currentShader->bind())         qWarning() << __func__ << "failed to bind shader program";     currentShader->setWorldMatrix(worldMatrix); }

void RenderableLineEntityItem::updateGeometry() {    auto geometryCache = DependencyManager::get<GeometryCache>();    if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {        _lineVerticesID = geometryCache ->allocateID();    }    if (_pointsChanged) {        glm::vec4 lineColor(toGlm(getXColor()), getLocalRenderAlpha());        geometryCache->updateVertices(_lineVerticesID, getLinePoints(), lineColor);        _pointsChanged = false;    }}

void wyGradientColorLayer::setContentSize(float w, float h) {	// 原始位置opengl顶点，依次为左上，左下，右上，右下	if (m_originalVertices != NULL) {		m_originalVertices[1] = h;		m_originalVertices[4] = w;		m_originalVertices[5] = h;		m_originalVertices[6] = w;	}	wyLayer::setContentSize(w, h);	updateVertices();}

GuiSprite::GuiSprite(){	model.setNew();	std::vector<unsigned int> indices(6);	indices[0] = 0;	indices[1] = 3;	indices[2] = 2;	indices[3] = 2;	indices[4] = 1;	indices[5] = 0;	model->setIndices(indices);	updateVertices();}

bool BlockPlaneIntersectionGeometry::initialize() {    if (_vaoId == 0)        glGenVertexArrays(1, &_vaoId);    if (_vBufferId == 0) {        glGenBuffers(1, &_vBufferId);        if (_vBufferId == 0) {            LERROR("Could not create vertex buffer");            return false;        }    }    updateVertices();    return true;}

void MeshView::partialUpdate( const FractalData* data ){    if ( m_resolution.isNull() || m_resolution != data->size() )        return;    const QList<QRect> validRegions = data->validRegions();    if ( validRegions.count() > 0 && validRegions.first().top() == 0 && validRegions.first().bottom() > m_updatedRegion.bottom() ) {        int top = m_updatedRegion.bottom() + 1;        QRect region( 0, top, validRegions.first().width(), validRegions.first().bottom() - top + 1 );        updateVertices( data, region );        m_updatedRegion = validRegions.first();        updateGL();    }}

voidrender(void){   DMAPoolBuffer *dma = updateVertices(0.2, 0.8, 0.2, 0, 0);   int row;   trashBuffer();   uploadRow(0, dma);   for (row = 1; row < MESH_HEIGHT; row++) {      uploadRow(row, dma);      drawStrip(row - 1);   }   SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma);}

void NinePatch::update(const TexturePtr& tex,                      const Vec2& inSize,                      float l,                      float r,                      float t,                      float b){  size = inSize;  left = l;  right = r;  top = t;  bottom = b;  material->setTexture(0, tex);  updateVertices();  updateTexCoords();  }

    void SGBox::setMaxZ(Real z)    {        // v0, v1, v2, v3, v4, v5, v14, v15, v17, v19, v20, v22        mVertices[0].position.z() = z;        mVertices[1].position.z() = z;        mVertices[2].position.z() = z;        mVertices[3].position.z() = z;        mVertices[4].position.z() = z;        mVertices[5].position.z() = z;        mVertices[14].position.z() = z;        mVertices[15].position.z() = z;        mVertices[17].position.z() = z;        mVertices[19].position.z() = z;        mVertices[20].position.z() = z;        mVertices[22].position.z() = z;        updateVertices();    }