gfm.sdl2.surface source code

1 module gfm.sdl2.surface;
2 
3 import derelict.sdl2.sdl;
4 
5 import gfm.sdl2.sdl;
6 
7 /// SDL Surface wrapper.
8 /// A SDL2Surface might own the SDL_Surface* handle or not.
9 final class SDL2Surface
10 {
11     public
12     {
13         /// Whether a SDL Surface is owned by the wrapper or borrowed.
14         enum Owned
15         {
16             NO,  // Not owned.
17             YES  // Owned.
18         }
19 
20         /// Create from an existing SDL_Surface* handle.
21         this(SDL2 sdl2, SDL_Surface* surface, Owned owned)
22         {
23             assert(surface !is null);
24             _sdl2 = sdl2;
25             _surface = surface;
26             _handleOwned = owned;
27         }
28 
29         /// Create a new RGBA surface. Both pixels data and handle are owned.
30         /// See_also: $(LINK http://wiki.libsdl.org/SDL_CreateRGBSurface)
31         /// Throws: $(D SDL2Exception) on error.
32         this(SDL2 sdl2, int width, int height, int depth,
33              uint Rmask, uint Gmask, uint Bmask, uint Amask)
34         {
35             _sdl2 = sdl2;
36             _surface = SDL_CreateRGBSurface(0, width, height, depth, Rmask, Gmask, Bmask, Amask);
37             if (_surface is null)
38                 _sdl2.throwSDL2Exception("SDL_CreateRGBSurface");
39             _handleOwned = Owned.YES;
40         }
41 
42         /// Create surface from RGBA data. Pixels data is <b>not</b> and not owned.
43         /// See_also: clone, $(WEB wiki.libsdl.org/SDL_CreateRGBSurfaceFrom,SDL_CreateRGBSurfaceFrom)
44         /// Throws: $(D SDL2Exception) on error.
45         this(SDL2 sdl2, void* pixels, int width, int height, int depth, int pitch,
46              uint Rmask, uint Gmask, uint Bmask, uint Amask)
47         {
48             _sdl2 = sdl2;
49             _surface = SDL_CreateRGBSurfaceFrom(pixels, width, height, depth, pitch, Rmask, Gmask, Bmask, Amask);
50             if (_surface is null)
51                 _sdl2.throwSDL2Exception("SDL_CreateRGBSurfaceFrom");
52             _handleOwned = Owned.YES;
53         }
54 
55         /// Releases the SDL resource.
56         ~this()
57         {
58             if (_surface !is null)
59             {
60                 debug ensureNotInGC("SDL2Surface");
61                 if (_handleOwned == Owned.YES)
62                     SDL_FreeSurface(_surface);
63                 _surface = null;
64             }
65         }
66         deprecated("Use .destroy instead") void close(){}
67 
68         /// Converts the surface to another format.
69         /// See_also: $(LINK http://wiki.libsdl.org/SDL_ConvertSurface)
70         /// Returns: A new surface.
71         SDL2Surface convert(const(SDL_PixelFormat)* newFormat)
72         {
73             SDL_Surface* surface = SDL_ConvertSurface(_surface, newFormat, 0);
74             if (surface is null)
75                 _sdl2.throwSDL2Exception("SDL_ConvertSurface");
76             assert(surface != _surface); // should not be the same handle
77             return new SDL2Surface(_sdl2, surface, Owned.YES);
78         }
79 
80         /// Returns: A copy of the surface, useful for taking ownership of not-owned pixel data.
81         /// See_also: $WEB(wiki.libsdl.org/SDL_CreateRGBSurfaceFrom,SDL_CreateRGBSurfaceFrom)
82         SDL2Surface clone()
83         {
84             return convert(pixelFormat());
85         }
86 
87         /// Returns: Width of the surface in pixels.
88         @property int width() const
89         {
90             return _surface.w;
91         }
92 
93         /// Returns: Height of the surface in pixels.
94         @property int height() const
95         {
96             return _surface.h;
97         }
98 
99         /// Returns: Pointer to surface data.
100         /// You must lock the surface before accessng it.
101         ubyte* pixels()
102         {
103             return cast(ubyte*) _surface.pixels;
104         }
105 
106         /// Get the surface pitch (number of bytes between lines).
107         size_t pitch()
108         {
109             return _surface.pitch;
110         }
111 
112         /// Lock the surface, allow to use pixels().
113         /// Throws: $(D SDL2Exception) on error.
114         void lock()
115         {
116             if (SDL_LockSurface(_surface) != 0)
117                 _sdl2.throwSDL2Exception("SDL_LockSurface");
118         }
119 
120         /// Unlock the surface.
121         void unlock()
122         {
123             SDL_UnlockSurface(_surface);
124         }
125 
126         /// Returns: SDL handle.
127         SDL_Surface* handle()
128         {
129             return _surface;
130         }
131 
132         /// Returns: SDL_PixelFormat which describe the surface.
133         SDL_PixelFormat* pixelFormat()
134         {
135             return _surface.format;
136         }
137 
138         ///
139         struct RGBA
140         {
141             ubyte r, g, b, a;
142         }
143 
144         /// Get a surface pixel color.
145         /// Bugs: must be locked when using this method. Slow!
146         RGBA getRGBA(int x, int y)
147         {
148             // crash if out of image
149             if (x < 0 || x >= width())
150                 assert(0);
151 
152             if (y < 0 || y >= height())
153                 assert(0);
154 
155             SDL_PixelFormat* fmt = _surface.format;
156 
157             ubyte* pixels = cast(ubyte*)_surface.pixels;
158             int pitch = _surface.pitch;
159 
160             uint* pixel = cast(uint*)(pixels + y * pitch + x * fmt.BytesPerPixel);
161             ubyte r, g, b, a;
162             SDL_GetRGBA(*pixel, fmt, &r, &g, &b, &a);
163             return RGBA(r, g, b, a);
164         }
165     }
166 
167     package
168     {
169         SDL2 _sdl2;
170         SDL_Surface* _surface;
171         Owned _handleOwned;
172     }
173 }