void SceneXrender::Window::setPictureFilter(xcb_render_picture_t pic, Scene::ImageFilterType filter)
{
QByteArray filterName;
switch (filter) {
case KWin::Scene::ImageFilterFast:
filterName = QByteArray("fast");
break;
case KWin::Scene::ImageFilterGood:
filterName = QByteArray("good");
break;
}
xcb_render_set_picture_filter(connection(), pic, filterName.length(), filterName.constData(), 0, NULL);
}
static void CreateBuffers(vout_display_t *vd, const vout_display_cfg_t *cfg)
{
const video_format_t *fmt = &vd->source;
vout_display_sys_t *sys = vd->sys;
xcb_connection_t *conn = sys->conn;
xcb_create_pixmap(conn, 32, sys->drawable.crop, sys->root,
fmt->i_visible_width, fmt->i_visible_height);
xcb_create_pixmap(conn, 32, sys->drawable.scale, sys->root,
cfg->display.width, cfg->display.height);
xcb_render_create_picture(conn, sys->picture.crop, sys->drawable.crop,
sys->format.argb, 0, NULL);
xcb_render_create_picture(conn, sys->picture.scale, sys->drawable.scale,
sys->format.argb, 0, NULL);
vout_display_place_t *place = &sys->place;
vout_display_PlacePicture(place, fmt, cfg);
/* Homogeneous coordinates transform from destination(place)
* to source(fmt) */
int32_t ax = place->height; /* multiply x instead of dividing y */
int32_t ay = place->width; /* multiply y instead of dividing x */
int32_t bx = 0;
int32_t by = 0;
switch (fmt->orientation) {
case ORIENT_TOP_LEFT:
case ORIENT_LEFT_TOP:
break;
case ORIENT_TOP_RIGHT:
case ORIENT_RIGHT_TOP:
ax *= -1;
bx -= place->width;
break;
case ORIENT_BOTTOM_LEFT:
case ORIENT_LEFT_BOTTOM:
ay *= -1;
by -= place->height;
break;
case ORIENT_BOTTOM_RIGHT:
case ORIENT_RIGHT_BOTTOM:
ax *= -1;
ay *= -1;
bx -= place->width;
by -= place->height;
break;
}
sys->src_x = bx;
sys->src_y = by;
xcb_render_transform_t transform = {
0, 0, 0,
0, 0, 0,
/* Multiply z by width and height to compensate for x and y above */
0, 0, place->width * place->height,
};
if (ORIENT_IS_SWAP(fmt->orientation)) {
transform.matrix12 = ay * fmt->i_visible_width;
transform.matrix21 = ax * fmt->i_visible_height;
} else {
transform.matrix11 = ax * fmt->i_visible_width;
transform.matrix22 = ay * fmt->i_visible_height;
}
xcb_render_set_picture_transform(conn, sys->picture.crop, transform);
if (likely(sys->filter != NULL))
xcb_render_set_picture_filter(conn, sys->picture.crop,
strlen(sys->filter), sys->filter,
0, NULL);
}
void TrackMouseEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
{
effects->paintScreen(mask, region, data); // paint normal screen
if (!m_active)
return;
if ( effects->isOpenGLCompositing() && m_texture[0] && m_texture[1]) {
ShaderBinder binder(ShaderManager::GenericShader);
GLShader *shader(binder.shader());
if (!shader) {
return;
}
QMatrix4x4 modelview;
modelview = shader->getUniformMatrix4x4("modelview");
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
QMatrix4x4 matrix(modelview);
const QPointF p = m_lastRect[0].topLeft() + QPoint(m_lastRect[0].width()/2.0, m_lastRect[0].height()/2.0);
const float x = p.x()*data.xScale() + data.xTranslation();
const float y = p.y()*data.yScale() + data.yTranslation();
for (int i = 0; i < 2; ++i) {
matrix.translate(x, y, 0.0);
matrix.rotate(i ? -2*m_angle : m_angle, 0, 0, 1.0);
matrix.translate(-x, -y, 0.0);
shader->setUniform(GLShader::ModelViewMatrix, matrix);
shader->setUniform(GLShader::Saturation, 1.0);
shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
m_texture[i]->bind();
m_texture[i]->render(region, m_lastRect[i]);
m_texture[i]->unbind();
}
glDisable(GL_BLEND);
shader->setUniform(GLShader::ModelViewMatrix, modelview);
}
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
if ( effects->compositingType() == XRenderCompositing && m_picture[0] && m_picture[1]) {
float sine = sin(m_angle);
const float cosine = cos(m_angle);
for (int i = 0; i < 2; ++i) {
if (i) sine = -sine;
const float dx = m_size[i].width()/2.0;
const float dy = m_size[i].height()/2.0;
const xcb_render_picture_t picture = *m_picture[i];
#define DOUBLE_TO_FIXED(d) ((xcb_render_fixed_t) ((d) * 65536))
xcb_render_transform_t xform = {
DOUBLE_TO_FIXED( cosine ), DOUBLE_TO_FIXED( -sine ), DOUBLE_TO_FIXED( dx - cosine*dx + sine*dy ),
DOUBLE_TO_FIXED( sine ), DOUBLE_TO_FIXED( cosine ), DOUBLE_TO_FIXED( dy - sine*dx - cosine*dy ),
DOUBLE_TO_FIXED( 0.0 ), DOUBLE_TO_FIXED( 0.0 ), DOUBLE_TO_FIXED( 1.0 )
};
#undef DOUBLE_TO_FIXED
xcb_render_set_picture_transform(xcbConnection(), picture, xform);
xcb_render_set_picture_filter(xcbConnection(), picture, 8, "bilinear", 0, NULL);
const QRect &rect = m_lastRect[i];
xcb_render_composite(xcbConnection(), XCB_RENDER_PICT_OP_OVER, picture, XCB_RENDER_PICTURE_NONE,
effects->xrenderBufferPicture(), 0, 0, 0, 0,
qRound((rect.x()+rect.width()/2.0)*data.xScale() - rect.width()/2.0 + data.xTranslation()),
qRound((rect.y()+rect.height()/2.0)*data.yScale() - rect.height()/2.0 + data.yTranslation()),
rect.width(), rect.height());
}
}
#endif
if (effects->compositingType() == QPainterCompositing && !m_image[0].isNull() && !m_image[1].isNull()) {
QPainter *painter = effects->scenePainter();
const QPointF p = m_lastRect[0].topLeft() + QPoint(m_lastRect[0].width()/2.0, m_lastRect[0].height()/2.0);
for (int i = 0; i < 2; ++i) {
painter->save();
painter->translate(p.x(), p.y());
painter->rotate(i ? -2*m_angle : m_angle);
painter->translate(-p.x(), -p.y());
painter->drawImage(m_lastRect[i], m_image[i]);
painter->restore();
}
}
}
