void Context::bindDrawFramebuffer(GLuint framebuffer)
{
if (!getFramebuffer(framebuffer))
{
mFramebufferMap[framebuffer] = new Framebuffer(mCaps, mRenderer, framebuffer);
}
mState.setDrawFramebufferBinding(getFramebuffer(framebuffer));
}
int CrFbDisplayWindow::winVisibilityChanged()
{
HCR_FRAMEBUFFER hFb = getFramebuffer();
if (!hFb || !CrFbIsEnabled(hFb))
{
Assert(!mpWindow || !mpWindow->IsVisivle());
return VINF_SUCCESS;
}
int rc = VINF_SUCCESS;
if (mpWindow)
{
rc = mpWindow->UpdateBegin();
if (RT_SUCCESS(rc))
{
rc = mpWindow->SetVisible(!g_CrPresenter.fWindowsForceHidden);
if (!RT_SUCCESS(rc))
WARN(("SetVisible failed, rc %d", rc));
mpWindow->UpdateEnd();
}
else
WARN(("UpdateBegin failed, rc %d", rc));
}
return rc;
}
int CrFbDisplayWindow::fbSync()
{
int rc = CrFbDisplayBase::fbSync();
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
HCR_FRAMEBUFFER hFb = getFramebuffer();
mu32Screen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
rc = windowSync();
if (!RT_SUCCESS(rc))
{
WARN(("windowSync failed %d", rc));
return rc;
}
if (CrFbHas3DData(hFb))
{
if (mpWindow && mpWindow->GetParentId())
{
rc = mpWindow->Create();
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
}
}
return VINF_SUCCESS;
}
// threadId of ALL_THREADS means run all threads. Otherwise, run just the
// indicated thread.
static void runUntilInterrupt(Core *core, uint32_t threadId, bool enableFbWindow)
{
fd_set readFds;
int result;
struct timeval timeout;
FD_ZERO(&readFds);
while (1)
{
if (!executeInstructions(core, threadId, gScreenRefreshRate))
break;
if (enableFbWindow)
{
updateFramebuffer(getFramebuffer(core));
pollEvent();
}
FD_SET(gClientSocket, &readFds);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
result = select(gClientSocket + 1, &readFds, NULL, NULL, &timeout);
if ((result < 0 && errno != EINTR) || result == 1)
break;
}
}
bool CrFbDisplayWindow::isVisible()
{
HCR_FRAMEBUFFER hFb = getFramebuffer();
if (!hFb)
return false;
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(hFb);
return !CrVrScrCompositorIsEmpty(pCompositor);
}
void CrFbDisplayBase::onUpdateEnd()
{
if (mFlags.fRegionsShanged)
{
mFlags.fRegionsShanged = 0;
if (getFramebuffer()) /*<-dont't do anything on cleanup*/
ueRegions();
}
}
void Snow::drawFramebuffer() {
for (int r=0; r<ROWS; ++r) {
byte row = framebuffer[r];
for (int c=0; c<COLS; ++c) {
lc.setLed(0,r,c,getFramebuffer(r,c));
}
}
}
int CrFbDisplayWindow::windowSetCompositor(bool fSet)
{
if (!mpWindow)
return VINF_SUCCESS;
if (fSet)
{
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(getFramebuffer());
return mpWindow->SetCompositor(pCompositor);
}
return mpWindow->SetCompositor(NULL);
}
void CrFbDisplayWindowRootVr::rootVrTranslateForPos()
{
const RTRECT *pRect = getViewportRect();
const struct VBVAINFOSCREEN* pScreen = CrFbGetScreenInfo(getFramebuffer());
int32_t x = pScreen->i32OriginX;
int32_t y = pScreen->i32OriginY;
int32_t dx = cr_server.RootVrCurPoint.x - x;
int32_t dy = cr_server.RootVrCurPoint.y - y;
cr_server.RootVrCurPoint.x = x;
cr_server.RootVrCurPoint.y = y;
VBoxVrListTranslate(&cr_server.RootVr, dx, dy);
}
int CrFbDisplayWindowRootVr::synchCompositorRegions()
{
int rc;
rootVrTranslateForPos();
/* ensure the rootvr compositor does not hold any data,
* i.e. cleanup all rootvr entries data */
CrVrScrCompositorClear(&mCompositor);
rc = CrVrScrCompositorIntersectedList(CrFbGetCompositor(getFramebuffer()), &cr_server.RootVr, &mCompositor, rootVrGetCEntry, this, NULL);
if (!RT_SUCCESS(rc))
{
WARN(("CrVrScrCompositorIntersectedList failed, rc %d", rc));
return rc;
}
return getWindow()->SetVisibleRegionsChanged();
}
void UniformResamplingRecursiveMISBPTRenderer::processTile(uint32_t threadID, uint32_t tileID, const Vec4u& viewport) const {
auto spp = getSppCount();
TileProcessingRenderer::processTilePixels(viewport, [&](uint32_t x, uint32_t y) {
auto pixelID = getPixelIndex(x, y);
// Add a new sample to the pixel
for(auto i = 0u; i <= getFramebuffer().getChannelCount(); ++i) {
accumulate(i, pixelID, Vec4f(0, 0, 0, 1));
}
// Process each sample
for(auto sampleID = 0u; sampleID < spp; ++sampleID) {
processSample(threadID, tileID, pixelID, sampleID, x, y);
}
});
// Compute contributions for 1-length eye paths (connection to sensor)
connectLightVerticesToSensor(threadID, tileID, viewport);
}
void Application::paintGL() {
// Some plugins process message events, allowing paintGL to be called reentrantly.
if (_aboutToQuit || _window->isMinimized()) {
return;
}
_renderFrameCount++;
_lastTimeRendered.start();
auto lastPaintBegin = usecTimestampNow();
PROFILE_RANGE_EX(render, __FUNCTION__, 0xff0000ff, (uint64_t)_renderFrameCount);
PerformanceTimer perfTimer("paintGL");
if (nullptr == _displayPlugin) {
return;
}
DisplayPluginPointer displayPlugin;
{
PROFILE_RANGE(render, "/getActiveDisplayPlugin");
displayPlugin = getActiveDisplayPlugin();
}
{
PROFILE_RANGE(render, "/pluginBeginFrameRender");
// If a display plugin loses it's underlying support, it
// needs to be able to signal us to not use it
if (!displayPlugin->beginFrameRender(_renderFrameCount)) {
QMetaObject::invokeMethod(this, "updateDisplayMode");
return;
}
}
RenderArgs renderArgs;
glm::mat4 HMDSensorPose;
glm::mat4 eyeToWorld;
glm::mat4 sensorToWorld;
bool isStereo;
glm::mat4 stereoEyeOffsets[2];
glm::mat4 stereoEyeProjections[2];
{
QMutexLocker viewLocker(&_renderArgsMutex);
renderArgs = _appRenderArgs._renderArgs;
// don't render if there is no context.
if (!_appRenderArgs._renderArgs._context) {
return;
}
HMDSensorPose = _appRenderArgs._headPose;
eyeToWorld = _appRenderArgs._eyeToWorld;
sensorToWorld = _appRenderArgs._sensorToWorld;
isStereo = _appRenderArgs._isStereo;
for_each_eye([&](Eye eye) {
stereoEyeOffsets[eye] = _appRenderArgs._eyeOffsets[eye];
stereoEyeProjections[eye] = _appRenderArgs._eyeProjections[eye];
});
}
{
PROFILE_RANGE(render, "/gpuContextReset");
_gpuContext->beginFrame(HMDSensorPose);
// Reset the gpu::Context Stages
// Back to the default framebuffer;
gpu::doInBatch(_gpuContext, [&](gpu::Batch& batch) {
batch.resetStages();
});
}
{
PROFILE_RANGE(render, "/renderOverlay");
PerformanceTimer perfTimer("renderOverlay");
// NOTE: There is no batch associated with this renderArgs
// the ApplicationOverlay class assumes it's viewport is setup to be the device size
renderArgs._viewport = glm::ivec4(0, 0, getDeviceSize());
_applicationOverlay.renderOverlay(&renderArgs);
}
{
PROFILE_RANGE(render, "/updateCompositor");
getApplicationCompositor().setFrameInfo(_renderFrameCount, eyeToWorld, sensorToWorld);
}
gpu::FramebufferPointer finalFramebuffer;
QSize finalFramebufferSize;
{
PROFILE_RANGE(render, "/getOutputFramebuffer");
// Primary rendering pass
auto framebufferCache = DependencyManager::get<FramebufferCache>();
finalFramebufferSize = framebufferCache->getFrameBufferSize();
// Final framebuffer that will be handled to the display-plugin
finalFramebuffer = framebufferCache->getFramebuffer();
}
{
if (isStereo) {
renderArgs._context->enableStereo(true);
renderArgs._context->setStereoProjections(stereoEyeProjections);
renderArgs._context->setStereoViews(stereoEyeOffsets);
}
renderArgs._hudOperator = displayPlugin->getHUDOperator();
renderArgs._hudTexture = _applicationOverlay.getOverlayTexture();
renderArgs._blitFramebuffer = finalFramebuffer;
runRenderFrame(&renderArgs);
}
auto frame = _gpuContext->endFrame();
frame->frameIndex = _renderFrameCount;
frame->framebuffer = finalFramebuffer;
frame->framebufferRecycler = [](const gpu::FramebufferPointer& framebuffer) {
DependencyManager::get<FramebufferCache>()->releaseFramebuffer(framebuffer);
};
// deliver final scene rendering commands to the display plugin
{
PROFILE_RANGE(render, "/pluginOutput");
PerformanceTimer perfTimer("pluginOutput");
_renderLoopCounter.increment();
displayPlugin->submitFrame(frame);
}
// Reset the framebuffer and stereo state
renderArgs._blitFramebuffer.reset();
renderArgs._context->enableStereo(false);
{
Stats::getInstance()->setRenderDetails(renderArgs._details);
}
uint64_t lastPaintDuration = usecTimestampNow() - lastPaintBegin;
_frameTimingsScriptingInterface.addValue(lastPaintDuration);
}
int CrFbDisplayWindowRootVr::compositorMarkUpdated()
{
CrVrScrCompositorClear(&mCompositor);
int rc = CrVrScrCompositorRectSet(&mCompositor, CrVrScrCompositorRectGet(CrFbGetCompositor(getFramebuffer())), NULL);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
rc = setRegionsChanged();
if (!RT_SUCCESS(rc))
{
WARN(("screenChanged failed %d", rc));
return rc;
}
return VINF_SUCCESS;
}
int main() {
createWindow(640, 480);
int framecnt = 0;
Image* img = loadTGAImage("cat.tga");
if(img == NULL) {
printf("ERROR: Could not open image file\n");
exit(1);
}
Image* font = loadTGAImage("font.tga");
if(font == NULL) {
printf("ERROR: Could not load font file\n");
exit(1);
}
int mousePos[2] = {0, 0};
while(1) {
KeyEvent ev;
profileBlockStart("eventHandling");
while(pollEvent(&ev)) {
switch(ev.type) {
case KEY_DOWN:
printf("Keycode: %d\n", ev.key);
if(ev.key == 53) {
goto endGame;
}
break;
case MOUSE_MOVE:
mousePos[0] = ev.posx;
mousePos[1] = ev.posy;
break;
}
}
profileBlockEnd("eventHandling");
Image* fb = getFramebuffer();
profileBlockStart("clearFramebuffer");
Color backColor = color(0, 30, 140, 40);
clear(fb, &backColor);
profileBlockEnd("clearFramebuffer");
profileBlockStart("paintCats");
for(int i = 0; i < 300; i++) {
paint(PAINT_OVER, img, fb, (int)(fb->width / 2 + (i * 0.7) * sin(i * 1.221 + framecnt * 0.004)),
(int)(fb->height / 2 + (i * 0.7) * cos(i * 1.221 + framecnt * 0.004)));
}
profileBlockEnd("paintCats");
profileBlockStart("paintText");
Color textColor = color(255, 200, 250, 255);
textColor.a = (framecnt * 32) % 256;
drawText(fb, font, &textColor, "Hello world!", mousePos[0], mousePos[1]);
drawButton(fb, font, "Click here!", 120, 200);
profileBlockEnd("paintText");
profileBlockStart("flush");
flushFramebuffer();
profileBlockEnd("flush");
framecnt++;
}
endGame:
saveProfile("_profile.json");
deleteImage(img);
closeWindow();
}
void GraphicsEngine::render_performFrame() {
// Some plugins process message events, allowing paintGL to be called reentrantly.
_renderFrameCount++;
auto lastPaintBegin = usecTimestampNow();
PROFILE_RANGE_EX(render, __FUNCTION__, 0xff0000ff, (uint64_t)_renderFrameCount);
PerformanceTimer perfTimer("paintGL");
DisplayPluginPointer displayPlugin;
{
PROFILE_RANGE(render, "/getActiveDisplayPlugin");
displayPlugin = qApp->getActiveDisplayPlugin();
}
{
PROFILE_RANGE(render, "/pluginBeginFrameRender");
// If a display plugin loses it's underlying support, it
// needs to be able to signal us to not use it
if (!displayPlugin->beginFrameRender(_renderFrameCount)) {
QMetaObject::invokeMethod(qApp, "updateDisplayMode");
return;
}
}
RenderArgs renderArgs;
glm::mat4 HMDSensorPose;
glm::mat4 eyeToWorld;
glm::mat4 sensorToWorld;
ViewFrustum viewFrustum;
bool isStereo;
glm::mat4 stereoEyeOffsets[2];
glm::mat4 stereoEyeProjections[2];
{
QMutexLocker viewLocker(&_renderArgsMutex);
renderArgs = _appRenderArgs._renderArgs;
// don't render if there is no context.
if (!_appRenderArgs._renderArgs._context) {
return;
}
HMDSensorPose = _appRenderArgs._headPose;
eyeToWorld = _appRenderArgs._eyeToWorld;
sensorToWorld = _appRenderArgs._sensorToWorld;
isStereo = _appRenderArgs._isStereo;
for_each_eye([&](Eye eye) {
stereoEyeOffsets[eye] = _appRenderArgs._eyeOffsets[eye];
stereoEyeProjections[eye] = _appRenderArgs._eyeProjections[eye];
});
viewFrustum = _appRenderArgs._renderArgs.getViewFrustum();
}
{
PROFILE_RANGE(render, "/gpuContextReset");
getGPUContext()->beginFrame(_appRenderArgs._view, HMDSensorPose);
// Reset the gpu::Context Stages
// Back to the default framebuffer;
gpu::doInBatch("Application_render::gpuContextReset", getGPUContext(), [&](gpu::Batch& batch) {
batch.resetStages();
});
if (isStereo) {
renderArgs._context->enableStereo(true);
renderArgs._context->setStereoProjections(stereoEyeProjections);
renderArgs._context->setStereoViews(stereoEyeOffsets);
}
}
gpu::FramebufferPointer finalFramebuffer;
QSize finalFramebufferSize;
{
PROFILE_RANGE(render, "/getOutputFramebuffer");
// Primary rendering pass
auto framebufferCache = DependencyManager::get<FramebufferCache>();
finalFramebufferSize = framebufferCache->getFrameBufferSize();
// Final framebuffer that will be handed to the display-plugin
finalFramebuffer = framebufferCache->getFramebuffer();
}
if (!_programsCompiled.load()) {
gpu::doInBatch("splashFrame", _gpuContext, [&](gpu::Batch& batch) {
batch.setFramebuffer(finalFramebuffer);
batch.enableSkybox(true);
batch.enableStereo(isStereo);
batch.setViewportTransform({ 0, 0, finalFramebuffer->getSize() });
_splashScreen->render(batch, viewFrustum);
});
} else {
{
PROFILE_RANGE(render, "/renderOverlay");
PerformanceTimer perfTimer("renderOverlay");
// NOTE: There is no batch associated with this renderArgs
// the ApplicationOverlay class assumes it's viewport is setup to be the device size
renderArgs._viewport = glm::ivec4(0, 0, qApp->getDeviceSize());
qApp->getApplicationOverlay().renderOverlay(&renderArgs);
}
{
PROFILE_RANGE(render, "/updateCompositor");
qApp->getApplicationCompositor().setFrameInfo(_renderFrameCount, eyeToWorld, sensorToWorld);
}
{
PROFILE_RANGE(render, "/runRenderFrame");
renderArgs._hudOperator = displayPlugin->getHUDOperator();
renderArgs._hudTexture = qApp->getApplicationOverlay().getOverlayTexture();
renderArgs._blitFramebuffer = finalFramebuffer;
render_runRenderFrame(&renderArgs);
}
}
auto frame = getGPUContext()->endFrame();
frame->frameIndex = _renderFrameCount;
frame->framebuffer = finalFramebuffer;
frame->framebufferRecycler = [](const gpu::FramebufferPointer& framebuffer) {
auto frameBufferCache = DependencyManager::get<FramebufferCache>();
if (frameBufferCache) {
frameBufferCache->releaseFramebuffer(framebuffer);
}
};
// deliver final scene rendering commands to the display plugin
{
PROFILE_RANGE(render, "/pluginOutput");
PerformanceTimer perfTimer("pluginOutput");
_renderLoopCounter.increment();
displayPlugin->submitFrame(frame);
}
// Reset the framebuffer and stereo state
renderArgs._blitFramebuffer.reset();
renderArgs._context->enableStereo(false);
#if !defined(DISABLE_QML)
{
auto stats = Stats::getInstance();
if (stats) {
stats->setRenderDetails(renderArgs._details);
}
}
#endif
uint64_t lastPaintDuration = usecTimestampNow() - lastPaintBegin;
_frameTimingsScriptingInterface.addValue(lastPaintDuration);
}
Target* GLframebuffermanager::allocTarget(Target::AllocHint hint, int width, int height, TexFormat texformat) {
GLframebuffer* fb = getFramebuffer(width, height);
return fb->allocTarget(hint, texformat);
}
bool CrFbDisplayWindow::isActive()
{
HCR_FRAMEBUFFER hFb = getFramebuffer();
return hFb && CrFbIsEnabled(hFb);
}
uint32_t getPixelIndex(uint32_t x, uint32_t y) const {
return BnZ::getPixelIndex(x, y, getFramebuffer().getSize());
}
const struct RTRECT* CrFbDisplayWindow::getRect()
{
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(getFramebuffer());
return CrVrScrCompositorRectGet(pCompositor);
}