138 lines
4.6 KiB
C++
138 lines
4.6 KiB
C++
///
|
|
/// @file Renderer.h
|
|
///
|
|
/// @brief The header for the Renderer class.
|
|
///
|
|
/// @author
|
|
///
|
|
/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
|
|
///
|
|
/// Website: <http://ultralig.ht>
|
|
///
|
|
/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
|
|
///
|
|
#pragma once
|
|
#include <Ultralight/Defines.h>
|
|
#include <Ultralight/RefPtr.h>
|
|
#include <Ultralight/Session.h>
|
|
#include <Ultralight/View.h>
|
|
|
|
namespace ultralight {
|
|
|
|
///
|
|
/// @brief This singleton manages the lifetime of all Views (@see View) and
|
|
/// coordinates painting, network requests, and event dispatch.
|
|
///
|
|
/// @note You don't have to create this instance directly if you use the
|
|
/// AppCore API. The App class will automatically create a Renderer and
|
|
/// perform all rendering within its run loop. @see App::Create
|
|
///
|
|
class UExport Renderer : public RefCounted {
|
|
public:
|
|
///
|
|
/// Create the Ultralight Renderer directly.
|
|
///
|
|
/// Unlike App::Create(), this does not use any native windows for drawing
|
|
/// and allows you to manage your own runloop and painting. This method is
|
|
/// recommended for those wishing to integrate the library into a game.
|
|
///
|
|
/// You should set up your Platform config, file-system, font loader,
|
|
/// and surface-factories/gpu-drivers before calling this function.
|
|
/// (@see <Ultralight/Platform.h>)
|
|
///
|
|
/// At a minimum, you will need to define a FontLoader ahead of time or this
|
|
/// call will fail. You can use the platform's native FontLoader by calling:
|
|
/// <pre>
|
|
/// /// This function is defined in <AppCore/Platform.h>
|
|
/// Platform::instance().set_font_loader(GetPlatformFontLoader());
|
|
/// </pre>
|
|
///
|
|
/// @note You should only create one Renderer per application lifetime.
|
|
///
|
|
/// @note: You should not call this if you are using App::Create(), it
|
|
/// creates its own renderer and provides default implementations for
|
|
/// various platform handlers automatically.
|
|
///
|
|
/// @return Renderer is ref-counted. This method returns a ref-pointer
|
|
/// to a new instance, you should store it in a RefPtr<> to keep
|
|
/// the instance alive.
|
|
///
|
|
static Ref<Renderer> Create();
|
|
|
|
///
|
|
/// Create a Session to store local data in (such as cookies, local storage,
|
|
/// application cache, indexed db, etc).
|
|
///
|
|
/// @note A default, persistent Session is already created for you. You
|
|
/// only need to call this if you want to create private, in-memory
|
|
/// session or use a separate session for each View.
|
|
///
|
|
/// @param is_persistent Whether or not to store the session on disk.
|
|
/// Persistent sessions will be written to the path
|
|
/// set in Config::cache_path
|
|
///
|
|
/// @param name A unique name for this session, this will be used to
|
|
/// generate a unique disk path for persistent sessions.
|
|
///
|
|
virtual Ref<Session> CreateSession(bool is_persistent, const String& name) = 0;
|
|
|
|
///
|
|
/// Get the default Session. This session is persistent (backed to disk) and
|
|
/// has the name "default".
|
|
///
|
|
virtual Ref<Session> default_session() = 0;
|
|
|
|
///
|
|
/// Create a new View.
|
|
///
|
|
/// @param width The initial width, in pixels.
|
|
///
|
|
/// @param height The initial height, in pixels.
|
|
///
|
|
/// @param transparent Whether or not the view background is transparent.
|
|
///
|
|
/// @param session The session to store local data in. Pass a nullptr to
|
|
/// use the default session.
|
|
///
|
|
/// @return Returns a ref-pointer to a new View instance. You should assign
|
|
/// it to either a Ref<View> (non-nullable) or RefPtr<View>
|
|
/// (nullable).
|
|
///
|
|
virtual Ref<View> CreateView(uint32_t width, uint32_t height,
|
|
bool transparent, RefPtr<Session> session,
|
|
bool force_cpu_renderer = false) = 0;
|
|
|
|
///
|
|
/// Update timers and dispatch internal callbacks. You should call this often
|
|
/// from your main application loop.
|
|
///
|
|
virtual void Update() = 0;
|
|
|
|
///
|
|
/// Render all active views to their respective render-targets/surfaces.
|
|
///
|
|
/// You should call this once per frame (usually in synchrony with the
|
|
/// monitor's refresh rate).
|
|
///
|
|
/// @note Views are only repainted if they actually need painting.
|
|
///
|
|
virtual void Render() = 0;
|
|
|
|
///
|
|
/// Attempt to release as much memory as possible. Don't call this from any
|
|
/// callbacks or driver code.
|
|
///
|
|
virtual void PurgeMemory() = 0;
|
|
|
|
///
|
|
/// Print detailed memory usage statistics to the log.
|
|
/// (@see Platform::set_logger())
|
|
///
|
|
virtual void LogMemoryUsage() = 0;
|
|
|
|
protected:
|
|
virtual ~Renderer();
|
|
};
|
|
|
|
} // namespace ultralight
|