C++ VertexBufferPtr类代码示例

    void UnderWaterGodRay::_updateRays()
    {
        Camera * cam = World::Instance()->MainCamera();
        const Vec3 * corner = cam->GetCorner();
        float FarWidth   = (corner[4] - corner[5]).Length();
        float RaysLength = cam->GetFarClip();

        VertexBufferPtr vb = mRender.vxStream.GetStream(0);
        Vec3 * vert = (Vec3*)vb->Lock(0, 0, LOCK_DISCARD);

        Vec2 Pos;
        float Dis, RayLength;

        for(int k = 0; k < mNumberOfRays; k++)
        {
            Pos       = _calculateRayPosition(k);
            Dis       = mRaysSize * RaysLength;
            RayLength = RaysLength * (0.3f + Pos.Length());

            Pos *= FarWidth/2;

            // 4 Planes, 3 vertices each plane, 12 vertices per ray
            // ----> 1/4
            // 0
            *vert++ = Vec3(0, 0, 0);
            // A
            *vert++ = Vec3(Pos.x, Pos.y, -RayLength);
            // B
            *vert++ = Vec3(Pos.x+Dis, Pos.y, -RayLength);
            // ----> 2/4
            // 0
            *vert++ = Vec3(0, 0, 0);
            // D
            *vert++ = Vec3(Pos.x+Dis, Pos.y+Dis, -RayLength);
            // B
            *vert++ = Vec3(Pos.x+Dis, Pos.y, -RayLength);
            // ----> 3/4
            // 0
            *vert++ = Vec3(0, 0, 0);
            // C
            *vert++ = Vec3(Pos.x, Pos.y+Dis, -RayLength);
            // D
            *vert++ = Vec3(Pos.x+Dis, Pos.y+Dis, -RayLength);
            // ----> 4/4
            // 0
            *vert++ = Vec3(0, 0, 0);
            // C
            *vert++ = Vec3(Pos.x, Pos.y+Dis, -RayLength);
            // A
            *vert++ = Vec3(Pos.x, Pos.y, -RayLength);
        }

        vb->Unlock();
    }

    i32 CreateRect2D(Resources::CMesh* pMesh, const IInputLayout* pIL, const SRect2DOptions& Opts)
    {
        Vec3 vecScale( 100 ); 
        Vec2 vecWidth( 0, 100 );
        Vec2 vecHeight( 0, 100 );

        IndexBufferPtr pIB = pMesh->CreateIndexBuffer();
        VertexBufferPtr pVB = pMesh->CreateVertexBuffer();

        pVB->SetVertexCount( 4 );
        pVB->SetInputLayout( pIL );
        pVB->SetTopologyType( TopologyTypes::TRIANGLE_LIST );
        pVB->SetUsage( Opts.eUsage );

        pIB->SetIndexCount( 6 );
        pIB->SetUsage( BufferUsages::STATIC );

        pVB->Lock();
        CVertexData& VData = pVB->GetVertexData();

        if( pIL->IsPosition() )
        {
            VData.SetPosition( 0, Vec3( 0,			0,				0 ) );
            VData.SetPosition( 1, Vec3( vecScale.x, 0,				0 ) );
            VData.SetPosition( 2, Vec3( vecScale.x, -vecScale.y,	0 ) );
            VData.SetPosition( 3, Vec3( 0,			-vecScale.y,	0) );
        }

        if( pIL->IsColor() )
        {
            VData.SetColor( 0, Vec4( 1, 1, 1, 1 ) );
            VData.SetColor( 1, Vec4( 1, 1, 1, 1 ) );
            VData.SetColor( 2, Vec4( 1, 1, 1, 1 ) );
            VData.SetColor( 3, Vec4( 1, 1, 1, 1 ) );
        }

        if( pIL->IsTexCoord0() )
        {
            VData.SetTexCoord( 0, 0, Vec2( 0, 1 ) );
            VData.SetTexCoord( 1, 0, Vec2( 1, 1 ) );
            VData.SetTexCoord( 2, 0, Vec2( 0, 1 ) );
            VData.SetTexCoord( 3, 0, Vec2( 0, 0 ) );
        }

        pVB->Unlock();
        pVB->Create();

        pIB->Lock();
        CIndexData& IData = pIB->GetIndexData();

        IData.SetTriangle( 0, 0, 2, 3 );
        IData.SetTriangle( 1, 1, 2, 0 );

        return XST_OK;
    }

