gfx

package

v1.0.4 Latest Latest Go to latest Published: Feb 26, 2020 License: MIT Imports: 3 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/Youngju-Heo/gomedia

Links

Open Source Insights

Documentation ¶

Overview ¶

Package gfx is an add-on for SDL2 that provides drawing of graphics primitives, rotozoomer, MMX image filters and framerate control.

Index ¶

Constants
func AACircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool
func AACircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool
func AAEllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool
func AAEllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool
func AALineColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool
func AALineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool
func AAPolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool
func AAPolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool
func ArcColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool
func ArcRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool
func BezierColor(renderer *sdl.Renderer, vx, vy []int16, s int, color sdl.Color) bool
func BezierRGBA(renderer *sdl.Renderer, vx, vy []int16, s int, r, g, b, a uint8) bool
func BoxColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool
func BoxRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool
func CharacterColor(renderer *sdl.Renderer, x, y int32, c byte, color sdl.Color) bool
func CharacterRGBA(renderer *sdl.Renderer, x, y int32, c, r, g, b, a uint8) bool
func CircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool
func CircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool
func EllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool
func EllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool
func FilledCircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool
func FilledCircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool
func FilledEllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool
func FilledEllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool
func FilledPieColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool
func FilledPieRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool
func FilledPolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool
func FilledPolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool
func FilledTrigonColor(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, color sdl.Color) bool
func FilledTrigonRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, r, g, b, a uint8) bool
func FramerateDelay(manager *FPSmanager) uint32
func GetFramecount(manager *FPSmanager) (int, bool)
func GetFramerate(manager *FPSmanager) (int, bool)
func HlineColor(renderer *sdl.Renderer, x1, x2, y int32, color sdl.Color) bool
func HlineRGBA(renderer *sdl.Renderer, x1, x2, y int32, r, g, b, a uint8) bool
func ImageFilterAbsDiff(src1, src2, dest []byte) bool
func ImageFilterAdd(src1, src2, dest []byte) bool
func ImageFilterAddByte(src1, dest []byte, c byte) bool
func ImageFilterAddUint(src1, dest []byte, c uint) bool
func ImageFilterBinarizeUsingThreshold(src1, dest []byte, t byte) bool
func ImageFilterBitAnd(src1, src2, dest []byte) bool
func ImageFilterBitNegation(src1, dest []byte) bool
func ImageFilterBitOr(src1, src2, dest []byte) bool
func ImageFilterClipToRange(src1, dest []byte, tmin, tmax byte) bool
func ImageFilterDiv(src1, src2, dest []byte) bool
func ImageFilterMMXdetect() bool
func ImageFilterMMXoff()
func ImageFilterMMXon()
func ImageFilterMean(src1, src2, dest []byte) bool
func ImageFilterMult(src1, src2, dest []byte) bool
func ImageFilterMultByByte(src1, dest []byte, c byte) bool
func ImageFilterMultDivby2(src1, src2, dest []byte) bool
func ImageFilterMultDivby4(src1, src2, dest []byte) bool
func ImageFilterMultNor(src1, src2, dest []byte) bool
func ImageFilterNormalizeLinear(src1, dest []byte, cmin, cmax, nmin, nmax int) bool
func ImageFilterShiftLeft(src1, dest []byte, n byte) bool
func ImageFilterShiftLeftByte(src1, dest []byte, n byte) bool
func ImageFilterShiftLeftUint(src1, dest []byte, n byte) bool
func ImageFilterShiftRight(src1, dest []byte, n byte) bool
func ImageFilterShiftRightAndMultByByte(src1, dest []byte, n, c byte) bool
func ImageFilterShiftRightUint(src1, dest []byte, n byte) bool
func ImageFilterSub(src1, src2, dest []byte) bool
func ImageFilterSubByte(src1, dest []byte, c byte) bool
func ImageFilterSubUint(src1, dest []byte, c uint) bool
func InitFramerate(manager *FPSmanager)
func LineColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool
func LineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool
func PieColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool
func PieRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool
func PixelColor(renderer *sdl.Renderer, x, y int32, color sdl.Color) bool
func PixelRGBA(renderer *sdl.Renderer, x, y int32, r, g, b, a uint8) bool
func PolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool
func PolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool
func RectangleColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool
func RectangleRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool
func RotateSurface90Degrees(src *sdl.Surface, numClockwiseTurns int) *sdl.Surface
func RotoZoomSurface(src *sdl.Surface, angle, zoom float64, smooth int) *sdl.Surface
func RotoZoomSurfaceXY(src *sdl.Surface, angle, zoomx, zoomy float64, smooth int) *sdl.Surface
func RoundedBoxColor(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, color sdl.Color) bool
func RoundedBoxRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, r, g, b, a uint8) bool
func RoundedRectangleColor(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, color sdl.Color) bool
func RoundedRectangleRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, r, g, b, a uint8) bool
func SetFont(fontdata []byte, cw, ch uint32)
func SetFontRotation(rotation uint32)
func SetFramerate(manager *FPSmanager, rate uint32) bool
func ShrinkSurface(src *sdl.Surface, factorx, factory int) *sdl.Surface
func StringColor(renderer *sdl.Renderer, x, y int32, s string, color sdl.Color) bool
func StringRGBA(renderer *sdl.Renderer, x, y int32, s string, r, g, b, a uint8) bool
func TexturedPolygon(renderer *sdl.Renderer, vx, vy []int16, surface *sdl.Surface, ...) bool
func ThickLineColor(renderer *sdl.Renderer, x1, y1, x2, y2, width int32, color sdl.Color) bool
func ThickLineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, width int32, r, g, b, a uint8) bool
func TrigonColor(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, color sdl.Color) bool
func TrigonRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, r, g, b, a uint8) bool
func VlineColor(renderer *sdl.Renderer, x, y1, y2 int32, color sdl.Color) bool
func VlineRGBA(renderer *sdl.Renderer, x, y1, y2 int32, r, g, b, a uint8) bool
func ZoomSurface(src *sdl.Surface, zoomx, zoomy float64, smooth int) *sdl.Surface
func ZoomSurfaceSize(width, height int32, zoomx, zoomy float64) (dstwidth, dstheight int)
type FPSmanager

Constants ¶

View Source

const (
	FPS_UPPER_LIMIT = 200 // highest possible rate supported by framerate controller in Hz (1/s)
	FPS_LOWER_LIMIT = 1   // lowest possible rate supported by framerate controller in Hz (1/s)
	FPS_DEFAULT     = 30  // default rate of framerate controller in Hz (1/s)
)

FPS definitions.

View Source

const (
	SMOOTHING_OFF = 0 // disable anti-aliasing (no smoothing)
	SMOOTHING_ON  = 1 // enable anti-aliasing (smoothing)
)

Rotozoom smoothing settings.

Variables ¶

This section is empty.

Functions ¶

func AACircleColor ¶

func AACircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool

AACircleColor draws anti-aliased circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#aad64361b01181e6aff940add96d23c61)

func AACircleRGBA ¶

func AACircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool

AACircleRGBA draws anti-aliased circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a332780885aa2cfdc2de34dcff8d67e8b)

func AAEllipseColor ¶

func AAEllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool

AAEllipseColor draws anti-aliased ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a1c7d20dcba8e0d7ce483f4c854c438be)

func AAEllipseRGBA ¶

func AAEllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool

AAEllipseRGBA draws anti-aliased ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#ab9f0f00d7fb2f04aa9ba1630e31a27bf)

func AALineColor ¶

func AALineColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool

AALineColor draws anti-aliased line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a25c56f2def855db01dcf7ff7f7356182)

func AALineRGBA ¶

func AALineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool

AALineRGBA draws anti-aliased line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a25c56f2def855db01dcf7ff7f7356182)

func AAPolygonColor ¶

func AAPolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool

AAPolygonColor draws anti-aliased polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a09950a50e8806e88bb20c543c58cc6a8)

func AAPolygonRGBA ¶

func AAPolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool

AAPolygonRGBA draws anti-aliased polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a7d08522e52d8290c5c498ce435fa51f0)

func ArcColor ¶

func ArcColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool

ArcColor draws arc with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a461b8ac31e00306aee5f8a4c242671d2)

func ArcRGBA ¶

func ArcRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool

ArcRGBA draws arc with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a2aff993d0d8d64564e16145f401d3cf1)

func BezierColor ¶

func BezierColor(renderer *sdl.Renderer, vx, vy []int16, s int, color sdl.Color) bool

BezierColor draws a bezier curve with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#adfe8f9c42d29a090aae15eeb19b80d51)

func BezierRGBA ¶

func BezierRGBA(renderer *sdl.Renderer, vx, vy []int16, s int, r, g, b, a uint8) bool

BezierRGBA draws a bezier curve with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a4b7fbf6cc366abdf345a25308d53e125)

func BoxColor ¶

func BoxColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool

BoxColor draws box (filled rectangle) with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a6bb30dfc32d0aee20271a0356a2e2fd0)

func BoxRGBA ¶

func BoxRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool

BoxRGBA draws box (filled rectangle) with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a1864b3062793a7f7dd81aaf8c8abd6b0)

func CharacterColor ¶

func CharacterColor(renderer *sdl.Renderer, x, y int32, c byte, color sdl.Color) bool

CharacterColor draws a character of the currently set font. On first call for a particular character and color combination, the function needs to generate the character surface (slower). Subsequent calls blit a cached surface (fast). Uses alpha blending if A<255 in color. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#aef5fdeb16c4578d8cd50e106299e993e)

func CharacterRGBA ¶

func CharacterRGBA(renderer *sdl.Renderer, x, y int32, c, r, g, b, a uint8) bool

CharacterRGBA draws a character of the currently set font. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a96379d2ce808aa642afb57bced0c670e)

func CircleColor ¶

func CircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool

CircleColor draws circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#aa99bd361cc947b448142720f2ca3320e)

func CircleRGBA ¶

func CircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool

CircleRGBA draws circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a7fe51d4c9426c8795e58c7ddd313b0a4)

func EllipseColor ¶

func EllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool

EllipseColor draws ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a476cff7702f4be9090871e35859782f0)

func EllipseRGBA ¶

func EllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool

EllipseRGBA draws ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a18c8a26c9009482eec40f9f4a6945fd1)

func FilledCircleColor ¶

func FilledCircleColor(renderer *sdl.Renderer, x, y, rad int32, color sdl.Color) bool

FilledCircleColor draws filled circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a39147d1282ec814a1b9e31243aad0359)

func FilledCircleRGBA ¶

func FilledCircleRGBA(renderer *sdl.Renderer, x, y, rad int32, r, g, b, a uint8) bool

FilledCircleRGBA draws filled circle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a562ba6b18fb70547cd50cb3bb0f70272)

func FilledEllipseColor ¶

func FilledEllipseColor(renderer *sdl.Renderer, x, y, rx, ry int32, color sdl.Color) bool

FilledEllipseColor draws filled ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a8fed50800f2f1bdfaa048698f5052f25)

func FilledEllipseRGBA ¶

func FilledEllipseRGBA(renderer *sdl.Renderer, x, y, rx, ry int32, r, g, b, a uint8) bool

FilledEllipseRGBA draws filled ellipse with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a33595ad996dd0dcccde3abbcef540eec)

func FilledPieColor ¶

func FilledPieColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool

FilledPieColor draws filled pie with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a2c30ee985b2513dc58d9b19d4e71562b)

func FilledPieRGBA ¶

func FilledPieRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool

FilledPieRGBA draws filled pie with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a4ffdfd2834f3ef0fd0ee622b5f1d16b8)

func FilledPolygonColor ¶

func FilledPolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool

FilledPolygonColor draws filled polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#af22692175cb73329410cbcc7d7491c4d)

func FilledPolygonRGBA ¶

func FilledPolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool

FilledPolygonRGBA draws filled polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a40ef0b898905c190c193f0f55deb5a6c)

func FilledTrigonColor ¶

func FilledTrigonColor(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, color sdl.Color) bool

FilledTrigonColor draws filled trigon (triangle) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a78d4ed2372527f3b78f5893928b0f519)

func FilledTrigonRGBA ¶

func FilledTrigonRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, r, g, b, a uint8) bool

FilledTrigonRGBA draws filled trigon (triangle) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a8f318d776ff1e3c6790405e0e59e5356)

func FramerateDelay ¶

func FramerateDelay(manager *FPSmanager) uint32

FramerateDelay delays execution to maintain a constant framerate and calculate fps. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__framerate_8c.html#afce13fa3dd37130deb4975d8b230c3ba)

func GetFramecount ¶

func GetFramecount(manager *FPSmanager) (int, bool)

GetFramecount returns the current framecount. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__framerate_8c.html#a96b13e26f8436222e866904a592a6eec)

func GetFramerate ¶

func GetFramerate(manager *FPSmanager) (int, bool)

GetFramerate returns the current target framerate in Hz. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__framerate_8c.html#a575bb511d6f817ad846a788cbd08ae91)

func HlineColor ¶

func HlineColor(renderer *sdl.Renderer, x1, x2, y int32, color sdl.Color) bool

HlineColor draws horizontal line with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#ac211a904dce45093315e15b10c80d8ac)

func HlineRGBA ¶

func HlineRGBA(renderer *sdl.Renderer, x1, x2, y int32, r, g, b, a uint8) bool

HlineRGBA draws horizontal line with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a6608a0d1d4c7e16fa1afcbd3eb5c3850)

func ImageFilterAbsDiff ¶

func ImageFilterAbsDiff(src1, src2, dest []byte) bool

ImageFilterAbsDiff filters using AbsDiff: D = | S1 - S2 |. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a472909f904274255cd6793c520172e48)

func ImageFilterAdd ¶

func ImageFilterAdd(src1, src2, dest []byte) bool

ImageFilterAdd filters using Add: D = saturation255(S1 + S2). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a9f06507eb0b63198dbd67495d61c9b20)

func ImageFilterAddByte ¶

func ImageFilterAddByte(src1, dest []byte, c byte) bool

ImageFilterAddByte filters using AddByte: D = saturation255(S + C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a812cb307cb60ef31f1ffe81a9eee6bb1)

func ImageFilterAddUint ¶

func ImageFilterAddUint(src1, dest []byte, c uint) bool

ImageFilterAddUint filters using AddUint: D = saturation255((S[i] + Cs[i % 4]), Cs=Swap32((uint)C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a660543426c47dfec39a349eb3b8f905b)

func ImageFilterBinarizeUsingThreshold ¶

func ImageFilterBinarizeUsingThreshold(src1, dest []byte, t byte) bool

ImageFilterBinarizeUsingThreshold filters using BinarizeUsingThreshold: D = (S >= T) ? 255:0. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a951a062e15df290a137428e1e0f4d5ce)

func ImageFilterBitAnd ¶

func ImageFilterBitAnd(src1, src2, dest []byte) bool

ImageFilterBitAnd filters using BitAnd: D = S1 & S2. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a85837ce1b5de1f907b6b9053922b5cbc)

func ImageFilterBitNegation ¶

func ImageFilterBitNegation(src1, dest []byte) bool

ImageFilterBitNegation filters using BitNegation: D = !S. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#ac3abfaa8ec2e88c3c4893588c5555856)

func ImageFilterBitOr ¶

func ImageFilterBitOr(src1, src2, dest []byte) bool

ImageFilterBitOr filters using BitOr: D = S1 | S2. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a5cf1c477f4e32d02f74ee95d9f7b0021)

func ImageFilterClipToRange ¶

func ImageFilterClipToRange(src1, dest []byte, tmin, tmax byte) bool

ImageFilterClipToRange filters using ClipToRange: D = (S >= Tmin) & (S <= Tmax) S:Tmin | Tmax. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#ab7224abc4ecc1b8a6f4441ef8379515f)

func ImageFilterDiv ¶

func ImageFilterDiv(src1, src2, dest []byte) bool

ImageFilterDiv filters using Div: D = S1 / S2. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a0ea22f01c6a4724bac307da3e5355f58)

func ImageFilterMMXdetect ¶

func ImageFilterMMXdetect() bool

ImageFilterMMXdetect reports whether MMX check for filter functions is enabled. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a798ce71024ee1a1d1b174fd60fe79917)

func ImageFilterMMXoff ¶

func ImageFilterMMXoff()

ImageFilterMMXoff disables MMX check for filter functions and force to use non-MMX C based code. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a5dff661660755161bb4aaf6199cd1384)

func ImageFilterMMXon ¶

func ImageFilterMMXon()

ImageFilterMMXon enables MMX check for filter functions and use MMX code if available. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a353ee234c3b51b33c4c5c4b30db5832d)

func ImageFilterMean ¶

func ImageFilterMean(src1, src2, dest []byte) bool

ImageFilterMean filters using Mean: D = S1/2 + S2/2. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#ace072118fef77973210eb04fb4bfc779)

func ImageFilterMult ¶

func ImageFilterMult(src1, src2, dest []byte) bool

ImageFilterMult filters using Mult: D = saturation255(S1 * S2). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#af4633031d40a9ea0956a2f3c6c87a384)

func ImageFilterMultByByte ¶

func ImageFilterMultByByte(src1, dest []byte, c byte) bool

ImageFilterMultByByte filters using MultByByte: D = saturation255(S * C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a06f7a19d6e2fc89d7b48cc45d715806d)

func ImageFilterMultDivby2 ¶

func ImageFilterMultDivby2(src1, src2, dest []byte) bool

ImageFilterMultDivby2 filter using MultDivby2: D = saturation255(S1/2 * S2) (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a80737f6427c7bdb30d39a92f6524fc14)

func ImageFilterMultDivby4 ¶

func ImageFilterMultDivby4(src1, src2, dest []byte) bool

ImageFilterMultDivby4 filters using MultDivby4: D = saturation255(S1/2 * S2/2). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a30e685653eb1050c7d48feaeb8f801a1)

func ImageFilterMultNor ¶

func ImageFilterMultNor(src1, src2, dest []byte) bool

ImageFilterMultNor filters using MultNor: D = S1 * S2. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a5f3c9fd40426bb46eba5ac167505dcc5)

func ImageFilterNormalizeLinear ¶

func ImageFilterNormalizeLinear(src1, dest []byte, cmin, cmax, nmin, nmax int) bool

ImageFilterNormalizeLinear filters using NormalizeLinear: D = saturation255((Nmax - Nmin)/(Cmax - Cmin)*(S - Cmin) + Nmin). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#ab018ace4db884cac953b06b09c00828b)

func ImageFilterShiftLeft ¶

func ImageFilterShiftLeft(src1, dest []byte, n byte) bool

ImageFilterShiftLeft filters ShiftLeft: D = saturation255(S << N). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a98372fea76310903abef7808db10d226)

func ImageFilterShiftLeftByte ¶

func ImageFilterShiftLeftByte(src1, dest []byte, n byte) bool

ImageFilterShiftLeftByte filters using ShiftLeftByte: D = (S << N). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a4561a73b249a26babc4c469ffbdae604)

func ImageFilterShiftLeftUint ¶

func ImageFilterShiftLeftUint(src1, dest []byte, n byte) bool

ImageFilterShiftLeftUint filters using ShiftLeftUint: D = ((uint)S << N). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a250e796fb2db470da0a78b74b78114e8)

func ImageFilterShiftRight ¶

func ImageFilterShiftRight(src1, dest []byte, n byte) bool

ImageFilterShiftRight filters using ShiftRight: D = saturation0(S >> N). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a68851aed2dcc5dfd2f3b258236f3b88c)

func ImageFilterShiftRightAndMultByByte ¶

func ImageFilterShiftRightAndMultByByte(src1, dest []byte, n, c byte) bool

ImageFilterShiftRightAndMultByByte filters using ShiftRightAndMultByByte: D = saturation255((S >> N) * C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a0713d6c267fba9756d6beae81e89f9e4)

func ImageFilterShiftRightUint ¶

func ImageFilterShiftRightUint(src1, dest []byte, n byte) bool

ImageFilterShiftRightUint filters using ShiftRightUint: D = saturation0((uint)S[i] >> N). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a540d4625d76bcd03318c2a59ce650fdb)

func ImageFilterSub ¶

func ImageFilterSub(src1, src2, dest []byte) bool

ImageFilterSub filters using Sub: D = saturation0(S1 - S2). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a3c01cf8576ea7a0dfc09dbaa953c9287)

func ImageFilterSubByte ¶

func ImageFilterSubByte(src1, dest []byte, c byte) bool

ImageFilterSubByte filters using SubByte: D = saturation0(S - C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#a387fb6f0d48cc5d08f37f7f9b92d14b2)

func ImageFilterSubUint ¶

func ImageFilterSubUint(src1, dest []byte, c uint) bool

ImageFilterSubUint filters using SubUint: D = saturation0(S[i] - Cs[i % 4]), Cs=Swap32((uint)C). (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__image_filter_8c.html#abb343ef95e22945e1d4d648b2e176e64)

func InitFramerate ¶

func InitFramerate(manager *FPSmanager)

InitFramerate initializes the framerate manager. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__framerate_8c.html#a444ebaaaa6b1ceeafa921562bdab1a44)

func LineColor ¶

func LineColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool

LineColor draws line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#ad44c550fab3cb736eb049713ede94052)

func LineRGBA ¶

func LineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool

LineRGBA draws line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a760139e11a9ae5defeb755ca0c794f5f)

func PieColor ¶

func PieColor(renderer *sdl.Renderer, x, y, rad, start, end int32, color sdl.Color) bool

PieColor draws pie (outline) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a3c2bc64deabda74933f31daba6bed7be)

func PieRGBA ¶

func PieRGBA(renderer *sdl.Renderer, x, y, rad, start, end int32, r, g, b, a uint8) bool

PieRGBA draws pie (outline) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a8442f2c2bedbe27c96d8d44319981992)

func PixelColor ¶

func PixelColor(renderer *sdl.Renderer, x, y int32, color sdl.Color) bool

PixelColor pixel draws with blending enabled if a<255. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#ae6f8690e5c5a85d3263c8e16727b34ef)

func PixelRGBA ¶

func PixelRGBA(renderer *sdl.Renderer, x, y int32, r, g, b, a uint8) bool

PixelRGBA pixel draws with blending enabled if a<255. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a7b6f83bdef72f6b356664a93841381c0)

func PolygonColor ¶

func PolygonColor(renderer *sdl.Renderer, vx, vy []int16, color sdl.Color) bool

PolygonColor draws polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a2d692dc25f3b579b386dff8dcd9cbc00)

func PolygonRGBA ¶

func PolygonRGBA(renderer *sdl.Renderer, vx, vy []int16, r, g, b, a uint8) bool

PolygonRGBA draws polygon with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#ae55541ec58990420dc6dc6b9d61f33d6)

func RectangleColor ¶

func RectangleColor(renderer *sdl.Renderer, x1, y1, x2, y2 int32, color sdl.Color) bool

RectangleColor draws rectangle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a6ab25c393f6e5f8d68ea3365f6ea98d2)

func RectangleRGBA ¶

func RectangleRGBA(renderer *sdl.Renderer, x1, y1, x2, y2 int32, r, g, b, a uint8) bool

RectangleRGBA draws rectangle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a40991c6eeb936d35d0a8e8aa95268f72)

func RotateSurface90Degrees ¶

func RotateSurface90Degrees(src *sdl.Surface, numClockwiseTurns int) *sdl.Surface

RotateSurface90Degrees rotates a 32 bit surface in increments of 90 degrees. Specialized 90 degree rotator which rotates a 'src' surface in 90 degree increments clockwise returning a new surface. Faster than rotozoomer since not scanning or interpolation takes place. Input surface must be 32 bit. (code contributed by J. Schiller, improved by C. Allport and A. Schiffler) (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#a77563d68634cb2624d4f2f0bcdc19e73)

func RotoZoomSurface ¶

func RotoZoomSurface(src *sdl.Surface, angle, zoom float64, smooth int) *sdl.Surface

RotoZoomSurface rotates and zooms a surface and optional anti-aliasing. Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface. 'angle' is the rotation in degrees and 'zoom' a scaling factor. If 'smooth' is set then the destination 32bit surface is anti-aliased. If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#a5f64ed53eeee5f2667971c857698d1e5)

func RotoZoomSurfaceXY ¶

func RotoZoomSurfaceXY(src *sdl.Surface, angle, zoomx, zoomy float64, smooth int) *sdl.Surface

RotoZoomSurfaceXY rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing. Rotates and zooms a 32bit or 8bit 'src' surface to newly created 'dst' surface. 'angle' is the rotation in degrees, 'zoomx and 'zoomy' scaling factors. If 'smooth' is set then the destination 32bit surface is anti-aliased. If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#aab98b5b0da4ea468bacf47f7b85f0ee2)

func RoundedBoxColor ¶

func RoundedBoxColor(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, color sdl.Color) bool

RoundedBoxColor draws rounded-corner box (filled rectangle) with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a718c4f31d1e145106959c2a77d5fee9d)

func RoundedBoxRGBA ¶

func RoundedBoxRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, r, g, b, a uint8) bool

RoundedBoxRGBA draws rounded-corner box (filled rectangle) with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#aad706348fec18631d7bc48a2d91f5b4d)

func RoundedRectangleColor ¶

func RoundedRectangleColor(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, color sdl.Color) bool

RoundedRectangleColor draws rounded-corner rectangle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a830dd9dcfa39f4718aa2c269060326d0)

func RoundedRectangleRGBA ¶

func RoundedRectangleRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, rad int32, r, g, b, a uint8) bool

RoundedRectangleRGBA draws rounded-corner rectangle with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a300272b3b799f09ca6cd5c541b19f07a)

func SetFont ¶

func SetFont(fontdata []byte, cw, ch uint32)

SetFont sets or resets the current global font data. The font data array is organized in follows: [fontdata] = [character 0][character 1]...[character 255] where [character n] = [byte 1 row 1][byte 2 row 1]...[byte {pitch} row 1][byte 1 row 2] ...[byte {pitch} row height] where [byte n] = [bit 0]...[bit 7] where [bit n] = [0 for transparent pixel|1 for colored pixel]. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#afacd57651ec0e0ccab60753636862cd0)

func SetFontRotation ¶

func SetFontRotation(rotation uint32)

SetFontRotation sets current global font character rotation steps. Default is 0 (no rotation). 1 = 90deg clockwise. 2 = 180deg clockwise. 3 = 270deg clockwise. Changing the rotation, will reset the character cache.(http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#aef6796a883f07d31bbf7c7df6d1153d2)

func SetFramerate ¶

func SetFramerate(manager *FPSmanager, rate uint32) bool

SetFramerate sets the framerate in Hz. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__framerate_8c.html#afad4b503cf9719daced45fa4d9653d72)

func ShrinkSurface ¶

func ShrinkSurface(src *sdl.Surface, factorx, factory int) *sdl.Surface

ShrinkSurface shrink a surface by an integer ratio using averaging. Shrinks a 32bit or 8bit 'src' surface to a newly created 'dst' surface. 'factorx' and 'factory' are the shrinking ratios (i.e. 2=1/2 the size, 3=1/3 the size, etc.) The destination surface is antialiased by averaging the source box RGBA or Y information. If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly. The input surface is not modified. The output surface is newly allocated. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#aad3bf0cd89cc39ff874ffa778fa1495d)

func StringColor ¶

func StringColor(renderer *sdl.Renderer, x, y int32, s string, color sdl.Color) bool

StringColor draws a string in the currently set font. The spacing between consequtive characters in the string is the fixed number of pixels of the character width of the current global font. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a62d2ba55abc7673f2dfa29e6bbffefdf)

