opengl.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef VIDEO_OPENGL_H
#define VIDEO_OPENGL_H
 
#include "../core/geometry_type.hpp"
#include "../gfx_type.h"
#include "../spriteloader/spriteloader.hpp"
#include "../misc/lrucache.hpp"
 
typedef void (*OGLProc)();
typedef OGLProc (*GetOGLProcAddressProc)(const char *proc);
 
bool IsOpenGLVersionAtLeast(uint8_t major, uint8_t minor);
bool HasStringInExtensionList(std::string_view string, std::string_view substring);
 
class OpenGLSprite;
 
using OpenGLSpriteLRUCache = LRUCache<SpriteID, std::unique_ptr<OpenGLSprite>>;

class OpenGLBackend : public SpriteEncoder {
private:
  static OpenGLBackend *instance; 
 
  bool persistent_mapping_supported = false; 
  GLsync sync_vid_mapping{}; 
  GLsync sync_anim_mapping{}; 
 
  void *vid_buffer = nullptr; 
  GLuint vid_pbo = 0; 
  GLuint vid_texture = 0; 
  GLuint vid_program = 0; 
  GLuint pal_program = 0; 
  GLuint vao_quad = 0; 
  GLuint vbo_quad = 0; 
  GLuint pal_texture = 0; 
 
  void *anim_buffer = nullptr; 
  GLuint anim_pbo = 0; 
  GLuint anim_texture = 0; 
 
  GLuint remap_program = 0; 
  GLint  remap_sprite_loc = 0; 
  GLint  remap_screen_loc = 0; 
  GLint  remap_zoom_loc = 0; 
  GLint  remap_rgb_loc = 0; 
 
  GLuint sprite_program = 0; 
  GLint  sprite_sprite_loc = 0; 
  GLint  sprite_screen_loc = 0; 
  GLint  sprite_zoom_loc = 0; 
  GLint  sprite_rgb_loc = 0; 
  GLint  sprite_crash_loc = 0; 
 
  OpenGLSpriteLRUCache cursor_cache; 
  PaletteID last_sprite_pal = (PaletteID)-1; 
  bool clear_cursor_cache = false; 
 
  Point cursor_pos{}; 
  bool cursor_in_window = false; 
  std::vector<CursorSprite> cursor_sprites{}; 
 
  OpenGLBackend();
  ~OpenGLBackend() override;
 
  std::optional<std::string_view> Init(const Dimension &screen_res);
  bool InitShaders();
 
  void InternalClearCursorCache();
 
  void RenderOglSprite(const OpenGLSprite *gl_sprite, PaletteID pal, int x, int y, ZoomLevel zoom);
 
public:
  static inline OpenGLBackend *Get()
  {
    return OpenGLBackend::instance;
  }
 
  static std::optional<std::string_view> Create(GetOGLProcAddressProc get_proc, const Dimension &screen_res);
  static void Destroy();
 
  void PrepareContext();
 
  std::string GetDriverName();
 
  void UpdatePalette(const Colour *pal, uint first, uint length);
  bool Resize(int w, int h, bool force = false);
  void Paint();
 
  void DrawMouseCursor();
  void PopulateCursorCache();
  void ClearCursorCache();
 
  void *GetVideoBuffer();
  uint8_t *GetAnimBuffer();
  void ReleaseVideoBuffer(const Rect &update_rect);
  void ReleaseAnimBuffer(const Rect &update_rect);
 
  /* SpriteEncoder */
 
  bool Is32BppSupported() override { return true; }
  uint GetSpriteAlignment() override { return 1u << to_underlying(ZoomLevel::Max); }
  Sprite *Encode(SpriteType sprite_type, const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator) override;
};
 

class OpenGLSprite {
private:
  enum Texture : uint8_t {
    TEX_RGBA,    
    TEX_REMAP,   
    NUM_TEX
  };
 
  Dimension dim{};
  std::array<GLuint, NUM_TEX> tex{}; 
  int16_t x_offs = 0;  
  int16_t y_offs = 0;  
 
  static std::array<GLuint, NUM_TEX> dummy_tex; 
 
  static GLuint pal_identity; 
  static GLuint pal_tex;      
  static GLuint pal_pbo;      
 
  static bool Create();
  static void Destroy();
 
  bool BindTextures() const;
 
public:
  OpenGLSprite(SpriteType sprite_type, const SpriteLoader::SpriteCollection &sprite);
 
  /* No support for moving/copying the textures is implemented. */
  OpenGLSprite(const OpenGLSprite&) = delete;
  OpenGLSprite(OpenGLSprite&&) = delete;
  OpenGLSprite& operator=(const OpenGLSprite&) = delete;
  OpenGLSprite& operator=(OpenGLSprite&&) = delete;
  ~OpenGLSprite();
 
  void Update(uint width, uint height, uint level, const SpriteLoader::CommonPixel *data);
  Dimension GetSize(ZoomLevel level) const;
 
  friend class OpenGLBackend;
};
 
#endif /* VIDEO_OPENGL_H */