void MeshLoader_v0::ReadVertexStream(VertexBufferPtr & vb, int & stride, int count, DataStreamPtr & stream)
{
    EXCEPTION_DEBUG(vb.IsNull(), "model file error.");

    stream->Read(&stride, sizeof(int));

    vb = VideoBufferManager::Instance()->CreateVertexBuffer(stride * count, stride);
    
    void * data = vb->Lock(0, 0, LOCK_DISCARD);

    stream->Read(data, stride * count);

    vb->Unlock();
}

    void UnderWaterGodRay::_createGodRays()
    {
        VertexStream * vxStream = &mRender.vxStream;
        IndexStream * ixStream = &mRender.ixStream;

        int iVertexCount = mNumberOfRays * 12;
        int iIndexCount = mNumberOfRays * 12;
        int iPrimCount = iIndexCount / 3;
        int iStride = 12;

        VertexDeclarationPtr decl = VideoBufferManager::Instance()->CreateVertexDeclaration();
        decl->AddElement(0, 0, DT_FLOAT3, DU_POSITION, 0);
        decl->Init();

        vxStream->SetDeclaration(decl);

        VertexBufferPtr vb = VideoBufferManager::Instance()->CreateVertexBuffer(iVertexCount * 20, 20, USAGE_DYNAMIC);
        IndexBufferPtr ib = VideoBufferManager::Instance()->CreateIndexBuffer(iIndexCount * sizeof(short));

        float * vert = (float *)vb->Lock(0, 0, LOCK_NORMAL);
        short * idx = (short *)ib->Lock(0, 0, LOCK_NORMAL);

        int index = 0;
        for (int j = 0; j < mNumberOfRays; ++j)
        {
            for (int i = 0; i < 12; ++i)
            {
                *vert++ = 0; *vert++ = 0; *vert++ = 0;
                *idx++ = index++; 
            }
        }

        vb->Unlock();
        ib->Unlock();

        vxStream->Bind(0,vb, iStride);
        vxStream->SetCount(iVertexCount);

        ixStream->Bind(ib, 0);
        ixStream->SetCount(iIndexCount);

        mRender.iPrimCount = iPrimCount;
        mRender.ePrimType = PRIM_TRIANGLELIST;
        mRender.rState.blendMode = BM_ADD;
        mRender.rState.cullMode = CULL_NONE;
        mRender.rState.fillMode = FILL_SOLID;
        mRender.rState.depthWrite = false;
        mRender.rState.depthCheck = DCM_NONE;
    }

