Most efficient way to draw a picture pixel by pixel?

[panithadrum]

Errors can lead to some nice and artistic effects

Yes. My first impression was: Wow, it looks like a complex effect. Then I realized it was an error.  

[Xorlium]

For example, if x = 2, y =17 and x=17, y =2, you'd be getting always the same colour, but you clearly don't want that.

No, it's right. I wanted to see if I can get everything to be painted white before I make the next big step (adding the array). That's why I wrote

(stupid nonsense example of what I tried follows)

But I even failed this simple test.  :?

No, I know you wanted everything white, what I'm saying is that x*y doesn't uniquely identify one pixel, so it can't be right. Do what I said and then Laurent repeated: 4(800*y+x) and then that plus 1, 2, and 3. Notice that uniquely identifies each pixel, in the sense that if you have a number n = 800*y+x, there are no two different x and y that give that n.

Xorlium

[AlexM]

hey I've been trying to get this to work and I've been getting "std::bad_alloc at memory location" errors at runtime when populating the array.

I tried pasting sam's code that outputted the funky array since it at least compiles but I still get the same error on my end.

Here is the my original code (setting up the array in a constructor).

Code: [Select]


ScreenArray::ScreenArray( int width, int height )
{
int arrayLength = width * height;
colorArray = new sf::Uint8[arrayLength * 4];


for (int pos = 1; pos < arrayLength; pos++)
{
colorArray[(pos*4)-1] = 255;
colorArray[(pos*4)-2] = 255;
colorArray[(pos*4)-3] = 255;
colorArray[(pos*4)-4] = 255;

}

}}

[Laurent]

You should use the debugger to see what's happening, and where.

Or at least you should print the value of arrayLength.

Code: [Select]

  for (int pos = 1; pos < arrayLength; pos++)
   {
         colorArray[(pos*4)-1] = 255;
         colorArray[(pos*4)-2] = 255;
         colorArray[(pos*4)-3] = 255;
         colorArray[(pos*4)-4] = 255;
         
   }

This should be:

Code: [Select]

  for (int pos = 0; pos < arrayLength; pos++)
   {
         colorArray[(pos*4)+0] = 255;
         colorArray[(pos*4)+1] = 255;
         colorArray[(pos*4)+2] = 255;
         colorArray[(pos*4)+3] = 255;
   }
Or simply

Code: [Select]

std::fill(colorArray, colorArray + arrayLength + 4, 255);
And use std::vector, not raw arrays

[AlexM]

I was using the debugger, I just wasn't using the debugger enough

Turns out the error was due to a method called right after populating the array, seems the array logic was fine.

One question regarding std::vector. You would recommend using it even when I know I won't be resizing the array?

[Laurent]

You would recommend using it even when I know I won't be resizing the array?

Yes, because:
- you won't have to store the size yourself
- you won't have to manage the memory manually

std::vector is more than a resizable array, it's a generic abstraction of dynamic arrays.

[AlexM]

ok thanks, I do use them when I know I'll be resizing often but I wasn't sure if I should use them in situations like this.

Thanks for the info, I'll make sure I do that in the future

[Nexus]

And if you need static arrays (size known at compile time), you should still abandon raw arrays and use std::tr1::array or boost::array instead. It's worth all the comfortable features like copy semantics, debug assertions or the iterator interface -- with zero overhead in release mode

[AlexM]

Really? awesome.

I've been meaning to check out boost. I'll take a look into it this weekend. From a quick look I see a lot of useful classes there