func StringRGBA ¶

func StringRGBA(renderer *sdl.Renderer, x, y int32, s string, r, g, b, a uint8) bool

StringRGBA draws a string in the currently set font. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a6ca71826e311bdd9acf13b009256aa1c)

func TexturedPolygon ¶

func TexturedPolygon(renderer *sdl.Renderer, vx, vy []int16, surface *sdl.Surface, textureDX, textureDY int) bool

TexturedPolygon draws a polygon filled with the given texture. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a65137af308ea878f28abc95419e8aef5)

func ThickLineColor ¶

func ThickLineColor(renderer *sdl.Renderer, x1, y1, x2, y2, width int32, color sdl.Color) bool

ThickLineColor draws a thick line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a1494109358b4e4b7ec300d83e3f90300)

func ThickLineRGBA ¶

func ThickLineRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, width int32, r, g, b, a uint8) bool

ThickLineRGBA draws a thick line with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a8b24d64b51e23592c93abc2aa50c818e)

func TrigonColor ¶

func TrigonColor(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, color sdl.Color) bool

TrigonColor draws trigon (triangle outline) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a7465d08ef930ebb5442c7dd246fed4b5)

func TrigonRGBA ¶

func TrigonRGBA(renderer *sdl.Renderer, x1, y1, x2, y2, x3, y3 int32, r, g, b, a uint8) bool

TrigonRGBA draws trigon (triangle outline) with alpha blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a45d6a7edcd8b25e1a60e39b7f60bda3f)

func VlineColor ¶

func VlineColor(renderer *sdl.Renderer, x, y1, y2 int32, color sdl.Color) bool

VlineColor draws vertical line with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a9b45060155a19fee24f998d7790f1d67)

func VlineRGBA ¶

func VlineRGBA(renderer *sdl.Renderer, x, y1, y2 int32, r, g, b, a uint8) bool

VlineRGBA draws vertical line with blending. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__gfx_primitives_8c.html#a8b79ac1e779755aee92b04f3a6cfc5d7)

func ZoomSurface ¶

func ZoomSurface(src *sdl.Surface, zoomx, zoomy float64, smooth int) *sdl.Surface

ZoomSurface zoom a surface by independent horizontal and vertical factors with optional smoothing. Zooms a 32bit or 8bit 'src' surface to newly created 'dst' surface. 'zoomx' and 'zoomy' are scaling factors for width and height. If 'smooth' is on then the destination 32bit surface is anti-aliased. If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly. If zoom factors are negative, the image is flipped on the axes. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#abdd772b2f6b1f26134e4e90cda657a21)

func ZoomSurfaceSize ¶

func ZoomSurfaceSize(width, height int32, zoomx, zoomy float64) (dstwidth, dstheight int)

ZoomSurfaceSize calculates the size of the target surface for a gfx.ZoomSurface() call. The minimum size of the target surface is 1. The input factors can be positive or negative. (http://www.ferzkopp.net/Software/SDL_gfx-2.0/Docs/html/_s_d_l__rotozoom_8c.html#a8ba40859c1a977dae87488dd8be1bf9a)

Types ¶

type FPSmanager ¶

type FPSmanager struct {
	FrameCount uint32
	RateTicks  float32
	BaseTicks  uint32
	LastTicks  uint32
	Rate       uint32
}

FPSmanager contains the state and timing information of the framerate controller.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL