View difference between Paste ID: ejkj2hvm and 6C2RTMb2

-#ifndef DRAW_H_INCLUDED
+
-#define DRAW_H_INCLUDED
+#include "stdio.h"
 #include "sys/stat.h"//required for setting file permissions
-#include <GL/gl.h>
+#include "fcntl.h"//required for setting create/readwrite/read only etc.
-#include <GL/glext.h>
+#include <cstring>
 #include <stdlib.h>
 #include <stdint.h>
 #include <iostream>
-///OGL texture structs
+using namespace std;
-//textures are the format OGL blits, non editable data -(loaded sprites/images)
+#include "BMP.h" ///// note for other viewers: doesn't have anything other than function prototypes
-struct OGL_Texture{
+
-	protected:
+
-	bool texture_generated;
+void saveBMP(const char *filepath, OGL_Surface *Surface, int bpp, uint8_t compression)
 {
-	public:
+	if (bpp==32 || bpp==4){bpp=24;}//do not support 32bit
-	GLuint Texture_ID;
+	if (bpp==3){bpp=24;}
-	uint32_t w,h;
+	int palettecols =0;// (should be included as function arg)
 	uint32_t imgbytes = (Surface->w*Surface->h*bpp)/8;
-	void gen_texture(uint16_t w, uint16_t h, uint8_t *PixData);
+	int padding = (Surface->w*3)%4;
 	if (padding != 0){padding=4-padding; imgbytes += Surface->h*padding;}
-	OGL_Texture();
+	uint32_t data = 0;
-	~OGL_Texture();
+
-};
+	int file = open(filepath, O_CREAT | O_RDWR, S_IRWXU);
-//surfaces contain editable pixel data, can be cast to textures for blitting -(effects, debug/primitive data draws)
+	if (file < 0 ){perror("ERROR CREATING/OPENING BMP FILE");exit(1);}
-struct OGL_Surface : OGL_Texture{
+	lseek(file, 0, SEEK_SET);
-	uint32_t w,h;
+
-	uint8_t bpp;
+	/// file header (14 bytes)
-	uint8_t *PixData;
+	//BitMap declaraction
 	write(file, "BM", 2);
-	void Create_Surface(uint16_t w,uint16_t h, char bpp);
+	//complete file size in bytes. 14+40 + num bytes for image data  + (palette)
-	void Clear_Surface(uint8_t r, uint8_t g, uint8_t b, uint8_t a=255);
+	if (bpp>8){data = imgbytes + 54;}
-	void Set_Surface_AlphaKey(uint8_t r, uint8_t g, uint8_t b);
+	else{data = imgbytes + 54 + palettecols*4;}
-	void gen_texture();
+	write(file, &data, 4);
 	//reserved nulls
-	OGL_Surface();
+	data=0;
-	~OGL_Surface();
+	write(file, &data, 4);
-};
+	//offset to actual pixel data (again 14+40) + (palette)
 	if (bpp>8){data=54;}
-OGL_Texture *Texture_Cast(OGL_Surface *Surface);
+	else{data = 54 + palettecols*4;}
 	write(file, &data, 4);
-////////
+
-//BLIT//
+	/// file info (40 bytes)
-////////
+	//size of info data
-enum Image_Options{
+	data=40;
-	IMG_NORM  = 0,
+	write(file, &data, 4);
-	IMG_HFLIP = 1,
+	//image width, height
-	IMG_VFLIP = 2,
+	data=Surface->w;
-	IMG_ADD_BLEND = 3
+	write(file, &data, 4);
-};
+	data=Surface->h;
-void DrawImage(OGL_Texture *Texture, int dx, int dy, float rot=0.0,float scale_x=1.0,float scale_y=1.0,float alpha=1.0,int options=0);
+	write(file, &data, 4);
-void DrawSubImage(OGL_Texture *Texture, int sx, int sy, int sw, int sh, int dx, int dy, float rot=0.0,float scale_x=1.0,float scale_y=1.0,float alpha=1.0,int options=0);
+	//must be set to 1
 	data=1;
-//////////
+	write(file, &data, 2);
-//COLOUR//
+	//bits per pixel (MAX 24!)
-//////////
+	data= min(bpp,24);
-uint32_t make_col(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+	write(file, &data, 2);
-uint32_t make_col(uint8_t r, uint8_t g, uint8_t b);
+	//compression, compression notes: http://netghost.narod.ru/gff/vendspec/micbmp/bmp.txt
 	data=0;
-///////////////////
+	write(file, &data, 4);
-//DRAW PRIMITIVES//
+	//image size in bytes
-///////////////////
+	data=imgbytes;
-bool putpixel(OGL_Surface *Surface, int x, int y, uint32_t col);
+	write(file, &data, 4);
-bool getpixel(OGL_Surface *Surface, int x, int y, uint32_t &col);
+	//x,y pixels per meter (set to 0)
-//
+	data=0;
-void hline(OGL_Surface *Surface, int x, int y, int w, uint32_t col);
+	write(file, &data, 4);
-void vline(OGL_Surface *Surface, int x, int y, int h, uint32_t col);
+	write(file, &data, 4);
-void line(OGL_Surface *Surface, int x1, int y1, int x2, int y2, uint32_t col);
+
-void box(OGL_Surface *Surface, int x, int y, int w, int h, uint32_t col);
+	/// palette (only for 1,4 and 8 bit images, 4 bytes per colour, min 8 bytes)
-void rect(OGL_Surface *Surface, int x, int y, int w, int h, uint32_t col);
+	//colours used (0=autodetect from bpp, for 8bpp or less palette will only use the amount of colours)
-void polyline(OGL_Surface *Surface, unsigned char n, int points[], uint32_t col);
+	write(file, &data, 4);
-void polygon(OGL_Surface *Surface, unsigned char n, int points[], uint32_t col);
+	//important colours (0=all are important)
-void circle(OGL_Surface *Surface, int x0, int y0, int radius, uint32_t col);
+	write(file, &data, 4);
-void circle_fill(OGL_Surface *Surface, int x0, int y0, int radius, uint32_t col);
+	//palette (should be included as function arg)
-//
+	uint32_t *palette = NULL;
 	uint8_t r,g,b;
-#endif // DRAW_H_INCLUDED
+	if (bpp<24){
 		for (uint8_t i = 0; i<palettecols; i++){
 			r=(palette[i]&0x000000FF);
 			g=(palette[i]&0x0000FF00)>>8;
 			b=(palette[i]&0x00FF0000)>>16;
 			write(file, &b, 1);//b
 			write(file, &g, 1);//g
 			write(file, &r, 1);//r
 			write(file, 0, 1);//null
 		}
 	}
 	/// pixeldata
 	uint8_t *buffer =  new uint8_t[imgbytes];
 	memset(buffer, 0, imgbytes);
 	int datawidth = (Surface->w*3)+padding;
 	int pos = 0;
 	int buf_pos = imgbytes-datawidth;
 	for (uint32_t y = 0; y<Surface->h; y++){
 		for (uint32_t x = 0; x<Surface->w; x++){
 			buffer[buf_pos]  = Surface->PixData[pos];
 			buffer[buf_pos+1]= Surface->PixData[pos+1];
 			buffer[buf_pos+2]= Surface->PixData[pos+2];
 			buf_pos+=3;
 			pos+=Surface->bpp;
 		}
 		//return buffer to start of line then up one line
 		buf_pos += padding;
 		buf_pos -= datawidth+datawidth;
 	}
 	write(file, buffer, imgbytes);
 	close(file);
 	delete [] buffer;
 }
 
 void loadBMP(const char *filepath, OGL_Surface *Surface)
 {
 
 	char BMP[3]= {0,0};
 	int dataoffset=0;
 	int imgbytes=0;
 	int compression=0;
 	char bpp= 0;
 	int file = open(filepath, O_RDONLY, S_IRWXU);
 	if (file < 0 ){perror("ERROR LOADING BMP FILE");exit(1);}
 
 	/// file header
 	//BitMap declaraction
 	lseek(file, 0, SEEK_SET);
 	read(file, BMP, 2);
 	if (BMP[0] != 'B' || BMP[1] != 'M'){printf("UNSUPPORTED FILE TYPE (not BMP)");exit(1);}
 	//skip file size, 4
 	//skip reserved nulls, 4
 	//offset to actual pixel data
 	lseek(file, 10, SEEK_SET);
 	read(file, &dataoffset, 4);
 	//skip headersize, 4
 	//width & height
 	lseek(file, 18, SEEK_SET);
 	read(file, &Surface->w, 4);
 	read(file, &Surface->h, 4);
 	//skip "planes", 2
 	//bits per pixel
 	lseek(file, 28, SEEK_SET);
 	read(file, &bpp, 2);
 	//compression
 	read(file, &compression, 4);
 	if (compression != 0){printf("FILE USING UNSUPPORTED COMPRESSION");exit(1);}
 	//size of image data in bytes
 	read(file, &imgbytes, 4);
 	//skip hres, 4
 	//skip vres, 4
 
 	/// palette (only for 1,4 and 8 bit images)
 	uint32_t *palette;
 	if (bpp<24){
 		//colours used
 		lseek(file, 46, SEEK_SET);
 		int palettecols;
 		read(file, &palettecols, 4);
 		//skip important colours, 4
 		if (palettecols != 0){
 			palette = new uint32_t[palettecols];
 			memset(palette, 0, palettecols*4);
 		}
 		for (int i = 0; i<palettecols; i++){
 			read(file, &palette[i], 4);
 		}
 	}
 
 	/// pixeldata
 	lseek(file, dataoffset, SEEK_SET);
 	uint8_t *buffer =  new uint8_t[imgbytes];
 	memset(buffer, 0, imgbytes);
 	read(file, buffer, imgbytes);
 	close(file);
 
 	/// convert data to rgb format
 	if (Surface->PixData != NULL){delete [] Surface->PixData;}
 	Surface->PixData = new uint8_t[Surface->w*Surface->h*Surface->bpp];
 	memset(Surface->PixData, 255, Surface->w*Surface->h*Surface->bpp);
 	int padding = (Surface->w*3)%4;
 	if (padding != 0){padding=4-padding;}
 	int datawidth = (Surface->w*3)+padding;
 	int pos = 0;
 	int buf_pos = imgbytes-datawidth;
 	for (uint32_t y = 0; y<Surface->h; y++){
 		for (uint32_t x = 0; x<Surface->w; x++){
 			Surface->PixData[pos]  = buffer[buf_pos];
 			Surface->PixData[pos+1]= buffer[buf_pos+1];
 			Surface->PixData[pos+2]= buffer[buf_pos+2];
 			//if supporting alpha, set 255,0,255 to transparent
 			if(Surface->bpp==4 && buffer[buf_pos] == 255 && buffer[buf_pos+1] == 0 && buffer[buf_pos+2] == 255){Surface->PixData[pos+3]= 0;}
 			buf_pos+=3;
 			pos+=Surface->bpp;
 		}
 		//return buffer to start of line then up one line
 		buf_pos += padding;
 		buf_pos -= datawidth+datawidth;
 	}
 	delete [] buffer;
 }
 
 void loadBMP(const char *filepath, OGL_Texture *Texture)
 {
 	OGL_Surface *Surface = new OGL_Surface;
 	Surface->Create_Surface(1,1,4);
 	loadBMP(filepath, Surface);
 	Texture->gen_texture(Surface->w, Surface->h, Surface->PixData);
 	delete Surface;
 }