Move functions

raylib/raudio.go

@@ -40,20 +40,73 @@ func internalAudioStreamCallbackGo(data unsafe.Pointer, frames C.int) {
 	}
 }
 
+// newWaveFromPointer - Returns new Wave from pointer
+func newWaveFromPointer(ptr unsafe.Pointer) Wave {
+	return *(*Wave)(ptr)
+}
+
 // cptr returns C pointer
 func (w *Wave) cptr() *C.Wave {
 	return (*C.Wave)(unsafe.Pointer(w))
 }
 
+// newSoundFromPointer - Returns new Sound from pointer
+func newSoundFromPointer(ptr unsafe.Pointer) Sound {
+	return *(*Sound)(ptr)
+}
+
 func (s *Sound) cptr() *C.Sound {
 	return (*C.Sound)(unsafe.Pointer(s))
 }
 
+// newAudioStreamFromPointer - Returns new AudioStream from pointer
+func newAudioStreamFromPointer(ptr unsafe.Pointer) AudioStream {
+	return *(*AudioStream)(ptr)
+}
+
 // cptr returns C pointer
 func (a *AudioStream) cptr() *C.AudioStream {
 	return (*C.AudioStream)(unsafe.Pointer(a))
 }
 
+// newMusicFromPointer - Returns new Music from pointer
+func newMusicFromPointer(ptr unsafe.Pointer) Music {
+	return *(*Music)(ptr)
+}
+
+// Sound source type
+type Sound struct {
+	Stream     AudioStream
+	FrameCount uint32
+	_          [4]byte
+}
+
+// Music type (file streaming from memory)
+// NOTE: Anything longer than ~10 seconds should be streamed
+type Music struct {
+	Stream     AudioStream
+	FrameCount uint32
+	Looping    bool
+	CtxType    int32
+	CtxData    unsafe.Pointer
+}
+
+// AudioStream type
+// NOTE: Useful to create custom audio streams not bound to a specific file
+type AudioStream struct {
+	// Buffer
+	Buffer *C.rAudioBuffer
+	// Processor
+	Processor *C.rAudioProcessor
+	// Frequency (samples per second)
+	SampleRate uint32
+	// Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+	SampleSize uint32
+	// Number of channels (1-mono, 2-stereo)
+	Channels uint32
+	_        [4]byte
+}
+
 // InitAudioDevice - Initialize audio device and context
 func InitAudioDevice() {
 	C.InitAudioDevice()

raylib/raylib.go

@@ -1,45 +1,14 @@
 /*
-Package raylib - Go bindings for raylib, a simple and easy-to-use library to learn videogames programming.
+Package raylib - Go bindings for raylib, a simple and easy-to-use library to enjoy videogames programming.
 
 raylib is highly inspired by Borland BGI graphics lib and by XNA framework.
-
 raylib could be useful for prototyping, tools development, graphic applications, embedded systems and education.
 
 NOTE for ADVENTURERS: raylib is a programming library to learn videogames programming; no fancy interface, no visual helpers, no auto-debugging... just coding in the most pure spartan-programmers way.
-
-Example:
-
-	package main
-
-	import "github.com/gen2brain/raylib-go/raylib"
-
-	func main() {
-		rl.InitWindow(800, 450, "raylib [core] example - basic window")
-
-		rl.SetTargetFPS(60)
-
-		for !rl.WindowShouldClose() {
-			rl.BeginDrawing()
-
-			rl.ClearBackground(rl.RayWhite)
-
-			rl.DrawText("Congrats! You created your first window!", 190, 200, 20, rl.LightGray)
-
-			rl.EndDrawing()
-		}
-
-		rl.CloseWindow()
-	}
 */
 package rl
 
-/*
-#include "raylib.h"
-#include <stdlib.h>
-*/
-import "C"
 import (
-	"image"
 	"image/color"
 	"io"
 	"runtime"
@@ -71,59 +40,6 @@ func NewWave(sampleCount, sampleRate, sampleSize, channels uint32, data []byte)
 	return Wave{sampleCount, sampleRate, sampleSize, channels, d}
 }
 
-// newWaveFromPointer - Returns new Wave from pointer
-func newWaveFromPointer(ptr unsafe.Pointer) Wave {
-	return *(*Wave)(ptr)
-}
-
-// Sound source type
-type Sound struct {
-	Stream     AudioStream
-	FrameCount uint32
-	_          [4]byte
-}
-
-// newSoundFromPointer - Returns new Sound from pointer
-func newSoundFromPointer(ptr unsafe.Pointer) Sound {
-	return *(*Sound)(ptr)
-}
-
-// Music type (file streaming from memory)
-// NOTE: Anything longer than ~10 seconds should be streamed
-type Music struct {
-	Stream     AudioStream
-	FrameCount uint32
-	Looping    bool
-	CtxType    int32
-	CtxData    unsafe.Pointer
-}
-
-// newMusicFromPointer - Returns new Music from pointer
-func newMusicFromPointer(ptr unsafe.Pointer) Music {
-	return *(*Music)(ptr)
-}
-
-// AudioStream type
-// NOTE: Useful to create custom audio streams not bound to a specific file
-type AudioStream struct {
-	// Buffer
-	Buffer *C.rAudioBuffer
-	// Processor
-	Processor *C.rAudioProcessor
-	// Frequency (samples per second)
-	SampleRate uint32
-	// Bit depth (bits per sample): 8, 16, 32 (24 not supported)
-	SampleSize uint32
-	// Number of channels (1-mono, 2-stereo)
-	Channels uint32
-	_        [4]byte
-}
-
-// newAudioStreamFromPointer - Returns new AudioStream from pointer
-func newAudioStreamFromPointer(ptr unsafe.Pointer) AudioStream {
-	return *(*AudioStream)(ptr)
-}
-
 // CameraMode type
 type CameraMode int32
 
@@ -483,11 +399,6 @@ func NewVector2(x, y float32) Vector2 {
 	return Vector2{x, y}
 }
 
-// newVector2FromPointer - Returns new Vector2 from pointer
-func newVector2FromPointer(ptr unsafe.Pointer) Vector2 {
-	return *(*Vector2)(ptr)
-}
-
 // Vector3 type
 type Vector3 struct {
 	X float32
@@ -500,11 +411,6 @@ func NewVector3(X, Y, Z float32) Vector3 {
 	return Vector3{X, Y, Z}
 }
 
-// newVector3FromPointer - Returns new Vector3 from pointer
-func newVector3FromPointer(ptr unsafe.Pointer) Vector3 {
-	return *(*Vector3)(ptr)
-}
-
 // Vector4 type
 type Vector4 struct {
 	X float32
@@ -518,11 +424,6 @@ func NewVector4(X, Y, Z, W float32) Vector4 {
 	return Vector4{X, Y, Z, W}
 }
 
-// newVector4FromPointer - Returns new Vector4 from pointer
-func newVector4FromPointer(ptr unsafe.Pointer) Vector4 {
-	return *(*Vector4)(ptr)
-}
-
 // Matrix type (OpenGL style 4x4 - right handed, column major)
 type Matrix struct {
 	M0, M4, M8, M12  float32
@@ -536,11 +437,6 @@ func NewMatrix(m0, m4, m8, m12, m1, m5, m9, m13, m2, m6, m10, m14, m3, m7, m11,
 	return Matrix{m0, m4, m8, m12, m1, m5, m9, m13, m2, m6, m10, m14, m3, m7, m11, m15}
 }
 
-// newMatrixFromPointer - Returns new Matrix from pointer
-func newMatrixFromPointer(ptr unsafe.Pointer) Matrix {
-	return *(*Matrix)(ptr)
-}
-
 // Mat2 type (used for polygon shape rotation matrix)
 type Mat2 struct {
 	M00 float32
@@ -576,11 +472,6 @@ func NewColor(r, g, b, a uint8) color.RGBA {
 	return color.RGBA{r, g, b, a}
 }
 
-// newColorFromPointer - Returns new Color from pointer
-func newColorFromPointer(ptr unsafe.Pointer) color.RGBA {
-	return *(*color.RGBA)(ptr)
-}
-
 // Rectangle type
 type Rectangle struct {
 	X      float32
@@ -594,11 +485,6 @@ func NewRectangle(x, y, width, height float32) Rectangle {
 	return Rectangle{x, y, width, height}
 }
 
-// newRectangleFromPointer - Returns new Rectangle from pointer
-func newRectangleFromPointer(ptr unsafe.Pointer) Rectangle {
-	return *(*Rectangle)(ptr)
-}
-
 // ToInt32 converts rectangle to int32 variant
 func (r *Rectangle) ToInt32() RectangleInt32 {
 	rect := RectangleInt32{}
@@ -651,11 +537,6 @@ func NewCamera3D(pos, target, up Vector3, fovy float32, ct CameraProjection) Cam
 	return Camera3D{pos, target, up, fovy, ct}
 }
 
-// newCamera3DFromPointer - Returns new Camera3D from pointer
-func newCamera3DFromPointer(ptr unsafe.Pointer) Camera3D {
-	return *(*Camera3D)(ptr)
-}
-
 // Camera2D type, defines a 2d camera
 type Camera2D struct {
 	// Camera offset (displacement from target)
@@ -673,11 +554,6 @@ func NewCamera2D(offset, target Vector2, rotation, zoom float32) Camera2D {
 	return Camera2D{offset, target, rotation, zoom}
 }
 
-// newCamera2DFromPointer - Returns new Camera2D from pointer
-func newCamera2DFromPointer(ptr unsafe.Pointer) Camera2D {
-	return *(*Camera2D)(ptr)
-}
-
 // BoundingBox type
 type BoundingBox struct {
 	// Minimum vertex box-corner
@@ -691,11 +567,6 @@ func NewBoundingBox(min, max Vector3) BoundingBox {
 	return BoundingBox{min, max}
 }
 
-// newBoundingBoxFromPointer - Returns new BoundingBox from pointer
-func newBoundingBoxFromPointer(ptr unsafe.Pointer) BoundingBox {
-	return *(*BoundingBox)(ptr)
-}
-
 // Asset file
 type Asset interface {
 	io.ReadSeeker
@@ -816,11 +687,6 @@ type Mesh struct {
 	VboID *uint32
 }
 
-// newMeshFromPointer - Returns new Mesh from pointer
-func newMeshFromPointer(ptr unsafe.Pointer) Mesh {
-	return *(*Mesh)(ptr)
-}
-
 // Material type
 type Material struct {
 	// Shader
@@ -831,11 +697,6 @@ type Material struct {
 	Params [4]float32
 }
 
-// newMaterialFromPointer - Returns new Material from pointer
-func newMaterialFromPointer(ptr unsafe.Pointer) Material {
-	return *(*Material)(ptr)
-}
-
 // GetMap - Get pointer to MaterialMap by map type
 func (mt Material) GetMap(index int32) *MaterialMap {
 	return (*MaterialMap)(unsafe.Pointer(uintptr(unsafe.Pointer(mt.Maps)) + uintptr(index)*uintptr(unsafe.Sizeof(MaterialMap{}))))
@@ -901,11 +762,6 @@ func (m Model) GetBindPose() []Transform {
 	return unsafe.Slice(m.BindPose, m.BoneCount)
 }
 
-// newModelFromPointer - Returns new Model from pointer
-func newModelFromPointer(ptr unsafe.Pointer) Model {
-	return *(*Model)(ptr)
-}
-
 // BoneInfo type
 type BoneInfo struct {
 	Name   [32]int8
@@ -932,11 +788,6 @@ func NewRay(position, direction Vector3) Ray {
 	return Ray{position, direction}
 }
 
-// newRayFromPointer - Returns new Ray from pointer
-func newRayFromPointer(ptr unsafe.Pointer) Ray {
-	return *(*Ray)(ptr)
-}
-
 // ModelAnimation type
 type ModelAnimation struct {
 	BoneCount  int32
@@ -946,11 +797,6 @@ type ModelAnimation struct {
 	Name       [32]int8
 }
 
-// newModelAnimationFromPointer - Returns new ModelAnimation from pointer
-func newModelAnimationFromPointer(ptr unsafe.Pointer) ModelAnimation {
-	return *(*ModelAnimation)(ptr)
-}
-
 // RayCollision type - ray hit information
 type RayCollision struct {
 	Hit      bool
@@ -964,11 +810,6 @@ func NewRayCollision(hit bool, distance float32, point, normal Vector3) RayColli
 	return RayCollision{hit, distance, point, normal}
 }
 
-// newRayCollisionFromPointer - Returns new RayCollision from pointer
-func newRayCollisionFromPointer(ptr unsafe.Pointer) RayCollision {
-	return *(*RayCollision)(ptr)
-}
-
 // BlendMode type
 type BlendMode int32
 
@@ -997,11 +838,6 @@ func NewShader(id uint32, locs *int32) Shader {
 	return Shader{id, locs}
 }
 
-// newShaderFromPointer - Returns new Shader from pointer
-func newShaderFromPointer(ptr unsafe.Pointer) Shader {
-	return *(*Shader)(ptr)
-}
-
 // GetLocation - Get shader value's location
 func (sh Shader) GetLocation(index int32) int32 {
 	return *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(sh.Locs)) + uintptr(index*4)))
@@ -1031,11 +867,6 @@ func NewGlyphInfo(value int32, offsetX, offsetY, advanceX int32, image Image) Gl
 	return GlyphInfo{value, offsetX, offsetY, advanceX, image}
 }
 
-// newGlyphInfoFromPointer - Returns new GlyphInfo from pointer
-func newGlyphInfoFromPointer(ptr unsafe.Pointer) GlyphInfo {
-	return *(*GlyphInfo)(ptr)
-}
-
 // Font type, includes texture and charSet array data
 type Font struct {
 	// Base size (default chars height)
@@ -1052,11 +883,6 @@ type Font struct {
 	Chars *GlyphInfo
 }
 
-// newFontFromPointer - Returns new Font from pointer
-func newFontFromPointer(ptr unsafe.Pointer) Font {
-	return *(*Font)(ptr)
-}
-
 // PixelFormat - Texture format
 type PixelFormat int32
 
@@ -1160,36 +986,6 @@ func NewImage(data []byte, width, height, mipmaps int32, format PixelFormat) *Im
 	return &Image{d, width, height, mipmaps, format}
 }
 
-// newImageFromPointer - Returns new Image from pointer
-func newImageFromPointer(ptr unsafe.Pointer) *Image {
-	return (*Image)(ptr)
-}
-
-// NewImageFromImage - Returns new Image from Go image.Image
-func NewImageFromImage(img image.Image) *Image {
-	size := img.Bounds().Size()
-
-	cx := (C.int)(size.X)
-	cy := (C.int)(size.Y)
-	ccolor := colorCptr(White)
-	ret := C.GenImageColor(cx, cy, *ccolor)
-
-	for y := 0; y < size.Y; y++ {
-		for x := 0; x < size.X; x++ {
-			color := img.At(x, y)
-			r, g, b, a := color.RGBA()
-			rcolor := NewColor(uint8(r), uint8(g), uint8(b), uint8(a))
-			ccolor = colorCptr(rcolor)
-
-			cx = (C.int)(x)
-			cy = (C.int)(y)
-			C.ImageDrawPixel(&ret, cx, cy, *ccolor)
-		}
-	}
-	v := newImageFromPointer(unsafe.Pointer(&ret))
-	return v
-}
-
 // Texture2D type, bpp always RGBA (32bit)
 // NOTE: Data stored in GPU memory
 type Texture2D struct {
@@ -1210,11 +1006,6 @@ func NewTexture2D(id uint32, width, height, mipmaps int32, format PixelFormat) T
 	return Texture2D{id, width, height, mipmaps, format}
 }
 
-// newTexture2DFromPointer - Returns new Texture2D from pointer
-func newTexture2DFromPointer(ptr unsafe.Pointer) Texture2D {
-	return *(*Texture2D)(ptr)
-}
-
 // RenderTexture2D type, for texture rendering
 type RenderTexture2D struct {
 	// Render texture (fbo) id
@@ -1230,11 +1021,6 @@ func NewRenderTexture2D(id uint32, texture, depth Texture2D) RenderTexture2D {
 	return RenderTexture2D{id, texture, depth}
 }
 
-// newRenderTexture2DFromPointer - Returns new RenderTexture2D from pointer
-func newRenderTexture2DFromPointer(ptr unsafe.Pointer) RenderTexture2D {
-	return *(*RenderTexture2D)(ptr)
-}
-
 // TraceLogLevel parameter of trace log message
 type TraceLogLevel int
 

raylib/rcore.go

@@ -11,51 +11,101 @@ import (
 	"unsafe"
 )
 
+// newVector2FromPointer - Returns new Vector2 from pointer
+func newVector2FromPointer(ptr unsafe.Pointer) Vector2 {
+	return *(*Vector2)(ptr)
+}
+
 // cptr returns C pointer
 func (v *Vector2) cptr() *C.Vector2 {
 	return (*C.Vector2)(unsafe.Pointer(v))
 }
 
+// newVector3FromPointer - Returns new Vector3 from pointer
+func newVector3FromPointer(ptr unsafe.Pointer) Vector3 {
+	return *(*Vector3)(ptr)
+}
+
 // cptr returns C pointer
 func (v *Vector3) cptr() *C.Vector3 {
 	return (*C.Vector3)(unsafe.Pointer(v))
 }
 
+// newVector4FromPointer - Returns new Vector4 from pointer
+func newVector4FromPointer(ptr unsafe.Pointer) Vector4 {
+	return *(*Vector4)(ptr)
+}
+
 // cptr returns C pointer
 func (v *Vector4) cptr() *C.Vector4 {
 	return (*C.Vector4)(unsafe.Pointer(v))
 }
 
+// newMatrixFromPointer - Returns new Matrix from pointer
+func newMatrixFromPointer(ptr unsafe.Pointer) Matrix {
+	return *(*Matrix)(ptr)
+}
+
 // cptr returns C pointer
 func (m *Matrix) cptr() *C.Matrix {
 	return (*C.Matrix)(unsafe.Pointer(m))
 }
 
+// newColorFromPointer - Returns new Color from pointer
+func newColorFromPointer(ptr unsafe.Pointer) color.RGBA {
+	return *(*color.RGBA)(ptr)
+}
+
 // colorCptr returns color C pointer
 func colorCptr(col color.RGBA) *C.Color {
 	return (*C.Color)(unsafe.Pointer(&col))
 }
 
+// newRectangleFromPointer - Returns new Rectangle from pointer
+func newRectangleFromPointer(ptr unsafe.Pointer) Rectangle {
+	return *(*Rectangle)(ptr)
+}
+
 // cptr returns C pointer
 func (r *Rectangle) cptr() *C.Rectangle {
 	return (*C.Rectangle)(unsafe.Pointer(r))
 }
 
+// newCamera3DFromPointer - Returns new Camera3D from pointer
+func newCamera3DFromPointer(ptr unsafe.Pointer) Camera3D {
+	return *(*Camera3D)(ptr)
+}
+
 // cptr returns C pointer
 func (c *Camera) cptr() *C.Camera {
 	return (*C.Camera)(unsafe.Pointer(c))
 }
 
+// newCamera2DFromPointer - Returns new Camera2D from pointer
+func newCamera2DFromPointer(ptr unsafe.Pointer) Camera2D {
+	return *(*Camera2D)(ptr)
+}
+
 // cptr returns C pointer
 func (c *Camera2D) cptr() *C.Camera2D {
 	return (*C.Camera2D)(unsafe.Pointer(c))
 }
 
+// newBoundingBoxFromPointer - Returns new BoundingBox from pointer
+func newBoundingBoxFromPointer(ptr unsafe.Pointer) BoundingBox {
+	return *(*BoundingBox)(ptr)
+}
+
 // cptr returns C pointer
 func (b *BoundingBox) cptr() *C.BoundingBox {
 	return (*C.BoundingBox)(unsafe.Pointer(b))
 }
 
+// newShaderFromPointer - Returns new Shader from pointer
+func newShaderFromPointer(ptr unsafe.Pointer) Shader {
+	return *(*Shader)(ptr)
+}
+
 // cptr returns C pointer
 func (s *Shader) cptr() *C.Shader {
 	return (*C.Shader)(unsafe.Pointer(s))

raylib/rmodels.go

@@ -14,31 +14,61 @@ import (
 	"unsafe"
 )
 
+// newMeshFromPointer - Returns new Mesh from pointer
+func newMeshFromPointer(ptr unsafe.Pointer) Mesh {
+	return *(*Mesh)(ptr)
+}
+
 // cptr returns C pointer
 func (m *Mesh) cptr() *C.Mesh {
 	return (*C.Mesh)(unsafe.Pointer(m))
 }
 
+// newMaterialFromPointer - Returns new Material from pointer
+func newMaterialFromPointer(ptr unsafe.Pointer) Material {
+	return *(*Material)(ptr)
+}
+
 // cptr returns C pointer
 func (m *Material) cptr() *C.Material {
 	return (*C.Material)(unsafe.Pointer(m))
 }
 
+// newModelFromPointer - Returns new Model from pointer
+func newModelFromPointer(ptr unsafe.Pointer) Model {
+	return *(*Model)(ptr)
+}
+
 // cptr returns C pointer
 func (m *Model) cptr() *C.Model {
 	return (*C.Model)(unsafe.Pointer(m))
 }
 
+// newRayFromPointer - Returns new Ray from pointer
+func newRayFromPointer(ptr unsafe.Pointer) Ray {
+	return *(*Ray)(ptr)
+}
+
 // cptr returns C pointer
 func (r *Ray) cptr() *C.Ray {
 	return (*C.Ray)(unsafe.Pointer(r))
 }
 
+// newModelAnimationFromPointer - Returns new ModelAnimation from pointer
+func newModelAnimationFromPointer(ptr unsafe.Pointer) ModelAnimation {
+	return *(*ModelAnimation)(ptr)
+}
+
 // cptr returns C pointer
 func (r *ModelAnimation) cptr() *C.ModelAnimation {
 	return (*C.ModelAnimation)(unsafe.Pointer(r))
 }
 
+// newRayCollisionFromPointer - Returns new RayCollision from pointer
+func newRayCollisionFromPointer(ptr unsafe.Pointer) RayCollision {
+	return *(*RayCollision)(ptr)
+}
+
 // DrawLine3D - Draw a line in 3D world space
 func DrawLine3D(startPos Vector3, endPos Vector3, col color.RGBA) {
 	cstartPos := startPos.cptr()

raylib/rtext.go

@@ -10,11 +10,21 @@ import (
 	"unsafe"
 )
 
+// newGlyphInfoFromPointer - Returns new GlyphInfo from pointer
+func newGlyphInfoFromPointer(ptr unsafe.Pointer) GlyphInfo {
+	return *(*GlyphInfo)(ptr)
+}
+
 // cptr returns C pointer
 func (c *GlyphInfo) cptr() *C.GlyphInfo {
 	return (*C.GlyphInfo)(unsafe.Pointer(c))
 }
 
+// newFontFromPointer - Returns new Font from pointer
+func newFontFromPointer(ptr unsafe.Pointer) Font {
+	return *(*Font)(ptr)
+}
+
 // cptr returns C pointer
 func (s *Font) cptr() *C.Font {
 	return (*C.Font)(unsafe.Pointer(s))

raylib/rtextures.go

@@ -12,6 +12,11 @@ import (
 	"unsafe"
 )
 
+// newImageFromPointer - Returns new Image from pointer
+func newImageFromPointer(ptr unsafe.Pointer) *Image {
+	return (*Image)(ptr)
+}
+
 // cptr returns C pointer
 func (i *Image) cptr() *C.Image {
 	return (*C.Image)(unsafe.Pointer(i))
@@ -31,16 +36,51 @@ func (i *Image) ToImage() image.Image {
 	return img
 }
 
+// newTexture2DFromPointer - Returns new Texture2D from pointer
+func newTexture2DFromPointer(ptr unsafe.Pointer) Texture2D {
+	return *(*Texture2D)(ptr)
+}
+
 // cptr returns C pointer
 func (t *Texture2D) cptr() *C.Texture2D {
 	return (*C.Texture2D)(unsafe.Pointer(t))
 }
 
+// newRenderTexture2DFromPointer - Returns new RenderTexture2D from pointer
+func newRenderTexture2DFromPointer(ptr unsafe.Pointer) RenderTexture2D {
+	return *(*RenderTexture2D)(ptr)
+}
+
 // cptr returns C pointer
 func (r *RenderTexture2D) cptr() *C.RenderTexture2D {
 	return (*C.RenderTexture2D)(unsafe.Pointer(r))
 }
 
+// NewImageFromImage - Returns new Image from Go image.Image
+func NewImageFromImage(img image.Image) *Image {
+	size := img.Bounds().Size()
+
+	cx := (C.int)(size.X)
+	cy := (C.int)(size.Y)
+	ccolor := colorCptr(White)
+	ret := C.GenImageColor(cx, cy, *ccolor)
+
+	for y := 0; y < size.Y; y++ {
+		for x := 0; x < size.X; x++ {
+			color := img.At(x, y)
+			r, g, b, a := color.RGBA()
+			rcolor := NewColor(uint8(r), uint8(g), uint8(b), uint8(a))
+			ccolor = colorCptr(rcolor)
+
+			cx = (C.int)(x)
+			cy = (C.int)(y)
+			C.ImageDrawPixel(&ret, cx, cy, *ccolor)
+		}
+	}
+	v := newImageFromPointer(unsafe.Pointer(&ret))
+	return v
+}
+
 // LoadImage - Load an image into CPU memory (RAM)
 func LoadImage(fileName string) *Image {
 	cfileName := C.CString(fileName)