graphics.hpp

/*
 * Copyright 2019-2022 University of Toronto
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Authors: Mario Badr, Sameh Attia, Tanner Young-Schultz and Vaughn Betz
 */
 
#ifndef EZGL_GRAPHICS_HPP
#define EZGL_GRAPHICS_HPP
 
#include "ezgl/color.hpp"
#include "ezgl/point.hpp"
#include "ezgl/rectangle.hpp"
#include "ezgl/camera.hpp"
 
#include <cairo.h>
#include <gdk/gdk.h>
 
#ifdef CAIRO_HAS_XLIB_SURFACE
#ifdef GDK_WINDOWING_X11
#include <cairo-xlib.h>
 
// Speed up draw calls by using X11 instead of cairo wherever possible. X11 is about twice as fast.
// Cairo is always used if we're using a partially transparent color, so opaque rendering is faster.
#define EZGL_USE_X11
#endif
#endif
 
#include <functional>
#include <string>
#include <vector>
#include <cfloat>
#include <cmath>
#include <algorithm>
 
namespace ezgl {
 
typedef cairo_surface_t surface;
 
enum t_coordinate_system {
  WORLD,
  SCREEN
};
 
enum class justification {
  center,
  left,
  right,
  top,
  bottom
};
 
enum class font_slant : int {
  normal = CAIRO_FONT_SLANT_NORMAL,
 
  italic = CAIRO_FONT_SLANT_ITALIC,
 
  oblique = CAIRO_FONT_SLANT_OBLIQUE
};
 
enum class font_weight : int {
  normal = CAIRO_FONT_WEIGHT_NORMAL,
 
  bold = CAIRO_FONT_WEIGHT_BOLD
};
 
enum class line_cap : int {
  butt = CAIRO_LINE_CAP_BUTT,
 
  round = CAIRO_LINE_CAP_ROUND
};
 
enum class line_dash : int {
  none,
 
  asymmetric_5_3
};
 
class renderer {
public:
  void set_coordinate_system(t_coordinate_system new_coordinate_system);
 
  void set_visible_world(rectangle new_world);
 
  rectangle get_visible_world();
 
  rectangle get_visible_screen();
 
  rectangle world_to_screen(const rectangle& box);
 
  /**** Functions to set graphics attributes (for all subsequent drawing calls). ****/
 
  void set_color(color new_color);
 
  void set_color(color new_color, uint_fast8_t alpha);
 
  void set_color(uint_fast8_t red, uint_fast8_t green, uint_fast8_t blue, uint_fast8_t alpha = 255);
 
  void set_line_cap(line_cap cap);
 
  void set_line_dash(line_dash dash);
 
  void set_line_width(int width);
 
  void set_font_size(double new_size);
 
  void format_font(std::string const &family, font_slant slant, font_weight weight);
 
  void
  format_font(std::string const &family, font_slant slant, font_weight weight, double new_size);
 
  void set_text_rotation(double degrees);
 
  void set_horiz_justification(justification horiz_just);
 
  void set_vert_justification(justification vert_just);
 
  /**** Functions to draw various graphics primitives ****/
 
  void draw_line(point2d start, point2d end);
 
  void draw_rectangle(point2d start, point2d end);
 
  void draw_rectangle(point2d start, double width, double height);
 
  void draw_rectangle(rectangle r);
 
  void fill_rectangle(point2d start, point2d end);
 
  void fill_rectangle(point2d start, double width, double height);
 
  void fill_rectangle(rectangle r);
 
  void fill_poly(std::vector<point2d> const &points);
 
  void draw_elliptic_arc(point2d center,
      double radius_x,
      double radius_y,
      double start_angle,
      double extent_angle);
 
  void draw_arc(point2d center, double radius, double start_angle, double extent_angle);
 
  void fill_elliptic_arc(point2d center,
      double radius_x,
      double radius_y,
      double start_angle,
      double extent_angle);
 
  void fill_arc(point2d center, double radius, double start_angle, double extent_angle);
 
  void draw_text(point2d point, std::string const &text);
 
  void draw_text(point2d point, std::string const &text, double bound_x, double bound_y);
 
  void draw_surface(surface *p_surface, point2d anchor_point, double scale_factor = 1);
 
  static surface *load_png(const char *file_path);
 
  static void free_surface(surface *surface);
 
  ~renderer();
 
protected:
  // Only the canvas class can create a renderer.
  friend class canvas;
 
  using transform_fn = std::function<point2d(point2d)>;
 
  renderer(cairo_t *cairo, transform_fn transform, camera *m_camera, cairo_surface_t *m_surface);
 
  void update_renderer(cairo_t *cairo, cairo_surface_t *m_surface);
 
private:
  void draw_rectangle_path(point2d start, point2d end, bool fill_flag);
 
  void draw_arc_path(point2d center,
      double radius,
      double start_angle,
      double extent_angle,
      double stretch_factor,
      bool fill_flag);
 
  // Pre-clipping function
  bool rectangle_off_screen(rectangle rect);
 
  // Current coordinate system (World is the default)
  t_coordinate_system current_coordinate_system = WORLD;
 
  // A non-owning pointer to a cairo graphics context.
  cairo_t *m_cairo;
 
#ifdef EZGL_USE_X11
  // The x11 drawable
  Drawable x11_drawable;
 
  // The x11 display
  Display *x11_display = nullptr;
 
  // The x11 context
  GC x11_context;
 
  // Transparency flag, if set, cairo will be used
  bool transparency_flag = false;
#endif
 
  transform_fn m_transform;
 
  //A non-owning pointer to camera object
  camera *m_camera;
 
  // Drawing attributes declared and given reasonable defaults below.
 
  // the rotation angle variable used in rotating text
  double rotation_angle = 0;
 
  // Current horizontal justification (used for text and surfaces)
  justification horiz_justification = justification::center;
 
  // Current vertical justification (used for text and surfaces)
  justification vert_justification = justification::center;
 
  // Current line width
  int current_line_width = 0;
 
  // Current line cap
  line_cap current_line_cap = line_cap::butt;
 
  // Current line dash
  line_dash current_line_dash = line_dash::none;
 
  // Current color
  color current_color = {0, 0, 0, 255};
};
}
 
#endif //EZGL_GRAPHICS_HPP