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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef VIDEO_OPENGL_H
#define VIDEO_OPENGL_H
 
#include "../core/alloc_type.hpp"
#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);
const char *FindStringInExtensionList(const char *string, const char *substring);
 
class OpenGLSprite;
 
class OpenGLBackend : public ZeroedMemoryAllocator, SpriteEncoder {
private:
  static OpenGLBackend *instance; 
 
  bool persistent_mapping_supported; 
  GLsync sync_vid_mapping;           
  GLsync sync_anim_mapping;          
 
  void *vid_buffer;   
  GLuint vid_pbo;     
  GLuint vid_texture; 
  GLuint vid_program; 
  GLuint pal_program; 
  GLuint vao_quad;    
  GLuint vbo_quad;    
  GLuint pal_texture; 
 
  void *anim_buffer;   
  GLuint anim_pbo;     
  GLuint anim_texture; 
 
  GLuint remap_program;    
  GLint  remap_sprite_loc; 
  GLint  remap_screen_loc; 
  GLint  remap_zoom_loc;   
  GLint  remap_rgb_loc;    
 
  GLuint sprite_program;    
  GLint  sprite_sprite_loc; 
  GLint  sprite_screen_loc; 
  GLint  sprite_zoom_loc;   
  GLint  sprite_rgb_loc;    
  GLint  sprite_crash_loc;  
 
  LRUCache<SpriteID, Sprite> cursor_cache;   
  PaletteID last_sprite_pal = (PaletteID)-1; 
  bool clear_cursor_cache = false;           
 
  Point cursor_pos;                    
  bool cursor_in_window;               
  std::vector<CursorSprite> cursor_sprites; 
 
  OpenGLBackend();
  ~OpenGLBackend();
 
  std::optional<std::string_view> Init(const Dimension &screen_res);
  bool InitShaders();
 
  void InternalClearCursorCache();
 
  void RenderOglSprite(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 << (ZOOM_LVL_END - 1); }
  Sprite *Encode(const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator) override;
};
 
 
class OpenGLSprite {
private:
  enum Texture {
    TEX_RGBA,    
    TEX_REMAP,   
    NUM_TEX
  };
 
  Dimension dim;
  GLuint tex[NUM_TEX]; 
 
  static GLuint dummy_tex[NUM_TEX]; 
 
  static GLuint pal_identity; 
  static GLuint pal_tex;      
  static GLuint pal_pbo;      
 
  static bool Create();
  static void Destroy();
 
  bool BindTextures();
 
public:
  OpenGLSprite(uint width, uint height, uint levels, SpriteColourComponent components);
  ~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 */