DEV Community: Giovanni Cortés

Setup FNA Framework in macOS with Apple Processors

Giovanni Cortés — Fri, 06 Sep 2024 13:00:00 +0000

FNA is a reimplementation of the Microsoft XNA Game Studio 4.0 Refresh libraries, the framework with which I started learning to create video games.

FNA has good support for Windows and Linux to create a viable environment, but it has some problems with macOS, specially with M processors. So if you want to develop a FNA game in macOS is not as simple as seen, but I finally got to have a setup in my Mac.

If you want to develop games in macOS using FNA, follow these steps, these are working for me, but I can’t guarantee that it will work 100% for you. If you have problems, you can join to the Discord Server.

Install brew

First of all, we need to setup brew to be able to install all the requirements.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Install the required prerequisites

Once you have installed brew, now is time to install python, cmake and git.

brew install cmake python3 git

Get the fnalibs and compile for the platform

This is the more important step, FNA uses natives libraries to develop and run games, the FNA team provides the native libraries for Windows, Linux, and x86_64 macOS but for arm64 we need to compile by our self, but thanks to TheSpydog and his repo, we can compile our libraries easier than before.

First, you need to download the repo: https://github.com/TheSpydog/fnalibs-apple-builder

The repo has clear instructions for building, so we only need to reproduce here.

For example, if you download the repo in the Download folder, you need to go to the folder in the terminal and run the commands.

cd ~/Downloads
./updatelibs
./buildlibs macos # Build for mac, you can build for ios/ios-sim/tvos/tvos-sim/all too

After building the libraries, you are going to have a bin directory where you are going to find the native libraries that you are going to use.

Install dotnet 8

FNA uses C# to write games, so we need to install dotnet in your mac, go to theofficial site and install the Arm64 version.

Create your project

Finally we can create our project for our game. Open to your terminal, then go to the location where you are going to put your project.

cd ~/Desktop
mkdir MyGame
cd MyGame
dotnet new sln # Create a solution file to add the projects
dotnet new console -o MyGame
dotnet sln add MyGame/MyGame.csproj

You need to add the FNA repo, the FNA FAQ’s has a explanation why they are not using NuGet packages, so, in the terminal run the this command.

git clone --recursive https://github.com/FNA-XNA/FNA
dotnet sln add FNA/FNA.Core.csproj # Add the core project because we are using dotnet core

We need to add the reference in our project so we can get the FNA Framework working in our code.

cd MyGame
dotnet add reference ../FNA/FNA.Core.csproj

Once we have created the reference, we need to build our project.

dotnet build

The build command, is going to generate a build directory, you need to put the native libraries that compiled early in the build/Debu/net8.0 path.

Creating the Content folder

If you have used Monogame or XNA, you know that we need to use a Content Pipeline to convert the files in a .xnb format. In FNA we have more freedom in our assets,

The FNA documentation says:

FNA supports loading common data formats like PNG, WAV and OGG directly, and the community maintains a few libraries for font loading and rendering.

But we want to emulate XNA, so in your project root folder, create a folder and namedContent.

But we need a little of configuration in the MyGame.csproj to add the Content folder to our bin directory. Open and modify MyGame.csproj to add the next code.

<ItemGroup>
    <None Include="Content\**" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>

Your file should looks like this:

<Project Sdk="Microsoft.NET.Sdk">

  <ItemGroup>
    <ProjectReference Include="..\FNA\FNA.Core.csproj" />
  </ItemGroup>

  <ItemGroup>
    <None Include="Content\**" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>

</Project>

Test our FNA setup

Now, is time to test and see if all the steps are working.

First, download the ball image (I took from Monogame Tutorial) and save it as ball.png in the Content folder.

Now, replace the Program.cs file with this code

using System;

static class Program
{
    [STAThread]
    static void Main()
    {
        using (var g = new MainGame())
        {
            g.Run();
        }
    }
}

Create a new file and named it MainGame.cs and add this code

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

public class MainGame : Game
{
    private GraphicsDeviceManager _graphics;
    private SpriteBatch _spriteBatch;

    Texture2D ballTexture;

    public MainGame()
    {
        _graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
    }

    protected override void Initialize()
    {

        // TODO: Add your initialization logic here

        base.Initialize();
    }

    protected override void LoadContent()
    {
        _spriteBatch = new SpriteBatch(GraphicsDevice);
        ballTexture = Content.Load<Texture2D>("ball");
    }

    protected override void UnloadContent()
    {
        base.UnloadContent();
    }

    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
            Exit();

        // TODO: Add your game logic here

        base.Update(gameTime);
    }

    protected override void Draw(GameTime gameTime)
    {
        _graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

        // TODO: Add your drawing code here
        _spriteBatch.Begin();
        _spriteBatch.Draw(ballTexture, new Vector2(0, 0), Color.White);
        _spriteBatch.End();

        base.Draw(gameTime);
    }
}

This is a code that was generated in the template of XNA (I just added the ball), and it is a good template for start with your game.

Running the game

Now you can run your game

dotnet run

