Sorry your browser is not supported!

// http://code.google.com/p/darkbasicpro/source/browse/trunk/%20darkbasicpro%20--username%20LeeBamberTGC/Dark%20Basic%20Pro%20SDK/Shared/Objects/CommonC.h

bool CreateNewObject            ( int iID, LPSTR pName, int iFrame );
sFrame* CreateNewFrame          ( sObject* pObject, LPSTR pName, bool bNewMesh );
bool SetupStandardVertex        ( DWORD dwFVF, BYTE* pVertex, int iOffset, float x, float y, float z, float nx, float ny, float nz, DWORD dwDiffuseColour, float tu, float tv );
bool SetupMeshFVFData           ( sMesh* pMesh, DWORD dwFVF, DWORD dwVertexCount, DWORD dwIndexCount );
bool SetNewObjectFinalProperties( int iID, float fRadius );
void SetTexture                 ( int iID, int iImage );

bool CreateDBO(int iID, const aiScene *scene){
	DWORD dwMeshCount = scene->mNumMeshes;
    DWORD dwFrameCount = dwMeshCount;
    // create a new object
    CreateNewObject ( iID, "test", 1);

    // setup general object data
    sObject*        pObject = dbGetObject ( iID );

	for(int frame = 0; frame < dwFrameCount; frame++){
		//bool hasTex = scene->mMeshes[frame]->HasTextureCoords(0);
		//int channels = scene->mMeshes[frame]->GetNumUVChannels();
        sFrame* pFrame = 0;
		if(frame == 0){
           pFrame  = pObject->pFrame;
		}
		else{
           pFrame = CreateNewFrame(pObject, "", true);
		}
        sMesh* pMesh   = pFrame->pMesh;
		
		// create vertex memory
		DWORD dwVertexCount = scene->mMeshes[frame]->mNumVertices;  // store number of vertices
		DWORD dwFaceCount   = scene->mMeshes[frame]->mNumFaces;
		DWORD dwIndexCount  = dwFaceCount * 3;                      // store number of indices
		SetupMeshFVFData ( pMesh, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1, dwVertexCount, dwIndexCount);

		// VERTICES
		for(int i = 0; i < dwVertexCount; i++){
			aiVector3D pos = scene->mMeshes[frame]->mVertices[i];
			aiVector3D norm = scene->mMeshes[frame]->mNormals[i];
			aiVector3D uv = scene->mMeshes[frame]->mTextureCoords[0][i];
			SetupStandardVertex ( pMesh->dwFVF, pMesh->pVertexData, i, pos.x, pos.y, pos.z, norm.x, norm.y, norm.z, D3DCOLOR_ARGB ( 255, 255, 255, 255 ), uv.x, uv.y );
		}

		bool faces = scene->mMeshes[frame]->HasFaces();
		// INDICES
		int iIndex = 0;
		for(int i = 0; i < dwFaceCount; i++){
			aiFace face = scene->mMeshes[frame]->mFaces[i];
			for(int index = 0; index < face.mNumIndices; index++){
				pMesh->pIndices[iIndex] = face.mIndices[index];
				iIndex++;
			}
		}

		// setup mesh drawing properties
		pMesh->iPrimitiveType   = D3DPT_TRIANGLELIST;
		pMesh->iDrawVertexCount = dwVertexCount;
		pMesh->iDrawPrimitives  = dwFaceCount;  // if indexdata?
	}
    // setup new object and introduce to buffers
    SetNewObjectFinalProperties ( iID, 10 );

    // give the object a default texture
    SetTexture ( iID, 0 );
	return true;
}

