Passing the Pointer the wrong way?

[Incubbus]

Hey...

I got the following Code

void CStarField::Draw(LPDIRECT3DSURFACE9 Surface)
{
	D3DLOCKED_RECT LockedRect;

	if(FAILED(Surface->LockRect(&LockedRect,NULL,0)))
	{
		MessageBox(NULL,"Error Locking","",MB_ICONERROR | MB_OK);
		return;
	}

	int Pitch = LockedRect.Pitch / 4;

	D3DCOLOR *Pixels = (D3DCOLOR*)LockedRect.pBits;

	for(int i =0; i < m_NumberOfStars;i++)
	{
		m_Stars[i].Draw(Pixels,Pitch);
		m_Stars[i].Move();
	}

	Surface->UnlockRect();
}

and

void CStar::Draw(D3DCOLOR* Pixels, int Pitch)
{
	int index = ((int)m_y * Pitch + (int)m_x);

	for(int i = 0; i < m_length; i++)
	{
		Pixels[index + i*Pitch] = StarColors[i]; Here
	}
}

the MS VC debugger sets the error indicating arrow (the yellow arrow) right in front of the int index = ((int)m_y * Pitch + (int)m_x);

and says "Error writing at location"...

Do i do something wrong with the pointer?...

What drives me crazy is the fact, that this works while trying this with an simple array of x- and y- coordinates outside a class (just within the WM_PAINT-message)...

[EDIT]: when i expand the "this"-Pointer it cant resolve/show me the m_x, m_y, m_dy and m_length - members...

[Bazzy]

What are m_y and m_x ?

[Incubbus]

pardon, forgot it:

My Star Class:

class CStar
{
public:
	CStar(void);
	~CStar(void);
	void Move(void);
	void CalcNewPos(void);
	void Draw(LPDIRECT3DSURFACE9);

protected:
	float m_x;
	float m_y;
	float m_dy;
	float m_length;
};
//////////////////////////////
CStar::CStar(void)
{
	CalcNewPos();
}

CStar::~CStar(void)
{
	CalcNewPos();
}

void CStar::Move(void)
{
	m_y += m_dy;

	//Out of Framge
	if(y >= 600 - m_length)
	{
		CalcNewPos();

		m_y = m_dy;
	}
}

void CStar::CalcNewPos(void)
{
	m_x = (rand() % 800);
	m_y = (rand() % 600);

	m_dy = (rand() % MAX_SPEED);
	m_dy /= 10;

	m_length = (int)m_dy+1;
}

void CStar::Draw(D3DCOLOR* Pixels, int Pitch)
{
	int index = ((int)m_y * Pitch + (int)m_x);

	for(int i = 0; i < m_length; i++)
	{
		Pixels[index + i*Pitch] = StarColors[i]; Here
	}

}

and my StarField-Class:

class CStarField
{
public:
	CStarField(void);
	CStarField(int);
	~CStarField(void);

	void Draw(LPDIRECT3DSURFACE9 Surface);
	void SetStars(int number);

protected:
	CStar* m_Stars;
	int m_NumberOfStars;
};
///////////////////////////////////////

CStarField::CStarField(void) : m_NumberOfStars(20)
{
}

CStarField::CStarField(int NumberOfStars)
{
	m_NumberOfStars = NumberOfStars;
}


CStarField::~CStarField(void)
{
	delete [] m_Stars;
}

void CStarField::Draw(LPDIRECT3DSURFACE9 Surface)
{

	D3DLOCKED_RECT LockedRect;

	if(FAILED(Surface->LockRect(&LockedRect,NULL,0)))
	{
		MessageBox(NULL,"Error Locking","",MB_ICONERROR | MB_OK);
		return;
	}

	int Pitch = LockedRect.Pitch / 4;

	D3DCOLOR *Pixels = (D3DCOLOR*)LockedRect.pBits;

	for(int i =0; i < m_NumberOfStars;i++)
	{
		m_Stars[i].Draw(Pixels,Pitch);
		m_Stars[i].Move();
	}

	Surface->UnlockRect();

}

void CStarField::SetStars(int number)
{
	m_NumberOfStars = number;
	m_Stars = new CStar[number];
}

Originally i did let my StarField-Class lock the Surface but that didnt work, too... so i tried to lock it for any access (what definetly is not very fast)

[Bazzy]

Check for overflow in Pixels[index + i*Pitch] when passing a pointer to be used as an array you should also pass the array size so you can check it
eg:

void CStar::Draw(D3DCOLOR* Pixels, int size, int Pitch)
{
	int index = ((int)m_y * Pitch + (int)m_x);

	for(int i = 0; i < m_length; i++)
	{
		int pixel_index = index + i*Pitch;
 		if ( pixel_index >= size )
 			break; //exit from the loop as continuing would cause overflow
		Pixels[ pixel_index ] = StarColors[i];
	}
}

[Incubbus]

1.

void CStar::Draw(D3DCOLOR* Pixels, int Pitch)
{
	>>>Error Marker Goes here<<<int index = ((int)m_y * Pitch + (int)m_x);

	for(int i = 0; i < m_length; i++)
	{
		Pixels[index + i*Pitch] = StarColors[i]; Here
	}

}

2. I dont know how to get the size of the the space allocated behind the pointer, because D3DLOCKED_RECT:

typedef struct _D3DLOCKED_RECT
{
    INT                 Pitch;
    void*               pBits;
} D3DLOCKED_RECT;

where pBits is an Pointer to the memory for the Pixels which needs to be casted...
and Pitch is the memory in bytes reserved for image informations in the memory allocated to pBits... I need to divide it by 4, because i use 32bit Color Formats...

[EDIT]:: according to this my Arrays size is (on my GPU - Pitch == 3200) in Bytes would be 3200 bytes * 600 rows... =1920000 bytes... devided by 4 = 480000 ... muahrahrahrhar... the maximum acess i do is 480800 for the point x = 800, y = 600 T_T... but the space behind that should still be accessible, because its about 1920000 bytes for the whole thing ...
(http://msdn.microsoft.com/en-us/library/bb206357%28VS.85%29.aspx)

where am i mistaken? -.-