You should see our FNA window with a ball :D

From here, you can read XNA, Monogame and FNA tutorials to learn more or if you are a experience developer you can test your ideas.

Gaming on Ubuntu and Derivatives

Giovanni Cortés — Thu, 15 Jul 2021 22:43:40 +0000

One of the myths that we have about Linux is that it is not good for gaming, and this has been true for a long time, since we could only enjoy native games and not so high budget, although there were exceptions, we must admit that if you wanted to play , you had to have a partition with Windows.

Lately this has changed, because, although there are not many native AAA games for Linux yet, there are ways that we can play modern games and almost as easily as Windows.

In this post I am going to show you what are the options that we have to play using Ubuntu and its Ubuntu based distros (Linux Mint, Pop! _OS, Kubuntu, etc), so there will no longer be a pretext because your options to play in Linux have increased.

Steam

One of the easiest ways to play games in Linux is Steam. The Steam client is native to Linux and you can play a lot of games that are made natively for Linux, but there is also the option to use Proton.

Proton is developed by Valve and works through Steam Play so that games developed for Windows are translated into a language that is compatible with Linux, uses tools such as DirectX Vulkan so we will have almost the same performance as in Windows.

But not all games are compatible with Steam, to know which games run well and which ones we will have a bit of problems we can use Proton DB. In Proton DB we have a database that will help us know which games are compatible, we have ratings to know this.

Native: (They are native games for Linux)
Platinum : (They run perfectly without making modifications)
Gold : (Runs perfectly after making a few minor modifications)
Silver : (Runs the game, with a few minor issues, but generally plays well)
Bronze : (Runs but with problems)
Borked : (Game won’t even start or is unplayable)

If you go to the page, you will see that many games are Gold or above, and that the little unplayable are generally multiplayer (like Destiny), but before installing anything I recommend that you visit the page to see if your game runs well.

Set up and install Steam

Using Steam in Ubuntu is very easy, you just have to download the Steam client from its website and install it. If you use Pop! _OS it is much easier, since it comes in the repositories, in fact Pop!_OS has very good support for games.

sudo apt install steam

Once we have Steam installed we need to start the application, now we have to activate Steam Play and Proton

Once you activate it, you can start playing games like The Witcher 3, Skyrim and other great titles.

Lutris

Lutris is an Open Source library in which users upload scripts for emulators and WINE to run games that were made for Windows, personally I use it if there is a game that is not on Steam like Magic The Gathering Arena and World of Warcraft.

The easiest way to install lutris is thought the repositories

sudo apt install lutris

If there is not Lutris in your repos, you need to add the apt-repository

sudo dpkg --add-architecture i386
sudo add-apt-repository ppa:lutris-team/lutris
sudo apt update
sudo apt install lutris

Once done, you can start searching the Lutris app for games and installing them.

Using Lutris is not as simple as Steam, but there shouldn’t be so many complications, I play Magic and WoW without problems, but sometimes there are scripts that don’t work, it is a matter of reading the instructions that come at the beginning and installing.

Here are some screenshots that I am actually playing in WoW

Graphics Cards and Hardware

Obviously Linux does not make miracles, to play recent games you will have to have a graphic card that is capable to play games in high resolution, for example, to play high in 1080p you can use an NVIDIA GeForce GTX 1660Ti or 1660 super, if you have a better card you can take advantage of it.

Also the AMD cards are good and have good Linux support.

If you want to use your NVIDIA card to its full potential, you have to activate the proprietary drivers.

If you use Pop! _OS, you have to download the ISO that has the NVIDIA drivers integrated.

Regarding the CPU, it is good to have an iCore 5 from 8th generation onwards or a Ryzen 5 from 2nd generation, for RAM with 16 GB it is enough for all games.

MangoHud

One of the things I like to do is monitoring the temperature of the GPU and CPU while I am playing, as well as the percentage of use, I use MangoHud to have those statistics

To install MangoHud do the following, we must install git to make it easier

sudo apt install git

Inside the MangoHud folder we run the following (let it finish executing one command before running the next one)

./build.sh build
./build.sh package
./build.sh install

Once it is installed, we must create a configuration file to show what we want to , we can copy the one that comes by default

cp /usr/share/doc/mangohud/MangoHud.conf.example ~/.config/MangoHud/MangoHud.conf

Open the file

gedit ~/.config/MangoHud/MangoHud.conf

And copy paste this code

### MangoHud configuration file
### Uncomment any options you wish to enable. Default options are left uncommented
### Use some_parameter=0 to disable a parameter (only works with on/off parameters)
### Everything below can be used / overridden with the environment variable MANGOHUD_CONFIG instead

################ PERFORMANCE #################

### Limit the application FPS. Comma-separated list of one or more FPS values (e.g. 0,30,60). 0 means unlimited (unless VSynced).
# fps_limit=

### VSync [0-3] 0 = adaptive; 1 = off; 2 = mailbox; 3 = on
# vsync=

