Good evening all, so it has been a while since I've posted but I am back to working on some stuff now that I have time.  I'm working out some issues with a game I'm working on which is an old school 2D top down style JRPG.  I'm working out the code for rendering the map to the screen which I know is something that has been done a million times and believe me I have read through close to hundreds of articles and tried so many changes to my code to find out what is going on and what is causing the error I'm having and I still can't track down what I'm doing wrong so I have decided that it is time for a fresh set of eyes to look at my code.

Let me set the stage for what I'm doing I have my map setup so that I can have multiple layers to the map, to give the world some depth, and I am using a Vector to hold my array of int values that are used to decide the tiles to render to the screen. 

The issue I am having is somewhere between my rendering and my update code if I try to move the map at all on the screen I immediately get a Vector index out of bounds error and I can't track down what I'm doing wrong.  I know it is probably something simple but I can't see it.

Here is my update method:

void Layer::UpdateLayer(float deltaTime)
{
	// update the draw position based on scroll speed, velocity and the change in time from frame to frame
	m_currentDrawPosition.x += (m_scrollSpeed.x * m_velocity.x) * deltaTime;
	m_currentDrawPosition.y += (m_scrollSpeed.y * m_velocity.y) * deltaTime;

	// check to see that the draw position isn't less than 0
	if (m_currentDrawPosition.x < 0)
	{
		m_currentDrawPosition.x = 0;
	}

	// check to see that the draw position isn't greater than the size of the map
	if ( (m_mapDimensions.x >= RenderManager::GetInstance().GetGameWidth()) && 
		m_currentDrawPosition.x > m_mapDimensions.x - RenderManager::GetInstance().GetGameWidth())
	{
		m_currentDrawPosition.x = m_mapDimensions.x - RenderManager::GetInstance().GetGameWidth();
	}

	// check to see that the draw position isn't less than 0
	if (m_currentDrawPosition.y < 0)
	{
		m_currentDrawPosition.y = 0;
	}

	// check to see that the draw position isn't greater than the size of the map
	if ( (m_mapDimensions.y >= RenderManager::GetInstance().GetGameHeight()) &&
		m_currentDrawPosition.y > m_mapDimensions.y - RenderManager::GetInstance().GetGameHeight())
	{
		m_currentDrawPosition.y = m_mapDimensions.y - RenderManager::GetInstance().GetGameHeight();
	}
}

Here is my Render Method:

void Layer::RenderLayer()
{
	int screenRows = 0;		// int that represents the number of rows on the screen
	int screenColumns = 0;	// int that represents the number of columns on the screen
	int tileX = 0;			// int that represents x position on screen for a tile
	int tileY = 0;			// int that represents y position on screen for a tile
	int tileValue = 0;		// value of tile in tilemap at the position
	int textureColumns = 0;	// how many columns in the texture

							// only calculate and do rendering if this is a graphical layer
	if (m_layerType == graphicLayer)
	{
		// calculate certain values for rendering
		screenRows = RenderManager::GetInstance().GetGameHeight() / (int)(m_tileDimensions.y);
		screenColumns = RenderManager::GetInstance().GetGameWidth() / (int)(m_tileDimensions.x);

		if (screenColumns > m_layerColumns)
		{
			screenColumns = m_layerColumns;
		}

		if (screenRows > m_layerRows)
		{
			screenRows = m_layerRows;
		}

		tileX = (int)(m_currentDrawPosition.x / m_tileDimensions.x);
		tileY = (int)(m_currentDrawPosition.y / m_tileDimensions.y);

		textureColumns = (int)(RenderManager::GetInstance().GetTextureDesc(m_textureName).Width / m_tileDimensions.x);

		// traverse through the number of rows
		for (int row = 0; row < m_layerRows; row++)
		{
			// traverse through the number of columns
			for (int column = 0; column < m_layerColumns; column++)
			{
				// grab value from tilemap
				tileValue = m_tileMap[((tileY + row) * m_layerColumns + (tileX + column))];

				// calculate the source rectangle
				m_sourceRectangle.left = (long)((tileValue % textureColumns) * m_tileDimensions.x);
				m_sourceRectangle.top = (long)((tileValue / textureColumns) * m_tileDimensions.y);
				m_sourceRectangle.right = (long)(m_sourceRectangle.left + m_tileDimensions.x);
				m_sourceRectangle.bottom = (long)(m_sourceRectangle.top + m_tileDimensions.y);

				// calculate the destination rectangle
				m_destinationRectangle.left = (long)(column * m_tileDimensions.x);
				m_destinationRectangle.top = (long)(row * m_tileDimensions.y);
				m_destinationRectangle.right = (long)(m_destinationRectangle.left + m_tileDimensions.x);
				m_destinationRectangle.bottom = (long)(m_destinationRectangle.top + m_tileDimensions.y);

				// draw the tile to the screen at the correct position
				RenderManager::GetInstance().RenderObject(m_textureName, m_sourceRectangle, m_destinationRectangle);
			}
		}
	}
}

