Initial stubs for the Windows version.

The port is still incomplete and will be incomplete for a long time.

8 files changed, 2360 insertions, 0 deletions

diff --git a/smelt/w32/gfx_d3d.cpp b/smelt/w32/gfx_d3d.cpp
new file mode 100644
index 0000000..c8255f8
--- /dev/null
+++ b/smelt/w32/gfx_d3d.cpp
@@ -0,0 +1,1086 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * GFX implementation based on DirectX 9 and hge
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#include "smelt_internal.hpp"
+
+static const char* GFX_SDL_SRCFN="smelt/sdl/gfx_d3d.cpp";
+bool SMELT_IMPL::smRenderBegin2D(bool ztest,SMTRG trg)
+{
+	TRenderTargetList *targ=(TRenderTargetList*)trg;
+	if(vertexArray)
+	{smLog("%s:" SLINE ": Last frame not closed.\n",GFX_SDL_SRCFN);return false;}
+	if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,(targ)?targ->frame:0);
+	pOpenGLDevice->glDepthFunc(GL_GEQUAL);
+	ztest?pOpenGLDevice->glEnable(GL_DEPTH_TEST):pOpenGLDevice->glDisable(GL_DEPTH_TEST);
+	zbufenabled=ztest;
+	if(targ)
+	{
+		pOpenGLDevice->glScissor(0,0,targ->w,targ->h);
+		pOpenGLDevice->glViewport(0,0,targ->w,targ->h);
+		configProjectionMatrix2D(targ->w,targ->h);
+	}
+	else
+	{
+		pOpenGLDevice->glScissor(0,0,scrw,scrh);
+		pOpenGLDevice->glViewport(0,0,scrw,scrh);
+		configProjectionMatrix2D(scrw,scrh);
+	}
+	sm2DCamera5f3v(NULL,NULL,NULL);
+	curTarget=targ;tdmode=0;
+	vertexArray=vertexBuf;
+	return true;
+}
+bool SMELT_IMPL::smRenderBegin3D(float fov,bool ztest,SMTRG trg)
+{
+	TRenderTargetList *targ=(TRenderTargetList*)trg;
+	if(vertexArray)
+	{smLog("%s:" SLINE ": Last frame not closed.\n",GFX_SDL_SRCFN);return false;}
+	if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,(targ)?targ->frame:0);
+	pOpenGLDevice->glDepthFunc(GL_LESS);
+	ztest?pOpenGLDevice->glEnable(GL_DEPTH_TEST):pOpenGLDevice->glDisable(GL_DEPTH_TEST);
+	zbufenabled=ztest;
+	if(targ)
+	{
+		pOpenGLDevice->glScissor(0,0,targ->w,targ->h);
+		pOpenGLDevice->glViewport(0,0,targ->w,targ->h);
+		configProjectionMatrix3D(targ->w,targ->h,fov);
+	}
+	else
+	{
+		pOpenGLDevice->glScissor(0,0,scrw,scrh);
+		pOpenGLDevice->glViewport(0,0,scrw,scrh);
+		configProjectionMatrix3D(scrw,scrh,fov);
+	}
+	sm3DCamera6f2v(NULL,NULL);
+	curTarget=targ;tdmode=1;
+	vertexArray=vertexBuf;
+	return true;
+}
+bool SMELT_IMPL::smRenderEnd()
+{
+	batchOGL(true);
+	if(curTarget&&!pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	{
+		glTexture *pTex=(glTexture*)curTarget->tex;
+		if(pTex&&pTex->lost)
+		configTexture(pTex,pTex->rw,pTex->rh,pTex->px);
+		int w=curTarget->w,h=curTarget->h;
+		pOpenGLDevice->glFinish();
+		DWORD *px=new DWORD[w*h];
+		pOpenGLDevice->glReadPixels(0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,pTex->name);
+		pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget,0,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,primTex?(((glTexture*)primTex)->name):0);
+		delete[] px;
+	}
+	if(curTarget&&curTarget->ms)
+	{
+		glTexture *pTex=(glTexture*)curTarget->tex;
+		if(pTex&&pTex->lost)
+		configTexture(pTex,pTex->rw,pTex->rh,pTex->px);
+		int w=curTarget->w,h=curTarget->h;
+		pOpenGLDevice->glFinish();
+		DWORD *px=new DWORD[w*h];
+		pOpenGLDevice->glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,curTarget->frame);
+		pOpenGLDevice->glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT,curTarget->sframe);
+		pOpenGLDevice->glBlitFramebufferEXT(0,0,w,h,0,0,w,h,GL_COLOR_BUFFER_BIT,GL_NEAREST);
+		pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,curTarget->sframe);
+		pOpenGLDevice->glReadPixels(0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,pTex->name);
+		pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget,0,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,primTex?(((glTexture*)primTex)->name):0);
+		delete[] px;
+	}
+	if(!curTarget)SDL_GL_SwapWindow((SDL_Window*)hwnd);
+	return true;
+}
+void SMELT_IMPL::smClrscr(DWORD color,bool clearcol,bool cleardep)
+{
+	GLfloat a=(GLfloat)(GETA(color))/255.f;
+	GLfloat r=(GLfloat)(GETR(color))/255.f;
+	GLfloat g=(GLfloat)(GETG(color))/255.f;
+	GLfloat b=(GLfloat)(GETB(color))/255.f;
+	if(clearcol)
+	pOpenGLDevice->glClearColor(r,g,b,a);
+	if(tdmode)pOpenGLDevice->glClearDepth(1);
+	else if(zbufenabled)pOpenGLDevice->glClearDepth(0);
+	pOpenGLDevice->glClear((clearcol?GL_COLOR_BUFFER_BIT:0)|(((zbufenabled||tdmode)&&cleardep)?GL_DEPTH_BUFFER_BIT:0));
+}
+void SMELT_IMPL::sm3DCamera6f2v(float *pos,float *rot)
+{
+	batchOGL();
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	pOpenGLDevice->glLoadIdentity();
+	if(!pos||!rot)return;
+	pOpenGLDevice->glRotatef((GLfloat)-rot[0],1,0,0);
+	pOpenGLDevice->glRotatef((GLfloat)-rot[1],0,1,0);
+	pOpenGLDevice->glRotatef((GLfloat)-rot[2],0,0,1);
+	pOpenGLDevice->glTranslatef((GLfloat)-pos[0],(GLfloat)-pos[1],(GLfloat)-pos[2]);
+}
+void SMELT_IMPL::smMultViewMatrix(float *mat)
+{
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	pOpenGLDevice->glMultMatrixf(mat);
+}
+void SMELT_IMPL::sm2DCamera5f3v(float *pos,float *dpos,float *rot)
+{
+	batchOGL();
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	pOpenGLDevice->glLoadIdentity();
+	if(!pos||!dpos||!rot)return;
+	pOpenGLDevice->glTranslatef(-pos[0],-pos[1],0.0f);
+	pOpenGLDevice->glRotatef(*rot,0.0f,0.0f,1.0f);
+	pOpenGLDevice->glTranslatef(pos[0]+dpos[0],pos[1]+dpos[1],0.0f);
+}
+void SMELT_IMPL::smRenderLinefd(float x1,float y1,float z1,float x2,float y2,float z2,DWORD color)
+{
+	if(vertexArray)
+	{
+		if(primType!=PRIM_LINES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_LINES||primTex||primBlend!=BLEND_ALPHABLEND)
+		{
+			batchOGL();
+			primType=PRIM_LINES;
+			if(primBlend!=BLEND_ALPHAADD)setBlend(BLEND_ALPHAADD);
+			bindTexture(NULL);
+		}
+		int i=(primcnt++)*PRIM_LINES;
+		vertexArray[i].x=x1,vertexArray[i+1].x=x2;
+		vertexArray[i].y=y1,vertexArray[i+1].y=y2;
+		vertexArray[i].x=z1,vertexArray[i+1].x=z2;
+		vertexArray[i].col=vertexArray[i+1].col=color;
+		vertexArray[i].tx=vertexArray[i+1].tx=.0;
+		vertexArray[i].ty=vertexArray[i+1].ty=.0;
+	}
+}
+void SMELT_IMPL::smRenderLinefvd(float *p1,float *p2,DWORD color)
+{
+	if(vertexArray&&p1&&p2)
+	{
+		if(primType!=PRIM_LINES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_LINES||primTex||primBlend!=BLEND_ALPHABLEND)
+		{
+			batchOGL();
+			primType=PRIM_LINES;
+			if(primBlend!=BLEND_ALPHAADD)setBlend(BLEND_ALPHAADD);
+			bindTexture(NULL);
+		}
+		int i=(primcnt++)*PRIM_LINES;
+		vertexArray[i].x=p1[0],vertexArray[i+1].x=p2[0];
+		vertexArray[i].y=p1[1],vertexArray[i+1].y=p2[1];
+		vertexArray[i].x=p2[2],vertexArray[i+1].x=p2[2];
+		vertexArray[i].col=vertexArray[i+1].col=color;
+		vertexArray[i].tx=vertexArray[i+1].tx=.0;
+		vertexArray[i].ty=vertexArray[i+1].ty=.0;
+	}
+}
+void SMELT_IMPL::smRenderTriangle(smTriangle *t)
+{
+	if(vertexArray)
+	{
+		if(primType!=PRIM_TRIANGLES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_TRIANGLES||
+		primTex!=t->tex||primBlend!=t->blend)
+		{
+			batchOGL();
+			primType=PRIM_TRIANGLES;
+			if(primBlend!=t->blend)setBlend(t->blend);
+			bindTexture((glTexture*)t->tex);
+		}
+		memcpy(&vertexArray[(primcnt++)*PRIM_TRIANGLES],t->v,sizeof(smVertex)*PRIM_TRIANGLES);
+	}
+}
+void SMELT_IMPL::smRenderQuad(smQuad *q)
+{
+	if(vertexArray)
+	{
+		if(primType!=PRIM_QUADS||primcnt>=VERTEX_BUFFER_SIZE/PRIM_QUADS||
+		primTex!=q->tex||primBlend!=q->blend)
+		{
+			batchOGL();
+			primType=PRIM_QUADS;
+			if(primBlend!=q->blend)setBlend(q->blend);
+			bindTexture((glTexture*)q->tex);
+		}
+		memcpy(&vertexArray[(primcnt++)*PRIM_QUADS],q->v,sizeof(smVertex)*PRIM_QUADS);
+	}
+}
+smVertex* SMELT_IMPL::smGetVertArray()
+{
+	if(vertexArray)
+	{
+		batchOGL();
+		return vertexArray;
+	}
+	else return NULL;
+}
+void SMELT_IMPL::smDrawVertArray(int prim,SMTEX texture,int blend,int _primcnt)
+{
+	primType=prim;
+	bindTexture((glTexture*)texture);
+	if(primBlend!=blend)setBlend(blend);
+	primcnt=primcnt;
+}
+void SMELT_IMPL::smDrawCustomIndexedVertices(smVertex* vb,WORD* ib,int vbc,int ibc,int blend,SMTEX texture)
+{
+	if(vertexArray)
+	{
+		batchOGL();
+		pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER,0);
+		pOpenGLDevice->glVertexPointer(3,GL_FLOAT,sizeof(smVertex),&vb[0].x);
+		pOpenGLDevice->glColorPointer(4,GL_UNSIGNED_BYTE,sizeof(smVertex),&vb[0].col);
+		pOpenGLDevice->glTexCoordPointer(2,GL_FLOAT,sizeof(smVertex),&vb[0].tx);
+
+		float twm=1.,thm=1.;
+		if(texture)
+		{
+			if(filtermode==TFLT_NEAREST)
+			{
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+			}
+			if(filtermode==TFLT_LINEAR)
+			{
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+			}
+			glTexture *ptex=(glTexture*)texture;
+			if(pOpenGLDevice->TextureTarget==GL_TEXTURE_RECTANGLE_ARB)
+			{twm=ptex->rw;thm=ptex->rh;}
+			else if(ptex->dw&&ptex->dh)
+			{
+				twm=(ptex->rw)/(float)(ptex->dw);
+				thm=(ptex->rh)/(float)(ptex->dh);
+			}
+		}
+		if(!tdmode)
+		{
+			float h=curTarget?curTarget->h:scrh;
+			for(int i=0;i<vbc;++i)
+			{
+				vertexArray[i].y=h-vertexArray[i].y;
+				vertexArray[i].z=-vertexArray[i].z;
+			}
+		}
+		for(int i=0;i<vbc;++i)
+		{
+			vb[i].tx*=twm;
+			vb[i].ty=(1.-vb[i].ty)*thm;
+			DWORD color=vb[i].col;
+			BYTE *col=(BYTE*)&vb[i].col;
+			BYTE a=((color>>24)&0xFF);
+			BYTE r=((color>>16)&0xFF);
+			BYTE g=((color>> 8)&0xFF);
+			BYTE b=((color>> 0)&0xFF);
+			col[0]=r;col[1]=g;
+			col[2]=b;col[3]=a;
+		}
+		if(texture!=primTex)bindTexture((glTexture*)texture);
+		if(blend!=primBlend)setBlend(blend);
+		pOpenGLDevice->glDrawElements(GL_TRIANGLES,ibc,GL_UNSIGNED_SHORT,ib);
+
+		pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER,IndexBufferObject);
+		pOpenGLDevice->glVertexPointer(3,GL_FLOAT,sizeof(smVertex),&vertexBuf[0].x);
+		pOpenGLDevice->glColorPointer(4,GL_UNSIGNED_BYTE,sizeof(smVertex),&vertexBuf[0].col);
+		pOpenGLDevice->glTexCoordPointer(2,GL_FLOAT,sizeof(smVertex),&vertexBuf[0].tx);
+	}
+}
+SMTRG SMELT_IMPL::smTargetCreate(int w,int h,int ms)
+{
+	bool ok=false;
+	TRenderTargetList *pTarget=new TRenderTargetList;
+	memset(pTarget,0,sizeof(TRenderTargetList));
+	pTarget->tex=buildTexture(w,h,NULL);
+	glTexture *gltex=(glTexture*)pTarget->tex;
+	gltex->isTarget=true;gltex->lost=false;
+	configTexture(gltex,w,h,NULL,false);
+	pTarget->w=w;pTarget->h=h;
+	ok=buildTarget(pTarget,gltex->name,w,h,ms);
+	if(!ok)
+	{
+		smLog("%s:" SLINE ": Failed to create render target.\n",GFX_SDL_SRCFN);
+		smTextureFree(pTarget->tex);
+		delete pTarget;
+		return 0;
+	}
+	pTarget->next=targets;
+	targets=pTarget;
+	return (SMTRG)pTarget;
+}
+SMTEX SMELT_IMPL::smTargetTexture(SMTRG targ)
+{
+	TRenderTargetList *pTarg=(TRenderTargetList*)targ;
+	return targ?pTarg->tex:0;
+}
+void SMELT_IMPL::smTargetFree(SMTRG targ)
+{
+	TRenderTargetList *pTarget=targets,*pLastTarg=NULL;
+	while(pTarget)
+	{
+		if((TRenderTargetList*)targ==pTarget)
+		{
+			if(pLastTarg)pLastTarg->next=pTarget->next;
+			else targets=pTarget->next;
+			if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+			{
+				if(curTarget==(TRenderTargetList*)targ)
+				pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
+				if(pTarget->depth)
+				pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->depth);
+				pOpenGLDevice->glDeleteFramebuffersEXT(1,&pTarget->frame);
+				if(pTarget->ms)
+				{
+					pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->colorms);
+					pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->scolor);
+					pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->sdepth);
+					pOpenGLDevice->glDeleteFramebuffersEXT(1,&pTarget->sframe);
+				}
+			}
+			if(curTarget==(TRenderTargetList*)targ)curTarget=0;
+			smTextureFree(pTarget->tex);
+			delete pTarget;
+			return;
+		}
+		pLastTarg=pTarget;
+		pTarget=pTarget->next;
+	}
+}
+SMTEX SMELT_IMPL::smTextureCreate(int w,int h)
+{
+	DWORD *px=new DWORD[w*h];
+	memset(px,0,sizeof(DWORD)*w*h);
+	SMTEX ret=buildTexture(w,h,px);
+	if(ret)
+	{
+		TTextureList *tex=new TTextureList;
+		tex->tex=ret;
+		tex->w=w;
+		tex->h=h;
+		tex->next=textures;
+		textures=tex;
+	}
+	return ret;
+}
+SMTEX SMELT_IMPL::smTextureLoad(const char *path)
+{
+	FILE *pFile;DWORD size,rsize;char *buff;
+	SMTEX ret=0;
+	pFile=fopen(path,"rb");
+	if(!pFile)return 0;
+	fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile);
+	buff=(char*)malloc(sizeof(char)*size);
+	if(!buff)return 0;
+	rsize=fread(buff,1,size,pFile);
+	if(rsize!=size)return 0;
+	ret=smTextureLoadFromMemory(buff,size);if(!ret)return 0;
+	glTexture *t=(glTexture*)ret;
+	configTexture(t,t->rw,t->rh,t->px);
+	delete[] t->px;t->px=NULL;
+	t->fn=strcpy(new char[strlen(path)+1],path);
+	free(buff);
+	fclose(pFile);
+	return ret;
+}
+SMTEX SMELT_IMPL::smTextureLoadFromMemory(const char *ptr,DWORD size)
+{
+	int w=0,h=0;SMTEX ret=0;
+	DWORD *px=decodeImage((BYTE*)ptr,NULL,size,w,h);
+	if(px)ret=buildTexture(w,h,px);
+	if(ret)
+	{
+		TTextureList *tex=new TTextureList;
+		tex->tex=ret;tex->w=w;tex->h=h;
+		tex->next=textures;textures=tex;
+	}else smLog("%s:" SLINE ": Unsupported texture format.\n",GFX_SDL_SRCFN);
+	return ret;
+}
+void SMELT_IMPL::smTextureFree(SMTEX tex)
+{
+	if(!pOpenGLDevice)return;
+	TTextureList *ctex=textures,*lasttex=NULL;
+	while(ctex)
+	{
+		if(ctex->tex==tex)
+		{
+			if(lasttex)lasttex->next=ctex->next;
+			else textures=ctex->next;
+			delete ctex;
+			break;
+		}
+		lasttex=ctex;
+		ctex=ctex->next;
+	}
+	if(tex)
+	{
+		glTexture *ptex=(glTexture*)tex;
+		delete[] ptex->fn;delete[] ptex->locpx;delete[] ptex->px;
+		pOpenGLDevice->glDeleteTextures(1,&ptex->name);
+		delete ptex;
+	}
+}
+void SMELT_IMPL::smTextureOpt(int potopt,int filter)
+{
+	batchOGL();
+	if(potopt==TPOT_NONPOT)
+	{
+		if(pOpenGLDevice->have_GL_ARB_texture_rectangle)
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_RECTANGLE_ARB;
+		else if(pOpenGLDevice->have_GL_ARB_texture_non_power_of_two)
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_2D;
+		else pOpenGLDevice->TextureTarget=GL_TEXTURE_2D;
+		pOpenGLDevice->glDisable(GL_TEXTURE_2D);
+		if(pOpenGLDevice->have_GL_ARB_texture_rectangle)pOpenGLDevice->glDisable(GL_TEXTURE_RECTANGLE_ARB);
+		pOpenGLDevice->glEnable(pOpenGLDevice->TextureTarget);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
+	}
+	if(potopt==TPOT_POT)
+	{
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_2D;
+		pOpenGLDevice->glDisable(GL_TEXTURE_2D);
+		if(pOpenGLDevice->have_GL_ARB_texture_rectangle)pOpenGLDevice->glDisable(GL_TEXTURE_RECTANGLE_ARB);
+		pOpenGLDevice->glEnable(pOpenGLDevice->TextureTarget);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_S,GL_REPEAT);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_T,GL_REPEAT);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_R,GL_REPEAT);
+	}
+	filtermode=filter;
+	if(filter==TFLT_NEAREST)
+	{
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+	}
+	if(filter==TFLT_LINEAR)
+	{
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+	}
+}
+int SMELT_IMPL::smTextureGetWidth(SMTEX tex,bool original)
+{
+	if(original)
+	{
+		TTextureList *ctex=textures;
+		while(ctex){if(ctex->tex==tex)return ctex->w;ctex=ctex->next;}
+	}
+	else return ((glTexture*)tex)->rw;
+	return 0;
+}
+int SMELT_IMPL::smTextureGetHeight(SMTEX tex,bool original)
+{
+	if(original)
+	{
+		TTextureList *ctex=textures;
+		while(ctex){if(ctex->tex==tex)return ctex->h;ctex=ctex->next;}
+	}
+	else return ((glTexture*)tex)->rh;
+	return 0;
+}
+DWORD* SMELT_IMPL::smTextureLock(SMTEX tex,int l,int t,int w,int h,bool ro)
+{
+	glTexture *ptex=(glTexture*)tex;
+	if(ptex->locpx)return NULL;
+	bool fromfile=(ptex->px==NULL&&ptex->fn);
+	if(fromfile)
+	{
+		FILE *pFile;DWORD size,rsize;char *buff;
+		pFile=fopen(ptex->fn,"rb");
+		if(!pFile)return 0;
+		fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile);
+		buff=(char*)malloc(sizeof(char)*size);
+		if(!buff)return 0;
+		rsize=fread(buff,1,size,pFile);
+		if(rsize!=size)return 0;
+		int _w,_h;
+		ptex->px=decodeImage((BYTE*)buff,ptex->fn,size,_w,_h);
+		if(_w!=(int)ptex->rw||_h!=(int)ptex->rh)
+		{delete[] ptex->px;ptex->px=NULL;}
+		free(buff);
+		fclose(pFile);
+		if(ptex->px&&!ro){delete[] ptex->fn;ptex->fn=NULL;}
+	}
+	if(!ptex->px&&!ptex->isTarget)return 0;
+	if(!w)w=ptex->rw;if(!h)h=ptex->rh;
+	//asserts...
+	ptex->roloc=ro;ptex->locx=l;ptex->locy=t;ptex->locw=w;ptex->loch=h;
+	ptex->locpx=new DWORD[w*h];
+	if(!ptex->isTarget)
+	{
+		DWORD *dst=ptex->locpx,*src=ptex->px+((t*ptex->rw)+l);
+		for(int i=0;i<h;++i)//TODO: flip it...
+		{
+			memcpy(dst,src,w*sizeof(DWORD));
+			dst+=w;src+=ptex->rw;
+		}
+	}
+	else return 0;
+	return ptex->locpx;
+}
+void SMELT_IMPL::smTexutreUnlock(SMTEX tex)
+{
+	glTexture *ptex=(glTexture*)tex;
+	if(!ptex->locpx)return;
+	if(!ptex->roloc)
+	{
+		DWORD *src=ptex->locpx,*dst=ptex->px+((ptex->locy*ptex->rw)+ptex->locx);
+		for(int i=0;i<ptex->loch;++i)//TODO: flip it...
+		{
+			memcpy(dst,src,ptex->locw*sizeof(DWORD));
+			dst+=ptex->rw;src+=ptex->locw;
+		}
+		if(ptex->lost)configTexture(ptex,ptex->rw,ptex->rh,ptex->px);
+		else
+		{
+			pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,ptex->name);
+			pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget,0,ptex->locx,
+										  (ptex->rh-ptex->locy)-ptex->loch,ptex->locw,ptex->loch,GL_RGBA,
+										  GL_UNSIGNED_BYTE,ptex->locpx);
+			pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,primTex?(((glTexture*)primTex)->name):0);
+		}
+	}
+	if(ptex->fn&&ptex->roloc){delete[] ptex->px;ptex->px=NULL;}
+	delete[] ptex->locpx;ptex->locpx=NULL;
+	ptex->roloc=false;
+	ptex->locx=ptex->locy=ptex->locw=ptex->loch=-1;
+}
+
+inline bool ispot(GLuint x){return((x&(x-1))==0);}
+inline GLuint npot(GLuint x)
+{
+	--x;
+	for(unsigned i=1;i<sizeof(GLuint)*8;i<<=1)x|=x>>i;
+	return x+1;
+}
+DWORD* SMELT_IMPL::decodeImage(BYTE *data,const char *fn,DWORD size,int &w,int &h)
+{
+	w=h=0;
+	DWORD *px=NULL;
+	int fnlen=fn?strlen(fn):0;
+	if((fnlen>5)&&(strcasecmp((fn+fnlen)-5,".rgba"))==0)//raw image... pending remove
+	{
+		DWORD *ptr=(DWORD*)data;
+		DWORD _w=ptr[0],_h=ptr[1];
+		if(((_w*_h*4)+8)==size)
+		{
+			w=_w;h=_h;
+			px=new DWORD[w*h];
+			memcpy(px,ptr+2,w*h*4);
+		}
+		return px;
+	}
+	CxImage img;
+	img.Decode(data,size,CXIMAGE_FORMAT_UNKNOWN);
+	if(img.IsValid())
+	{
+		w=img.GetWidth();h=img.GetHeight();
+		px=new DWORD[w*h];
+		BYTE *sptr=(BYTE*)px;
+		bool atunnel=img.AlphaIsValid();
+		for(int i=0;i<h;++i)
+		for(int j=0;j<w;++j)
+		{
+			RGBQUAD rgb=img.GetPixelColor(j,i,true);
+			*(sptr++)=rgb.rgbRed;
+			*(sptr++)=rgb.rgbGreen;
+			*(sptr++)=rgb.rgbBlue;
+			*(sptr++)=atunnel?rgb.rgbReserved:0xFF;
+		}
+	}
+	return px;
+}
+void SMELT_IMPL::bindTexture(glTexture *t)
+{
+	if(t&&t->lost)
+	configTexture(t,t->rw,t->rh,t->px);
+	if(((SMTEX)t)!=primTex)
+	{
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,t?t->name:0);
+		primTex=(SMTEX)t;
+	}
+}
+bool SMELT_IMPL::buildTarget(TRenderTargetList *pTarget,GLuint texid,int w,int h,int ms=0)
+{
+	bool ok=true;
+	if(ms)
+	{
+		if(!pOpenGLDevice->have_GL_EXT_framebuffer_object||
+		!pOpenGLDevice->have_GL_EXT_framebuffer_multisample||
+		!pOpenGLDevice->have_GL_EXT_framebuffer_blit)
+			ms=0;
+		else
+		{
+			pOpenGLDevice->glGenFramebuffersEXT(1,&pTarget->sframe);
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,pTarget->sframe);
+			pOpenGLDevice->glGenRenderbuffersEXT(1,&pTarget->scolor);
+			pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,pTarget->scolor);
+			pOpenGLDevice->glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_RGBA,w,h);
+			pOpenGLDevice->glGenRenderbuffersEXT(1,&pTarget->sdepth);
+			pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,pTarget->sdepth);
+			pOpenGLDevice->glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT24,w,h);
+			pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_RENDERBUFFER_EXT,pTarget->scolor);
+			pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_RENDERBUFFER_EXT,pTarget->sdepth);
+
+			pOpenGLDevice->glGenFramebuffersEXT(1,&pTarget->frame);
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,pTarget->frame);
+			pOpenGLDevice->glGenRenderbuffersEXT(1,&pTarget->colorms);
+			pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,pTarget->colorms);
+			pOpenGLDevice->glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT,ms,GL_RGBA,w,h);
+			pOpenGLDevice->glGenRenderbuffersEXT(1,&pTarget->depth);
+			pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,pTarget->depth);
+			pOpenGLDevice->glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT,ms,GL_DEPTH_COMPONENT24,w,h);
+			pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_RENDERBUFFER_EXT,pTarget->colorms);
+			pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_RENDERBUFFER_EXT,pTarget->depth);
+			GLenum rc=pOpenGLDevice->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+			if((rc==GL_FRAMEBUFFER_COMPLETE_EXT)&&(pOpenGLDevice->glGetError()==GL_NO_ERROR))
+			{
+				pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+				ok=true;pTarget->ms=ms;
+			}
+			else
+			{
+				pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
+				pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->colorms);
+				pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->depth);
+				pOpenGLDevice->glDeleteFramebuffersEXT(1,&pTarget->frame);
+				pOpenGLDevice->glDeleteFramebuffersEXT(1,&pTarget->sframe);
+				ok=false;ms=0;
+			}
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,curTarget?curTarget->frame:0);
+		}
+	}
+	if(!ms)
+	if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	{
+		pOpenGLDevice->glGenFramebuffersEXT(1,&pTarget->frame);
+		pOpenGLDevice->glGenRenderbuffersEXT(1,&pTarget->depth);
+		pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,pTarget->frame);
+		pOpenGLDevice->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,pOpenGLDevice->TextureTarget,texid,0);
+		pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,pTarget->depth);
+		pOpenGLDevice->glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT24,w,h);
+		pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_RENDERBUFFER_EXT,pTarget->depth);
+		GLenum rc=pOpenGLDevice->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+		if((rc==GL_FRAMEBUFFER_COMPLETE_EXT)&&(pOpenGLDevice->glGetError()==GL_NO_ERROR))
+		{
+			pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+			ok=true;pTarget->ms=0;
+		}
+		else
+		{
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
+			pOpenGLDevice->glDeleteRenderbuffersEXT(1,&pTarget->depth);
+			pOpenGLDevice->glDeleteFramebuffersEXT(1,&pTarget->frame);
+			ok=false;
+		}
+		pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,curTarget?curTarget->frame:0);
+	}
+	return ok;
+}
+void SMELT_IMPL::configTexture(glTexture *t,int w,int h,DWORD *px,bool compressed)
+{
+	GLuint tex=0;
+	pOpenGLDevice->glGenTextures(1,&tex);
+	t->lost=false;t->name=tex;t->rw=w;t->rh=h;t->px=px;
+	t->dw=t->dh=0;
+	bool fromfile=(!px&&(t->fn));
+	if(fromfile)
+	{
+		FILE *pFile;DWORD size,rsize;char *buff;
+		pFile=fopen(t->fn,"rb");
+		if(!pFile)return;
+		fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile);
+		buff=(char*)malloc(sizeof(char)*size);
+		if(!buff)return;
+		rsize=fread(buff,1,size,pFile);
+		if(rsize!=size)return;
+		int _w,_h;
+		px=decodeImage((BYTE*)buff,t->fn,size,_w,_h);
+		if(_w!=w||_h!=h){delete[] px;px=NULL;}
+		free(buff);
+		fclose(pFile);
+	}
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,tex);
+	if(pOpenGLDevice->TextureTarget!=GL_TEXTURE_RECTANGLE_ARB)
+	{
+		pOpenGLDevice->glTexParameterf(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_LOD,0.0f);
+		pOpenGLDevice->glTexParameterf(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAX_LOD,0.0f);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_BASE_LEVEL,0);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAX_LEVEL,0);
+	}
+	const GLenum fmt=pOpenGLDevice->have_GL_EXT_texture_compression_s3tc&&compressed?/*GL_COMPRESSED_RGBA_S3TC_DXT5_EXT*/GL_COMPRESSED_RGBA_ARB:GL_RGBA8;
+	if((pOpenGLDevice->have_GL_ARB_texture_rectangle)||(pOpenGLDevice->have_GL_ARB_texture_non_power_of_two)||(ispot(w)&&ispot(h)))
+	{
+		pOpenGLDevice->glTexImage2D(pOpenGLDevice->TextureTarget,0,fmt,w,h,0,GL_RGBA,GL_UNSIGNED_BYTE,px);
+	}
+	else
+	{
+		t->dw=npot(w);
+		t->dh=npot(h);
+		pOpenGLDevice->glTexImage2D(pOpenGLDevice->TextureTarget,0,fmt,t->dw,t->dh,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
+		pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget,0,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px);
+	}
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget,primTex?(((glTexture*)primTex)->name):0);
+	if (fromfile)delete[] px;
+}
+SMTEX SMELT_IMPL::buildTexture(int w,int h,DWORD *px)
+{
+	glTexture *ret=new glTexture;
+	memset(ret,0,sizeof(glTexture));
+	ret->lost=true;
+	ret->rw=w;ret->rh=h;ret->px=px;
+	return (SMTEX)ret;
+}
+void SMELT_IMPL::configProjectionMatrix2D(int w,int h)
+{
+	pOpenGLDevice->glMatrixMode(GL_PROJECTION);
+	pOpenGLDevice->glLoadIdentity();
+	pOpenGLDevice->glOrtho(0,(float)w,0,(float)h,0.0f,1.0f);
+}
+void SMELT_IMPL::configProjectionMatrix3D(int w,int h,float fov)
+{
+	pOpenGLDevice->glMatrixMode(GL_PROJECTION);
+	pOpenGLDevice->glLoadIdentity();
+
+	GLfloat matrix[16]={0.0f};
+	float f=1./tanf(M_PI*fov/360.);
+	float ar=(float)w/(float)h;
+	float Near=0.1,Far=1000.;
+	matrix[0]=f/ar;matrix[5]=f;
+	matrix[10]=(Far+Near)/(Near-Far);matrix[11]=-1.0f;
+	matrix[14]=(2*Far*Near)/(Near-Far);
+	pOpenGLDevice->glMultMatrixf(matrix);
+}
+void SMELT_IMPL::batchOGL(bool endScene)
+{
+	if(vertexArray&&primcnt)
+	{
+		float twm=1.,thm=1.;
+		if(primTex)
+		{
+			if(filtermode==TFLT_NEAREST)
+			{
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+			}
+			if(filtermode==TFLT_LINEAR)
+			{
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+				pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+			}
+			glTexture *ptex=(glTexture*)primTex;
+			if(pOpenGLDevice->TextureTarget==GL_TEXTURE_RECTANGLE_ARB)
+			{twm=ptex->rw;thm=ptex->rh;}
+			else if(ptex->dw&&ptex->dh)
+			{
+				twm=(ptex->rw)/(float)(ptex->dw);
+				thm=(ptex->rh)/(float)(ptex->dh);
+			}
+		}
+		if(!tdmode)
+		{
+			float h=curTarget?curTarget->h:scrh;
+			for(int i=0;i<primcnt*primType;++i)
+			{
+				vertexArray[i].y=h-vertexArray[i].y;
+				vertexArray[i].z=-vertexArray[i].z;
+			}
+		}
+		for(int i=0;i<primcnt*primType;++i)
+		{
+			vertexArray[i].tx*=twm;
+			vertexArray[i].ty=(1.-vertexArray[i].ty)*thm;
+			DWORD color=vertexArray[i].col;
+			BYTE *col=(BYTE*)&vertexArray[i].col;
+			BYTE a=((color>>24)&0xFF);
+			BYTE r=((color>>16)&0xFF);
+			BYTE g=((color>> 8)&0xFF);
+			BYTE b=((color>> 0)&0xFF);
+			col[0]=r;col[1]=g;
+			col[2]=b;col[3]=a;
+		}
+		switch(primType)
+		{
+			case PRIM_LINES:
+				pOpenGLDevice->glDrawArrays(GL_LINES,0,2*primcnt);
+			break;
+			case PRIM_TRIANGLES:
+				pOpenGLDevice->glDrawArrays(GL_TRIANGLES,0,3*primcnt);
+			break;
+			case PRIM_QUADS:
+				pOpenGLDevice->glDrawElements(GL_TRIANGLES,6*primcnt,GL_UNSIGNED_SHORT,pOpenGLDevice->have_GL_ARB_vertex_buffer_object?0:indexBuf);
+#if 0
+				for (int i=0;i<primcnt*6;i+=3)
+				{
+					printf("idxbuf:%d\n",indexBuf[i]);
+					printf("QUAD'S TRIANGLE:\n");
+#define printVertex(a) printf("(%.2f,%.2f,%.2f),0x%X,(%.2f,%.2f)\n",a.x,a.y,a.z,a.col,a.tx,a.ty);
+					printf("#%d: ",indexBuf[i+0]);printVertex(vertexBuf[indexBuf[i+0]]);
+					printf("#%d: ",indexBuf[i+1]);printVertex(vertexBuf[indexBuf[i+1]]);
+					printf("#%d: ",indexBuf[i+2]);printVertex(vertexBuf[indexBuf[i+2]]);
+#undef printVertex
+				}
+#endif
+			break;
+		}
+		primcnt=0;
+	}
+	if(vertexArray)vertexArray=endScene?0:vertexBuf;
+}
+void SMELT_IMPL::setBlend(int blend)
+{
+	if((blend&BLEND_ALPHABLEND)!=(primBlend&BLEND_ALPHABLEND))
+	{
+		if(blend&BLEND_ALPHABLEND)pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+		else pOpenGLDevice->glBlendFunc(blend&BLEND_COLORINV?GL_ONE_MINUS_DST_COLOR:GL_SRC_ALPHA,blend&BLEND_COLORINV?GL_ZERO:GL_ONE);
+	}
+	if((blend&BLEND_ZWRITE)!=(primBlend&BLEND_ZWRITE))
+	{
+		if(blend&BLEND_ZWRITE||tdmode)pOpenGLDevice->glDepthMask(GL_TRUE);
+		else pOpenGLDevice->glDepthMask(GL_FALSE);
+	}
+	if((blend&BLEND_COLORADD)!=(primBlend&BLEND_COLORADD))
+	{
+		if(blend&BLEND_COLORADD)pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_ADD);
+		else pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
+	}
+	if((blend&BLEND_COLORINV)!=(primBlend&BLEND_COLORINV))
+	{
+		if(blend&BLEND_COLORINV)pOpenGLDevice->glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
+		else pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA,blend&BLEND_ALPHABLEND?GL_ONE_MINUS_SRC_ALPHA:GL_ONE);
+	}
+	primBlend=blend;
+}
+void SMELT_IMPL::unloadGLEntryPoints()
+{
+	#define GL_PROC(ext,fn,call,ret,params) pOpenGLDevice->fn=NULL;
+	#include "glimports.hpp"
+	#undef GL_PROC
+}
+bool SMELT_IMPL::checkGLExtension(const char *extlist,const char *ext)
+{
+	const char *ptr=strstr(extlist,ext);
+	if(ptr==NULL)return false;
+	const char endchar=ptr[strlen(ext)];
+	if((endchar=='\0')||(endchar==' '))return true;
+	return false;
+}
+bool SMELT_IMPL::loadGLEntryPoints()
+{
+	smLog("%s:" SLINE ": OpenGL: loading entry points and examining extensions...\n",GFX_SDL_SRCFN);
+	pOpenGLDevice->have_base_opengl=true;
+	pOpenGLDevice->have_GL_ARB_texture_rectangle=true;
+	pOpenGLDevice->have_GL_ARB_texture_non_power_of_two=true;
+	pOpenGLDevice->have_GL_EXT_framebuffer_object=true;
+	pOpenGLDevice->have_GL_EXT_texture_compression_s3tc=false;
+	pOpenGLDevice->have_GL_ARB_vertex_buffer_object=true;
+	pOpenGLDevice->have_GL_EXT_framebuffer_multisample=true;
+	pOpenGLDevice->have_GL_EXT_framebuffer_blit=true;
+	#define GL_PROC(ext,fn,call,ret,params) \
+		if(pOpenGLDevice->have_##ext) \
+		{ \
+			if((pOpenGLDevice->fn=(_PFN_##fn) SDL_GL_GetProcAddress(#fn))==NULL) \
+			{ \
+				smLog("%s: Failed to load OpenGL entry point '" #fn "'\n",GFX_SDL_SRCFN); \
+				pOpenGLDevice->have_##ext = false; \
+			} \
+		} else {}
+	#include "glimports.hpp"
+	#undef GL_PROC
+	if (!pOpenGLDevice->have_base_opengl)
+	{
+		unloadGLEntryPoints();
+		return false;
+	}
+	smLog("%s:" SLINE ": GL_RENDERER: %s\n",GFX_SDL_SRCFN,(const char *)pOpenGLDevice->glGetString(GL_RENDERER));
+	smLog("%s:" SLINE ": GL_VENDOR: %s\n",GFX_SDL_SRCFN,(const char *)pOpenGLDevice->glGetString(GL_VENDOR));
+	smLog("%s:" SLINE ": GL_VERSION: %s\n",GFX_SDL_SRCFN,(const char *)pOpenGLDevice->glGetString(GL_VERSION));
+	const char *verstr=(const char*)pOpenGLDevice->glGetString(GL_VERSION);
+	int maj=0,min=0;
+	sscanf(verstr,"%d.%d",&maj,&min);
+	if((maj<1)||((maj==1)&&(min<2)))
+	{
+		smLog("%s:" SLINE ": OpenGL implementation must be at least version 1.2.\n",GFX_SDL_SRCFN);
+		unloadGLEntryPoints();
+		return false;
+	}
+	const char *exts=(const char*)pOpenGLDevice->glGetString(GL_EXTENSIONS);
+	pOpenGLDevice->have_GL_ARB_texture_rectangle=
+		checkGLExtension(exts,"GL_ARB_texture_rectangle")||
+		checkGLExtension(exts,"GL_EXT_texture_rectangle")||
+		checkGLExtension(exts, "GL_NV_texture_rectangle");
+	pOpenGLDevice->have_GL_ARB_texture_non_power_of_two=
+		maj>=2||checkGLExtension(exts,"GL_ARB_texture_non_power_of_two");
+	if(pOpenGLDevice->have_GL_ARB_texture_rectangle)
+	{
+		smLog("%s:" SLINE ": OpenGL: Using GL_ARB_texture_rectangle.\n",GFX_SDL_SRCFN);
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_RECTANGLE_ARB;
+	}
+	else if(pOpenGLDevice->have_GL_ARB_texture_non_power_of_two)
+	{
+		smLog("%s:" SLINE ": OpenGL: Using GL_ARB_texture_non_power_of_two.\n",GFX_SDL_SRCFN);
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_2D;
+	}
+	else
+	{
+		smLog("%s:" SLINE ": OpenGL: Using power-of-two textures. This costs more memory!\n",GFX_SDL_SRCFN);
+		pOpenGLDevice->TextureTarget=GL_TEXTURE_2D;
+	}
+	if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+		pOpenGLDevice->have_GL_EXT_framebuffer_object=
+		checkGLExtension(exts, "GL_EXT_framebuffer_object");
+	if(pOpenGLDevice->have_GL_EXT_framebuffer_object)
+		smLog("%s:" SLINE ": OpenGL: Using GL_EXT_framebuffer_object.\n",GFX_SDL_SRCFN);
+	else
+		smLog("%s:" SLINE ": OpenGL: WARNING! No render-to-texture support. Things may render badly.\n",GFX_SDL_SRCFN);
+	if(pOpenGLDevice->have_GL_EXT_texture_compression_s3tc)
+		pOpenGLDevice->have_GL_EXT_texture_compression_s3tc=
+		checkGLExtension(exts,"GL_ARB_texture_compression")&&
+	    checkGLExtension(exts,"GL_EXT_texture_compression_s3tc");
+	if(pOpenGLDevice->have_GL_EXT_texture_compression_s3tc)
+		smLog("%s:" SLINE ": OpenGL: Using GL_EXT_texture_compression_s3tc.\n",GFX_SDL_SRCFN);
+	else if (true)
+	{
+		smLog("%s:" SLINE ": OpenGL: Texture compression disabled!\n",GFX_SDL_SRCFN);
+	}
+	if(pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+	{
+		pOpenGLDevice->have_GL_ARB_vertex_buffer_object=
+		checkGLExtension(exts,"GL_ARB_vertex_buffer_object");
+	}
+	if(pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+		smLog("%s:" SLINE ": OpenGL: Using GL_ARB_vertex_buffer_object.\n",GFX_SDL_SRCFN);
+	else
+		smLog("%s:" SLINE ": OpenGL: WARNING! No VBO support; performance may suffer.\n",GFX_SDL_SRCFN);
+	pOpenGLDevice->have_GL_EXT_framebuffer_multisample=
+		checkGLExtension(exts,"GL_EXT_framebuffer_multisample");
+	pOpenGLDevice->have_GL_EXT_framebuffer_blit=
+		checkGLExtension(exts,"GL_EXT_framebuffer_blit");
+	if(!pOpenGLDevice->have_GL_EXT_framebuffer_multisample||!pOpenGLDevice->have_GL_EXT_framebuffer_blit)
+		smLog("%s:" SLINE ": Multisampling is not supported.\n",GFX_SDL_SRCFN);
+	else
+		smLog("%s:" SLINE ": Multisampling is supported. Still experimental!\n",GFX_SDL_SRCFN);
+	return true;
+}
+bool SMELT_IMPL::initOGL()
+{
+	primTex=0;
+	if(pOpenGLDevice){smLog("%s:" SLINE ": Multiple initialization!\n",GFX_SDL_SRCFN);return false;}
+	pOpenGLDevice=new TOpenGLDevice;
+	if(!loadGLEntryPoints())return false;
+	smLog("%s:" SLINE ": Mode: %d x %d\n",GFX_SDL_SRCFN,scrw,scrh);
+	vertexArray=NULL;textures=NULL;IndexBufferObject=0;
+	if(!confOGL())return false;
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+	if(!curTarget)SDL_GL_SwapWindow((SDL_Window*)hwnd);
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+	if(!curTarget)SDL_GL_SwapWindow((SDL_Window*)hwnd);
+	return true;
+}
+void SMELT_IMPL::finiOGL()
+{
+	while(textures)smTextureFree(textures->tex);
+	while(targets)smTargetFree((SMTRG)targets);
+	textures=NULL;targets=NULL;vertexArray=NULL;
+	delete[] vertexBuf;vertexBuf=NULL;
+	delete[] indexBuf;indexBuf=NULL;
+	if(pOpenGLDevice)
+	{
+		if (pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+		{
+			if (IndexBufferObject!=0)
+			{
+				pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER,0);
+				pOpenGLDevice->glDeleteBuffersARB(1,&IndexBufferObject);
+				IndexBufferObject=0;
+			}
+		}
+		delete pOpenGLDevice;
+		pOpenGLDevice=NULL;
+	}
+}
+bool SMELT_IMPL::restOGL()
+{
+	if(!pOpenGLDevice)return false;
+	delete[] vertexBuf;vertexBuf=NULL;
+	delete[] indexBuf;indexBuf=NULL;
+	unloadGLEntryPoints();
+	if(!loadGLEntryPoints())return false;
+	if(!confOGL())return false;
+	//if()return();//TODO: rest func
+	return true;
+}
+bool SMELT_IMPL::confOGL()
+{
+	bindTexture(NULL);
+	for(TTextureList *i=textures;i;i=i->next)
+	{
+		glTexture *t=(glTexture*)i->tex;
+		if(!t)continue;t->lost=true;t->name=0;
+	}
+	TRenderTargetList *target=targets;
+	while(target)
+	{
+		glTexture *tex=(glTexture*)target->tex;
+		bindTexture(tex);bindTexture(NULL);
+		buildTarget(target,tex?tex->name:0,target->w,target->h);
+		target=target->next;
+	}
+	vertexBuf=new smVertex[VERTEX_BUFFER_SIZE];
+	indexBuf=new GLushort[VERTEX_BUFFER_SIZE*6/4];
+	GLushort* indices=indexBuf;
+	for(int i=0,n=0;i<VERTEX_BUFFER_SIZE/4;++i)
+	{
+		*indices++=n;*indices++=n+1;
+		*indices++=n+2;*indices++=n+2;
+		*indices++=n+3;*indices++=n;
+		n+=4;
+	}
+	if(pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+	{
+		pOpenGLDevice->glGenBuffersARB(1,&IndexBufferObject);
+		pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER,IndexBufferObject);
+		pOpenGLDevice->glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER,sizeof(GLushort)*((VERTEX_BUFFER_SIZE*6)/4),indexBuf,GL_STATIC_DRAW);
+	}
+	pOpenGLDevice->glVertexPointer(3,GL_FLOAT,sizeof(smVertex),&vertexBuf[0].x);
+	pOpenGLDevice->glColorPointer(4,GL_UNSIGNED_BYTE,sizeof(smVertex),&vertexBuf[0].col);
+	pOpenGLDevice->glTexCoordPointer(2,GL_FLOAT,sizeof(smVertex),&vertexBuf[0].tx);
+	pOpenGLDevice->glEnableClientState(GL_VERTEX_ARRAY);
+	pOpenGLDevice->glEnableClientState(GL_COLOR_ARRAY);
+	pOpenGLDevice->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	pOpenGLDevice->glPixelStorei(GL_UNPACK_ALIGNMENT,1);
+	pOpenGLDevice->glPixelStorei(GL_PACK_ALIGNMENT,1);
+	pOpenGLDevice->glDisable(GL_TEXTURE_2D);
+	if(pOpenGLDevice->have_GL_ARB_texture_rectangle)pOpenGLDevice->glDisable(GL_TEXTURE_RECTANGLE_ARB);
+	pOpenGLDevice->glEnable(pOpenGLDevice->TextureTarget);
+	pOpenGLDevice->glEnable(GL_SCISSOR_TEST);
+	pOpenGLDevice->glDisable(GL_CULL_FACE);
+	pOpenGLDevice->glDisable(GL_LIGHTING);
+	pOpenGLDevice->glDepthFunc(GL_GEQUAL);
+	pOpenGLDevice->glEnable(GL_DEPTH_TEST);
+	pOpenGLDevice->glEnable(GL_BLEND);
+	pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+	pOpenGLDevice->glEnable(GL_ALPHA_TEST);
+	pOpenGLDevice->glAlphaFunc(GL_GEQUAL,1.0f/255.0f);
+	pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
+	filtermode=TFLT_LINEAR;
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+	//GL_REPEAT doesn't work with non-pot textures...
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
+	primcnt=0;primType=PRIM_QUADS;primBlend=BLEND_ALPHABLEND;primTex=0;
+	pOpenGLDevice->glScissor(0,0,scrw,scrh);
+	pOpenGLDevice->glViewport(0,0,scrw,scrh);
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+	configProjectionMatrix2D(scrw,scrh);
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	pOpenGLDevice->glLoadIdentity();
+	return true;
+}
diff --git a/smelt/w32/inp_w32.cpp b/smelt/w32/inp_w32.cpp
new file mode 100644
index 0000000..b981f97
--- /dev/null
+++ b/smelt/w32/inp_w32.cpp
@@ -0,0 +1,203 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * Input manager implementation
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#include "smelt_internal.hpp"
+//static const char* INP_SDL_SRCFN="smelt/sdl/inp_w32.cpp";
+bool SMELT_IMPL::smGetInpEvent(smInpEvent *e)
+{
+	TInputEventList *eptr;
+	if(inpQueue)
+	{
+		eptr=inpQueue;memcpy(e,&eptr->e,sizeof(smInpEvent));
+		inpQueue=inpQueue->next;delete eptr;return true;
+	}
+	return false;
+}
+void SMELT_IMPL::smGetMouse2f(float *x,float *y){*x=posx,*y=posy;}
+void SMELT_IMPL::smSetMouse2f(float x,float y){SDL_WarpMouseInWindow((SDL_Window*)hwnd,x,y);}
+void SMELT_IMPL::smSetMouseGrab(bool enabled){SDL_SetRelativeMouseMode((SDL_bool)(enabled?1:0));}
+int SMELT_IMPL::smGetWheel(){return posz;}
+bool SMELT_IMPL::smIsMouseOver(){return mouseOver;}
+int SMELT_IMPL::smGetKey(){return lkey;}
+int SMELT_IMPL::smGetKeyState(int key)
+{
+	if(!(keyz[key]&4)&&keylst[key])return SMKST_RELEASE;
+	if(!(keyz[key]&4))return SMKST_NONE;
+	if((keyz[key]&4)&&!keylst[key])return SMKST_HIT;
+	return SMKST_KEEP;
+}
+
+void SMELT_IMPL::buildEvent(int type,int k,int scan,int flags,int x,int y)
+{
+	TInputEventList *last,*eptr=new TInputEventList;
+	eptr->e.type=type;eptr->e.chcode=0;
+	int ptx=x,pty=y;
+	if(type==INPUT_KEYDOWN)
+	{
+		k=SDLKeyToSMKey(k);
+		if((k<0)||(k>(int)(sizeof(keyz)/sizeof(keyz[0]))))return;
+		keyz[k]|=4;if(!(flags&SMINP_REPEAT))keyz[k]|=1;
+		eptr->e.chcode=(k>=32&&k<=127)?k:0;
+	}
+	if(type==INPUT_KEYUP)
+	{
+		k=SDLKeyToSMKey(k);
+		if((k<0)||(k>(int)(sizeof(keyz)/sizeof(keyz[0]))))return;
+		keyz[k]&=~4;keyz[k]|=2;
+		eptr->e.chcode=(k>=32&&k<=127)?k:0;
+	}
+	if(type==INPUT_MOUSEWHEEL)
+	{eptr->e.sccode=0;eptr->e.wheel=k;}
+	else{eptr->e.sccode=k;eptr->e.wheel=0;}
+	if(type==INPUT_MBUTTONDOWN){keyz[k]|=1|4;captured=true;}
+	if(type==INPUT_MBUTTONUP){keyz[k]|=2;keyz[k]&=~4;ptx=(int)posx;pty=(int)posy;captured=false;}
+	if(keymods&KMOD_SHIFT)flags|=SMINP_SHIFT;
+	if(keymods&KMOD_CTRL)flags|=SMINP_CTRL;
+	if(keymods&KMOD_ALT)flags|=SMINP_ALT;
+	if(keymods&KMOD_CAPS)flags|=SMINP_CAPSLOCK;
+	if(keymods&KMOD_MODE)flags|=SMINP_SCROLLLOCK;
+	if(keymods&KMOD_NUM)flags|=SMINP_NUMLOCK;
+	eptr->e.flag=flags;
+	if(ptx==-1){eptr->e.x=posx;eptr->e.y=posy;}
+	else
+	{
+		ptx<0?ptx=0:0;pty<0?pty=0:0;
+		ptx>=scrw?ptx=scrw-1:0;pty>=scrh?pty=scrh-1:0;
+		eptr->e.x=(float)ptx;eptr->e.y=(float)pty;
+	}
+	eptr->next=0;
+	if(!inpQueue)inpQueue=eptr;
+	else
+	{
+		last=inpQueue;
+		while(last->next)last=last->next;
+		last->next=eptr;
+	}
+	if(eptr->e.type==INPUT_KEYDOWN||eptr->e.type==INPUT_MBUTTONDOWN)
+	lkey=eptr->e.sccode;
+	if(eptr->e.type==INPUT_MOUSEMOVE)posx=eptr->e.x,posy=eptr->e.y;
+	if(eptr->e.type==INPUT_MOUSEWHEEL)posz=eptr->e.wheel;
+}
+void SMELT_IMPL::initInput(){posx=posy=.0;memset(keyz,0,sizeof(keyz));}
+void SMELT_IMPL::clearQueue()
+{
+	TInputEventList *nxt,*eptr=inpQueue;
+	for(unsigned i=0;i<sizeof(keyz)/sizeof(keyz[0]);++i)keyz[i]&=~3;
+	while(eptr){nxt=eptr->next;delete eptr;eptr=nxt;}
+	inpQueue=NULL;posz=0;lkey=0;
+}
+int SMELT_IMPL::SDLKeyToSMKey(int sdlkey)
+{
+	switch (sdlkey)
+	{
+		case SDL_SCANCODE_ESCAPE: return SMK_ESCAPE;
+		case SDL_SCANCODE_BACKSPACE: return SMK_BACKSPACE;
+		case SDL_SCANCODE_TAB: return SMK_TAB;
+		case SDL_SCANCODE_RETURN: return SMK_ENTER;
+		case SDL_SCANCODE_SPACE: return SMK_SPACE;
+		case SDL_SCANCODE_LSHIFT: return SMK_SHIFT;
+		case SDL_SCANCODE_RSHIFT: return SMK_SHIFT;
+		case SDL_SCANCODE_LCTRL: return SMK_CTRL;
+		case SDL_SCANCODE_RCTRL: return SMK_CTRL;
+		case SDL_SCANCODE_LALT: return SMK_ALT;
+		case SDL_SCANCODE_RALT: return SMK_ALT;
+		case SDL_SCANCODE_LGUI: return SMK_LWIN;
+		case SDL_SCANCODE_RGUI: return SMK_RWIN;
+		case SDL_SCANCODE_PAUSE: return SMK_PAUSE;
+		case SDL_SCANCODE_CAPSLOCK: return SMK_CAPSLOCK;
+		case SDL_SCANCODE_NUMLOCKCLEAR: return SMK_NUMLOCK;
+		case SDL_SCANCODE_SCROLLLOCK: return SMK_SCROLLLOCK;
+		case SDL_SCANCODE_PAGEUP: return SMK_PGUP;
+		case SDL_SCANCODE_PAGEDOWN: return SMK_PGDN;
+		case SDL_SCANCODE_HOME: return SMK_HOME;
+		case SDL_SCANCODE_END: return SMK_END;
+		case SDL_SCANCODE_INSERT: return SMK_INSERT;
+		case SDL_SCANCODE_DELETE: return SMK_DELETE;
+		case SDL_SCANCODE_LEFT: return SMK_LEFT;
+		case SDL_SCANCODE_UP: return SMK_UP;
+		case SDL_SCANCODE_RIGHT: return SMK_RIGHT;
+		case SDL_SCANCODE_DOWN: return SMK_DOWN;
+		case SDL_SCANCODE_0: return SMK_0;
+		case SDL_SCANCODE_1: return SMK_1;
+		case SDL_SCANCODE_2: return SMK_2;
+		case SDL_SCANCODE_3: return SMK_3;
+		case SDL_SCANCODE_4: return SMK_4;
+		case SDL_SCANCODE_5: return SMK_5;
+		case SDL_SCANCODE_6: return SMK_6;
+		case SDL_SCANCODE_7: return SMK_7;
+		case SDL_SCANCODE_8: return SMK_8;
+		case SDL_SCANCODE_9: return SMK_9;
+		case SDL_SCANCODE_A: return SMK_A;
+		case SDL_SCANCODE_B: return SMK_B;
+		case SDL_SCANCODE_C: return SMK_C;
+		case SDL_SCANCODE_D: return SMK_D;
+		case SDL_SCANCODE_E: return SMK_E;
+		case SDL_SCANCODE_F: return SMK_F;
+		case SDL_SCANCODE_G: return SMK_G;
+		case SDL_SCANCODE_H: return SMK_H;
+		case SDL_SCANCODE_I: return SMK_I;
+		case SDL_SCANCODE_J: return SMK_J;
+		case SDL_SCANCODE_K: return SMK_K;
+		case SDL_SCANCODE_L: return SMK_L;
+		case SDL_SCANCODE_M: return SMK_M;
+		case SDL_SCANCODE_N: return SMK_N;
+		case SDL_SCANCODE_O: return SMK_O;
+		case SDL_SCANCODE_P: return SMK_P;
+		case SDL_SCANCODE_Q: return SMK_Q;
+		case SDL_SCANCODE_R: return SMK_R;
+		case SDL_SCANCODE_S: return SMK_S;
+		case SDL_SCANCODE_T: return SMK_T;
+		case SDL_SCANCODE_U: return SMK_U;
+		case SDL_SCANCODE_V: return SMK_V;
+		case SDL_SCANCODE_W: return SMK_W;
+		case SDL_SCANCODE_X: return SMK_X;
+		case SDL_SCANCODE_Y: return SMK_Y;
+		case SDL_SCANCODE_Z: return SMK_Z;
+		case SDL_SCANCODE_MINUS: return SMK_MINUS;
+		case SDL_SCANCODE_EQUALS: return SMK_EQUALS;
+		case SDL_SCANCODE_BACKSLASH: return SMK_BACKSLASH;
+		case SDL_SCANCODE_LEFTBRACKET: return SMK_LBRACKET;
+		case SDL_SCANCODE_RIGHTBRACKET: return SMK_RBRACKET;
+		case SDL_SCANCODE_SEMICOLON: return SMK_SEMICOLON;
+		case SDL_SCANCODE_APOSTROPHE: return SMK_APOSTROPHE;
+		case SDL_SCANCODE_COMMA: return SMK_COMMA;
+		case SDL_SCANCODE_PERIOD: return SMK_PERIOD;
+		case SDL_SCANCODE_SLASH: return SMK_SLASH;
+		case SDL_SCANCODE_KP_0: return SMK_NUMPAD0;
+		case SDL_SCANCODE_KP_1: return SMK_NUMPAD1;
+		case SDL_SCANCODE_KP_2: return SMK_NUMPAD2;
+		case SDL_SCANCODE_KP_3: return SMK_NUMPAD3;
+		case SDL_SCANCODE_KP_4: return SMK_NUMPAD4;
+		case SDL_SCANCODE_KP_5: return SMK_NUMPAD5;
+		case SDL_SCANCODE_KP_6: return SMK_NUMPAD6;
+		case SDL_SCANCODE_KP_7: return SMK_NUMPAD7;
+		case SDL_SCANCODE_KP_8: return SMK_NUMPAD8;
+		case SDL_SCANCODE_KP_9: return SMK_NUMPAD9;
+		case SDL_SCANCODE_KP_MULTIPLY: return SMK_MULTIPLY;
+		case SDL_SCANCODE_KP_DIVIDE: return SMK_DIVIDE;
+		case SDL_SCANCODE_KP_PLUS: return SMK_ADD;
+		case SDL_SCANCODE_KP_MINUS: return SMK_SUBTRACT;
+		case SDL_SCANCODE_KP_PERIOD: return SMK_DECIMAL;
+		case SDL_SCANCODE_F1: return SMK_F1;
+		case SDL_SCANCODE_F2: return SMK_F2;
+		case SDL_SCANCODE_F3: return SMK_F3;
+		case SDL_SCANCODE_F4: return SMK_F4;
+		case SDL_SCANCODE_F5: return SMK_F5;
+		case SDL_SCANCODE_F6: return SMK_F6;
+		case SDL_SCANCODE_F7: return SMK_F7;
+		case SDL_SCANCODE_F8: return SMK_F8;
+		case SDL_SCANCODE_F9: return SMK_F9;
+		case SDL_SCANCODE_F10: return SMK_F10;
+		case SDL_SCANCODE_F11: return SMK_F11;
+		case SDL_SCANCODE_F12: return SMK_F12;
+		default: return -1;
+	}
+	return -1;
+}
diff --git a/smelt/w32/makefile b/smelt/w32/makefile
new file mode 100644
index 0000000..c68bb77
--- /dev/null
+++ b/smelt/w32/makefile
@@ -0,0 +1,29 @@
+CC= i686-w64-mingw32-g++
+CXXFLAGS= -c -g -O2 -std=c++11 -Wall -I../include -D_WIN32 -fPIC
+
+all: objects-normal archive-normal
+
+dumb: objects-dumb archive-dumb
+
+objects-normal: gfx inp sfx sys
+
+objects-dumb: gfx inp sfx-dumb sys
+
+gfx:
+	$(CC) gfx_d3d.cpp $(CXXFLAGS)
+sfx:
+	$(CC) sfx_w32.cpp $(CXXFLAGS)
+sfx-dumb:
+	$(CC) sfx_dumb.cpp $(CXXFLAGS)
+inp:
+	$(CC) inp_w32.cpp $(CXXFLAGS)
+sys:
+	$(CC) sys_w32.cpp $(CXXFLAGS)
+archive-normal:
+	$(AR) rcs libsmelt.a gfx_d3d.o sfx_w32.o inp_w32.o sys_w32.o
+archive-dumb:
+	$(AR) rcs libsmelt-dumb.a gfx_d3d.o sfx_dumb.o inp_w32.o sys_w32.o
+clean:
+	rm -f *.o
+clean-all: clean
+	rm *.a
\ No newline at end of file
diff --git a/smelt/w32/sfx_dumb.cpp b/smelt/w32/sfx_dumb.cpp
new file mode 100644
index 0000000..4e7a277
--- /dev/null
+++ b/smelt/w32/sfx_dumb.cpp
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * SFX dumb implementation
+ * This dumb implementation has everything stubbed, useful if you don't
+ * use the audio routines here.
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#include "smelt_internal.hpp"
+
+static const char* SFX_SDL_SRCFN="smelt/sdl/sfx_dumb.cpp";
+
+SMSFX SMELT_IMPL::smSFXLoad(const char *path)
+{return 0;}
+SMSFX SMELT_IMPL::smSFXLoadFromMemory(const char *ptr,DWORD size)
+{return 0;}
+SMCHN SMELT_IMPL::smSFXPlay(SMSFX fx,int vol,int pan,float pitch,bool loop)
+{return 0;}
+float SMELT_IMPL::smSFXGetLengthf(SMSFX fx)
+{return 0.0;}
+DWORD SMELT_IMPL::smSFXGetLengthd(SMSFX fx)
+{return -1;}
+void SMELT_IMPL::smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r)
+{}
+void SMELT_IMPL::smSFXFree(SMSFX fx)
+{}
+void SMELT_IMPL::smChannelVol(SMCHN chn,int vol)
+{}
+void SMELT_IMPL::smChannelPan(SMCHN chn,int pan)
+{}
+void SMELT_IMPL::smChannelPitch(SMCHN chn,float pitch)
+{}
+void SMELT_IMPL::smChannelPause(SMCHN chn)
+{}
+void SMELT_IMPL::smChannelResume(SMCHN chn)
+{}
+void SMELT_IMPL::smChannelStop(SMCHN chn)
+{}
+void SMELT_IMPL::smChannelPauseAll()
+{}
+void SMELT_IMPL::smChannelResumeAll()
+{}
+void SMELT_IMPL::smChannelStopAll()
+{}
+bool SMELT_IMPL::smChannelIsPlaying(SMCHN chn)
+{return false;}
+float SMELT_IMPL::smChannelGetPosf(SMCHN chn)
+{return -1.;}
+void SMELT_IMPL::smChannelSetPosf(SMCHN chn,float pos)
+{}
+int SMELT_IMPL::smChannelGetPosd(SMCHN chn)
+{return -1;}
+void SMELT_IMPL::smChannelSetPosd(SMCHN chn,int pos)
+{}
+
+ALuint SMELT_IMPL::getSource()
+{return 0;}
+bool SMELT_IMPL::initOAL()
+{
+	smLog("%s:" SLINE ": I'm dumb!\n",SFX_SDL_SRCFN);
+	pOpenALDevice=(void*)1;
+	return true;
+}
+void SMELT_IMPL::finiOAL()
+{
+	if(pOpenALDevice)
+	{
+		pOpenALDevice=NULL;
+	}
+}
diff --git a/smelt/w32/sfx_w32.cpp b/smelt/w32/sfx_w32.cpp
new file mode 100644
index 0000000..c49162a
--- /dev/null
+++ b/smelt/w32/sfx_w32.cpp
@@ -0,0 +1,356 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * GFX implementation based on OpenAL
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#include "smelt_internal.hpp"
+
+static const char* SFX_SDL_SRCFN="smelt/sdl/sfx_sdl.cpp";
+struct oggdata{const BYTE *data;DWORD size,pos;};
+static void* readVorbis(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq);
+static void* readRiffWv(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq);
+SMSFX SMELT_IMPL::smSFXLoad(const char *path)
+{
+	FILE *pFile;DWORD size,rsize; char *buff;
+	pFile=fopen(path,"rb");
+	if(!pFile)return 0;
+	fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile);
+	buff=(char*)malloc(sizeof(char)*size);
+	if(!buff)return 0;
+	rsize=fread(buff,1,size,pFile);
+	if(rsize!=size)return 0;
+	SMSFX ret=smSFXLoadFromMemory(buff,size);
+	free(buff);
+	fclose(pFile);
+	return ret;
+}
+SMSFX SMELT_IMPL::smSFXLoadFromMemory(const char *ptr,DWORD size)
+{
+	if(pOpenALDevice&&!mute)
+	{
+		bool isOgg=size>4&&ptr[0]=='O'&&ptr[1]=='g'&&ptr[2]=='g'&&ptr[3]=='S';
+		void *decompdata=NULL,*decomp=NULL;
+		ALsizei decompsize=0,freq=0;
+		ALenum fmt=AL_FORMAT_STEREO16;
+		decompdata=readRiffWv((const BYTE*)ptr,size,&decompsize,&fmt,&freq);
+		if(!decompdata)
+		{
+			if(!isOgg)return 0;
+			else decompdata=readVorbis((const BYTE*)ptr,size,&decompsize,&fmt,&freq);
+		}
+		if(!decompdata)return 0;
+		decomp=decompdata;
+		ALuint buff=0;alGenBuffers(1,&buff);
+		alBufferData(buff,fmt,decomp,decompsize,freq);
+		free(decompdata);return(SMSFX)buff;
+	}
+	return 0;
+}
+SMCHN SMELT_IMPL::smSFXPlay(SMSFX fx,int vol,int pan,float pitch,bool loop)
+{
+	if(pOpenALDevice)
+	{
+		ALuint src=getSource();
+		if(src)
+		{
+			if(vol<0)vol=0;if(vol>100)vol=100;
+			if(pan<-100)pan=-100;if(pan>100)pan=100;
+			alSourceStop(src);
+			alSourcei(src,AL_BUFFER,(ALint)fx);
+			alSourcef(src,AL_GAIN,((ALfloat)vol)/100.);
+			alSourcef(src,AL_PITCH,pitch);
+			alSource3f(src,AL_POSITION,((ALfloat)pan)/100.,.0,.0);
+			alSourcei(src,AL_LOOPING,loop?AL_TRUE:AL_FALSE);
+			alSourcePlay(src);
+		}
+		return src;
+	}
+	return 0;
+}
+float SMELT_IMPL::smSFXGetLengthf(SMSFX fx)
+{
+	ALuint buff=(ALuint)fx;
+	ALint freq;
+	DWORD lend=smSFXGetLengthd(fx);
+	alGetBufferi(buff,AL_FREQUENCY,&freq);
+	float ret=lend/(float)freq;
+	return ret;
+}
+DWORD SMELT_IMPL::smSFXGetLengthd(SMSFX fx)
+{
+	if(pOpenALDevice)
+	{
+		ALint size_b,chnc,bit;
+		ALuint buff=(ALuint)fx;
+		alGetBufferi(buff,AL_SIZE,&size_b);
+		alGetBufferi(buff,AL_CHANNELS,&chnc);
+		alGetBufferi(buff,AL_BITS,&bit);
+		DWORD ret=size_b*8/(chnc*bit);
+		return ret;
+	}
+	return -1;
+}
+void SMELT_IMPL::smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r)
+{
+	if(pOpenALDevice)
+	{
+		ALint pt[2];pt[0]=l;pt[1]=r;
+		alBufferiv((ALuint)fx,AL_LOOP_POINTS_SOFT,pt);
+	}
+}
+void SMELT_IMPL::smSFXFree(SMSFX fx)
+{
+	if(pOpenALDevice)
+	{
+		ALuint buff=(ALuint)fx;
+		alDeleteBuffers(1,&buff);
+	}
+}
+void SMELT_IMPL::smChannelVol(SMCHN chn,int vol)
+{
+	if(pOpenALDevice)
+	{
+		if(vol<0)vol=0;if(vol>100)vol=100;
+		alSourcef((ALuint)chn,AL_GAIN,((ALfloat)vol)/100.);
+	}
+}
+void SMELT_IMPL::smChannelPan(SMCHN chn,int pan)
+{
+	if(pOpenALDevice)
+	{
+		if(pan<-100)pan=-100;if(pan>100)pan=100;
+		alSource3f((ALuint)chn,AL_POSITION,((ALfloat)pan)/100.,.0,.0);
+	}
+}
+void SMELT_IMPL::smChannelPitch(SMCHN chn,float pitch)
+{
+	if(pOpenALDevice)alSourcef((ALuint)chn,AL_PITCH,pitch);
+}
+void SMELT_IMPL::smChannelPause(SMCHN chn)
+{
+	if(pOpenALDevice)alSourcePause((ALuint)chn);
+}
+void SMELT_IMPL::smChannelResume(SMCHN chn)
+{
+	if(pOpenALDevice)alSourcePlay((ALuint)chn);
+}
+void SMELT_IMPL::smChannelStop(SMCHN chn)
+{
+	if(pOpenALDevice)alSourceStop((ALuint)chn);
+}
+void SMELT_IMPL::smChannelPauseAll()
+{
+	if(pOpenALDevice)
+	{
+		ALCcontext *ctx=alcGetCurrentContext();
+		alcSuspendContext(ctx);
+	}
+}
+void SMELT_IMPL::smChannelResumeAll()
+{
+	if(pOpenALDevice)
+	{
+		ALCcontext *ctx=alcGetCurrentContext();
+		alcProcessContext(ctx);
+	}
+}
+void SMELT_IMPL::smChannelStopAll()
+{
+	if(pOpenALDevice)
+	{
+		for(int i=0;i<scnt;++i)alSourceStop(src[i]);
+	}
+}
+bool SMELT_IMPL::smChannelIsPlaying(SMCHN chn)
+{
+	if(pOpenALDevice)
+	{
+		ALint state=AL_STOPPED;
+		alGetSourceiv((ALuint)chn,AL_SOURCE_STATE,&state);
+		return state==AL_PLAYING;
+	}
+	return false;
+}
+float SMELT_IMPL::smChannelGetPosf(SMCHN chn)
+{
+	if(pOpenALDevice)
+	{
+		ALfloat ret;
+		alGetSourcef((ALuint)chn,AL_SEC_OFFSET,&ret);
+		return (float)ret;
+	}
+	return -1.;
+}
+void SMELT_IMPL::smChannelSetPosf(SMCHN chn,float pos)
+{
+	if(pOpenALDevice)alSourcef((ALuint)chn,AL_SEC_OFFSET,(ALfloat)pos);
+}
+int SMELT_IMPL::smChannelGetPosd(SMCHN chn)
+{
+	if(pOpenALDevice)
+	{
+		ALint ret;
+		alGetSourcei((ALuint)chn,AL_SAMPLE_OFFSET,&ret);
+		return (int)ret;
+	}
+	return -1;
+}
+void SMELT_IMPL::smChannelSetPosd(SMCHN chn,int pos)
+{
+	if(pOpenALDevice)alSourcei((ALuint)chn,AL_SAMPLE_OFFSET,(ALint)pos);
+}
+
+static size_t oggRead(void *ptr,size_t size,size_t nmemb,void *ds)
+{
+	oggdata *data=(oggdata*)ds;
+	const DWORD avail=data->size-data->pos;
+	size_t want=nmemb*size;
+	if(want>avail)want=avail-(avail%size);
+	if(want>0)
+	{
+		memcpy(ptr,data->data+data->pos,want);
+		data->pos+=want;
+	}
+	return want/size;
+}
+static int oggSeek(void *ds,ogg_int64_t offset,int whence)
+{
+	oggdata *data=(oggdata*)ds;
+	ogg_int64_t pos=0;
+	switch(whence)
+	{
+		case SEEK_SET:pos=offset;break;
+		case SEEK_CUR:pos=((ogg_int64_t)data->pos)+offset;break;
+		case SEEK_END:pos=((ogg_int64_t)data->size)+offset;break;
+		default: return -1;
+	}
+	if((pos<0)||(pos>((ogg_int64_t)data->size)))return -1;
+	data->pos=(DWORD)pos;
+	return 0;
+}
+static long oggLocate(void *ds)
+{
+	oggdata* data=(oggdata*)ds;
+	return (long)data->pos;
+}
+static int oggClose(void *ds){return 0;}
+
+static ov_callbacks oggrt={oggRead,oggSeek,oggClose,oggLocate};
+static void* readVorbis(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq)
+{
+	oggdata adata={data,size,0};
+	OggVorbis_File vf;
+	memset(&vf,0,sizeof(vf));
+	if(ov_open_callbacks(&adata,&vf,NULL,0,oggrt)==0)
+	{
+		int bs=0;
+		vorbis_info *info=ov_info(&vf,-1);
+		*decomp_size=0;
+		*fmt=(info->channels==1)?AL_FORMAT_MONO16:AL_FORMAT_STEREO16;
+		*freq=info->rate;
+		if(!(info->channels==1||info->channels==2)){ov_clear(&vf);return NULL;}
+		char buf[1024*16];long rc=0;size_t allocated=1024*16;
+		BYTE *ret=(ALubyte*)malloc(allocated);
+		while((rc=ov_read(&vf,buf,sizeof(buf),0,2,1,&bs))!=0)
+		{
+			if(rc>0)
+			{
+				*decomp_size+=rc;
+				if((unsigned)*decomp_size>=allocated)
+				{
+					allocated<<=1;
+					ALubyte *tmp=(ALubyte*)realloc(ret,allocated);
+					if(!tmp){free(ret);ret=NULL;break;}
+					ret=tmp;
+				}
+				memcpy(ret+(*decomp_size-rc),buf,rc);
+			}
+		}
+		ov_clear(&vf);
+		return ret;
+	}
+	return NULL;
+}
+static void* readRiffWv(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq)
+{
+	if(data[0x0]!='R'||data[0x1]!='I'||data[0x2]!='F'||data[0x3]!='F')return NULL;
+	if(data[0x8]!='W'||data[0x9]!='A'||data[0xA]!='V'||data[0xB]!='E')return NULL;
+	if(data[0xC]!='f'||data[0xD]!='m'||data[0xE]!='t'||data[0xF]!=' ')return NULL;
+	if(data[0x16]==2)
+	{
+		if(data[0x22]==16)*fmt=AL_FORMAT_STEREO16;
+		else if(data[0x22]==8)*fmt=AL_FORMAT_STEREO8;
+		else return NULL;
+	}
+	else if(data[0x16]==1)
+	{
+		if(data[0x22]==16)*fmt=AL_FORMAT_MONO16;
+		else if(data[0x22]==8)*fmt=AL_FORMAT_MONO8;
+		else return NULL;
+	}else return NULL;
+	*decomp_size=(ALsizei)(data[0x28]|(data[0x29]<<8L)|(data[0x2A]<<16L)|(data[0x2B]<<24L));
+	*freq=(ALsizei)(data[0x18]|(data[0x19]<<8L)|(data[0x1A]<<16L)|(data[0x1B]<<24L));
+	ALubyte *ret=(ALubyte*)malloc(*decomp_size);
+	memcpy(ret,data+44,*decomp_size);
+	return ret;
+}
+ALuint SMELT_IMPL::getSource()
+{
+	for(int i=0;i<scnt;++i)
+	{
+		ALint state=AL_PLAYING;
+		alGetSourceiv(src[i],AL_SOURCE_STATE,&state);
+		if(!(state==AL_PLAYING||state==AL_PAUSED))return src[i];
+	}
+	if(scnt>=SRC_MAX)return 0;
+	ALuint ret=0;
+	alGenSources(1,&ret);if(!ret)return 0;
+	src[scnt++]=ret;return ret;
+}
+bool SMELT_IMPL::initOAL()
+{
+	if(pOpenALDevice)return true;
+	scnt=0;memset(src,0,sizeof(src));
+	smLog("%s:" SLINE ": Initializing OpenAL...\n",SFX_SDL_SRCFN);
+	ALCdevice *dev=alcOpenDevice(NULL);
+	if(!dev)
+	{
+		smLog("%s:" SLINE ": alcOpenDevice() failed.\n",SFX_SDL_SRCFN);
+		return mute=true;
+	}
+	ALint caps[]={ALC_FREQUENCY,44100,0};
+	ALCcontext *ctx=alcCreateContext(dev,caps);
+	if(!ctx)
+	{
+		smLog("%s:" SLINE ": alcCreateContext() failed.\n",SFX_SDL_SRCFN);
+		return mute=true;
+	}
+	alcMakeContextCurrent(ctx);alcProcessContext(ctx);
+	smLog("%s:" SLINE ": Done OpenAL initialization\n",SFX_SDL_SRCFN);
+	smLog("%s:" SLINE ": AL_VENDOR: %s\n",SFX_SDL_SRCFN,(char*)alGetString(AL_VENDOR));
+	smLog("%s:" SLINE ": AL_RENDERER: %s\n",SFX_SDL_SRCFN,(char*)alGetString(AL_RENDERER));
+	smLog("%s:" SLINE ": AL_VERSION: %s\n",SFX_SDL_SRCFN,(char*)alGetString(AL_VERSION));
+	const char* ext=(const char*)alGetString(AL_EXTENSIONS);
+	lpp=strstr(ext,"AL_SOFT_loop_points")!=NULL;
+	if(!lpp)smLog("%s:" SLINE ": Warning: loop points not supported. Please recompile with OpenAL Soft.\n",SFX_SDL_SRCFN);
+	pOpenALDevice=(void*)dev;
+	return true;
+}
+void SMELT_IMPL::finiOAL()
+{
+	if(pOpenALDevice)
+	{
+		for(int i=0;i<scnt;++i)alSourceStop(src[i]);
+		alDeleteSources(scnt,src);scnt=0;memset(src,0,sizeof(src));
+		ALCcontext *ctx=alcGetCurrentContext();
+		ALCdevice *dev=alcGetContextsDevice(ctx);
+		alcMakeContextCurrent(NULL);
+		alcSuspendContext(ctx);alcDestroyContext(ctx);
+		alcCloseDevice(dev);pOpenALDevice=NULL;
+	}
+}
diff --git a/smelt/w32/smelt_config.hpp b/smelt/w32/smelt_config.hpp
new file mode 100644
index 0000000..4400ae3
--- /dev/null
+++ b/smelt/w32/smelt_config.hpp
@@ -0,0 +1,20 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * Configuration header for Windows version
+ *
+ * Modify this header according to your own requirements.
+ *
+ */
+
+/*
+ * Maximum audio channels.
+ * (How many audio can be played simultaneously?)
+ */
+#define SRC_MAX 128
+
+/*
+ * Client-side vertex buffer size.
+ */
+#define VERTEX_BUFFER_SIZE 4000
diff --git a/smelt/w32/smelt_internal.hpp b/smelt/w32/smelt_internal.hpp
new file mode 100644
index 0000000..3698ae8
--- /dev/null
+++ b/smelt/w32/smelt_internal.hpp
@@ -0,0 +1,237 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * Internal header for Windows version
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#ifndef SMELT_INTERNAL_H
+#define SMELT_INTERNAL_H
+
+#include "../../include/smelt.hpp"
+#include "smelt_config.hpp"
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <ctime>
+#include <cstdarg>
+#include <d3d9.h>
+#include <d3dx9.h>
+#include <AL/al.h>
+#include <AL/alc.h>
+#include <AL/alext.h>
+#include <ogg/ogg.h>
+#include <vorbis/vorbisfile.h>
+#ifdef _WIN32
+#include <intrin.h>
+#endif
+
+#define xstr(s) str(s)
+#define str(s) #s
+#define SLINE xstr(__LINE__)
+
+#define D3DFVF_SMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
+
+class TRenderTargetList
+{
+public:
+	int w,h,ms;
+	IDirect3DTexture9* tex;
+	IDirect3DSurface9*	pDepth;
+	TRenderTargetList *next;
+};
+class TTextureList
+{
+public:
+	SMTEX tex;
+	int w,h;
+	TTextureList *next;
+};
+class TInputEventList
+{
+public:
+	smInpEvent e;
+	TInputEventList *next;
+};
+
+class SMELT_IMPL:public SMELT
+{
+public:
+	virtual void smRelease();
+	virtual bool smInit();
+	virtual void smFinale();
+	virtual void smMainLoop();
+	virtual void smUpdateFunc(smHook func);
+	virtual void smUpdateFunc(smHandler* h);
+	virtual void smUnFocFunc(smHook func);
+	virtual void smUnFocFunc(smHandler* h);
+	virtual void smFocFunc(smHook func);
+	virtual void smFocFunc(smHandler* h);
+	virtual void smQuitFunc(smHook func);
+	virtual void smQuitFunc(smHandler* h);
+	virtual void smWinTitle(const char* title);
+	virtual bool smIsActive();
+	virtual void smNoSuspend(bool para);
+	virtual void smVidMode(int resX,int resY,bool _windowed);
+	virtual void smLogFile(const char* path);
+	virtual void smLog(const char* format,...);
+	virtual void smScreenShot(const char* path);
+
+	virtual void smSetFPS(int fps);
+	virtual float smGetFPS();
+	virtual float smGetDelta();
+	virtual float smGetTime();
+
+	virtual SMSFX smSFXLoad(const char *path);
+	virtual SMSFX smSFXLoadFromMemory(const char *ptr,DWORD size);
+	virtual SMCHN smSFXPlay(SMSFX fx,int vol=100,int pan=0,float pitch=1.,bool loop=0);
+	virtual float smSFXGetLengthf(SMSFX fx);
+	virtual DWORD smSFXGetLengthd(SMSFX fx);
+	virtual void smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r);
+	virtual void smSFXFree(SMSFX fx);
+
+	virtual void smChannelVol(SMCHN chn,int vol);
+	virtual void smChannelPan(SMCHN chn,int pan);
+	virtual void smChannelPitch(SMCHN chn,float pitch);
+	virtual void smChannelPause(SMCHN chn);
+	virtual void smChannelResume(SMCHN chn);
+	virtual void smChannelStop(SMCHN chn);
+	virtual void smChannelPauseAll();
+	virtual void smChannelResumeAll();
+	virtual void smChannelStopAll();
+	virtual bool smChannelIsPlaying(SMCHN chn);
+	virtual float smChannelGetPosf(SMCHN chn);
+	virtual void smChannelSetPosf(SMCHN chn,float pos);
+	virtual int smChannelGetPosd(SMCHN chn);
+	virtual void smChannelSetPosd(SMCHN chn,int pos);
+
+	virtual void smGetMouse2f(float *x,float *y);
+	virtual void smSetMouse2f(float x,float y);
+	virtual void smSetMouseGrab(bool enabled);
+	virtual int smGetWheel();
+	virtual bool smIsMouseOver();
+	virtual int smGetKeyState(int key);
+	virtual int smGetKey();
+	virtual bool smGetInpEvent(smInpEvent *e);
+
+	virtual bool smRenderBegin2D(bool ztest=0,SMTRG trg=0);
+	virtual bool smRenderBegin3D(float fov,bool ztest=0,SMTRG trg=0);
+	virtual bool smRenderEnd();
+	virtual void sm3DCamera6f2v(float *pos,float *rot);
+	virtual void sm2DCamera5f3v(float *pos,float *dpos,float *rot);
+	virtual void smMultViewMatrix(float *mat);
+	virtual void smClrscr(DWORD color,bool clearcol=true,bool cleardep=true);
+	virtual void smRenderLinefd(float x1,float y1,float z1,float x2,float y2,float z2,DWORD color);
+	virtual void smRenderLinefvd(float *p1,float *p2,DWORD color);
+	virtual void smRenderTriangle(smTriangle *t);
+	virtual void smRenderQuad(smQuad *q);
+	virtual smVertex* smGetVertArray();
+	virtual void smDrawVertArray(int prim,SMTEX texture,int blend,int _primcnt);
+	virtual void smDrawCustomIndexedVertices(smVertex* vb,WORD* ib,int vbc,int ibc,int blend,SMTEX texture);
+
+	virtual SMTRG smTargetCreate(int w,int h,int ms=0);
+	virtual SMTEX smTargetTexture(SMTRG targ);
+	virtual void smTargetFree(SMTRG targ);
+
+	virtual SMTEX smTextureCreate(int w,int h);
+	virtual SMTEX smTextureLoad(const char *path);
+	virtual SMTEX smTextureLoadFromMemory(const char *ptr,DWORD size);
+	virtual void smTextureFree(SMTEX tex);
+	virtual void smTextureOpt(int potopt=TPOT_NONPOT,int filter=TFLT_LINEAR);
+	virtual int smTextureGetWidth(SMTEX tex,bool original=false);
+	virtual int smTextureGetHeight(SMTEX tex,bool original=false);
+	virtual DWORD* smTextureLock(SMTEX tex,int l,int t,int w,int h,bool ro=true);
+	virtual void smTexutreUnlock(SMTEX tex);
+//internal routines&variables...
+	static SMELT_IMPL* getInterface();
+	void focusChange(bool actif);
+
+	HINSTANCE hinstance;
+	HWND *hwnd;
+	bool Active;
+	char curError[256];
+
+	bool (*pUpdateFunc)();
+	bool (*pUnFocFunc)();
+	bool (*pFocFunc)();
+	bool (*pQuitFunc)();
+	smHandler *updateHandler,*unFocHandler,*focHandler,*quitHandler;
+	const char *Icon;
+	char winTitle[256];
+	int scrw,scrh;
+	int dispw,disph;
+	bool windowed,vsync;
+	char logFile[256];
+	int limfps;
+	bool hideMouse,noSuspend;
+
+	D3DPRESENT_PARAMETERS* d3dpp;
+	D3DPRESENT_PARAMETERS d3dppW;
+	RECT rectW;
+	LONG styleW;
+
+	D3DPRESENT_PARAMETERS d3dppFS;
+	RECT rectFS;
+	LONG styleFS;
+	IDirect3D9* pD3D;
+	IDirect3DDevice9* pD3DDevice;
+	IDirect3DVertexBuffer9* vertBuf;
+	smVertex* vertArr;
+	IDirect3DIndexBuffer9* indexBuf;
+	IDirect3DSurface9* pScreenSurf;
+	IDirect3DSurface9* pScreenDepth;
+	TRenderTargetList *targets;
+	TRenderTargetList *curTarget;
+	TTextureList *textures;
+	D3DXMATRIX matModView;
+	D3DXMATRIX matProj;
+	bool tdmode;
+	int primcnt,primType,primBlend,filtermode;
+	SMTEX primTex;
+	bool zbufenabled;
+	bool initD3D();
+	void finiD3D();
+	bool restD3D();
+	bool confD3D();
+	void batchD3D(bool endScene=false);
+	void configTexture(glTexture *t,int w,int h,DWORD *px,bool compress=true);
+	void bindTexture(glTexture *t);
+	bool buildTarget(TRenderTargetList *pTarget,GLuint texid,int w,int h,int ms);
+	SMTEX buildTexture(int w,int h,DWORD *px);
+	void setBlend(int blend);
+	void configProjectionMatrix2D(int w,int h);
+	void configProjectionMatrix3D(int w,int h,float fov);
+	DWORD* decodeImage(BYTE *data,const char *fn,DWORD size,int &w,int &h);
+
+	void *pOpenALDevice;
+	bool initOAL();
+	void finiOAL();
+	bool mute,lpp;
+	int scnt;
+	ALuint src[SRC_MAX];
+	ALuint getSource();
+
+	int posz,lkey;
+	float posx,posy;
+	bool mouseOver,captured;
+	char keyz[256];
+	bool keylst[256];
+	TInputEventList *inpQueue;
+	void initInput();
+	void clearQueue();
+	void buildEvent(int type,int k,int scan,int flags,int x,int y);
+	bool procSDLEvent(const SDL_Event &e);
+	int SDLKeyToSMKey(int sdlkey);
+
+	float timeDelta,updateFPSDelay,fps,timeS;
+	DWORD fixDelta,t0;
+	int fcnt;
+	DWORD dt;
+private:
+	SMELT_IMPL();
+};
+extern SMELT_IMPL *pSM;
+#endif
diff --git a/smelt/w32/sys_w32.cpp b/smelt/w32/sys_w32.cpp
new file mode 100644
index 0000000..716a039
--- /dev/null
+++ b/smelt/w32/sys_w32.cpp
@@ -0,0 +1,355 @@
+// -*- C++ -*-
+/*
+ * Simple MultimEdia LiTerator(SMELT)
+ * by Chris Xiong 2015
+ * SMELT system implementation
+ *
+ * WARNING: This library is in development and interfaces would be very
+ * unstable.
+ *
+ */
+#include "smelt_internal.hpp"
+static const char* SYS_SDL_SRCFN="smelt/sdl/sys_w32.cpp";
+int refcnt=0;
+SMELT_IMPL *pSM=0;
+
+SMELT* smGetInterface(int apilevel)
+{
+	if(apilevel==SMELT_APILEVEL)
+	return(SMELT*)SMELT_IMPL::getInterface();
+	else return 0;
+}
+
+SMELT_IMPL* SMELT_IMPL::getInterface()
+{
+	if(!pSM)pSM=new SMELT_IMPL();
+	++refcnt;return pSM;
+}
+
+void SMELT_IMPL::smRelease()
+{
+	--refcnt;
+	if(!refcnt)
+	{
+		if(pSM->hwnd)pSM->smFinale();
+		delete pSM;pSM=0;
+	}
+}
+
+bool SMELT_IMPL::smInit()
+{
+	smLog("%s:" SLINE ": Initalizing SMELT...\n",SYS_SDL_SRCFN);
+	smLog("%s:" SLINE ": SMELT api version %d\n",SYS_SDL_SRCFN,SMELT_APILEVEL);
+	time_t t=time(NULL);
+	smLog("%s:" SLINE ": Date %s",SYS_SDL_SRCFN,asctime(localtime(&t)));
+#ifdef WIN32
+	OSVERSIONINFO os_ver; MEMORYSTATUS mem_st;
+	os_ver.dwOSVersionInfoSize=sizeof(os_ver);
+	GetVersionEx(&os_ver);
+	smLog("%s:" SLINE ": OS: Windows %ld.%ld.%ld\n", SYS_SDL_SRCFN,os_ver.dwMajorVersion,os_ver.dwMinorVersion,os_ver.dwBuildNumber);
+
+	int CPUInfo[4]={-1};
+	__cpuid(CPUInfo,0x80000000);
+	unsigned int nExIds=CPUInfo[0];
+	char *cpuName,*loced;cpuName=calloc(0x40,sizeof(char));loced=cpuName;
+	for(unsigned int i=0x80000000;i<=nExIds;++i)
+	{
+		__cpuid(CPUInfo, i);
+		if(i==0x80000002)
+			memcpy(cpuName,CPUInfo,sizeof(CPUInfo));
+		else if(i==0x80000003)
+			memcpy(cpuName+16,CPUInfo,sizeof(CPUInfo));
+		else if(i==0x80000004)
+		memcpy(cpuName+32, CPUInfo, sizeof(CPUInfo));
+	}
+	while(*cpuName=' ')++cpuName;
+	smLog("%s:" SLINE ": CPU: %s\n", SYS_SDL_SRCFN,cpuName);
+	free(loced);
+
+	GlobalMemoryStatus(&mem_st);
+	smLog("%s:" SLINE ": Memory: %ldK total, %ldK free\n", SYS_SDL_SRCFN,mem_st.dwTotalPhys/1024L,mem_st.dwAvailPhys/1024L);
+#else
+	system("uname -svm > /tmp/os.out");
+	char osv[100];FILE* a=fopen("/tmp/os.out","r");fgets(osv,100,a);fclose(a);
+	osv[strlen(osv)-1]='\0';
+	smLog("%s:" SLINE ": OS: %s\n",SYS_SDL_SRCFN,osv);
+	system("rm /tmp/os.out");
+
+	system("cat /proc/cpuinfo | grep name -m 1 > /tmp/cpu.out");
+	a=fopen("/tmp/cpu.out","r");fgets(osv,100,a);fclose(a);
+	osv[strlen(osv)-1]='\0';char *ptr=osv;while(*ptr!=':')++ptr;ptr+=2;
+	smLog("%s:" SLINE ": CPU: %s\n",SYS_SDL_SRCFN,osv);
+	system("rm /tmp/cpu.out");
+
+	a=fopen("/proc/meminfo","r");
+	unsigned totalm,freem;
+	fscanf(a,"MemTotal: %u kB\n",&totalm);
+	fscanf(a,"MemFree: %u kB\n",&freem);
+	smLog("%s:" SLINE ": RAM: %ukB installed, %ukB free\n",SYS_SDL_SRCFN,totalm,freem);
+	fclose(a);
+#endif
+	if(SDL_Init(SDL_INIT_VIDEO)==-1)
+	{
+		smLog("%s:" SLINE ": SDL_Init() failed with error %s\n",SYS_SDL_SRCFN,SDL_GetError());
+		return false;
+	}
+	if(SDL_GL_LoadLibrary(NULL)==-1)
+	{
+		smLog("%s:" SLINE ": SDL_GL_LoadLibrary() failed with error %s\n",SYS_SDL_SRCFN,SDL_GetError());
+		return false;
+	}
+	SDL_DisplayMode vidinfo;
+	if(SDL_GetDesktopDisplayMode(0,&vidinfo))
+	{
+		smLog("%s:" SLINE ": SDL_GetDesktopDisplayMode() failed with error %s\n",SYS_SDL_SRCFN,SDL_GetError());
+		SDL_Quit();
+		return false;
+	}
+	dispw=vidinfo.w;disph=vidinfo.h;
+	smLog("%s:" SLINE ": Screen: %d x %d\n",SYS_SDL_SRCFN,dispw,disph);
+	Uint32 flags=SDL_WINDOW_OPENGL;
+	if(!windowed)flags|=SDL_WINDOW_FULLSCREEN;
+	SDL_Window *screen=SDL_CreateWindow(winTitle,SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,scrw,scrh,flags);
+	hwnd=(void*)screen;
+	glContext=SDL_GL_CreateContext(screen);
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
+	SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,1);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
+	SDL_GL_SetSwapInterval(vsync?1:0);
+	if(!hwnd)
+	{
+		smLog("%s:" SLINE ": SDL_CreateWindow() failed with error %s\n",SYS_SDL_SRCFN,SDL_GetError());
+		SDL_Quit();
+		return false;
+	}
+	if(!windowed)
+	{
+		mouseOver=true;
+		if(!pSM->Active)pSM->focusChange(true);
+	}
+	SDL_ShowCursor(hideMouse?SDL_DISABLE:SDL_ENABLE);
+	initInput();
+	if(!initOGL()){smFinale();return false;}
+	if(!initOAL()){smFinale();return false;}
+	t0=SDL_GetTicks();dt=fcnt=0;fps=.0;
+	updateFPSDelay=.0;
+	return true;
+}
+
+void SMELT_IMPL::smFinale()
+{
+	smLog("%s:" SLINE ": Cleaning up...\n",SYS_SDL_SRCFN);
+	clearQueue();finiOAL();finiOGL();
+	SDL_GL_UnloadLibrary();SDL_Quit();hwnd=0;
+}
+
+void SMELT_IMPL::smMainLoop()
+{
+	if(!hwnd)return smLog("%s:" SLINE ": Error: SMELT is not initialized.\n",SYS_SDL_SRCFN);
+	if(!pUpdateFunc&&!updateHandler) return smLog("%s:" SLINE ": UpdateFunc is not defined.\n",SYS_SDL_SRCFN);
+	Active=true;
+	for(;;)
+	{
+		SDL_Event e;
+		bool loopcont=true;
+		while(SDL_PollEvent(&e)&&loopcont)loopcont=procSDLEvent(e);
+		if(!loopcont)break;
+		if(Active||noSuspend)
+		{
+			Uint32 sdlticks;
+			do{sdlticks=SDL_GetTicks();dt=sdlticks-t0;}while(dt<1);
+			if(dt>=fixDelta)
+			{
+				timeDelta=dt/1000.;
+				if(timeDelta>0.2)timeDelta=fixDelta?fixDelta/1000.:.01;
+				++fcnt;updateFPSDelay+=timeDelta;t0=sdlticks;timeS+=timeDelta;
+				if(updateFPSDelay>1){fps=fcnt/updateFPSDelay;updateFPSDelay=.0;fcnt=0;}
+				if(pUpdateFunc){if(pUpdateFunc())break;}
+				if(updateHandler){if(updateHandler->handlerFunc())break;}
+				for(int i=1;i<=255;++i)keylst[i]=((keyz[i]&4)!=0);
+				clearQueue();
+			}
+			else
+			if(fixDelta&&dt+3<fixDelta)SDL_Delay(1);
+		}else SDL_Delay(1);
+	}
+	clearQueue();Active=false;
+}
+void SMELT_IMPL::smUpdateFunc(smHook func){pUpdateFunc=func;}
+void SMELT_IMPL::smUpdateFunc(smHandler* h){updateHandler=h;}
+void SMELT_IMPL::smUnFocFunc(smHook func){pUnFocFunc=func;}
+void SMELT_IMPL::smUnFocFunc(smHandler* h){unFocHandler=h;}
+void SMELT_IMPL::smFocFunc(smHook func){pFocFunc=func;}
+void SMELT_IMPL::smFocFunc(smHandler* h){focHandler=h;}
+void SMELT_IMPL::smQuitFunc(smHook func){pQuitFunc=func;}
+void SMELT_IMPL::smQuitFunc(smHandler* h){quitHandler=h;}
+void SMELT_IMPL::smWinTitle(const char *title){strcpy(winTitle,title);}
+bool SMELT_IMPL::smIsActive(){return Active;}
+void SMELT_IMPL::smNoSuspend(bool para){noSuspend=para;}
+void SMELT_IMPL::smVidMode(int resX,int resY,bool _windowed)
+{
+	if(vertexArray)return;
+	if(!pOpenGLDevice)scrw=resX,scrh=resY,windowed=_windowed;
+	else if(windowed!=_windowed)
+	{
+		windowed=_windowed;
+		Uint32 flags=SDL_WINDOW_OPENGL;
+		if(!windowed)flags|=SDL_WINDOW_FULLSCREEN;
+		SDL_SetWindowFullscreen((SDL_Window*)hwnd,flags);
+		restOGL();
+		if(!windowed){mouseOver=true;if(!pSM->Active)pSM->focusChange(true);}
+	}
+}
+void SMELT_IMPL::smLogFile(const char* path)
+{
+	strcpy(logFile,path);
+	FILE *tf=fopen(logFile,"w");
+	if(!tf)*logFile=0;else fclose(tf);
+}
+void SMELT_IMPL::smLog(const char* format,...)
+{
+	va_list ap;
+	va_start(ap,format);vfprintf(stderr,format,ap);va_end(ap);
+	FILE *logf=fopen(logFile,"a");if(!logf)return;
+	va_start(ap,format);vfprintf(logf,format,ap);va_end(ap);
+	fclose(logf);
+}
+void SMELT_IMPL::smScreenShot(const char* path)
+{
+	if(pOpenGLDevice)
+	{
+		#if SDL_BYTEORDER==SDL_BIG_ENDIAN
+		const Uint32 rmask=0xFF0000;
+		const Uint32 gmask=0x00FF00;
+		const Uint32 bmask=0x0000FF;
+		#else
+		const Uint32 rmask=0x0000FF;
+		const Uint32 gmask=0x00FF00;
+		const Uint32 bmask=0xFF0000;
+		#endif
+		pOpenGLDevice->glFinish();
+		SDL_Surface *screen=SDL_GetWindowSurface((SDL_Window*)hwnd);
+		SDL_Surface *surface=SDL_CreateRGBSurface(SDL_SWSURFACE,screen->w,screen->h,24,rmask,gmask,bmask,0);
+		pOpenGLDevice->glReadPixels(0,0,screen->w,screen->h,GL_RGB,GL_UNSIGNED_BYTE,surface->pixels);
+		flipSDLSurface(surface->pitch,surface->h,surface->pixels);
+		SDL_SaveBMP(surface,path);
+		SDL_FreeSurface(surface);
+	}
+}
+void SMELT_IMPL::smSetFPS(int fps)
+{
+	vsync=(fps==FPS_VSYNC);
+	if(pOpenGLDevice)SDL_GL_SetSwapInterval(vsync?1:0);
+	if(fps>0)fixDelta=1000./fps;else fixDelta=0;
+}
+float SMELT_IMPL::smGetFPS(){return fps;}
+float SMELT_IMPL::smGetDelta(){return timeDelta;}
+float SMELT_IMPL::smGetTime(){return timeS;}
+
+SMELT_IMPL::SMELT_IMPL()
+{
+	hwnd=NULL;Active=false;memset(curError,0,sizeof(curError));
+	pUpdateFunc=pUnFocFunc=pFocFunc=pQuitFunc=NULL;
+	updateHandler=unFocHandler=focHandler=quitHandler=NULL;
+	Icon=NULL;strcpy(winTitle,"untitled");scrw=dispw=800;scrh=disph=600;
+	windowed=vsync=false;memset(logFile,0,sizeof(logFile));
+	limfps=0;hideMouse=true;noSuspend=false;
+	pOpenGLDevice=NULL;targets=NULL;curTarget=NULL;
+	textures=NULL;vertexArray=NULL;vertexBuf=NULL;indexBuf=NULL;primTex=0;
+	pOpenALDevice=NULL;mute=false;inpQueue=NULL;posz=0;posx=posy=.0;
+	mouseOver=true;captured=false;keymods=KMOD_NONE;zbufenabled=false;
+	timeDelta=updateFPSDelay=fps=.0;fcnt=dt=fixDelta=0;
+}
+void SMELT_IMPL::focusChange(bool actif)
+{
+	Active=actif;
+	if(actif){pFocFunc?pFocFunc():0;focHandler?focHandler->handlerFunc():0;}
+	else {pUnFocFunc?pUnFocFunc():0;unFocHandler?unFocHandler->handlerFunc():0;};
+}
+bool SMELT_IMPL::procSDLEvent(const SDL_Event &e)
+{
+	switch(e.type)
+	{
+		case SDL_WINDOWEVENT:
+			switch(e.window.event)
+			{
+				case SDL_WINDOWEVENT_EXPOSED:
+					//redraw, omitted.
+				break;
+				case SDL_WINDOWEVENT_FOCUS_GAINED:
+					pSM->focusChange(true);
+				break;
+				case SDL_WINDOWEVENT_FOCUS_LOST:
+					pSM->focusChange(false);
+				break;
+				case SDL_WINDOWEVENT_ENTER:
+					mouseOver=true;
+				break;
+				case SDL_WINDOWEVENT_LEAVE:
+					mouseOver=false;
+				break;
+			}
+		break;
+		case SDL_QUIT:
+		{
+			bool accepted=true;
+			if(pSM->pQuitFunc&&pSM->pQuitFunc())accepted=false;
+			if(pSM->quitHandler&&quitHandler->handlerFunc())accepted=false;
+			if(accepted)return false;
+		}
+		break;
+		case SDL_KEYDOWN:
+			keymods=(SDL_Keymod)e.key.keysym.mod;
+			if((keymods&KMOD_ALT)&&((e.key.keysym.sym==SDLK_RETURN)||(e.key.keysym.sym==SDLK_KP_ENTER)))
+			{smVidMode(scrw,scrh,!windowed);break;}
+			pSM->buildEvent(INPUT_KEYDOWN,e.key.keysym.scancode,0,0,-1,-1);
+		break;
+		case SDL_KEYUP:
+			keymods=(SDL_Keymod)e.key.keysym.mod;
+			pSM->buildEvent(INPUT_KEYUP,e.key.keysym.scancode,0,0,-1,-1);
+		break;
+		case SDL_MOUSEBUTTONDOWN:
+			if(e.button.button==SDL_BUTTON_LEFT)
+			pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_LBUTTON,0,0,e.button.x,e.button.y);
+			if(e.button.button==SDL_BUTTON_RIGHT)
+			pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_RBUTTON,0,0,e.button.x,e.button.y);
+			if(e.button.button==SDL_BUTTON_MIDDLE)
+			pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_MBUTTON,0,0,e.button.x,e.button.y);
+		break;
+		case SDL_MOUSEBUTTONUP:
+			if(e.button.button==SDL_BUTTON_LEFT)
+			pSM->buildEvent(INPUT_MBUTTONUP,SMK_LBUTTON,0,0,e.button.x,e.button.y);
+			if(e.button.button==SDL_BUTTON_RIGHT)
+			pSM->buildEvent(INPUT_MBUTTONUP,SMK_RBUTTON,0,0,e.button.x,e.button.y);
+			if(e.button.button==SDL_BUTTON_MIDDLE)
+			pSM->buildEvent(INPUT_MBUTTONUP,SMK_MBUTTON,0,0,e.button.x,e.button.y);
+		break;
+		case SDL_MOUSEWHEEL:
+			if(e.wheel.y>0)pSM->buildEvent(INPUT_MOUSEWHEEL,1,0,0,e.button.x,e.button.y);
+			if(e.wheel.y<0)pSM->buildEvent(INPUT_MOUSEWHEEL,-1,0,0,e.button.x,e.button.y);
+		break;
+		case SDL_MOUSEMOTION:
+			pSM->buildEvent(INPUT_MOUSEMOVE,0,0,0,e.motion.x,e.motion.y);
+		break;
+	}
+	return true;
+}
+void SMELT_IMPL::flipSDLSurface(int p,int h,void* px)
+{
+	void* temp_row;
+	int height_div_2;
+	temp_row=(void*)malloc(p);
+	//assert(temp_row);
+	height_div_2=(int)(h*.5);
+	for(int i=0;i<height_div_2;++i)
+	{
+		memcpy((Uint8*)temp_row,(Uint8*)(px)+p*i,p);
+		memcpy((Uint8*)(px)+p*i,(Uint8*)(px)+p*(h-i-1),p);
+		memcpy((Uint8*)(px)+p*(h-i-1),temp_row,p);
+	}
+	free(temp_row);
+}