reading rgba-values of an image and input handling

Author

Message

Hierro

16

Years of Service

User Offline

Joined: 22nd Mar 2008

Location:

Posted: 1st Apr 2008 17:03

Link

heyoha,

i'm currently developing a 2d-game using dark gdk and box2d and need two things i wasn't able to find in the documentation:

1) i load an image and want to get its rgba-values on a certain position, but unfortunately wasn't able to find a function handling this?

2) with dbKeyState, dbLeftKey, dbRightKey,... i can find out if a key is currently pressed. that's nice but not exactly what i need: i want to handle only button-down events (when a button is pressed i only want to do certain things once and not all the time when the button is pressed...) and not "button pressed"-events. how can i do this using dark gdk?

greetings and thanks in advance!

Back to top

Profile PM

ErDa

16

Years of Service

User Offline

Joined: 17th Feb 2008

Location:

Posted: 1st Apr 2008 19:53

Link

Your first question is similar to the one i just posted, so I can't help you with that. For the second however:

+ Code Snippet

int i = 0;
while ( LoopGDK () )
   if ( dbRightKey() )
   {
      if ( i = 0 )
      {
         /*Insert any action you want to occur once after key is pressed*/
         i = 1;
      }
   }
   if ( !(dbRightKey()) ) /* "!" means "not", if not (dbRightKey) is pressed */
   {
      i = 0;
   }
}

This should work nicely i think. What it does is that it executes the commands if 1 is 0, then changes i to 1 until dbRightKey is released.

Back to top

Profile PM

Lilith

16

Years of Service

User Offline

Joined: 12th Feb 2008

Location: Dallas, TX

Posted: 1st Apr 2008 20:15 Edited at: 1st Apr 2008 20:16

Link

I can't address the image question at the moment, though I wish I could. But with regards to the keyboard you might have to do the same thing that I did with the mouse, which behaves the same way. I have to keep a variable (bool mouseIsClicked) and react differently depending on whether the mouse was previously clicked. Below is the code I use.

+ Code Snippet

		

if (mouseIsClicked && (dbMouseClick() == 0)) mouseIsClicked = false;	// need to know when button is released
if (!mouseIsClicked && dbMouseClick() == 1) {
  bg.Click(point (dbMouseX(), dbMouseY()));
  mouseIsClicked = true;
}

The downside is that you pretty much have to constantly check the mouse state in order to know when the thing's been released.

Eventually what I'm probably going to have to do is create a Mouse class that tracks the ups and downs of the available mouse buttons. And, I suspect, the same is going to need to be done for the keyboard.

Lilith, Night Butterfly
I'm not a programmer but I play one in the office

Back to top

Profile PM

nodapro

16

Years of Service

User Offline

Joined: 14th Mar 2008

Location:

Posted: 1st Apr 2008 20:34

Link

For the first question:

The function
int dbPoint ( int iX, int iY );
will get the color value from the current bitmap, and
int dbRGBR ( int iRed );
int dbRGBG ( int iGreen );
int dbRGBB ( int iBlue );
can extract the RGB. Don't know how to get the Alpha though.

For the second question:

If you want to do something only ONCE if key/mouse is pressed, see if the following method to avoid repeated reading helps:

http://forum.thegamecreators.com/?m=forum_view&t=126468&b=22

Back to top

Profile PM

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 1st Apr 2008 23:17

Link

Nice - but the image thing... its not so bad.

MAKE MEMBLOCK from IMAGE

Now you have your image in a memblock.

First 4 bytes are a DWORD - Width of image:
Psuedo - MyImageWidth = Read Memblock DWORD Position 0

Next 4 are Height:
Psuedo - MyImageHeight = Read Memblock DWORD Position 4

Next 4 are Bit depth - usually 32, and frankly - that's all I've seen or used so far - so this post only referes to 32bit depth format.

Psuedo - MyImageBitDepth = Read Memblock DWORD Position 8

From Position 12 on up to memblock size are DWORDS also. Each one represents a Pixel. So each pixel is represented in four bytes. One byte is the RED, the another BLUE, Another Green, and Another the Alpha (Zero=transparent, >ZERO how much it should count when being drawn)

The exact order in mem I forget - meaning ... in a given pixel, I forget what comes first of the RGBA... what I USUALLY do - is something along the lines of:

