04.03 - Pixel Manipulation - Hands-On Interactive Game Development

Teej · 2001-12-29T16:46:05

Starting With the Basics So far, we’ve looked at our game template code and how it uses DirectDraw to get us into a full-screen mode with our desired resolution and color depth. We then created DirectDrawSurface objects for the primary display (video card), and a backbuffer for our actual drawing. You know, I really like the overhead projector analogy with transparencies (clear plastic sheets). Our primary surface is the transparency currently on the overhead projector, and our backbuffer is an extra sheet on our desk. We’ll draw whatever we want onto this backbuffer, and quickly trade transparencies so that the backbuffer becomes the active display, and we start drawing all over again on the new backbuffer. We’re going to start drawing things on surfaces, and we’re going to start from scratch. What that means is that you take the contents of Game_Main() and clean it out so that it looks like this: void Game_Main() { } You can go ahead and run this program, and as you’d expect, nothing will be displayed. Thankfully the ESC key press is intercepted by Windows and passed to our template code via WindowProc() so that the program can terminate properly. Remember now, this function gets called over and over so long as the program is running. We know that there’s a primary DirectDrawSurface object for the active display and a secondary DirectDrawSurface object that’s our backbuffer. We also know that the plan is to draw onto the backbuffer and flip the two DirectDraw surfaces so that the backbuffer surface becomes the active display surface. Okay, so let’s paint some pixels! Pixel Painting Our first objective is to get our hands on the memory held by the backbuffer DirectDrawSurface object. The online SDK docs tell us that there are two methods for this purpose, Lock() and Unlock() . Okay, so let’s take a look at Lock() : HRESULT Lock ( LPRECT lpDestRect; LPDDSURFACEDESC2 lpDDSurfaceDesc; DWORD dwFlags, HANDLE hEvent ); You really need to have the online SDK docs open in order to be able to fill out method calls like this correctly – especially when flags are involved. We’ll fill in the parameters together, assuming that you are reading along: We can ask for a particular region of surface memory to lock, but we really want the entire thing, so we use NULL (as per the doc directions). This method requires a pointer to a valid DDSURFACEDESC2 structure. Lock() will fill in certain fields in this structure for us to use. So, we create a DDSURFACEDESC2 variable on the stack (‘on the stack’ means a local variable) and pass a pointer to it to the Lock() method as our second parameter. Taking a look at the possible flags in the docs, we see that DDLOCK_SURFACEMEMORYPTR is a must-have. Later in the tutorial we’ll explore the use of other flags, but for now this is all we need. We are told to use NULL here. No problem. Here’s the finished product: DDSURFACEDESC2 ddsd; // Lock the backbuffer surface ZeroMemory(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); G.lpDDSBack->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); First, I’ve cleared the DDSURFACEDESC2 structure using ZeroMemory() , which is the same thing as calling memset() – we’re just setting the entire structure to zeros. Then, we’re placing the size of the structure into the structure itself in the dwSize field. This is important, as many DirectX methods use structures as parameters and require us to supply the size in this field. Although it’s not important to us why, it’s worth mentioning that this is the only way a DirectX method can tell what structure we’re giving it is to provide the structure’s size. If you consider the fact that there’s a DDSURFACEDESC structure and a DDSURFACEDESC2 structure available, you can see why telling the difference might be important. And then, we call Lock() with our parameters. All DirectX methods returns values of type HRESULT, but for simplicity’s sake I’m not taking the return values into account for now. Rest assured however that we’ll need to, because so many things can go wrong and if you’re not checking the results of method calls, you get what you deserve in terms of headaches when things don’t work right (or worse yet, crash). There are two fields inside of the DDSURFACEDESC2 structure that we’re interested in, lpSurface and lPitch . With these two fields, we have everything we need to draw onto the backbuffer. Before I get to their use however, I’d like to get the rest of the DirectDraw methods out of the way. Okay, so assuming we’ve done our drawing, we are then supposed to unlock the backbuffer. This is done with Unlock() , which looks like this: HRESULT Unlock ( LPRECT lpRect ); This one’s easy – if you used a RECT in the call to Lock() , give it here as well. For us, we’ve locked the entire buffer, so we simply use NULL here as well: G.lpDDSBack->Unlock(NULL); The last thing we need to do is to actually get the backbuffer onto the active display. The method is called Flip() , and its prototype looks like this: HRESULT Flip ( LPDIRECTDRAWSURFACE7 lpDDSurfaceTargetOverride, DWORD dwFlags ); If you read the paragraph in the SDK docs describing the first parameter, you quickly realize that it’s an advanced feature we don’t need. For us, the default action is to flip the primary and secondary buffer, so we use NULL here. As for the flags, we don’t need any of them, so we’ll use 0. That’s it for DirectDraw calls! If you were to run the program now, you’d still see nothing (maybe some memory garbage), but the template for pixel manipulation is in place. Our last task in Game_Main() now is to actually alter the backbuffer memory using the surface pointer provided by Lock() . Accessing Surface Memory How large do you think the area of memory is that we now have access to? Well, what’s involved in figuring it out? Here’s the criteria: screen width in pixels screen height in pixels color depth (in bits) The logic is as follows: If I have 10 pixels across and 10 pixels down, I therefore have 100 pixels on the display. If each pixel needs 16 bits (= 2 bytes) of memory, then I’d need 100 pixels * 2 bytes = 200 bytes of memory. In our particular case, we’d like to use a 640x480 screen with 16-bit color, which would make our memory needs 614,400 bytes. For this article, I’m going to assume that your video card can handle 16-bit color. I’m also going to assume that it maps 5 bits for red and blue, and 6 bits for green (the most popular combination). Some video cards prefer to use 5 bits for each color component and use the remaining bit as an alpha component, and there’s a way to check in your code for what type of video card you have, but it’s really outside of the scope of this article. Now, it’s a fact that pointers to areas of memory can also be used as arrays. As a matter of fact, an array name is equivalent to a pointer. What we’d like to do is take our surface memory pointer and use it like an array, with each array element corresponding to a single pixel. This way, pixels would be accessed like this: buffer[0] = color; // First pixel (0,0) buffer[10] = color; // (10,0) So, the first row of pixels in a 640x480 display would be numbered 0-639. Therefore, the first pixel in the second row would be number 640: buffer[640] = color; // (0,1) …and the first pixel in the third row would be 640 + 640 = 1280. Generalizing, we can use the following: int x, y; buffer[y * SCREEN_WIDTH + x] = color; // (x,y) Make sure that the above line makes perfect sense to you. Every time we go SCREEN_WIDTH pixels across, we end up directly underneath ourselves, so we move an additional x pixels over to get to any location on the display. There are two outstanding issues at this point: the surface memory pointer and the actual color value composition. We’re almost there… Typecasting the Buffer Pointer The surface memory pointer given to us by Lock() is of type LPVOID. In other words, it can’t be used until it is ‘cast’ to a proper data type. Just like with an array, the pointer needs a type so that when we do something like this: buffer[3] = color; …the compiler knows how far over in memory the fourth element is (0,1,2,3 = 4th). Is it a byte? Ten bytes? Forty-three? When we declare an array like this: int Array[20]; …the compiler knows that each element is four bytes wide because that’s how large an int is. The answer here is to figure out how big a pixel is, and typecast our surface pointer to some data type that matches. Since we’re playing with 16-bit color, any 16-bit unsigned data type will do (there are no negative color values). Now, I realize that some people would like assistance with all of these data types, so check in 03.03 – Selected C Topics for an overview. I can tell you that either USHORT* or WORD* would work fine, so let’s use WORD. It’s now time to take possession of the surface pointer hidden in that DDSURFACEDESC2 structure we got back from Lock() : WORD *pwBuffer; pwBuffer = (WORD *)ddsd.lpSurface; That’s it! The (WORD *) is the typecast that changes the pointer from LPVOID (VOID*) to WORD*. Now, every time we access pwBuffer elements, we’ll be moving 16-bits at a time – exactly the size of a pixel in 16-bit color mode. Using the Memory Pitch In our illustrations, screen memory (in bytes) is exactly 640x480 multiplied by the number of bytes per pixel. In reality however, there’s a notable difference – the video adapter may reserve some extra memory for itself. If you picture the surface memory as being a rectangle (just like the monitor screen), then picture the video card’s private memory as being a rectangular ‘growth’ coming out of the right-hand side of the monitor. In other words, the number of bytes per horizontal line is equal to the number of pixels per line times the number of bytes per pixel, PLUS the video card’s reserved memory. This is where the lPitch field comes in. This value represents the total number of bytes used by the video card of each horizontal line of memory for the display (which equals the visible display memory plus the reserved memory). Don’t let it bake your brain too much; just read this next line a few times over: buffer[ y * lPitch + x] = color; Of course, this assumes that the pitch is in pixels. DirectDraw gives it to us in bytes, so if you’re not using 8-bit color you’d better fix that value like so: long lPitch; // Get the pitch for 16-bit pixels lPitch = ddsd.lPitch / 2; The reasoning is like this: If there are x bytes in each row, then there are x / 2 WORDs in each row. It’s like in math – if your unit of measurement is metres, make sure you convert any miles and inches before evaluating anything. For us, we’ve decided that a pixel is one WORD wide, so we need our pitch in WORDs, not bytes. Put another way, think: “If the video card uses x bytes per row, how many pixels per row is that?”. Color Composition To some extent, I’ve already covered this subject in the Learning Ladder series, but I’ll reiterate some of it here for clarity. Our pixels are 16-bits wide, and out buffer has been typecast to 16-bit elements. This means that whatever we assign to an array element will be 16 bits wide. Recall that in 5,6,5 16-bit color mode we have 5 bits available for red (intensity (brightness) from 0-31), 6 bits for green (0-63), and 5 bits for blue (0-31). Once you’ve decided on your values for these three, you need to combine them into a 16-bit number. Since I’ve already discussed how this is done, I’ll just show you a macro that’s included in GAMEMAIN.CPP to make life a little easier: // This converts an R,G,B set to a 16-bit color (565) #define RGB16(r,g,b) ((r << 11) + (g << 5) + b) Here’s how you would use it with a buffer: buffer[0] = RGB16(0, 0, 0); // Black buffer[1] = RGB16(31, 63, 31); // White buffer[2] = RGB16(31, 0, 0); // Red buffer[3] = RGB16(031, 0, 31); // Purple (Red + Blue) Just think of each color component as a brightness knob that you adjust from 0% to 100%. The color component’s highest allowed value is 100% bright, and 0 is always 0%. It may seem odd that green has an extra bit to it, and therefore can produce a higher maximum value, but don’t forget that 0 is 0, 63 is 100% brightness, and 50% brightness is ~32, just like ~16 is 50% bright for red or blue. Putting it all Together Let’s bring out the complete Game_Main() as it stands: void Game_Main() { DDSURFACEDESC2 ddsd; WORD *buffer; long lPitch; // Prepare a DDSURFACEDESC2 structure for Lock() ZeroMemory(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); // Lock the backbuffer surface G.lpDDSBack->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); // Get the surface pointer and the memory pitch (in WORDs) buffer = (WORD *)ddsd.lpSurface; lPitch = ddsd.lPitch / 2; // (bytes / 2 = WORDs) // Draw onto the display // Fill the entire screen with white pixels int x, y; for (y = 0; y < SCREEN_HEIGHT; y++) { for (x = 0; x < SCREEN_WIDTH; x++) { buffer[y * lPitch + x] = RGB16(31, 63, 31); } } // Unlock the surface G.lpDDSBack->Unlock(NULL); // Flip the surfaces G.lpDDSPrimary->Flip(NULL, 0); } Pop that into your GAMEMAIN.CPP, and take a quick look at GLOBALS.H to make sure that you’re in 16-bit color mode (i.e. SCREEN_BITDEPTH is 16). As it says, this function will color every pixel on the display white. Go Play With Yourself It’s absolutely vital that you take the time (the more the better) to really play with this function – especially the actual pixel coloring. I can think of dozens of cool effects to try and create right off the top of my head, so there’s plenty that can be done here with a few simple variables and some creative thinking. Here’s some little tidbits that might come in handy in your adventures: The rand() function returns a pseudo-random number between 0 and 32,767. When used with the modulo operator (%), you can get a number in any range. Here’s an example: buffer[0] = RGB16(rand()%32, rand()%64, rand()%32); Since % gives you a remainder, something like rand()%32 will give you a number between 0 and 31, which is the exact range for a 5-bit color component. You might be interested in 'seeding' the random-number generator, which basically gives you fresh, unique streams of random numbers -- look in your online help for more information. The static keyword, when used with a local variable (i.e. a variable declared inside of a function) will retain its value between function calls. A function like this: void SomeFunction() { static int i = 0; printf(“Number = %d”, i); i++; } …will output increasing values for i with every call, instead of always printing zeros if the variable wasn’t static. With variables of this type, you can do some interesting things with Game_Main() . SCREEN_WIDTH and SCREEN_HEIGHT are your friends. Never use hard-coded values in Game_Main() . Also, many interesting effects can be generated by using these definitions in your drawing code. Some Things to Try If you’re feeling like a challenge, try the following: Create solid diagonal lines of varying color on the display Create a sequence of boxes around the screen, steadily decreasing in size down to the middle Emulate gray-scale “off-air” television noise (think Poltergeist) Have single pixels or lines race from the top-left to the bottom right of the display Scatter pixels on the display that pulsate in varying colors We don’t want to get too complicated here, but I’d love to have anyone who comes up with a cool creation using simple variables, loops and math functions to submit it for everyone to see and try. Questions? Comments? Do you have a wicked demo to show off? Please reply to this topic! Edited by - teej on May 10, 2001 10:59:32 AM

mirrorman

122

June 14, 2001 03:06 PM

Got a bit carried away with this one, but once I started, I couldn't stop! Far too many angles and radii to keep track of...

Thanks for the tutorial, Teej, this is by far the best on the net. THANKS!

      void Game_Main(){    WORD *buffer;    long lPitch;    DDBLTFX ddbltfx;    ZeroMemory(&ddbltfx, sizeof(ddbltfx));    ddbltfx.dwSize = sizeof(ddbltfx);    // fill with black      ddbltfx.dwFillColor = 0;      G.lpDDSBack->Blt(NULL,NULL,NULL,                     DDBLT_COLORFILL | DDBLT_WAIT,                     &ddbltfx);        DDSURFACEDESC2 ddsd;    ZeroMemory(&ddsd, sizeof(ddsd));    ddsd.dwSize = sizeof(ddsd);    	// lock surface    G.lpDDSBack->Lock(NULL, &ddsd,                          DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,                          NULL);    buffer = (WORD *)ddsd.lpSurface;    lPitch = ddsd.lPitch/2;    	double theta,angle;	static double firsttheta=0,bigtheta=0;	int x,y,r;	static int radius=1;	// radius of coloured circles	double xcentre;		// centre coords of each coloured  	double ycentre;		// circle	WORD colour;	double tempblue, tempred;	int green, red, blue;	static int flag=0;		// draw three circles 120 degrees apart	for (angle=bigtheta; angle<360+bigtheta; angle=angle+120)	{		// calculate centre coords of each circle 		xcentre=(100*cos(angle*(3.141/180)))+(SCREEN_WIDTH/2);		ycentre=(100*sin(angle*(3.141/180)))+(SCREEN_HEIGHT/2);		green=63;		tempblue=tempred=31;		// draw green section of each coloured circle		for (theta=firsttheta+60; theta>firsttheta-1; theta--)		{			colour=RGB16(0, green, 0);				for (r=-radius; r<radius+1; r++)				{				x=(int) ((r*cos((3.141/180)*theta)) + xcentre);				y=(int) ((r*sin((3.141/180)*theta)) + ycentre);				buffer[y*lPitch + x]=colour;				}			// darken green by 1 step every degree			green=green-1;		}		// draw red section of each coloured circle		for (theta=firsttheta+180; theta>(firsttheta+120)-1; theta--)		{			colour=RGB16(red, 0, 0);				for (r=-radius; r<radius+1; r++)				{				x=(int) ((r*cos((3.141/180)*theta)) + xcentre);				y=(int) ((r*sin((3.141/180)*theta)) + ycentre);				buffer[y*lPitch + x]=colour;			}			// darken red by 1 step every 2 degrees			tempred=tempred-0.5;			red=(int)tempred;		}		// draw blue section of each coloured circle		for (theta=firsttheta+300; theta>(firsttheta+240)-1; theta--)		{			colour=RGB16(0, 0, blue);				for (r=-radius; r<radius+1; r++)				{				x=(int) ((r*cos((3.141/180)*theta)) + xcentre);				y=(int) ((r*sin((3.141/180)*theta)) + ycentre);				buffer[y*lPitch + x]=colour;				}            // darken blue by 1 step every 2 degrees			tempblue=tempblue-0.5;			blue=int(tempblue);		}	}			firsttheta++;   // rotate circles clockwise	bigtheta--;     // rotate entire thing anti-clockwise	if (radius>50) flag=1; // maximum radius for each circle, set flag to begin			       // radius decrease		if (flag==0)	radius++;	else	radius--;	if (radius<1)          // minimum radius for each circle, set radius to 1 and	{		       // set flag to begin radius increase		radius=1;		flag=0;	}		// unlock the surface again    G.lpDDSBack->Unlock(NULL);     // flip backbuffer to primary    G.lpDDSPrimary->Flip(NULL, 0);}

Edited by - mirrorman on June 14, 2001 4:19:28 PM

Edited by - mirrorman on June 14, 2001 4:24:26 PM

FragLegs

122

June 19, 2001 01:05 PM

More fractal fun: this time with the Mandelbrot set.

NOTE: This code requires a SCREEN_BITDEPTH of 8,
and it only looks good if you load a palette that is
like a gradient.

   #define OUTER_BOUND (double)1000.0 void Game_Main(){	static int xLoc = 0;	static int yLoc = 0;	static double cx = -2.5;	static double cy = 1.5;	double zx = 0.0;	double zy = 0.0;	// so it doesn't try to keep calculating	if(yLoc > SCREEN_HEIGHT) return;	for(int i = 0; i < 256; i++)	{		double oldZX = zx;		zx = (zx*zx) - (zy*zy) + cx;		zy = (2*oldZX*zy) + cy;		if( (sqrt( zx*zx + zy*zy )) > OUTER_BOUND)			break;	}	DDSURFACEDESC2 ddsd;	UCHAR *buffer; 	long lPitch;  	// Prepare a DDSURFACEDESC2 structure for Lock() 	ZeroMemory(&ddsd, sizeof(ddsd));	ddsd.dwSize = sizeof(ddsd);	// Lock the backbuffer surface	G.lpDDSPrimary->Lock(NULL, &ddsd,				 DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);  	// Get the surface pointer and the memory pitch (in WORDs)	buffer = (UCHAR *)ddsd.lpSurface;	lPitch = ddsd.lPitch;	// Draw onto the display 	buffer[yLoc*lPitch + xLoc] = i;		  	// Unlock the surface 	G.lpDDSPrimary->Unlock(NULL);		xLoc++;	if(xLoc > SCREEN_WIDTH)	{		xLoc = 0;		cx = -2.5;		yLoc++;		cy -= (double)3/SCREEN_HEIGHT;	}	else	{		cx += (double)4/SCREEN_WIDTH;	}}

Edited by - FragLegs on June 19, 2001 2:09:56 PM

simulator

122

July 23, 2001 02:44 AM

Hey- well I also got this working using directx3 on win nt.... was more difficult this time- had to use directdrawsurface2- because the lock funtion isnt in the first- that was easy enough- but I had to do a query interface- which I have no idea why

hRet = G.lpDD->CreateSurface(&ddsd, &G.lpDDSPrimary1, NULL);
hRet = G.lpDDSPrimary1->QueryInterface(IID_IDirectDrawSurface2, (LPVOID *)&G.lpDDSPrimary);

why is this??? why can''t i just use the 2nd implementiation directly????

simulator

122

August 01, 2001 02:12 AM

Hey All

Well here''s my assignment, hehe (how far behind the class am I haha????). Its inspired by the "Symphony of Lights" going on here right now- its an annual international fireworks contest held ever summer in Engish Bay Vancouver. It has noise, diagonal lines, a breast stroke thingee going from (0,0) to (640,480), waves and pulsating bursts (well-not really the last thing). LOL,it all looks kindof weird and the pyrotechnicians would laugh but I''m still proud of it!! And also- please- don''t laugh at my programming hehe.

2 things bugging me:
1)Diagonal lines- how to get rid of the dashed effect at certian angles?????? Is this a result of converting to an integer grid???
2)Random Noise: I ended up having to get both a random x pixel and a random y pixel. Why doesn''t
rpStars=(rand()%100)*tp/100;
buffer[rpStars] = RGB16(31,63,31)
work??????? Can''t figure it out.

