internal static Font INTERNAL_Font_Create(SDLRenderer renderer, int ptSize, string filename)
{
// Create Font instance
var font = new Font();
// Assign the renderer
font._sdlRenderer = renderer;
// Create from the renderer
font._ptSize = ptSize;
font._sdlFont = SDL_ttf.TTF_OpenFont(filename, ptSize);
if (font._sdlFont == IntPtr.Zero)
{
font.Dispose();
return(null);
}
// Fetch the Surface formatting information
if (!font.FillOutInfo())
{
// Someting dun goned wrung
font.Dispose();
return(null);
}
return(font);
}
/// <summary>
/// Create a new SDL font.
/// </summary>
/// <remarks>
/// I'm normally not a huge fan of classes that load themselves, much less a constructor
/// that loads itself from a file. I have to make an exception for the moment because
/// SDL_image's API only supports loading from a file... once someone (maybe me) adds the
/// load from memory calls I can remove this and create a proper byte[] constructor
/// instead. (And leave the file loading up to the caller).
/// </remarks>
public SDLFont(SDLRenderer renderer, string fontName, int fontSize)
{
// Make sure our inputs are valid!
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (String.IsNullOrEmpty(fontName))
{
throw new ArgumentNullException("fontName");
}
if (fontSize <= 0)
{
throw new ArgumentOutOfRangeException("fontSize");
}
// Make sure the image actually exists on disk before attempting to ask SDL to load it.
// (Bonus: SDL doesn't return a null when the image does not exist on disk!)
if (!File.Exists(fontName))
{
throw new FileNotFoundException(fontName);
}
// Ask SDL to load our font for us and check if it worked.
mFont = SDL_ttf.TTF_OpenFont(fontName, fontSize);
if (mFont == null)
{
throw new SDLException("Failed to load font");
}
}
static bool LoadMedia()
{
//Loading success flag
bool success = true;
//Open the font
Font = SDL_ttf.TTF_OpenFont("lazy.ttf", 28);
if (Font == IntPtr.Zero)
{
Console.WriteLine("Failed to load lazy font! SDL_ttf Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
//Render text
var textColor = new SDL.SDL_Color();
if (!_TextTexture.LoadFromRenderedText("The quick brown fox jumps over the lazy dog", textColor))
{
Console.WriteLine("Failed to render text texture!");
success = false;
}
}
return(success);
}
static public void Main()
{
System.IntPtr window;
System.Random rand = new System.Random();
// SDL.SDL_LogSetPriority(SDL.SDL_LOG_CATEGORY_APPLICATION, SDL.SDL_LOG_PRIORITY_INFO);
// SDL.SDL_SetHint(SDL.SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING, "1");
SDL.SDL_WindowFlags flags = 0;
// flags |= SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN;
if (SDL.SDL_CreateWindowAndRenderer(WindowWidth, WindowHeight, flags, out window, out Renderer) < 0)
{
Quit(2);
}
SDL.SDL_SetWindowTitle(window, "TestTtf");
SDL.SDL_ShowCursor(0);
SDL_ttf.TTF_Init();
Font = SDL_ttf.TTF_OpenFont("misaki_gothic.ttf", FontSize);
if (LoadSprite("icon.bmp", Renderer) < 0)
{
Quit(2);
}
for (int i = 0; i < NumSprites; ++i)
{
Positions[i].x = rand.Next(WindowWidth - Sprite_w);
Positions[i].y = rand.Next(WindowHeight - Sprite_h);
Positions[i].w = Sprite_w;
Positions[i].h = Sprite_h;
Velocities[i].x = 0;
Velocities[i].y = 0;
while (Velocities[i].x == 0 && Velocities[i].y == 0)
{
Velocities[i].x = rand.Next(MaxSpeed * 2 + 1) - MaxSpeed;
Velocities[i].y = rand.Next(MaxSpeed * 2 + 1) - MaxSpeed;
}
}
Done = 0;
sw.Start();
while (Done == 0)
{
Loop();
}
SDL.SDL_DestroyRenderer(Renderer);
SDL.SDL_DestroyWindow(window);
SDL.SDL_Quit();
SDL_ttf.TTF_CloseFont(Font);
SDL_ttf.TTF_Quit();
Quit(0);
}
public Font(string path, int pointSize, FontStyle style = FontStyle.Normal, bool unicode = true)
{
cacheFonts = SettingsManager.instance.engine.cacheFonts;
this.pointSize = pointSize;
this.style = style;
this.unicode = unicode;
if (SDL_ttf.TTF_WasInit() == 0)
{
if (SDL_ttf.TTF_Init() != 0)
{
throw new ApplicationException("Failed to initialize SDL_ttf: " + SDL.SDL_GetError());
}
}
handle = SDL_ttf.TTF_OpenFont(path, pointSize);
if (handle == IntPtr.Zero)
{
throw new ApplicationException("Failed to load font: " + SDL.SDL_GetError());
}
SDL_ttf.TTF_SetFontStyle(handle, (int)style);
familyName = SDL_ttf.TTF_FontFaceFamilyName(handle);
ushort characterCount = unicode ? ushort.MaxValue : (ushort)256;
bool generateTextures = true;
if (cacheFonts)
{
if (LoadGlyphDataCached() && LoadTextureDataCached())
{
Log.Info("Font: Using cached font data");
generateTextures = false;
}
else
{
glyphs = null;
foreach (Texture2D texture in textures)
{
texture.Dispose();
}
textures.Clear();
}
}
if (generateTextures)
{
GenerateGlyphData(characterCount);
GenerateTextures(characterCount);
if (cacheFonts)
{
CacheGlyphData();
}
}
loadedFonts++;
}
public void UpdateFontString(string strOutput, SDL.SDL_Rect dstRect, SdlTextureOrientation orientation = null, int fontSize = 28, SDL.SDL_Color?color = null)
{
// checking initialization
if (SDL_ttf.TTF_WasInit() == 0 && SDL_ttf.TTF_Init() < 0)
{
Debug.WriteLine($"Could not create LoadingScreen: {SDL.SDL_GetError() }");
return;
}
var textTexture = SDL.SDL_CreateTextureFromSurface(_renderer, SDL_ttf.TTF_RenderText_Blended(
SDL_ttf.TTF_OpenFont(_fontSourceRegular, fontSize),
"Initializing...",
color ?? new SDL.SDL_Color {
a = 0xff, r = 0xff, g = 0xff, b = 0xff
}
));
orientation = orientation ?? new SdlTextureOrientation();
SDL.SDL_QueryTexture(textTexture, out uint fmt, out int acs, out dstRect.w, out dstRect.h);
// TODO: testwise implement horizontal centering (ignoring all other cases for now)
switch (orientation.Horizontal)
{
case TextureOrientation.Center:
dstRect.x = _rectOrigin.w / 2 - dstRect.w / 2;
break;
}
if (textTexture == IntPtr.Zero)
{
Debug.WriteLine($"Could not create texture for ttf: {SDL.SDL_GetError()}");
return;
}
SDL.SDL_RenderCopy(_renderer, textTexture, ref _rectOrigin, ref dstRect);
}
static bool LoadMedia()
{
//Loading success flag
bool success = true;
//Open the font
Font = SDL_ttf.TTF_OpenFont("lazy.ttf", 28);
if (Font == IntPtr.Zero)
{
Console.WriteLine("Failed to load lazy font! SDL_ttf Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
//Set text color as black
var textColor = new SDL.SDL_Color {
a = 255
};
//Load prompt texture
if (!_PromptTextTexture.LoadFromRenderedText("Press Enter to Reset Start Time.", textColor))
{
Console.WriteLine("Unable to render prompt texture!");
success = false;
}
}
return(success);
}
static bool loadMedia()
{
//Loading success flag
bool success = true;
//Open the font
gFont = SDL_ttf.TTF_OpenFont("lazy.ttf", 28);
if (gFont == IntPtr.Zero)
{
Console.WriteLine("Failed to load lazy font! SDL_ttf Error: {0}", SDL.SDL_GetError());
success = false;
}
else
{
SDL.SDL_Color textColor = new SDL.SDL_Color {
a = 0xFF
};
if (!gPromptTextTexture.loadFromRenderedText("Enter Text:", textColor))
{
Console.WriteLine("Failed to render prompt text!");
success = false;
}
}
return(success);
}
//initialize the Three Card Poker sprites and variables
public unsafe ThreeCardPokerGame(IntPtr interfaceWindow)
{
window = interfaceWindow;
windowSurface = SDL.SDL_GetWindowSurface(window);
SDL.SDL_Surface *windowSDLSurface = (SDL.SDL_Surface *)windowSurface;
clearColor = SDL.SDL_MapRGB(windowSDLSurface->format, 0, 100, 0);
textColor.r = 255; textColor.b = 255; textColor.g = 255; textColor.a = 255;
screenRect.x = 0; screenRect.y = 0;
screenRect.w = 600; screenRect.h = 480;
cardSprite = SDL.SDL_LoadBMP("cards.bmp");
cardBackSprite = SDL.SDL_LoadBMP("card back blue.bmp");
playButton = SDL.SDL_LoadBMP("play button.bmp");
foldButton = SDL.SDL_LoadBMP("fold button.bmp");
dealButton = SDL.SDL_LoadBMP("deal button.bmp");
quitButton = SDL.SDL_LoadBMP("quit button.bmp");
font = SDL_ttf.TTF_OpenFont("times.ttf", 20);
betTextSprite = SDL_ttf.TTF_RenderText_Solid(font, "Ante: $50", textColor);
playerWinTextSprite = SDL_ttf.TTF_RenderText_Solid(font, "You won!", textColor);
dealerWinTextSprite = SDL_ttf.TTF_RenderText_Solid(font, "The dealer won.", textColor);
drawTextSprite = SDL_ttf.TTF_RenderText_Solid(font, "Draw...", textColor);
}
public void LoadInit(IntPtr rendererPtr)
{
fontPtr = SDL_ttf.TTF_OpenFont("media/font/typed.ttf", 25);
if (fontPtr == IntPtr.Zero)
{
Console.WriteLine("Error loading font. SDL: {0}", SDL.SDL_GetError());
}
textColor = new SDL.SDL_Color
{
r = 217,
g = 204,
b = 0,
a = 255
};
activeTextColor = new SDL.SDL_Color
{
r = 255,
g = 125,
b = 0,
a = 255
};
}
protected override Font MakeFont(string name, int size)
{
IntPtr ft = SDL_ttf.TTF_OpenFont(name, size);
if (ft != IntPtr.Zero)
{
return(new SDLFont(name, size, ft));
}
return(null);
}
public SDL2GeneralDisplay(string title, int width, int height, int internalWidth, int internalHeight, int x = 0, int y = 0, string fontFile = null, int?fontSize = null)
{
SDL_ttf.TTF_Init();
_font = SDL_ttf.TTF_OpenFont(fontFile ?? "./default.ttf", fontSize ?? 20);
InternalWidth = internalWidth;
InternalHeight = internalHeight;
ActualWidth = width;
ActualHeight = height;
SDL.SDL_Init(SDL.SDL_INIT_VIDEO);
try
{
_window = SDL.SDL_CreateWindow(title,
SDL.SDL_WINDOWPOS_CENTERED,
SDL.SDL_WINDOWPOS_CENTERED,
width,
height,
SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE | SDL.SDL_WindowFlags.SDL_WINDOW_VULKAN
);
}
catch { }
finally
{
if (_window == IntPtr.Zero)
{
_window = SDL.SDL_CreateWindow(title,
SDL.SDL_WINDOWPOS_CENTERED,
SDL.SDL_WINDOWPOS_CENTERED,
width,
height,
SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE);
}
}
if (x > 0 && y > 0)
{
SDL.SDL_SetWindowPosition(_window, x, y);
}
Pixels = new uint[internalWidth * internalHeight * 4];
PixelsText = new uint[internalWidth * internalHeight * 4];
_renderer = SDL.SDL_CreateRenderer(_window, -1, 0);
_texture = SDL.SDL_CreateTexture(_renderer, SDL.SDL_PIXELFORMAT_ARGB8888, (int)SDL.SDL_TextureAccess.SDL_TEXTUREACCESS_TARGET, internalWidth, internalHeight);
SDL.SDL_GL_SetSwapInterval(0);
unsafe { fixed(uint *t = &Pixels[0]) _bufferPtr = new IntPtr(t); }
IsOpen = true;
}
public static TextRenderer Load(string fontPath, int size)
{
var font = SDL_ttf.TTF_OpenFont(fontPath, size);
if (font == IntPtr.Zero)
{
throw new InvalidOperationException($"Cant load font {fontPath}: {SDL.SDL_GetError()}");
}
return(new TextRenderer(font));
}
/* #################################################################### */
/* # CONSTRUCTORS # */
/* #################################################################### */
/* #################################################################### */
/* # DELEGATES # */
/* #################################################################### */
/* #################################################################### */
/* # PROPERTIES # */
/* #################################################################### */
/* #################################################################### */
/* # METHODS # */
/* #################################################################### */
public IntPtr GetFont(string name, int size)
{
var key = $"{name}__{size}";
if (!_fonts.ContainsKey(key))
{
var font = SDL_ttf.TTF_OpenFont(Engine.Instance.Path("assets", "base", "fonts", $"{name}.ttf"), size);
_fonts.Add(key, font);
}
return(_fonts[key]);
}
private void LoadAndPrepareResources()
{
music_mp3 = SDL_mixer.Mix_LoadMUS("ringtone.mp3");
if (music_mp3 == IntPtr.Zero)
{
Console.WriteLine("Failed to load mp3! SDL_mixer error {0}", SDL.SDL_GetError());
}
SDL_mixer.Mix_PlayMusic(music_mp3, -1);
music_wav = SDL_mixer.Mix_LoadWAV("beat.wav");
if (music_wav == IntPtr.Zero)
{
Console.WriteLine("Failed to load wav! SDL_mixer error {0}", SDL.SDL_GetError());
}
font = SDL_ttf.TTF_OpenFont("lazy.ttf", 64);
if (font == IntPtr.Zero)
{
Console.WriteLine("Failed to load lazy font! SDL_ttf Error: {0}", SDL.SDL_GetError());
}
//Render text surface
var textColor = new SDL.SDL_Color();
var textSurface = SDL_ttf.TTF_RenderText_Solid(font, "Hello SDL2 World!", textColor);
if (textSurface == IntPtr.Zero)
{
Console.WriteLine("Unable to render text surface! SDL_ttf Error: {0}", SDL.SDL_GetError());
}
texture_text = SDL.SDL_CreateTextureFromSurface(renderer, textSurface);
if (texture_text == IntPtr.Zero)
{
Console.WriteLine("Unable to create texture from rendered text! SDL Error: {0}", SDL.SDL_GetError());
}
s_text = Marshal.PtrToStructure <SDL.SDL_Surface>(textSurface);
IntPtr image_png = SDL_image.IMG_Load("transparent.png");
if (image_png == IntPtr.Zero)
{
Console.WriteLine("Unable to load image! SDL_image Error: {0}", SDL.SDL_GetError());
}
s_png = Marshal.PtrToStructure <SDL.SDL_Surface>(image_png);
SDL.SDL_SetColorKey(image_png, (int)SDL.SDL_bool.SDL_TRUE, SDL.SDL_MapRGB(s_png.format, 0, 0xFF, 0xFF));
texture_png = SDL.SDL_CreateTextureFromSurface(renderer, image_png);
if (texture_png == IntPtr.Zero)
{
Console.WriteLine("Unable to create texture from png! SDL Error: {0}", SDL.SDL_GetError());
}
}
/// <summary>
/// Loads a font from the Assets directory for a single text size. Supports the following formats: TTF, FON.
/// </summary>
/// <param name="path">The path to the font file, relative to the Assets directory.</param>
/// <param name="pointSize">The size of the text that will be rendered by this font (in points).</param>
public static Font LoadFont(string path, int pointSize)
{
IntPtr handle = SDL_ttf.TTF_OpenFont(GetAssetPath(path), pointSize);
if (handle == IntPtr.Zero)
{
throw new Exception("Failed to load font.");
}
return(new Font(handle));
}
public GameStatusBar(Game game)
{
this._current = game;
this._target = new SDL.SDL_Rect();
this._font = SDL_ttf.TTF_OpenFont("arial.ttf", 15);
this._color = new SDL.SDL_Color();
_color.r = 255;
_color.g = 255;
_color.b = 255;
}
public override void Load(string path, ContentLoader contentLoader)
{
Canvas = contentLoader.Canvas as SDLCanvas;
FilePath = path;
SDL_Font = SDL_ttf.TTF_OpenFont(FilePath, FontSize);
FontSize = FontSize;
if (SDL_Font == SDL_Font.Zero)
{
Logger.Log(LogLevel.Error, $"Error loading SDLFont '{path}' with error : {SDL2.SDL.SDL_GetError()}");
}
}
public Font(string Path, int Size = 12)
{
FontPointer = SDL_ttf.TTF_OpenFont(Path, Size);
if (FontPointer == IntPtr.Zero)
{
//Console.WriteLine("Something went wrong with TTF_OpenFont.");
//Console.WriteLine("You are probably going to segfault the program.");
//string Err = SDL.SDL_GetError();
//Console.WriteLine(Err);
string Err = SDL.SDL_GetError();
throw new SDLException($"TTF_OpenFont error! SDL_GetError = {Err}");
}
}
public CharacterStatusBar(CharacterBase character, int X, int Y)
{
this._current = character;
this._target = new SDL.SDL_Rect();
this._font = SDL_ttf.TTF_OpenFont("arial.ttf", 15);
this._color = new SDL.SDL_Color();
_color.r = 255;
_color.g = 255;
_color.b = 255;
this._x = X;
this._y = Y;
}
//Creates a font from a path
public Font(string path, ushort fontSize)
{
Size = fontSize;
FontType = SDL_ttf.TTF_OpenFont(path, fontSize);
if (FontType == null)
{
SDL.SDL_ShowSimpleMessageBox
(SDL.SDL_MessageBoxFlags.SDL_MESSAGEBOX_ERROR, "Error",
"Could not create the screen", (IntPtr)null);
Environment.Exit(4);
}
}
/// <summary>
/// Construct a font from a name and point size
/// </summary>
/// <param name="name">The path to the font from the resource folder</param>
/// <param name="ptsize">The point size of the font</param>
public Font(string name, int ptsize)
{
// Construct the full path
string path = Path.Combine(Graphics.RESOURCE_PATH, name);
// Load the font
IntPtr font = SDL_ttf.TTF_OpenFont(path, ptsize);
if (font == IntPtr.Zero)
{
throw new SDLException("TTF_OpenFont");
}
FontPtr = font;
}
static bool loadMedia()
{
//Loading success flag
bool success = true;
//Open the font
gFont = SDL_ttf.TTF_OpenFont("lazy.ttf", 28);
if (gFont == IntPtr.Zero)
{
Console.WriteLine("Failed to load lazy font! SDL_ttf Error: {0}", SDL.SDL_GetError());
success = false;
}
return(success);
}
IntPtr GetFont(int ptSize)
{
if (_fontPoints.ContainsKey(ptSize))
{
return(_fontPoints[ptSize]);
}
IntPtr fontPtr;
if ((fontPtr = SDL_ttf.TTF_OpenFont("OpenSans-Light.ttf", ptSize)) == IntPtr.Zero)
{
throw new Exception("unable to load font");
}
return(_fontPoints[ptSize] = fontPtr);
}
public int CreateFont(string path, string name, int size)
{
//Open the font
IntPtr font = SDL_ttf.TTF_OpenFont(path, size);
if (font == IntPtr.Zero)
{
Console.WriteLine($"Failed to load {path}! SDL_ttf Error: {0}", SDL.SDL_GetError());
}
else
{
fonts.Add(name, font);
}
return(0);
}
public Font(string path, int fontPointSize)
{
if (String.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
FilePath = path;
PointSize = fontPointSize;
Handle = SDL_ttf.TTF_OpenFont(path, fontPointSize);
if (Handle == IntPtr.Zero)
{
throw new InvalidOperationException(String.Format("TTF_OpenFont: {0}", SDL.SDL_GetError()));
}
}
public static IntPtr DrawText(string text, string fontFileTTF, byte r, byte g, byte b, byte a)
{
IntPtr font = SDL_ttf.TTF_OpenFont(fontFileTTF, 40);
SDL_Color color;
color.r = r;
color.g = g;
color.b = b;
color.a = a;
IntPtr surfaceMessage = SDL_ttf.TTF_RenderText_Solid(font, text, color);
IntPtr message = SDL_CreateTextureFromSurface(Screen.Renderer, surfaceMessage);
SDL_FreeSurface(surfaceMessage);
return(message);
}
private static void Init()
{
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) != 0)
{
throw new SdlException(nameof(SDL.SDL_Init));
}
if (SDL_ttf.TTF_Init() != 0)
{
throw new SdlException(nameof(SDL_ttf.TTF_Init));
}
_window = SDL.SDL_CreateWindow("Langton`s Ant", 0, 0, 640, 480, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
if (_window == IntPtr.Zero)
{
throw new SdlException(nameof(SDL.SDL_CreateWindow));
}
_renderer = SDL.SDL_CreateRenderer(
_window, -1,
SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
if (_renderer == IntPtr.Zero)
{
throw new SdlException(nameof(SDL.SDL_CreateRenderer));
}
_font = SDL_ttf.TTF_OpenFont(_fontPath, 14);
KeydownHandler = new KeyHandler();
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_ESCAPE, () => _quit = true);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F5, LoadWorld);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F2, () => _speed -= 10);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F3, () => _speed += 10);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F4, () => _speed = 0);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_z, () => GetWorldRenderer().AddZoom(-10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_x, () => GetWorldRenderer().AddZoom(10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_c, () => GetWorldRenderer().ResetZoom());
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_RIGHT, () => GetWorldRenderer().MoveZoom(10, 0));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_UP, () => GetWorldRenderer().MoveZoom(0, -10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_LEFT, () => GetWorldRenderer().MoveZoom(-10, 0));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_DOWN, () => GetWorldRenderer().MoveZoom(0, 10));
}
private static IntPtr MakeTextSurface(string message)
{
SDL_ttf.TTF_Init();
var font = SDL_ttf.TTF_OpenFont(ArialFontFilename(), 128);
if (font == IntPtr.Zero)
{
throw new Exception($"Could not initialize font: {SDL_GetError()}");
}
var color = new SDL_pixels.SDL_Color {
r = 255, g = 255, b = 255, a = 255
};
var surface = SDL_ttf.TTF_RenderText_Solid(font,
message, color);
SDL_ttf.TTF_CloseFont(font);
SDL_ttf.TTF_Quit();
return(surface);
}
public static bool InitEngine()
{
// Initialise the log
log = new Log("harambae_runtime.log");
log.Info("Engine starting");
// Initialise required SDL2 components
int result;
result = SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING);
if (result < 0)
{
log.Error("Could not init SDL2");
return(false);
}
if (CreateContext(800, 600, false) == false)
{
log.Error("Could not create a context");
return(false);
}
// SDL2_TTF
result = SDL_ttf.TTF_Init();
if (result < 0)
{
log.Error("Could not init SDL2_TTF");
DestroyContext();
SDL.SDL_Quit();
return(false);
}
largefont = SDL_ttf.TTF_OpenFont("assets/papyrus.ttf", 32);
smallfont = SDL_ttf.TTF_OpenFont("assets/papyrus.ttf", 16);
// SDL2_image
result = SDL_image.IMG_Init(SDL_image.IMG_InitFlags.IMG_INIT_PNG);
return(true);
}