(Snippets from my oop lib's JGC_PIXELGRID class.)
// To get the Memposition in a memblock that was made from an image:

+ Code Snippet

//----------------------------------------------------------------------------
inline DWORD JGC_PIXELGRID::MemPos(int p_X, int p_Y){
//----------------------------------------------------------------------------
  // 12 is the header size - BPP or Bytes Per Pixel Defaults to 4.
  DWORD dwOffset=(  (p_X + (p_Y*pvt_Width)) * pvt_BytesPerPixel)+12;
  return dwOffset;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
inline DWORD JGC_PIXELGRID::MemPos(int p_X, int p_Y, int p_Width){
//----------------------------------------------------------------------------
  // 12 is the header size - BPP or Bytes Per Pixel Defaults to 4.
  DWORD dwOffset=(  (p_X + (p_Y*p_Width)) * pvt_BytesPerPixel)+12;
  return dwOffset;
};
//----------------------------------------------------------------------------

Here - to access indivudla colors etc using above code for plotting the mem location:

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Red_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+2,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Green_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+1,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Blue_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Alpha_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+3,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, DWORD p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=this->MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,(p_Value & 0x000f));
    MB->Byte_Set(mp+1,(p_Value & 0x00f0));
    MB->Byte_Set(mp+2,(p_Value & 0x0f00));
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, int p_R, int p_G, int p_B){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,p_B);
    MB->Byte_Set(mp+1,p_G);
    MB->Byte_Set(mp+2,p_R);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, JGC_RGBA *p_JGC_RGBA){
//----------------------------------------------------------------------------
  this->RGB_Set(p_X, p_Y, p_JGC_RGBA->RGB_Get());  
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, int p_R, int p_G, int p_B, int p_A){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,p_B);
    MB->Byte_Set(mp+1,p_G);
    MB->Byte_Set(mp+2,p_R);
    MB->Byte_Set(mp+3,p_A);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, DWORD p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Dword_Set(mp,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, JGC_RGBA *p_JGC_RGBA){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Dword_Set(mp,p_JGC_RGBA->RGBA_Get());
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Red_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+2);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Green_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+1);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Blue_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+0);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Alpha_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+3);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
DWORD JGC_PIXELGRID::RGB_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Dword_Get(mp) & (DWORD)0x00FFFFFF;
  } else {
    return (DWORD)0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
DWORD JGC_PIXELGRID::RGBA_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Dword_Get(mp);
  } else {
    return (DWORD)0;
  };
};
//----------------------------------------------------------------------------

