void Image::init(const KConfigGroup &config)
{
m_timer.stop();
if (renderingMode().name().isEmpty()) {
m_mode = "SingleImage";
} else {
m_mode = renderingMode().name();
}
calculateGeometry();
m_delay = config.readEntry("slideTimer", 10);
setResizeMethodHint((ResizeMethod)config.readEntry("wallpaperposition", (int)ScaledResize));
m_wallpaper = config.readEntry("wallpaper", QString());
if (m_wallpaper.isEmpty()) {
useSingleImageDefaults();
}
m_color = config.readEntry("wallpapercolor", QColor(Qt::black));
m_usersWallpapers = config.readEntry("userswallpapers", QStringList());
m_dirs = config.readEntry("slidepaths", QStringList());
if (m_dirs.isEmpty()) {
m_dirs << KStandardDirs::installPath("wallpaper");
}
setUsingRenderingCache(m_mode == "SingleImage");
if (m_mode == "SingleImage") {
setSingleImage();
setContextualActions(QList<QAction*>());
} else {
m_nextWallpaperAction = new QAction(KIcon("user-desktop"), i18n("Next Wallpaper Image"), this);
connect(m_nextWallpaperAction, SIGNAL(triggered(bool)), this, SLOT(nextSlide()));
m_openImageAction = new QAction(KIcon("document-open"), i18n("Open Wallpaper Image"), this);
connect(m_openImageAction, SIGNAL(triggered(bool)), this, SLOT(openSlide()));
QTimer::singleShot(200, this, SLOT(startSlideshow()));
QList<QAction*> actions;
actions.push_back(m_nextWallpaperAction);
actions.push_back(m_openImageAction);
setContextualActions(actions);
updateWallpaperActions();
}
m_animation = new QPropertyAnimation(this, "fadeValue");
m_animation->setProperty("easingCurve", QEasingCurve::InQuad);
m_animation->setProperty("duration", 500);
m_animation->setProperty("startValue", 0.0);
m_animation->setProperty("endValue", 1.0);
}
void Scene_polyhedron_shortest_path_item::draw(Viewer_interface* viewer) const
{
if (supportsRenderingMode(renderingMode()))
{
draw_points(viewer);
}
}
void
Scene_textured_polyhedron_item::
contextual_changed()
{
prev_shading = cur_shading;
cur_shading = renderingMode();
if(prev_shading != cur_shading)
{
invalidate_buffers();
}
}
void FilterEffectRenderer::allocateBackingStoreIfNeeded()
{
// At this point the effect chain has been built, and the
// source image sizes set. We just need to attach the graphic
// buffer if we have not yet done so.
if (!m_graphicsBufferAttached) {
IntSize logicalSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height());
if (!sourceImage() || sourceImage()->logicalSize() != logicalSize)
setSourceImage(ImageBuffer::create(logicalSize, 1, ColorSpaceDeviceRGB, renderingMode()));
m_graphicsBufferAttached = true;
}
}
void
Scene_textured_polyhedron_item::
contextual_changed()
{
GLint new_shading;
qFunc.glGetIntegerv(GL_SHADE_MODEL, &new_shading);
prev_shading = cur_shading;
cur_shading = renderingMode();
if(prev_shading != cur_shading)
{
changed();
}
}
void RawImport::slotAbort()
{
// If preview loading, don't play with threaded filter interface.
if (renderingMode() == EditorToolThreaded::NoneRendering)
{
d->previewWidget->cancelLoading();
d->settingsBox->histogramBox()->histogram()->stopHistogramComputation();
EditorToolIface::editorToolIface()->setToolStopProgress();
setBusy(false);
return;
}
EditorToolThreaded::slotAbort();
}
void FilterEffectRenderer::prepare()
{
// At this point the effect chain has been built, and the
// source image sizes set. We just need to attach the graphic
// buffer if we have not yet done so.
if (!m_graphicsBufferAttached) {
IntSize logicalSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height());
setSourceImage(ImageBuffer::create(logicalSize, 1, ColorSpaceDeviceRGB, renderingMode()));
m_graphicsBufferAttached = true;
}
m_sourceGraphic->clearResult();
for (size_t i = 0; i < m_effects.size(); ++i)
m_effects[i]->clearResult();
}
// Rendering mode as a human readable string
QString Scene_item::renderingModeName() const
{
switch(renderingMode())
{
case Points:
return tr("points");
case Wireframe:
return tr("wire");
case Flat:
return tr("flat");
case FlatPlusEdges:
return tr("flat+edges");
case Gouraud:
return tr("Gouraud");
default:
Q_ASSERT(false);
return tr("unknown");
}
}
// Rendering mode as a human readable string
QString Scene_item::renderingModeName() const
{
return modeName(renderingMode());
}
// Rendering mode as a human readable string
QString CGAL::Three::Scene_item::renderingModeName() const
{
return modeName(renderingMode());
}
void Scene_c3t3_item::draw_edges(CGAL::Three::Viewer_interface* viewer) const {
if(renderingMode() == FlatPlusEdges)
{
GLint renderMode;
glGetIntegerv(GL_RENDER_MODE, &renderMode);
if(renderMode == GL_SELECT) return;
}
Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
if (!are_buffers_filled)
{
ncthis->compute_elements();
ncthis->initialize_buffers(viewer);
}
if(renderingMode() == Wireframe)
{
vaos[Grid]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", QColor(Qt::black));
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = frame->matrix()[i];
program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_grid.size() / 3));
program->release();
vaos[Grid]->release();
}
vaos[Edges]->bind();
program = getShaderProgram(PROGRAM_C3T3_EDGES);
attrib_buffers(viewer, PROGRAM_C3T3_EDGES);
program->bind();
QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
program->setUniformValue("cutplane", cp);
program->setAttributeValue("colors", QColor(Qt::black));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_lines_size / 3));
program->release();
vaos[Edges]->release();
if(!frame->isManipulated()) {
if (!are_intersection_buffers_filled)
{
ncthis->compute_intersections();
ncthis->initialize_intersection_buffers(viewer);
}
vaos[iEdges]->bind();
program = getShaderProgram(PROGRAM_NO_SELECTION);
attrib_buffers(viewer, PROGRAM_NO_SELECTION);
program->bind();
program->setAttributeValue("colors", QColor(Qt::black));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_lines.size() / 3));
program->release();
vaos[iEdges]->release();
}
if(spheres_are_shown)
{
vaos[Wired_spheres]->bind();
program_sphere->bind();
//ModelViewMatrix used for the transformation of the camera.
QMatrix4x4 mvp_mat;
// ModelView Matrix used for the lighting system
QMatrix4x4 mv_mat;
GLdouble d_mat[16];
GLint is_both_sides = 0;
viewer->camera()->getModelViewProjectionMatrix(d_mat);
//Convert the GLdoubles matrices in GLfloats
for (int i=0; i<16; ++i){
mvp_mat.data()[i] = GLfloat(d_mat[i]);
}
viewer->camera()->getModelViewMatrix(d_mat);
for (int i=0; i<16; ++i)
mv_mat.data()[i] = GLfloat(d_mat[i]);
QVector4D position(0.0f,0.0f,1.0f, 1.0f );
QVector4D ambient(0.4f, 0.4f, 0.4f, 0.4f);
// Diffuse
QVector4D diffuse(1.0f, 1.0f, 1.0f, 1.0f);
// Specular
QVector4D specular(0.0f, 0.0f, 0.0f, 1.0f);
viewer->glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE, &is_both_sides);
program_sphere->setUniformValue("mvp_matrix", mvp_mat);
program_sphere->setUniformValue("mv_matrix", mv_mat);
program_sphere->setUniformValue("light_pos", position);
program_sphere->setUniformValue("light_diff",diffuse);
program_sphere->setUniformValue("light_spec", specular);
program_sphere->setUniformValue("light_amb", ambient);
program_sphere->setUniformValue("spec_power", 51.8f);
program_sphere->setUniformValue("is_two_side", is_both_sides);
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(ws_vertex.size()/3),
static_cast<GLsizei>(s_radius.size()));
program_sphere->release();
vaos[Wired_spheres]->release();
}
}
