Jump to content
  • Advertisement

Archived

This topic is now archived and is closed to further replies.

DarkSaint

progress on DX9 isometric engine using direct3D

This topic is 5359 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

I just started on an isometric engine using DX9 at the beginning of this week, I just finished implementing lights and next I''m gonna finish the scrolling. Right now it''s 3D although it''s gonna be represented in a 2d fashion. What I want to know is if my rendering function is good right now or can it be optimized? here''s my maptile structure

struct BIGMAPTILE
{
    D3DXVECTOR3 position; // The 3D position for the vertex

    D3DXVECTOR3 normal;   // The surface normal for the vertex


#ifndef SHOW_HOW_TO_USE_TCI
	FLOAT tu,tv;
#endif
};
and my map structure

struct MAPSTRUCTURE{

	short TileID;
	LPDIRECT3DTEXTURE9 pTexture;
	short light[2]; //light[0] is used to determine whether or not a tile is lit while light[1] is the light type.


};

and other variables used
float const TileX = 128; //width of tiles in worldcoords

float const TileY = 64; //height of tiles in worldcoords


short ScreenTilesX = 8;
short ScreenTilesY = 20;
Here''s my rendering function

void RenderTiles (short CrntRndrLocX, short CrntRndrLocY)
{

	short ScrlPosX = 0;
	short ScrlPosY = 0;
	short CrntTileX = CrntRndrLocX;
	short CrntTileY = CrntRndrLocY;
	short CrntLayer = 0;
	short MapLayers = 2;
	BIGMAPTILE vertices[4];

	// Move to next column of tiles once the screen has scrolled a full tile width

	if(ScrlPosX <= -128)
	{
		CrntTileX += 1;
		ScrlPosX = 0;
	}

	for (int j = 0; j < 128; j++)
	{

		for (int i = 0; i < 128; i++)
	{
		map[2][i][j].pTexture = g_pTexture;

	}

	}

		// makes sure rendering never happens outside of map boundaries. solid numbers

		// need to be replaced with map width/hieght variables.

		// Start

		if (CrntTileX > 120)
		{
			CrntTileX = 120;
		}
		if (CrntTileX < 0)
		{
			CrntTileX = 0;
		}
		if (CrntTileY > 108)
		{
			CrntTileY = 108;
		}
		if (CrntTileY < 0)
		{
			CrntTileY = 0;
		}
		// End


	// Enter the tile Draw loop.

	for (int L = 0; L <= MapLayers; L++)
	{

		float Vert1PosX = (-512.0f + ScrlPosX);
		float Vert1PosY = (320.0f  + ScrlPosY);
		float Vert2PosX = (-448.0f + ScrlPosX);
		float Vert2PosY = (352.0f  + ScrlPosY);
		float Vert3PosX = (-448.0f + ScrlPosX);
		float Vert3PosY = (288.0f  + ScrlPosY);
		float Vert4PosX = (-384.0f + ScrlPosX);
		float Vert4PosY = (320.0f  + ScrlPosY);

	for (int Y = 0; Y < ScreenTilesY; Y++)
	{

	// Draw 1 row of tiles across the screen. Starts at outside leftside of the screen and ends

	// at the right, outside the screen.

	for (int X = 0; X < ScreenTilesX; X++)
	{

			// dapply a texture to the cuurent tile depending on what the tiles pTexture holds

			g_pd3dDevice->SetTexture( 0, map[CrntLayer][CrntTileX][CrntTileY].pTexture );
			g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
			g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
			g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );

			//Increase tile position along the x axis and declare image coords

			vertices[0].position = D3DXVECTOR3 (Vert1PosX += TileX, Vert1PosY, 0.5f);
			vertices[0].normal   = D3DXVECTOR3 (Vert1PosX ,Vert1PosY, -1.0f);
			vertices[0].tu       = 0;
			vertices[0].tv       = 1;

			vertices[1].position = D3DXVECTOR3 (Vert2PosX += TileX,Vert2PosY, 0.5f);
			vertices[1].normal   = D3DXVECTOR3 (Vert2PosX, Vert2PosY, 1.0f);
			vertices[1].tu       = 0;
		    vertices[1].tv       = 0;


			vertices[2].position = D3DXVECTOR3 (Vert3PosX += TileX,Vert3PosY, 0.5f);
			vertices[2].normal   = D3DXVECTOR3 (Vert3PosX, Vert3PosY , 1.0f);
			vertices[2].tu       = 1;
			vertices[2].tv       = 1;

			vertices[3].position = D3DXVECTOR3 (Vert4PosX += TileX,Vert4PosY, 0.5f);
			vertices[3].normal   = D3DXVECTOR3 (Vert4PosX, Vert4PosY, 1.0f);
			vertices[3].tu       = 1;
			vertices[3].tv       = 0;


			// Creates a light at a tile if the specified tile contains a light.

			// After the light is created light[0] is set to 0 to avoid creating multiple

			// lights in the same spot when the loop comes back around.

			if(map[CrntLayer][CrntTileX][CrntTileY].light[0] == 1)
			{

				CreateTileLt(Vert1PosX + 64, Vert1PosY, 10.0f, map[CrntLayer][CrntTileX][CrntTileY].light[1]);
				map[CrntLayer][CrntTileX][CrntTileY].light[0] = 0;

			}
    
    // Now we fill the vertex buffer. To do this, we need to Lock() the VB to

    // gain access to the vertices. This mechanism is required becuase vertex

    // buffers may be in device memory.


    VOID* pVertices;
    ( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) );
    memcpy( pVertices, vertices, sizeof(vertices) );
    g_pVB->Unlock();

        // Draw the triangles in the vertex buffer. This is broken into a few

        // steps. We are passing the vertices down a "stream", so first we need

        // to specify the source of that stream, which is our vertex buffer. Then

        // we need to let D3D know what vertex shader to use. Full, custom vertex

        // shaders are an advanced topic, but in most cases the vertex shader is

        // just the FVF, so that D3D knows what type of vertices we are dealing

        // with. Finally, we call DrawPrimitive() which does the actual rendering

        // of our geometry (in this case, just one triangle).

        g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(BIGMAPTILE) );
        g_pd3dDevice->SetFVF( D3DFVF_BIGMAPTILE );
        g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
		CrntTileX += 1;
	}

	// Shift the vertices back to outside of the left of the screen in order to draw the next row of tiles

	if ( 1 == CrntTileY % 2)
	{

		
		Vert1PosX -= TileX * ScreenTilesX -64.0f;
		Vert2PosX -= TileX * ScreenTilesX -64.0f;
		Vert3PosX -= TileX * ScreenTilesX -64.0f;
		Vert4PosX -= TileX * ScreenTilesX -64.0f;

	}
	else
	{
		Vert1PosX -= TileX * ScreenTilesX +64.0f;
		Vert2PosX -= TileX * ScreenTilesX +64.0f;
		Vert3PosX -= TileX * ScreenTilesX +64.0f;
		Vert4PosX -= TileX * ScreenTilesX +64.0f;
	}




	// Shift vertices down the screen half a tile width.

	Vert1PosY -= 32.0f;
	Vert2PosY -= 32.0f;
	Vert3PosY -= 32.0f;
	Vert4PosY -= 32.0f;

	//Move to the next row of tiles

	CrntTileY += 1;
	CrntTileX -= ScreenTilesX;
	}

	//Shift back up to the top row and move to the next layer

	CrntTileY -= ScreenTilesY;
	CrntLayer += 1;
	}

}

Share this post


Link to post
Share on other sites
Advertisement
Well this is not exactly an optimization thing, but something you should definitly think about nonetheless.

You''ve got quite a lot of magic numbers there. I would not even want think about changing the tile size. You should simplify this to be scaleable. When you improve your engine you may want to show higher-res tiles and you''ll be in quite a bit of trouble there.

Share this post


Link to post
Share on other sites

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!