VertexArrayPtr RenderContext::createVertexArray(VertexDescription description, VertexBufferPtr buffer) {
  VertexArrayPtr vao = VertexArrayPtr(new VertexArray());
  vao->bind();
  buffer->bind();
  int offset = 0;
  for(VertexDescriptionElement e : description) {
    if(e.shaderAttribLocation() != -1) {
      glVertexAttribPointer(e.shaderAttribLocation(), e.numberOfComponents(), (int)e.type(), GL_FALSE, description.sizeInBytes(), (char*)nullptr + offset);
      glEnableVertexAttribArray(e.shaderAttribLocation());
    }
    offset += e.sizeInBytes();
  }
  buffer->release();
  vao->release();
  return vao;
}

    void Moon::_geometry()
    {
        VertexStream * vxStream = &mRender.vxStream;
        IndexStream * ixStream = &mRender.ixStream;

        int iVertexCount = 4;
        int iPrimCount = 2;

        VertexDeclarationPtr decl = VideoBufferManager::Instance()->CreateVertexDeclaration();
        decl->AddElement(0, 0, DT_FLOAT3, DU_POSITION, 0);
        decl->AddElement(0, 12, DT_FLOAT2, DU_TEXCOORD, 0);
        decl->Init();

        vxStream->SetDeclaration(decl);

        VertexBufferPtr vb = VideoBufferManager::Instance()->CreateVertexBuffer(iVertexCount * 20, 20);

        float * vert = (float *)vb->Lock(0, 0, LOCK_DISCARD);
        {
            float x = 0, y = 0, z = 0;

            *vert++ = x; *vert++ = y; *vert++ = z;
            *vert++ = 0; *vert++ = 0;

            *vert++ = x; *vert++ = y; *vert++ = z;
            *vert++ = 1; *vert++ = 0;

            *vert++ = x; *vert++ = y; *vert++ = z;
            *vert++ = 0; *vert++ = 1;

            *vert++ = x; *vert++ = y; *vert++ = z;
            *vert++ = 1; *vert++ = 1;
        }
        vb->Unlock();

        vxStream->Bind(0, vb, 20);
        vxStream->SetCount(iVertexCount);

        mRender.iPrimCount = iPrimCount;
        mRender.ePrimType = PRIM_TRIANGLESTRIP;

        mRender.rState.blendMode = BM_ALPHA_BLEND;
        mRender.rState.depthWrite = false;
        mRender.rState.depthCheck = DCM_LESS_EQUAL;
    }

    void UnderWaterBubble::_geom()
    {
        VertexStream * vxStream = &mRender.vxStream;

        VertexBufferPtr vb = vxStream->GetStream(0);

        float * v = (float *)vb->Lock(0, 0, LOCK_DISCARD);
        {
            List<Bubble>::Iterator whr = mBubbles.Begin();
            List<Bubble>::Iterator end = mBubbles.End();

            while (whr != end)
            {
                const Bubble & b = *whr;
                *v++ = b.position.x;
                *v++ = b.position.y;
                *v++ = b.position.z;
                *v++ = b.size;
                *v++ = b.alpha;

                *v++ = b.position.x;
                *v++ = b.position.y;
                *v++ = b.position.z;
                *v++ = b.size;
                *v++ = b.alpha;

                *v++ = b.position.x;
                *v++ = b.position.y;
                *v++ = b.position.z;
                *v++ = b.size;
                *v++ = b.alpha;

                *v++ = b.position.x;
                *v++ = b.position.y;
                *v++ = b.position.z;
                *v++ = b.size;
                *v++ = b.alpha;

                ++whr;
            }
        }
        vb->Unlock();

        mRender.iPrimCount = mBubbles.Size() * 2;
    }

	//-------------------------------------------------------------------------------//
	void OverlayPanelElement::updateGeometryData()
	{
		/*
			0-----2
			|    /|
			|  /  |
			|/    |
			1-----3
		*/
		Renderer* renderer = Root::getSingleton().getActiveRenderer();
		float offsetLeft = mLeft + renderer->getHorizontalTexelOffset() / OverlayMgr::getSingleton().getViewportWidth();
		float offsetTop = mTop + renderer->getVerticalTexelOffset() / OverlayMgr::getSingleton().getViewportHeight();
		float left, right, top, bottom;
		left = offsetLeft * 2 - 1;
		right = left + mWidth * 2;
		top = -((offsetTop * 2) - 1);
		bottom = top - mHeight * 2;

		VertexBufferPtr vbuf = mRenderData.vertexData->vertexBufferBinding->getBuffer(0);

		float* pPos = static_cast<float*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));

		float zValue = Root::getSingleton().getActiveRenderer()->getMaxDepthValue();
		*pPos++ = left;
		*pPos++ = top;
		*pPos++ = zValue;

		*pPos++ = left;
		*pPos++ = bottom;
		*pPos++ = zValue;

		*pPos++ = right;
		*pPos++ = top;
		*pPos++ = zValue;

		*pPos++ = right;
		*pPos++ = bottom;
		*pPos++ = zValue;

		vbuf->unlock();

		
	}

	//-------------------------------------------------------------------------------//
	void OverlayPanelElement::updateTexData()
	{
		if(!mTexture.isNull() &&mIsInitialised)
		{
			VertexDeclaration* decl = mRenderData.vertexData->vertexDecl;
			if(mTexCoordNum == 0)
			{
				decl->addElement(1, 0,VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);

				VertexBufferPtr vbuf = HardwareBufferMgr::getSingletonPtr()->createVertexBuffer(decl->getVertexSize(1), mRenderData.vertexData->vertexCount,
					HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);

				mRenderData.vertexData->vertexBufferBinding->setBinding(1,vbuf);
				mTexCoordNum = 1;
			}

			if(mTexCoordNum)
			{
				VertexBufferPtr buf = mRenderData.vertexData->vertexBufferBinding->getBuffer(1);
				float* pVBStart = static_cast<float*>(buf->lock(HardwareBuffer::HBL_DISCARD));

				size_t uvSize = VertexElement::getTypeSize(VET_FLOAT2) / sizeof(float);
				size_t vertexSize = decl->getVertexSize(1) / sizeof(float);
				
				float* pTex = pVBStart;

				pTex[0] = mU1;	pTex[1] = mV1;
				pTex += vertexSize;

				pTex[0] = mU1;	pTex[1] = mV2;
				pTex += vertexSize;
				
				pTex[0] = mU2;	pTex[1] = mV1;
				pTex += vertexSize;

				pTex[0] = mU2;	pTex[1] = mV2;

				buf->unlock();
			}
			
		}
	}

