Game framework using C++

Question

I'm writing my own game framework and would like to get feedback on the API while I'm writing it. At the moment it's very simple, but I would like some guidance about where to take it.

This is a sample main function to create a window:

#include <string>
#include <iostream>

#include "pneu/graphics/Window.hpp"
#include "pneu/core/MethodResult.hpp"

int main(int argc, const char** argv) {
  // declare window
  pneu::graphics::Window window("hello-world", 800, 600, 80, 60);

  // initialise it, handling any errors
  window.init().onError([](const std::string& error) {
                          std::cout << error << std::endl;
                          exit(1);
                        });

  // main event loop
  while (window.isRunning()) {
    window.pollEvents();
    window.update();
    window.renderFrame();
  }

  return 0;
}

Here is the declaration of MethodResult (it's a header-only class)

#pragma once

#include <exception>
#include <functional>
#include <string>

namespace pneu {

namespace core {

class MethodResult final {
public:
  static auto ok(void) -> MethodResult
  {
    return MethodResult(true, "");
  }

  static auto error(const std::string& desc) -> MethodResult
  {
    return MethodResult(false, desc);
  }

  MethodResult(const MethodResult&) = default;
  ~MethodResult(void)               = default;

  inline auto isOk(void) const -> bool
  {
    return fOk;
  }

  inline auto getError(void) const -> std::string
  {
    return fDescription;
  }

  inline auto onError(const std::function<void (const std::string&)>& f) -> void
  {
    if (!isOk()) {
      f(getError());
    }
  }

  inline auto throwOnError(const std::exception& e) -> void
  {
    if (!isOk()) {
      throw e;
    }
  }

private:
  MethodResult(bool ok, const std::string& desc)
    :
    fOk(ok),
    fDescription(desc) { }

  const bool fOk;
  const std::string fDescription;
};

} // namespace core

} // namespace pneu

#define PNEU_EXCEPT_TO_METHODRES(func) \
  do { \
    try { \
      func; \
    } catch(const std::exception& e) { \
      return pneu::Graphics::MethodResult::error(e.what()); \
    } \
  }

#define PNEU_TRY_METHOD(func) \
  do { \
    auto err = func; \
    if (!err.isOk()) { \
      return err; \
    } \
  } while(0)

Window class declaration

#pragma once

#include <memory>
#include <string>

struct GLFWwindow;

namespace pneu {

namespace core {

class MethodResult;

} // namespace core

namespace graphics {

class RenderObject;
class Window final {
public:
  Window(const std::string& title, int width,
                                   int height,
                                   int min_width = 0,
                                   int min_height = 0);
  Window(const Window&)                                                     = delete;
  Window(Window&&)                                                          = delete;
  auto operator=(const Window&)                                  -> Window& = delete;
  ~Window(void);

  auto init(void)                                                -> pneu::core::MethodResult;

  auto update(void)                                              -> void;
  auto pollEvents(void)                                          -> void;
  auto renderFrame(void)                                         -> void;

  auto isRunning(void)                                           -> bool;

  auto addRenderObject(std::weak_ptr<RenderObject> object)       -> void;

private:  
  auto _initGlfw(const std::string&)                             -> pneu::core::MethodResult;

  auto _handleKeypress(int, int, int, int)                       -> void;
  auto _handleRefresh(void)                                      -> void;
  auto _handleQuitRequested(void)                                -> void;

  auto _handleWindowResize(int, int)                             -> void;
  auto _handleWindowMove(int, int)                               -> void;
  auto _handleViewportResize(int, int)                           -> void;

  auto _handleFocusLost(void)                                    -> void;
  auto _handleFocusGained(void)                                  -> void;

  static auto _windowResizeCallback(GLFWwindow*, int, int)       -> void;
  static auto _viewportResizeCallback(GLFWwindow*, int, int)     -> void;

  static auto _windowMoveCallback(GLFWwindow*, int, int)         -> void;
  static auto _refreshCallback(GLFWwindow*)                      -> void;
  static auto _keypressCallback(GLFWwindow*, int, int, int, int) -> void;
  static auto _quitRequestedCallback(GLFWwindow*)                -> void;
  static auto _windowFocusChangeCallback(GLFWwindow*, int)       -> void;

  struct WindowImpl;
  std::unique_ptr<WindowImpl> fWinImpl;
  std::string fWinTitle;
};

} // namespace graphics

} // namespace pneu

The two code snippets you have presented appear to have nothing to do with each other. Neither one "works", as far as I can tell. Your first function uses the Window class, which isn't included in the question. The MethodResult class seems to do some error handling, but I can't tell how it's supposed to be used. — 200_success♦, Aug 8 '14 at 17:53
Sorry if its incomplete. The Window's init() method returns a MethodResult, which is a class that is supposed to be used to signal the success of a method which may fail, but does not return a value, similar to a Maybe class. I will add the Window class header to the question. — burtonageo, Aug 8 '14 at 19:09

glampert · Answer 1 · 2014-08-09 14:13:35Z

up vote 1 down vote

Use the normal C++ syntax for return values:

This

auto update(void) -> void;

is very unnatural. It seems to me that you are abusing a C++11 feature. Most C++ programmers will be expecting common class methods to be declared in the usual way:

void update();

The so called trailing-return-type was designed to be used with lambdas and template functions. Not for plain class methods or common functions.

Functions/methods that take no arguments are implicitly void:

This is C:

void update(void);

This is C++:

void update();

In C, you have to add a void to the parameter list of a function that takes no arguments because otherwise the compiler would assume a default integer parameter. This does not apply to C++. Adding void like you did is redundant and unnecessary.

Inline is implicit when a method is defined inside the class body:

All methods that are defined directly inside the class body, in the header file, are implicitly inline. The inline keyword in this case is just visual pollution and to a certain extent nonsensical, since the reader is clearly seeing that the function definition is in-line.

edited Aug 9 '14 at 14:13

answered Aug 9 '14 at 0:59

glampert
11.3k21062

Thank you for your feedback. Regarding trailing return types, I have read at stackoverflow.com/questions/11215227/… that they mean that the return types line up easier so that it is easy to visually parse the header file. – burtonageo Aug 9 '14 at 7:34

OK, so some are actually starting to use the trailing return type for common methods. Who knows, maybe it will become a thing in the future... I personally think it decharacterizes the language when used everywhere. – glampert Aug 9 '14 at 14:08

Moreover, the trailing return type syntax is close to the type theory notation. I also often describe functions in the order "a function that takes x and returns y", almost never in the reverse order. Since there are some times where you can't do without this syntax, always using it helps to be consistent. All these benefits are small, but they add up. – Morwenn Aug 9 '14 at 17:00

add a comment |

Morwenn · Answer 2 · 2014-08-09 17:24:53Z

There are several small things that you can easily improve:

Tell me if I am mistaken, but it seems that the macro PNEU_EXCEPT_TO_METHODRES needs some trailing while (0) if you don't want to add it manually everytime you invoke it.
In MethodResult, you explicitly defaulted the copy constructor and the destructor. You could actually totally get rid of these lines by using the rule of zero: don't write any copy/move constructors/operators, and the compiler will generate them for. Unless you intend to make a non-copyable class or a RAII one, you generally want to use the rule of zero.

If you want to copy a string, don't pass it by const&, but use the copy-then-move idiom instead:

MethodResult(bool ok, std::string desc)
  :
  fOk(ok),
  fDescription(std::move(desc)) { }

The function trailing return type is fine, but if you want to get the readbility benefits, you can put the type name on the following line. That really helps to visually separate the return type and avoids having overly long function declarations. That said, it is most useful when you have long template types.
```
static auto ok()
    -> MethodResult
{
    return MethodResult(true, "");
}
```
Note that I did not chose the best function to prove my point. However, this allows to split long declarations in two lines and still have both the function names and the return types aligned. Example with Window class declaration:
```
auto update()
    -> void;
auto pollEvents()
    -> void;
auto renderFrame()
    -> void;
```
The obvious drawback is of course the fact that the declaration now takes two lines. There is a choice to make, and it is yours.
You can use list initialization in a return statement when you create and return an object and the same line. That will help avoiding to repeat the type:
```
static auto ok()
    -> MethodResult
{
    return { true, "" };
}
```
Two small things concerning your main: don't bother to add argc and argv if you are not going to use them. You don't have to write return 0; at the end of main; if the compiler reaches the end of main without having encountered a return statement, it will automatically add a return 0;.

asked	1 year ago
viewed	163 times
active	1 year ago

current community

your communities

more stack exchange communities

Game framework using C++

2 Answers 2

Your Answer

Not the answer you're looking for? Browse other questions tagged c++ c++11 library error-handling gui or ask your own question.

Hot Network Questions

current community

your communities

more stack exchange communities

Game framework using C++

2 Answers 2

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged c++ c++11 library error-handling gui or ask your own question.

Related

Hot Network Questions