View difference between Paste ID: R7Daf8n5 and 6ysGygxp

 #include "Draw.h"
-#include <stdio.h>
+///vars to add to structs
-#include <stdlib.h>
+struct OGL_Texture{
-#include <cstring>
+	float bw,bh;//blit width/height if non pwr 2 textures
-using namespace std;
+};
 struct OGL_Surface : OGL_Texture{
 	float bw,bh;
 };
 
-//OGL Texture//
+///Draw Funcs to replace (also replace "GL_TEXTURE_RECTANGLE_NV" with "GL_TEXTURE_2D")
 bool IsPowerOfTwo(uint32_t x)
-OGL_Texture::OGL_Texture(){
+
-	w=h=0;
+    return ((x & (x - 1)) == 0);
-	texture_generated = false;
+
-	Texture_ID = 0;
+int HighestBit(uint32_t x)
 {
-OGL_Texture::~OGL_Texture(){
+	if (IsPowerOfTwo(x)){return x;}
-	if (Texture_ID){glDeleteTextures(1,&Texture_ID);}//0 is not a valid texture id
+	uint32_t y = 1<<31;
 	while (y>x){y=y>>1;}
  	return y<<1;
 }
 void OGL_Texture::gen_texture(uint16_t width, uint16_t height, uint8_t *PixData){
 	if (width==0 || height==0){printf("ERROR! WIDTH OR HEIGHT OF TEXTURE == 0"); exit(1);}
 	//delete old texture if existing
 	if (texture_generated && Texture_ID){
 		glDeleteTextures(1,&Texture_ID);
 	}
 	//Power of two texture support
 	w = width;
 	h = height;
 	uint8_t *NewPixData = PixData;
-	glEnable(GL_TEXTURE_RECTANGLE_NV);
+	bool todelete = false;
-		glBindTexture(GL_TEXTURE_RECTANGLE_NV, Texture_ID);
+	if (!(IsPowerOfTwo(w) && IsPowerOfTwo(h))){
 		uint32_t new_w = HighestBit(w);
-		glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, PixData);
+		uint32_t new_h = HighestBit(h);
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		NewPixData = new uint8_t[new_w*new_h*4];
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		memset(NewPixData,255, new_w*new_h*4);
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		uint32_t pos1 = 0;
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		uint32_t pos2 = 0;
 		for (uint32_t y = 0; y<h; y++){
 			for (uint32_t x = 0; x<w; x++){
-	glDisable(GL_TEXTURE_RECTANGLE_NV);
+				NewPixData[pos1]  = PixData[pos2];
 				NewPixData[pos1+1]= PixData[pos2+1];
 				NewPixData[pos1+2]= PixData[pos2+2];
 				NewPixData[pos1+3]= PixData[pos2+3];
 				pos1+=4;
 				pos2+=4;
 			}
 			pos1+=(new_w-w)*4;
-OGL_Surface::OGL_Surface(){
+
-	texture_generated = false;
+		width= new_w;
-	bpp=4;
+		height= new_h;
-	w=h=0;
+		bw = float(w)/float(new_w);
-	PixData = nullptr;
+		bh = float(h)/float(new_h);
 		todelete = true;
-OGL_Surface::~OGL_Surface(){
+
 	//generate texture
 	glGenTextures(1,&Texture_ID);
 	if (Texture_ID==0){printf("ERROR IN TEXTURE GENERATION! NO DEVICE CONTEXT?"); exit(1);}
 	glEnable(GL_TEXTURE_2D);
 		glBindTexture(GL_TEXTURE_2D, Texture_ID);
 		//2d texture, level of detail, number of components (3=rgb), w,h, border, byte order, data format, data
 		glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA8, width, height, 0, GL_BGRA,GL_UNSIGNED_BYTE, NewPixData);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
 	glDisable(GL_TEXTURE_2D);
 	texture_generated = true;
 	//cleanup
 	if (todelete){delete [] NewPixData;}
 }
 
-void OGL_Surface::Clear_Surface(uint8_t r, uint8_t g, uint8_t b, uint8_t a){
+
-	if (r == g && g == b && bpp==3){
+
-		memset(PixData, r, w*h*bpp);
+
 void OGL_Surface::Create_Surface(uint16_t set_w,uint16_t set_h, char set_bpp){
-	else if (r == g && g == b && b == a && bpp==4){
+
-		memset(PixData, r, w*h*bpp);
+
 	// if surface already exists and width or height change delete old texture
-	else{
+
-		unsigned int pos = 0;
+
-		while (pos<w*h*bpp){
+
-			PixData[pos++] = r;
+
-			PixData[pos++] = g;
+
-			PixData[pos++] = b;
+
-			if(bpp==4){PixData[pos++] = a;}
+
 	h = set_h;
 	bpp = set_bpp;
 	PixData = new uint8_t[w*h*bpp];
-void OGL_Surface::Set_Surface_AlphaKey(uint8_t r, uint8_t g, uint8_t b)
+
 	if (!(IsPowerOfTwo(w) && IsPowerOfTwo(h))){printf("WARNING: non pow two surface, may be slow\n");}
-	if(bpp!=4){printf("trying to set alphakey on bpp that does not support alpha\n");return;}
+
-	int pos = 0;
+
-	for (unsigned int y = 0; y<h; y++){
+
-		for (unsigned int x = 0; x<w; x++){
+
-			if ((PixData[pos]==r) && (PixData[pos+1]==b) && (PixData[pos+2] == b)){
+
-				PixData[pos+3]= 0;//if colour = alphakey set alpha channel to 0
+
 	uint8_t *NewPixData = PixData;
-			pos+=4;
+	bool todelete = false;
 	if (!(IsPowerOfTwo(w) && IsPowerOfTwo(h))){
 		uint32_t new_w = HighestBit(w);
 		uint32_t new_h = HighestBit(h);
 		NewPixData = new uint8_t[new_w*new_h*4];
 		memset(NewPixData,255, new_w*new_h*4);
 		uint32_t pos1 = 0;
 		uint32_t pos2 = 0;
 		for (uint32_t y = 0; y<h; y++){
 			for (uint32_t x = 0; x<w; x++){
 				NewPixData[pos1]  = PixData[pos2];
 				NewPixData[pos1+1]= PixData[pos2+1];
 				NewPixData[pos1+2]= PixData[pos2+2];
 				NewPixData[pos1+3]= PixData[pos2+3];
-	glEnable(GL_TEXTURE_RECTANGLE_NV);
+				pos1+=4;
-		glBindTexture(GL_TEXTURE_RECTANGLE_NV, Texture_ID);
+				pos2+=4;
 			}
 			pos1+=(new_w-w)*4;
 		}
 		width= new_w;
 		height= new_h;
-				case 3: glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA8, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, PixData); break;
+		bw = w/new_w;
-				case 4: glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA8, width, height, 0, GL_BGRA,GL_UNSIGNED_BYTE, PixData); break;
+		bh = h/new_h;
 		todelete = true;
 	}
 	//only generate a texture once
 	if (!texture_generated){
 		glGenTextures(1,&Texture_ID);
 		if (Texture_ID==0){printf("ERROR IN TEXTURE GENERATION! NO DEVICE CONTEXT?"); exit(1);}
 	}
-				case 3: glTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, PixData); break;
+	glEnable(GL_TEXTURE_2D);
-				case 4: glTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 0, 0, width, height, GL_BGRA,GL_UNSIGNED_BYTE, PixData); break;
+		glBindTexture(GL_TEXTURE_2D, Texture_ID);
 		//glTexImage2D respecifies the entire texture, changing its size, deleting the previous data etc.
 		//only do this if texture doesn't exist or if w/h change
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
-		glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+				case 3: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, NewPixData); break;
 				case 4: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA,GL_UNSIGNED_BYTE, NewPixData); break;
 			}
-	glDisable(GL_TEXTURE_RECTANGLE_NV);
+
 		//glTexSubImage2D only modifies pixel data within the texture.
 		//do this when pixels need to be updated
 		else{
-OGL_Texture *Texture_Cast(OGL_Surface *Surface)
+
 				//2d texture, level of detail, xoffset,yoffset, w,h,  byte order, data format, data
-	OGL_Texture *Texture = static_cast<OGL_Texture*>(Surface);
+				case 3: glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, NewPixData); break;
-	Texture->w = Surface->w;
+				case 4: glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_BGRA,GL_UNSIGNED_BYTE, NewPixData); break;
-	Texture->h = Surface->h;
+
-	return Texture;
+
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
 	glDisable(GL_TEXTURE_2D);
 	texture_generated = true;
 	//cleanup
 	if (todelete){delete [] NewPixData;}
 }
 //BLIT//
 ////////
 //glBlendFunc(source_blend, dst_blend)
 //GL_ZERO						colour is ignored
 //GL_ONE						full colour is taken into addition
 //GL_(DST/SRC)_COLOR			colour is multiplied by (DST/SRC) color
 //GL_ONE_MINUS_(DST/SRC)_COLOR	colour is multiplied by inverted (DST/SRC) color
 //GL_(DST/SRC)_ALPHA			colour is multiplied by (DST/SRC) alpha value
 //GL_ONE_MINUS_(DST/SRC)_ALPHA	colour is multiplied by inverted (DST/SRC) alpha value
 //overall colour (GL_SRC_ALPHA, GL_ONE) -addative- = (r1*a1,g1*a1,b1*a1)+(r2,g2,b2)
 void DrawImage(OGL_Texture *Texture, int dx, int dy, float rot,float scale_x,float scale_y,float alpha,int options){
 	if (options & IMG_HFLIP){dx+=Texture->w; scale_x=-1;}
 	if (options & IMG_VFLIP){dy+=Texture->h; scale_y=-1;}
 	glLoadIdentity();
 	glTranslatef(dx, dy, 0.0);
-	glEnable(GL_TEXTURE_RECTANGLE_NV);
+
-		glEnable(GL_BLEND);
+
-			//additive blending - gray + gray = white
+
-			if (options &= IMG_ADD_BLEND){glBlendFunc(GL_SRC_ALPHA, GL_ONE);}
+
-			//regular alpha blending - gray + gray = gray
+
-			else{glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);}
+
-			//blit
+
-			glColor4f(1.0f, 1.0f, 1.0f, alpha);
+
-			glBindTexture(GL_TEXTURE_RECTANGLE_NV, Texture->Texture_ID);
+	glEnable(GL_TEXTURE_2D);
-			glBegin(GL_QUADS);
+	glEnable(GL_BLEND);
-				glTexCoord2i(0,0);
+		//additive blending - gray + gray = white
-				glVertex2i(0, 0);
+		if (options &= IMG_ADD_BLEND){glBlendFunc(GL_SRC_ALPHA, GL_ONE);}
-				glTexCoord2i(Texture->w,0);
+		//regular alpha blending - gray + gray = gray
-				glVertex2i(Texture->w, 0);
+		else{glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);}
-				glTexCoord2i(Texture->w,Texture->h);
+		//blit
-				glVertex2i(Texture->w, Texture->h);
+		glColor4f(1.0f, 1.0f, 1.0f, alpha);
-				glTexCoord2i(0,Texture->h);
+		glBindTexture(GL_TEXTURE_2D, Texture->Texture_ID);
-				glVertex2i(0, Texture->h);
+		glBegin(GL_QUADS);
-			glEnd();
+			glTexCoord2f(0,0);
-		glDisable(GL_BLEND);
+			glVertex2d(0, 0);
-	glDisable(GL_TEXTURE_RECTANGLE_NV);
+			glTexCoord2f(Texture->bw,0);
 			glVertex2d(Texture->w, 0);
 			glTexCoord2f(Texture->bw,Texture->bh);
 			glVertex2d(Texture->w, Texture->h);
 			glTexCoord2f(0,Texture->bh);
 			glVertex2d(0, Texture->h);
 		glEnd();
 	glDisable(GL_BLEND);
 	glDisable(GL_TEXTURE_2D);
 	glLoadIdentity();
 }
 void DrawSubImage(OGL_Texture *Texture, int sx, int sy, int sw, int sh, int dx, int dy, float rot,float scale_x,float scale_y,float alpha,int options){
 	float tex_coord_x1 = (float)sx/(float)Texture->w;
 	float tex_coord_y1 = (float)sy/(float)Texture->h;
 	float tex_coord_x2 = tex_coord_x1+((float)sw/(float)Texture->w);
 	float tex_coord_y2 = tex_coord_y1+((float)sh/(float)Texture->h);
-	glEnable(GL_TEXTURE_RECTANGLE_NV);
+	tex_coord_x1 *= Texture->bw;
-		glEnable(GL_BLEND);
+	tex_coord_y1 *= Texture->bh;
-			//additive blending - gray + gray = white
+	tex_coord_x2 *= Texture->bw;
-			if (options &= IMG_ADD_BLEND){glBlendFunc(GL_SRC_ALPHA, GL_ONE);}
+	tex_coord_y2 *= Texture->bh;
-			//regular alpha blending - gray + gray = gray
+
-			else{glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);}
+
-			//blit
+
-			glColor4f(1.0,1.0,1.0,alpha);
+
-			glBindTexture(GL_TEXTURE_RECTANGLE_NV, Texture->Texture_ID);
+
-			glBegin(GL_QUADS);
+
-				glTexCoord2i(sx,sy);
+
-				glVertex2i(0, 0);
+
-				glTexCoord2i(sx+sw,sy);
+
-				glVertex2i(sw, 0);
+
-				glTexCoord2i(sx+sw,sy+sh);
+
-				glVertex2i(sw, sh);
+
-				glTexCoord2i(sx,sy+sh);
+	glEnable(GL_TEXTURE_2D);
-				glVertex2i(0, sh);
+	glEnable(GL_BLEND);
-			glEnd();
+		//additive blending - gray + gray = white
-		glDisable(GL_BLEND);
+		if (options &= IMG_ADD_BLEND){glBlendFunc(GL_SRC_ALPHA, GL_ONE);}
-	glDisable(GL_TEXTURE_RECTANGLE_NV);
+		//regular alpha blending - gray + gray = gray
 		else{glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);}
 		//blit
 		glColor4f(1.0,1.0,1.0,alpha);
-//////////
+		glBindTexture(GL_TEXTURE_2D, Texture->Texture_ID);
-//COLOUR//
+		glBegin(GL_QUADS);
-//////////
+			glTexCoord2f(tex_coord_x1,tex_coord_y1);
-uint32_t make_col(uint8_t r, uint8_t g, uint8_t b, uint8_t a){
+			glVertex2d(0, 0);
-	uint32_t col = 0;
+			glTexCoord2f(tex_coord_x2,tex_coord_y1);
-	col |= r;
+			glVertex2d(sw, 0);
-	col |= uint32_t(g)<<8;
+			glTexCoord2f(tex_coord_x2,tex_coord_y2);
-	col |= uint32_t(b)<<16;
+			glVertex2d(sw, sh);
-	col |= uint32_t(a)<<24;
+			glTexCoord2f(tex_coord_x1,tex_coord_y2);
-	//printf("%#X, %d,%d,%d\n", col,r,g,b);
+			glVertex2d(0, sh);
-	return col;
+		glEnd();
 	glDisable(GL_BLEND);
 	glDisable(GL_TEXTURE_2D);
-uint32_t make_col(uint8_t r, uint8_t g, uint8_t b){
+
-	return make_col(r,g,b,255);
+