Water fun

Monkey Forums/Monkey Code/Water fun

Jesse (Posted 2012) [#1]

below is a program designed by Tetra at DBF that I converted to BlitzMax and I wanted to see if I could get it working in monkey. I did it with out much hustle. Only problem is the only platform it runs decent on is GLFW and release mode. '-------------------------------- ' ' Water Transition ' 640x480 ' Interpolating gradient offsets ' ' 17 January 2005 ' By Dafydd Brown aka Tetra / DBF ' ' Modified on 27 January 2006 '-------------------------------- Strict Import mojo Global divi:float = 1.0 Global MAXDEPTH:Int = 500 Global MAXDEPTHD2:Int = MAXDEPTH/10 Global DEPTH:Int =-MAXDEPTH Global VISCOSITY:Int = 60 Const gfx_width:Int = 320 Const gfx_height:Int = 240 Const tex_width:Int = 320 Const tex_height:Int = 240 Global dShowDetail:Int = 0 Global wave_map_width:Int = 80 ' has To be 640 x 480 ratio Global wave_map_height:Int = 60 ' has To be 640 x 480 ratio Global wave_ratio:Int = gfx_width / wave_map_width Global tex_ratio:Int = tex_width / gfx_width Global frnt:Int = 1 Global drpSz:Int = 2 Global smooth:Int = 0 Global lastX:Int = 100 Global lastY:Int = 100 Global WaveMap:float[][][] Global gradient:float[][][] Global atlas:Image Global image:Image Global destImage:Image Global imageWidth:Int Global imageHeight:int global fs:Int = 0 Function Main:Int() New Game Return True End Function Class Game Extends App Method OnCreate:Int() WaveMap = New Float[ wave_map_width][][] For Local i:Int = 0 Until wave_map_width WaveMap[i] = New Float[wave_map_height][] For Local j:Int = 0 Until wave_map_height WaveMap[i][j] = New Float[3] Next next gradient = New Float[ wave_map_width][][] For Local i:Int = 0 Until wave_map_width gradient[i] = New Float[wave_map_height][] For Local j:Int = 0 Until wave_map_height gradient[i][j] = New Float[2] Next next LoadTextureImage("fortest.png") '*************************** replace this image ************************ SetVirtualDisplay 320,240 '1440, 900 SetUpdateRate 30 Return True End Method Method OnUpdate:Int() SetVirtualZoom 1.0 Return False End Method Method OnRender:Int() UpdateVirtualDisplay Cls() Local tim:Int = Millisecs() Local newX:Int=VMouseX() Local newY:Int=VMouseY() If KeyDown(KEY_1) changeWavemapSize(20,15) If KeyDown(KEY_2) changeWavemapSize(40,30) If KeyDown(KEY_3) changeWavemapSize(80,60) If KeyDown(KEY_4) changeWavemapSize(160,120) If KeyDown(KEY_5) changeWavemapSize(320,240) If MouseDown(0) indentline(newX / wave_ratio,newY / wave_ratio,lastX / wave_ratio,lastY / wave_ratio) Endif UpdateWaveMap() If KeyDown(KEY_UP) MAXDEPTH = MAXDEPTH+25 MAXDEPTHD2 = MAXDEPTH/10 Endif If KeyDown(KEY_DOWN) If MAXDEPTH > 25 MAXDEPTH = MAXDEPTH-25 MAXDEPTHD2 = MAXDEPTH/10 Endif Endif If KeyDown(KEY_RIGHT) Then divi = divi + 0.05 If KeyDown(KEY_LEFT) Then divi = divi - 0.05 lastX = newX lastY = newY If KeyHit(KEY_SPACE) Then dShowDetail = 1 - dShowDetail Local i:Int=0 For Local y:Int = 0 Until imageHeight For Local x:int = 0 Until imageWidth If destImage.frames[i] DrawImage destImage,x,y,i Endif i += 1 Next Next If (dShowDetail = 1) SetColor 255,50,0 DrawText "Detail: "+(wave_map_width / 40),10,30 Endif Return True End Method End Class '-------------------------------- ' ' Water Transition ' 640x480 ' Interpolating gradient offsets ' ' 17 January 2005 ' By Dafydd Brown aka Tetra / DBF ' ' Modified on 27 January 2006 '-------------------------------- '------------------------------------------ ' Change the detail of the wavemap ' Function changeWavemapSize:Void(wd:Int,ht:Int) wave_map_width = wd ' has To be 640 x 480 ratio wave_map_height = ht ' has To be 640 x 480 ratio wave_ratio = gfx_width / wave_map_width ' has To be 640 x 480 ratio WaveMap = New Float[ wave_map_width][][] For Local i:Int = 0 Until wave_map_width WaveMap[i] = New Float[wave_map_height][] For Local j:Int = 0 Until wave_map_height WaveMap[i][j] = New Float[3] Next next gradient = New Float[ wave_map_width][][] For Local i:Int = 0 Until wave_map_width gradient[i] = New Float[wave_map_height][] For Local j:Int = 0 Until wave_map_height gradient[i][j] = New Float[2] Next next End Function '------------------------------------------ ' Load the texture To use ' Function LoadTextureImage:void(filename$) atlas = LoadImage(filename) If Not atlas Error "Unable to load image "+filename Endif imageWidth = atlas.Width() imageHeight= atlas.Height() image = atlas.GrabImage(0,0,1,1,imageWidth*imageHeight) destImage = image.CreateNullFrames() For Local i:Int = 0 Until imageWidth*imageHeight destImage.frames[i] = image.frames[i] Next End Function '------------------------------------------ ' Smooth indentation into the wavemap along a line ' Function indentline:Void( xa:float, ya:float, xb:Int, yb:Int ) Local ti:Int,i:Int,j:Int,tj:Int,xLen:Int,yLen:Int,llen:float Local xDelta:float,yDelta:float If (xa > 4)And(xa < wave_map_width-4)And(ya > 4)And(ya < wave_map_height-4) If (xb > 4)And(xb < wave_map_width-4)And(yb > 4)And(yb < wave_map_height-4) xLen = xb - xa yLen = yb - ya llen = Sqrt(xLen*xLen + yLen*yLen) xDelta = xLen / llen yDelta = yLen / llen For Local ii:Int = 0 To llen For i = -drpSz To drpSz ti = (xa+i) Mod (wave_map_width-1) If ( ti < 0 ) Then ti=ti+wave_map_width For j=-drpSz To drpSz tj=(ya+j) Mod (wave_map_height-1) If tj<0 Then tj=tj+wave_map_height WaveMap[ti][tj][1] = Rnd(MAXDEPTH) Next Next For i = xa-drpSz To xa+drpSz For j = ya-drpSz To ya+drpSz WaveMap[i][j][1]=(WaveMap[i+1][j][1]+WaveMap[i-1][j][1]+WaveMap[i][j+1][1]+WaveMap[i][j-1][1]) Shr 2 Next Next xa = xa + xDelta ya = ya + yDelta Next Endif EndIf End Function ' Smooths the wavemap ' Function smoothit:Void( wf:Int ) Local x:Int,y:Int,xp1:Int,yp1:Int,xm1:Int,ym1:Int,n:float For y = 0 Until wave_map_height WaveMap[ 0][y][ wf ] = 0 WaveMap[ wave_map_width-1][y][ wf ] = 0 Next For x = 0 Until wave_map_width WaveMap[ x][0][ wf ] = 0 WaveMap[ x][wave_map_height-1][ wf ] = 0 Next For y = 1 To wave_map_height-2 yp1 = y + 1 ym1 = y - 1 For x = 1 To wave_map_width-2 xp1 = x + 1 xm1 = x - 1 n = (WaveMap[xm1][y][wf]+WaveMap[xp1][y][wf]+WaveMap[x][ym1][wf]+WaveMap[x][yp1][wf]) n = n + (WaveMap[xm1][ym1][wf]+WaveMap[xp1][yp1][wf]+WaveMap[xp1][ym1][wf]+WaveMap[xm1][yp1][wf]) WaveMap[ x][y][ wf ] = ( WaveMap[ x][y][ wf ] + ( n / 8.0) )/2 Next Next End Function '------------------------------------------ ' Does the wave stuff ' Function UpdateWaveMap:Void() Local wf:Int,nfrnt:Int,n:float Local x:Int,y:Int,xp1:Int,yp1:Int,xm1:Int,ym1:Int 'get rid of a sticky bug For y = 0 To wave_map_height-1 WaveMap[0][y][wf] = 0 WaveMap[wave_map_width-1][y][wf] = 0 Next 'get rid of a sticky bug For x = 0 To wave_map_width-1 WaveMap[x][0][wf] = 0 WaveMap[x][wave_map_height-1][wf] = 0 Next ' this is here so that I dont have To write 1 - frnt everywhere I need it nfrnt = 1 - frnt 'distortion map For y = 1 To wave_map_height-2 yp1 = y + 1 ym1 = y - 1 For x = 1 To wave_map_width-2 xp1 = x + 1 xm1 = x - 1 n=(WaveMap[xm1][y][frnt]+WaveMap[xp1][y][frnt]+ WaveMap[x][ym1][frnt]+WaveMap[x][yp1][frnt])/ 2.0 n = ( n - WaveMap[x][y][nfrnt] ) n = ( n - ( n / VISCOSITY ) ) ' Cap wave height If n > MAXDEPTH Then n = MAXDEPTH If n < -MAXDEPTH Then n = -MAXDEPTH WaveMap[x][y][nfrnt ] = n Next Next 'Calculate texture offsets like bumpmapping For y = 1 To wave_map_height-2 yp1=(y+1) ym1=(y-1) For Local x:Int = 1 To wave_map_width-2 xp1=(x+1) xm1=(x-1) gradient[x][y][0] = (WaveMap[xp1 ][ y ][ nfrnt]-WaveMap[xm1][y][nfrnt]) / divi gradient[x][y][1] = (WaveMap[x ][ yp1 ][ nfrnt]-WaveMap[x][ym1][nfrnt]) / divi Next Next ' Smooth out the wave ' this is required Or it looks really bad smoothit(1-frnt) ' Render the screen using a textured polygon fill routing ' its a pretty standard polyfill routine ' that could probably be more optimised For the job For Local y:Int = 1 To wave_map_height - 2 Local yp1:Int=(y+1) Local yp:Int = y * wave_ratio If ( yp1 > wave_map_height - 1 ) Then yp1 = wave_map_height-1 For Local x:Int = 1 To wave_map_width-2 Local xp1:Int = x + 1 If xp1 > wave_map_width-1 Then xp1 = wave_map_width-1 Local tx1:float = gradient[ x][y][ 0 ] / 4.0 Local ty1:float = gradient[ x][y][ 1 ] / 4.0 Local xp:Int = x * wave_ratio tx1 = tx1 + xp ty1 = ty1 + yp Local tx2:Int = ((xp1) * wave_ratio) + (gradient[xp1][y][0] / 4.0) Local ty2:Int = ((yp1) * wave_ratio) + (gradient[xp1][y][1] / 4.0) Local vxDeltal:float = (gradient[x][yp1][0] - gradient[x][y][0]) / wave_ratio Local vyDeltal:float = (gradient[x][yp1][1] - gradient[x][y][1]) / wave_ratio Local lBasex:float = gradient[x][y][0] Local lBasey:float = gradient[x][y][1] Local vxDeltar:float = (gradient[xp1][yp1][0] - gradient[xp1][y][0]) / wave_ratio Local vyDeltar:float = (gradient[xp1][yp1][1] - gradient[xp1][y][1]) / wave_ratio Local rBasex:float = gradient[xp1][y][0] Local rBasey:float = gradient[xp1][y][1] ' \|/--- Make this a 1 To see the size of the polygon For Local j:Int = 0 To wave_ratio-1 Local xDelta:float =Float(rBasex - lBasex)/ Float(wave_ratio) Local xBase:float = lBasex Local yDelta:float =Float(rBasey - lBasey)/ Float(wave_ratio) Local yBase:float = lBasey ' \|/--- Make this a 1 To see the size of the polygon For Local i:Int = 0 To wave_ratio-1 Local ttx21:Int = ( xp+i+xBase ) * tex_ratio Local tty21:Int = ( yp+j+yBase ) * tex_ratio If ttx21 > tex_width-1 Then ttx21 = tex_width-1 If tty21 > tex_height-1 Then tty21 = tex_height-1 If ttx21 < 0 Then ttx21 = 0 If tty21 < 0 Then tty21 = 0 destImage.frames[(yp+j)*atlas.width+(xp+i)] = image.frames[tty21*atlas.width+ttx21] xBase = xBase + xDelta yBase = yBase + yDelta Next lBasex = lBasex + vxDeltal lBasey = lBasey + vyDeltal rBasex = rBasex + vxDeltar rBasey = rBasey + vyDeltar Next Next Next ' swap wave map For update, Very imortant To have this line included frnt = 1 - frnt End Function ' TODO -- Limit mouse x/y to visible (zoomed) area, rather than just virtual ' display area? Only when keepborders kicks in? ' ----------------------------------------------------------------------------- ' Usage. For details see function definitions... ' ----------------------------------------------------------------------------- ' ----------------------------------------------------------------------------- ' SetVirtualDisplay ' ----------------------------------------------------------------------------- ' Call during OnCreate, passing intended width and height of game area. Design ' your game for this fixed display size and it will be scaled correctly on any ' device. You can pass no parameters for default 640 x 480 virtual device size. ' Optional zoom parameter default to 1.0. ' ----------------------------------------------------------------------------- ' UpdateVirtualDisplay ' ----------------------------------------------------------------------------- ' Call at start of OnRender, BEFORE ANYTHING ELSE, including Cls! ' ----------------------------------------------------------------------------- ' VMouseX/VMouseY ' ----------------------------------------------------------------------------- ' Call during OnUpdate (or OnRender) to get correctly translated MouseX/MouseY ' positions. By default, the results are bound to the display area within the ' borders. You can override this by passing False as an optional parameter, ' and the functions will then return values outside of the borders. ' ----------------------------------------------------------------------------- ' VDeviceWidth/VDeviceHeight ' ----------------------------------------------------------------------------- ' Call during OnUpdate (or OnRender) for the virtual device width/height. These ' are just the values you passed to SetVirtualDisplay. ' ----------------------------------------------------------------------------- ' SetVirtualZoom ' ----------------------------------------------------------------------------- ' Call in OnUpdate to set zoom level. ' ----------------------------------------------------------------------------- ' AdjustVirtualZoom ' ----------------------------------------------------------------------------- ' Call in OnUpdate to zoom in/out by given amount. ' ----------------------------------------------------------------------------- ' GetVirtualZoom ' ----------------------------------------------------------------------------- ' Call in OnUpdate or OnRender to retrieve current zoom level. ' ----------------------------------------------------------------------------- ' Function definitions and parameters... ' ----------------------------------------------------------------------------- ' ----------------------------------------------------------------------------- ' SetVirtualDisplay: Call in OnCreate... ' ----------------------------------------------------------------------------- ' Parameters: width and height of virtual game area, optional zoom... Function SetVirtualDisplay:void (width:Int = 640, height:Int = 480, zoom:Float = 1.0) New VirtualDisplay (width, height, zoom) End ' ----------------------------------------------------------------------------- ' SetVirtualZoom: Call in OnUpdate... ' ----------------------------------------------------------------------------- ' Parameters: zoom level (1.0 being normal)... Function SetVirtualZoom:Void (zoom:Float) VirtualDisplay.Display.SetZoom zoom End ' ----------------------------------------------------------------------------- ' AdjustVirtualZoom: Call in OnUpdate... ' ----------------------------------------------------------------------------- ' Parameters: amount by which to change current zoom level. Positive values ' zoom in, negative values zoom out... Function AdjustVirtualZoom:void (amount:Float) VirtualDisplay.Display.AdjustZoom amount End ' ----------------------------------------------------------------------------- ' GetVirtualZoom: Call in OnUpdate or OnRender... ' ----------------------------------------------------------------------------- ' Parameters: none... Function GetVirtualZoom:Float () Return VirtualDisplay.Display.GetZoom () End ' ----------------------------------------------------------------------------- ' UpdateVirtualDisplay: Call at start of OnRender... ' ----------------------------------------------------------------------------- ' Parameters: ' Gah! Struggling to explain this! Just experiment! ' The 'zoomborders' parameter can be set to False to allow you to retain FIXED ' width/height borders for the current device size/ratio. Effectively, this ' means that as you zoom out, you can see more of the 'playfield' outside the ' virtual display, instead of having borders drawn to fill the outside area. ' See VMouseX/Y information for more details on how this can be used... ' The 'keepborders' parameter, if set to True, means the outer borders are ' kept no matter how ZOOMED IN the game is. Setting this to False means you ' can zoom into the game, the borders appearing to go 'outside' the screen ' as you zoom further in. You'll have to try it to get it, but it only ' affects zooming inwards. NB. ONLY TAKES EFFECT IF zoomborders IS TRUE! Function UpdateVirtualDisplay:void (zoomborders:Bool = True, keepborders:Bool = True) VirtualDisplay.Display.UpdateVirtualDisplay zoomborders, keepborders End ' ----------------------------------------------------------------------------- ' Misc functions: Call in OnUpdate (optionally)... ' ----------------------------------------------------------------------------- ' Mouse position within virtual display; the limit parameter allows you to only ' return values within the virtual display. ' Set the 'limit' parameter to False to allow returning of values outside ' the virtual display area. Combine this with ScaleVirtualDisplay's zoomborders ' parameter set to False if you want to be able to zoom way out and allow ' gameplay in the full zoomed-out area... Function VMouseX:Float (limit:Bool = True) Return VirtualDisplay.Display.VMouseX (limit) End Function VMouseY:Float (limit:Bool = True) Return VirtualDisplay.Display.VMouseY (limit) End ' Virtual display size... Function VDeviceWidth:Float () Return VirtualDisplay.Display.vwidth End Function VDeviceHeight:Float () Return VirtualDisplay.Display.vheight End ' ----------------------------------------------------------------------------- ' AutoFit - Virtual Display System... [Public domain code] ' ----------------------------------------------------------------------------- ' Couldn't think of a better name! Class VirtualDisplay ' MISC NOTES ' CORRECT MOUSE FRACTION OF DEVICE WIDTH 'Local cfrac:Float = (MouseX - (Float (DeviceWidth) * 0.5)) / Float (DeviceWidth) ' WIDTH OF SCALED VIRTUAL DISPLAY IN PIXELS 'Local real:Float = (vwidth * zoom * multi) ' CORRECT SPACE BETWEEN SCALED DEVICE AND DEVICE ' Local offx:Float = (Float (DeviceWidth) - real)' * 0.5 Global Display:VirtualDisplay Private Field vwidth:Float ' Virtual width Field vheight:Float ' Virtual height Field vratio:Float ' Virtual ratio Field scaledw:Float ' Width of *scaled* virtual display in real pixels Field scaledh:Float ' Width of *scaled* virtual display in real pixels Field widthborder:Float ' Size of border at sides Field heightborder:Float ' Size of border at top/bottom Field multi:Float ' Ratio scale factor Field vzoom:Float ' Zoom scale factor Field fdw:Float ' DeviceWidth gets pre-cast to Float in UpdateVirtualDisplay Field fdh:Float ' DeviceHeight gets pre-cast to Float in UpdateVirtualDisplay Public Method New (width:Int, height:Int, zoom:Float) ' Set virtual width and height... vwidth = width vheight = height vzoom = zoom ' Store ratio... vratio = vheight / vwidth ' Create global VirtualDisplay object... Display = Self End Method GetZoom:Float () Return vzoom End Method SetZoom:void (zoomlevel:Float) If zoomlevel < 0.0 Then zoomlevel = 0.0 vzoom = zoomlevel End Method AdjustZoom:void (amount:Float) vzoom = vzoom + amount If vzoom < 0.0 Then vzoom = 0.0 End Method VMouseX:Float (limit:Bool) ' Position of mouse, in real pixels, from centre of screen (centre being 0)... Local mouseoffset:Float = MouseX() - Float (DeviceWidth()) * 0.5 ' This calculates the scaled position on the virtual display. Somehow... Local x:Float = (mouseoffset / multi) / vzoom + (VDeviceWidth() * 0.5) ' Check if mouse is to be limited to virtual display area... If limit Local widthlimit:Float = vwidth - 1 If x > 0 If x < widthlimit Return x Else Return widthlimit Endif Else Return 0 Endif Else Return x Endif End Method VMouseY:Float (limit:Bool) ' Position of mouse, in real pixels, from centre of screen (centre being 0)... Local mouseoffset:Float = MouseY() - Float (DeviceHeight()) * 0.5 ' This calculates the scaled position on the virtual display. Somehow... Local y:Float = (mouseoffset / multi) / vzoom + (VDeviceHeight() * 0.5) ' Check if mouse is to be limited to virtual display area... If limit Local heightlimit:Float = vheight - 1 If y > 0 If y < heightlimit Return y Else Return heightlimit Endif Else Return 0 Endif Else Return y Endif End Method UpdateVirtualDisplay:void (zoomborders:Bool, keepborders:Bool) ' Store device resolution as float values to avoid loads of casts. Doing it here as ' device resolution may potentially be changed on the fly on some platforms... fdw = Float (DeviceWidth()) fdh = Float (DeviceHeight()) ' Device ratio is calculated on the fly since it can change (eg. resizeable ' browser window)... Local dratio:Float = fdh / fdw ' Compare to pre-calculated virtual device ratio... If dratio >= vratio ' ----------------------------------------------------------------- ' Device aspect narrower than (or same as) game aspect ratio: ' will use full width, borders above and below... ' ----------------------------------------------------------------- ' Multiplier required to scale game width to device width (to be applied to height)... multi = fdw / vwidth ' "vheight * multi" below applies width multiplier to height... heightborder = (fdh - vheight * multi) * 0.5 widthborder = 0 Else ' ----------------------------------------------------------------- ' Device aspect wider than game aspect ratio: ' will use full height, borders at sides... ' ----------------------------------------------------------------- ' Multiplier required to scale game height to device height (to be applied to width)... multi = fdh / vheight ' "vwidth * multi" below applies height multiplier to width... widthborder = (fdw - vwidth * multi) * 0.5 heightborder = 0 Endif ' --------------------------------------------------------------------- ' Clear outer area (black borders if required)... ' --------------------------------------------------------------------- SetScissor 0, 0, DeviceWidth(), DeviceHeight() Cls 0, 0, 0 ' --------------------------------------------------------------------- ' Set inner area... ' --------------------------------------------------------------------- Local sx:Float, sy:Float, sw:Float, sh:Float If zoomborders ' Width/height of SCALED virtual display in real pixels... Local realx:Float = (vwidth * vzoom * multi) Local realy:Float = (vheight * vzoom * multi) ' Space in pixels between real device borders and virtual device borders... Local offx:Float = (fdw - realx) * 0.5 Local offy:Float = (fdh - realy) * 0.5 ' WIP: Retain borders when zoomed in... add option to lose borders... ' Can keepborders check go outside? If keepborders If offx < widthborder sx = widthborder sw = fdw - widthborder * 2.0 Else sx = offx sw = fdw - (offx * 2.0) Endif Else sx = offx sw = fdw - (offx * 2.0) Endif If keepborders If offy < heightborder sy = heightborder sh = fdh - heightborder * 2.0 Else sy = offy sh = fdh - (offy * 2.0) Endif Else sy = offy sh = fdh - (offy * 2.0) Endif sx = Max (0.0, sx) sy = Max (0.0, sy) sw = Min (sw, fdw) sh = Min (sh, fdh) SetScissor sx, sy, sw, sh Else sx = Max (0.0, widthborder) sy = Max (0.0, heightborder) sw = Min (fdw - widthborder * 2.0, fdw) sh = Min (fdh - heightborder * 2.0, fdh) SetScissor sx, sy, sw, sh Endif ' --------------------------------------------------------------------- ' Scale and translate everything... ' --------------------------------------------------------------------- Scale multi * vzoom, multi * vzoom ' --------------------------------------------------------------------- ' Shift display to account for borders/zoom level... ' --------------------------------------------------------------------- If vzoom ' Gets skipped if zero... ' Width and height of *scaled* virtual display in pixels... scaledw = (vwidth * multi * vzoom) scaledh = (vheight * multi * vzoom) ' Find offsets by which view needs to be shifted... Local xoff:Float = (fdw - scaledw) * 0.5 Local yoff:Float = (fdh - scaledh) * 0.5 ' Ahh, good old trial and error -- I have no idea how this works! xoff = (xoff / multi) / vzoom yoff = (yoff / multi) / vzoom ' Aaaand, shift... Translate xoff, yoff Endif End End It uses Hitoro virtual screen resolution (included/integrated). to use it, use any 320 x 240 image. you can set the density by pressing a number between 1 and 5 inclusive while running.

Gerry Quinn (Posted 2012) [#2]

What's Image.CreateNullFrames()?

Jesse (Posted 2012) [#3]

Sorry Gerry and sorry Everyone, I completely forgot I had modified the Image class to create a null Image with the number of frames from the already created image so I could just move frames from one image to another. I did that and completely forgot about it. I guess this thread is just pointless. Sorry everybody. if anybody is interested in getting it to run the mojo.graphics image class needs to be modified by adding this methods: [monkeycode] Method CreateEmpty:Image(iwidth,iheight,nframes,iflags,source:Image) Self.source = source surface=source.surface width = iwidth height= iheight frames = New Frame[nframes] ApplyFlags iflags Return Self End Method [/monkeycode] and [monkeycode] Method CreateNullFrames:Image() Return (New Image).CreateEmpty(width,height,frames.Length,flags,Self) End Method [/monkeycode] and removed Private from Image class. yea, I know everybody hates it but I just hate being puppet and following standards and being limited to the puppet master rules. Makes it easier for me to work as I like. Once Again, Sorry!

Gerry Quinn (Posted 2012) [#4]

Gave it a try... it compiles, but it doesn't seem to be doing anything.

CodeGit (Posted 2012) [#5]

Tried to run this, gave up after 2 minutes. :)

Jesse (Posted 2012) [#6]

it only works with glfw on release mode. I did mention that in the first post. it's really really slow on any other platform otherwise. And click on screen. :)