func (t *Text) draw_texture(texture *sdl.Texture, x, y int32, center_x, center_y bool) {
_, _, t.w, t.h, _ = texture.Query()
if center_x {
x = int32(win_size/2 - t.w/2)
}
if center_y {
y = int32(win_size/2 - t.h/2)
}
dst = sdl.Rect{x, y, int32(t.w), int32(t.h)}
renderer.Copy(texture, &src, &dst)
}
// DestroyGraphic destroys a Graphic that has been previously loaded by
// LoadGraphic. It must be called once for each graphic that has been loaded
// before the program exists.
//
// DestroyGraphic will panic if:
//
// 1. The Graphic, g, does not contain a Graphic type.
//
// 2. The toolbox has not been initialised.
func DestroyGraphic(g Graphic) {
if !initialised {
// this stops execution here, so ne need for an else after the if
panic(notInitialisedMessage)
}
if g == nil {
panic(nilGraphicMessage)
}
var t *sdl.Texture
t = g
t.Destroy()
}
func lockTexture(tex *sdl.Texture, width int, height int) (pixels []Pixel, pitch int) {
var data unsafe.Pointer
err := tex.Lock(nil, &data, &pitch)
if err != nil {
fmt.Fprintf(os.Stderr, "tex.Lock: %v", err)
panic(err)
}
// Convert pitch units from byte to pixels
pitch /= 4
pixels = sliceFromPixelPtr(data, width*height)
return
}
func run() int {
var window *sdl.Window
var renderer *sdl.Renderer
var texture *sdl.Texture
var src, dst sdl.Rect
var err error
window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
winWidth, winHeight, sdl.WINDOW_SHOWN)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err)
return 1
}
defer window.Destroy()
renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err)
return 2
}
defer renderer.Destroy()
image, err := img.Load(imageName)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to load PNG: %s\n", err)
return 3
}
defer image.Free()
texture, err = renderer.CreateTextureFromSurface(image)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err)
return 4
}
defer texture.Destroy()
src = sdl.Rect{0, 0, 512, 512}
dst = sdl.Rect{100, 50, 512, 512}
renderer.Clear()
renderer.SetDrawColor(255, 0, 0, 255)
renderer.FillRect(&sdl.Rect{0, 0, int32(winWidth), int32(winHeight)})
renderer.Copy(texture, &src, &dst)
renderer.Present()
sdl.Delay(2000)
return 0
}
func main() {
var window *sdl.Window
var renderer *sdl.Renderer
var texture *sdl.Texture
var src, dst sdl.Rect
window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
winWidth, winHeight, sdl.WINDOW_SHOWN)
if window == nil {
fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError())
os.Exit(1)
}
renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
if renderer == nil {
fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError())
os.Exit(2)
}
image := img.Load(imageName)
if image == nil {
fmt.Fprintf(os.Stderr, "Failed to load PNG: %s\n", sdl.GetError())
os.Exit(3)
}
texture = renderer.CreateTextureFromSurface(image)
if texture == nil {
fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", sdl.GetError())
os.Exit(4)
}
src = sdl.Rect{0, 0, 512, 512}
dst = sdl.Rect{100, 50, 512, 512}
renderer.Clear()
renderer.SetDrawColor(255, 0, 0, 255)
renderer.FillRect(&sdl.Rect{0, 0, int32(winWidth), int32(winHeight)})
renderer.Copy(texture, &src, &dst)
renderer.Present()
sdl.Delay(2000)
image.Free()
texture.Destroy()
renderer.Destroy()
window.Destroy()
}
func main() {
var window *sdl.Window
var renderer *sdl.Renderer
var image *sdl.Surface
var texture *sdl.Texture
var src, dst sdl.Rect
var err error
window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
winWidth, winHeight, sdl.WINDOW_SHOWN)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err)
os.Exit(1)
}
defer window.Destroy()
renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err)
os.Exit(2)
}
defer renderer.Destroy()
image, err = sdl.LoadBMP(imageName)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to load BMP: %s\n", err)
os.Exit(3)
}
defer image.Free()
texture, err = renderer.CreateTextureFromSurface(image)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err)
os.Exit(4)
}
defer texture.Destroy()
src = sdl.Rect{0, 0, 512, 512}
dst = sdl.Rect{100, 50, 512, 512}
renderer.Clear()
renderer.Copy(texture, &src, &dst)
renderer.Present()
sdl.Delay(2000)
}
func (t *Texture) MarkSubTexture(r splish.Rectangle) interface{} {
si := t.Src.SubImage(r.ToImage()).(*image.RGBA)
size := r.Size()
var subTex *sdl.Texture
var err error
subTex, err = t.Win.renderer.CreateTexture(
sdl.PIXELFORMAT_RGBA8888,
sdl.TEXTUREACCESS_STATIC,
int(size.X),
int(size.Y),
)
if err == nil {
err = subTex.Update(nil, unsafe.Pointer(&si.Pix), t.Src.Stride)
}
if err != nil {
return 0
}
t.Subs = append(t.Subs, subTex)
return len(t.Subs) - 1
}
// GetSizeOfGraphic returns the width and heigth of the Graphic, g.
// GetSizeOfGraphic returns two numbers of type int. The first numnber,
// marked as 'width', is the width of the Graphic, g, in pixels. The second number,
// marked as 'height' is the height of the Graphic, g, in pixels.
//
// GetSizeOfGraphic will panic if:
//
// 1. The Graphic, g, does not contain a Graphic type.
//
// 2. The toolbox has not been initialised.
func GetSizeOfGraphic(g Graphic) (width, height int) {
if !initialised {
// this stops execution here, so ne need for an else after the if
panic(notInitialisedMessage)
}
if g == nil {
panic(nilGraphicMessage)
}
var w, h int32
var err error
var t *sdl.Texture
t = g
_, _, w, h, err = t.Query()
if err != nil {
fmt.Print("Failed to query texture: ")
fmt.Println(err)
panic(err)
}
width = int(w)
height = int(h)
// return is implicit - using named return paramaters
return
}
func LoadTMX(mapname string, renderer *sdl.Renderer) ([][]Space, []*Object) {
f, _ := os.Open(mapname)
output, _ := ioutil.ReadAll(f)
_ = f.Close()
tmx := &TMX{}
err := xml.Unmarshal(output, tmx)
if err != nil {
fmt.Fprintf(os.Stderr, "Error parsing the tmx map: %s\n", err)
os.Exit(11)
}
var tilesetTxt *sdl.Texture
for i := 0; i < len(tmx.Tilesets); i++ {
tmx.Tilesets[i].TTMap = make(map[int][4]*Terrain)
tilesetImg, err := img.Load("assets/" + tmx.Tilesets[i].Image.Src)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to load PNG: %s\n", err)
os.Exit(3)
}
defer tilesetImg.Free()
tilesetTxt, err = renderer.CreateTextureFromSurface(tilesetImg)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err)
os.Exit(4)
}
defer tilesetTxt.Destroy()
for _, tt := range tmx.Tilesets[i].TerrainTiles {
var terrList [4]*Terrain
// Spliting and converting into integer so that it
// can be used as array idx
for ti, terr := range strings.Split(tt.TerStr, ",") {
ttype, _ := strconv.Atoi(terr)
terrList[ti] = &tmx.Tilesets[i].TerrTypes[ttype]
}
tmx.Tilesets[i].TTMap[tt.Id] = terrList
}
tmx.Tilesets[i].Txtr = tilesetTxt
}
world := make([][]Space, tmx.HeightTiles)
for i := 0; i < tmx.Layers[0].Height; i++ {
world[i] = make([]Space, tmx.WidthTiles)
}
ts := tmx.Tilesets[0]
for li, layer := range tmx.Layers {
for i := 0; i < layer.Height; i++ {
for j := 0; j < layer.Width; j++ {
tile := layer.Tiles[(i*layer.Height)+j]
// RENDER ORDER: RIGHT-DOWN
world[j][i].Terrains = ts.TTMap[tile.Gid]
world[j][i].Gfxs[li] = &Gfx{
Txtr: ts.Txtr,
Source: ts.GetGIDRect(tile.Gid),
}
for _, terr := range world[i][j].Terrains {
if terr == nil {
continue
}
for _, prop := range terr.PropList {
switch prop.Name {
case "COLL":
world[i][j].Coll = (prop.Value == "1")
break
case "WARP":
world[i][j].Warp = prop.Value
break
}
}
}
}
}
}
// Now loading the Tiled Objects
var objects []*Object
for _, g := range tmx.ObjGroups {
for _, o := range g.Objects {
obj := &Object{
Pos: sdl.Rect{o.X, o.Y, o.W, o.H},
Gfx: nil,
Type: TRIG,
}
objects = append(objects, obj)
}
}
//tmx = nil
return world, objects
}
func play(seq *video.VideoSequence) {
var window *sdl.Window
var renderer *sdl.Renderer
var texture *sdl.Texture
var err error
window, err = sdl.CreateWindow(winTitle,
sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
winWidth, winHeight,
sdl.WINDOW_SHOWN)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err)
os.Exit(1)
}
defer window.Destroy()
renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err)
os.Exit(2)
}
defer renderer.Destroy()
seq.AlignTo(video.SequenceHeaderStartCode)
var pointer unsafe.Pointer
var pitch int
var yLen int
var cLen int
sdl.Delay(1000)
renderer.Present()
for {
img, err := seq.Next()
if err == io.EOF {
break
}
if err != nil {
fmt.Fprintf(os.Stderr, "Decoding error: %s\n", err)
os.Exit(3)
}
if texture == nil {
w, h := seq.Size()
yLen = w * h
cLen = (w * h) >> 2
texture, err = renderer.CreateTexture(sdl.PIXELFORMAT_IYUV, sdl.TEXTUREACCESS_STREAMING, w, h)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err)
os.Exit(4)
}
defer texture.Destroy()
}
{
texture.Lock(nil, &pointer, &pitch)
// Convert pointer to []uint8
pixels := *(*[]uint8)(unsafe.Pointer(&reflect.SliceHeader{
Data: uintptr(pointer),
Len: yLen + 2*cLen,
Cap: yLen + 2*cLen,
}))
// Select color planes
y := pixels[0:yLen]
cb := pixels[yLen : yLen+cLen]
cr := pixels[yLen+cLen : yLen+cLen+cLen]
// Copy image data into texture
copy(y, img.Y)
copy(cb, img.Cb)
copy(cr, img.Cr)
texture.Unlock()
}
err = renderer.Copy(texture, nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "Copy failed: %s\n", err)
os.Exit(5)
}
renderer.Present()
}
}
