BIPLAN | Byte coded Interpreted Programming language

you have called CreateCompatibleBitmap function before settiing height and width . your height and width are 0 , so your hbmp will never contain data.

const BI_RGB and Const DIB_RGB_COLORS are not declared

you are ignoring alpha channel in 32 bit color and it is better to use byte array in capturing individual R G B color

Try Edited Code shown below

Structure packing and alignment padding are implementation defined, and byte order is platform defined.

If the byte order for your platform is the same as that defined for BMP (little-endian) then you can use whatever compiler extensions your toolchain supports for structure packing. For example in GCC:

buffer_height and buffer_width are both 0 until a WM_SIZE message is received, so the pixel loop won't try to access buffer_memory until a bitmap is actually created. However, you are not validating that VirtualAlloc() is successful.

0xC0000005 is an Access Violation. Somewhere you are accessing invalid memory. You need to debug your code to find it.

Also, you are drawing on the window from inside your message loop. You should be drawing on it only from inside of a WM_PAINT message handler instead.

Try this instead:

You have problem with the remainder from the ratio devision in the following line for(int a=0;a<=ratioX;a++)

Though the ratioX is a float, the loop will work until the integer part of the number. Whatever remained from the difference of ratioX - (int)ratioX.

Solution is same as we had solved the leap year problem. We accumulate the extra 6h of the year's duration and we add one day on each 4 years. In a same manner, you need to accumulate this difference and add an extra pixel each time the accumulator passes 1 (and deduct 1 from the accumulator).

This will leave you with a problem with the last pixel. Sometimes, your line will be one pixel short, even with all of the compensations. So you might set the last pixel on the targetX,targetY explicitly.

Here is the example based on the code above:

You need to allocate a suitably-sized BITMAPINFO and cast it to BITMAPINFOHEADER* (or just use its bmiHeader member). Not allocate a BITMAPINFOHEADER and cast it to BITMAPINFO*. A BITMAPINFO consists of a BITMAPINFOHEADER followed by an array of 0 or more RGBQUAD elements for a color table. A BITMAPINFOHEADER itself does not contain the color table, but it does describe the color table that follows it.

Per the GetDIBits() documentation:

If the requested format for the DIB matches its internal format, the RGB values for the bitmap are copied. If the requested format doesn't match the internal format, a color table is synthesized...

If the lpvBits parameter is a valid pointer, the first six members of the BITMAPINFOHEADER structure must be initialized to specify the size and format of the DIB. The scan lines must be aligned on a DWORD except for RLE compressed bitmaps.

A bottom-up DIB is specified by setting the height to a positive number, while a top-down DIB is specified by setting the height to a negative number. The bitmap color table will be appended to the BITMAPINFO structure.

If lpvBits is NULL, GetDIBits examines the first member of the first structure pointed to by lpbi. This member must specify the size, in bytes, of a BITMAPCOREHEADER or a BITMAPINFOHEADER structure. The function uses the specified size to determine how the remaining members should be initialized.

If lpvBits is NULL and the bit count member of BITMAPINFO is initialized to zero, GetDIBits fills in a BITMAPINFOHEADER structure or BITMAPCOREHEADER without the color table. This technique can be used to query bitmap attributes.

So, in your case, you are setting lpvBits to NULL, but the BITMAPINFOHEADER::biBitCount field is not 0, so GetDIBits() will try to fill in the color table of the provided BITMAPINFO, but you are not allocating any memory to receive that color table. So GetDIBits() ends up corrupting the memory that follows the BITMAPINFOHEADER.

Your WM_SIZE handler is missing a break statement:

Based on the information you provide it's impossible to say for sure, but here is my best guess:

1. Change the signature of your render_backround() to this: void render_backround(HWND hwnd)

2. Remove the line HWND hwnd; from that function

3. In your second .cpp file replace this line render_backround(); with this: render_backround(hwnd);

4. As written, the render_backround(hwnd); is unreachable. You are missing a case WM_PAINT: line in front of it.

I think this is the way to go, because your function windows_callback is later on registered as a callback (as the naming suggests). That means Windows will be responsible for passing it sane parameters. Among those parameters there happens to be a HWND, just what you need. So, if the set up callback mechanism works at all, we can expect that this HWND instance inside of the callback will be the one to work with. So you only need to use that very same instance in your render_backround function, hence you have to pass it there rather than have it declare its own one (which leeds to your error).

“As if the bitmap itself has a black background.”

Because your background is set to:

The line: buffer_width = rect.left - rect.right;

=> buffer_width = rect.right- rect.left ;

You should draw in the WM_PAINT message,