algo/al/display.go

package al

/*
#include <stdlib.h>
#include <allegro5/allegro.h>
#include "helpers.h"
*/
import "C"

import "runtime"
import "unsafe"
import "fmt"

// Usful regexp for KATE:  ALLEGRO_([A-Z0-9_]+)(.*) -> \1 = C.ALLEGRO_\1

// Display functions.

// Possible bit combinations for the flags parameter of CreateDisplay.
const (
    WINDOWED                  = C.ALLEGRO_WINDOWED
    FULLSCREEN                = C.ALLEGRO_FULLSCREEN
    OPENGL                    = C.ALLEGRO_OPENGL
    DIRECT3D_INTERNAL         = C.ALLEGRO_DIRECT3D_INTERNAL
    RESIZABLE                 = C.ALLEGRO_RESIZABLE
    FRAMELESS                 = C.ALLEGRO_FRAMELESS
    NOFRAME                   = C.ALLEGRO_NOFRAME
    GENERATE_EXPOSE_EVENTS    = C.ALLEGRO_GENERATE_EXPOSE_EVENTS
    OPENGL_3_0                = C.ALLEGRO_OPENGL_3_0
    OPENGL_FORWARD_COMPATIBLE = C.ALLEGRO_OPENGL_FORWARD_COMPATIBLE
    FULLSCREEN_WINDOW         = C.ALLEGRO_FULLSCREEN_WINDOW
    MINIMIZED                 = C.ALLEGRO_MINIMIZED
)

/* Possible parameters for SetDisplayOption. */
const (
    RED_SIZE               = C.ALLEGRO_RED_SIZE
    GREEN_SIZE             = C.ALLEGRO_GREEN_SIZE
    BLUE_SIZE              = C.ALLEGRO_BLUE_SIZE
    ALPHA_SIZE             = C.ALLEGRO_ALPHA_SIZE
    RED_SHIFT              = C.ALLEGRO_RED_SHIFT
    GREEN_SHIFT            = C.ALLEGRO_GREEN_SHIFT
    BLUE_SHIFT             = C.ALLEGRO_BLUE_SHIFT
    ALPHA_SHIFT            = C.ALLEGRO_ALPHA_SHIFT
    ACC_RED_SIZE           = C.ALLEGRO_ACC_RED_SIZE
    ACC_GREEN_SIZE         = C.ALLEGRO_ACC_GREEN_SIZE
    ACC_BLUE_SIZE          = C.ALLEGRO_ACC_BLUE_SIZE
    ACC_ALPHA_SIZE         = C.ALLEGRO_ACC_ALPHA_SIZE
    STEREO                 = C.ALLEGRO_STEREO
    AUX_BUFFERS            = C.ALLEGRO_AUX_BUFFERS
    COLOR_SIZE             = C.ALLEGRO_COLOR_SIZE
    DEPTH_SIZE             = C.ALLEGRO_DEPTH_SIZE
    STENCIL_SIZE           = C.ALLEGRO_STENCIL_SIZE
    SAMPLE_BUFFERS         = C.ALLEGRO_SAMPLE_BUFFERS
    SAMPLES                = C.ALLEGRO_SAMPLES
    RENDER_METHOD          = C.ALLEGRO_RENDER_METHOD
    FLOAT_COLOR            = C.ALLEGRO_FLOAT_COLOR
    FLOAT_DEPTH            = C.ALLEGRO_FLOAT_DEPTH
    SINGLE_BUFFER          = C.ALLEGRO_SINGLE_BUFFER
    SWAP_METHOD            = C.ALLEGRO_SWAP_METHOD
    COMPATIBLE_DISPLAY     = C.ALLEGRO_COMPATIBLE_DISPLAY
    UPDATE_DISPLAY_REGION  = C.ALLEGRO_UPDATE_DISPLAY_REGION
    VSYNC                  = C.ALLEGRO_VSYNC
    MAX_BITMAP_SIZE        = C.ALLEGRO_MAX_BITMAP_SIZE
    SUPPORT_NPOT_BITMAP    = C.ALLEGRO_SUPPORT_NPOT_BITMAP
    CAN_DRAW_INTO_BITMAP   = C.ALLEGRO_CAN_DRAW_INTO_BITMAP
    SUPPORT_SEPARATE_ALPHA = C.ALLEGRO_SUPPORT_SEPARATE_ALPHA
    DISPLAY_OPTIONS_COUNT  = C.ALLEGRO_DISPLAY_OPTIONS_COUNT
)

