/// <summary>
/// Initialize SDL, SDL_image and SDL_ttf
/// </summary>
public static void InitGraphics()
{
// Initialize SDL
if (SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING) != 0)
{
throw new SDLException("SDL_Init");
}
// Initialize SDL PNG image loading
if ((SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG) &
(int)SDL_image.IMG_InitFlags.IMG_INIT_PNG) !=
(int)SDL_image.IMG_InitFlags.IMG_INIT_PNG)
{
throw new SDLException("IMG_Init");
}
// Initialize SDL TTF rendering
if (SDL_ttf.TTF_Init() != 0)
{
throw new SDLException("TTF_Init");
}
}
private static void Close()
{
//Free loaded images
_TimeTextTexture.Free();
_StartPromptTexture.Free();
_PausePromptTexture.Free();
//Free global font
SDL_ttf.TTF_CloseFont(Font);
Font = IntPtr.Zero;
//Destroy window
SDL.SDL_DestroyRenderer(Renderer);
SDL.SDL_DestroyWindow(_Window);
_Window = IntPtr.Zero;
Renderer = IntPtr.Zero;
//Quit SDL subsystems
SDL_ttf.TTF_Quit();
SDL_image.IMG_Quit();
SDL.SDL_Quit();
}
//Loads image at specified path
public bool LoadFromFile(string path)
{
//Get rid of preexisting texture
Free();
//Load image at specified path
var loadedSurface = SDL_image.IMG_Load(path);
if (loadedSurface == IntPtr.Zero)
{
Console.WriteLine("Unable to load image {0}! SDL Error: {1}", path, SDL.SDL_GetError());
return(false);
}
var s = Marshal.PtrToStructure <SDL.SDL_Surface>(loadedSurface);
//Color key image
SDL.SDL_SetColorKey(loadedSurface, (int)SDL.SDL_bool.SDL_TRUE, SDL.SDL_MapRGB(s.format, 0, 0xFF, 0xFF));
//Create texture from surface pixels
var newTexture = SDL.SDL_CreateTextureFromSurface(Program.Renderer, loadedSurface);
if (newTexture == IntPtr.Zero)
{
Console.WriteLine("Unable to create texture from {0}! SDL Error: {1}", path, SDL.SDL_GetError());
return(false);
}
//Get image dimensions
_Width = s.w;
_Height = s.h;
//Get rid of old loaded surface
SDL.SDL_FreeSurface(loadedSurface);
//Return success
_Texture = newTexture;
return(true);
}
public SDLGame()
{
Logger.AddLogger(new ConsoleLogger());
fileResolver = new SDLFileResolver("Content");
SDL.SDL_SetHint(SDL.SDL_HINT_RENDER_SCALE_QUALITY, "best");
SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO);
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
win = SDL.SDL_CreateWindow("SDL Tiles", SDL.SDL_WINDOWPOS_UNDEFINED, SDL.SDL_WINDOWPOS_UNDEFINED, 800, 600, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN | SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE | SDL.SDL_WindowFlags.SDL_WINDOW_ALLOW_HIGHDPI);
ren = SDL.SDL_CreateRenderer(win, -1, SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
fontEngine = new SDLFontEngine();
graphics = new SDLGraphics(this, 800, 600, fontEngine, new DebugOptions()
{
ShowGrid = false,
ShowHighlight = false,
ShowSelected = true,
ShowTileCounter = false,
ShowCoordinates = false
});
sounds = new SDLSounds();
engine = new Engine(fileResolver, graphics, fontEngine, sounds);
}
private static bool Init()
{
//Init the video card
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) < 0)
{
Console.WriteLine("SDL could not initialize! SDL_Error: {0}", SDL.SDL_GetError());
return(false);
}
else
{
//Create an SDL window to render graphics upon.
_windowPtr = SDL.SDL_CreateWindow("SDL2 Keyboard Sample", SDL.SDL_WINDOWPOS_CENTERED, SDL.SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
_rendererPtr = SDL.SDL_CreateRenderer(_windowPtr, -1, SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED);
if (_windowPtr == IntPtr.Zero)
{
Console.WriteLine("The window could not be created!!");
Console.ReadLine();
return(false);
}
else
{
//Initialize PNG loading
var imgFlags = SDL_image.IMG_InitFlags.IMG_INIT_PNG;
if ((SDL_image.IMG_Init(imgFlags) > 0 & imgFlags > 0) == false)
{
//TODO: Convert to exception
Console.WriteLine("SDL_image could not initialize! SDL_image Error: {0}", SDL.SDL_GetError());
return(false);
}
}
}
return(true);
}
void GEALOSprog()
{
init();
while (running)
{
time.update();
while (SDL.SDL_PollEvent(out SDL.SDL_Event e) == 1)
{
switch (e.type)
{
case SDL.SDL_EventType.SDL_QUIT:
running = false;
break;
case SDL.SDL_EventType.SDL_KEYDOWN:
input.setPress(e.key.keysym.sym, true);
break;
case SDL.SDL_EventType.SDL_KEYUP:
if (e.key.repeat == 0)
{
input.setPress(e.key.keysym.sym, false);
}
break;
}
}
update();
}
SDL_mixer.Mix_Quit();
SDL_ttf.TTF_Quit();
SDL_image.IMG_Quit();
SDL.SDL_Quit();
}
public void Run()
{
SDL.SDL_Init(SDL.SDL_INIT_VIDEO);
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG | SDL_image.IMG_InitFlags.IMG_INIT_JPG);
var window = SDL.SDL_CreateWindow("Testing SDL2", SDL.SDL_WINDOWPOS_CENTERED, SDL.SDL_WINDOWPOS_CENTERED, 400, 800, 0);
renderer = SDL.SDL_CreateRenderer(window, -1, SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
field = new int[M, N];
tilesTexture = SDL_image.IMG_LoadTexture(renderer, @"img\Tiles.png");
if (tilesTexture == IntPtr.Zero)
{
Console.WriteLine("Error loading texture: " + SDL.SDL_GetError());
}
for (int i = 0; i < 4; i++)
{
point[i].X = shapes[shapeToDraw, i] % 2;
point[i].Y = shapes[shapeToDraw, i] / 2;
}
running = true;
while (running)
{
HandelInput();
Update();
Render();
}
SDL.SDL_DestroyWindow(window);
SDL.SDL_Quit();
}
/// <summary>Initializes the game by calling initialize on the SDL2 instance with the passed flags
/// or "EVERYTHING" if 0. Additionally, this method will initialize SDL_ttf and SDL_image to load fonts and images.
/// </summary>
/// <param name="types">Bit flags indicating the way in which SDL should be initialized</param>
private void InitializeBase(GameEngineInitializeType types)
{
if (SDL.SDL_Init((uint)types) != 0)
{
throw new InvalidOperationException($"SDL_Init: {SDL.SDL_GetError()}");
}
if (SDL_ttf.TTF_Init() != 0)
{
throw new InvalidOperationException($"TTF_Init: {SDL.SDL_GetError()}");
}
SDL_image.IMG_InitFlags initImageFlags =
SDL_image.IMG_InitFlags.IMG_INIT_JPG
| SDL_image.IMG_InitFlags.IMG_INIT_PNG
| SDL_image.IMG_InitFlags.IMG_INIT_TIF
| SDL_image.IMG_InitFlags.IMG_INIT_WEBP;
int initImageResult = SDL_image.IMG_Init(initImageFlags);
if ((initImageResult & (int)initImageFlags) != (int)initImageFlags)
{
throw new InvalidOperationException($"IMG_Init: {SDL.SDL_GetError()}");
}
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="hero">The hero.</param>
/// <param name="map">The map.</param>
/// <param name="renderer">The renderer.</param>
public Graphics(Hero hero, Map map, IntPtr renderer)
{
this.hero = hero;
this.map = map;
this.renderer = renderer;
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_JPG);
SDL.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0);
// Load the images from the media folder.
var heroImg = SDL_image.IMG_Load("media//hero.jpg");
var wallImg = SDL_image.IMG_Load("media//wall.jpg");
var boxImg = SDL_image.IMG_Load("media//box.jpg");
var slotImg = SDL_image.IMG_Load("media//slot.jpg");
var boxOnSlotImg = SDL_image.IMG_Load("media//boxOnSlot.jpg");
var victoryImg = SDL_image.IMG_Load("media//victory.jpg");
HeroTex = SDL.SDL_CreateTextureFromSurface(renderer, heroImg);
WallTex = SDL.SDL_CreateTextureFromSurface(renderer, wallImg);
BoxTex = SDL.SDL_CreateTextureFromSurface(renderer, boxImg);
SlotTex = SDL.SDL_CreateTextureFromSurface(renderer, slotImg);
BoxOnSlotTex = SDL.SDL_CreateTextureFromSurface(renderer, boxOnSlotImg);
VictoryTex = SDL.SDL_CreateTextureFromSurface(renderer, victoryImg);
}
private void LoadImages()
{
// Пока загружаем все файлы с расширением PNG из каталога Assets.
// Идентификатором будет являться наименование файла.
var assetsPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
assetsPath = Path.Combine(assetsPath, "Assets");
foreach (var texturePath in Directory.GetFiles(assetsPath, "*.png", SearchOption.AllDirectories))
{
var texture = SDL_image.IMG_Load(texturePath);
if (texture == IntPtr.Zero)
{
_logger.Error("Ошибка при загруке файла изображения {texturePath}. Текстура не создана.", texturePath);
continue;
}
var textureIndent = Path.GetFileNameWithoutExtension(texturePath);
_logger.Debug("Загружено изображение \"{textureIndent}\" из {texturePath}", textureIndent, texturePath);
_textures.Add(textureIndent, texture);
}
}
private TextureStruct BMPToTexture(string imagePath, byte r, byte g, byte b)
{
TextureStruct finalTexture = new TextureStruct(IntPtr.Zero, 0, 0);
IntPtr sprite = IntPtr.Zero;
//loads all (supported) images, not only BMP
sprite = SDL_image.IMG_Load(imagePath);
//sprite = SDL_LoadBMP(imagePath);
if (sprite == IntPtr.Zero)
{
Console.Write("Unable to load image: " + imagePath + " SDL Error:" + SDL_GetError() + " \n");
SDL_FreeSurface(sprite);
return(finalTexture);
}
//Set Colorkey
var format = ((SDL_Surface)Marshal.PtrToStructure(sprite, typeof(SDL_Surface))).format;
SDL_SetColorKey(sprite, 1, SDL_MapRGB(format, r, g, b));
IntPtr myTexture = SDL_CreateTextureFromSurface(renderer, sprite);
if (myTexture == IntPtr.Zero)
{
Console.Write("Unable to create texture! SDL Error:" + SDL_GetError() + " \n");
Console.Write(imagePath + " \n");
SDL_FreeSurface(sprite);
return(finalTexture);
}
finalTexture.h = ((SDL_Surface)Marshal.PtrToStructure(sprite, typeof(SDL_Surface))).h;
finalTexture.w = ((SDL_Surface)Marshal.PtrToStructure(sprite, typeof(SDL_Surface))).w;
finalTexture.texture = myTexture;
SDL_FreeSurface(sprite);
return(finalTexture);
}
//Inits SDL,SDL_image and SDL_ttf or exits the aplication if it fails
static Hardware()
{
if (SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING) < 0)
{
SDL.SDL_ShowSimpleMessageBox
(SDL.SDL_MessageBoxFlags.SDL_MESSAGEBOX_ERROR, "Error",
"Could not init SDL", screen);
Environment.Exit(1);
}
if (SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG) < 0)
{
SDL.SDL_ShowSimpleMessageBox
(SDL.SDL_MessageBoxFlags.SDL_MESSAGEBOX_ERROR, "Error",
"Could not init SDL_Image", screen);
Environment.Exit(1);
}
if (SDL_ttf.TTF_Init() < 0)
{
SDL.SDL_ShowSimpleMessageBox
(SDL.SDL_MessageBoxFlags.SDL_MESSAGEBOX_ERROR, "Error",
"Could not init SDL_ttf", screen);
Environment.Exit(1);
}
}
/// <summary>Initializes the game by calling initialize on the SDL2 instance with the passed flags
/// or "EVERYTHING" if 0. Additionally, this method will initialize SDL_ttf and SDL_image to load fonts and images.
/// </summary>
/// <param name="flags">Bit flags indicating the way in which SDL should be initialized</param>
protected virtual void Initialize(uint flags)
{
if (flags == EMPTY_UINT)
{
flags = SDL.SDL_INIT_EVERYTHING;
}
if (SDL.SDL_Init(flags) != 0)
{
throw new InvalidOperationException(String.Format("SDL_Init: {0}", SDL.SDL_GetError()));
}
if (SDL_ttf.TTF_Init() != 0)
{
throw new InvalidOperationException(String.Format("TTF_Init: {0}", SDL.SDL_GetError()));
}
int initImageResult = SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
if ((initImageResult & (int)SDL_image.IMG_InitFlags.IMG_INIT_PNG) != (int)SDL_image.IMG_InitFlags.IMG_INIT_PNG)
{
throw new InvalidOperationException(String.Format("IMG_Init: {0}", SDL.SDL_GetError()));
}
}
public static Engine Create(EngineOptions options, IController controller, IEventsCycle eventsCycle,
ISceneRenderer sceneRenderer)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw new InvalidOperationException($"Cant initialize SDL2: {SDL_GetError()}");
}
if (SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_JPG | SDL_image.IMG_InitFlags.IMG_INIT_PNG) < 0)
{
throw new InvalidOperationException($"Cant initialize SDL_image: {SDL_GetError()}");
}
if (SDL_ttf.TTF_Init() < 0)
{
throw new InvalidOperationException($"TTF_Init: {SDL_GetError()}");
}
if (SDL_ShowCursor(0) < 0)
{
throw new InvalidOperationException($"Cant disable cursor: {SDL_GetError()}");
}
if (SDL_mixer.Mix_Init(
SDL_mixer.MIX_InitFlags.MIX_INIT_MP3
| SDL_mixer.MIX_InitFlags.MIX_INIT_MID
| SDL_mixer.MIX_InitFlags.MIX_INIT_MOD
| SDL_mixer.MIX_InitFlags.MIX_INIT_OGG
| SDL_mixer.MIX_InitFlags.MIX_INIT_FLAC
| SDL_mixer.MIX_InitFlags.MIX_INIT_OPUS) < 0)
{
throw new InvalidOperationException($"MixInit: {SDL_GetError()}");
}
if (SDL_mixer.Mix_OpenAudio(22050, SDL_mixer.MIX_DEFAULT_FORMAT, 2, 4096) < 0)
{
throw new InvalidOperationException($"OpenAudio: {SDL_GetError()}");
}
if (SDL_mixer.Mix_AllocateChannels(16) < 0)
{
throw new InvalidOperationException($"Cant allocate channels: {SDL_GetError()}");
}
if (SDL_mixer.Mix_Volume(-1, 64) < 0)
{
throw new InvalidOperationException($"Min_Volume: {SDL_GetError()}");
}
var screen = Ui.Screen.Create(options.WindowTitle, options.ScreenHeight, options.ScreenWidth,
options.FullScreen);
var miniMapRenderer = new MiniMapRenderer();
var statusBarHeight = screen.Height / 8;
var statusBarWidth = screen.Width;
var statusBarSprite = Sprite.Load(UiResourcesHelper.StatusBarSpritePath);
var bowSprite = Sprite.Load(UiResourcesHelper.BowMiniSpritePath);
var frameSprite = Sprite.Load(UiResourcesHelper.FrameSpritePath);
var crossSprite = options.CrossSpritePath == null ? null : Sprite.Load(options.CrossSpritePath);
var arrowSprite = Sprite.Load(UiResourcesHelper.ArrowSpritePath);
var swordSprite = Sprite.Load(UiResourcesHelper.SwordSpritePath);
var fireBallSprite = Sprite.Load(UiResourcesHelper.FireBallSpritePath);
var shockBallSprite = Sprite.Load(UiResourcesHelper.ShockBallSpritePath);
var faceSprite = Sprite.Load(UiResourcesHelper.FaceSprintPath);
var faceHurtedSprite = Sprite.Load(UiResourcesHelper.FaceHurtedSpritePath);
var faceBadSprite = Sprite.Load(UiResourcesHelper.FaceBadSpritePath);
var logTextRenderer = TextRenderer.Load(options.FontPath, screen.Height / 50);
var notesTextRenderer = TextRenderer.Load(options.FontPath, screen.Height / 50);
var statusTextRenderer = TextRenderer.Load(options.FontPath, screen.Height / 20);
var notesRenderer = new NotesRenderer(Sprite.Load(options.NotesSpritePath), notesTextRenderer, statusBarHeight);
var monologueTextRenderer = TextRenderer.Load(options.FontPath, screen.Height / 50);
var monologueRenderer = new MonologueRenderer(monologueTextRenderer, statusBarHeight);
var statusBarRenderer = new StatusRenderer(
statusBarSprite,
crossSprite,
statusBarHeight,
logTextRenderer,
notesRenderer,
monologueRenderer,
bowSprite,
swordSprite,
frameSprite,
statusTextRenderer,
arrowSprite,
fireBallSprite,
shockBallSprite,
faceSprite,
faceHurtedSprite,
faceBadSprite);
var textRenderer = options.FontPath == null ? null : TextRenderer.Load(options.FontPath, 24);
return(new Engine(screen, controller, eventsCycle, sceneRenderer, miniMapRenderer, statusBarRenderer,
textRenderer));
}
internal override void SavePNG(
Stream stream,
int width,
int height,
int imgWidth,
int imgHeight,
byte[] data
)
{
// Create an SDL_Surface*, write the pixel data
IntPtr surface = SDL.SDL_CreateRGBSurface(
0,
imgWidth,
imgHeight,
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
);
SDL.SDL_LockSurface(surface);
unsafe
{
SDL_Surface *surPtr = (SDL_Surface *)surface;
Marshal.Copy(
data,
0,
surPtr->pixels,
data.Length
);
}
SDL.SDL_UnlockSurface(surface);
data = null; // We're done with the original pixel data.
// Blit to a scaled surface of the size we want, if needed.
if (width != imgWidth || height != imgHeight)
{
IntPtr scaledSurface = SDL.SDL_CreateRGBSurface(
0,
width,
height,
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
);
SDL.SDL_BlitScaled(
surface,
IntPtr.Zero,
scaledSurface,
IntPtr.Zero
);
SDL.SDL_FreeSurface(surface);
surface = scaledSurface;
}
// Create an SDL_RWops*, save PNG to RWops
const int pngHeaderSize = 41;
const int pngFooterSize = 57;
byte[] pngOut = new byte[
(width * height * 4) +
pngHeaderSize +
pngFooterSize +
256 // FIXME: Arbitrary zlib data padding for low-res images
]; // Max image size
IntPtr dst = SDL.SDL_RWFromMem(pngOut, pngOut.Length);
SDL_image.IMG_SavePNG_RW(surface, dst, 1);
SDL.SDL_FreeSurface(surface); // We're done with the surface.
// Get PNG size, write to Stream
int size = (
(pngOut[33] << 24) |
(pngOut[34] << 16) |
(pngOut[35] << 8) |
(pngOut[36])
) + pngHeaderSize + pngFooterSize;
stream.Write(pngOut, 0, size);
}
public static void SavePNG(SDLSurface Surface, IntPtr Dst, bool Freedst)
{
Util.ThrowIfResultIsError(SDL_image.IMG_SavePNG_RW(Surface.Ptr, Dst, Convert.ToInt32(Freedst)));
}
/// <summary>
/// Initializes SDL and its components.
/// </summary>
public static void Start()
{
Console.WriteLine("Start loading dependencies...");
if (Platform == Platform.Windows)
{
SetProcessDPIAware();
SDL.Bind("./lib/windows/SDL2.dll", "./lib/windows/zlib1.dll");
if (File.Exists("./lib/windows/libjpeg-9.dll"))
{
LoadedJPEG = true;
SDL_image.Bind("./lib/windows/SDL2_image.dll", "./lib/windows/libpng16-16.dll", "./lib/windows/libjpeg-9.dll");
}
else
{
SDL_image.Bind("./lib/windows/SDL2_image.dll", "./lib/windows/libpng16-16.dll");
}
SDL_ttf.Bind("./lib/windows/SDL2_ttf.dll", "./lib/windows/libfreetype-6.dll");
}
else if (Platform == Platform.Linux)
{
SDL.Bind("./lib/linux/SDL2.so", "./lib/linux/libz.so");
if (File.Exists("./lib/linux/libjpeg-9.so"))
{
LoadedJPEG = true;
SDL_image.Bind("./lib/linux/SDL2_image.so", "./lib/linux/libpng16-16.so", "./lib/linux/libjpeg-9.so");
}
else
{
SDL_image.Bind("./lib/linux/SDL2_image.so", "./lib/linux/libpng16-16.so");
}
SDL_ttf.Bind("./lib/linux/SDL2_ttf.so", "./lib/linux/libfreetype-6.so");
}
else if (Platform == Platform.MacOS)
{
throw new Exception("MacOS support has not yet been implemented.");
}
else
{
throw new Exception("No platform could be detected.");
}
uint IMG_Flags = IMG_INIT_PNG;
if (LoadedJPEG)
{
IMG_Flags |= IMG_INIT_JPG;
}
if (SDL_Init(SDL_INIT_EVERYTHING) < 0 ||
IMG_Init(IMG_Flags) != (int)IMG_Flags ||
TTF_Init() < 0)
{
throw new Exception(SDL_GetError());
}
int screens = SDL_GetNumVideoDisplays();
for (int i = 0; i < screens; i++)
{
SDL_Rect r;
if (SDL_GetDisplayBounds(i, out r) != 0)
{
throw new Exception($"Could not retrieve screen size for screen {i}: {SDL_GetError()}");
}
Screens.Add(new Rect(r));
}
SDL_StopTextInput();
Initialized = true;
}
public static void LoadInit(IntPtr rendererPtr, string texturePath)
{
texture = SDL_image.IMG_LoadTexture(rendererPtr, texturePath);
SDL.SDL_QueryTexture(texture, out _, out _, out width, out height);
}
public void Execute()
{
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) != 0)
{
SdlLogger.Fatal(nameof(SDL.SDL_Init));
}
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
var window = SDL.SDL_CreateWindow(TITLE, 0, 0, WIDTH, HEIGHT, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
if (window == IntPtr.Zero)
{
SdlLogger.Fatal(nameof(SDL.SDL_CreateWindow),
() => ReleaseAndQuit(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero));
}
var renderer = SDL.SDL_CreateRenderer(
window, -1,
SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
if (renderer == IntPtr.Zero)
{
SdlLogger.Fatal(
nameof(SDL.SDL_CreateRenderer),
() => ReleaseAndQuit(window, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero));
}
var image = Resources.LoadTextureFromImage(Resources.GetFilePath(@"lesson5/image.png"), renderer);
if (image == IntPtr.Zero)
{
SdlLogger.Fatal(
nameof(Resources.LoadTextureFromImage),
() => ReleaseAndQuit(window, renderer, IntPtr.Zero, image));
}
var quit = false;
int x, y, iW = 100, iH = 100, useClip = 0;
x = WIDTH / 2 - iW / 2;
y = HEIGHT / 2 - iH / 2;
var clips = new SDL.SDL_Rect[4];
for (var i = 0; i < clips.Length; i++)
{
clips[i] = new SDL.SDL_Rect
{
x = i / 2 * iW,
y = i % 2 * iH,
w = iW,
h = iH,
};
}
var e = new SDL.SDL_Event();
while (!quit)
{
// event handling
while (SDL.SDL_PollEvent(out e) > 0)
{
if (e.type == SDL.SDL_EventType.SDL_QUIT)
{
quit = true;
}
if (e.type == SDL.SDL_EventType.SDL_KEYDOWN)
{
switch (e.key.keysym.sym)
{
case SDL.SDL_Keycode.SDLK_LEFT:
useClip = useClip > 0 ? useClip - 1 : clips.Length - 1;
break;
case SDL.SDL_Keycode.SDLK_RIGHT:
useClip = useClip < clips.Length - 1 ? useClip + 1 : 0;
break;
case SDL.SDL_Keycode.SDLK_ESCAPE:
quit = true;
break;
}
}
}
// rendering
SDL.SDL_RenderClear(renderer);
SdlDrawing.RenderTexture(image, renderer, x, y, clips[useClip]);
SDL.SDL_RenderPresent(renderer);
}
ReleaseAndQuit(window, renderer, IntPtr.Zero, image);
}
public override void Cleanup()
{
SDL_ttf.TTF_Quit();
SDL_image.IMG_Quit();
SDL2.SDL.SDL_Quit();
}
public void SaveClientToPNG(String filePath)
{
DoAndCheckError(SDL_image.IMG_SavePNG(pBackBufferSurface, filePath), "Error saving client to PNG.");
}
public static IntPtr LoadTyped_RWPtr(IntPtr Src, bool Freesrc, string Type)
{
return(SDL_image.IMG_LoadTyped_RW(Src, Convert.ToInt32(Freesrc), Type));
}
public void Init()
{
SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING);
Window = SDL.SDL_CreateWindow("SDL2 GUI",
WindowSize[0], WindowSize[1],
WindowSize[2], WindowSize[3],
SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE |
SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN |
SDL.SDL_WindowFlags.SDL_WINDOW_INPUT_FOCUS);
SDL.SDL_SetWindowResizable(Window, SDL.SDL_bool.SDL_FALSE);
int drivers = SDL.SDL_GetNumRenderDrivers();
for (int i = 0; i < drivers; i++)
{
SDL.SDL_RendererInfo info;
SDL.SDL_GetRenderDriverInfo(i, out info);
Renderer = SDL.SDL_CreateRenderer(Window, i, (SDL.SDL_RendererFlags)info.flags);
if (Renderer.ToInt32() != 0)
{
Printer.Instance.Init(Renderer);
break;
}
}
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
LoadImages();
SDL.SDL_Rect sliceParams;
sliceParams.x = 4;
sliceParams.y = 4;
sliceParams.w = 27;
sliceParams.h = 27;
_images[0].Slice(sliceParams);
_images[1].Slice(sliceParams);
_images[2].Slice(sliceParams);
_images[3].Slice(sliceParams);
_gui = new MyGUI(Renderer, WindowSize[2], WindowSize[3]);
Canvas window = new Canvas(_gui);
for (int i = 0; i < 4; i++)
{
Button b = new Button(_images[0], _images[1], _images[2], _images[3], 0, i * 25, 100, 25, "Click Me!");
b.OnMouseClick = ClickHandler;
if (i == 3)
{
b.Disable();
b.SetText("Disabled");
_toEnableRef = b;
}
else
{
_countersByButtonId.Add(b.ObjectId, 0);
}
window.AddElement(b);
}
Button enabler = new Button(_images[0], _images[1], _images[2], _images[3], 0, 5 * 25, 100, 25, "Enabler");
enabler.OnMouseClick = EnablerHandler;
window.AddElement(enabler);
Button b2 = new Button(_images[0], _images[1], _images[2], _images[3], 775, 0, 25, 25, "X");
b2.TextScale = 1.5f;
b2.OnMouseClick = ExitApp;
window.AddElement(b2);
_gui.PushCanvas(window);
}
public static SDLTexture LoadTyped_RW(IntPtr Src, bool Freesrc, string Type)
{
return(new SDLTexture(SDL_image.IMG_LoadTyped_RW(Src, Convert.ToInt32(Freesrc), Type)));
}
public void SaveAsPng(Stream stream, int width, int height)
{
// Get the Texture2D pixels
byte[] data = new byte[Width * Height * 4];
GetData(data);
// Create an SDL_Surface*, write the pixel data
IntPtr surface = SDL.SDL_CreateRGBSurface(
0,
Width,
Height,
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
);
SDL.SDL_LockSurface(surface);
Marshal.Copy(
data,
0,
INTERNAL_getSurfacePixels(surface),
data.Length
);
SDL.SDL_UnlockSurface(surface);
data = null; // We're done with the original pixel data.
// Blit to a scaled surface of the size we want, if needed.
if (width != Width || height != Height)
{
IntPtr scaledSurface = SDL.SDL_CreateRGBSurface(
0,
width,
height,
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
);
SDL.SDL_BlitScaled(
surface,
IntPtr.Zero,
scaledSurface,
IntPtr.Zero
);
SDL.SDL_FreeSurface(surface);
surface = scaledSurface;
}
// Create an SDL_RWops*, save PNG to RWops
byte[] pngOut = new byte[width * height * 4]; // Max image size
IntPtr dst = SDL.SDL_RWFromMem(pngOut, pngOut.Length);
SDL_image.IMG_SavePNG_RW(surface, dst, 1);
SDL.SDL_FreeSurface(surface); // We're done with the surface.
// Get PNG size, write to Stream
int size = (
(pngOut[33] << 24) |
(pngOut[34] << 16) |
(pngOut[35] << 8) |
(pngOut[36])
) + 41 + 57; // 41 - header, 57 - footer
stream.Write(pngOut, 0, size);
}
public static IntPtr ReadXPMFromArrayPtr(string[] xpm)
{
return(SDL_image.IMG_ReadXPMFromArray(xpm));
}
private static bool Init()
{
//Initialization flag
bool success = true;
//Initialize SDL
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) < 0)
{
Console.WriteLine("SDL could not initialize! SDL_Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
//Set texture filtering to linear
if (SDL.SDL_SetHint(SDL.SDL_HINT_RENDER_SCALE_QUALITY, "1") == SDL.SDL_bool.SDL_FALSE)
{
Console.WriteLine("Warning: Linear texture filtering not enabled!");
}
//Create window
_Window = SDL.SDL_CreateWindow("SDL Tutorial", SDL.SDL_WINDOWPOS_UNDEFINED, SDL.SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
if (_Window == IntPtr.Zero)
{
Console.WriteLine("Window could not be created! SDL_Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
//Create vsynced renderer for window
var renderFlags = SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC;
Renderer = SDL.SDL_CreateRenderer(_Window, -1, renderFlags);
if (Renderer == IntPtr.Zero)
{
Console.WriteLine("Renderer could not be created! SDL Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
//Initialize renderer color
SDL.SDL_SetRenderDrawColor(Renderer, 0xFF, 0xFF, 0xFF, 0xFF);
//Initialize PNG loading
var imgFlags = SDL_image.IMG_InitFlags.IMG_INIT_PNG;
if ((SDL_image.IMG_Init(imgFlags) > 0 & imgFlags > 0) == false)
{
Console.WriteLine("SDL_image could not initialize! SDL_image Error: {0}", SDL.SDL_GetError());
success = false;
}
//Initialize SDL_ttf
if (SDL_ttf.TTF_Init() == -1)
{
Console.WriteLine("SDL_ttf could not initialize! SDL_ttf Error: {0}", SDL.SDL_GetError());
success = false;
}
}
}
}
return(success);
}
public static SDLSurface ReadXPMFromArray(string[] xpm)
{
return(new SDLSurface(SDL_image.IMG_ReadXPMFromArray(xpm)));
}
public void Execute()
{
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) != 0)
{
SdlLogger.Fatal(nameof(SDL.SDL_Init));
}
SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
if (SDL_ttf.TTF_Init() != 0)
{
SdlLogger.Fatal(nameof(SDL_ttf.TTF_Init));
}
var window = SDL.SDL_CreateWindow(TITLE, 0, 0, WIDTH, HEIGHT, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
if (window == IntPtr.Zero)
{
SdlLogger.Fatal(nameof(SDL.SDL_CreateWindow),
() => ReleaseAndQuit(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero));
}
var renderer = SDL.SDL_CreateRenderer(
window, -1,
SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
if (renderer == IntPtr.Zero)
{
SdlLogger.Fatal(
nameof(SDL.SDL_CreateRenderer),
() => ReleaseAndQuit(window, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero));
}
var font = SDL_ttf.TTF_OpenFont(Resources.GetFilePath("lesson6/long_pixel-7.ttf"), 16);
if (font == IntPtr.Zero)
{
SdlLogger.Fatal(
nameof(Resources.LoadTextureFromImage),
() => ReleaseAndQuit(window, renderer, IntPtr.Zero, IntPtr.Zero));
}
var colorWhite = new SDL.SDL_Color();
colorWhite.r = 255;
colorWhite.g = 255;
colorWhite.b = 255;
var image = SdlDrawing.CreateTextureFromText(@"SDL2_TTF - крутота!", font, colorWhite, renderer);
var quit = false;
int x, y, iW = 100, iH = 100;
x = WIDTH / 2 - iW / 2;
y = HEIGHT / 2 - iH / 2;
var e = new SDL.SDL_Event();
while (!quit)
{
// event handling
while (SDL.SDL_PollEvent(out e) > 0)
{
if (e.type == SDL.SDL_EventType.SDL_QUIT)
{
quit = true;
}
if (e.type == SDL.SDL_EventType.SDL_KEYDOWN)
{
switch (e.key.keysym.sym)
{
case SDL.SDL_Keycode.SDLK_ESCAPE:
quit = true;
break;
}
}
}
// rendering
SDL.SDL_RenderClear(renderer);
SdlDrawing.RenderTexture(image, renderer, x, y);
SDL.SDL_RenderPresent(renderer);
}
ReleaseAndQuit(window, renderer, font, image);
}
public static void SavePNG(SDLSurface Surface, string File)
{
Util.ThrowIfResultIsError(SDL_image.IMG_SavePNG(Surface.Ptr, File));
}
