//Common
int32 requestedKeyboardOverlayImage=0;

#ifndef QB64_GUI //begin stubs
    
    //STUB: simulate generating a hardware surface
    int32 new_hardware_img(int32 x, int32 y, uint32 *pixels, int32 flags){
        //create hardware img
        int32 handle;
        hardware_img_struct* hardware_img;
        handle=list_add(hardware_img_handles);
        hardware_img=(hardware_img_struct*)list_get(hardware_img_handles,handle);
        hardware_img->w=x;
        hardware_img->h=y;
        hardware_img->dest_context_handle=0;
        hardware_img->depthbuffer_handle=0;
        hardware_img->pending_commands=0;
        hardware_img->remove=0;
        hardware_img->alpha_disabled=0;
        hardware_img->depthbuffer_mode=DEPTHBUFFER_MODE__ON;
        hardware_img->valid=1;
        hardware_img->source_state.PO2_fix=PO2_FIX__OFF;
        hardware_img->source_state.texture_wrap=TEXTURE_WRAP_MODE__UNKNOWN;
        hardware_img->source_state.smooth_stretched=SMOOTH_MODE__UNKNOWN;
        hardware_img->source_state.smooth_shrunk=SMOOTH_MODE__UNKNOWN;
        if (flags&NEW_HARDWARE_IMG__BUFFER_CONTENT){    
            hardware_img->texture_handle=0;
            if (flags&NEW_HARDWARE_IMG__DUPLICATE_PROVIDED_BUFFER){
                hardware_img->software_pixel_buffer=NULL;
                }else{
                free(pixels);//the buffer was meant to be consumed, so we just free it immediately
                hardware_img->software_pixel_buffer=NULL;
            }
        }
        return handle;
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    #else //end stubs
    
    
    
    int32 force_NPO2_fix=0;//This should only be set to 1 for debugging QB64
    
    uint32 *NPO2_buffer=(uint32*)malloc(4);
    int32 NPO2_buffer_size_in_pixels=1;
    
    uint32 *NPO2_texture_generate(int32 *px, int32 *py, uint32 *pixels){
        int32 ox=*px;
        int32 oy=*py;
        int32 nx=1;
        int32 ny=1;
        
        //assume not negative & not 0
        while ((ox&1)==0){
            ox>>=1;
            nx<<=1;
        }
        if (ox!=1){//x is not a power of 2
            while (ox!=0){
                ox>>=1;
                nx<<=1;
            }	
            nx<<1;
        }
        while ((oy&1)==0){
            oy>>=1;
            ny<<=1;
        }
        if (oy!=1){//y is not a power of 2
            while (oy!=0){
                oy>>=1;
                ny<<=1;
            }	
            ny<<1;
        }
        
        //reset original values
        ox=*px;
        oy=*py;
        
        if (nx==ox&&ny==oy){ //no action required
            return pixels;
        }
        
        int32 size_in_pixels=nx*ny;
        if (size_in_pixels>NPO2_buffer_size_in_pixels){
            NPO2_buffer=(uint32*)realloc(NPO2_buffer,size_in_pixels*4);
            NPO2_buffer_size_in_pixels=size_in_pixels;
        }
        
        //copy source NPO2 rectangle into destination PO2 rectangle
        if (nx==ox){ //can copy as a single block
            memcpy(NPO2_buffer,pixels,ox*oy*4);
            }else{
            uint32 *dst_pixel_offset=NPO2_buffer;
            uint32 *src_pixel_offset=pixels;
            while (oy--){
                memcpy(dst_pixel_offset,src_pixel_offset,ox*4);
                dst_pixel_offset+=nx;
                src_pixel_offset+=ox;
            }
            oy=*py;
        }
        
        //tidy edges - extend the right-most column and bottom-most row to avoid pixel/color bleeding
        //rhs column
        if (ox!=nx){
            for (int y=0;y<oy;y++){
                NPO2_buffer[ox+nx*y]=NPO2_buffer[ox+nx*y-1];
            }
        }
        //bottom row + 1 pixel for corner
        if (oy!=ny){
            for (int x=0;x<(ox+1);x++){
                NPO2_buffer[nx*oy+x]=NPO2_buffer[nx*oy+x-nx];
            }
        }
        
        //int maxtexsize;
        //glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
        //alert(maxtexsize); 
        
        //alert(nx);
        //alert(ny);
        
        *px=nx;
        *py=ny;
        
        return NPO2_buffer;
        
    }
    
    
    int32 new_texture_handle(){
        GLuint texture=0;
        glGenTextures(1,&texture);
        return (int32)texture;
    }
    
    
    int32 new_hardware_img(int32 x, int32 y, uint32 *pixels, int32 flags){
        //note: non power-of-2 dimensioned textures are supported on modern 3D cards and
        //      even on some older cards, as long as mip-mapping is not being used
        //      therefore, no attempt is made to convert the non-power-of-2 SCREEN sizes via software
        //      to avoid the performance hit this would incur
        //create hardware img
        int32 handle;
        hardware_img_struct* hardware_img;
        handle=list_add(hardware_img_handles);
        hardware_img=(hardware_img_struct*)list_get(hardware_img_handles,handle);
        hardware_img->w=x;
        hardware_img->h=y;
        hardware_img->dest_context_handle=0;
        hardware_img->depthbuffer_handle=0;
        hardware_img->pending_commands=0;
        hardware_img->remove=0;
        hardware_img->alpha_disabled=0;
        hardware_img->depthbuffer_mode=DEPTHBUFFER_MODE__ON;
        hardware_img->valid=1;
        hardware_img->source_state.PO2_fix=PO2_FIX__OFF;
        hardware_img->source_state.texture_wrap=TEXTURE_WRAP_MODE__UNKNOWN;
        hardware_img->source_state.smooth_stretched=SMOOTH_MODE__UNKNOWN;
        hardware_img->source_state.smooth_shrunk=SMOOTH_MODE__UNKNOWN;
        
        if (flags&NEW_HARDWARE_IMG__BUFFER_CONTENT){
            hardware_img->texture_handle=0;    
            if (flags&NEW_HARDWARE_IMG__DUPLICATE_PROVIDED_BUFFER){
                hardware_img->software_pixel_buffer=(uint32*)malloc(x*y*4);
                memcpy(hardware_img->software_pixel_buffer,pixels,x*y*4);
                }else{
                hardware_img->software_pixel_buffer=pixels;
            }
            }else{
            hardware_img->software_pixel_buffer=NULL;
            hardware_img->texture_handle=new_texture_handle();
            glBindTexture (GL_TEXTURE_2D, hardware_img->texture_handle); 
            //non-power of 2 dimensions fallback support    
            static int glerrorcode;
            glerrorcode=glGetError();//clear any previous errors
            if (force_NPO2_fix==0) glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels); 
            glerrorcode=glGetError();
            if (glerrorcode!=0||force_NPO2_fix==1){
                int32 nx=x,ny=y;
                uint32 *npixels=NPO2_texture_generate(&nx,&ny,pixels);
                glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, nx, ny, 0, GL_BGRA, GL_UNSIGNED_BYTE,npixels);
                hardware_img->source_state.PO2_fix=PO2_FIX__EXPANDED;
                hardware_img->PO2_w=nx;
                hardware_img->PO2_h=ny;
                glerrorcode=glGetError();	
                if (glerrorcode){
                    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, x, y, GL_BGRA, GL_UNSIGNED_BYTE, pixels );
                    glerrorcode=glGetError();
                    if (glerrorcode){
                        alert("gluBuild2DMipmaps failed");
                        alert(glerrorcode);
                    }
                    hardware_img->source_state.PO2_fix=PO2_FIX__MIPMAPPED;
                    hardware_img->PO2_w=x;
                    hardware_img->PO2_h=y;
                }
            }
            set_render_source(INVALID_HARDWARE_HANDLE);
        }
        return handle;
    }
    
    void hardware_img_buffer_to_texture(int32 handle){
        static hardware_img_struct* hardware_img;
        hardware_img=(hardware_img_struct*)list_get(hardware_img_handles,handle);
        if (hardware_img->texture_handle==0){
            hardware_img->texture_handle=new_texture_handle();
            glBindTexture (GL_TEXTURE_2D, hardware_img->texture_handle);    
            //non-power of 2 dimensions fallback support
            static int glerrorcode;
            glerrorcode=glGetError();//clear any previous errors
            if (force_NPO2_fix==0) glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, hardware_img->w, hardware_img->h, 0, GL_BGRA, GL_UNSIGNED_BYTE, hardware_img->software_pixel_buffer);  
            glerrorcode=glGetError();
            if (glerrorcode!=0||force_NPO2_fix==1){
                hardware_img->source_state.PO2_fix=PO2_FIX__EXPANDED;	
                int32 x=hardware_img->w;
                int32 y=hardware_img->h;
                uint32 *pixels=NPO2_texture_generate(&x,&y,hardware_img->software_pixel_buffer);
                hardware_img->PO2_w=x;
                hardware_img->PO2_h=y;
                glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_BGRA, GL_UNSIGNED_BYTE,pixels);
                glerrorcode=glGetError();	
                if (glerrorcode){
                    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, hardware_img->w, hardware_img->h, GL_BGRA, GL_UNSIGNED_BYTE, hardware_img->software_pixel_buffer);
                    glerrorcode=glGetError();
                    if (glerrorcode){
                        alert("gluBuild2DMipmaps failed");
                        alert(glerrorcode);
                    }
                    hardware_img->source_state.PO2_fix=PO2_FIX__MIPMAPPED;
                    hardware_img->PO2_w=hardware_img->w;
                    hardware_img->PO2_h=hardware_img->h;
                }
            }
            free(hardware_img->software_pixel_buffer);
            hardware_img->software_pixel_buffer=NULL;//2015 critical bug fix
            set_render_source(INVALID_HARDWARE_HANDLE);
        }
    }
    
    void hardware_img_requires_depthbuffer(hardware_img_struct* hardware_img){
        if (hardware_img->depthbuffer_handle==0){
            //inspiration... http://www.opengl.org/wiki/Framebuffer_Object_Examples#Color_texture.2C_Depth_texture
            static GLuint depth_tex;
            #ifndef QB64_GLES
                glGenTextures(1, &depth_tex);
                glBindTexture(GL_TEXTURE_2D, depth_tex);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
                glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, hardware_img->w, hardware_img->h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
                glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depth_tex, 0/*mipmap level*/);
                #else
                glGenRenderbuffers(1, &depth_tex);    
                glBindRenderbuffer(GL_RENDERBUFFER, depth_tex);
                glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, hardware_img->w, hardware_img->h);
                glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_tex);
            #endif
            //NULL means reserve texture memory, but texels are undefined
            glClear(GL_DEPTH_BUFFER_BIT);
            hardware_img->depthbuffer_handle=depth_tex;
            set_render_source(INVALID_HARDWARE_HANDLE);
        }
    }
    
    
#endif