graphics_processor.h

Go to the documentation of this file.

/*
 * This file is part of Anbox Platform SDK
 *
 * Copyright 2021 Canonical Ltd.
 *
 * 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.
 */
 
#ifndef ANBOX_SDK_GRAPHICS_PROCESSOR_H_
#define ANBOX_SDK_GRAPHICS_PROCESSOR_H_
 
#include "anbox-platform-sdk/types.h"
 
typedef void (*AnboxVsyncCallback)(uint64_t time_ns, void* user_data);
 
namespace anbox {
class GraphicsProcessor {
  public:
    GraphicsProcessor() = default;
    virtual ~GraphicsProcessor() = default;
    GraphicsProcessor(const GraphicsProcessor &) = delete;
    GraphicsProcessor& operator=(const GraphicsProcessor &) = delete;
 
    virtual EGLDisplay create_display() { return EGL_NO_DISPLAY; }
 
    virtual int initialize(AnboxGraphicsConfiguration* configuration) {
      (void) configuration;
      return 0;
    };
 
    virtual void begin_frame() { };
 
    virtual void finish_frame() { };
 
    virtual EGLSurface create_offscreen_surface(EGLDisplay display, EGLConfig config, const EGLint* attribs) {
      (void) display;
      (void) config;
      (void) attribs;
      return EGL_NO_SURFACE;
    }
 
    virtual bool destroy_offscreen_surface(EGLDisplay display, EGLSurface surface) {
      (void) display;
      (void) surface;
      return false;
    }
 
    [[deprecated("Use GraphicsProcessor::present(AnboxGraphicsBuffer2* buffer, AnboxCallback* callback) instead")]]
    virtual bool present(AnboxGraphicsBuffer* buffer, AnboxCallback* callback) {
      (void) buffer;
      (void) callback;
      return false;
    }
 
    virtual bool present(AnboxGraphicsBuffer2* buffer, AnboxCallback* callback) {
      (void) buffer;
      (void) callback;
      return false;
    }
 
    virtual bool create_buffer(uint32_t width, uint32_t height, uint32_t format,
                               uint32_t usage, AnboxGraphicsBuffer2** buffer) {
      (void) width;
      (void) height;
      (void) format;
      (void) usage;
      (void) buffer;
      return false;
    }
 
  virtual void set_vsync_callback(const AnboxVsyncCallback& callback,
                                  void* user_data) {
    vsync_callback_ = callback;
    vsync_callback_user_data_ = user_data;
  }
 
 protected:
  void signal_vsync(uint64_t time_ns) {
    if (!vsync_callback_)
      return;
 
    vsync_callback_(time_ns, vsync_callback_user_data_);
  }
 
 private:
  AnboxVsyncCallback vsync_callback_ = nullptr;
  void* vsync_callback_user_data_ = nullptr;
};
} // namespace anbox
 
#endif