### OpenGL VSync [0-N] 0 = off; >=1 = wait for N v-blanks, N > 1 acts as a FPS limiter (FPS = display refresh rate / N)
# gl_vsync=

################### VISUAL ###################

### Legacy layout
# legacy_layout = false

### Display the current CPU information
cpu_stats
cpu_temp
# cpu_power
# cpu_text = "CPU"
# cpu_mhz
# cpu_load_change
# cpu_load_value
# cpu_load_color

### Display the current GPU information
gpu_stats
gpu_temp
# gpu_core_clock
# gpu_mem_clock
# gpu_name
# gpu_power
# gpu_text = "GPU"
# vulkan_driver
# gpu_load_change
# gpu_load_value
# gpu_load_color

### Display FPS and frametime
fps
# fps_sampling_period=
frametime

### Display loaded MangoHud architecture
# arch

### Display the frametime line graph
frame_timing
#histogram

### Display the current system time
# time

### Time formatting examples
# time_format = %H:%M
# time_format = [%T %F]
# time_format = %X # locally formatted time, because of limited glyph range, missing characters may show as '?' (e.g. Japanese)

### Change the hud font size (default is 24)
font_size=24
# font_scale=1.0
# font_size_text=24
# font_scale_media_player = 0.55
# no_small_font

### Change default font (set location to .TTF/.OTF file )
## Set font for the whole hud
# font_file=

## Set font only for text like media player metadata
# font_file_text=

## Set font glyph ranges. Defaults to latin-only. Don't forget to set font_file/text_font_file to font that supports these.
## Probably don't enable all at once because of memory usage and hardware limits concerns.
## If you experience crashes or text is just squares, reduce glyph range or reduce font size.
# font_glyph_ranges=korean, chinese, chinese_simplified, japanese, cyrillic, thai, vietnamese, latin_ext_a, latin_ext_b

### Change the hud position (default is top-left)
position=top-left

### Display the current CPU load & frequency for each core
# core_load

### IO read and write for the app (not system)
# io_read
# io_write
# io_stats

### Display system RAM / VRAM usage
ram
vram

### Display MangoHud, engine or Wine version
# version
# engine_version
# wine

### Disable / hide the hud by default
# no_display

### Hud position offset
# offset_x=
# offset_y=

### Hud dimensions
# width=
# height=
# table_columns=
# cellpadding_y=

### Hud transparency / alpha
background_alpha=0.5
# alpha=

### Color customization
# text_color=FFFFFF
# gpu_color=2E9762
# cpu_color=2E97CB
# vram_color=AD64C1
# ram_color=C26693
# engine_color=EB5B5B
# io_color=A491D3
# frametime_color=00FF00
# background_color=020202
# media_player_color=FFFFFF
# wine_color=732010

### Show media player metadata
# media_player
# media_player_name = spotify
# media_player_order = title,artist,album

### Specify gpu with pci bus id for amdgpu and NVML stats.
### Set to 'domain:bus:slot.function'
# pci_dev = 0:0a:0.0

### Blacklist
# blacklist =

################## INTERACTION #################

### Change toggle keybinds for the hud & logging
toggle_hud=F11
# toggle_fps_limit=Shift_L+F1
# toggle_logging=Shift_L+F2
# reload_cfg=Shift_L+F4
# upload_log=Shift_L+F3

################## LOG #################
### Automatically start the log after X seconds
# autostart_log = 1
### Set amount of time in seconds that the logging will run for
# log_duration
### Set location of the output files (required for logging)
# output_folder = /home/<USERNAME>/mangologs
### Permit uploading logs directly to FlightlessMango.com
# permit_upload=1
### Define a '+'-separated list of percentiles shown in the benchmark results.
### Use "AVG" to get a mean average. Default percentiles are 97+AVG+1+0.1
# benchmark_percentiles=