void _GDK_PM::GDK_build_object()
{
	iLimbCount = map_size * 3;
	ObjID = GDK_free_object();

	CreateNewObject( ObjID, "", 1 );
	pObject = dbGetObject( ObjID );

	GDK_dbo_floor();
	GDK_dbo_wall();
	GDK_dbo_roof();

	SetNewObjectFinalProperties( ObjID, 10.0f );
	SetTexture( ObjID, 0 );

	dbConvertObjectFVF( ObjID, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 | D3DFVF_DIFFUSE | D3DFVF_SPECULAR );

	int loop, type;
	int wall_off = map_size;
	int roof_off = wall_off + map_size;

	for ( loop = 0; loop < map_size; loop ++ )
	{
		type = pSegList[loop].faces[0].type;

		int limb = loop + 1;

		if ( type == PM_RFACE )
		{
			if ( textures[0] ) dbTextureLimb( ObjID, limb, textures[0] );
			else				 dbColorLimb( ObjID, limb, 0xffffff );
			if ( textures[1] ) dbTextureLimb( ObjID, limb + wall_off, textures[1] );
			else				 dbColorLimb( ObjID, limb + wall_off, 0xff8800 );
			if ( textures[2] ) dbTextureLimb( ObjID, limb + roof_off, textures[2] );
			else				 dbColorLimb( ObjID, limb + roof_off, 0xff0000 );
		}
		else
		{
			if ( textures[3] ) dbTextureLimb( ObjID, limb, textures[3] );
			else				 dbColorLimb( ObjID, limb, 0x00ffff );
			if ( textures[4] ) dbTextureLimb( ObjID, limb + wall_off, textures[4] );
			else				 dbColorLimb( ObjID, limb + wall_off, 0x00ff88 );
			if ( textures[5] ) dbTextureLimb( ObjID, limb + roof_off, textures[5] );
			else				 dbColorLimb( ObjID, limb + roof_off, 0x00ff00 );
		}
	}

	dbSetObjectSpecular( ObjID, 0xffffff );
	dbSetObjectSpecularPower( ObjID, 5 );
}

void _GDK_PM::GDK_dbo_floor()
{
	int iVerts, iIndices, loop;

	sFrame *pFrame = 0;

	for ( curr_seg = 0; curr_seg < map_size; curr_seg++ )
	{
		// get the mesh size

		iVerts	 = pSegList[curr_seg].verts.size();
		iIndices = pSegList[curr_seg].faces.size() * 3;

		// create a new frame? (Not if very first mesh to add)

		if ( curr_seg == 0)
			pFrame = pObject->pFrame;
		else
			pFrame = CreateNewFrame( pObject, "", true );

		// setup the new mesh data

		sMesh *pMesh = pFrame->pMesh;
		SetupMeshFVFData( pMesh, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1, iVerts, iIndices );

		// add verts

		_VERT *v = &pSegList[curr_seg].verts[0];
		int size = pSegList[curr_seg].verts.size();
		
		for ( loop = 0; loop < size; loop++ )
		{
			SetupStandardVertex(pMesh->dwFVF, pMesh->pVertexData, loop,
				v->x, v->y, v->z, v->nx, v->ny, v->nz, 0xffffff, v->s, v->t );
			v++;
		}

		// add faces

		size = pSegList[curr_seg].faces.size();
		_FACE * f = &pSegList[curr_seg].faces[0];

		for ( loop = 0; loop < size; loop++ )
		{
			pMesh->pIndices[loop*3]		= f->v1;
			pMesh->pIndices[loop*3+1]	= f->v2;
			pMesh->pIndices[loop*3+2]	= f->v3;
			f++;
		}

		// finalise limb

		pMesh->iPrimitiveType	= D3DPT_TRIANGLELIST;
		pMesh->iDrawVertexCount = iVerts;
		pMesh->iDrawPrimitives	= pSegList[curr_seg].faces.size();
	} // EOF for ( curr_seg
}

		// create a new frame? (Not if very first mesh to add)

		if ( curr_seg == 0)
			pFrame = pObject->pFrame;
		else
			pFrame = CreateNewFrame( pObject, "", true );

GDK_dbo_floor();
GDK_dbo_wall();
GDK_dbo_roof();

GDK_dbo_wall();
GDK_dbo_roof();
GDK_dbo_floor();

if ( DBO_flag == false)
		{
			DBO_flag = true;
			pFrame = pObject->pFrame;
		}
		else
			pFrame = CreateNewFrame( pObject, "", true );