RenderFunctions.cpp

#include "RenderFunctions.h"
 
#include "Context.h"
#include "DebugFunctions.h"
#include "Engine.h"
#include "ViewContext.h"
 
#include "Services/DPIService.h"
#include "Services/Time.h"
 
#include "Renderer/IRenderer.h"
 
#include "Systems/Core/CameraSystem.h"
 
#include "Components/Core/CameraComponent.h"
 
#include "Foundation/Platform/Mouse.h"
 
using namespace Cogs::Core;
 
CogsBool render(BridgeContext* ctx) {
  Cogs::Core::Context* context = static_cast<Cogs::Core::Context *>(ctx);
 
  CHECKED(context, context->engine->update());
  return context->engine->needsUpdate();
}
 
void resize(BridgeContext* ctx, int x, int y) {
  Cogs::Core::ViewContext* view = static_cast<Cogs::Core::Context*>(ctx)->getDefaultView();
 
  if (view) {
    resizeView(view, x, y);
  }
}
 
void resizeView(BridgeView* bv, int x, int y) {
  // rendering will fail to resume unless we now enforce minimum render target size which is checked in Engine.cpp
  static_cast<Cogs::Core::ViewContext*>(bv)->setSize(std::max(x, 2), std::max(y, 2));
}
 
void setDPI(BridgeContext* ctx, int dpi, float scaleFactor) {
  Cogs::Core::ViewContext* view = static_cast<Cogs::Core::Context*>(ctx)->getDefaultView();
 
  if (view) {
    setViewDPI(view, dpi, scaleFactor);
  }
}
 
void setViewDPI(BridgeView* bv, int dpi, float scaleFactor) {
  static_cast<Cogs::Core::ViewContext*>(bv)->setDPI(dpi, scaleFactor);
}
 
void setRenderMode(BridgeContext * ctx, int mode)
{
  auto context = static_cast<Context *>(ctx);
 
  context->renderer->setMode(static_cast<RenderMode>(mode));
  context->engine->setDirty();
}
 
void setBackgroundColor(BridgeContext * ctx, float * color)
{
  auto context = static_cast<Context *>(ctx);
 
  context->renderer->setBackgroundColor(glm::vec4(color[0], color[1], color[2], color[3]));
  context->engine->setDirty();
}
 
void * renderScreenshot(BridgeContext * ctx, const void * settingsPtr, uint32_t * stride)
{
  auto context = static_cast<Context *>(ctx);
  auto settings = static_cast<const ScreenshotSettings *>(settingsPtr);
 
  auto oldSize = context->renderer->getSize();
 
  resize(ctx, settings->width, settings->height);
 
  context->renderer->beginFrame();
 
  context->time->update();
  context->engine->updateSystems();
  context->engine->preRender();
 
  static std::vector<uint8_t> bytes;
  context->renderer->renderScreenshot(*settings, bytes, stride);
 
  context->renderer->endFrame(0, Cogs::PresentFlags::NoSwap);
 
  resize(ctx, static_cast<int>(oldSize.x), static_cast<int>(oldSize.y));
 
  return bytes.data();
}
 
int getEnginePermutationId(BridgeContext * ctx, const char * name)
{
  auto context = static_cast<Context *>(ctx);
  return (int)context->renderer->getEnginePermutations().getIndex(name);
}
 
void setEnginePermutationProperty(BridgeContext * ctx, int id, const char * key, const void * value, int valueSize)
{
  auto context = static_cast<Context *>(ctx);
  context->renderer->getEnginePermutations().get(id)->setProperty(key, value, valueSize);
}