There are several options that you can uncomment (remove the # from the command) but with this file that we have we can already see the amount of RAM and CPU that is used as well as the percentage and you can activate and deactivate with F11.

Now, to show it in Steam games, you must type the following in the launch parameters of each game.

mangohud %command%

I will change the picture for the english version

For Lutris we must go to Options and have the advanced option enabled, and in system options in the Command Prefix part, write mangohud

And now you can have MangoHud activated.

With this guide I hope you can start playing on Linux and enjoy gaming.

The post Gaming on Ubuntu and Derivatives appeared first on Giovanni Codes.

Setup SDL2 with Visual Studio Code and mingw64 on Windows

Giovanni Cortés — Mon, 28 Sep 2020 15:50:18 +0000

Recently I changed my setup from macOS to Windows, and I’d like to do some experiments with GameDev in Windows. So one of the first things that I did was try to set up my dev environment and test some SDL2 code.

This is a simple guide to how to setup SDL2 with Visual Studio Code and mingw64, for me worked and I hope that you can start with SDL2 in Windows.

Installing the tools.

The first thing that we need to install is Visual Studio Code editor. Download, install, and launch VS Code.

You need to install the C/C++ plugin from Microsoft.

Now, you need to install mingw64 to use the compilers that are included like g++, if you want to use the Visual Studio compiler, you can change some of the settings here but for now we continue with mingw64.

For easy installation, use the MinGW-W64 Online Installer, take note of the path where you installed your compiler, because we’re going to need it in the configuration.

Now, we need to download SDL2. For our case, we have to download the Development libraries for MinGW

And download the Runtime libraries to run our games.

We are going to use the x64 version. Unzip those folders in a location that you can find because we are going to need it.

Creating the SDL2 project

Now we are ready to start our SDL2 project. Create a folder for your project and open it with VSCode. Inside the folder, create another called src , here is where are going to save our code files. For our SDL2 and C++ configuration, create a .vscode folder. For the output of our compilation, create a build folder. Your editor should be like this

The first thing that we need to create is our Task to compile our code. In the .vscode ** folder, create a new file and name it **tasks.json. Inside the file, write the following configuration.

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "shell",
            "label": "SDL2",
            "command": "D:\\sdk\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64\\bin\\g++.exe",
            "args": [
                "-g",
                "src\\*.cpp",
                "-o",
                "build\\game.exe",
                "-ID:/sdk/sdl2/mingw/x86_64/include",
                "-LD:/sdk/sdl2/mingw/x86_64/lib",
                "-lmingw32",
                "-lSDL2main",
                "-lSDL2",
                "-mwindows"
            ],
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

label option is the name in which we are going to identify our task.

In the command option, we need to put the path to our g++ installation, that is where we install mingw64.

In the args options, we have some arguments that are important to notice. For example, "build\\game.exe", is the name of our game and the folder where we’re going to save it.

"-ID:/sdk/sdl2/mingw/x86_64/include" is where we save our SDL2 files, this is for SDL2 include libraries, the same as "-LD:/sdk/sdl2/mingw/x86_64/lib", is the path to SDL2 libraries.

"-lmingw32" is an option to compile with the mingw libraries, besides that said 32, we’re are using the 64 bits compiler. "-lSDL2main", "-lSDL2", "-mwindows" in this case, we are indicating to our compiler that we need to include the SDL2main and SDL2 libraries and we don’t want the command prompt when launching our game.

Now, we need to create a launch.json file to launch our game and debugging.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb)",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}\\build\\game.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "D:\\sdk\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64\\bin\\gdb.exe",
            "setupCommands": [
                {
                    "description": "Enably pretty printing",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "SDL2"
        }
    ]
}

"program": "${workspaceFolder}\\build\\game.exe", is the executable that we are going to launch, in our case is the same that our game.

"miDebuggerPath": "D:\\sdk\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64\\bin\\gdb.exe" is the path where gdb.exe is.

"preLaunchTask": "SDL2" before launch our program, we need to run the task “SDL2”, this is the name that we put in the label option in tasks.json.

Now, as the last configuration step, we need to configure our C++ options to have a better Intellisense autocomplete and configuration of our compiler.

In Visual Studio Code, press CTRL + SHIFT + P , write C/C++ and select C/C++ Edit configurations (GUI). Here we’re are going to change some configurations.

In Compiler Path, you need to put the path to your compiler. Like we put in the tasks.json and change the IntelliSense mode to gcc_x64. In Include Path, add the path to your SDL2 includes.

Other options that you may change are C Standard and C++ Standard, ** If you save these configurations, you are going to have a file named **c_cpp_properties.json in your .vscode folder.

Now, you need to put the SDL2.dll file in the build folder, to be able to run our SDL2 game.

Remember to use the version of your game

Testing our SDL2 game.

Create a main.cpp file in the *src * folder to test our environment, and write the next code

#include <SDL2/SDL.h>
#include <iostream>

