Sorry your browser is not supported!

Rem Project: ImageFunctions
Rem Created: Sunday, February 14, 2021

Rem ***** Main Source File *****

// Common Constants
#Constant True -1
#Constant False 0
#Constant Null  0

#Constant WindowsBlue 0x00ADEF

// Resource Constants
#Constant ImageResource     0x00
#Constant BitmapResource    0x02
#Constant MemblockResource  0x04
#Constant MeshResource      0x08
#Constant ObjectResource    0x10
#Constant SoundResource     0x20

#Constant MirrorImage   0
#Constant FlipImage     1

Set Window Size 1280, 720
Set Window Title "Image Functions"
Set Display Mode 1280, 720, 32
Set Window On

Sync On
Sync Rate 0
Disable EscapeKey

Global TestImage As Integer
TestImage = NextAvailableResource( ImageResource )
Load Image "Test.png", TestImage

Global MirroredImage As Integer
Global FlippedImage As Integer

MirroredImage = FlipImage( TestImage, MirrorImage )
FlippedImage = FlipImage( TestImage, FlipImage )

Repeat
    Cls WindowsBlue
    
    Paste Image TestImage, 20, 20
    Paste Image MirroredImage, 20 + Image Width( MirroredImage ), 20
    Paste Image FlippedImage, 20, 20 + Image Height( FlippedImage )

    Sync
Until EscapeKey()

// Clean Up

// If the Next Image ID available isn't 1 (meaning we HAVE images)
If NextAvailableResource( ImageResource ) > 1
    // Loop through however many we have and delete them from Memory
    For ID = 1 To NextAvailableResource( ImageResource )
        Delete Image ID
    Next
EndIf

End // This needs to be added to prevent "Function Mid-Program" Message

// Automated ID Check
// This would be quite slow in AppGameKit :\
Function NextAvailableResource( ResourceType As Dword )
    Local Resource As Dword
    Local Check As Boolean
    
    Repeat
        Inc Resource
        
        // Resource Type Check
        Select ResourceType
        // Image
            Case ImageResource :
                Check = Image Exist( Resource )
            EndCase
        // Bitmap / RenderTarget
            Case BitmapResource :
                Check = Bitmap Exist( Resource )
            EndCase
        // Memblock
            Case MemblockResource :
                Check = Memblock Exist( Resource )
            EndCase
        // Mesh
            Case MeshResource :
                Check = Mesh Exist( Resource )
            EndCase
        // Object
            Case ObjectResource :
                Check = Object Exist( Resource )
            EndCase
        // Sound
            Case SoundResource :
                Check = Sound Exist( Resource )
            EndCase
        EndSelect
    Until ( Check = False )
EndFunction Resource

Function FlipImage( Image As Integer, FlipDirection As Boolean )
    Local Output As Integer : Output = NextAvailableResource( ImageResource )
    Local RenderTarget As Integer : RenderTarget = NextAvailableResource( BitmapResource )
    
    // Just a check to make sure there IS and Image before we start committing memory
    If Image Exist( Image )
        // Create the RenderTarget & Paste our Image to Manipulate
        Create Bitmap RenderTarget, Image Width( Image ), Image Height( Image )
        Paste Image Image, 0, 0
        
        // Handle the Direction to Flip / Mirror
        If FlipDirection
            Flip Bitmap RenderTarget
        Else
            Mirror Bitmap RenderTarget
        EndIf
        
        // Now we make the new Flip / Mirrored Image from the RenderTarget
        Get Image Output, 0, 0, Bitmap Width( RenderTarget ), Bitmap Height( RenderTarget )
        
        // We set Draw Operations back to Screen / Default Camera
        Set Current Bitmap Null
        Delete Bitmap RenderTarget // as we no longer need the Offscreen RenderTarget, we can delete it        
    Else
        ExitFunction False
    EndIf
EndFunction Output

Rem Project: Test
Rem Created: Monday, February 15, 2021

Rem ***** Main Source File *****

// Common Constants
#Constant True      -1
#Constant False      0
#Constant Null       0
#Constant MathPI    3.1415927

// Basic Application Settings
Set Window Size 1280, 720
Set Window Title "Test Program"
Set Display Mode 1280, 720, 32
Set Window On // Start in Windowed Mode

Sync On             // We Enable Sync (there are "Problems" without it)
Sync Rate 0         // But we switch to Present as opposed to a Set Sync
                    // This allows the Application to run as fast as possible
Disable EscapeKey   // While I do tend to use ESC to exit the Prototype, I want to control "Clean Up"    
//Hide Mouse        // I like the Mouse Cursor for Testing, but for games you might want to disable it

Cls 0x000000        // Let's just make sure we have a Clear Backbuffer
Color Backdrop 0x000000

// -- Application Initialisation

// Program Specific Constants
// for 'RESOURCE_' we don't need to make sure these are always the same
// as strictly speaking we're not checking specific flags, these instead just
// have to be defined here and then a check definition added to the NextAvailableResource( ) Function
#Constant RESOURCE_OBJECT   0x10
#Constant RESOURCE_BITMAP   0x20
#Constant RESOURCE_MEMBLOCK 0x40
#Constant RESOURCE_IMAGE    0x80

Global VirtualWidth As Dword    : VirtualWidth = 320
Global VirtualHeight As Dword   : VirtualHeight = 240

Type Clock_Type
    Previous As Dword
    Current As Dword
    Delta As Float
EndType

Global Clock As Clock_Type : Clock.Current = Timer()

Global Cube As Dword : Cube = NextAvailableResource( RESOURCE_OBJECT )
Make Object Cube Cube, 10.0 : Color Object Cube, RGB( 128, 128, 128 )

// Now note, this we want to always keep active; we're just swapping to it to Render
Global RenderTarget As Dword 
RenderTarget = NextAvailableResource( RESOURCE_BITMAP )
Create Bitmap RenderTarget, VirtualWidth, VirtualHeight // Emulate Old School Resolution 
Set Bitmap Format 32

Global pRenderBuffer As Dword : pRenderBuffer = Make Memory( VirtualWidth * VirtualHeight * 4 )

Repeat
    SyncClock()

    // Switch to Off-Screen Rendering
    Set Current Bitmap RenderTarget
        
    Text 0, 0, Str$( Screen FPS() )
    Rotate Object Cube, WrapValue( Object Angle X( Cube ) + TimedValue( 4.0 ) ), WrapValue( Object Angle Y( Cube ) + TimedValue( 8.0 ) ), 0.0
   
    // We Grab the current Frame and save it to a Fast "Memblock"
    Lock Pixels
        Pitch = Bitmap Width( RenderTarget ) * 4
        For Y = 0 To Bitmap Height( RenderTarget ) - 1
            For X = 0 To Bitmap Width( RenderTarget ) - 1
                pBuffer = pRenderBuffer + ( Y * Pitch + ( X * 4 ) )
                *pBuffer = Point( X, Y )
            Next
        Next  
    Unlock Pixels
        
    // Remember that we're Syncing here to handle Rendering with the Off-Screen Bitmap
    FastSync
    
    // Now we set Rendering back to the Actual Display
    Set Current Bitmap 0
    
    // Here we are Rendering out Fast "Memblock" to the Screen
    Lock Pixels
        // We use this for Scaling to the Higher Resolution
        Pitch = Bitmap Width( RenderTarget ) * 4
        DeltaX# = 1.0 / ( Int( Bitmap Width( 0 ) / Bitmap Width( RenderTarget ) ) )
        DeltaY# = 1.0 / ( Int( Bitmap Height( 0 ) / Bitmap Height( RenderTarget ) ) )
        
        // Here is where we actually Draw it
        pPixel = Get Pixels Pointer( )
        PixelPitch = Get Pixels Pitch( )
        For Y = 0 To Bitmap Height( 0 ) - 1
            SY = Int( Y * DeltaY# ) * Pitch
            For X = 0 To Bitmap Width( 0 ) - 1
                pBack = pRenderBuffer + ( SY + ( Int( X * DeltaX# ) * 4 ) )
                pFront = pPixel + ( (Y * PixelPitch) + ( X * 4 ) )
                *pFront = *pBack
            Next
        Next 
    Unlock Pixels   
 
Until EscapeKey( )

Delete Memory pRenderBuffer // YOU MUST CLEAN UP MEMORY WE CREATE!!!

// Clean Up
If Bitmap Exist( RenderTarget ) Then Delete Bitmap RenderTarget

If NextAvailableResource( RESOURCE_OBJECT ) > 1
    For Entity = 1 To NextAvailableResource( RESOURCE_OBJECT ) - 1
        Delete Object Entity
    Next
EndIf

// Finish Program 
End

// -- Defined Functions
Function SyncClock( )
    Clock.Previous = Clock.Current
    Clock.Current = Timer()
    Clock.Delta = 0.001 * (Clock.Current - Clock.Previous)
EndFunction

Function TimedValue( Value As Float )
    Local Output As Float : Output = Value * Clock.Delta
EndFunction Output

Function NextAvailableResource( ResourceType As Dword )
    Local Resource As Dword // Resource ID we're outputting
    Local Check As Boolean  // Resource Type Check
    
    Repeat
        Inc Resource
        
        // We can expand this for whatever Resources we want
        // Provided each has a Unique Identifier
        Select ResourceType
            // Objects
            Case RESOURCE_OBJECT :
                Check = Object Exist( Resource )
            EndCase
            // Bitmap
            Case RESOURCE_BITMAP :
                Check = Bitmap Exist( Resource )
            EndCase
            // Image
            Case RESOURCE_IMAGE :
                Check = Image Exist( Resource )
            EndCase
            // Memblock
            Case RESOURCE_MEMBLOCK :
                Check = Memblock Exist( Resource )
            EndCase
        EndSelect
    Until ( Check = False )
    
EndFunction Resource