So although I'm not looking for somebody to write my code for me I'm looking for some help in figuring out what I'm doing wrong that is causing the error's I'm getting.  Please help me with this if you can.  Also let me know if you need any more info on how I'm doing things.

If you use the debugger while that exception occurs you should look at the values you pass as index into your m_tileMap.

You loop over the full(!) map, but apply tileX,tileY offset as well. Obviously that will get out of bounds once tileX or tileY are not zero.

Hmm ok so I looked at what you both were talking about and I figured out how to fix the issue somewhat... so it is no longer going out of bounds and it does scroll all around the map like it is supposed to which is great but I do have one problem left to solve which is now when it is scrolling up down left and right I get some weird abnormality which I think has to do with my sourceRectangle and DestinationRectangle code.  I have included a picture to show what it is doing:  I realize again this is probably something simple that I'm missing and I am going to keep looking at my own code to see if I can find it but if anybody has any ideas as to what is causing this please help.  I'm currently working off of very little sleep so any help is appreciated on this project.

Also somebody asked me about how I am rendering things just an FYI that might help in understanding I am using DirectX 11 but I'm using the DirectXTK in order to make doing 2D rendering easier which from what I can see there is no translate option for 2D in DirectXTK so...  And as a reminder this is how my look that render's the map to the screen looks right now.

		// traverse through the number of rows
		for (int row = 0; row < screenRows; row++)
		{
			// traverse through the number of columns
			for (int column = 0; column < screenColumns; column++)
			{
				// grab value from tilemap
				tileValue = m_tileMap[((tileY + row) * m_layerColumns + (tileX + column))];
				//tileValue = m_tileMap[(column * m_layerColumns) + row];

				// calculate the source rectangle
				//m_sourceRectangle.left = (long)((tileValue % textureColumns) * m_tileDimensions.x);
				m_sourceRectangle.left = (long)(m_currentDrawPosition.x + (long)((tileValue % textureColumns) * m_tileDimensions.x));
				m_sourceRectangle.top = (long)(m_currentDrawPosition.y + (tileValue / textureColumns) * m_tileDimensions.y);
				m_sourceRectangle.right = (long)(m_sourceRectangle.left + m_tileDimensions.x);
				m_sourceRectangle.bottom = (long)(m_sourceRectangle.top + m_tileDimensions.y);

				// calculate the destination rectangle
				m_destinationRectangle.left = (long)(column * m_tileDimensions.x);
				m_destinationRectangle.top = (long)(row * m_tileDimensions.y);
				m_destinationRectangle.right = (long)(m_destinationRectangle.left + m_tileDimensions.x);
				m_destinationRectangle.bottom = (long)(m_destinationRectangle.top + m_tileDimensions.y);

				// draw the tile to the screen at the correct position
				RenderManager::GetInstance().RenderObject(m_textureName, m_sourceRectangle, m_destinationRectangle);
			}
		}

4 minutes ago, McGrane said:

You should assign your indexer to an int, and step through it to ensure it is getting what you expect, there isint much information in what you showed - but i suspect its your m_layerColumns

id suspect that this is accessing the wrong value, depending on what its value actually is ( isint shown )

Hey thanks for responding here is the code that I use to define the layerColumns, and layerRows:

// calculate certain values for rendering
screenRows = (RenderManager::GetInstance().GetGameHeight() / (int)(m_tileDimensions.y) + 1);
screenColumns = (RenderManager::GetInstance().GetGameWidth() / (int)(m_tileDimensions.x) + 1);

Yes I will look at what you mentioned.

Hey so I figured this out it was my code for grabbing the tile actually lol so my source rectangle wasn't setup properly it was slowly grabbing different tiles from the array of tiles.  Now to speed up the scrolling speed...

I see what you are talking about with the rendering I'm not sure how to fix this yet I'm going to do some research.  The challenge is with using Direct X 11 + DirectXTK the way DirectXTK does rendering for 2D is using an implementation of a sprite batch which I currently have things setup so that every system in my engine that is currently active that needs to render does a render call between the SpriteBatch Begin call and the SpriteBatch End call.

But I have been trying to make this DirectXTK stuff work for a while now maybe its time to consider another way of rendering.