C++ TriMesh::UpdateModelSpace方法代码示例

//----------------------------------------------------------------------------
void IntersectingBoxes::ModifyMesh (int i)
{
    Vector3f center(
        0.5f*(mBoxes[i].Min[0] + mBoxes[i].Max[0]),
        0.5f*(mBoxes[i].Min[1] + mBoxes[i].Max[1]),
        0.5f*(mBoxes[i].Min[2] + mBoxes[i].Max[2]));

    float xExtent = 0.5f*(mBoxes[i].Max[0] - mBoxes[i].Min[0]);
    float yExtent = 0.5f*(mBoxes[i].Max[1] - mBoxes[i].Min[1]);
    float zExtent = 0.5f*(mBoxes[i].Max[2] - mBoxes[i].Min[2]);

    Vector3f xTerm = xExtent*Vector3f::UNIT_X;
    Vector3f yTerm = yExtent*Vector3f::UNIT_Y;
    Vector3f zTerm = zExtent*Vector3f::UNIT_Z;

    TriMesh* mesh = StaticCast<TriMesh>(mScene->GetChild(i));
    VertexBufferAccessor vba(mesh);

    vba.Position<Vector3f>(0) = center - xTerm - yTerm - zTerm;
    vba.Position<Vector3f>(1) = center + xTerm - yTerm - zTerm;
    vba.Position<Vector3f>(2) = center + xTerm + yTerm - zTerm;
    vba.Position<Vector3f>(3) = center - xTerm + yTerm - zTerm;
    vba.Position<Vector3f>(4) = center - xTerm - yTerm + zTerm;
    vba.Position<Vector3f>(5) = center + xTerm - yTerm + zTerm;
    vba.Position<Vector3f>(6) = center + xTerm + yTerm + zTerm;
    vba.Position<Vector3f>(7) = center - xTerm + yTerm + zTerm;

    mesh->UpdateModelSpace(Visual::GU_NORMALS);
    mRenderer->Update(mesh->GetVertexBuffer());
}

//.........这里部分代码省略.........
            vba.Position<Float3>(i) = vba.Position<Float3>(save);

            if (mHasNormals)
            {
                vba.Normal<Float3>(i) = vba.Normal<Float3>(save);
            }

            tcoord = Float2(1.0f, axisFraction);
            for (unit = 0; unit < MAX_UNITS; ++unit)
            {
                if (mHasTCoords[unit])
                {
                    vba.TCoord<Float2>(0, i) = tcoord;
                }
            }

            ++i;
        }
        TransformData(vba);

        // Generate indices.
        IndexBuffer* ibuffer = new0 IndexBuffer(numIndices, 4, mUsage);
        int* indices = (int*)ibuffer->GetData();
        for (a = 0, aStart = 0; a < axisSamples-1; ++a)
        {
            int i0 = aStart;
            int i1 = i0 + 1;
            aStart += radialSamples + 1;
            int i2 = aStart;
            int i3 = i2 + 1;
            for (i = 0; i < radialSamples; ++i, indices += 6)
            {
                if (mInside)
                {
                    indices[0] = i0++;
                    indices[1] = i2;
                    indices[2] = i1;
                    indices[3] = i1++;
                    indices[4] = i2++;
                    indices[5] = i3++;
                }
                else // outside view
                {
                    indices[0] = i0++;
                    indices[1] = i1;
                    indices[2] = i2;
                    indices[3] = i1++;
                    indices[4] = i3++;
                    indices[5] = i2++;
                }
            }
        }

        delete1(cs);
        delete1(sn);

        mesh = new0 TriMesh(mVFormat, vbuffer, ibuffer);
    }
    else
    {
        mesh = Sphere(axisSamples, radialSamples, radius);
        VertexBuffer* vbuffer = mesh->GetVertexBuffer();
        int numVertices = vbuffer->GetNumElements();

        VertexBufferAccessor vba(mVFormat, vbuffer);

        // Flatten sphere at poles.
        float hDiv2 = 0.5f*height;
        vba.Position<Float3>(numVertices-2)[2] = -hDiv2;  // south pole
        vba.Position<Float3>(numVertices-1)[2] = +hDiv2;  // north pole

        // Remap z-values to [-h/2,h/2].
        float zFactor = 2.0f/(axisSamples-1);
        float tmp0 = radius*(-1.0f + zFactor);
        float tmp1 = 1.0f/(radius*(+1.0f - zFactor));
        for (int i = 0; i < numVertices-2; ++i)
        {
            Float3& pos = vba.Position<Float3>(i);
            pos[2] = hDiv2*(-1.0f + tmp1*(pos[2] - tmp0));
            float adjust = radius*Mathf::InvSqrt(pos[0]*pos[0] +
                pos[1]*pos[1]);
            pos[0] *= adjust;
            pos[1] *= adjust;
        }
        TransformData(vba);

        if (mHasNormals)
        {
            mesh->UpdateModelSpace(Visual::GU_NORMALS);
        }
    }

    // The duplication of vertices at the seam causes the automatically
    // generated bounding volume to be slightly off center.  Reset the bound
    // to use the true information.
    float maxDist = Mathf::Sqrt(radius*radius + height*height);
    mesh->GetModelBound().SetCenter(APoint::ORIGIN);
    mesh->GetModelBound().SetRadius(maxDist);
    return mesh;
}

