void VideoRendererItem::prepare(QSGGeometryNode *node) {
Q_ASSERT(d->shader);
if (d->take) {
auto image = renderTarget().toImage();
if (!image.isNull())
d->mposd->drawOn(image);
emit frameImageObtained(image);
d->take = false;
}
if (!d->queue.isEmpty()) {
auto &frame = d->queue.front();
if (!frame.format().isEmpty()) {
d->ptsOut = frame.pts();
d->render = true;
d->frameSize = frame.format().size();
if (_Change(d->displaySize, frame.format().displaySize()))
d->updateGeometry(true);
d->shader->upload(frame);
d->direct = d->shader->directRendering();
++d->drawnFrames;
}
d->queue.pop_front();
if (!d->queue.isEmpty()) {
if (d->queue.size() > 3) {
emit droppedFramesChanged(d->dropped += d->queue.size());
d->queue.clear();
} else {
if (d->queue.size() > 1) {
d->queue.pop_front();
emit droppedFramesChanged(++d->dropped);
}
update();
}
}
}
if (d->render && !d->frameSize.isEmpty()) {
if (d->rerender)
d->shader->reupload();
if (d->direct) {
setRenderTarget(d->shader->renderTarget());
} else {
if (!d->fbo || d->fbo->size() != d->frameSize) {
_Renew(d->fbo, d->frameSize, OpenGLCompat::framebufferObjectTextureFormat());
Q_ASSERT(d->fbo->isValid());
}
setRenderTarget(d->fbo->texture());
d->fbo->bind();
d->shader->render(d->kernel);
d->fbo->release();
}
node->markDirty(QSGNode::DirtyMaterial);
}
d->rerender = d->render = false;
LOG_GL_ERROR_Q
}
void Painter::buildFB()
{
auto bbWidth = context().backbuffer().width();
auto fbWidth = bbWidth > 0 ? bbWidth : 800;
auto bbHeight = context().backbuffer().height();
auto fbHeight = bbHeight > 0 ? bbHeight : 450;
m_fb = context().createFramebuffer(fbWidth, fbHeight);
m_fb.addDepthTarget(deliberation::PixelFormat_Depth_32_F);
m_fb.addRenderTarget(deliberation::PixelFormat_RGB_32_F);
m_fb.addRenderTarget(deliberation::PixelFormat_RGBA_32_F);
m_fb.addRenderTarget(deliberation::PixelFormat_RGB_32_F);
m_fb.clear().setColor(1, {0.0f, 0.0f, 0.0f, 1.0f});
m_ao = deliberation::AmbientOcclusion(*m_fb.renderTarget(1),
*m_fb.renderTarget(0),
*m_fb.renderTarget(2),
camera());
auto gridFB = context().createFramebuffer(fbWidth, fbHeight);
gridFB.setDepthTarget(m_fb.depthTarget());
gridFB.setRenderTarget(0, m_fb.renderTarget(0));
m_clusterPainter.setFramebuffer(m_fb);
if (m_penVoxelDrawValid)
{
m_penVoxelDraw.setFramebuffer(m_fb);
}
m_grid.setFramebuffer(gridFB);
}
DemoQPItem::DemoQPItem(QQuickItem *parent)
: QQuickPaintedItem(parent)
, m_animationTime(0.0)
, m_enabledTests(0)
, m_testCount(1)
, m_qpAntialiasing(true)
, m_qpRenderTargetFBO(false)
{
// Setup colors
m_colorWhite = QColor(255,255,255,255);
m_colorGray = QColor(180,180,180,255);
m_colorBlack = QColor(0,0,0,255);
m_color1 = QColor(180,190,40,20);
m_color2 = QColor(255,255,255,150);
m_color3 = QColor(255,255,255,80);
m_circleImage = QImage(":/qml/images/circle.png");
// Load custom font
int id = QFontDatabase::addApplicationFont(":/qml/fonts/Roboto-Regular.ttf");
QStringList s = QFontDatabase::applicationFontFamilies(id);
m_testFont = QFont(s.at(0));
// Set antialiasing and render target
setAntialiasing(m_qpAntialiasing);
setRenderTarget(m_qpRenderTargetFBO ? QQuickPaintedItem::FramebufferObject : QQuickPaintedItem::Image);
// Enable this to try FastFBOResizing
//setPerformanceHint(QQuickPaintedItem::FastFBOResizing, true);
}
QGLView::QGLView(QQuickItem *parent)
: QQuickPaintedItem(parent)
, m_initialized(false)
, m_modelProgram(0)
, m_lineProgram(0)
, m_textProgram(0)
, m_projectionAspectRatio(1.0)
, m_backgroundColor(QColor(Qt::black))
, m_pathEnabled(false)
, m_selectionModeActive(false)
, m_currentGlItem(NULL)
, m_propertySignalMapper(new QSignalMapper(this))
, m_camera(new QGLCamera(this))
, m_light(new QGLLight(this))
{
//setFlag(QQuickItem::ItemHasContents, true);
connect(this, SIGNAL(windowChanged(QQuickWindow*)), this, SLOT(handleWindowChanged(QQuickWindow*)));
// queue this connection to prevent trigger on destruction
connect(this, SIGNAL(childrenChanged()), this, SLOT(updateChildren()), Qt::QueuedConnection);
connect(m_propertySignalMapper, SIGNAL(mapped(QObject*)), this, SLOT(updateItem(QObject*)));
//connect(this, SIGNAL(initialized()), this, SLOT(updateItems()), Qt::QueuedConnection);
setRenderTarget(QQuickPaintedItem::InvertedYFramebufferObject);
setMipmap(true);
//setAntialiasing(true);
}
PlotCanvas::PlotCanvas(QQuickItem *parent)
: QQuickPaintedItem(parent)
, m_scaling(QGuiApplication::primaryScreen()->devicePixelRatio())
{
// m_scaling = QGuiApplication::primaryScreen()->devicePixelRatio();
setRenderTarget(QQuickPaintedItem::InvertedYFramebufferObject);
}
Renderer::Renderer(Context *context, Conventions conventions, bool exactColorRounding) : VertexProcessor(context), PixelProcessor(context), SetupProcessor(context), context(context), viewport()
{
setGlobalRenderingSettings(conventions, exactColorRounding);
setRenderTarget(0, nullptr);
clipper = new Clipper;
blitter = new Blitter;
#if PERF_HUD
resetTimers();
#endif
for(int i = 0; i < 16; i++)
{
vertexTask[i] = nullptr;
worker[i] = nullptr;
resume[i] = nullptr;
suspend[i] = nullptr;
}
threadsAwake = 0;
resumeApp = new Event();
currentDraw = 0;
nextDraw = 0;
qHead = 0;
qSize = 0;
for(int i = 0; i < 16; i++)
{
triangleBatch[i] = nullptr;
primitiveBatch[i] = nullptr;
}
for(int draw = 0; draw < DRAW_COUNT; draw++)
{
drawCall[draw] = new DrawCall();
drawList[draw] = drawCall[draw];
}
for(int unit = 0; unit < 16; unit++)
{
primitiveProgress[unit].init();
}
for(int cluster = 0; cluster < 16; cluster++)
{
pixelProgress[cluster].init();
}
clipFlags = 0;
swiftConfig = new SwiftConfig(disableServer);
updateConfiguration(true);
sync = new Resource(0);
}
//! set or reset special render targets
bool CNullDriver::setRenderTarget(E_RENDER_TARGET target, bool clearTarget,
bool clearZBuffer, SColor color)
{
if (ERT_FRAME_BUFFER==target)
return setRenderTarget(0,clearTarget, clearZBuffer, color);
else
return false;
}
RenderContext2D::RenderContext2D(RenderTarget* target)
{
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
setRenderTarget(target);
setShader (mShader);
PrintGLError();
}
void RenderDevice::setActiveView( RenderView* view )
{
activeView = view;
if( !activeView ) return;
setRenderTarget(view->getRenderTarget());
renderBackend->setupRenderView(view);
}
PlotCanvas::PlotCanvas(QQuickItem *parent)
: QQuickPaintedItem(parent)
, m_scaling(qApp->devicePixelRatio())
, m_updateTriggered(true)
{
// m_scaling = QGuiApplication::primaryScreen()->devicePixelRatio();
setRenderTarget(QQuickPaintedItem::FramebufferObject);
// setRenderTarget(QQuickPaintedItem::Image);
}
void NoRSX::Flip(){
waitFlip();
memcpy(buffers[currentBuffer].ptr, buffer, buffer_size);
flip(context, currentBuffer);
currentBuffer = !currentBuffer;
setRenderTarget(context, &buffers[currentBuffer]);
sysUtilCheckCallback();
return;
}
void NoRSX::RescaleFlip(){
waitFlip();
ResizeBuffer();
flip(context, currentBuffer);
currentBuffer = !currentBuffer;
setRenderTarget(context, &buffers[currentBuffer]);
sysUtilCheckCallback();
return;
}
void FramebufferImpl::addRenderTarget(PixelFormat format, int index)
{
auto texture = m_context.createTexture2D(m_width, m_height, format, true);
if (index < 0)
{
index = m_renderTargets.size();
}
m_renderTargetTextures[index] = texture;
setRenderTarget(index, &texture.surface(0));
}
FrameItem::FrameItem(QQuickItem *parent) :
QQuickPaintedItem(parent),
m_currentFrame(0)
{
m_fpsCount = 0;
m_fpsCounter = 0;
m_fpsCounterTime.start();
setRenderTarget(QQuickPaintedItem::FramebufferObject);
}
void Render(ID3D11Device* device,
ID3D11DeviceContext* context,
common_tool::functionType<std::function<void(ID3D11Device*, ID3D11DeviceContext*)> > renderFunction)
{
setRenderTarget(device, context);
clearRenderTarget(device, context);
SHADERS.bindPair("ProjectionTex", device, context);
SHADERS.DisableShaderBind();
renderFunction(device, context);
SHADERS.EnableShaderBind();
}
int main() {
sysUtilRegisterCallback(SYSUTIL_EVENT_SLOT0, sysutil_callback, NULL);
void *host_addr = memalign(1024*1024, HOST_SIZE);
init_screen(host_addr, HOST_SIZE);
setRenderTarget(curr_fb);
int payload = payload_status();
/*
char dlgmsg[256];
sprintf(dlgmsg, "Payload: %d", payload);
showDialog(dlgmsg);
*/
if(payload == ZERO_PAYLOAD) {
s32 fd = 0;
int bdemu = bdemu_version(&fd);
if(bdemu == 0) {
//Wrong or inexistent file.
lv2buzzer(0x1004, 0xa, 0x1b6);
showDialog("Couldn't find correct \"BDEMU.BIN\".");
}
else {
int fw_version = get_version();
if(fw_version == FW_355_VALUE) {
if(bdemu == 2) {
payload_sky(fd);
}
else {
payload_dean(fd);
}
}
else if(fw_version == FW_341_VALUE && bdemu == 2) {
payload_hermes(fd);
}
else {
lv2buzzer(0x1004, 0xa, 0x1b6);
showDialog("BDEMU.BIN doesn't suppoort your firmware.");
}
}
}
msgDialogAbort();
gcmSetWaitFlip(context);
rsxFinish(context, 1);
//Launch Application on exit.
sysProcessExitSpawn2(APP_LAUNCH, NULL, NULL, NULL, 0, 1001, SYS_PROCESS_SPAWN_STACK_SIZE_1M);
return 0;
}
int CDirectXRenderLayer::setRenderTarget(SURFACE_REF surface, TRect& clipBound)
{
if (setRenderTarget(surface))
{
mD3DViewPort.X = clipBound.mX0;
mD3DViewPort.Y = clipBound.mY0;
mD3DViewPort.Width = clipBound.mX1;
mD3DViewPort.Height = clipBound.mY1;
return SUCCEEDED(mD3DDevice->SetViewport(&mD3DViewPort));
}
return E_FAILED;
}
int main(int argc,const char *argv[])
{
s32 ret,i;
padInfo padinfo;
padData paddata;
rsxProgramConst *consts = rsxFragmentProgramGetConsts(fpo);
initialize();
ioPadInit(7);
sphere = createSphere(3.0f,32,32);
donut = createDonut(3.0f,1.5f,32,32);
cube = createCube(5.0f);
rsxConstOffsetTable *co_table = rsxFragmentProgramGetConstOffsetTable(fpo,consts[lightColor_id].index);
u32 const_addr = (u32)((u64)fp_buffer + co_table->offset[0]);
setup_shared_buffer(const_addr,(u32)(u64)mem_align(128,128),(u32)(u64)gcmGetLabelAddress(64));
signal_spu_ppu();
signal_spu_rsx();
P = transpose(Matrix4::perspective(DEGTORAD(45.0f),aspect_ratio,1.0f,3000.0f));
setRenderTarget(curr_fb);
rsxFinish(context,0);
ret = atexit(program_exit_callback);
ret = sysUtilRegisterCallback(0,sysutil_exit_callback,NULL);
delete cube;
running = 1;
while(running) {
ret = sysUtilCheckCallback();
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++) {
if(padinfo.status[i]) {
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS) {
return 0;
}
}
}
drawFrame();
flip();
}
return 0;
}
NoRSX::NoRSX() : EventHandler(){
currentBuffer = 0;
buffer_type = screen_type = 0;
host_addr = memalign(1024*1024, HOST_SIZE);
getResolution(&width,&height);
context = initScreen(host_addr, HOST_SIZE,0, width, height);
for(int i=0;i<2;i++)
makeBuffer(&buffers[i],width,height,i);
buffer = makeMemBuffer(width,height,&buffer_size);
flip(context, 0);
setRenderTarget(context, &buffers[currentBuffer]);
RegisterCallBack(EVENT_SLOT0);
}
VlcQmlVideoObject::VlcQmlVideoObject(QQuickItem *parent)
: QQuickPaintedItem(parent),
_geometry(0, 0, 640, 480),
_boundingRect(0, 0, 0, 0),
_frameSize(0, 0),
_graphicsPainter(0),
_paintedOnce(false),
_gotSize(false),
_aspectRatio(Vlc::Original),
_cropRatio(Vlc::Original)
{
setRenderTarget(InvertedYFramebufferObject);
setFlag(ItemHasContents, true);
}
int main(int argc,const char *argv[])
{
s32 ret,i;
padInfo padinfo;
padData paddata;
void *host_addr = memalign(1024*1024,HOST_SIZE);
printf("rsxtest started...\n");
init_screen(host_addr,HOST_SIZE);
ioPadInit(7);
init_shader();
init_texture();
sphere = createSphere(3.0f,32,32);
donut = createDonut(3.0f,1.5f,32,32);
cube = createCube(5.0f);
ret = atexit(program_exit_callback);
ret = sysUtilRegisterCallback(0,sysutil_exit_callback,NULL);
P = transpose(Matrix4::perspective(DEGTORAD(45.0f),aspect_ratio,1.0f,3000.0f));
setTexture();
setDrawEnv();
setRenderTarget(curr_fb);
running = 1;
while(running) {
ret = sysUtilCheckCallback();
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS){
return 0;
}
}
}
drawFrame();
flip();
}
return 0;
}
void flip()
{
if(!first_fb) waitflip();
else gcmResetFlipStatus();
gcmSetFlip(context,curr_fb);
rsxFlushBuffer(context);
gcmSetWaitFlip(context);
curr_fb ^= 1;
setRenderTarget(curr_fb);
first_fb = 0;
}
void Render(ID3D11Device* device,
ID3D11DeviceContext* context,
common_tool::functionType<std::function<void(ID3D11Device*, ID3D11DeviceContext*)> > renderFunction)
{
horiBuffer->setRenderTarget(device, context);
horiBuffer->clearRenderTarget(device, context);
renderFunction(device, context);
setRenderTarget(device, context);
clearRenderTarget(device, context);
horiBuffer->bindPS(device, context, 0);
SHADERS.bindPair("Hblur", device, context);
GRAPHICS.RenderRectangle(0, 0, WINWIDTH, WINHEIGHT);
}
void FakeTiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& calculator)
{
// Ensure there is always a target render surface available. If none has been
// set (the layer is an orphan for the test), then just set a surface on itself.
bool missingTargetRenderSurface = !renderTarget();
if (missingTargetRenderSurface)
createRenderSurface();
TiledLayerChromium::setTexturePriorities(calculator);
if (missingTargetRenderSurface) {
clearRenderSurface();
setRenderTarget(0);
}
}
void VideoRendererItem::initializeGL() {
TextureRendererItem::initializeGL();
Q_ASSERT(QOpenGLContext::currentContext() != nullptr);
_Renew(d->shader);
d->shader->setDeintMethod(d->deint);
d->shader->setColor(d->color);
d->shader->setEffects(d->effects);
d->shader->setChromaInterpolator(d->chromaUpscaler);
d->shader->setRange(d->range);
d->black.create(OGL::Repeat);
OpenGLTextureBinder<OGL::Target2D> binder(&d->black);
const quint32 p = 0x0;
d->black.initialize(1, 1, OGL::BGRA, &p);
d->initialized = true;
d->direct = false;
setRenderTarget(d->black);
}
QtYARPScope::QtYARPScope(QQuickItem *parent):
QQuickPaintedItem(parent),
i(0),
yarp(yarp::os::YARP_CLOCK_SYSTEM),
loader(nullptr),
plotManager(PlotManager::instance()),
topLevel(nullptr),
bPressed(false),
currentSelectedPlotter(nullptr)
{
setFlag(ItemHasContents, true);
setAcceptedMouseButtons(Qt::AllButtons);
setRenderTarget(QQuickPaintedItem::FramebufferObject);
connect(this, SIGNAL(widthChanged()), this, SLOT(updateCustomPlotSize()) );
connect(this, SIGNAL(heightChanged()), this, SLOT(updateCustomPlotSize()));
}
NoRSX::NoRSX(int id_type) : EventHandler(){
buffer_type = screen_type = id_type;
currentBuffer = 0;
host_addr = memalign(1024*1024, HOST_SIZE);
switch(id_type){
case RESOLUTION_1920x1080: {
width=1920;height=1080;
buffers[0].width=1920;buffers[0].height=1080;
buffers[1].width=1920;buffers[1].height=1080;
} break;
case RESOLUTION_1280x720: {
width=1280;height=720;
buffers[0].width=1280;buffers[0].height=720;
buffers[1].width=1280;buffers[1].height=720;
} break;
case RESOLUTION_720x576: {
width=720;height=576;
buffers[0].width=720;buffers[0].height=576;
buffers[1].width=720;buffers[1].height=576;
} break;
case RESOLUTION_720x480: {
width=720;height=480;
buffers[0].width=720;buffers[0].height=480;
buffers[1].width=720;buffers[1].height=480;
} break;
default:
getResolution(&width,&height);
buffers[0].width=width;buffers[0].height=height;
buffers[1].width=width;buffers[1].height=height;
break;
}
context = initScreen(host_addr, HOST_SIZE, id_type, width, height);
for(int i=0;i<2;i++)
makeBuffer(&buffers[i],width,height,i);
buffer = makeMemBuffer(width,height,&buffer_size);
flip(context, 0);
setRenderTarget(context, &buffers[0]);
RegisterCallBack(EVENT_SLOT0);
}
HexView::HexView()
: showGuidelines_(false),model_(0)
{
setBytesPerRow( 16 );
setRowHeight( 20 );
// setContentLength(0);
setShowAscii(true);
setShowHex(true);
setShowOffsets(true);
setOffsetsWidth(100);
setSpacer(35);
setHexSpacer(25);
setAsciiSpacer(15);
setOffsetLen(6);
setContentLength(273);
recalcHeight();
recalcWidth();
setRenderTarget(QQuickPaintedItem::FramebufferObject);
}
PainterBezier::PainterBezier(QQuickItem *parent)
:QQuickPaintedItem (parent)
,m_p1(QPointF(0.f,0.f))
,m_p2(QPointF(0.f,0.f))
,m_p3(QPointF(0.f,0.f))
,m_p4(QPointF(0.f,0.f))
,m_OutlineColor(Qt::black)
,m_FillColor(QColor(177,189,180))
,m_OutlineWidth(1.f)
,m_FillWidth(3.f)
{
setX(0);
setY(0);
setWidth(1);
setHeight(1);
setFlag(ItemHasContents, true);
//setAntialiasing(true);
setRenderTarget(QQuickPaintedItem::FramebufferObject);
setSmooth(true);
}
ArcStyle::ArcStyle(QQuickItem *parent) :
QQuickPaintedItem(parent),
m_value(0),
m_minValue(0),
m_maxValue(100),
m_stepSize(0.1),
m_readOnly(false),
m_color(QColor(135,206,235)),
m_factor(57.6),
m_scale(16 / m_factor),
m_startAngle(-1680),
m_spanAngle(480),
m_offset((1440) + ( m_spanAngle / 2 )),
m_anim(NULL)
{
setAntialiasing(true);
#if defined Q_OS_LINUX || defined Q_OS_MAC
setRenderTarget(QQuickPaintedItem::FramebufferObject);
#endif
}