int main(int argv, char** args)
{
    SDL_Init(SDL_INIT_EVERYTHING);

    SDL_Window *window = SDL_CreateWindow("Hello SDL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, 0);
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);

    bool isRunning = true;
    SDL_Event event;

    while (isRunning)
    {
        while (SDL_PollEvent(&event))
        {
            switch (event.type)
            {
            case SDL_QUIT:
                isRunning = false;
                break;

            case SDL_KEYDOWN:
                if (event.key.keysym.sym == SDLK_ESCAPE)
                {
                    isRunning = false;
                }
            }
        }

        SDL_RenderClear(renderer);
        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);

        SDL_RenderPresent(renderer);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

Press *F5 * and cross your fingers. You should watch a red window, is you see it, then you are ready to work with SDL2 and VS Code!

This is a simple configuration for start with SDL2, if you want to use SDL_image, you should do the same steps to add the headers and libraries. I will continue with SDL2 and check if with this configuration can be have some problems, but for now, you are able to start working with SDL2.

The post Setup SDL2 with Visual Studio Code and mingw64 on Windows appeared first on Giovanni Codes.

SFML Template to start with your game

Giovanni Cortés — Thu, 07 May 2020 21:31:42 +0000

If you have setup SFML with the tutorial that I wrote, the example is easy but is not very useful if you want to create more complex games.

In this post, I going to show you how I create a simple Game class to have more control about the game loop, the user input and the frame rate.

First, you need to create a Game.h and Game.cpp files. In your Game.h write this code

#ifndef GAME_H
#define GAME_H

#include <SFML/Graphics.hpp>

class Game
{
public:
    Game();
    void Run();

private:
    void processEvents();
    void update(sf::Time deltaTime);
    void render();
    void handlePlayerInput(sf::Keyboard::Key key, bool isPressed);

    sf::RenderWindow mWindow;

    static const sf::Time TimePerFrame;
};

#endif //GAME_H

This is the header of our Game class, as you can see, we have only a constructor and one public method run, all other methods are private to Game.

We have one method for process the SFML events and one for the player input. The update method take a delta time which is going to help us with the frame rate and with other stuffs.

And we have the *render * method, that is going to draw our game.

We need a RenderWindow to render our window and finally a const to help us with the frame rate.

Now, in the Game.cpp file, write the next code

//
// Created by Giovanni Cortes on 07/05/20.
//

#include "Game.h"

const sf::Time Game::TimePerFrame = sf::seconds(1.f/60.f);

Game::Game()
: mWindow(sf::VideoMode(640, 480), "Your Awesome Game!")
{
}

void Game::Run()
{
    sf::Clock clock;
    sf::Time timeSinceLastUpdate = sf::Time::Zero;

    while (mWindow.isOpen())
    {
        timeSinceLastUpdate += clock.restart();
        while (timeSinceLastUpdate > TimePerFrame)
        {
            timeSinceLastUpdate -= TimePerFrame;
            processEvents();
            update(TimePerFrame);
        }
        render();
    }
}

void Game::processEvents()
{
    sf::Event event{};

    while (mWindow.pollEvent(event))
    {
        switch (event.type)
        {
            case sf::Event::KeyPressed:
                handlePlayerInput(event.key.code, true);
                break;
            case sf::Event::KeyReleased:
                handlePlayerInput(event.key.code, false);
                break;
            case sf::Event::Closed:
                mWindow.close();
                break;
            default:
                break;
        }

    }
}

void Game::update(sf::Time deltaTime)
{
    // TODO: Update your objects here
    // Example: mWindow.draw(mPlayer);
}

void Game::render()
{
    mWindow.clear();

    // TODO: Draw your objects here

    mWindow.display();
}

void Game::handlePlayerInput(sf::Keyboard::Key key, bool isPressed)
{
    // TODO: Key events for your game
    // Example:
    // if (key == sf::Keyboard::W)
    // {
    // mIsMovingUp = isPressed;
    // }
}

The most important method, is the run method. We have locked our game loop to 60 frames per second thanks to line

const sf::Time TimePerFrame = sf::seconds(1.f/60.f);

SFML has a setFrameLimit() method, but I prefer use mine for control and for learning.

The remains methods are self explanatory but if you have any doubt, you can write me to explain more in detail.

Running the game loop

Now, we have to create a Main.cpp file to run our game loop, write the next code

#include "Game.h"

int main()
{
    Game game;
    game.Run();
    return 0;
}

As you can see, the code is very simple, we create a Game instance and run our game loop. If you run this, you are going to see this window

Now, you can extend your game and have a better control of your game loop.

The post SFML Template to start with your game appeared first on Giovanni Codes.

GBA Development setup in macOS

Giovanni Cortés — Fri, 10 Jan 2020 21:36:42 +0000

To develop in GBA we need the tools to do it, and installing it in macOS is simple even if they take a few steps.

Install pacman

The first thing we must do is install pacmac, which will allow us to download the devkitpro for the GBA, to install it we must go to the following URL:

https://github.com/devkitPro/pacman/releases/tag/devkitpro-pacman-1.0.1

And we will download devkitpro-pacman-installer.pkg. Once it has been downloaded, we install the package. The following will appear::

So, we need to go to *System Preferences -> Security & Privacy * and allow the permissions:

Follow the steps to install the package.

Once that the installation was finished, we need to update our .bashrc or .zshrc file.

Update our environments vars

With the installation of pacman, we need to tell to our system where the files are located, so we need to update our .bashrc or .zshrc file.

Open your file and copy the next exports

export DEVKITPRO=/opt/devkitpro
export DEVKITARM=${DEVKITPRO}/devkitARM
export DEVKITPPC=${DEVKITPRO}/devkitPPC
export PATH=${DEVKITPRO}/tools/bin:$PATH

Install Xcode Tools

Now we need to install the Xcode tools to use the compiler and other utilities. In your terminal write the follow command:

xcode-select --install

Install devkitpro

Now we have all the tools to install our GBA compiler, so is time to write in the terminal.

sudo dkp-pacman -S gba-dev

Enter your password. You will prompt with options to get more control about the things that your going to install, for now we are going to install all of them. So, hit Enter and then Enter to confirm.

If you have Catalina you will get an error.

error: Partition / is mounted read only
error: not enough free disk space
error: failed to commit transaction (not enough free disk space)

This is because Catalina root partition is only for read, and you cannot install anything here, but you can have a workaround installing with this command:

sudo dkp-pacman -S gba-dev -r /System/Volumes/Data

Again, hit Enter, and Enter.

With devkitpro installed, your are not able to create a GBA game, so we need to test if our tools was installed correctly.

Hello World GBA

In your Desktop or whenever you want, create a folder named hellogma, ** inside create a new file named **Makefile , this file will help us to compile our code and generate a rom

Copy the following

#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------

ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif

include $(DEVKITARM)/gba_rules

#---------------------------------------------------------------------------------
# TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary data
# GRAPHICS is a list of directories containing files to be processed by grit
#
# All directories are specified relative to the project directory where
# the makefile is found
#
#---------------------------------------------------------------------------------
TARGET := rom/$(notdir $(CURDIR))
BUILD := build
SOURCES := src
INCLUDES    := include
DATA :=
MUSIC :=

#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH    :=  -mthumb -mthumb-interwork

CFLAGS  :=  -g -Wall -O2\
        -mcpu=arm7tdmi -mtune=arm7tdmi\
        $(ARCH)

CFLAGS  +=  $(INCLUDE)

CXXFLAGS    :=  $(CFLAGS) -fno-rtti -fno-exceptions

ASFLAGS :=  -g $(ARCH)
LDFLAGS =   -g $(ARCH) -Wl,-Map,$(notdir $*.map)

#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
#---------------------------------------------------------------------------------
LIBS    := -lmm -lgba

#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS :=  $(LIBGBA)

#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#---------------------------------------------------------------------------------

ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------

export OUTPUT   :=  $(CURDIR)/$(TARGET)

export VPATH    :=  $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
            $(foreach dir,$(DATA),$(CURDIR)/$(dir)) \
            $(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))