//----------------------------------------------------------------------------
TriMesh* StandardMesh::Box (float xExtent, float yExtent, float zExtent)
{
    int numVertices = 8;
    int numTriangles = 12;
    int numIndices = 3*numTriangles;
    int stride = mVFormat->GetStride();

    // Create a vertex buffer.
    VertexBuffer* vbuffer = new0 VertexBuffer(numVertices, stride, mUsage);
    VertexBufferAccessor vba(mVFormat, vbuffer);

    // Generate geometry.
    vba.Position<Float3>(0) = Float3(-xExtent, -yExtent, -zExtent);
    vba.Position<Float3>(1) = Float3(+xExtent, -yExtent, -zExtent);
    vba.Position<Float3>(2) = Float3(+xExtent, +yExtent, -zExtent);
    vba.Position<Float3>(3) = Float3(-xExtent, +yExtent, -zExtent);
    vba.Position<Float3>(4) = Float3(-xExtent, -yExtent, +zExtent);
    vba.Position<Float3>(5) = Float3(+xExtent, -yExtent, +zExtent);
    vba.Position<Float3>(6) = Float3(+xExtent, +yExtent, +zExtent);
    vba.Position<Float3>(7) = Float3(-xExtent, +yExtent, +zExtent);
    for (int unit = 0; unit < MAX_UNITS; ++unit)
    {
        if (mHasTCoords[unit])
        {
            vba.TCoord<Float2>(unit, 0) = Float2(0.25f, 0.75f);
            vba.TCoord<Float2>(unit, 1) = Float2(0.75f, 0.75f);
            vba.TCoord<Float2>(unit, 2) = Float2(0.75f, 0.25f);
            vba.TCoord<Float2>(unit, 3) = Float2(0.25f, 0.25f);
            vba.TCoord<Float2>(unit, 4) = Float2(0.0f, 1.0f);
            vba.TCoord<Float2>(unit, 5) = Float2(1.0f, 1.0f);
            vba.TCoord<Float2>(unit, 6) = Float2(1.0f, 0.0f);
            vba.TCoord<Float2>(unit, 7) = Float2(0.0f, 0.0f);
        }
    }
    TransformData(vba);

    // Generate indices (outside view).
    IndexBuffer* ibuffer = new0 IndexBuffer(numIndices, 4, mUsage);
    int* indices = (int*)ibuffer->GetData();
    indices[ 0] = 0;  indices[ 1] = 2;  indices[ 2] = 1;
    indices[ 3] = 0;  indices[ 4] = 3;  indices[ 5] = 2;
    indices[ 6] = 0;  indices[ 7] = 1;  indices[ 8] = 5;
    indices[ 9] = 0;  indices[10] = 5;  indices[11] = 4;
    indices[12] = 0;  indices[13] = 4;  indices[14] = 7;
    indices[15] = 0;  indices[16] = 7;  indices[17] = 3;
    indices[18] = 6;  indices[19] = 4;  indices[20] = 5;
    indices[21] = 6;  indices[22] = 7;  indices[23] = 4;
    indices[24] = 6;  indices[25] = 5;  indices[26] = 1;
    indices[27] = 6;  indices[28] = 1;  indices[29] = 2;
    indices[30] = 6;  indices[31] = 2;  indices[32] = 3;
    indices[33] = 6;  indices[34] = 3;  indices[35] = 7;

    if (mInside)
    {
        ReverseTriangleOrder(numTriangles, indices);
    }

    TriMesh* mesh = new0 TriMesh(mVFormat, vbuffer, ibuffer);
    if (mHasNormals)
    {
        mesh->UpdateModelSpace(Visual::GU_NORMALS);
    }
    return mesh;
}

