diff options
Diffstat (limited to 'smelt/w32')
-rw-r--r-- | smelt/w32/gfx_d3d.cpp | 1086 | ||||
-rw-r--r-- | smelt/w32/inp_w32.cpp | 203 | ||||
-rw-r--r-- | smelt/w32/makefile | 29 | ||||
-rw-r--r-- | smelt/w32/sfx_dumb.cpp | 74 | ||||
-rw-r--r-- | smelt/w32/sfx_w32.cpp | 356 | ||||
-rw-r--r-- | smelt/w32/smelt_config.hpp | 20 | ||||
-rw-r--r-- | smelt/w32/smelt_internal.hpp | 237 | ||||
-rw-r--r-- | smelt/w32/sys_w32.cpp | 355 |
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); +} |