// Constants that determine if a setting is required or not.
const (
    DONTCARE = C.ALLEGRO_DONTCARE
    REQUIRE  = C.ALLEGRO_REQUIRE
    SUGGEST  = C.ALLEGRO_SUGGEST
)

// Display orientations
const (
    DISPLAY_ORIENTATION_0_DEGREES   = C.ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES
    DISPLAY_ORIENTATION_90_DEGREES  = C.ALLEGRO_DISPLAY_ORIENTATION_90_DEGREES
    DISPLAY_ORIENTATION_180_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_180_DEGREES
    DISPLAY_ORIENTATION_270_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_270_DEGREES
    DISPLAY_ORIENTATION_FACE_UP     = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_UP
    DISPLAY_ORIENTATION_FACE_DOWN   = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_DOWN
)

// Type that wraps a Display (a main window)
type Display struct {
    handle *C.ALLEGRO_DISPLAY
}

// Converts display to C display 
func (disp *Display) toC() *C.ALLEGRO_DISPLAY {
    return disp.handle 
}


// Destroys a display. Use this only when really needed!
func (self *Display) Destroy() {
    if self.handle != nil {
        C.al_destroy_display(self.handle)
    }
    self.handle = nil
}

// Wraps a C Allegro display in a Display. Sets no finalizer.
func wrapDisplayRaw(handle *C.ALLEGRO_DISPLAY) *Display {
    if handle == nil {
        return nil
    }
    return &Display{handle}
}

// Wraps a C Allegro display in a Display. Sets a finalizer that calls Destroy
func wrapDisplay(handle *C.ALLEGRO_DISPLAY) *Display {
    self := wrapDisplayRaw(handle)
    if self != nil {
        runtime.SetFinalizer(self, func(me *Display) { me.Destroy() })
    }
    return self
}

// Monitor info
type MonitorInfo C.ALLEGRO_MONITOR_INFO

// Returns the X1 of the monitor info self.
func (self *MonitorInfo) X1() int {
    return int(self.x1)
}

// Returns the Y1 of the monitor info self.
func (self *MonitorInfo) Y1() int {
    return int(self.y1)
}

// Returns the X2 of the monitor info self.
func (self *MonitorInfo) X2() int {
    return int(self.x2)
}

// Returns the Y2 of the monitor info self.
func (self *MonitorInfo) Y2() int {
    return int(self.y2)
}

const (
    DEFAULT_DISPLAY_ADAPTER = C.ALLEGRO_DEFAULT_DISPLAY_ADAPTER
)

// Sets the flags that a display created by CreateDisplay will get after
// this function was called.
func SetNewDisplayFlags(flags int) {
    C.al_set_new_display_flags(C.int(flags))
}

// Creates a new dosplay with the given size. Influenced by SetNewDisplayFlags.
func CreateDisplay(width, height int) *Display {
    return wrapDisplay(C.al_create_display(C.int(width), C.int(height)))
}

// Resizes the display.
func (self *Display) Resize(width, height int) bool {
    return bool(C.al_resize_display(self.handle, C.int(width), C.int(height)))
}

// Updates the display to the physical scree no any changes become visible
func FlipDisplay() {
    C.al_flip_display()
}

// Same as FlipDisplay, for mere consistency
func (self *Display) Flip() {
    C.al_flip_display()
}


// Fills the current active display with a color
func ClearToColor(color Color) {
    C.al_clear_to_color(color.toC())
}

// Clears the depth buffer of the active display
func ClearDepthBuffer(z float32) {
    C.al_clear_depth_buffer(C.float(z))
}

// Draws a pixel on the active display at the given location 
// with the given color
func DrawPixel(x, y float32, color Color) {
    C.al_draw_pixel(C.float(x), C.float(y), C.ALLEGRO_COLOR(color))
}

// Sets the refresh rate that the display should have after CreateDisplay().
func SetNewDisplayRefreshRate(refresh_rate int) {
    C.al_set_new_display_refresh_rate(C.int(refresh_rate))
}

// Gets the refresh rate that the display should have after CreateDisplay().
func NewDisplayRefreshRate() int {
    return int(C.al_get_new_display_refresh_rate())
}

// Gets the display flags that the display should have after CreateDisplay().
func NewDisplayFlags() int {
    return int(C.al_get_new_display_flags())
}

// Gets the width of the display  in pixels
func (self *Display) Width() int {
    return int(C.al_get_display_width(self.handle))
}

// Gets the height of the display in pixels
func (self *Display) Height() int {
    return int(C.al_get_display_height(self.handle))
}

// Gets the refresh rate of the display
func (self *Display) RefreshRate() int {
    return int(C.al_get_display_refresh_rate(self.handle))
}

// Gets the display flags of the display
func (self *Display) DisplayFlags() int {
    return int(C.al_get_display_flags(self.handle))
}

// Gets the orientation of the display
func (self *Display) Orientation() int {
    return int(C.al_get_display_orientation(self.handle))
}

// Sets a dispay flag on the display
func (self *Display) SetDisplayFlag(flag int, onoff bool) bool {
    return cb2b(C.al_set_display_flag(self.handle, C.int(flag), b2cb(onoff)))
}

// Returns the current display 
func CurrentDisplay() *Display {
    return wrapDisplayRaw(C.al_get_current_display())
}

// Sets the target C bitmap of allegro drawing 
func setTargetCBitmap(bmp *C.ALLEGRO_BITMAP) {
    C.al_set_target_bitmap(bmp)
}

// Sets the target bitmap of the allegro drawing
func SetTargetBitmap(bmp Bitmap) {
    setTargetCBitmap(bmp.handle)
}

// Sets the target C backbuffer of allegro drawing 
func setTargetCBackbuffer(display *C.ALLEGRO_DISPLAY) {
    C.al_set_target_backbuffer(display)
}

// Sets the target backbuffer of allegro drawing 
func SetTargetBackbuffer(display *Display) {
    setTargetCBackbuffer(display.handle)
}

// Gets the backbuffer bitmap of the display 
func (self *Display) Backbuffer() *Bitmap {
    return wrapBitmapRaw(C.al_get_backbuffer(self.handle))
}

// Gets the target bitmap of allegro drawing
func TargetBitmap() *Bitmap {
    return wrapBitmapRaw(C.al_get_target_bitmap())
}

// Must be called to acknowledge a RESIZE event
func (self *Display) AcknowledgeResize() bool {
    return cb2b(C.al_acknowledge_resize(self.handle))
}

// Updates a region of the display (not the whole display like flip does)
func UpdateDisplayRegion(x, y, width, height int) {
    C.al_update_display_region(C.int(x), C.int(y), C.int(width), C.int(height))
}

// Returns true of the bitmap is compatible with the current display, false if not. 
func (bitmap *Bitmap) IsCompatibleBitmap() bool {
    return cb2b(C.al_is_compatible_bitmap(bitmap.handle))
}

// Waits for the vertical retrace of the monitor to lessen tearing.
func WaitForVsync() {
    C.al_wait_for_vsync()
}

// Gets the event source of the display to registeron an event queue 
// with RegisterEventSource.
func (self *Display) GetEventSource() *EventSource {
    return wrapEventSourceRaw(C.al_get_display_event_source(self.handle))
}

// Sets the display icon the window manager should use for the display window
func (self *Display) SetDisplayIcon(bitmap *Bitmap) {
    C.al_set_display_icon(self.handle, bitmap.handle)
}


// Converts an array of Bitmaps to an array of ALLEGRO_BITMAPS  and a length 
func CBitmaps(bitmaps []*Bitmap) (count C.int, cbitmaps **C.ALLEGRO_BITMAP) {
    length := len(bitmaps)
    cbitmaps   = (**C.ALLEGRO_BITMAP)(malloc(length * int(unsafe.Sizeof(*cbitmaps))))
    tmpslice := (*[1 << 30]*C.ALLEGRO_BITMAP)(unsafe.Pointer(cbitmaps))[:length:length]
    for i, b := range bitmaps {
        tmpslice[i] = b.handle
    }
    
    count = C.int(length)
    return count, cbitmaps 
}

// frees the data allocated by Cstrings
func CBitmapsFree(count C.int, cbitmaps **C.ALLEGRO_BITMAP) {
    free(unsafe.Pointer(cbitmaps))
}


// Sets the display icons the window manager should use for the display window
func (self *Display) SetDisplayIcons(bitmaps []*Bitmap) {
    count , cbitmaps := CBitmaps(bitmaps)   
    defer CBitmapsFree(count, cbitmaps) 
    C.al_set_display_icons(self.handle, count, cbitmaps)
}


// Gets the number of available video adapters (I.E. grapic cards)
func NumVideoAdapters() int {
    return int(C.al_get_num_video_adapters())
}

// Converts a monitor info pointer to a C  * ALLEGRO_MONITOR_INFO
func (self *MonitorInfo) toC() *C.ALLEGRO_MONITOR_INFO {
    return (*C.ALLEGRO_MONITOR_INFO)(self)
}

// Gets the monitor info for the index'th video adapter
func (self *MonitorInfo) Get(index int) bool {
    return cb2b(C.al_get_monitor_info(C.int(index), self.toC()))
}

// Gets the monitor info for the index'th video adapter
func GetMonitorInfo(index int) *MonitorInfo {
    var info MonitorInfo
    if (&info).Get(index) {
        return &info
    }
    return nil
}

func (mi * MonitorInfo) String() string {
    return fmt.Sprintf("%d %d %d %d", mi.X1(), mi.Y1(), mi.X2(), mi.Y2())
}

// Gets all available monitors and their info
func GetAllMonitorInfo() []*MonitorInfo {
    count := NumVideoAdapters();
    info := make([]*MonitorInfo, count)
    for i := 0 ; i < count; i ++ {
        info[i] = GetMonitorInfo(i)
    }
    return info
}

// Returns the number of the display adapter where new dsplays will be created
func NewDisplayAdapter() int {
    return int(C.al_get_new_display_adapter())
}

// Sets the number of the display adapter where new dsplays will be created
func SetNewDisplayAdapter(adapter int) {
    C.al_set_new_display_adapter(C.int(adapter))
}

// Returns the position where new windowed displays will be created
func NewWindowPosition() (x, y int) {
    var cx, cy C.int
    C.al_get_new_window_position(&cx, &cy)
    return int(cx), int(cy)
}

// Sets the position where new windowed displays will be created
func SetNewWindowPosition(x, y int) {
    C.al_set_new_window_position(C.int(x), C.int(y))
}

// Returns the current position of the windowed display
func (self *Display) WindowPosition() (x, y int) {
    var cx, cy C.int
    C.al_get_window_position(self.handle, &cx, &cy)
    return int(cx), int(cy)
}

// Sets the position where new windowed displays will be created
func (self *Display) SetWindowPosition(x, y int) {
    C.al_set_window_position(self.handle, C.int(x), C.int(y))
}

// Constrains the window of a display. The environment might ignore the restraints.
// 0 means no restraint.
func (self *Display) SetWindowConstraints(min_w, min_h, max_w, max_h int) {
    C.al_set_window_constraints(self.handle, C.int(min_w), C.int(min_h), C.int(max_w), C.int(max_h))
}

// Returns the current constraints of the windowed display
func (self *Display) WindowContraints() (min_w, min_h, max_w, max_h int) {
    var cmin_w, cmin_h, cmax_w, c_max_h C.int
    C.al_get_window_constraints(self.handle, &cmin_w, &cmin_h, &cmax_w, &c_max_h)
    return int(cmin_w), int(cmin_h), int(cmax_w), int(c_max_h)
}


// Gets the title for displays that will be newly created
func NewWindowTitle() string {
    return C.GoString(C.al_get_new_window_title())
}

// Sets the title of the windowed display
func (self *Display) SetWindowTitle(str string) {
    cstr := cstr(str)
    defer cstrFree(cstr)
    C.al_set_window_title(self.handle, cstr)
}

// Sets the title of newly created windowed displays
func SetNewWindowTitle(str string) {
    cstr := cstr(str)
    defer cstrFree(cstr)
    C.al_set_new_window_title(cstr)
}

// Sets a display option to be used when a new display is created
func SetNewDisplayOption(option, value, importance int) {
    C.al_set_new_display_option(C.int(option), C.int(value), C.int(importance))
}

// Resets all display oprions for new displays to their default values.
func ResetNewDisplayOptions() {
    C.al_reset_new_display_options()
}

// Gets the display option of this display
func (self *Display) DisplayOption(option int) int {
    return int(C.al_get_display_option(self.handle, C.int(option)))
}

// Allows to speed up drawing by holding the display . Only bitmap functions and font 
// drawing, as well as tranformations should be used until the hold is released
func HoldBitmapDrawing(hold bool) {
    C.al_hold_bitmap_drawing(b2cb(hold))
}

// Returns whether or not the bitmap drawing was held
func IsBitmapDrawingHeld() bool {
    return bool(C.al_is_bitmap_drawing_held())
}

/* UNSTABLE API
func (disp * Display) BackupDirtyBitmaps() {
    C.backup_dirty_bitmaps(disp.handle)
}
*/