std::shared_ptr<render::VertexBuffer>
GeometryParser::deserializeVertexBuffer(std::string&                                serializedVertexBuffer,
                                        std::shared_ptr<render::AbstractContext>    context)
{
    msgpack::type::tuple<std::string, std::vector<SerializeAttribute>>	deserializedVertex;

    unpack(deserializedVertex, serializedVertexBuffer.data(), serializedVertexBuffer.size());

    std::vector<float>		vector			= deserialize::TypeDeserializer::deserializeVector<float>(deserializedVertex.get<0>());
    VertexBufferPtr			vertexBuffer	= render::VertexBuffer::create(context, vector);

    uint numAttributes = deserializedVertex.get<1>().size();

    for (unsigned int attributesIndex = 0; attributesIndex < numAttributes; ++attributesIndex)
        vertexBuffer->addAttribute(
            deserializedVertex.get<1>()[attributesIndex].get<0>(),
            deserializedVertex.get<1>()[attributesIndex].get<1>(),
            deserializedVertex.get<1>()[attributesIndex].get<2>());

    return vertexBuffer;
}

SkinRenderer::SkinRenderer()
	: OnRender(RenderEvent::OnRenderGUI2, this, &SkinRenderer::Render)
{
	msInstance = this;

	mEnable = false;

	mRenderOp = new RenderOp;

	VertexDeclarationPtr vdecl = VideoBufferManager::Instance()->CreateVertexDeclaration();
	vdecl->AddElement(0, 0, DT_FLOAT2, DU_POSITION, 0);
	vdecl->Init();

	mRenderOp->vxStream.SetDeclaration(vdecl);

	VertexBufferPtr vb = VideoBufferManager::Instance()->CreateVertexBuffer(8 * 4, 8);

	float * vert = (float *)vb->Lock(0, 0, LOCK_NORMAL);
	{
		*vert++ = 0; *vert++ = 0;
		*vert++ = 1; *vert++ = 0;
		*vert++ = 0; *vert++ = 1;
		*vert++ = 1; *vert++ = 1;
	}
	vb->Unlock();

	mRenderOp->vxStream.Bind(0, vb);
	mRenderOp->vxStream.SetCount(4);

	mRenderOp->rState.depthCheck = DCM_NONE;
	mRenderOp->rState.depthWrite = false;
	mRenderOp->ePrimType = PRIM_TRIANGLESTRIP;
	mRenderOp->iPrimCount = 2;
	
	mTech = App::Instance()->GetShaderLib()->GetTechnique("SkinRenderer");

	d_assert (mTech != NULL);

	mBackTexture = VideoBufferManager::Instance()->Load2DTexture("BackgroundTile.png", "BackgroundTile.png");
}

    i32 CreateCircle( Resources::CMesh* pMesh, const IInputLayout* pIL, const SCircleOptions& Options )
    {
        xst_vector< Vec3 > vPoints;
        f32 fAngle = 0.0f;
        for( u32 i = 0; i <= 360; i += Options.uStep )
        {
            fAngle = XST::Math::DegreesToRadians( (f32)i );
            vPoints.push_back( Vec3( XST::Math::Cos( fAngle ) * Options.fRadius, XST::Math::Sin( fAngle ) * Options.fRadius, 0.0f ) );
        }

        bool bIsNormal = pIL->IsNormal();
        ul32 ulVertCount = vPoints.size();
        VertexBufferPtr pVB = pMesh->CreateVertexBuffer();

        pVB->SetTopologyType( TopologyTypes::LINE_STRIP );
        pVB->SetUsage( BufferUsages::DEFAULT );
        pVB->SetVertexCount( ulVertCount );
        pVB->SetInputLayout( pIL );

        if( XST_FAILED( pVB->Lock() ) )
        {
            return XST_FAIL;
        }

        CVertexData& Data = pVB->GetVertexData();

        ul32 vs = pIL->GetVertexSize();

        for( u32 i = 0; i < vPoints.size(); ++i )
        {
            if( pIL->IsPosition() )
            {
                Data.SetPosition( i, vPoints[ i ] + Options.vecPos );
            }
        }

        if( XST_FAILED( pVB->Unlock() ) || XST_FAILED( pVB->Create() ) )
        {
            return XST_FAIL;
        }

        return XST_OK;
    }

 bool Model::bindAttribWithVertexBuffer(const char *name, VertexBufferPtr &vertices, bool overWrite)
 {
     int location;
     std::map<std::string, int>::iterator it = _locations.find(name);
     if (it != _locations.end())
     {
         location = it->second;
     }else{
         location = _shaderProgram->getAttribLocation(name);
         if (location < 1)
         {
             printf("can't find attrib : %s", name);
             return false;
         }
         _locations.insert(std::map<std::string, int>::value_type(name, location));
     }
     vertices->bindToAttribLocation(location);
     _attribs.push_back(vertices);
     _isDirty = true;
     return true;
 }

void xObjBound::Init(Event * sender)
{
	mRenderAABB = new RenderOp();

	VertexStream * vxStream = &mRenderAABB->vxStream;
	IndexStream * ixStream = &mRenderAABB->ixStream;

	int iVertexCount = 8;
	int iIndexCount = 12 * 2;
	int iPrimCount = 12;

	VertexDeclarationPtr decl = VideoBufferManager::Instance()->CreateVertexDeclaration();
	decl->AddElement(0, 0, DT_FLOAT3, DU_POSITION, 0);
	decl->Init();

	vxStream->SetDeclaration(decl);

	VertexBufferPtr vb = VideoBufferManager::Instance()->CreateVertexBuffer(iVertexCount * 12, 12);

	float * vert = (float *)vb->Lock(0, 0, LOCK_DISCARD);
	{
		const float half_w = 0.5f;
		const float half_h = 0.5f;
		const float half_d = 0.5f;
		Vec3 pos;

		//front
		pos = Vec3(-half_w, half_h, -half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(half_w, half_h, -half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(-half_w, -half_h, -half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(half_w, -half_h, -half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		//back
		pos = Vec3(-half_w, half_h, half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(half_w, half_h, half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(-half_w, -half_h, half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;

		pos = Vec3(half_w, -half_h, half_d);
		*vert++ = pos.x;
		*vert++ = pos.y;
		*vert++ = pos.z;
	}
	vb->Unlock();

	vxStream->Bind(0, vb, 12);
	vxStream->SetCount(iVertexCount);

	IndexBufferPtr ibuffer = VideoBufferManager::Instance()->CreateIndexBuffer(iIndexCount * sizeof(short));
	short * indices = (short *)ibuffer->Lock(0, 0, LOCK_DISCARD);
	{
		*indices++ = 0, *indices++ = 1;
		*indices++ = 2, *indices++ = 3;
		*indices++ = 0, *indices++ = 2;
		*indices++ = 1, *indices++ = 3;

		*indices++ = 4, *indices++ = 5;
		*indices++ = 6, *indices++ = 7;
		*indices++ = 4, *indices++ = 6;
		*indices++ = 5, *indices++ = 7;

		*indices++ = 0, *indices++ = 4;
		*indices++ = 1, *indices++ = 5;
		*indices++ = 2, *indices++ = 6;
		*indices++ = 3, *indices++ = 7;
	}
	ibuffer->Unlock();

	ixStream->SetCount(iIndexCount);
	ixStream->Bind(ibuffer, 0);

	mRenderAABB->iPrimCount = iPrimCount;
	mRenderAABB->ePrimType = PRIM_LINELIST;

	mRenderAABB->rState.cullMode = CULL_NONE;
//.........这里部分代码省略.........

	Mesh * PS_MeshSet::_createCone(bool up)
	{
		Float3 offset = mCenter;
		int rings = (mRings + 3) / 4;
		int segments = mSegments;
		float radius = mRadius;
		float height = mHeight;

		if (rings < 1)
			return NULL;

		Mesh * pMesh = new Mesh;
		SubMesh * sm = pMesh->NewSubMesh();

		float h1 = up ? 0 : height;
		float h2 = up ? height : 0;

		int iVertexCount = 1 + (rings * 4 + 1);
		int iIndexCount = rings * 4 * 3;
		int iPrimCount = iIndexCount / 3;

		d_assert(iIndexCount < 65536);

		sm->GetRenderOp()->vertexDeclarations[0].AddElement(eVertexSemantic::POSITION, eVertexType::FLOAT3);
		sm->GetRenderOp()->vertexDeclarations[0].AddElement(eVertexSemantic::TEXCOORD0, eVertexType::FLOAT2);

		VertexBufferPtr buffer = HWBufferManager::Instance()->NewVertexBuffer(20, iVertexCount);

		float * vert = (float *)buffer->Lock(eLockFlag::WRITE);
		{
			float r_step = (PI2 / (rings * 4));
			float d_step = (radius * 2 / rings);
			float u_step = 1 / (float)rings;
			float v_step = u_step;
			float x, z;
			float rads = -PI * 0.25f;

			*vert++ = 0 + offset.x;
			*vert++ = h1 + offset.x;
			*vert++ = 0 + offset.z;
			*vert++ = 0.5f;
			*vert++ = 0.5f;

			// top
			for (int i = 0; i <= rings; ++i)
			{
				Math::SinCos(rads, z, x);

				x *= radius;
				z *= radius;

				*vert++ = x + offset.x;
				*vert++ = h2 + offset.y;
				*vert++ = z + offset.z;
				*vert++ = i * u_step;
				*vert++ = 0;

				rads += r_step;
			}

			// right
			for (int i = 1; i <= rings; ++i)
			{
				Math::SinCos(rads, z, x);

				x *= radius;
				z *= radius;

				*vert++ = x + offset.x;
				*vert++ = h2 + offset.y;
				*vert++ = z + offset.z;
				*vert++ = 1;
				*vert++ = i * v_step;

				rads += r_step;
			}

			// bottom
			for (int i = 1; i <= rings; ++i)
			{
				Math::SinCos(rads, z, x);

				x *= radius;
				z *= radius;

				*vert++ = x + offset.x;
				*vert++ = h2 + offset.y;
				*vert++ = z + offset.z;
				*vert++ = 1 - i * u_step;
				*vert++ = 1;

				rads += r_step;
			}

			// left
			for (int i = 1; i <= rings; ++i)
			{
				Math::SinCos(rads, z, x);

				x *= radius;
//.........这里部分代码省略.........