export DEPSDIR  :=  $(CURDIR)/$(BUILD)

CFILES :=   $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES    :=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES :=   $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES    :=  $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))

ifneq ($(strip $(MUSIC)),)
    export AUDIOFILES   :=  $(foreach dir,$(notdir $(wildcard $(MUSIC)/*.*)),$(CURDIR)/$(MUSIC)/$(dir))
    BINFILES += soundbank.bin
endif

#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
 export LD   :=  $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
 export LD   :=  $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------

export OFILES_BIN := $(addsuffix .o,$(BINFILES))

export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)

export OFILES := $(OFILES_BIN) $(OFILES_SOURCES)

export HFILES := $(addsuffix .h,$(subst .,_,$(BINFILES)))

export INCLUDE  :=  $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
                    $(foreach dir,$(LIBDIRS),-I$(dir)/include) \
                    -I$(CURDIR)/$(BUILD)

export LIBPATHS :=  $(foreach dir,$(LIBDIRS),-L$(dir)/lib)

.PHONY: $(BUILD) clean

#---------------------------------------------------------------------------------
$(BUILD):
    @[-d $@] || mkdir -p $@
    @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile

#---------------------------------------------------------------------------------
clean:
    @echo clean ...
    @rm -fr $(BUILD) $(TARGET).elf $(TARGET).gba

#---------------------------------------------------------------------------------
else

#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------

$(OUTPUT).gba   :   $(OUTPUT).elf

$(OUTPUT).elf   :   $(OFILES)

$(OFILES_SOURCES) : $(HFILES)

#---------------------------------------------------------------------------------
# The bin2o rule should be copied and modified
# for each extension used in the data directories
#---------------------------------------------------------------------------------

#---------------------------------------------------------------------------------
# rule to build soundbank from music files
#---------------------------------------------------------------------------------
soundbank.bin soundbank.h : $(AUDIOFILES)
#---------------------------------------------------------------------------------
 @mmutil $^ -osoundbank.bin -hsoundbank.h

#---------------------------------------------------------------------------------
# This rule links in binary data with the .bin extension
#---------------------------------------------------------------------------------
%.bin.o %_bin.h :   %.bin
#---------------------------------------------------------------------------------
 @echo $(notdir $<)
    @$(bin2o)

-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------------

This template include all necessary things to compile and generate a rom, for now, the most important lines are:

TARGET := rom/$(notdir $(CURDIR))
BUILD := build
SOURCES := src
INCLUDES    := include
DATA :=
MUSIC :=

That are the directories where you’re going to write your code and generate the output. Create the rom, build, src and include folders.

Inside src directory, create a new file named hello.c and write the next code

int main()
{
    *(unsigned int*)0x04000000 = 0x0403;

    ((unsigned short*)0x06000000)[120+80*240] = 0x001F;
    ((unsigned short*)0x06000000)[136+80*240] = 0x03E0;
    ((unsigned short*)0x06000000)[120+96*240] = 0x7C00;

    while(1);

    return 0;
}

This code show three points in the screen, we are going to use only to test our environment.

Now is time to compile!

In your terminal, write this

make

And if you see this message

linking cartridge
built ... hellogba.gba
ROM fixed!

Your environment is ready to work with. In the rom ** folder, you are going to see two files, **hello.gba and hello.elf , the last one is util for debugging.

Now we need an emulator to test our “game”.

I am using mGBA and you can download it here https://mgba.io/

Load the hello.gba in the emulator and you should see this screen

Now, you are ready to create GBA games!

Resources

Some resources to start GBA development

https://www.youtube.com/channel/UCQvQbVuWMM7OYTVrmGQq0hA

http://www.coranac.com/tonc/text/toc.htm

http://www.loirak.com/gameboy/gbatutor.php

https://github.com/gbdev/awesome-gbadev

https://www.reinterpretcast.com/writing-a-game-boy-advance-game

The post GBA Development setup in macOS appeared first on Giovanni Codes.

OpenGL Setup in macOS

Giovanni Cortés — Tue, 10 Dec 2019 18:25:23 +0000

We have configured SFML in macOS, now we’re going to configure OpenGL with macOS and Xcode.

First, you need to install GLFW

brew install glfw

Then, you need to download GLAD to get the OpenGL headers: Use gl version 4.1 if you want to be compatible with macOS and in Profile select Core. Click in Generate. Download the glad.zip and unzip in your Download folder.

https://glad.dav1d.de

Once you are downloaded and unzipped the folder, put the glad and KHR folders in the /usr/local/include directory of your mac.

Creating the Xcode Project

After installed GLFW and downloading the glad files, is time to create the XCode project.

Create a new Project and macOS and Command Line Tool, then click on Next

Then, put a name to your project and select C++ as language, next and save the project

In the zip that you downloaded, you will have a glad.c file, add that file to your project

We need to configure Xcode to find the libraries that we added, so in your Xcode, select the Project Target and then Build Settings and in Header Search Paths add /usr/local/include

Now, in Framework and Libraries you need to add the libglfw library, so clic on + symbol and add the library that you will find in /usr/local/Cellar/glfw/3.3/lib

Now, in the main.cpp file, copy the follow code to test OpenGL

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);

int main()
{
    GLFWwindow* window;

    // Initialize the library
    if(!glfwInit())
        return -1;

    // Define version and compatibility settings
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
    glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    // Create a windowed mode window and its OpenGL context
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    // Mathe the window's context current
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // Initialize the OpenGL API with GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // Loop until the user closes the window
    while(!glfwWindowShouldClose(window))
    {
        // Render here!
        glClear(GL_COLOR_BUFFER_BIT);

        // Swap front and back buffers
        glfwSwapBuffers(window);

        // Poll for and process events
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width
    // and height will be significantly larger than specified on retina displays
    glViewport(0, 0, width, height);
}

If you are in Catalina and run the project, your are going to see an error, that is because the library has not the permissions to run in your mac, so you will need to sign it to run.

In the terminal copy and paste the command

codesign -f -s "your@email.com" /usr/local/Cellar/glfw/3.3/lib/libglfw.3.3.dylib

Now, run the project again and you should see the window (https://s.w.org/images/core/emoji/12.0.0-1/72x72/1f642.png)

Now you will be able to play with OpenGL

The post OpenGL Setup in macOS appeared first on Giovanni Codes.

About my learning of GameDev

Giovanni Cortés — Thu, 31 Oct 2019 03:17:22 +0000

For a long time I wanted to create video games; In fact, it was thanks to RPG Maker that I start to learn programming and I liked it, and that’s why I became a software developer

After a while I finally set out to really develop a game and release something, more than anything like a hobby, since I like everything that involves the game dev and also because it is very different from traditional programming.

I have tried some engines and sometimes I don’t feel at all comfortable, since I want to learn how everything works from inside and really learn how to program a video game without the help of engines.

After thinking a little and trying some frameworks, I decided, at least for now, to focus on two topics

MonoGame and C#
C++ and GBA programing

The first is because I like C # and it is one of my favorite languages, and I also consider MonoGame an excellent and well designed framework that comes from XNA and there is a lot of documentation since then, and something very important, it is cross platform!

Programming for GBA is because it is one of my favorite consoles. For me it would be a challenge, since you have to program at a very low level because we handle the hardware directly, even if C ++ is used you have to know its architecture. It is a great way to learn how computers work!

With this in mind, I will be writing in my blog about what I am learning and also uploading games that I will create.

So if you are interested in these two topics, you can follow my journey through my blog.

The post About my learning of GameDev appeared first on Giovanni Codes.

SFML 2.5.1 setup on macOS with CLion

Giovanni Cortés — Tue, 29 Oct 2019 23:50:51 +0000

I know that the title is very specific but that is the platform that I am doing some experiments with SFML.

So, if you want to create games with SFML and you have macOS and you want to use CLion as IDE just follow the next steps:

Install SFML

There are a lot ways to install SFML but the easiest is to install it with brew



brew install sfml

With this command, you’re going to install the version 2.5.1.

Create the project with CLion

Now is time to create a new project with CLion, put the name that you want

Now, you need to update the CMakeList.txt to compile and link your project with the SFML libraries.



cmake_minimum_required(VERSION 3.14)
project(HelloSFML)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

set(SOURCE_FILES main.cpp)
add_executable(HelloSFML ${SOURCE_FILES})
include_directories(/usr/local/include)

find_package(SFML 2.5 COMPONENTS system window graphics network audio REQUIRED)
include_directories(${SFML_INCLUDE_DIRS})
target_link_libraries(HelloSFML sfml-system sfml-window sfml-graphics sfml-audio sfml-network)

My recommendation is that you link the libraries that you are going to use, for example, only link and require sfml-graphics and sfml-audio for example.

A simple SFML project

Now , create a simple SFML code to check if all was installed correctly.



#include <SFML/Graphics.hpp>

int main()
{
    sf::RenderWindow window(sf::VideoMode(640, 480), "SFML Application");
    sf::CircleShape shape;
    shape.setRadius(40.f);
    shape.setPosition(100.f, 100.f);
    shape.setFillColor(sf::Color::Cyan);

    while (window.isOpen())
    {
        sf::Event event;

        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        window.clear();
        window.draw(shape);
        window.display();
    }
}

Run your project and you will see

Now you are ready to create games !

The post SFML 2.5.1 setup on macOS with CLion appeared first on Giovanni Codes.

Install Elixir in Debian/Ubuntu using precompiled packages

Giovanni Cortés — Fri, 25 Oct 2019 18:24:17 +0000

Today I had the necessity to update a production server using Debian to Elixir 1.9.2. The update from Elixir 1.6 to 1.9.2 was really easy but I will put my steps if anybody has the same requirement.

We will need three packages installed in our server:

wget
unzip
Erlang 20 or up

Installing Elixir

First, we need to go to our tmp folder to download the precompiled package, create a directory to unzip the package and then unzip it.

cd /tmp
wget https://github.com/elixir-lang/elixir/releases/download/v1.9.2/Precompiled.zip
mkdir elixir_precompiled
mv Precompiled.zip elixir_precompiled/
unzip Precompiled.zip

Now we have all the necessary stuff to get starting to install. We only need to move the bins and library from our temporal folder to /usr/local , or another directory. Just you need to remember to add the directory where you going to put Elixir to your system PATH.

cd bin
sudo cp elixir elixirc iex mix /usr/local/bin/
cd ..
cd lib
sudo cp -R * /usr/local/lib
cd ..
cd man
sudo cp * /usr/local/man

With those steps, we installed Elixir and the manuals for help.

As last check, we can see the elixir version in our system

Erlang/OTP 22 [erts-10.5.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] 
[async-threads:1] [hipe] [dtrace]

Elixir 1.9.2 (compiled with Erlang/OTP 22)

And that is all. We have the last version installed in our system

The post Install Elixir in Debian/Ubuntu using precompiled packages appeared first on Giovanni Codes.

Why C# is (one of) my favorite language?

Giovanni Cortés — Thu, 14 Mar 2019 20:32:31 +0000

My first approach with C# was when I was studying my career; a guy from Microsoft came to my school to do a chat about C# technologies and one of them was Windows Phone. So I started to learn C# and create Windows Phone apps (I won a Nokia for that :) ).

After one year, I started to create C# videos on YouTube and was a popular channel in its time, now is abandoned, but I received very good comments about that course in YouTube, even of teachers that send their students to watch that videos.

For some reasons, when I started my life as a professional developer I left C# and started to write apps for iOS, Python, Elixir, etc. But sometimes I had to write C# code for fixing some apps or for a job but just for 1 or 2 months. Whenever I got back to C# I feel very comfortable with the language, is like to return home. Now, that I'm doing a tutorial of MonoGame I am using C# again and I am enjoying it.

Today, I want to write why C# is one of my favorite languages and why I think that is a great language to work with

Is easy to learn

Despite Python is the option to learn as the first language, I think that C# is better to understand the "low level" programming without the complexity of C or C++.

Learn C# is not as complicated as other thinks, and because is very influenced by C and C++, once that you learned, you can change to another language very easy (I am able to read C++ code without even touched).

It is in a line between the old and the modern

When you write C#, you have to deal with "old" for style or creating arrays with a fixed length. But you can create lambdas expressions, you have access to foreach to go through a list, the string manipulation is very powerful etc.

With C# you have the option to be traditional or write code with the more advanced features.

Is very versatile

In recent years, C# has become in an all-terrain language. You can write Windows Apps, iOS apps, Android, IoT, web sites, run in Arduino, even run in Linux.

You can write games with Unity, MonoGame, Xenco and use it with Machine Learning.

Thanks to its open source we can expect a lot of implementations, and if you learn C# you can use almost as you only language (I do not recommend this but is possible)

Microsoft Documentation

I think that there is no better documentation than Microsoft Developer Site. Other pages like Apple Developer or Django are close but I feel that is not as extensive or comprehensive as Microsoft Docs.

I learned a lot (and I still doing) only reading the Microsoft site and I found that my problem was resolved without touch StackOverflow.

It is not Java

Ok, this is not a valid reason(?)

Well, that is a list of why C# is a language that I think deserve more love of the community.

Do you like or dislike C#?