+ Code Snippet

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Red_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+2,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Green_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+1,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Blue_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::Alpha_Set(int p_X, int p_Y, int p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+3,p_Value);
  };
};
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, DWORD p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=this->MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,(p_Value & 0x000f));
    MB->Byte_Set(mp+1,(p_Value & 0x00f0));
    MB->Byte_Set(mp+2,(p_Value & 0x0f00));
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, int p_R, int p_G, int p_B){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,p_B);
    MB->Byte_Set(mp+1,p_G);
    MB->Byte_Set(mp+2,p_R);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGB_Set(int p_X, int p_Y, JGC_RGBA *p_JGC_RGBA){
//----------------------------------------------------------------------------
  this->RGB_Set(p_X, p_Y, p_JGC_RGBA->RGB_Get());  
};
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, int p_R, int p_G, int p_B, int p_A){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Byte_Set(mp+0,p_B);
    MB->Byte_Set(mp+1,p_G);
    MB->Byte_Set(mp+2,p_R);
    MB->Byte_Set(mp+3,p_A);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, DWORD p_Value){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Dword_Set(mp,p_Value);
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_PIXELGRID::RGBA_Set(int p_X, int p_Y, JGC_RGBA *p_JGC_RGBA){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    MB->Dword_Set(mp,p_JGC_RGBA->RGBA_Get());
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Red_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+2);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Green_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+1);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Blue_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+0);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JGC_PIXELGRID::Alpha_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Byte_Get(mp+3);
  }else{
    return 0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
DWORD JGC_PIXELGRID::RGB_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Dword_Get(mp) & (DWORD)0x00FFFFFF;
  } else {
    return (DWORD)0;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
DWORD JGC_PIXELGRID::RGBA_Get(int p_X, int p_Y){
//----------------------------------------------------------------------------
  if(p_X<this->pvt_Width && p_Y<pvt_Height && p_X>=0 && p_Y>=0){
    int mp=MemPos(p_X,p_Y);
    return MB->Dword_Get(mp);
  } else {
    return (DWORD)0;
  };
};
//----------------------------------------------------------------------------

Hope that's helpful.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Lilith

16

Years of Service

User Offline

Joined: 12th Feb 2008

Location: Dallas, TX

Posted: 2nd Apr 2008 00:19

Link

IF I knew what I was doing it might be possible to access the data directly. However, I'm not sure I want to poke around in what may be the DirectX buffers. In the DarkSDKImage.h file there's a prototype for a function that shows the following:

LPDIRECT3DTEXTURE9 dbGetImagePointer ( int iID );

in addition to

void dbGetImageData ( int iID, DWORD* dwWidth, DWORD* dwHeight, DWORD* dwDepth, LPSTR* pData, DWORD* dwDataSize, bool bLockData );
void dbSetImageData ( int iID, DWORD dwWidth, DWORD dwHeight, DWORD dwDepth, LPSTR pData, DWORD dwDataSize );

along with other prototypes that aren't mentioned in the docs. Some look relatively benign while others I wouldn't touch without having a more detailed understanding of DirectX.

Lilith, Night Butterfly
I'm not a programmer but I play one in the office

Back to top

Profile PM

Hierro

16

Years of Service

User Offline

Joined: 22nd Mar 2008

Location:

Posted: 2nd Apr 2008 14:40

Link

thank you for your replies!

got the input and the rbga-reading working (thanks to jason for the memblock-insights!

).

here's a simple solution for my input problem:

+ Code Snippet

void Game::HandleInput()
{
	if(m_pressedKey == dbScanCode())
		return;

	m_pressedKey = dbScanCode();

	if(m_pressedKey == 203)
		m_level->MoveDot(Level::Left);
	else if(m_pressedKey == 205)
		m_level->MoveDot(Level::Right);
	else if(m_pressedKey == 200)
		m_level->MoveDot(Level::Up);
	else if(m_pressedKey == 208)
		m_level->MoveDot(Level::Down);
}

and here's my code for calculating the size of an image regarding to its alpha-channel:

+ Code Snippet

if(calculateSize)
	{
		dbMakeMemblockFromImage(1, imageNumber);
		
		DWORD imageWidth = dbMemblockDword(1, 0);
		DWORD imageHeight = dbMemblockDword(1, 4);
		DWORD imageBitDepth = dbMemblockDword(1, 8);

		int minX = imageWidth + 1;
		int maxX = -1;	
		int minY = imageHeight + 1;
		int maxY = -1;

		for(int x = 1; x < imageWidth; x++)
			for(int y = 1; y < imageHeight; y++)
			{
				int blue = dbMemblockByte(1, 12 + (x + y * imageWidth) * 4);
				int green = dbMemblockByte(1, 13 + (x + y * imageWidth) * 4);
				int red =dbMemblockByte(1, 14 + (x + y * imageWidth) * 4);
				int alpha =dbMemblockByte(1, 15 + (x + y * imageWidth) * 4);

				if(alpha > 200)
				{
					if(x < minX)
						minX = x;
					if(x > maxX)
						maxX = x;
					if(y < minY)
						minY = y;
					if(y > maxY)
						maxY = y;
				}
			}

		pictureSize = b2Vec2(maxX - minX, maxY - minY);
		dbDeleteMemblock(1);
	}

Back to top

Profile PM

nodapro

16

Years of Service

User Offline

Joined: 14th Mar 2008

Location:

Posted: 2nd Apr 2008 16:52

Link

I have a question:

After dbMakeMemblockFromImage, can the reading/writing be done faster than calling the functions such as dbPoint?

I recall a post that says it is very slow to read from bitmaps (the method I used), but I never compared it with memblocks.

Maybe jason has some idea?

Thanks.

Back to top

Profile PM

Lilith

16

Years of Service

User Offline

Joined: 12th Feb 2008

Location: Dallas, TX

Posted: 2nd Apr 2008 17:32

Link

Comparing the two operations might be difficult since benchmarking isn't that easy to do in a multi-tasking environment. I'm not even sure why bitmap operations would be slower. I assume that they're in memory too and just as accessible. But there are quite a number of things I don't know that could explain why bitmaps would be slower. Maybe the best way to test is to see what the maximum FPS rate is using both methods.

Having said that, I will say that I'm a firm believer in pointers and what advantage incrementing a pointer has over recalculating a memory location for each operation. If a large portion of my function requires traversing a row then a pointer is the way to go. And using pointer arithmetic to calculate the beginning of the next row should be a bit faster than recalculating the beginning portion of a row with (row*width + column). dbDot and dbPoint make things easier for me and I'll use them until I get my program well enough along that I can take time to experiment with some lower level functionality of my own.

I've got a few concerns about using memblocks in that they still need to be copied into images to be used. If you take the copy time and the time it takes to be written to the screen is it any better? Naturally that's all tied up in what you're doing with the graphic and how often it needs to be re-displayed. The current portion of the program I'm working on isn't really too dependent on speed since it's only for designing my screen levels. When it comes time to play the game I could do a one-off copy of the bitmap I generate to an image and not have to change the image for most of the level.

Lilith, Night Butterfly
I'm not a programmer but I play one in the office

Back to top

Profile PM

nodapro

16

Years of Service

User Offline

Joined: 14th Mar 2008

Location:

Posted: 2nd Apr 2008 17:42

Link

Thanks for the explanation, Lilith. I think I need to do the same thing when speed becomes important.

Back to top

Profile PM

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 3rd Apr 2008 04:25

Link

Agreed. Lilith's explaination is true to form for absolute speed. As she mentioned in another post - something I should ask David W about, is that we have a DarkGDK function that returns a pointer to the directx structure an image is REALLY at.

accessing this directly would be faster than the image to memblock back to image technique - not to mention the math to calc each pixel's position versus doing pointer math to get around using incrementing etc.

I think its safe to say we know it depends on what you're doing and whether or not the routine you're working on needs the speed or not.

I do SOMETIMES go for the generally accepted "mainstream best practice" for software design over my "urge to make everything a rocket performer". That "mainstream best practice" that's generally accepted is "Make it work first, then go back and hone the the bottlenecks".

For example - so far, I've only really used my image/memblock manipulations for loading and "pasting" fonts into images.. for text on image sorta stuff. So speed hasn't been a prioirty for this image manipulation thing YET.

I also believe that each task often needs its own optimization - especially with graphics. Plotting a dot? Calc the location, making a BOX Fill? Do the pointer incrementing technique. etc.

I think one of us needs to just eventually dig in and figure out how directx handles this data. My Fear is that the data MIGHT have many different formats depending on bit depth and POSSIBLY the nature of the hardware - (some sort of hardware optimization that requires a bytes to be in a special ... not so intuitive format)

I dunno. I think this is cool stuff though.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Lilith

16

Years of Service

User Offline

Joined: 12th Feb 2008

Location: Dallas, TX

Posted: 3rd Apr 2008 06:28

Link

Having re-read my post I'm thinking I understand why bitmaps are slower than images. This is strictly a guess but I'd say that the image is stored in video memory since it can be used as a texture and much of that is handled by the DirectX functionality. They're closer to the video hardware.

If, as you conjecture, the handling of images is dependent on many circumstances, including hardware brand and color depth, then I'd be inclined to stay away. I might think I'm handling it okay but it might not run under a specific configuration that I can't imagine or anticipate. Getting that close to the hardware scares me spitless unless it's extremely simple, consistent and obvious.

Lilith, Night Butterfly
I'm not a programmer but I play one in the office

Back to top

Profile PM

Sephnroth

21

Years of Service

User Offline

Joined: 10th Oct 2002

Location: United Kingdom

Posted: 28th May 2008 00:56

Link

(uber late reply

)
The main reason things like dbPoint() etc are slow are because the commands return a single point, just one and chances are you want many. However to access the surface it must be locked and then unlocked and thats slow - if you are going to do alot of reading from a surface you should try to just lock once, do all your reading in one go then unlock

goto this post: http://forum.thegamecreators.com/?m=forum_view&t=122165&b=22 and scroll down until you see my post in the thread. There are several blocks of code I put in there for image editing. One is GPU accelerated which is very fast but might not be what you want because I never did investigate support for reading pixels that way.

But if you look at the bit I put in "just for interest" then thats my software image editing library which accesses all pixel data by hand through pointers to the directx surfaces. Hopefully you can take something from that and make functions to suit your needs

Remember the biggest optimisation is the one that reduces the surface locks and unlocks to as little as possiable - prefably once per frame at most!

DarkSDK/WinAPI Tutorial

Back to top

Profile PM Email

Sorry your browser is not supported!

Dark GDK / reading rgba-values of an image and input handling