Bridge.cpp

#include "Bridge.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "Scene.h"
#include "MemoryContext.h"
#include "Engine.h"
#include "EntityStore.h"
#include "ExtensionRegistry.h"
#include "Renderer/Renderer.h"
 
#include "RenderFunctions.h"
#include "ResourceFunctions.h"
 
#include "Renderer/CustomRenderer/ImguiRenderer.h"
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/Texture.h"
 
#include "Components/Core/SceneComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Systems/Core/DynamicComponentSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Services/Variables.h"
#include "Utilities/Parsing.h"
 
#include "Input/InputManager.h"
#include "Input/InputDeviceType.h"
 
#include "Serialization/AssetReader.h"
#include "Serialization/AssetWriter.h"
#include "Serialization/ModelWriter.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Platform/WindowData.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Logging/RedirectedLogger.h"
 
using namespace Cogs::Core;
 
namespace
{
  const Cogs::Logging::Log          logger = Cogs::Logging::getLogger("Bridge");
  Cogs::Logging::RedirectedLogger*  redirectedLogger = nullptr;
 
  void entityError(const char* method, const EntityId entityId)
  {
    LOG_ERROR(logger, "%s: Invalid entity id %zd.", method, size_t(entityId));
  }
}
 
EntityId getNoInternalIdValue()
{
  return NoEntity;
}
 
void initializeStatic()
{
  Context::initializeStatic();
}
 
void cleanupStatic()
{
  Context::cleanupStatic();
}
 
 
BridgeContext* createContext(const char ** variables, const int count) {
  return new Context(variables, count);
}
 
CogsBool initializeContext(BridgeContext* ctx, BridgeView* defaultView, CogsBool initializeEngine) {
  Context* context = static_cast<Context*>(ctx);
  ViewContext* view = static_cast<ViewContext*>(defaultView);
  context->setDefaultView(view);
 
  if (!context->createDevice()){
    return false;
  }
  if (initializeEngine) {
    // TODO: have an initialization function in Context that calls into the engine instead of the other way around.
    context->engine->checkAndUpdateResources();
  }
  return true;
}
 
CogsBool updateContext(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
 
  context->engine->update();
 
  return context->engine->needsUpdate();
}
 
void destroyContext(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
 
  auto device = context->device;
 
  if (device) {
    //NOTE: Ensure the device is currently enabled while destroying the context. This is necessary due to
    // OpenGL based devices being bound in the current thread, so we want to free graphics resources from
    // the device they were actually made on.
    device->beginFrame();
  }
 
  delete context;
}
 
BridgeView* createView(BridgeContext* ctx, void* windowData) {
  Context* context = static_cast<Context*>(ctx);
  return context->createView(static_cast<Cogs::WindowData*>(windowData));
}
 
void destroyView(BridgeView* bv) {
  ViewContext*  view = static_cast<ViewContext*>(bv);
 
  view->getContext()->deleteView(view);
}
 
CogsBool initializeView(BridgeView* bv, EntityId cameraId) {
  ViewContext* view = static_cast<ViewContext*>(bv);
  return view->initialize(view->getContext()->store->getEntity(cameraId));
}
 
void setViewCamera(BridgeView* bv, EntityId cameraId) {
  ViewContext* view = static_cast<ViewContext*>(bv);
  view->setCamera(view->getContext()->store->getEntity(cameraId));
}
 
EntityId getViewCamera(BridgeView* bv) {
  ViewContext* view = static_cast<ViewContext*>(bv);
  assert(view);
  EntityPtr cameraEntity = view->getCamera();
  return cameraEntity ? cameraEntity->getId() : NoEntity;
}
 
BridgeContext* getViewContext(BridgeView* bv) {
  ViewContext* view = static_cast<ViewContext*>(bv);
  assert(view);
  return view->getContext();
}
 
BridgeView* getDefaultView(BridgeContext* ctx) {
  Context* context = static_cast<Context*>(ctx);
  return context->getDefaultView();
}
 
void * getSharedSurface(BridgeContext * ctx)
{
  return static_cast<Context*>(ctx)->sharedSurface;
}
 
void setupContext(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
 
  context->scene->setup(true);
}
 
void clearContext(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
  context->clear();
}
 