Id be curious to know how this runs on a faster computer than mine... no timers in the program.

Thanx and if you look at it, get ready for a good laugh hahaha!!

************************************************************

void Game_Main(){

DDSURFACEDESC ddsd;
WORD *buffer;
long lPitch;

// Prepare a DDSURFACEDESC structure for Lock()
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
G.lpDDSBack->Lock(NULL, &ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);
// Get the surface pointer and the memory pitch (in WORDs) (bytes / 2 = WORDs)
buffer = (WORD *)ddsd.lpSurface;
lPitch = ddsd.lPitch / 2;

const long int tp=lPitch*SCREEN_HEIGHT + SCREEN_WIDTH;
const long int cp=tp/2;
static WORD color, color2;
int x, y,z;
const double mypi=3.14159265358;

// basic background
const WORD color_background=RGB16(0,0,0);
for (y = 0; y < SCREEN_HEIGHT; y++){
for (x = 0; x < SCREEN_WIDTH; x++){
buffer[y * lPitch + x] = color_background;
}}

//bug************************************************************
const int lBug=50, hBug=5, dyBug=40, sBug=15;
int xBug,yBug;
static int phaseBug=1, countBug;
const WORD color_bug=RGB16(20,20,20);
const WORD color_bug2=RGB16(31,63,31);
static long int pixelBug=dyBug*lPitch+lBug;
static int yPrevious, yCurrent;
countBug++;
if (countBug>15){
countBug=0;
phaseBug=!phaseBug;
}
pixelBug +=sBug;
yCurrent=pixelBug/lPitch;
if (yCurrent>yPrevious) {
yCurrent +=dyBug;
pixelBug=pixelBug+dyBug*lPitch;
}
yPrevious=yCurrent;
if ((pixelBug+2*hBug*lPitch+2*lBug)>=tp) {
pixelBug=dyBug*lPitch+lBug;
yCurrent=0;
}
for (xBug=-lBug*phaseBug/2;xBug<(lBug+lBug*phaseBug/2);xBug++){
if (yCurrent==(pixelBug+xBug)/lPitch){
for (yBug=-hBug;yBug buffer[pixelBug+xBug+ yBug*lPitch] = color_bug;
}
}
}
if (phaseBug==0){
for (xBug=0;xBug if (yCurrent==(pixelBug+xBug)/lPitch){
for (yBug=-2*hBug;yBug<-hBug;yBug++){
buffer[pixelBug+xBug+ yBug*lPitch] = color_bug;
}
for (yBug=2*hBug;yBug buffer[pixelBug+xBug+ yBug*lPitch] = color_bug;
}
}
}
}

//diagonals*******************************************************
const WORD cTrail=RGB16(31,63,31);
const WORD cTip=RGB16(31,0,0);
const int szTip=4;
static int rDiagonal;
rDiagonal +=4;
int wTip, hTip;
double rad, theta0=0,fDiag;
const double dtheta=3.14159265358/6.0;
double ymax, xmax;
int rCurrent;

for (fDiag=1.0;fDiag>0.01; fDiag -=0.33){

rCurrent=(int)(fDiag*rDiagonal);
for (rad=theta0;rad<=theta0+3.14159265358;rad +=dtheta){
ymax=rCurrent*sin(rad);
xmax=rCurrent*cos(rad);
for (y=0;y<(long int)ymax;y++){
x=(long int)xmax*y/(long int)ymax;
buffer[cp+y * lPitch + x ] = cTrail;
buffer[cp-y * lPitch + x ] = cTrail;
}
if (y!=0){
for (hTip=-szTip;hTip<=szTip; hTip++){
for (wTip=-szTip;wTip<=szTip; wTip++){
buffer[cp+(y+hTip)* lPitch + x+wTip ] = cTip;
buffer[cp-(y+hTip)* lPitch + x+wTip ] = cTip;
}}
}
}
for (x=-rCurrent;x<=rCurrent;x++){
buffer[cp+ x ] = cTrail;
}
for (hTip=-szTip;hTip<=szTip; hTip++){
for (wTip=-szTip;wTip<=szTip; wTip++){
buffer[cp+(hTip*lPitch)+rCurrent+wTip ] = cTip;
buffer[cp-(hTip*lPitch)-rCurrent+wTip ] = cTip;
}}

theta0 +=0.314159265358;

}
if (rDiagonal>SCREEN_HEIGHT/2-10) rDiagonal=0;

//Noise*******************************************************
long int iPixel;
const long int nPixels=tp/100;
srand( (unsigned)timeGetTime() );
for (iPixel=0;iPixel<=nPixels;iPixel++){
x=rand()%SCREEN_WIDTH;
y=rand()%SCREEN_HEIGHT;
buffer[y*lPitch+x] = RGB16(31,63,31);
//I don''t know why, but the foloowing produced constant diagonal lines:
//I''d prefer to use it: needs only one rand() call versus 2
//rpStars=(rand()%100)*tp/100;
//buffer[rpStars] = RGB16(31,63,31);
}

//random circle*****************************************************
int rCircle, ymaxCircle;
long int pixelCircle;
static int rp1, kCircle;
static WORD color_circle;
const int kCircleMax=50;
kCircle +=2;
if (kCircle==2) rp1=tp*(rand()%100)/100;
for (rCircle = 0; rCircle <=kCircle; rCircle++) {
for (x = -rCircle; x <=rCircle; x++) {
ymaxCircle=(long int)sqrt(rCircle*rCircle-x*x);
for (y = -ymaxCircle; y <=ymaxCircle; y++) {
if ( rand()%kCircleMax> 0.95*kCircle){
pixelCircle=rp1+ y* lPitch + x;
if ( (tp>pixelCircle) && (pixelCircle>0) ) {
buffer[pixelCircle] = color_circle;
}
}
}
}
}
if (kCircle>kCircleMax) {
kCircle=0;
color_circle=RGB16(rand()%32, rand()%64, rand()%32);
}

//waves******************************************************
const WORD color_water=RGB16(0,0,31);
const WORD color_boat=RGB16(31,63,0);
const int amp=20, szShip=10;
const int y0wave=SCREEN_HEIGHT-50;
const int waveSpeed=2;
static int x0wave;
int dxShip, dyShip;

y=y0wave+(long int)(amp*cos(x0wave*20*mypi/SCREEN_WIDTH));
for (dyShip=-3*szShip;dyShip<=szShip;dyShip++){
for (dxShip=-szShip;dxShip<=szShip;dxShip++){
buffer[(y+dyShip) * lPitch + x0wave+dxShip]=color_boat;
}}
for (x = x0wave; x <=SCREEN_WIDTH+x0wave; x++) {
y=y0wave+(long int)(amp*cos(x*10*mypi/SCREEN_WIDTH));
buffer[y * lPitch + (x-x0wave)]=color_water;
for (z=y;z buffer[z * lPitch + (x-x0wave)]=color_water;
}
}
x0wave=x0wave+waveSpeed;
if (x0wave>SCREEN_WIDTH) x0wave=0;

// Unlock the surface
G.lpDDSBack->Unlock(NULL);
// Flip the surfaces
G.lpDDSPrimary->Flip(NULL, 0);
}

