Help with math

[egizz983]

Hello guys dont want to ask but i need your help with a math calculations , i want to start draw a picture from the bottom right corner , so i need to get a pixels backward too and , but as many times i have tried i could find right calculations to find a current index , to draw farward function was

Code: Select all

for (int a = 0; a < heigth; a++) {
	for (int b = 0; b < width; b++) {
		PutPixel(x +b ,y + a , image[b + a * width].GetR(), image[b + a * width].GetG(), image[b + a * width].GetB());
	}
}

and now i need a calculations to get pixels backward from 4000 to 0, cuz example width 50 height 80 , i am bad at math and could not figure this out

[freebattie]

you just want to change the order the picture is drawn ?or flip it? if u just want to start drawing same picture for bottom right corner you do (a= height - 1; a >= 0;a++) and same whit b i think
and if you want to flip the colors you do this img[(a +((height - 1) ) - b) * width] that how i flip my img at least. but maybe i misunderstand what you ask

[egizz983]

you just want to change the order the picture is drawn ?or flip it? if u just want to start drawing same picture for bottom right corner you do (a= height - 1; a >= 0;a++) and same whit b i think
and if you want to flip the colors you do this img[(a +((height - 1) ) - b) * width] that how i flip my img at least. but maybe i misunderstand what you ask

color formula doent mach width 50 height 80

Code: Select all

for (int a = heigth; a > 0; a--) {
		for (int b = width; b > 0; b--) {

 (a +((height - 1) ) - b) * width // (80 + (80 - 1 ) - 50) *50 = 116k instead of 4k 
}
}

what i am asking is , usually at least me start drawing a picture from top left corner to the right bottom corner right , so i need a formula for a backwards from bottom right corner to the top left corner , so formula should return result from width*height to 0 , as example width 50 heigth 80 so from 4000-0 ..

Edited:
okay i got this formula : (b-1) + a * width , its works fine

Code: Select all

for (int a = heigth-1; a > 0; a--) {
		for (int b = width; b > 0; b--) {

 (b-1) + a * width
}
}

[freebattie]

well for you to put the first color you read at buttom right you need to do
(a = height - 1 ; a >= 0;a--) and same for b(b = width - 1 ; b >= 0;b--), then you will start your put pixel at button right and draw it upwords.

if you whant to get the colors backwords you do;

[x +((height -1) - y) * width]
50 +((80- 1 ) - 80 ) 50 =
79 - 80 = -1
50 * -1 = -50
50 - 50 = 0
and if a is 0 and b is 1 you get =
1 + (80 - 1) -0) *50 = 4000

[freebattie]

whit your fomula you will go over the array if you at 80 and 50,
50- 1 = 49
80*50 = 4000
49 + 4000 = 4049
c++ does everything inside () first then it does * and / then it does - and +
as i understand it, maybe i am wrong

[egizz983]

this is how i solved this

Code: Select all

void Graphics::DrawSpriteBackW(int x, int y, int width, int heigth, std::vector<Color>& image)
{
	for (int a = heigth-1; a > 0; a--) {
		for (int b = width; b >= 0; b--) {
		PutPixel((x+width) - (width -b), (y+heigth) - (heigth- a), image[b - 1 + a*width].GetR(), image[b - 1 + a*width].GetG(), image[b - 1 + a*width].GetB());

		}
	}
}

but its still are no perfect i mean what do i do with this is a clipping effect (you fire bullet witch goes y--) once it reach y == 0 you start drawing a backward and --height, so this will creates clipping effect but at the end you can see some drawing bug where the pixel are no mach or some even not draw(black)

i have finished clipping effect only with a machine gun type weapon , witch is inside DrawBullets function

[albinopapa]

To draw a sprite backward, or flipped from right to left:

Code: Select all

     // width 50, height 80
     // Your x values for drawing: 0, 1, 2, 3, 4, 5, ...
     // Your x values for surface: 49, 48, 47, 46, 45, 44, ...
     // Your loops will be going forward, from 0 to 49, and your image index will be going from 49 to 0
	for( int iy = 0; iy < height; ++iy )
	{
		for( int ix = 0; ix < width; ++ix )
		{
			int surfaceIndex = ( ( width - 1 ) - ix ) + ( iy * width );
			PutPixel( x + ix, y + iy, image[ surfaceIndex ] );
		}
	}

To flip top to bottom, you'd do almost the same thing.
int sufaceIndex = (ix + ((height - iy - 1) * width));

To flip both right to left and top to bottom.
int surfaceIndex = (width -1 - ix) + ((height - iy - 1) * width);

This formula doesn't take into account any clipping though. It seems you are decreasing the height to be your clipping guide, there might be a better way to handle clipping though.

[NaturalDemon]

Hmmmm, if i remember correctly, you draw several hundreds of frames per second depending on your hardware.
But you only need max 60 Fps, i believe you see pixels from the previous frame drawn over the current frame.

You should build a state machine with a timer .... That updates a complete drawn frame instead of a partial frame to the gpu buffer once per 16 milisecond (ms). 1000 ms / 60 fps = 16.xxx ms

You only have 1 "backbuffer" and you keep updating those pixels while presenting to the gpu.
You could make a second buffer and alternate between them.
But you need a mechanism to slow down.

[LuisR14]

probly wrong thread NaturalDemon

edit:
anyways about the flip image, you just have to flip either the output coord or the image access(if you do both then in effect you'd be drawing as if normal)
(following would have a screen offset for out coords tho, which would be flipped too hehe xD)

Code: Select all

normal x, and img.x:
for( int y = 0; y < height; y++ )
{
	for( int x = 0; x < width; x++ )
	{
		DrawPixel( x, y, image[ x + y * width ] ); // top/left-to-bottom/right image access -> screen top/left-to-bottom/right
	}
}

reverse x, normal img.x: (draw img to flipped screen)
for( int y = 0; y < height; y++ )
{
	for( int x = 0; x < width; x++ )
	{
		DrawPixel( width - x, y, image[ x + y * width ] ); // top/left-to-bottom/right image access -> screen top/right-to-bottom/left
	}
}

normal x, reverse img.x: (flip image)
for( int y = 0; y < height; y++ )
{
	for( int x = 0; x < width; x++ )
	{
		DrawPixel( x, y, image[ width - x + y * width ] ); // top/left-to-bottom/right image access -> screen top/left-to-bottom/right
	}
}

reverse x, and img.x: (draw flipped img to flipped screen, hence same as normal)
for( int y = 0; y < height; y++ ) // top-to-bottom loop
{
	for( int x = 0; x < width; x++ ) // left-to-right loop
	{
		DrawPixel( width - x, y, image[ width - x + y * width ] ); // top/right-to-bottom/left image access -> screen top/right-to-bottom/left
	}
}

to flip the offset would mean

Code: Select all

normal x: offset = x; as normal haha
reverse x: offset = (scrnwidth - img.width - x) - (scrnwidth - (scrnwidth - (x + img.width) * 2)) - img.width

(dam that's some formula, easier to go the non-flipped screen mode xD, maybe someone can simplify it haha)

[albinopapa]

Hmmmm, if i remember correctly, you draw several hundreds of frames per second depending on your hardware.
But you only need max 60 Fps, i believe you see pixels from the previous frame drawn over the current frame.

You should build a state machine with a timer .... That updates a complete drawn frame instead of a partial frame to the gpu buffer once per 16 milisecond (ms). 1000 ms / 60 fps = 16.xxx ms

You only have 1 "backbuffer" and you keep updating those pixels while presenting to the gpu.
You could make a second buffer and alternate between them.
But you need a mechanism to slow down.

Yeah, if you are on the correct thread, the chili framework is already double-buffered, so the frames don't get updated until all is drawn to back buffer, so it's not an issue of seeing pixels from previous frames.