void prependSearchPath(BridgeContext * ctx, const char * path)
{
  addSearchPath(ctx, path);
  auto context = static_cast<Context*>(ctx);
  context->engine->setDirty();
}
 
CogsBool loadScene(BridgeContext * ctx, const char * filename, int flags)
{
  auto context = static_cast<Context*>(ctx);
  CogsBool rv = readAsset(context, filename, static_cast<AssetLoadFlags>(flags));
  context->engine->setDirty();
  return rv;
}
 
CogsBool loadAsset(BridgeContext * ctx, const char * filename, EntityId rootId, int flags)
{
  const AssetLoadFlags loadFlags = static_cast<AssetLoadFlags>(flags);
  if ((loadFlags & AssetLoadFlags::ClearScene) == AssetLoadFlags::ClearScene) {
    LOG_ERROR(logger, "loadAsset: Invalid flag ClearScene - load Ignored");
    return false;
  }
 
  auto context = static_cast<Context*>(ctx);
  CogsBool rv = readAsset(context, filename, loadFlags, rootId == NoEntity ? nullptr : context->store->getEntityPtr(rootId));
  context->engine->setDirty();
  return rv;
}
 
CogsBool loadAssetFromString(BridgeContext * ctx, const char* contents, EntityId rootId, int flags)
{
  const AssetLoadFlags loadFlags = static_cast<AssetLoadFlags>(flags);
  if ((loadFlags & AssetLoadFlags::ClearScene) == AssetLoadFlags::ClearScene) {
    LOG_ERROR(logger, "loadAssetFromString: Invalid flag ClearScene - load Ignored");
    return false;
  }
 
  auto context = static_cast<Context*>(ctx);
 
  CogsBool rv = readAssetFromString(context, contents, loadFlags, rootId == NoEntity ? nullptr : context->store->getEntityPtr(rootId));
  context->engine->setDirty();
  return rv;
}
 
CogsBool writeAsset(BridgeContext * ctx, const char * filename, EntityId rootId, int flags)
{
  auto context = static_cast<Context*>(ctx);
  return writeAsset(context, filename, static_cast<AssetWriteFlags>(flags), rootId == NoEntity ? nullptr : context->store->getEntityPtr(rootId));
}
 
CogsBool writeModel(BridgeContext * ctx, const char * filename, EntityId rootId)
{
  auto context = static_cast<Context*>(ctx);
  return writeModel(context, filename, context->store->getEntityPtr(rootId));
}
 
CogsBool loadPermutations(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context*>(ctx);
  CogsBool rv = context->renderer->getEnginePermutations().load(name);
  context->engine->setDirty();
  return rv;
}
 
EntityId createEntity(BridgeContext * ctx, const char * type)
{
  auto context = static_cast<Context *>(ctx);
 
  auto entity = context->store->createEntity(Cogs::StringView(), type);
  context->engine->setDirty();
  return entity->getId();
}
 
void destroyEntity(BridgeContext * ctx, EntityId id)
{
  auto context = static_cast<Context *>(ctx);
 
  context->store->destroyEntity(id);
 
  context->engine->setDirty();
}
 
uint32_t getEntityStoreRevision(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
  return context->store->getRevision();
}
 
const char * getEntityName(BridgeContext * ctx, EntityId entityId)
{
  auto context = static_cast<Context *>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("getEntityName", entityId);
    return nullptr;
  }
 
  return entity->getName().c_str();
}
 
void setEntityName(BridgeContext * ctx, EntityId entityId, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("setEntityName", entityId);
    return;
  }
 
  if (entity->getName() != name) {
    context->store->renameEntity(entity, name);
    context->engine->setDirty();
  }
}
 
EntityId getEntityParent(BridgeContext * ctx, EntityId entityId)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
 
  if (!entity) {
    entityError("getEntityParent", entityId);
    return NoEntity;
  }
 
  const auto parent = context->store->getEntityParent(entity);
  return parent ? parent->getId() : NoEntity;
}
 
void addChildEntity(BridgeContext * ctx, EntityId parentId, EntityId childId)
{
  auto context = static_cast<Context *>(ctx);
  auto parent = context->store->getEntityPtr(parentId);
  auto child = context->store->getEntity(childId);
  if (parent && child) {
    context->store->addChild(parent, child);
    context->engine->setDirty();
  }
  else {
    if (!parent) entityError("addChildEntity(parentId)", parentId);
    if (!child) entityError("addChildEntity(childId)", childId);
  }
}
 
void removeChildEntity(BridgeContext * ctx, EntityId parentId, EntityId childId)
{
  auto context = static_cast<Context *>(ctx);
  auto parent = context->store->getEntityPtr(parentId);
  auto child = context->store->getEntityPtr(childId);
  if (parent && child) {
    context->store->removeChild(parent, child);
    context->engine->setDirty();
  }
  else {
    if (!parent) entityError("removeChildEntity(parentId)", parentId);
    if (!child) entityError("removeChildEntity(childId)", childId);
  }
}
 
void setEntityParent(BridgeContext* ctx, EntityId parentId, EntityId childId)
{
  auto context = static_cast<Context*>(ctx);
  auto child = context->store->getEntityPtr(childId);
  if (child == nullptr) {
    entityError("setEntityParent(childId)", childId);
  }
  else {
    Entity* newParent = context->store->getEntityPtr(parentId);
    if (newParent == nullptr && parentId != NoEntity) {
      entityError("setEntityParent(parentId)", childId);
    }
    else {
      context->store->setEntityParent(newParent, child);
    }
  }
}
 
void addComponent(BridgeContext * ctx, EntityId entityId, ComponentId componentId)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("addComponent", entityId);
    return;
  }
 
  context->store->addComponent(entity, componentId);
  context->engine->setDirty();
}
 
void removeComponent(BridgeContext * ctx, EntityId entityId, ComponentId componentId)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("removeComponent", entityId);
    return;
  }
 
  context->store->removeComponent(entity, entity->getComponentHandle(componentId));
  context->engine->setDirty();
}
 
int getChildren(BridgeContext * ctx, EntityId entityId, EntityId * ids, int idCount)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("getChildren",  entityId);
    return 0;
  }
 
  auto sceneComponent = entity->getComponent<SceneComponent>();
 
  if (!sceneComponent) {
    return 0;
  }
 
  if (sceneComponent->children.size() > static_cast<size_t>(idCount)) {
    // Notify client about number of clients as a negative.
    // LOG_ERROR(logger, "Too many child instances (%zd) in entity with id: %zd, name: %s", sceneComponent->children.size(), entityId, entity->getName().c_str());
    return -static_cast<int>(sceneComponent->children.size());
  }
 
  int index = 0;
  for (auto & c : sceneComponent->children) {
    ids[index++] = c->getId();
  }
 
  return static_cast<int>(sceneComponent->children.size());
}
 
int getEntitiesWithComponent(BridgeContext * ctx, ComponentId componentId, EntityId * ids, int idCount)
{
  auto context = static_cast<Context*>(ctx);
  std::vector<EntityId> entities;
  context->store->getEntitiesWithComponent(entities, componentId);
  if (static_cast<size_t>(idCount) < entities.size()) {
    return -static_cast<int>(entities.size());
  }
  std::memcpy(ids, entities.data(), sizeof(EntityId)*entities.size());
  return static_cast<int>(entities.size());
}
 
 
int getComponents(BridgeContext * ctx, EntityId entityId, ComponentId * ids)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("getComponents", entityId);
    return 0;
  }
 
  auto & components = entity->getComponents();
 
  if (ids) {
    int index = 0;
    for (auto& c : components) {
      ids[index++] = c.resolve()->getTypeId();
    }
  }
 
  return static_cast<int>(components.size());
}
 
EntityId getEntityId(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
 
  auto entity = context->store->findEntity(name, nullptr);
 
  return entity ? entity->getId() : NoEntity;
}
 
EntityId getEntityFull(BridgeContext * ctx, EntityId rootId, const char* name, const int exactName )
{
  auto context = static_cast<Context*>(ctx);
 
  auto searchFlag = (exactName <= 0 || exactName > (int)Cogs::Core::EntityFind::MaxFlag) ? Cogs::Core::EntityFind::PartialNameMatch : Cogs::Core::EntityFind(exactName);
 
  auto entity = context->store->findEntity(name, (rootId != NoEntity) ? context->store->getEntityPtr(rootId) : nullptr, searchFlag);
 
  return entity? entity->getId() : NoEntity;
}
 
const char * getEntityTemplate(BridgeContext * ctx, EntityId entityId)
{
  auto context = static_cast<Context*>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
 
  if (!entity) return nullptr;
 
  size_t templateId = static_cast<const EntityData *>(entity->getUserData())->templateId;
  const EntityDefinition* definition = context->store->getEntityDefinition(templateId);
 
  if (!definition) return nullptr;
 
  return definition->name.c_str();
}
 
int getNumComponents(BridgeContext* ctx, EntityId entityId)
{
  auto context = static_cast<Context*>(ctx);
  const Cogs::ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
  if (entity) {
    return static_cast<int>(entity->getComponents().size());
  }
  else {
    return -1;
  }
}
 
int getComponentType(BridgeContext* ctx, EntityId entityId, int componentNo)
{
  auto context = static_cast<Context*>(ctx);
  const Cogs::ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
  if (entity) {
    const auto& components = entity->getComponents();
    const size_t index = static_cast<size_t>(componentNo);
    if (index < components.size()) {
      auto compPtr = components[index].resolve();
      if (compPtr) {
        return compPtr->getTypeId();
      }
    }
  }
 
  return NoComponentId;
}
 
void setLoggerLevel(const char* level)
{
  Cogs::Logging::Category category = Cogs::Logging::parseCategoryString(level);
  Cogs::Logging::Consumer::setDefaultMinimumCategory(category);
  Cogs::Logging::updateLoggerCategory(category);
}
 
void setLoggerCallback(LoggerCallback * callback)
{
  if (callback) {
    if (!redirectedLogger) {
      redirectedLogger = new Cogs::Logging::RedirectedLogger();
      redirectedLogger->setLoggerCallback(callback);
    }
  }
  else if (redirectedLogger){
    redirectedLogger->setLoggerCallback(nullptr);
 
    if (!redirectedLogger->getFileLineLoggerCallback()) {
      delete redirectedLogger;
      redirectedLogger = nullptr;
    }
  }
}
 
void setFileLineLoggerCallback(FileLineLoggerCallback * callback)
{
  if (callback) {
    if (!redirectedLogger) {
      redirectedLogger = new Cogs::Logging::RedirectedLogger();
      redirectedLogger->setFileLineLoggerCallback(callback);
    }
  }
  else if (redirectedLogger){
    redirectedLogger->setFileLineLoggerCallback(nullptr);
 
    if (!redirectedLogger->getLoggerCallback()) {
      delete redirectedLogger;
      redirectedLogger = nullptr;
    }
  }
}
 
void setUpdateCallback(BridgeContext * ctx, ::NeedsUpdateCallback* callback, void* data)
{
  auto context = static_cast<Context*>(ctx);
  context->engine->setNeedsUpdateCallback(callback, data);
}
 
CogsBool needsUpdate(BridgeContext * ctx) {
  const Context* context = static_cast<const Context*>(ctx);
  return context->engine->needsUpdate();
}
 
void setVariable(BridgeContext * ctx, const char * name, const char * value)
{
  auto context = static_cast<Context *>(ctx);
  context->variables->set(name, value);
  context->engine->setDirty();
}
 
void setBoolVariable(BridgeContext * ctx, const char * name, CogsBool value)
{
  auto context = static_cast<Context *>(ctx);
  context->variables->set(name, value);
  context->engine->setDirty();
}
 
void setIntVariable(BridgeContext * ctx, const char * name, int value)
{
  auto context = static_cast<Context *>(ctx);
  context->variables->set(name, value);
  context->engine->setDirty();
}
 
void setFloatVariable(BridgeContext * ctx, const char * name, float value)
{
  auto context = static_cast<Context *>(ctx);
  context->variables->set(name, value);
  context->engine->setDirty();
}
 
void setDoubleVariable(BridgeContext * ctx, const char * name, double value)
{
  auto context = static_cast<Context *>(ctx);
  context->variables->set(name, value);
  context->engine->setDirty();
}
 
CogsBool hasVariable(BridgeContext* ctx, const char* name)
{
  auto context = static_cast<Context*>(ctx);
  return context->variables->exist(name);
}
 
char * getVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return const_cast<char *>(context->variables->get(name, nullptr));
}
 
CogsBool getBoolVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return context->variables->get(name, false);
}
 
int getIntVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return context->variables->get(name, 0);
}
 
float getFloatVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return context->variables->get(name, 0.0f);
}
 
double getDoubleVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return context->variables->get(name, 0.0);
}
 
char * getVariableOrDefault(BridgeContext * ctx, const char * name, const char * defaultValue)
{
  Context* context = static_cast<Context *>(ctx);
  return const_cast<char *>(context->variables->get(name, defaultValue));
}
 
CogsBool getBoolVariableOrDefault(BridgeContext * ctx, const char * name, CogsBool defaultValue)
{
  Context* context = static_cast<Context *>(ctx);
  return context->variables->get(name, defaultValue);
}
 
int getIntVariableOrDefault(BridgeContext * ctx, const char * name, int defaultValue)
{
  Context* context = static_cast<Context *>(ctx);
  return context->variables->get(name, defaultValue);
}
 
float getFloatVariableOrDefault(BridgeContext * ctx, const char * name, float defaultValue)
{
  Context* context = static_cast<Context *>(ctx);
  return context->variables->get(name, defaultValue);
}
 
double getDoubleVariableOrDefault(BridgeContext * ctx, const char * name, double defaultValue)
{
  Context* context = static_cast<Context *>(ctx);
  return context->variables->get(name, defaultValue);
}
 
CogsBool eraseVariable(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  context->engine->setDirty();
  return context->variables->erase(name);
}
 
 
const void* loadExtensionModule(const char * name)
{
  return ExtensionRegistry::loadExtensionModule(name);
}
 
CogsBool checkExtension(const char * name)
{
  return ExtensionRegistry::hasExtension(name);
}
 
void* getExtensionSymbol(const char * extension, const char* symbol)
{
  return ExtensionRegistry::getExtensionSymbol(extension, symbol);
}
 
 
const char * getLicenseText(BridgeContext * ctx)
{
  auto context = static_cast<Context *>(ctx);
 
  static std::string text = context->resourceStore->getResourceContentString("Licenses.md");
 
  return text.c_str();
}
 
void setPostSystemsUpdateCallback(BridgeContext* ctx, ::RenderCallback* callback)
{
  static_cast<Context*>(ctx)->callbacks.postSystemsUpdateCallback = reinterpret_cast<Cogs::Core::RenderCallback*>(callback);
}
 
void setPreRenderCallback(BridgeContext* ctx, ::RenderCallback* callback)
{
  static_cast<Context*>(ctx)->callbacks.preRenderCallback = reinterpret_cast<Cogs::Core::RenderCallback*>(callback);
}
 
void setPostRenderCallback(BridgeContext* ctx, ::RenderCallback* callback)
{
  static_cast<Context*>(ctx)->callbacks.postRenderCallback = reinterpret_cast<Cogs::Core::RenderCallback*>(callback);
}
 
void setComponentNotifyCallback(BridgeContext* ctx, ::ComponentNotifyCallback* callback)
{
  Context* context = static_cast<Context*>(ctx);
  if (callback && context->callbacks.componentNotifyCallback) {
    LOG_WARNING(logger, "Replacing non-null componentNotifyCallback, set to null first to remove this message");
  }
  context->callbacks.componentNotifyCallback = callback;
}
 
ComponentNotifyCallback* getComponentNotifyCallback(BridgeContext* ctx)
{
  Context* context = static_cast<Context*>(ctx);
  return context->callbacks.componentNotifyCallback;
}
 
 
void registerDynamicType(BridgeContext * ctx, const char * name, size_t messageMask)
{
  auto context = static_cast<Context *>(ctx);
  context->dynamicComponentSystem->registerType(context, name, messageMask);
}
 
void registerMessageCallback(BridgeContext * ctx, EntityId entityId, ComponentId componentId, void * callback)
{
  auto context = static_cast<Context *>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("registerMessageCallback", entityId);
    return;
  }
 
  auto component = entity->getComponent(componentId);
 
  auto dynamicComponent = (DynamicComponent *)component;
 
  dynamicComponent->messageCallback = callback;
}
 
void registerUserData(BridgeContext * ctx, EntityId entityId, ComponentId componentId, void * userData)
{
  auto context = static_cast<Context *>(ctx);
  auto entity = context->store->getEntityPtr(entityId);
  if (!entity) {
    entityError("registerUserData", entityId);
    return;
  }
 
  auto component = entity->getComponent(componentId);
 
  auto dynamicComponent = (DynamicComponent *)component;
 
  dynamicComponent->userData = userData;
}
 
int getMessageId(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
 
  return static_cast<int>(context->dynamicComponentSystem->getMessageId(name));
}
 
void addInputActionMapping(BridgeContext * ctx, const char * name, const char * device, const char * action)
{
  auto context = static_cast<Context *>(ctx);
 
  context->getDefaultView()->inputManager->addActionMapping(name, device, action);
}
 
 
CogsBool getInputAction(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
 
  return context->getDefaultView()->inputManager->getActionState(name) ? 1 : 0;
}
 
void addInputAxisMapping(BridgeContext * ctx, const char * name, const char * device, const char * axis, float scale)
{
  auto context = static_cast<Context *>(ctx);
 
  context->getDefaultView()->inputManager->addAxisMapping(name, device, axis, scale);
}
 
float getInputAxis(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
 
  return context->getDefaultView()->inputManager->getAxisValue(name);
}
 
void gainedFocus(BridgeView* bv, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->gainedFocus(timestamp_ms);
}
 
void lostFocus(BridgeView* bv, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->lostFocus(timestamp_ms);
}
 
void inputTriggerPointerPress(BridgeView* bv, int pointerType, PointerId pointerId, int button, int x, int y, double timestamp_ms) {
  Cogs::PointerType type = static_cast<Cogs::PointerType>(pointerType);
  Cogs::MouseButton btn = static_cast<Cogs::MouseButton>(button);
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerPointerPress(type, pointerId, btn, {x, y}, timestamp_ms);
 
}
 
void inputTriggerPointerRelease(BridgeView* bv, int pointerType, PointerId pointerId, int button, int x, int y, double timestamp_ms) {
  Cogs::PointerType type = static_cast<Cogs::PointerType>(pointerType);
  Cogs::MouseButton btn = static_cast<Cogs::MouseButton>(button);
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerPointerRelease(type, pointerId, btn, {x, y}, timestamp_ms);
 
}
 
void inputTriggerPointerMove(BridgeView* bv, int pointerType, PointerId pointerId, int x, int y, double timestamp_ms) {
  Cogs::PointerType type = static_cast<Cogs::PointerType>(pointerType);
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerPointerMove(type, pointerId, {x, y}, timestamp_ms);
}
 
void inputTriggerMouseWheel(BridgeView* bv, int deltaValue, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerMouseWheel(deltaValue, timestamp_ms);
}
 
void inputTriggerKeyDown(BridgeView* bv, int key, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerKeyDown(static_cast<Cogs::Key>(key), timestamp_ms);
}
 
void inputTriggerKeyUp(BridgeView* bv, int key, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerKeyUp(static_cast<Cogs::Key>(key), timestamp_ms);
}
 
void inputTriggerKeyChar(BridgeView* bv, const char* ch, double timestamp_ms) {
  ViewContext* viewContext = static_cast<ViewContext*>(bv);
  viewContext->inputManager->triggerKeyChar(ch, timestamp_ms);
}
 
// Input Focus is handled for all views, but passing view for input functions consistency.
CogsBool hasGuiInputFocus(BridgeView* /*bv*/, int inputDeviceTypes)
{
  Cogs::Core::InputDeviceType deviceTypes = static_cast<Cogs::Core::InputDeviceType>(inputDeviceTypes);
  if (deviceTypes == None) {
    LOG_WARNING_ONCE(logger, "hasGuiInputFocus - no devices to check");
  }
  else if ((deviceTypes & InputDeviceType::Keyboard) == InputDeviceType::Keyboard && Cogs::Core::ImguiRenderer::isUsingKeyboard()) {
    return true;
  }
  else if ((deviceTypes & InputDeviceType::Mouse) == InputDeviceType::Mouse && Cogs::Core::ImguiRenderer::isUsingMouse()) {
    return true;
  }
 
  return false;
}
 
void setClipboardCallbacks(GetClipboardTextFn getter, SetClipboardTextFn setter) {
  ImguiRenderer::setClipboardCallbacks(getter, setter);
}