// GameMain.cpp - End of file

seze8

122

August 24, 2001 10:54 AM

Hi, can someone tell me how to plot pixels? I don''t know if the function is already in directx or if we have to make it ourselves. If we do have to make it ourselves, can someone give me a short example on how?
Thanks

SEZ

-darkcoder8

TomaHawK

122

August 25, 2001 06:52 AM

Teej, thanks a lot. "You rock my world dude."

I have some ''work'' to post, so here is another snow falling ''animation''. On this ''animation'' when the snow hits the ground it stays there, and accumulates until hitting the top screen line, I hope you like it. Also, it has three (3) diferent falling speeds, trying to give an idea of depth.

Put these defines on top of GameMain.cpp file
#define SNOW_FLAKES 250
#define MAX_SPEED 3
#define START_SNOW_HEIGHT 2

Replace your Game_Main() function with these one
void Game_Main()
{
DDSURFACEDESC2 ddsd;
WORD *buffer;
long lPitch;

struct SnowFlake
{
int pos_x;
int pos_y;
int fall_speed;
};

// Prepare a DDSURFACEDESC2 structure for Lock()
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);

EraseBackground();

// Lock the backbuffer surface
G.lpDDSBack->Lock( NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);

// Get the surface pointer and the memory pitch (in WORDs)
buffer = (WORD *)ddsd.lpSurface;
lPitch = ddsd.lPitch / 2;

static SnowFlake falling_snow[SNOW_FLAKES];
static int ground_snow[SCREEN_WIDTH];
static bool first = true;

//run only once, for initializing the variables
if(first)
{
// Init the array of flakes with their current position and falling speed
for(int i = 0; i < SNOW_FLAKES ; i++)
{
falling_snow.pos_x = rand()%SCREEN_WIDTH;
falling_snow.pos_y = rand()%SCREEN_HEIGHT; falling_snow.fall_speed = 1 + rand()%MAX_SPEED; } // Init the array that keeps track of the height of the snow on the floor for(int j = 0 ; j < SCREEN_WIDTH ; j++) ground_snow[j] = SCREEN_HEIGHT - START_SNOW_HEIGHT; first = false; } // paints falling snow flakes and updates their positions. for(int i = 0 ; i < SNOW_FLAKES ; i++) { buffer[falling_snow.pos_y * lPitch + falling_snow.pos_x] = RGB16(31,63,31); falling_snow.pos_y += falling_snow.fall_speed; // creates new snow flake if one hit the ground if(falling_snow.pos_y > ground_snow[falling_snow.pos_x]) { ground_snow[falling_snow.pos_x]–; if(ground_snow[falling_snow.pos_x] < 0) ground_snow[falling_snow.pos_x] = 0; falling_snow.pos_y = 0; falling_snow.pos_x = rand()%SCREEN_WIDTH; falling_snow.fall_speed = 1 + rand()%MAX_SPEED; } } // paints snow on the ground for(int k = 0 ; k < SCREEN_WIDTH ; k++) for(int l = ground_snow[k] ; l < SCREEN_HEIGHT ; l++) buffer[l * lPitch + k] = RGB16(31,63,31); // Unlock the surface G.lpDDSBack->Unlock(NULL); // Flip the surfaces G.lpDDSPrimary->Flip(NULL, 0); } That''s if I wish you have no problem compiling that, I''m been having not much luck compiling others work <img src="sad.gif" width=15 height=15 align=middle> some starnge compile errors, and somewhat strange for statements incomplete (!?!?!?), I just hope you don''t find nothing like that here. I was almost forgetting… How can I draw the sin function? I''ve tried the following code for(int i = 0; i < SCREEN_WIDTH ; i++) { // trying to paint the sin function on the center of the screen with an amplitude of 30 pixels buffer[(int)(sin(i) * 30 + SCREEN_HEIGHT/2)* lPitch + i] = RGB16(31,63,31); } but it apparently it''s draw around 4 sin functions at the same time(!?!?!?). What am I doing wrong? (I''ve included math.h, of course) Thanks in advance, TomaHawK

Do I really need one? :)

FragLegs

122

August 26, 2001 10:33 AM

TomaHawk:

Try this for your sin function:

for(int i = 0; i < SCREEN_WIDTH ; i++)
{
// trying to paint the sin function on the center of the screen with an amplitude of 30 pixels
buffer[(int)(sin((2*3.1415)(i/SCREEN_WIDTH)) * 30 + SCREEN_HEIGHT/2)* lPitch + i] = RGB16(31,63,31);
}

I hope that helps. I haven''t tested it, though, so who knows?

FragLegs

TomaHawK

122

August 26, 2001 02:44 PM

I managed to find how sin function works, but thanks anyway FragLegs. sin() takes as parameter radians ans I was giving degrees that''s why it was not working, I should pass it something like this : angle * 2 * PI / 360 (converts angle from degrees to radians)

So... with the sin function working, I did another version of the snow falling... Snow now moves with as the sin function.

Anyone interested click HERE to download the GameMain.cpp

Thanks,
TomaHawK

P.S. Now with the sin there are some bugs when snow hitting the ground

Do I really need one? :)

Anonymous

December 29, 2001 04:46 PM

hi there, i have a mystic problem with the pixel manipulation. i just paste in the code of teej in the game_main, the result is a white picture (yeah) but my computer freeze (so hang up). it''s the same with the examples made by the others. they go for 1-3 seconds and then system freeze. i have winxp/directx8 and a geforce3 ti500.
where is the fault?! is the geforce3 ti500 (5,6,5)? somebody else the problem?
hopefull mrxst

04.03 - Pixel Manipulation

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

04.03 - Pixel Manipulation

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines