Jump to content

  • Log In with Google      Sign In   
  • Create Account


Creating worldmatrix for renderables


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
1 reply to this topic

#1 cozzie   Members   -  Reputation: 1551

Like
0Likes
Like

Posted 21 February 2014 - 06:51 PM

Hi,

I'm moving from rendering whole mesh instances to renderables (submeshes of the mesh instance).

While doing this I can't figure out what's wrong with my world matrices of the renderables.

 

Here's a part of the code I use:

bool CD3dmeshInst::SetupBVWorldSpace(const CD3dmesh &pMesh)
{
	// resize vectors for renderables
	mRenderables.resize(pMesh.mSubMeshSize);

	TVERTEX *verticesPointer;
	TVERTEX *vertices = new TVERTEX[pMesh.mMesh->GetNumVertices()];

	pMesh.mVtxBuffer->Lock(0, 0, (void**)&verticesPointer, D3DLOCK_READONLY);		// ,0 = default
	memcpy(vertices, verticesPointer, pMesh.mMesh->GetNumVertices()*D3DXGetDeclVertexSize(vtxdecl, 0)); 
	pMesh.mVtxBuffer->Unlock();
	// VERTICES ARE NOT SCALED/ROTATED/TRANSLATED, AND ARE IN MODEL SPACE

	// CREATE BOUNDING VOLUMES (SPHERE & AABB) FOR FULL MESH, MODEL SPACE
	if(!SUCCEEDED(D3DXComputeBoundingSphere(&vertices[0].position, pMesh.mMesh->GetNumVertices(), D3DXGetDeclVertexSize(vtxdecl, 0), &mSphereCenterModelspace, &mSphereBoundingRadiusBase))) return false;	
	CreateAABB(vertices, 0, pMesh.mMesh->GetNumVertices(), &mBoundingBox);

	// CREATE BOUNDING VOLUMES (SPHERE & AABB) FOR RENDERABLES, MODEL SPACE
	for(size_t obj=0;obj<GetNrRenderables();++obj)
	{
		D3DXVECTOR3 sphereCenterModelspace;
		float sphereBoundingRadiusBase;
		if(!SUCCEEDED(D3DXComputeBoundingSphere(&vertices[pMesh.mSubMeshTable[obj].VertexStart].position, (DWORD)pMesh.mSubMeshTable[obj].VertexCount, D3DXGetDeclVertexSize(vtxdecl, 0), 
												&sphereCenterModelspace, &sphereBoundingRadiusBase))) return false; 
		
		mRenderables[obj].SetupBoundingSphere(sphereCenterModelspace, sphereBoundingRadiusBase);

		Crealysm_dxmath::BOUNDINGBOX bBox;
		CreateAABB(vertices, pMesh.mSubMeshTable[obj].VertexStart, pMesh.mSubMeshTable[obj].VertexCount, &bBox);

		mRenderables[obj].SetBoundingBox(bBox);
	}
	delete[] vertices;

	// CREATE WORLD MATRIX AND TRANFORM BOUNDING VOLUMES TO WORLDSPACE (SPHERE, AABB/OBB): FULL MESH
	CreateWorldMatrix(); 

	mSphereBoundingRadius = mSphereBoundingRadiusBase * mScale;

	for(int i=0;i<8;++i) D3DXVec3TransformCoord(&mBoundingBox.OBBcorners[i], &mBoundingBox.AABBcorners[i], &mMatWorld);
	UpdateAABBWorld(&mBoundingBox);

	D3DXVec3TransformCoord(&mBoundingBox.OBBcenter, &mBoundingBox.AABBcenter, &mMatWorld);
	mBoundingBox.OBBsize = mBoundingBox.AABBsize;

	// RENDERABLES: SETUP (i.e. CREATE WORLD MATRIX + BOUNDING VOLUMES TO WORLDSPACE)
	for(size_t obj=0;obj<GetNrRenderables();++obj)
	{
		mRenderables[obj].SetWorldPosParent(mWorldPos);			// mesh instance's world pos
		mRenderables[obj].SetRotParent(mRot);					// uses mesh instance's rotation as base
		
		mRenderables[obj].SetScale(mScale);
		mRenderables[obj].SetDynamic(mDynamic);					// for now all renderables take over mDynamic from the mesh instance!!

		if(!mRenderables[obj].Setup()) return false;
	}
	return true;
}


// setting up the renderable

bool CD3drenderable::Setup()
{
	if(mScale == 0.0f) return false;
	if(!mBoundingBox.created) return false;
	
	mWorldPos = mWorldPosParent + mSphereCenterModelspace;

	CreateWorldMatrix();

	mSphereBoundingRadius = mSphereBoundingRadiusBase * mScale;

	for(int i=0;i<8;++i) D3DXVec3TransformCoord(&mBoundingBox.OBBcorners[i], &mBoundingBox.AABBcorners[i], &mMatWorld);
	UpdateAABBWorld(&mBoundingBox);

	D3DXVec3TransformCoord(&mBoundingBox.OBBcenter, &mBoundingBox.AABBcenter, &mMatWorld);
	mBoundingBox.OBBsize = mBoundingBox.AABBsize;

	mAffectedLightIds.reserve(10);
	return true;
}

The result is this, there's a distance between the individual renderables:

 

renderable_nok.jpg

 

 

When I make the worldspace position of the renderables the same as the world pos of the whole instance, the result looks as expected. But that doesn't match up the theory and doesn't give me correct results for light culling, because the world position is then used to check the distance to point lights, which gives incorrect large distances for renderables that are far away from the center of the complete mesh instance.

//	mWorldPos = mWorldPosParent + mSphereCenterModelspace;
	mWorldPos = mWorldPosParent;

This is the result with this 'hack':

 

renderable_ok.jpg

 

 

My preliminary conclusion is that somehow the renderables vertices are handled like they are based around the origin of the whole mesh instance instead of their own origin (world matrix).

 

Any idea what's I'm not seeing?



Sponsor:

#2 cozzie   Members   -  Reputation: 1551

Like
0Likes
Like

Posted 22 February 2014 - 04:31 AM

I've been thinking about it and think I've made a fundemental mistake. Even it the above approach would work it wouldn't give much flexibility.

Should te approach be:

 

- mesh instance has it's own world matrix

- renderable has it's separate own matrix, with all offsets in relation to the parent

(i.e. worldpos = difference of center of the renderable to worldpos of mesh instance and in my case 0 rot and scale 1.0)

- the rendable class should have 2 functions for returning it's matrix: 1 = local, 2 = local multiplied * parent

- that way I don't have to save relations on transformations just multiply the parent with renderable matrix if something changes

 

What do you think?






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS