private static IntPtr GetScaledSurface(byte[] data, int srcW, int srcH, int dstW, int dstH) { // Create an SDL_Surface*, write the pixel data IntPtr surface = SDL_CreateRGBSurface(0, srcW, srcH, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000); SDL_LockSurface(surface); unsafe { SDL_Surface *surPtr = (SDL_Surface *)surface; Marshal.Copy(data, 0, surPtr->pixels, data.Length); } SDL_UnlockSurface(surface); // Blit to a scaled surface of the size we want, if needed. if (srcW != dstW || srcH != dstH) { IntPtr scaledSurface = SDL_CreateRGBSurface(0, dstW, dstH, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000); SDL_SetSurfaceBlendMode(surface, SDL_BlendMode.SDL_BLENDMODE_NONE); SDL_BlitScaled(surface, IntPtr.Zero, scaledSurface, IntPtr.Zero); SDL_FreeSurface(surface); surface = scaledSurface; } return(surface); }
/// <summary> /// Initializes a new instance of the <see cref="SDL2PlatformNativeSurface"/> class. /// </summary> /// <param name="src">A pointer to the native SDL surface.</param> public SDL2PlatformNativeSurface(SDL_Surface *src) { if (src == null) { throw new ArgumentNullException("src"); } var dst = SDL_CreateRGBSurface(0, src->w, src->h, 32, rmask, gmask, bmask, amask); if (dst == null) { throw new SDL2Exception(); } if (SDL_SetSurfaceBlendMode(dst, SDL_BLENDMODE_NONE) < 0) { throw new SDL2Exception(); } if (SDL_BlitSurface(src, null, dst, null) < 0) { throw new SDL2Exception(); } this.ptr = dst; }
private static unsafe IntPtr INTERNAL_getSurfacePixels(IntPtr surface) { IntPtr result; unsafe { SDL_Surface *surPtr = (SDL_Surface *)surface; result = surPtr->pixels; } return(result); }
private static unsafe int INTERNAL_getSurfaceHeight(IntPtr surface) { int result; unsafe { SDL_Surface *surPtr = (SDL_Surface *)surface; result = surPtr->h; } return(result); }
internal override void TextureDataFromStream( Stream stream, out int width, out int height, out byte[] pixels ) { // Load the Stream into an SDL_RWops* byte[] mem = new byte[stream.Length]; GCHandle handle = GCHandle.Alloc(mem, GCHandleType.Pinned); stream.Read(mem, 0, mem.Length); IntPtr rwops = SDL.SDL_RWFromMem(mem, mem.Length); // Load the SDL_Surface* from RWops, get the image data IntPtr surface = SDL_image.IMG_Load_RW(rwops, 1); if (surface == IntPtr.Zero) { // File not found, supported, etc. width = 0; height = 0; pixels = null; return; } surface = INTERNAL_convertSurfaceFormat(surface); unsafe { SDL_Surface *surPtr = (SDL_Surface *)surface; width = surPtr->w; height = surPtr->h; pixels = new byte[width * height * 4]; // MUST be SurfaceFormat.Color! Marshal.Copy(surPtr->pixels, pixels, 0, pixels.Length); } SDL.SDL_FreeSurface(surface); handle.Free(); /* Ensure that the alpha pixels are... well, actual alpha. * You think this looks stupid, but be assured: Your paint program is * almost certainly even stupider. * -flibit */ for (int i = 0; i < pixels.Length; i += 4) { if (pixels[i + 3] == 0) { pixels[i] = 0; pixels[i + 1] = 0; pixels[i + 2] = 0; } } }
public static void LoadImage(string file, out int width, out int height, out byte[] data) { if (!File.Exists(file)) { throw new FileNotFoundException("Texture file not found.", file); } IntPtr surfaceID = SDL_image.IMG_Load(file); // If image load fails, generate a default pink error texture if (surfaceID == IntPtr.Zero) { //throw new FileNotFoundException($"TextureDataFromStream: {SDL_GetError()}", file); surfaceID = SDL_CreateRGBSurfaceWithFormat(0, 32, 32, 0, SDL_PIXELFORMAT_ABGR8888); unsafe { SDL_Surface * surfacePtr = (SDL_Surface *)surfaceID; SDL_PixelFormat *pixelFormatPtr = (SDL_PixelFormat *)surfacePtr->format; SDL_FillRect(surfaceID, IntPtr.Zero, SDL_MapRGB((IntPtr)pixelFormatPtr, 255, 20, 147)); } } surfaceID = ConvertSurfaceFormat(surfaceID); unsafe { SDL_Surface *surface = (SDL_Surface *)surfaceID; width = surface->w; height = surface->h; data = new byte[width * height * 4]; Marshal.Copy(surface->pixels, data, 0, data.Length); } SDL_FreeSurface(surfaceID); // Enforce alpha for (int i = 0; i < data.Length; i += 4) { if (data[i + 3] == 0) { data[i] = 0; data[i + 1] = 0; data[i + 2] = 0; } } data = FlipImageData(width, height, 4, data); }
public static unsafe Texture FromPath(string path) { IntPtr origSurface = IMG_Load(path); IntPtr newSurface = SDL_ConvertSurfaceFormat(origSurface, SDL_PIXELFORMAT_ABGR8888, 0); SDL_Surface *surface = (SDL_Surface *)newSurface; Texture texture = FromData((uint)surface->w, (uint)surface->h, surface->pixels); SDL_FreeSurface(origSurface); SDL_FreeSurface(newSurface); return(texture); }
private static unsafe IntPtr INTERNAL_convertSurfaceFormat(IntPtr surface) { IntPtr result = surface; unsafe { SDL_Surface * surPtr = (SDL_Surface *)surface; SDL.SDL_PixelFormat *pixelFormatPtr = (SDL.SDL_PixelFormat *)surPtr->format; // SurfaceFormat.Color is SDL_PIXELFORMAT_ABGR8888 if (pixelFormatPtr->format != SDL.SDL_PIXELFORMAT_ABGR8888) { // Create a properly formatted copy, free the old surface result = SDL.SDL_ConvertSurfaceFormat(surface, SDL.SDL_PIXELFORMAT_ABGR8888, 0); SDL.SDL_FreeSurface(surface); } } return(result); }
private static extern SDL_Cursor *INTERNAL_SDL_CreateColorCursor(SDL_Surface *surface, Int32 hot_x, Int32 hot_y);
public override sealed Int32 SDL_GetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode *blendMode) => INTERNAL_SDL_GetSurfaceBlendMode(surface, blendMode);
public static extern SDL_Surface *SDL_ConvertSurface(SDL_Surface *src, SDL_PixelFormat *fmt, uint flags);
private static extern Int32 INTERNAL_SDL_FillRect(SDL_Surface *surface, SDL_Rect *rect, UInt32 color);
public static SDL_Cursor *SDL_CreateColorCursor(SDL_Surface *surface, Int32 hot_x, Int32 hot_y) => impl.SDL_CreateColorCursor(surface, hot_x, hot_y);
internal static bool Open(int w, int h, bool fullscreen, string caption) { if (IsSdlOpened) { AbormalTermination("SDL subsystem already open"); } if (SDL_Init(0) == -1 || SDL_InitSubSystem((int)Init.Video) != 0) { AbormalTermination(SDL_GetError()); } int flags = (int)(Video.HWSurface); if (fullscreen) { flags |= (int)(Video.FullScreen); } FrontSurface = SDL_SetVideoMode(w, h, 32, flags); if (FrontSurface == null) { AbormalTermination(SDL_GetError()); } SDL_WM_SetCaption(caption, null); SDL_ShowCursor((int)Enable.Disable); if (SDL_InitSubSystem((int)Init.Joystick) != 0) { AbormalTermination(SDL_GetError()); } OpenJoystickDevice(0); OpenJoystickDevice(1); SdlNativeMethods.FillRect(Color.Black); IsSdlOpened = true; return IsSdlOpened; }
public static Int32 SDL_BlitScaled(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect) => impl.SDL_BlitScaled(src, srcrect, dst, dstrect);
public static Int32 SDL_FillRect(SDL_Surface *surface, SDL_Rect *rect, UInt32 color) => impl.SDL_FillRect(surface, rect, color);
public static Int32 SDL_LockSurface(SDL_Surface *surface) => impl.SDL_LockSurface(surface);
public static Int32 SDL_SaveBMP_RW(SDL_Surface *surface, IntPtr dst, Int32 freedst) => impl.SDL_SaveBMP_RW(surface, dst, freedst);
public override sealed Int32 SDL_FillRects(SDL_Surface *dst, SDL_Rect *rects, Int32 count, UInt32 colors) => INTERNAL_SDL_FillRects(dst, rects, count, colors);
private static extern Int32 INTERNAL_SDL_FillRects(SDL_Surface *dst, SDL_Rect *rects, Int32 count, UInt32 colors);
public override sealed Int32 SDL_FillRect(SDL_Surface *surface, SDL_Rect *rect, UInt32 color) => INTERNAL_SDL_FillRect(surface, rect, color);
public static void SDL_FreeSurface(SDL_Surface *surface) => impl.SDL_FreeSurface(surface);
public override sealed SDL_Cursor *SDL_CreateColorCursor(SDL_Surface *surface, Int32 hot_x, Int32 hot_y) => INTERNAL_SDL_CreateColorCursor(surface, hot_x, hot_y);
public static void SDL_UnlockSurface(SDL_Surface *surface) => impl.SDL_UnlockSurface(surface);
public void draw(SDL_Surface Surface) { // Code for Draw m_surface = Surface; // maybe, need to check datatype. }
public static Int32 SDL_GetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode *blendMode) => impl.SDL_GetSurfaceBlendMode(surface, blendMode);
public static extern void SDL_FreeSurface(SDL_Surface *surface);
public static Int32 SDL_FillRects(SDL_Surface *dst, SDL_Rect *rects, Int32 count, UInt32 colors) => impl.SDL_FillRects(dst, rects, count, colors);
public static extern int SDL_LockSurface(SDL_Surface *surface);
public Color[,] LoadInternal(int *w, int *h, int *pixeldepth, Stream file) { if (file == null) { throw new ArgumentNullException(); } if (w == null || h == null || pixeldepth == null) { throw new ArgumentNullException(); } #if SYSTEM_DRAWING using (Bitmap bmp = new Bitmap(file)) { BitmapData bmp_data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Color[,] rz_mp = new Color[bmp.Width, bmp.Height]; * pixeldepth = 4; * w = bmp.Width; * h = bmp.Height; int scan0size = bmp.Width * bmp.Height; for (int display = 0; display < (scan0size); display++) { UniColor4 cur = ((UniColor4 *)bmp_data.Scan0.ToPointer())[display]; fixed(Color *p = &rz_mp[0, 0]) { Color *pix = p + display; pix->A = cur.A; pix->R = cur.B; pix->G = cur.G; pix->B = cur.R; } } bmp.UnlockBits(bmp_data); return(rz_mp); } #else byte[] rw = new byte[file.Length]; file.Read(rw, 0, rw.Length); SDL_RWops * pops = null; SDL_Surface *sf = null; fixed(byte *rws = &rw[0]) pops = SDL.SDL_RWFromMem(rws, rw.Length); if (pops == null) { throw new FunctionReturnedNullException("SDL_RWFromMem"); } sf = SDL.IMG_Load_RW(pops, 1); if (sf == null) { SDL.SDL_FreeRW(pops); throw new FunctionReturnedNullException("IMG_Load_RW"); } try { Color[,] rz_mp = new Color[sf->w, sf->h]; * pixeldepth = sf->format->BytesPerPixel; * w = sf->w; * h = sf->h; int scan0size = sf->h * sf->w; if (*pixeldepth == 1) { for (int display = 0; display < (scan0size); display++) { UniColor1 cur = ((UniColor1 *)sf->pixels)[display]; fixed(Color *p = &rz_mp[0, 0]) { Color *pix = p + display; pix->A = 255; pix->R = cur.C; pix->G = cur.C; pix->B = cur.C; } } } if (*pixeldepth == 3) { for (int display = 0; display < (scan0size); display++) { UniColor3 cur = ((UniColor3 *)sf->pixels)[display]; fixed(Color *p = &rz_mp[0, 0]) { Color *pix = p + display; pix->A = 255; pix->R = cur.R; pix->G = cur.G; pix->B = cur.B; } } } if (*pixeldepth == 4) { for (int display = 0; display < (scan0size); display++) { UniColor4 cur = ((UniColor4 *)sf->pixels)[display]; fixed(Color *p = &rz_mp[0, 0]) { Color *pix = p + display; pix->A = cur.A; pix->R = cur.R; pix->G = cur.G; pix->B = cur.B; } } } SDL.SDL_FreeSurface(sf); SDL.SDL_FreeRW(pops); return(rz_mp); } catch (Exception r) { SDL.SDL_FreeSurface(sf); SDL.SDL_FreeRW(pops); throw r; } #endif }
public static extern void SDL_UnlockSurface(SDL_Surface *surface);