//----------------------------------------------------------------------------
void BoxSurface::UpdateSurface ()
{
	int permute[3];
	TriMesh* mesh;
	VertexFormat* vformat;
	VertexBuffer* vbuffer;

	// u faces
	permute[0] = 1;
	permute[1] = 2;
	permute[2] = 0;

	// u = 0
	mesh = StaticCast<TriMesh>(GetChild(0));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumWSamples, mNumVSamples, vformat, vbuffer, false, 0.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);

	// u = 1
	mesh = StaticCast<TriMesh>(GetChild(1));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumWSamples, mNumVSamples, vformat, vbuffer, true, 1.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);

	// v faces
	permute[0] = 0;
	permute[1] = 2;
	permute[2] = 1;

	// v = 0
	mesh = StaticCast<TriMesh>(GetChild(2));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumWSamples, mNumUSamples, vformat, vbuffer, true, 0.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);

	// v = 1
	mesh = StaticCast<TriMesh>(GetChild(3));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumWSamples, mNumUSamples, vformat, vbuffer, false, 1.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);

	// w faces
	permute[0] = 0;
	permute[1] = 1;
	permute[2] = 2;

	// w = 0
	mesh = StaticCast<TriMesh>(GetChild(4));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumVSamples, mNumUSamples, vformat, vbuffer, false, 0.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);

	// w = 1
	mesh = StaticCast<TriMesh>(GetChild(5));
	vformat = mesh->GetVertexFormat();
	vbuffer = mesh->GetVertexBuffer();
	UpdateFace(mNumVSamples, mNumUSamples, vformat, vbuffer, true, 1.0f,
		permute);
	mesh->UpdateModelSpace(Renderable::GU_NORMALS);
	Renderer::UpdateAll(vbuffer);
}

//----------------------------------------------------------------------------
Node* SimplePendulumFriction::CreatePendulum ()
{
	VertexFormat* vformat = VertexFormat::Create(2,
	                        VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
	                        VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0);

	StandardMesh sm(vformat);

	// Pendulum rod.
	TriMesh* rod = sm.Cylinder(2, 8, 0.05f, 12.0f, true);
	rod->LocalTransform.SetTranslate(APoint(0.0f, 0.0f, 10.0f));

	// The pendulum bulb.  Start with a sphere (to get the connectivity) and
	// then adjust the vertices to form a pair of joined cones.
	TriMesh* bulb = sm.Sphere(16, 32, 2.0f);
	VertexBufferAccessor vba(bulb);
	int numVertices = vba.GetNumVertices();
	int i;
	for (i = 0; i < numVertices; ++i)
	{
		Float3& pos = vba.Position<Float3>(i);
		float r = Mathf::Sqrt(pos[0]*pos[0] + pos[1]*pos[1]);
		float z = pos[2] + 2.0f;
		if (z >= 2.0f)
		{
			z = 4.0f - r;
		}
		else
		{
			z = r;
		}
		pos[2] = z;
	}

	// Translate the pendulum joint to the origin for the purpose of
	// rotation.
	for (i = 0; i < numVertices; ++i)
	{
		vba.Position<Float3>(i)[2] -= 16.0f;
	}
	bulb->UpdateModelSpace(Visual::GU_NORMALS);

	vba.ApplyTo(rod);
	numVertices = vba.GetNumVertices();
	for (i = 0; i < numVertices; ++i)
	{
		vba.Position<Float3>(i)[2] -= 16.0f;
	}
	rod->UpdateModelSpace(Visual::GU_NORMALS);

	// Group the objects into a single subtree.
	mPendulum = new0 Node();
	mPendulum->AttachChild(rod);
	mPendulum->AttachChild(bulb);

	// Translate back to original model position.
	mPendulum->LocalTransform.SetTranslate(APoint(0.0f, 0.0f, 16.0f));

	// Add a material for coloring.
	Float4 black(0.0f, 0.0f, 0.0f, 1.0f);
	Float4 white(1.0f, 1.0f, 1.0f, 1.0f);
	Material* material = new0 Material();
	material->Emissive = black;
	material->Ambient = Float4(0.1f, 0.1f, 0.1f, 1.0f);
	material->Diffuse = Float4(0.99607f, 0.83920f, 0.67059f, 1.0f);
	material->Specular = black;

	// Use two lights to illuminate the pendulum.
	Light* light[2];
	light[0] = new0 Light(Light::LT_DIRECTIONAL);
	light[0]->Ambient = white;
	light[0]->Diffuse = white;
	light[0]->Specular = black;
	light[0]->SetDirection(AVector(-1.0f, -1.0f, 0.0f));

	light[1] = new0 Light(Light::LT_DIRECTIONAL);
	light[1]->Ambient = white;
	light[1]->Diffuse = white;
	light[1]->Specular = black;
	light[1]->SetDirection(AVector(+1.0f, -1.0f, 0.0f));

	// TODO:  The following code is used to piece together an effect with
	// two passes.  It is better to write an effect whose vertex shader
	// has constants corresponding to the two lights (for a single-pass
	// effect).
	LightDirPerVerEffect* effect = new0 LightDirPerVerEffect();
	VisualTechnique* technique = effect->GetTechnique(0);
	VisualPass* pass0 = technique->GetPass(0);
	VisualPass* pass1 = new0 VisualPass();
	pass1->SetVertexShader(pass0->GetVertexShader());
	pass1->SetPixelShader(pass0->GetPixelShader());
	AlphaState* astate = new0 AlphaState();
	astate->BlendEnabled = true;
	astate->SrcBlend = AlphaState::SBM_ONE;
	astate->DstBlend = AlphaState::DBM_ONE;
	pass1->SetAlphaState(astate);
	pass1->SetCullState(pass0->GetCullState());
	pass1->SetDepthState(pass0->GetDepthState());
	pass1->SetStencilState(pass0->GetStencilState());
//.........这里部分代码省略.........

//.........这里部分代码省略.........
	}
	if (mTextureCoordMap)
	{
		if (1 == mNumTexcoordToExport)
		{
			vFormat->Add(VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
		}
		else if (2 == mNumTexcoordToExport)
		{
			vFormat->Add(VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
			vFormat->Add(VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 1);
		}
	}
	if (mExportSkin)
	{
		vFormat->Add(VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT4, 1);
		vFormat->Add(VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT4, 2);
	}

	vFormat->Create();

	PX2::VertexBuffer *vBuffer = new0 PX2::VertexBuffer(mVertexMapQuantity, 
		vFormat->GetStride());

	VertexBufferAccessor vBA(vFormat, vBuffer);

	for (int i=0; i<mVertexMapQuantity; i++)
	{
		vBA.Position<Float3>(i) = mVertexMap[i];

		if (mNormalMap)
		{
			vBA.Normal<Float3>(i) = mNormalMap[i];
		}

		if (mColorMap)
		{
			vBA.Color<Float4>(0, i) = Float4(mColorMap[i][0], mColorMap[i][1],
				mColorMap[i][2], mColorMap[i][3]);
		}
		else
		{
			if (mExportColor)
				vBA.Color<Float4>(0, i) = Float4::WHITE;
		}

		if (mAlphaMap)
		{
			vBA.Color<Float4>(0, i) = Float4(mColorMap[i][0], mColorMap[i][1],
				mColorMap[i][2], mAlphaMap[i]);
		}

		if (mTextureCoordMap)
		{
			if (mNumTexcoordToExport == 1)
			{
				vBA.TCoord<Float2>(0, i) = Float2(mTextureCoordMap[i][0], 1.0f-mTextureCoordMap[i][1]);
			}
			else if (mNumTexcoordToExport == 2)
			{
				Float2 texCoord0 = Float2(mTextureCoordMap[i][0], 1.0f-mTextureCoordMap[i][1]);

				vBA.TCoord<Float2>(0, i) = texCoord0;

				if (mTextureCoordMap1)
				{
					vBA.TCoord<Float2>(1, i) = Float2(mTextureCoordMap1[i][0], 1.0f-mTextureCoordMap1[i][1]);
				}
				else
				{
					vBA.TCoord<Float2>(1, i) = texCoord0;
				}
			}
		}
	}
	
	// IndexBuffer
	IndexBuffer *iBuffer = new0 IndexBuffer(3*mFQuantity, 2);
	unsigned short *iData = (unsigned short*)iBuffer->GetData();
	for (int i=0; i<(int)3*mFQuantity; i++)
	{
		iData[i] = (unsigned short)mVFace[i];
	}

	// 创建Mesh
	TriMesh *triMesh = new0 TriMesh(vFormat, vBuffer, iBuffer);
	triMesh->UpdateModelSpace(Renderable::GU_MODEL_BOUND_ONLY);
	if (mExportTargentBinormal)
	{
		triMesh->UpdateModelSpace(Renderable::GU_USE_GEOMETRY);
	}

	MaterialInstance *mi = 0;
	mi = mMaterialInstance;

	triMesh->SetMaterialInstance(mi);
	triMesh->SetShine(mShine);

	return triMesh;
}