43b9a99983
Conflicts: examples/animation/animatedtiles/animatedtiles.pro examples/animation/appchooser/appchooser.pro examples/animation/easing/easing.pro examples/animation/easing/window.h examples/animation/moveblocks/moveblocks.pro examples/animation/states/states.pro examples/animation/stickman/stickman.pro examples/dbus/dbus-chat/dbus-chat.pro examples/dbus/dbus.pro examples/dbus/remotecontrolledcar/car/car.pro examples/dbus/remotecontrolledcar/controller/controller.pro examples/dbus/remotecontrolledcar/remotecontrolledcar.pro examples/desktop/desktop.pro examples/desktop/screenshot/screenshot.pro examples/dialogs/classwizard/classwizard.pro examples/dialogs/configdialog/configdialog.pro examples/dialogs/dialogs.pro examples/dialogs/extension/extension.pro examples/dialogs/findfiles/findfiles.pro examples/dialogs/licensewizard/licensewizard.pro examples/dialogs/sipdialog/sipdialog.pro examples/dialogs/standarddialogs/standarddialogs.pro examples/dialogs/tabdialog/tabdialog.pro examples/dialogs/trivialwizard/trivialwizard.pro examples/draganddrop/draggableicons/draggableicons.pro examples/draganddrop/draggabletext/draggabletext.pro examples/draganddrop/dropsite/dropsite.pro examples/draganddrop/fridgemagnets/fridgemagnets.pro examples/draganddrop/puzzle/puzzle.pro examples/effects/blurpicker/blurpicker.pro examples/effects/fademessage/fademessage.pro examples/effects/lighting/lighting.pro examples/examples.pro examples/gestures/imagegestures/imagegestures.pro examples/graphicsview/anchorlayout/anchorlayout.pro examples/graphicsview/basicgraphicslayouts/basicgraphicslayouts.pro examples/graphicsview/collidingmice/collidingmice.pro examples/graphicsview/diagramscene/diagramscene.pro examples/graphicsview/dragdroprobot/dragdroprobot.pro examples/graphicsview/elasticnodes/elasticnodes.pro examples/graphicsview/flowlayout/flowlayout.pro examples/graphicsview/graphicsview.pro examples/graphicsview/simpleanchorlayout/simpleanchorlayout.pro examples/graphicsview/weatheranchorlayout/weatheranchorlayout.pro examples/ipc/ipc.pro examples/ipc/sharedmemory/sharedmemory.pro examples/itemviews/addressbook/addressbook.pro examples/itemviews/basicsortfiltermodel/basicsortfiltermodel.pro examples/itemviews/chart/chart.pro examples/itemviews/coloreditorfactory/coloreditorfactory.pro examples/itemviews/combowidgetmapper/combowidgetmapper.pro examples/itemviews/customsortfiltermodel/customsortfiltermodel.pro examples/itemviews/dirview/dirview.pro examples/itemviews/editabletreemodel/editabletreemodel.pro examples/itemviews/fetchmore/fetchmore.pro examples/itemviews/frozencolumn/frozencolumn.pro examples/itemviews/itemviews.pro examples/itemviews/pixelator/pixelator.pro examples/itemviews/puzzle/puzzle.pro examples/itemviews/simpletreemodel/simpletreemodel.pro examples/itemviews/simplewidgetmapper/simplewidgetmapper.pro examples/itemviews/spinboxdelegate/spinboxdelegate.pro examples/itemviews/stardelegate/stardelegate.pro examples/ja_JP/linguist/hellotr/hellotr.pro examples/layouts/basiclayouts/basiclayouts.pro examples/layouts/borderlayout/borderlayout.pro examples/layouts/dynamiclayouts/dynamiclayouts.pro examples/layouts/flowlayout/flowlayout.pro examples/layouts/layouts.pro examples/linguist/arrowpad/arrowpad.pro examples/linguist/hellotr/hellotr.pro examples/linguist/linguist.pro examples/linguist/trollprint/trollprint.pro examples/mainwindows/application/application.pro examples/mainwindows/dockwidgets/dockwidgets.pro examples/mainwindows/mainwindows.pro examples/mainwindows/mdi/mdi.pro examples/mainwindows/menus/menus.pro examples/mainwindows/recentfiles/recentfiles.pro examples/mainwindows/sdi/sdi.pro examples/network/network.pro examples/opengl/opengl.pro examples/openvg/openvg.pro examples/painting/basicdrawing/basicdrawing.pro examples/painting/concentriccircles/concentriccircles.pro examples/painting/fontsampler/fontsampler.pro examples/painting/imagecomposition/imagecomposition.pro examples/painting/painterpaths/painterpaths.pro examples/painting/painting.pro examples/painting/transformations/transformations.pro examples/qtconcurrent/imagescaling/imagescaling.pro examples/qtconcurrent/map/map.pro examples/qtconcurrent/progressdialog/progressdialog.pro examples/qtconcurrent/qtconcurrent.pro examples/qtconcurrent/runfunction/runfunction.pro examples/qtconcurrent/wordcount/wordcount.pro examples/qtestlib/qtestlib.pro examples/qtestlib/tutorial1/tutorial1.pro examples/qtestlib/tutorial2/tutorial2.pro examples/qtestlib/tutorial3/tutorial3.pro examples/qtestlib/tutorial4/tutorial4.pro examples/qtestlib/tutorial5/tutorial5.pro examples/qws/dbscreen/dbscreen.pro examples/qws/framebuffer/framebuffer.pro examples/qws/mousecalibration/mousecalibration.pro examples/qws/simpledecoration/simpledecoration.pro examples/qws/svgalib/svgalib.pro examples/richtext/calendar/calendar.pro examples/richtext/orderform/orderform.pro examples/richtext/richtext.pro examples/richtext/syntaxhighlighter/syntaxhighlighter.pro examples/sql/sql.pro examples/statemachine/eventtransitions/eventtransitions.pro examples/statemachine/rogue/rogue.pro examples/statemachine/trafficlight/trafficlight.pro examples/statemachine/twowaybutton/twowaybutton.pro examples/threads/mandelbrot/mandelbrot.pro examples/threads/queuedcustomtype/queuedcustomtype.pro examples/threads/threads.pro examples/tools/codecs/codecs.pro examples/tools/completer/completer.pro examples/tools/contiguouscache/contiguouscache.pro examples/tools/customcompleter/customcompleter.pro examples/tools/customtype/customtype.pro examples/tools/customtypesending/customtypesending.pro examples/tools/echoplugin/echoplugin.pro examples/tools/echoplugin/echowindow/echowindow.pro examples/tools/echoplugin/plugin/plugin.pro examples/tools/i18n/i18n.pro examples/tools/inputpanel/inputpanel.pro examples/tools/plugandpaint/plugandpaint.pro examples/tools/plugandpaintplugins/basictools/basictools.pro examples/tools/plugandpaintplugins/extrafilters/extrafilters.pro examples/tools/plugandpaintplugins/plugandpaintplugins.pro examples/tools/regexp/regexp.pro examples/tools/settingseditor/settingseditor.pro examples/tools/styleplugin/plugin/plugin.pro examples/tools/styleplugin/styleplugin.pro examples/tools/styleplugin/stylewindow/stylewindow.pro examples/tools/tools.pro examples/tools/treemodelcompleter/treemodelcompleter.pro examples/tools/undoframework/undoframework.pro examples/touch/dials/dials.pro examples/touch/fingerpaint/fingerpaint.pro examples/touch/knobs/knobs.pro examples/touch/pinchzoom/pinchzoom.pro examples/tutorials/addressbook-fr/addressbook-fr.pro examples/tutorials/addressbook-fr/part1/part1.pro examples/tutorials/addressbook-fr/part2/part2.pro examples/tutorials/addressbook-fr/part3/part3.pro examples/tutorials/addressbook-fr/part4/part4.pro examples/tutorials/addressbook-fr/part5/part5.pro examples/tutorials/addressbook-fr/part6/part6.pro examples/tutorials/addressbook-fr/part7/part7.pro examples/tutorials/addressbook/addressbook.pro examples/tutorials/addressbook/part1/part1.pro examples/tutorials/addressbook/part2/part2.pro examples/tutorials/addressbook/part3/part3.pro examples/tutorials/addressbook/part4/part4.pro examples/tutorials/addressbook/part5/part5.pro examples/tutorials/addressbook/part6/part6.pro examples/tutorials/addressbook/part7/part7.pro examples/tutorials/modelview/1_readonly/1_readonly.pro examples/tutorials/modelview/2_formatting/2_formatting.pro examples/tutorials/modelview/3_changingmodel/3_changingmodel.pro examples/tutorials/modelview/4_headers/4_headers.pro examples/tutorials/modelview/5_edit/5_edit.pro examples/tutorials/modelview/6_treeview/6_treeview.pro examples/tutorials/modelview/7_selections/7_selections.pro examples/tutorials/modelview/modelview.pro examples/tutorials/widgets/childwidget/childwidget.pro examples/tutorials/widgets/nestedlayouts/nestedlayouts.pro examples/tutorials/widgets/toplevel/toplevel.pro examples/tutorials/widgets/windowlayout/windowlayout.pro examples/uitools/multipleinheritance/multipleinheritance.pro examples/uitools/textfinder/textfinder.pro examples/uitools/uitools.pro examples/widgets/analogclock/analogclock.pro examples/widgets/calculator/calculator.pro examples/widgets/calendarwidget/calendarwidget.pro examples/widgets/charactermap/charactermap.pro examples/widgets/codeeditor/codeeditor.pro examples/widgets/digitalclock/digitalclock.pro examples/widgets/groupbox/groupbox.pro examples/widgets/icons/icons.pro examples/widgets/imageviewer/imageviewer.pro examples/widgets/lineedits/lineedits.pro examples/widgets/movie/movie.pro examples/widgets/scribble/scribble.pro examples/widgets/shapedclock/shapedclock.pro examples/widgets/sliders/sliders.pro examples/widgets/softkeys/softkeys.pro examples/widgets/spinboxes/spinboxes.pro examples/widgets/styles/styles.pro examples/widgets/stylesheet/stylesheet.pro examples/widgets/tablet/tablet.pro examples/widgets/tetrix/tetrix.pro examples/widgets/tooltips/tooltips.pro examples/widgets/validators/validators.pro examples/widgets/widgets.pro examples/widgets/windowflags/windowflags.pro examples/xml/xml.pro mkspecs/qws/freebsd-generic-g++/qplatformdefs.h mkspecs/qws/linux-arm-g++/qplatformdefs.h mkspecs/qws/linux-arm-gnueabi-g++/qplatformdefs.h mkspecs/qws/linux-armv6-g++/qplatformdefs.h mkspecs/qws/linux-avr32-g++/qplatformdefs.h mkspecs/qws/linux-cellon-g++/qplatformdefs.h mkspecs/qws/linux-dm7000-g++/qplatformdefs.h mkspecs/qws/linux-dm800-g++/qplatformdefs.h mkspecs/qws/linux-generic-g++-32/qplatformdefs.h mkspecs/qws/linux-generic-g++/qplatformdefs.h mkspecs/qws/linux-ipaq-g++/qplatformdefs.h mkspecs/qws/linux-lsb-g++/qplatformdefs.h mkspecs/qws/linux-mips-g++/qplatformdefs.h mkspecs/qws/linux-nacl-g++/qplatformdefs.h mkspecs/qws/linux-powerpc-g++/qplatformdefs.h mkspecs/qws/linux-sh-g++/qplatformdefs.h mkspecs/qws/linux-sh4al-g++/qplatformdefs.h mkspecs/qws/linux-sharp-g++/qplatformdefs.h mkspecs/qws/linux-x86-g++/qplatformdefs.h mkspecs/qws/linux-x86_64-g++/qplatformdefs.h mkspecs/qws/linux-zylonite-g++/qplatformdefs.h mkspecs/qws/macx-generic-g++/qplatformdefs.h mkspecs/qws/macx-iphonedevice-g++/qplatformdefs.h mkspecs/qws/macx-iphonesimulator-g++/qplatformdefs.h mkspecs/qws/macx-nacl-g++/qplatformdefs.h mkspecs/qws/solaris-generic-g++/qplatformdefs.h src/gui/dialogs/qprintdialog_qws.cpp src/gui/egl/qegl_qws.cpp src/gui/embedded/qcopchannel_qws.cpp src/gui/embedded/qcopchannel_qws.h src/gui/embedded/qdecoration_qws.cpp src/gui/embedded/qdecoration_qws.h src/gui/embedded/qdecorationdefault_qws.cpp src/gui/embedded/qdecorationdefault_qws.h src/gui/embedded/qdecorationfactory_qws.cpp src/gui/embedded/qdecorationfactory_qws.h src/gui/embedded/qdecorationplugin_qws.cpp src/gui/embedded/qdecorationplugin_qws.h src/gui/embedded/qdecorationstyled_qws.cpp src/gui/embedded/qdecorationstyled_qws.h src/gui/embedded/qdecorationwindows_qws.cpp src/gui/embedded/qdecorationwindows_qws.h src/gui/embedded/qdirectpainter_qws.cpp src/gui/embedded/qdirectpainter_qws.h src/gui/embedded/qkbd_defaultmap_qws_p.h src/gui/embedded/qkbd_qws.cpp src/gui/embedded/qkbd_qws.h src/gui/embedded/qkbd_qws_p.h src/gui/embedded/qkbddriverfactory_qws.cpp src/gui/embedded/qkbddriverfactory_qws.h src/gui/embedded/qkbddriverplugin_qws.cpp src/gui/embedded/qkbddriverplugin_qws.h src/gui/embedded/qkbdintegrity_qws.cpp src/gui/embedded/qkbdintegrity_qws.h src/gui/embedded/qkbdlinuxinput_qws.cpp src/gui/embedded/qkbdlinuxinput_qws.h src/gui/embedded/qkbdqnx_qws.cpp src/gui/embedded/qkbdqnx_qws.h src/gui/embedded/qkbdtty_qws.cpp src/gui/embedded/qkbdtty_qws.h src/gui/embedded/qkbdum_qws.cpp src/gui/embedded/qkbdum_qws.h src/gui/embedded/qkbdvfb_qws.cpp src/gui/embedded/qkbdvfb_qws.h src/gui/embedded/qlock.cpp src/gui/embedded/qlock_p.h src/gui/embedded/qmouse_qws.cpp src/gui/embedded/qmouse_qws.h src/gui/embedded/qmousedriverfactory_qws.cpp src/gui/embedded/qmousedriverfactory_qws.h src/gui/embedded/qmousedriverplugin_qws.cpp src/gui/embedded/qmousedriverplugin_qws.h src/gui/embedded/qmouseintegrity_qws.cpp src/gui/embedded/qmouseintegrity_qws.h src/gui/embedded/qmouselinuxinput_qws.cpp src/gui/embedded/qmouselinuxinput_qws.h src/gui/embedded/qmouselinuxtp_qws.cpp src/gui/embedded/qmouselinuxtp_qws.h src/gui/embedded/qmousepc_qws.cpp src/gui/embedded/qmousepc_qws.h src/gui/embedded/qmouseqnx_qws.cpp src/gui/embedded/qmouseqnx_qws.h src/gui/embedded/qmousetslib_qws.cpp src/gui/embedded/qmousetslib_qws.h src/gui/embedded/qmousevfb_qws.cpp src/gui/embedded/qmousevfb_qws.h src/gui/embedded/qscreen_qws.cpp src/gui/embedded/qscreen_qws.h src/gui/embedded/qscreendriverfactory_qws.cpp src/gui/embedded/qscreendriverfactory_qws.h src/gui/embedded/qscreendriverplugin_qws.cpp src/gui/embedded/qscreendriverplugin_qws.h src/gui/embedded/qscreenintegrityfb_qws.cpp src/gui/embedded/qscreenintegrityfb_qws.h src/gui/embedded/qscreenlinuxfb_qws.cpp src/gui/embedded/qscreenlinuxfb_qws.h src/gui/embedded/qscreenmulti_qws.cpp src/gui/embedded/qscreenmulti_qws_p.h src/gui/embedded/qscreenproxy_qws.cpp src/gui/embedded/qscreenproxy_qws.h src/gui/embedded/qscreenqnx_qws.cpp src/gui/embedded/qscreenqnx_qws.h src/gui/embedded/qscreentransformed_qws.cpp src/gui/embedded/qscreentransformed_qws.h src/gui/embedded/qscreenvfb_qws.cpp src/gui/embedded/qscreenvfb_qws.h src/gui/embedded/qsoundqss_qws.cpp src/gui/embedded/qsoundqss_qws.h src/gui/embedded/qtransportauth_qws.cpp src/gui/embedded/qtransportauth_qws.h src/gui/embedded/qtransportauth_qws_p.h src/gui/embedded/qtransportauthdefs_qws.h src/gui/embedded/qunixsocket.cpp src/gui/embedded/qunixsocket_p.h src/gui/embedded/qunixsocketserver.cpp src/gui/embedded/qunixsocketserver_p.h src/gui/embedded/qvfbhdr.h src/gui/embedded/qwindowsystem_p.h src/gui/embedded/qwindowsystem_qws.cpp src/gui/embedded/qwindowsystem_qws.h src/gui/embedded/qwscommand_qws.cpp src/gui/embedded/qwscommand_qws_p.h src/gui/embedded/qwscursor_qws.cpp src/gui/embedded/qwsdisplay_qws.h src/gui/embedded/qwsdisplay_qws_p.h src/gui/embedded/qwsembedwidget.cpp src/gui/embedded/qwsevent_qws.cpp src/gui/embedded/qwsevent_qws.h src/gui/embedded/qwslock.cpp src/gui/embedded/qwslock_p.h src/gui/embedded/qwsmanager_p.h src/gui/embedded/qwsmanager_qws.cpp src/gui/embedded/qwsmanager_qws.h src/gui/embedded/qwsproperty_qws.cpp src/gui/embedded/qwsproperty_qws.h src/gui/embedded/qwsprotocolitem_qws.h src/gui/embedded/qwssharedmemory.cpp src/gui/embedded/qwssharedmemory_p.h src/gui/embedded/qwssignalhandler.cpp src/gui/embedded/qwssignalhandler_p.h src/gui/embedded/qwssocket_qws.cpp src/gui/embedded/qwssocket_qws.h src/gui/embedded/qwsutils_qws.h src/gui/image/qpixmap_qws.cpp src/gui/inputmethod/qwsinputcontext_p.h src/gui/inputmethod/qwsinputcontext_qws.cpp src/gui/kernel/qapplication_qpa.cpp src/gui/kernel/qapplication_qws.cpp src/gui/kernel/qclipboard_qws.cpp src/gui/kernel/qcursor_qws.cpp src/gui/kernel/qdesktopwidget_qws.cpp src/gui/kernel/qeventdispatcher_glib_qws.cpp src/gui/kernel/qeventdispatcher_glib_qws_p.h src/gui/kernel/qeventdispatcher_qws.cpp src/gui/kernel/qeventdispatcher_qws_p.h src/gui/kernel/qplatformintegration_qpa.cpp src/gui/kernel/qplatformwindowformat_qpa.cpp src/gui/kernel/qplatformwindowformat_qpa.h src/gui/kernel/qsessionmanager_qws.cpp src/gui/kernel/qsound_qws.cpp src/gui/kernel/qwidget_qws.cpp src/gui/painting/qcolormap_qws.cpp src/gui/painting/qgraphicssystem.cpp src/gui/painting/qgraphicssystem_mac.cpp src/gui/painting/qgraphicssystem_mac_p.h src/gui/painting/qgraphicssystem_p.h src/gui/painting/qgraphicssystem_qws.cpp src/gui/painting/qgraphicssystem_qws_p.h src/gui/painting/qgraphicssystem_raster.cpp src/gui/painting/qgraphicssystem_raster_p.h src/gui/painting/qgraphicssystem_runtime.cpp src/gui/painting/qgraphicssystem_runtime_p.h src/gui/painting/qgraphicssystemfactory.cpp src/gui/painting/qgraphicssystemfactory_p.h src/gui/painting/qgraphicssystemplugin.cpp src/gui/painting/qgraphicssystemplugin_p.h src/gui/painting/qpaintdevice_x11.cpp src/gui/painting/qprintengine_ps.cpp src/gui/painting/qprintengine_ps_p.h src/gui/painting/qprintengine_qws.cpp src/gui/painting/qprintengine_qws_p.h src/gui/painting/qregion_qws.cpp src/gui/painting/qunifiedtoolbarsurface_mac.cpp src/gui/painting/qunifiedtoolbarsurface_mac_p.h src/gui/painting/qwindowsurface_mac.cpp src/gui/painting/qwindowsurface_qws.cpp src/gui/painting/qwindowsurface_qws_p.h src/gui/painting/qwindowsurface_raster.cpp src/gui/painting/qwindowsurface_raster_p.h src/gui/painting/qwindowsurface_s60.cpp src/gui/painting/qwindowsurface_s60_p.h src/gui/painting/qwindowsurface_x11.cpp src/gui/painting/qwindowsurface_x11_p.h src/gui/painting/qwmatrix.h src/gui/text/qabstractfontengine_qws.cpp src/gui/text/qabstractfontengine_qws.h src/gui/text/qfont_qws.cpp src/gui/text/qfontdatabase_qws.cpp src/gui/text/qfontengine_qws.cpp src/opengl/qgl_qpa.cpp src/opengl/qgl_qws.cpp src/opengl/qglscreen_qws.cpp src/opengl/qglscreen_qws.h src/opengl/qglwindowsurface_qws.cpp src/opengl/qgraphicssystem_gl.cpp src/opengl/qgraphicssystem_gl_p.h src/openvg/qpaintengine_vg.cpp src/openvg/qpaintengine_vg_p.h src/openvg/qpixmapdata_vg.cpp src/openvg/qpixmapdata_vg_p.h src/openvg/qpixmapfilter_vg.cpp src/openvg/qpixmapfilter_vg_p.h src/openvg/qvg.h src/openvg/qvg_p.h src/openvg/qvg_symbian.cpp src/openvg/qvgcompositionhelper_p.h src/openvg/qvgfontglyphcache_p.h src/openvg/qvgimagepool.cpp src/openvg/qvgimagepool_p.h src/openvg/qwindowsurface_vg.cpp src/openvg/qwindowsurface_vg_p.h src/openvg/qwindowsurface_vgegl.cpp src/openvg/qwindowsurface_vgegl_p.h src/plugins/decorations/default/main.cpp src/plugins/decorations/styled/main.cpp src/plugins/decorations/windows/main.cpp src/plugins/gfxdrivers/ahi/qscreenahi_qws.cpp src/plugins/gfxdrivers/ahi/qscreenahi_qws.h src/plugins/gfxdrivers/ahi/qscreenahiplugin.cpp src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.h src/plugins/gfxdrivers/directfb/qdirectfbmouse.cpp src/plugins/gfxdrivers/directfb/qdirectfbmouse.h src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp src/plugins/gfxdrivers/directfb/qdirectfbscreen.h src/plugins/gfxdrivers/directfb/qdirectfbscreenplugin.cpp src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h src/plugins/gfxdrivers/eglnullws/eglnullwsscreen.cpp src/plugins/gfxdrivers/eglnullws/eglnullwsscreen.h src/plugins/gfxdrivers/eglnullws/eglnullwsscreenplugin.cpp src/plugins/gfxdrivers/eglnullws/eglnullwsscreenplugin.h src/plugins/gfxdrivers/eglnullws/eglnullwswindowsurface.cpp src/plugins/gfxdrivers/eglnullws/eglnullwswindowsurface.h src/plugins/gfxdrivers/linuxfb/main.cpp src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.h src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.cpp src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.h src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreenplugin.cpp src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglwindowsurface.cpp src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglwindowsurface.h src/plugins/gfxdrivers/qvfb/main.cpp src/plugins/gfxdrivers/transformed/main.cpp src/plugins/gfxdrivers/vnc/main.cpp src/plugins/gfxdrivers/vnc/qscreenvnc_p.h src/plugins/gfxdrivers/vnc/qscreenvnc_qws.cpp src/plugins/gfxdrivers/vnc/qscreenvnc_qws.h src/plugins/graphicssystems/meego/dithering.cpp src/plugins/graphicssystems/meego/qmeegoextensions.cpp src/plugins/graphicssystems/meego/qmeegoextensions.h src/plugins/graphicssystems/meego/qmeegographicssystem.cpp src/plugins/graphicssystems/meego/qmeegographicssystem.h src/plugins/graphicssystems/meego/qmeegographicssystemplugin.cpp src/plugins/graphicssystems/meego/qmeegographicssystemplugin.h src/plugins/graphicssystems/meego/qmeegolivepixmapdata.cpp src/plugins/graphicssystems/meego/qmeegolivepixmapdata.h src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp src/plugins/graphicssystems/meego/qmeegopixmapdata.h src/plugins/graphicssystems/meego/qmeegorasterpixmapdata.cpp src/plugins/graphicssystems/opengl/main.cpp src/plugins/graphicssystems/openvg/qgraphicssystem_vg.cpp src/plugins/graphicssystems/openvg/qgraphicssystem_vg_p.h src/plugins/graphicssystems/shivavg/main.cpp src/plugins/graphicssystems/shivavg/shivavggraphicssystem.cpp src/plugins/graphicssystems/shivavg/shivavggraphicssystem.h src/plugins/graphicssystems/shivavg/shivavgwindowsurface.cpp src/plugins/graphicssystems/shivavg/shivavgwindowsurface.h src/plugins/graphicssystems/trace/main.cpp src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp src/plugins/graphicssystems/trace/qgraphicssystem_trace_p.h src/plugins/kbddrivers/linuxinput/main.cpp src/plugins/mousedrivers/linuxtp/main.cpp src/plugins/mousedrivers/pc/main.cpp src/plugins/mousedrivers/tslib/main.cpp src/widgets/kernel/qwidget_qpa.cpp
5641 lines
177 KiB
C++
5641 lines
177 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of the QtOpenGL module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** GNU Lesser General Public License Usage
|
|
** This file may be used under the terms of the GNU Lesser General Public
|
|
** License version 2.1 as published by the Free Software Foundation and
|
|
** appearing in the file LICENSE.LGPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU Lesser
|
|
** General Public License version 2.1 requirements will be met:
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU General
|
|
** Public License version 3.0 as published by the Free Software Foundation
|
|
** and appearing in the file LICENSE.GPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU General
|
|
** Public License version 3.0 requirements will be met:
|
|
** http://www.gnu.org/copyleft/gpl.html.
|
|
**
|
|
** Other Usage
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include <qdebug.h>
|
|
#include <private/qfontengine_p.h>
|
|
#include <qmath.h>
|
|
#include <private/qmath_p.h>
|
|
#include <private/qdrawhelper_p.h>
|
|
#include <private/qpaintengine_p.h>
|
|
#include "qapplication.h"
|
|
#include "qbrush.h"
|
|
#include "qgl.h"
|
|
#include <private/qgl_p.h>
|
|
#include <private/qglpaintdevice_p.h>
|
|
#include <private/qpainter_p.h>
|
|
#include "qmap.h"
|
|
#include <private/qpaintengine_opengl_p.h>
|
|
#include <private/qdatabuffer_p.h>
|
|
#include "qpen.h"
|
|
#include "qvarlengtharray.h"
|
|
#include <private/qpainter_p.h>
|
|
#include <private/qglpixelbuffer_p.h>
|
|
#include <private/qbezier_p.h>
|
|
#include <qglframebufferobject.h>
|
|
#include <private/qstatictext_p.h>
|
|
|
|
#include "private/qtessellator_p.h"
|
|
|
|
#include "util/fragmentprograms_p.h"
|
|
|
|
#ifdef Q_WS_QWS
|
|
#include "private/qglwindowsurface_qws_p.h"
|
|
#include "qwsmanager_qws.h"
|
|
#include "private/qwsmanager_p.h"
|
|
#endif
|
|
|
|
#define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context());
|
|
|
|
#include <stdlib.h>
|
|
#include "qpaintengine_opengl_p.h"
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
Q_GUI_EXPORT QImage qt_imageForBrush(int brushStyle, bool invert); //in qbrush.cpp
|
|
#ifdef QT_MAC_USE_COCOA
|
|
extern void *qt_current_nsopengl_context(); // qgl_mac.mm
|
|
#endif
|
|
|
|
#define QREAL_MAX 9e100
|
|
#define QREAL_MIN -9e100
|
|
|
|
extern int qt_next_power_of_two(int v);
|
|
|
|
#define DISABLE_DEBUG_ONCE
|
|
|
|
//#define DEBUG_DISPLAY_MASK_TEXTURE
|
|
|
|
#ifdef DISABLE_DEBUG_ONCE
|
|
#define DEBUG_OVERRIDE(state) ;
|
|
#define DEBUG_ONCE_STR(str) ;
|
|
#define DEBUG_ONCE if (0)
|
|
#else
|
|
static int DEBUG_OVERRIDE_FLAG = 0;
|
|
static bool DEBUG_TEMP_FLAG;
|
|
#define DEBUG_OVERRIDE(state) { state ? ++DEBUG_OVERRIDE_FLAG : --DEBUG_OVERRIDE_FLAG; }
|
|
#define DEBUG_ONCE if ((DEBUG_TEMP_FLAG = DEBUG_OVERRIDE_FLAG) && 0) ; else for (static int DEBUG_ONCE_FLAG = false; !DEBUG_ONCE_FLAG || DEBUG_TEMP_FLAG; DEBUG_ONCE_FLAG = true, DEBUG_TEMP_FLAG = false)
|
|
#define DEBUG_ONCE_STR(str) DEBUG_ONCE qDebug() << (str);
|
|
#endif
|
|
|
|
#ifdef Q_WS_X11
|
|
static bool qt_nvidiaFboNeedsFinish = false;
|
|
#endif
|
|
|
|
static inline void qt_glColor4ubv(unsigned char *col)
|
|
{
|
|
glColor4f(col[0]/255.0f, col[1]/255.0f, col[2]/255.0f, col[3]/255.0f);
|
|
}
|
|
|
|
struct QT_PointF {
|
|
qreal x;
|
|
qreal y;
|
|
};
|
|
|
|
struct QGLTrapezoid
|
|
{
|
|
QGLTrapezoid()
|
|
{}
|
|
|
|
QGLTrapezoid(qreal top_, qreal bottom_, qreal topLeftX_, qreal topRightX_, qreal bottomLeftX_, qreal bottomRightX_)
|
|
: top(top_),
|
|
bottom(bottom_),
|
|
topLeftX(topLeftX_),
|
|
topRightX(topRightX_),
|
|
bottomLeftX(bottomLeftX_),
|
|
bottomRightX(bottomRightX_)
|
|
{}
|
|
|
|
const QGLTrapezoid translated(const QPointF &delta) const;
|
|
|
|
qreal top;
|
|
qreal bottom;
|
|
qreal topLeftX;
|
|
qreal topRightX;
|
|
qreal bottomLeftX;
|
|
qreal bottomRightX;
|
|
};
|
|
|
|
const QGLTrapezoid QGLTrapezoid::translated(const QPointF &delta) const
|
|
{
|
|
QGLTrapezoid trap(*this);
|
|
trap.top += delta.y();
|
|
trap.bottom += delta.y();
|
|
trap.topLeftX += delta.x();
|
|
trap.topRightX += delta.x();
|
|
trap.bottomLeftX += delta.x();
|
|
trap.bottomRightX += delta.x();
|
|
return trap;
|
|
}
|
|
|
|
|
|
class QOpenGLImmediateModeTessellator;
|
|
class QGLMaskGenerator;
|
|
class QGLOffscreen;
|
|
|
|
class QGLMaskTextureCache
|
|
{
|
|
public:
|
|
void setOffscreenSize(const QSize &offscreenSize);
|
|
void setDrawableSize(const QSize &drawableSize);
|
|
|
|
struct CacheLocation {
|
|
QRect rect;
|
|
int channel;
|
|
|
|
QRect screen_rect;
|
|
};
|
|
|
|
struct CacheInfo {
|
|
inline CacheInfo(const QPainterPath &p, const QTransform &m, qreal w = -1) :
|
|
path(p), matrix(m), stroke_width(w), age(0) {}
|
|
|
|
QPainterPath path;
|
|
QTransform matrix;
|
|
qreal stroke_width;
|
|
|
|
CacheLocation loc;
|
|
|
|
int age;
|
|
};
|
|
|
|
struct QuadTreeNode {
|
|
quint64 key;
|
|
|
|
int largest_available_block;
|
|
int largest_used_block;
|
|
};
|
|
|
|
CacheLocation getMask(QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *engine);
|
|
|
|
typedef QMultiHash<quint64, CacheInfo> QGLTextureCacheHash;
|
|
|
|
enum {block_size = 64};
|
|
|
|
// throw out keys that are too old
|
|
void maintainCache();
|
|
void clearCache();
|
|
|
|
private:
|
|
quint64 hash(const QPainterPath &p, const QTransform &m, qreal w);
|
|
|
|
void createMask(quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator);
|
|
|
|
QSize offscreenSize;
|
|
QSize drawableSize;
|
|
|
|
QGLTextureCacheHash cache;
|
|
|
|
QVector<QuadTreeNode> occupied_quadtree[4];
|
|
|
|
void quadtreeUpdate(int channel, int node, int current_block_size);
|
|
void quadtreeAllocate(quint64 key, const QSize &size, QRect *rect, int *channel);
|
|
|
|
bool quadtreeFindAvailableLocation(const QSize &size, QRect *rect, int *channel);
|
|
void quadtreeFindExistingLocation(const QSize &size, QRect *rect, int *channel);
|
|
|
|
void quadtreeInsert(int channel, quint64 key, const QRect &rect, int node = 0);
|
|
void quadtreeClear(int channel, const QRect &rect, int node = 0);
|
|
|
|
int quadtreeBlocksize(int node);
|
|
QPoint quadtreeLocation(int node);
|
|
|
|
QOpenGLPaintEnginePrivate *engine;
|
|
};
|
|
|
|
Q_GLOBAL_STATIC(QGLMaskTextureCache, qt_mask_texture_cache)
|
|
|
|
class QGLOffscreen : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QGLOffscreen()
|
|
: QObject(),
|
|
offscreen(0),
|
|
ctx(0),
|
|
mask_dim(0),
|
|
activated(false),
|
|
bound(false)
|
|
{
|
|
connect(QGLSignalProxy::instance(),
|
|
SIGNAL(aboutToDestroyContext(const QGLContext*)),
|
|
SLOT(cleanupGLContextRefs(const QGLContext*)));
|
|
}
|
|
|
|
inline void setDevice(QPaintDevice *pdev);
|
|
|
|
void begin();
|
|
void end();
|
|
|
|
inline void bind();
|
|
inline void release();
|
|
|
|
inline bool isBound() const;
|
|
|
|
inline QSize drawableSize() const;
|
|
inline QSize offscreenSize() const;
|
|
|
|
inline GLuint offscreenTexture() const;
|
|
|
|
QGLContext *context() const;
|
|
|
|
static bool isSupported();
|
|
|
|
inline void initialize();
|
|
|
|
inline bool isValid() const;
|
|
|
|
public Q_SLOTS:
|
|
void cleanupGLContextRefs(const QGLContext *context) {
|
|
if (context == ctx) {
|
|
delete offscreen;
|
|
ctx = 0;
|
|
offscreen = 0;
|
|
mask_dim = 0;
|
|
}
|
|
}
|
|
|
|
private:
|
|
QGLPaintDevice* device;
|
|
|
|
QGLFramebufferObject *offscreen;
|
|
QGLContext *ctx;
|
|
|
|
// dimensions of mask texture (square)
|
|
int mask_dim;
|
|
QSize last_failed_size;
|
|
|
|
bool drawable_fbo;
|
|
|
|
bool activated;
|
|
bool initialized;
|
|
|
|
bool bound;
|
|
};
|
|
|
|
inline void QGLOffscreen::setDevice(QPaintDevice *pdev)
|
|
{
|
|
if (pdev->devType() == QInternal::OpenGL)
|
|
device = static_cast<QGLPaintDevice*>(pdev);
|
|
else
|
|
device = QGLPaintDevice::getDevice(pdev);
|
|
|
|
if (!device)
|
|
return;
|
|
|
|
drawable_fbo = (pdev->devType() == QInternal::FramebufferObject);
|
|
}
|
|
|
|
void QGLOffscreen::begin()
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
initialized = false;
|
|
|
|
if (activated)
|
|
initialize();
|
|
#endif
|
|
}
|
|
|
|
void QGLOffscreen::initialize()
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
if (initialized)
|
|
return;
|
|
|
|
activated = true;
|
|
initialized = true;
|
|
|
|
int dim = qMax(2048, static_cast<int>(qt_next_power_of_two(qMax(device->size().width(), device->size().height()))));
|
|
|
|
bool shared_context = QGLContext::areSharing(device->context(), ctx);
|
|
bool would_fail = last_failed_size.isValid() &&
|
|
(device->size().width() >= last_failed_size.width() ||
|
|
device->size().height() >= last_failed_size.height());
|
|
bool needs_refresh = dim > mask_dim || !shared_context;
|
|
|
|
if (needs_refresh && !would_fail) {
|
|
DEBUG_ONCE qDebug() << "QGLOffscreen::initialize(): creating offscreen of size" << dim;
|
|
delete offscreen;
|
|
offscreen = new QGLFramebufferObject(dim, dim, GLenum(GL_TEXTURE_2D));
|
|
mask_dim = dim;
|
|
|
|
if (!offscreen->isValid()) {
|
|
qWarning("QGLOffscreen: Invalid offscreen fbo (size %dx%d)", mask_dim, mask_dim);
|
|
delete offscreen;
|
|
offscreen = 0;
|
|
mask_dim = 0;
|
|
last_failed_size = device->size();
|
|
}
|
|
}
|
|
|
|
qt_mask_texture_cache()->setOffscreenSize(offscreenSize());
|
|
qt_mask_texture_cache()->setDrawableSize(device->size());
|
|
ctx = device->context();
|
|
#endif
|
|
}
|
|
|
|
inline bool QGLOffscreen::isValid() const
|
|
{
|
|
return offscreen;
|
|
}
|
|
|
|
void QGLOffscreen::end()
|
|
{
|
|
if (bound)
|
|
release();
|
|
#ifdef DEBUG_DISPLAY_MASK_TEXTURE
|
|
glReadBuffer(GL_BACK);
|
|
glDrawBuffer(GL_BACK);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
glColor4f(1, 1, 1, 1);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, offscreen->texture());
|
|
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2f(0.0, 1.0); glVertex2f(0.0, 0.0);
|
|
glTexCoord2f(1.0, 1.0); glVertex2f(drawable.size().width(), 0.0);
|
|
glTexCoord2f(1.0, 0.0); glVertex2f(drawable.size().width(), drawable.size().height());
|
|
glTexCoord2f(0.0, 0.0); glVertex2f(0.0, drawable.size().height());
|
|
glEnd();
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
#endif
|
|
}
|
|
|
|
inline void QGLOffscreen::bind()
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
Q_ASSERT(initialized);
|
|
|
|
if (!offscreen || bound)
|
|
return;
|
|
|
|
DEBUG_ONCE qDebug() << "QGLOffscreen: binding offscreen";
|
|
offscreen->bind();
|
|
|
|
bound = true;
|
|
|
|
glViewport(0, 0, offscreenSize().width(), offscreenSize().height());
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
glOrtho(0, offscreenSize().width(), offscreenSize().height(), 0, -999999, 999999);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
#endif
|
|
}
|
|
|
|
inline void QGLOffscreen::release()
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
if (!offscreen || !bound)
|
|
return;
|
|
|
|
#ifdef Q_WS_X11
|
|
// workaround for bug in nvidia driver versions 9x.xx
|
|
if (qt_nvidiaFboNeedsFinish)
|
|
glFinish();
|
|
#endif
|
|
|
|
DEBUG_ONCE_STR("QGLOffscreen: releasing offscreen");
|
|
|
|
if (drawable_fbo)
|
|
device->ensureActiveTarget(); //###
|
|
else
|
|
offscreen->release();
|
|
|
|
QSize sz(device->size());
|
|
glViewport(0, 0, sz.width(), sz.height());
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
#ifndef QT_OPENGL_ES
|
|
glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
|
|
#else
|
|
glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);
|
|
#endif
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
bound = false;
|
|
#endif
|
|
}
|
|
|
|
inline bool QGLOffscreen::isBound() const
|
|
{
|
|
return bound;
|
|
}
|
|
|
|
inline QSize QGLOffscreen::drawableSize() const
|
|
{
|
|
return device->size();
|
|
}
|
|
|
|
inline QSize QGLOffscreen::offscreenSize() const
|
|
{
|
|
return QSize(mask_dim, mask_dim);
|
|
}
|
|
|
|
inline GLuint QGLOffscreen::offscreenTexture() const
|
|
{
|
|
return offscreen ? offscreen->texture() : 0;
|
|
}
|
|
|
|
inline QGLContext *QGLOffscreen::context() const
|
|
{
|
|
return ctx;
|
|
}
|
|
|
|
bool QGLOffscreen::isSupported()
|
|
{
|
|
return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject); // for fbo
|
|
}
|
|
|
|
struct QDrawQueueItem
|
|
{
|
|
QDrawQueueItem(qreal _opacity,
|
|
QBrush _brush,
|
|
const QPointF &_brush_origion,
|
|
QPainter::CompositionMode _composition_mode,
|
|
const QTransform &_matrix,
|
|
QGLMaskTextureCache::CacheLocation _location)
|
|
: opacity(_opacity),
|
|
brush(_brush),
|
|
brush_origin(_brush_origion),
|
|
composition_mode(_composition_mode),
|
|
matrix(_matrix),
|
|
location(_location) {}
|
|
qreal opacity;
|
|
QBrush brush;
|
|
QPointF brush_origin;
|
|
QPainter::CompositionMode composition_mode;
|
|
|
|
QTransform matrix;
|
|
QGLMaskTextureCache::CacheLocation location;
|
|
};
|
|
|
|
////////// GL program cache: start
|
|
|
|
struct GLProgram {
|
|
int brush; // brush index or mask index
|
|
int mode; // composition mode index
|
|
bool mask;
|
|
GLuint program;
|
|
};
|
|
|
|
typedef QMultiHash<const QGLContext *, GLProgram> QGLProgramHash;
|
|
|
|
class QGLProgramCache : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QGLProgramCache() {
|
|
// we have to know when a context is deleted so we can free
|
|
// any program handles it holds
|
|
connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext*)),
|
|
SLOT(cleanupPrograms(const QGLContext*)));
|
|
|
|
}
|
|
~QGLProgramCache() {
|
|
// at this point the cache should contain 0 elements
|
|
// Q_ASSERT(program.size() == 0);
|
|
}
|
|
|
|
GLuint getProgram(const QGLContext *ctx, int brush, int mode, bool mask_mode)
|
|
{
|
|
// 1. see if we have an entry for the ctx context
|
|
QList<GLProgram> progs = programs.values(ctx);
|
|
for (int i=0; i<progs.size(); ++i) {
|
|
const GLProgram &prg = progs.at(i);
|
|
if (mask_mode) {
|
|
if (prg.mask && prg.brush == brush)
|
|
return prg.program;
|
|
} else {
|
|
if (!prg.mask && prg.brush == brush && prg.mode == mode)
|
|
return prg.program;
|
|
}
|
|
}
|
|
|
|
// 2. try to find a match in a shared context, and update the
|
|
// hash with the entry found
|
|
QList<const QGLContext *> contexts = programs.uniqueKeys();
|
|
for (int i=0; i<contexts.size(); ++i) {
|
|
const QGLContext *cx = contexts.at(i);
|
|
if (cx != ctx && QGLContext::areSharing(cx, ctx)) {
|
|
QList<GLProgram> progs = programs.values(cx);
|
|
for (int k=0; k<progs.size(); ++k) {
|
|
const GLProgram &prg = progs.at(k);
|
|
if (mask_mode) {
|
|
if (prg.mask && prg.brush == brush) {
|
|
programs.insert(ctx, prg);
|
|
return prg.program;
|
|
}
|
|
} else {
|
|
if (!prg.mask && prg.brush == brush && prg.mode == mode) {
|
|
programs.insert(ctx, prg);
|
|
return prg.program;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. compile a new program and place it into the cache
|
|
// NB! assumes ctx is the current GL context
|
|
GLProgram prg;
|
|
prg.brush = brush;
|
|
prg.mode = mode;
|
|
prg.mask = mask_mode;
|
|
glGenProgramsARB(1, &prg.program);
|
|
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prg.program);
|
|
const char *src = mask_mode
|
|
? mask_fragment_program_sources[brush]
|
|
: painter_fragment_program_sources[brush][mode];
|
|
// necessary for .NET 2002, apparently
|
|
const GLbyte *gl_src = reinterpret_cast<const GLbyte *>(src);
|
|
|
|
while (glGetError() != GL_NO_ERROR) {} // reset error state
|
|
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
|
|
int(strlen(src)), gl_src);
|
|
if (glGetError() != GL_NO_ERROR) {
|
|
// qDebug() << "QGLProgramCache: Unable to compile fragment program.";
|
|
glDeleteProgramsARB(1, &prg.program);
|
|
return 0;
|
|
}
|
|
|
|
// qDebug() << "QGLProgramCache: Creating GL program:" << prg.program << hex << ctx;
|
|
programs.insert(ctx, prg);
|
|
return prg.program;
|
|
}
|
|
|
|
public Q_SLOTS:
|
|
void cleanupPrograms(const QGLContext *context)
|
|
{
|
|
QGLProgramHash::iterator it = programs.begin();
|
|
while (it != programs.end()) {
|
|
if (it.key() == context) {
|
|
if (!context->isSharing()) {
|
|
// the ctx variable below is needed for the glDeleteProgramARB call
|
|
// since it is resolved from our extension system
|
|
// NB! assumes context is the current GL context
|
|
const QGLContext *ctx = context;
|
|
// qDebug() << "QGLProgramHash: Deleting GL program:" << it.value().program << hex << it.key();
|
|
glDeleteProgramsARB(1, &it.value().program);
|
|
}
|
|
it = programs.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
QGLProgramHash programs;
|
|
};
|
|
|
|
Q_GLOBAL_STATIC(QGLProgramCache, qt_gl_program_cache)
|
|
|
|
////////// GL program cache: end
|
|
|
|
class QOpenGLPaintEnginePrivate;
|
|
class QGLPrivateCleanup : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QGLPrivateCleanup(QOpenGLPaintEnginePrivate *priv)
|
|
: p(priv)
|
|
{
|
|
connect(QGLSignalProxy::instance(),
|
|
SIGNAL(aboutToDestroyContext(const QGLContext*)),
|
|
SLOT(cleanupGLContextRefs(const QGLContext*)));
|
|
}
|
|
|
|
public Q_SLOTS:
|
|
void cleanupGLContextRefs(const QGLContext *context);
|
|
|
|
private:
|
|
QOpenGLPaintEnginePrivate *p;
|
|
};
|
|
|
|
class QOpenGLPaintEnginePrivate : public QPaintEngineExPrivate
|
|
{
|
|
Q_DECLARE_PUBLIC(QOpenGLPaintEngine)
|
|
public:
|
|
QOpenGLPaintEnginePrivate()
|
|
: opacity(1)
|
|
, composition_mode(QPainter::CompositionMode_SourceOver)
|
|
, has_fast_pen(false)
|
|
, use_stencil_method(false)
|
|
, dirty_drawable_texture(false)
|
|
, has_stencil_face_ext(false)
|
|
, use_fragment_programs(false)
|
|
, high_quality_antialiasing(false)
|
|
, use_smooth_pixmap_transform(false)
|
|
, use_emulation(false)
|
|
, txop(QTransform::TxNone)
|
|
, inverseScale(1)
|
|
, moveToCount(0)
|
|
, last_created_state(0)
|
|
, shader_ctx(0)
|
|
, grad_palette(0)
|
|
, tess_points(0)
|
|
, drawable_texture(0)
|
|
, ref_cleaner(this)
|
|
{}
|
|
|
|
inline void setGLPen(const QColor &c) {
|
|
uint alpha = qRound(c.alpha() * opacity);
|
|
pen_color[0] = qt_div_255(c.red() * alpha);
|
|
pen_color[1] = qt_div_255(c.green() * alpha);
|
|
pen_color[2] = qt_div_255(c.blue() * alpha);
|
|
pen_color[3] = alpha;
|
|
}
|
|
|
|
inline void setGLBrush(const QColor &c) {
|
|
uint alpha = qRound(c.alpha() * opacity);
|
|
brush_color[0] = qt_div_255(c.red() * alpha);
|
|
brush_color[1] = qt_div_255(c.green() * alpha);
|
|
brush_color[2] = qt_div_255(c.blue() * alpha);
|
|
brush_color[3] = alpha;
|
|
}
|
|
|
|
inline void setGradientOps(const QBrush &brush, const QRectF &bounds);
|
|
void createGradientPaletteTexture(const QGradient& g);
|
|
|
|
void updateGradient(const QBrush &brush, const QRectF &bounds);
|
|
|
|
inline void lineToStencil(qreal x, qreal y);
|
|
inline void curveToStencil(const QPointF &cp1, const QPointF &cp2, const QPointF &ep);
|
|
void pathToVertexArrays(const QPainterPath &path);
|
|
void fillVertexArray(Qt::FillRule fillRule);
|
|
void drawVertexArrays();
|
|
void fillPath(const QPainterPath &path);
|
|
void fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
|
|
Qt::FillRule fill);
|
|
|
|
void drawFastRect(const QRectF &rect);
|
|
void strokePath(const QPainterPath &path, bool use_cache);
|
|
void strokePathFastPen(const QPainterPath &path, bool needsResolving);
|
|
void strokeLines(const QPainterPath &path);
|
|
|
|
void updateDepthClip();
|
|
void systemStateChanged();
|
|
|
|
void cleanupGLContextRefs(const QGLContext *context) {
|
|
if (context == shader_ctx)
|
|
shader_ctx = 0;
|
|
}
|
|
|
|
inline void updateFastPen() {
|
|
qreal pen_width = cpen.widthF();
|
|
has_fast_pen =
|
|
((pen_width == 0 || (pen_width <= 1 && matrix.type() <= QTransform::TxTranslate))
|
|
|| cpen.isCosmetic())
|
|
&& cpen.style() == Qt::SolidLine
|
|
&& cpen.isSolid();
|
|
|
|
}
|
|
|
|
void disableClipping();
|
|
void enableClipping();
|
|
void ensureDrawableTexture();
|
|
|
|
QPen cpen;
|
|
QBrush cbrush;
|
|
Qt::BrushStyle brush_style;
|
|
QPointF brush_origin;
|
|
Qt::BrushStyle pen_brush_style;
|
|
qreal opacity;
|
|
QPainter::CompositionMode composition_mode;
|
|
|
|
Qt::BrushStyle current_style;
|
|
|
|
uint has_pen : 1;
|
|
uint has_brush : 1;
|
|
uint has_fast_pen : 1;
|
|
uint use_stencil_method : 1;
|
|
uint dirty_drawable_texture : 1;
|
|
uint has_stencil_face_ext : 1;
|
|
uint use_fragment_programs : 1;
|
|
uint high_quality_antialiasing : 1;
|
|
uint has_antialiasing : 1;
|
|
uint has_fast_composition_mode : 1;
|
|
uint use_smooth_pixmap_transform : 1;
|
|
uint use_system_clip : 1;
|
|
uint use_emulation : 1;
|
|
|
|
QRegion dirty_stencil;
|
|
|
|
void updateUseEmulation();
|
|
|
|
QTransform matrix;
|
|
GLubyte pen_color[4];
|
|
GLubyte brush_color[4];
|
|
QTransform::TransformationType txop;
|
|
QGLPaintDevice* device;
|
|
QGLOffscreen offscreen;
|
|
|
|
qreal inverseScale;
|
|
|
|
int moveToCount;
|
|
QPointF path_start;
|
|
|
|
bool isFastRect(const QRectF &r);
|
|
|
|
void drawImageAsPath(const QRectF &r, const QImage &img, const QRectF &sr);
|
|
void drawTiledImageAsPath(const QRectF &r, const QImage &img, qreal sx, qreal sy, const QPointF &offset);
|
|
|
|
void drawOffscreenPath(const QPainterPath &path);
|
|
|
|
void composite(const QRectF &rect, const QPoint &maskOffset = QPoint());
|
|
void composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
|
|
|
|
bool createFragmentPrograms();
|
|
void deleteFragmentPrograms();
|
|
void updateFragmentProgramData(int locations[]);
|
|
|
|
void cacheItemErased(int channel, const QRect &rect);
|
|
|
|
void addItem(const QGLMaskTextureCache::CacheLocation &location);
|
|
void drawItem(const QDrawQueueItem &item);
|
|
void flushDrawQueue();
|
|
|
|
void copyDrawable(const QRectF &rect);
|
|
|
|
void updateGLMatrix() const;
|
|
|
|
mutable QPainterState *last_created_state;
|
|
|
|
QGLContext *shader_ctx;
|
|
GLuint grad_palette;
|
|
|
|
GLuint painter_fragment_programs[num_fragment_brushes][num_fragment_composition_modes];
|
|
GLuint mask_fragment_programs[num_fragment_masks];
|
|
|
|
float inv_matrix_data[3][4];
|
|
float fmp_data[4];
|
|
float fmp2_m_radius2_data[4];
|
|
float angle_data[4];
|
|
float linear_data[4];
|
|
|
|
float porterduff_ab_data[4];
|
|
float porterduff_xyz_data[4];
|
|
|
|
float mask_offset_data[4];
|
|
float mask_channel_data[4];
|
|
|
|
FragmentBrushType fragment_brush;
|
|
FragmentCompositionModeType fragment_composition_mode;
|
|
|
|
void setPorterDuffData(float a, float b, float x, float y, float z);
|
|
void setInvMatrixData(const QTransform &inv_matrix);
|
|
|
|
qreal max_x;
|
|
qreal max_y;
|
|
qreal min_x;
|
|
qreal min_y;
|
|
|
|
QDataBuffer<QPointF> tess_points;
|
|
QVector<int> tess_points_stops;
|
|
|
|
GLdouble projection_matrix[4][4];
|
|
|
|
#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
|
|
GLfloat mv_matrix[4][4];
|
|
#else
|
|
GLdouble mv_matrix[4][4];
|
|
#endif
|
|
|
|
QList<QDrawQueueItem> drawQueue;
|
|
|
|
GLuint drawable_texture;
|
|
QSize drawable_texture_size;
|
|
|
|
int max_texture_size;
|
|
|
|
QGLPrivateCleanup ref_cleaner;
|
|
friend class QGLMaskTextureCache;
|
|
};
|
|
|
|
class QOpenGLCoordinateOffset
|
|
{
|
|
public:
|
|
QOpenGLCoordinateOffset(QOpenGLPaintEnginePrivate *d);
|
|
~QOpenGLCoordinateOffset();
|
|
|
|
static void enableOffset(QOpenGLPaintEnginePrivate *d);
|
|
static void disableOffset(QOpenGLPaintEnginePrivate *d);
|
|
|
|
private:
|
|
QOpenGLPaintEnginePrivate *d;
|
|
};
|
|
|
|
QOpenGLCoordinateOffset::QOpenGLCoordinateOffset(QOpenGLPaintEnginePrivate *d_)
|
|
: d(d_)
|
|
{
|
|
enableOffset(d);
|
|
}
|
|
|
|
void QOpenGLCoordinateOffset::enableOffset(QOpenGLPaintEnginePrivate *d)
|
|
{
|
|
if (!d->has_antialiasing) {
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
d->mv_matrix[3][0] += 0.5;
|
|
d->mv_matrix[3][1] += 0.5;
|
|
d->updateGLMatrix();
|
|
}
|
|
}
|
|
|
|
QOpenGLCoordinateOffset::~QOpenGLCoordinateOffset()
|
|
{
|
|
disableOffset(d);
|
|
}
|
|
|
|
void QOpenGLCoordinateOffset::disableOffset(QOpenGLPaintEnginePrivate *d)
|
|
{
|
|
if (!d->has_antialiasing) {
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
d->mv_matrix[3][0] -= 0.5;
|
|
d->mv_matrix[3][1] -= 0.5;
|
|
}
|
|
}
|
|
|
|
void QGLPrivateCleanup::cleanupGLContextRefs(const QGLContext *context)
|
|
{
|
|
p->cleanupGLContextRefs(context);
|
|
}
|
|
|
|
|
|
static inline void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform)
|
|
{
|
|
if (smoothPixmapTransform) {
|
|
glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
} else {
|
|
glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
}
|
|
glTexParameterf(target, GL_TEXTURE_WRAP_S, wrapMode);
|
|
glTexParameterf(target, GL_TEXTURE_WRAP_T, wrapMode);
|
|
}
|
|
|
|
static inline QPainterPath strokeForPath(const QPainterPath &path, const QPen &cpen) {
|
|
QPainterPathStroker stroker;
|
|
if (cpen.style() == Qt::CustomDashLine)
|
|
stroker.setDashPattern(cpen.dashPattern());
|
|
else
|
|
stroker.setDashPattern(cpen.style());
|
|
|
|
stroker.setCapStyle(cpen.capStyle());
|
|
stroker.setJoinStyle(cpen.joinStyle());
|
|
stroker.setMiterLimit(cpen.miterLimit());
|
|
stroker.setDashOffset(cpen.dashOffset());
|
|
|
|
qreal width = cpen.widthF();
|
|
if (width == 0)
|
|
stroker.setWidth(1);
|
|
else
|
|
stroker.setWidth(width);
|
|
|
|
QPainterPath stroke = stroker.createStroke(path);
|
|
stroke.setFillRule(Qt::WindingFill);
|
|
return stroke;
|
|
}
|
|
|
|
class QGLStrokeCache
|
|
{
|
|
struct CacheInfo
|
|
{
|
|
inline CacheInfo(QPainterPath p, QPainterPath sp, QPen stroke_pen) :
|
|
path(p), stroked_path(sp), pen(stroke_pen) {}
|
|
QPainterPath path;
|
|
QPainterPath stroked_path;
|
|
QPen pen;
|
|
};
|
|
|
|
typedef QMultiHash<quint64, CacheInfo> QGLStrokeTableHash;
|
|
|
|
public:
|
|
inline QPainterPath getStrokedPath(const QPainterPath &path, const QPen &pen) {
|
|
quint64 hash_val = 0;
|
|
|
|
for (int i = 0; i < path.elementCount() && i <= 2; i++) {
|
|
hash_val += quint64(path.elementAt(i).x);
|
|
hash_val += quint64(path.elementAt(i).y);
|
|
}
|
|
|
|
QGLStrokeTableHash::const_iterator it = cache.constFind(hash_val);
|
|
|
|
if (it == cache.constEnd())
|
|
return addCacheElement(hash_val, path, pen);
|
|
else {
|
|
do {
|
|
const CacheInfo &cache_info = it.value();
|
|
if (cache_info.path == path && cache_info.pen == pen)
|
|
return cache_info.stroked_path;
|
|
++it;
|
|
} while (it != cache.constEnd() && it.key() == hash_val);
|
|
// an exact match for this path was not found, create new cache element
|
|
return addCacheElement(hash_val, path, pen);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
inline int maxCacheSize() const { return 500; }
|
|
QPainterPath addCacheElement(quint64 hash_val, QPainterPath path, const QPen &pen) {
|
|
if (cache.size() == maxCacheSize()) {
|
|
int elem_to_remove = qrand() % maxCacheSize();
|
|
cache.remove(cache.keys()[elem_to_remove]); // may remove more than 1, but OK
|
|
}
|
|
QPainterPath stroke = strokeForPath(path, pen);
|
|
CacheInfo cache_entry(path, stroke, pen);
|
|
return cache.insert(hash_val, cache_entry).value().stroked_path;
|
|
}
|
|
|
|
QGLStrokeTableHash cache;
|
|
};
|
|
|
|
Q_GLOBAL_STATIC(QGLStrokeCache, qt_opengl_stroke_cache)
|
|
|
|
class QGLGradientCache : public QObject
|
|
{
|
|
Q_OBJECT
|
|
struct CacheInfo
|
|
{
|
|
inline CacheInfo(QGradientStops s, qreal op, QGradient::InterpolationMode mode) :
|
|
stops(s), opacity(op), interpolationMode(mode) {}
|
|
|
|
GLuint texId;
|
|
QGradientStops stops;
|
|
qreal opacity;
|
|
QGradient::InterpolationMode interpolationMode;
|
|
};
|
|
|
|
typedef QMultiHash<quint64, CacheInfo> QGLGradientColorTableHash;
|
|
|
|
public:
|
|
QGLGradientCache() : QObject(), buffer_ctx(0)
|
|
{
|
|
connect(QGLSignalProxy::instance(),
|
|
SIGNAL(aboutToDestroyContext(const QGLContext*)),
|
|
SLOT(cleanupGLContextRefs(const QGLContext*)));
|
|
}
|
|
|
|
inline GLuint getBuffer(const QGradient &gradient, qreal opacity, QGLContext *ctx) {
|
|
if (buffer_ctx && !QGLContext::areSharing(buffer_ctx, ctx))
|
|
cleanCache();
|
|
|
|
buffer_ctx = ctx;
|
|
|
|
quint64 hash_val = 0;
|
|
|
|
QGradientStops stops = gradient.stops();
|
|
for (int i = 0; i < stops.size() && i <= 2; i++)
|
|
hash_val += stops[i].second.rgba();
|
|
|
|
QGLGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
|
|
|
|
if (it == cache.constEnd())
|
|
return addCacheElement(hash_val, gradient, opacity);
|
|
else {
|
|
do {
|
|
const CacheInfo &cache_info = it.value();
|
|
if (cache_info.stops == stops && cache_info.opacity == opacity && cache_info.interpolationMode == gradient.interpolationMode()) {
|
|
return cache_info.texId;
|
|
}
|
|
++it;
|
|
} while (it != cache.constEnd() && it.key() == hash_val);
|
|
// an exact match for these stops and opacity was not found, create new cache
|
|
return addCacheElement(hash_val, gradient, opacity);
|
|
}
|
|
}
|
|
|
|
inline int paletteSize() const { return 1024; }
|
|
|
|
protected:
|
|
inline int maxCacheSize() const { return 60; }
|
|
inline void generateGradientColorTable(const QGradient& g,
|
|
uint *colorTable,
|
|
int size, qreal opacity) const;
|
|
GLuint addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity) {
|
|
if (cache.size() == maxCacheSize()) {
|
|
int elem_to_remove = qrand() % maxCacheSize();
|
|
quint64 key = cache.keys()[elem_to_remove];
|
|
|
|
// need to call glDeleteTextures on each removed cache entry:
|
|
QGLGradientColorTableHash::const_iterator it = cache.constFind(key);
|
|
do {
|
|
glDeleteTextures(1, &it.value().texId);
|
|
} while (++it != cache.constEnd() && it.key() == key);
|
|
cache.remove(key); // may remove more than 1, but OK
|
|
}
|
|
CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
|
|
uint buffer[1024];
|
|
generateGradientColorTable(gradient, buffer, paletteSize(), opacity);
|
|
glGenTextures(1, &cache_entry.texId);
|
|
#ifndef QT_OPENGL_ES
|
|
glBindTexture(GL_TEXTURE_1D, cache_entry.texId);
|
|
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, paletteSize(),
|
|
0, GL_BGRA, GL_UNSIGNED_BYTE, buffer);
|
|
#else
|
|
// create 2D one-line texture instead. This requires an impl of manual GL_TEXGEN for all primitives
|
|
#endif
|
|
return cache.insert(hash_val, cache_entry).value().texId;
|
|
}
|
|
|
|
void cleanCache() {
|
|
QGLShareContextScope scope(buffer_ctx);
|
|
QGLGradientColorTableHash::const_iterator it = cache.constBegin();
|
|
for (; it != cache.constEnd(); ++it) {
|
|
const CacheInfo &cache_info = it.value();
|
|
glDeleteTextures(1, &cache_info.texId);
|
|
}
|
|
cache.clear();
|
|
}
|
|
|
|
QGLGradientColorTableHash cache;
|
|
|
|
QGLContext *buffer_ctx;
|
|
|
|
public Q_SLOTS:
|
|
void cleanupGLContextRefs(const QGLContext *context) {
|
|
if (context == buffer_ctx) {
|
|
cleanCache();
|
|
buffer_ctx = 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
static inline uint endianColor(uint c)
|
|
{
|
|
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
|
|
return c;
|
|
#else
|
|
return ( (c << 24) & 0xff000000)
|
|
| ((c >> 24) & 0x000000ff)
|
|
| ((c << 8) & 0x00ff0000)
|
|
| ((c >> 8) & 0x0000ff00);
|
|
#endif // Q_BYTE_ORDER
|
|
}
|
|
|
|
void QGLGradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, qreal opacity) const
|
|
{
|
|
int pos = 0;
|
|
QGradientStops s = gradient.stops();
|
|
QVector<uint> colors(s.size());
|
|
|
|
for (int i = 0; i < s.size(); ++i)
|
|
colors[i] = s[i].second.rgba();
|
|
|
|
bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
|
|
|
|
uint alpha = qRound(opacity * 256);
|
|
uint current_color = ARGB_COMBINE_ALPHA(colors[0], alpha);
|
|
qreal incr = 1.0 / qreal(size);
|
|
qreal fpos = 1.5 * incr;
|
|
colorTable[pos++] = endianColor(PREMUL(current_color));
|
|
|
|
while (fpos <= s.first().first) {
|
|
colorTable[pos] = colorTable[pos - 1];
|
|
pos++;
|
|
fpos += incr;
|
|
}
|
|
|
|
if (colorInterpolation)
|
|
current_color = PREMUL(current_color);
|
|
|
|
for (int i = 0; i < s.size() - 1; ++i) {
|
|
qreal delta = 1/(s[i+1].first - s[i].first);
|
|
uint next_color = ARGB_COMBINE_ALPHA(colors[i+1], alpha);
|
|
if (colorInterpolation)
|
|
next_color = PREMUL(next_color);
|
|
|
|
while (fpos < s[i+1].first && pos < size) {
|
|
int dist = int(256 * ((fpos - s[i].first) * delta));
|
|
int idist = 256 - dist;
|
|
if (colorInterpolation)
|
|
colorTable[pos] = endianColor(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
|
|
else
|
|
colorTable[pos] = endianColor(PREMUL(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist)));
|
|
++pos;
|
|
fpos += incr;
|
|
}
|
|
current_color = next_color;
|
|
}
|
|
|
|
Q_ASSERT(s.size() > 0);
|
|
|
|
uint last_color = endianColor(PREMUL(ARGB_COMBINE_ALPHA(colors[s.size() - 1], alpha)));
|
|
for (;pos < size; ++pos)
|
|
colorTable[pos] = last_color;
|
|
|
|
// Make sure the last color stop is represented at the end of the table
|
|
colorTable[size-1] = last_color;
|
|
}
|
|
|
|
#ifndef Q_WS_QWS
|
|
Q_GLOBAL_STATIC(QGLGradientCache, qt_opengl_gradient_cache)
|
|
#endif
|
|
|
|
void QOpenGLPaintEnginePrivate::createGradientPaletteTexture(const QGradient& g)
|
|
{
|
|
#ifdef QT_OPENGL_ES //###
|
|
Q_UNUSED(g);
|
|
#else
|
|
GLuint texId = qt_opengl_gradient_cache()->getBuffer(g, opacity, device->context());
|
|
glBindTexture(GL_TEXTURE_1D, texId);
|
|
grad_palette = texId;
|
|
if (g.spread() == QGradient::RepeatSpread || g.type() == QGradient::ConicalGradient)
|
|
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
else if (g.spread() == QGradient::ReflectSpread)
|
|
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT_IBM);
|
|
else
|
|
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
inline void QOpenGLPaintEnginePrivate::setGradientOps(const QBrush &brush, const QRectF &bounds)
|
|
{
|
|
current_style = brush.style();
|
|
|
|
if (current_style < Qt::LinearGradientPattern || current_style > Qt::ConicalGradientPattern) {
|
|
setGLBrush(brush.color());
|
|
qt_glColor4ubv(brush_color);
|
|
}
|
|
|
|
updateGradient(brush, bounds);
|
|
|
|
#ifndef QT_OPENGL_ES //### GLES does not have GL_TEXTURE_GEN_ so we are falling back for gradients
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_1D);
|
|
|
|
if (current_style == Qt::LinearGradientPattern) {
|
|
if (high_quality_antialiasing || !has_fast_composition_mode) {
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_LINEAR;
|
|
} else {
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
glEnable(GL_TEXTURE_1D);
|
|
}
|
|
} else {
|
|
if (use_fragment_programs) {
|
|
if (current_style == Qt::RadialGradientPattern)
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_RADIAL;
|
|
else if (current_style == Qt::ConicalGradientPattern)
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_CONICAL;
|
|
else if (current_style == Qt::SolidPattern)
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_SOLID;
|
|
else if (current_style == Qt::TexturePattern && !brush.texture().isQBitmap())
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_TEXTURE;
|
|
else
|
|
fragment_brush = FRAGMENT_PROGRAM_BRUSH_PATTERN;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
QOpenGLPaintEngine::QOpenGLPaintEngine()
|
|
: QPaintEngineEx(*(new QOpenGLPaintEnginePrivate))
|
|
{
|
|
}
|
|
|
|
QOpenGLPaintEngine::~QOpenGLPaintEngine()
|
|
{
|
|
}
|
|
|
|
bool QOpenGLPaintEngine::begin(QPaintDevice *pdev)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (pdev->devType() == QInternal::OpenGL)
|
|
d->device = static_cast<QGLPaintDevice*>(pdev);
|
|
else
|
|
d->device = QGLPaintDevice::getDevice(pdev);
|
|
|
|
if (!d->device)
|
|
return false;
|
|
|
|
d->offscreen.setDevice(pdev);
|
|
d->has_fast_pen = false;
|
|
d->inverseScale = 1;
|
|
d->opacity = 1;
|
|
d->device->beginPaint();
|
|
d->matrix = QTransform();
|
|
d->has_antialiasing = false;
|
|
d->high_quality_antialiasing = false;
|
|
|
|
QSize sz(d->device->size());
|
|
d->dirty_stencil = QRect(0, 0, sz.width(), sz.height());
|
|
|
|
d->use_emulation = false;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 4; ++j)
|
|
d->mv_matrix[i][j] = (i == j ? qreal(1) : qreal(0));
|
|
|
|
bool has_frag_program = (QGLExtensions::glExtensions() & QGLExtensions::FragmentProgram)
|
|
&& (pdev->devType() != QInternal::Pixmap);
|
|
|
|
QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
|
|
if (!ctx) {
|
|
qWarning() << "QOpenGLPaintEngine: paint device doesn't have a valid GL context.";
|
|
return false;
|
|
}
|
|
|
|
if (has_frag_program)
|
|
has_frag_program = qt_resolve_frag_program_extensions(ctx) && qt_resolve_version_1_3_functions(ctx);
|
|
|
|
d->use_stencil_method = d->device->format().stencil()
|
|
&& (QGLExtensions::glExtensions() & QGLExtensions::StencilWrap);
|
|
if (d->device->format().directRendering()
|
|
&& (d->use_stencil_method && QGLExtensions::glExtensions() & QGLExtensions::StencilTwoSide))
|
|
d->has_stencil_face_ext = qt_resolve_stencil_face_extension(ctx);
|
|
|
|
#ifdef Q_WS_X11
|
|
static bool nvidia_workaround_needs_init = true;
|
|
if (nvidia_workaround_needs_init) {
|
|
// nvidia 9x.xx unix drivers contain a bug which requires us to
|
|
// call glFinish before releasing an fbo to avoid painting
|
|
// artifacts
|
|
const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
|
|
const int pos = versionString.indexOf("NVIDIA");
|
|
if (pos >= 0) {
|
|
const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
|
|
qt_nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
|
|
}
|
|
nvidia_workaround_needs_init = false;
|
|
}
|
|
#endif
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
if (!ctx->d_ptr->internal_context) {
|
|
glGetDoublev(GL_PROJECTION_MATRIX, &d->projection_matrix[0][0]);
|
|
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
glDisableClientState(GL_EDGE_FLAG_ARRAY);
|
|
glDisableClientState(GL_INDEX_ARRAY);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glDisable(GL_TEXTURE_1D);
|
|
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glPixelTransferi(GL_MAP_COLOR, false);
|
|
glPixelTransferi(GL_MAP_STENCIL, false);
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
|
|
glPixelStorei(GL_PACK_SWAP_BYTES, false);
|
|
glPixelStorei(GL_PACK_LSB_FIRST, false);
|
|
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
|
|
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
|
|
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
|
|
glPixelStorei(GL_UNPACK_SWAP_BYTES, false);
|
|
glPixelStorei(GL_UNPACK_LSB_FIRST, false);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
|
|
if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2) {
|
|
glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
|
|
glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!ctx->d_ptr->internal_context) {
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glMatrixMode(GL_TEXTURE);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
glDisableClientState(GL_NORMAL_ARRAY);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
|
|
glDisable(GL_MULTISAMPLE);
|
|
glDisable(GL_TEXTURE_2D);
|
|
if (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
|
|
glDisable(GL_TEXTURE_RECTANGLE_NV);
|
|
glDisable(GL_STENCIL_TEST);
|
|
glDisable(GL_CULL_FACE);
|
|
glDisable(GL_LIGHTING);
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
}
|
|
|
|
d->offscreen.begin();
|
|
|
|
glViewport(0, 0, sz.width(), sz.height()); // XXX (Embedded): We need a solution for GLWidgets that draw in a part or a bigger surface...
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
#ifdef QT_OPENGL_ES
|
|
glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);
|
|
#else
|
|
glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
|
|
#endif
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
glEnable(GL_BLEND);
|
|
d->composition_mode = QPainter::CompositionMode_SourceOver;
|
|
|
|
#ifdef QT_OPENGL_ES
|
|
d->max_texture_size = ctx->d_func()->maxTextureSize();
|
|
#else
|
|
bool shared_ctx = QGLContext::areSharing(d->device->context(), d->shader_ctx);
|
|
|
|
if (shared_ctx) {
|
|
d->max_texture_size = d->shader_ctx->d_func()->maxTextureSize();
|
|
} else {
|
|
d->max_texture_size = ctx->d_func()->maxTextureSize();
|
|
|
|
if (d->shader_ctx) {
|
|
d->shader_ctx->makeCurrent();
|
|
glBindTexture(GL_TEXTURE_1D, 0);
|
|
glDeleteTextures(1, &d->grad_palette);
|
|
|
|
if (has_frag_program && d->use_fragment_programs)
|
|
glDeleteTextures(1, &d->drawable_texture);
|
|
ctx->makeCurrent();
|
|
}
|
|
d->shader_ctx = d->device->context();
|
|
glGenTextures(1, &d->grad_palette);
|
|
|
|
qt_mask_texture_cache()->clearCache();
|
|
d->use_fragment_programs = has_frag_program;
|
|
}
|
|
|
|
if (d->use_fragment_programs && (!shared_ctx || sz.width() > d->drawable_texture_size.width()
|
|
|| sz.height() > d->drawable_texture_size.height()))
|
|
{
|
|
// delete old texture if size has increased, otherwise it was deleted earlier
|
|
if (shared_ctx)
|
|
glDeleteTextures(1, &d->drawable_texture);
|
|
|
|
d->dirty_drawable_texture = true;
|
|
d->drawable_texture_size = QSize(qt_next_power_of_two(sz.width()),
|
|
qt_next_power_of_two(sz.height()));
|
|
}
|
|
#endif
|
|
|
|
updateClipRegion(QRegion(), Qt::NoClip);
|
|
penChanged();
|
|
brushChanged();
|
|
opacityChanged();
|
|
compositionModeChanged();
|
|
renderHintsChanged();
|
|
transformChanged();
|
|
return true;
|
|
}
|
|
|
|
bool QOpenGLPaintEngine::end()
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
d->flushDrawQueue();
|
|
d->offscreen.end();
|
|
QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
|
|
if (!ctx->d_ptr->internal_context) {
|
|
glMatrixMode(GL_TEXTURE);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
}
|
|
#ifndef QT_OPENGL_ES
|
|
if (ctx->d_ptr->internal_context) {
|
|
glDisable(GL_SCISSOR_TEST);
|
|
} else {
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadMatrixd(&d->projection_matrix[0][0]);
|
|
glPopAttrib();
|
|
glPopClientAttrib();
|
|
}
|
|
#endif
|
|
d->device->endPaint();
|
|
qt_mask_texture_cache()->maintainCache();
|
|
|
|
#if defined(Q_WS_X11)
|
|
// clear out the references we hold for textures bound with the
|
|
// texture_from_pixmap extension
|
|
ctx->d_func()->boundPixmaps.clear();
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateState(const QPaintEngineState &state)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
QPaintEngine::DirtyFlags flags = state.state();
|
|
|
|
bool update_fast_pen = false;
|
|
|
|
if (flags & DirtyOpacity) {
|
|
update_fast_pen = true;
|
|
d->opacity = state.opacity();
|
|
if (d->opacity > 1.0f)
|
|
d->opacity = 1.0f;
|
|
if (d->opacity < 0.f)
|
|
d->opacity = 0.f;
|
|
// force update
|
|
flags |= DirtyPen;
|
|
flags |= DirtyBrush;
|
|
}
|
|
|
|
if (flags & DirtyTransform) {
|
|
update_fast_pen = true;
|
|
updateMatrix(state.transform());
|
|
// brush setup depends on transform state
|
|
if (state.brush().style() != Qt::NoBrush)
|
|
flags |= DirtyBrush;
|
|
}
|
|
|
|
if (flags & DirtyPen) {
|
|
update_fast_pen = true;
|
|
updatePen(state.pen());
|
|
}
|
|
|
|
if (flags & (DirtyBrush | DirtyBrushOrigin)) {
|
|
updateBrush(state.brush(), state.brushOrigin());
|
|
}
|
|
|
|
if (flags & DirtyFont) {
|
|
updateFont(state.font());
|
|
}
|
|
|
|
if (state.state() & DirtyClipEnabled) {
|
|
if (state.isClipEnabled())
|
|
updateClipRegion(painter()->clipRegion(), Qt::ReplaceClip);
|
|
else
|
|
updateClipRegion(QRegion(), Qt::NoClip);
|
|
}
|
|
|
|
if (flags & DirtyClipPath) {
|
|
updateClipRegion(QRegion(state.clipPath().toFillPolygon().toPolygon(),
|
|
state.clipPath().fillRule()),
|
|
state.clipOperation());
|
|
}
|
|
|
|
if (flags & DirtyClipRegion) {
|
|
updateClipRegion(state.clipRegion(), state.clipOperation());
|
|
}
|
|
|
|
if (flags & DirtyHints) {
|
|
updateRenderHints(state.renderHints());
|
|
}
|
|
|
|
if (flags & DirtyCompositionMode) {
|
|
updateCompositionMode(state.compositionMode());
|
|
}
|
|
|
|
if (update_fast_pen) {
|
|
Q_D(QOpenGLPaintEngine);
|
|
qreal pen_width = d->cpen.widthF();
|
|
d->has_fast_pen =
|
|
((pen_width == 0 || (pen_width <= 1 && d->txop <= QTransform::TxTranslate))
|
|
|| d->cpen.isCosmetic())
|
|
&& d->cpen.style() == Qt::SolidLine
|
|
&& d->cpen.isSolid();
|
|
}
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::setInvMatrixData(const QTransform &inv_matrix)
|
|
{
|
|
inv_matrix_data[0][0] = inv_matrix.m11();
|
|
inv_matrix_data[1][0] = inv_matrix.m21();
|
|
inv_matrix_data[2][0] = inv_matrix.m31();
|
|
|
|
inv_matrix_data[0][1] = inv_matrix.m12();
|
|
inv_matrix_data[1][1] = inv_matrix.m22();
|
|
inv_matrix_data[2][1] = inv_matrix.m32();
|
|
|
|
inv_matrix_data[0][2] = inv_matrix.m13();
|
|
inv_matrix_data[1][2] = inv_matrix.m23();
|
|
inv_matrix_data[2][2] = inv_matrix.m33();
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::updateGradient(const QBrush &brush, const QRectF &)
|
|
{
|
|
#ifdef QT_OPENGL_ES
|
|
Q_UNUSED(brush);
|
|
#else
|
|
bool has_mirrored_repeat = QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat;
|
|
Qt::BrushStyle style = brush.style();
|
|
|
|
QTransform m = brush.transform();
|
|
|
|
if (has_mirrored_repeat && style == Qt::LinearGradientPattern) {
|
|
const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
|
|
QTransform m = brush.transform();
|
|
QPointF realStart = g->start();
|
|
QPointF realFinal = g->finalStop();
|
|
QPointF start = m.map(realStart);
|
|
QPointF stop;
|
|
|
|
if (qFuzzyCompare(m.m11(), m.m22()) && m.m12() == 0.0 && m.m21() == 0.0) {
|
|
// It is a simple uniform scale and/or translation
|
|
stop = m.map(realFinal);
|
|
} else {
|
|
// It is not enough to just transform the endpoints.
|
|
// We have to make sure the _pattern_ is transformed correctly.
|
|
|
|
qreal odx = realFinal.x() - realStart.x();
|
|
qreal ody = realFinal.y() - realStart.y();
|
|
|
|
// nx, ny and dx, dy are normal and gradient direction after transform:
|
|
qreal nx = m.m11()*ody - m.m21()*odx;
|
|
qreal ny = m.m12()*ody - m.m22()*odx;
|
|
|
|
qreal dx = m.m11()*odx + m.m21()*ody;
|
|
qreal dy = m.m12()*odx + m.m22()*ody;
|
|
|
|
qreal lx = 1 / (dx - dy*nx/ny);
|
|
qreal ly = 1 / (dy - dx*ny/nx);
|
|
qreal l = 1 / qSqrt(lx*lx+ly*ly);
|
|
|
|
stop = start + QPointF(-ny, nx) * l/qSqrt(nx*nx+ny*ny);
|
|
}
|
|
|
|
float tr[4], f;
|
|
tr[0] = stop.x() - start.x();
|
|
tr[1] = stop.y() - start.y();
|
|
f = 1.0 / (tr[0]*tr[0] + tr[1]*tr[1]);
|
|
tr[0] *= f;
|
|
tr[1] *= f;
|
|
tr[2] = 0;
|
|
tr[3] = -(start.x()*tr[0] + start.y()*tr[1]);
|
|
brush_color[0] = brush_color[1] = brush_color[2] = brush_color[3] = 255;
|
|
qt_glColor4ubv(brush_color);
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
|
glTexGenfv(GL_S, GL_OBJECT_PLANE, tr);
|
|
}
|
|
|
|
if (use_fragment_programs) {
|
|
if (style == Qt::RadialGradientPattern) {
|
|
const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
|
|
QPointF realCenter = g->center();
|
|
QPointF realFocal = g->focalPoint();
|
|
qreal realRadius = g->radius();
|
|
QTransform translate(1, 0, 0, 1, -realFocal.x(), -realFocal.y());
|
|
QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
|
|
QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
|
|
QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
|
|
|
|
setInvMatrixData(inv_matrix);
|
|
|
|
fmp_data[0] = realCenter.x() - realFocal.x();
|
|
fmp_data[1] = realCenter.y() - realFocal.y();
|
|
|
|
fmp2_m_radius2_data[0] = -fmp_data[0] * fmp_data[0] - fmp_data[1] * fmp_data[1] + realRadius * realRadius;
|
|
} else if (style == Qt::ConicalGradientPattern) {
|
|
const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
|
|
QPointF realCenter = g->center();
|
|
QTransform translate(1, 0, 0, 1, -realCenter.x(), -realCenter.y());
|
|
QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
|
|
QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
|
|
QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
|
|
|
|
setInvMatrixData(inv_matrix);
|
|
|
|
angle_data[0] = -(g->angle() * 2 * Q_PI) / 360.0;
|
|
} else if (style == Qt::LinearGradientPattern) {
|
|
const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
|
|
|
|
QPointF realStart = g->start();
|
|
QPointF realFinal = g->finalStop();
|
|
QTransform translate(1, 0, 0, 1, -realStart.x(), -realStart.y());
|
|
QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
|
|
QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
|
|
QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
|
|
|
|
setInvMatrixData(inv_matrix);
|
|
|
|
QPointF l = realFinal - realStart;
|
|
|
|
linear_data[0] = l.x();
|
|
linear_data[1] = l.y();
|
|
|
|
linear_data[2] = 1.0f / (l.x() * l.x() + l.y() * l.y());
|
|
} else if (style != Qt::SolidPattern) {
|
|
QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
|
|
QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
|
|
QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted();
|
|
|
|
setInvMatrixData(inv_matrix);
|
|
}
|
|
}
|
|
|
|
if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
|
|
createGradientPaletteTexture(*brush.gradient());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
class QOpenGLTessellator : public QTessellator
|
|
{
|
|
public:
|
|
QOpenGLTessellator() {}
|
|
~QOpenGLTessellator() { }
|
|
QGLTrapezoid toGLTrapezoid(const Trapezoid &trap);
|
|
};
|
|
|
|
QGLTrapezoid QOpenGLTessellator::toGLTrapezoid(const Trapezoid &trap)
|
|
{
|
|
QGLTrapezoid t;
|
|
|
|
t.top = Q27Dot5ToDouble(trap.top);
|
|
t.bottom = Q27Dot5ToDouble(trap.bottom);
|
|
|
|
Q27Dot5 y = trap.topLeft->y - trap.bottomLeft->y;
|
|
|
|
qreal topLeftY = Q27Dot5ToDouble(trap.topLeft->y);
|
|
|
|
qreal tx = Q27Dot5ToDouble(trap.topLeft->x);
|
|
qreal m = (-tx + Q27Dot5ToDouble(trap.bottomLeft->x)) / Q27Dot5ToDouble(y);
|
|
t.topLeftX = tx + m * (topLeftY - t.top);
|
|
t.bottomLeftX = tx + m * (topLeftY - t.bottom);
|
|
|
|
y = trap.topRight->y - trap.bottomRight->y;
|
|
|
|
qreal topRightY = Q27Dot5ToDouble(trap.topRight->y);
|
|
|
|
tx = Q27Dot5ToDouble(trap.topRight->x);
|
|
m = (-tx + Q27Dot5ToDouble(trap.bottomRight->x)) / Q27Dot5ToDouble(y);
|
|
|
|
t.topRightX = tx + m * (topRightY - Q27Dot5ToDouble(trap.top));
|
|
t.bottomRightX = tx + m * (topRightY - Q27Dot5ToDouble(trap.bottom));
|
|
|
|
return t;
|
|
}
|
|
|
|
class QOpenGLImmediateModeTessellator : public QOpenGLTessellator
|
|
{
|
|
public:
|
|
void addTrap(const Trapezoid &trap);
|
|
void tessellate(const QPointF *points, int nPoints, bool winding) {
|
|
trapezoids.reserve(trapezoids.size() + nPoints);
|
|
setWinding(winding);
|
|
QTessellator::tessellate(points, nPoints);
|
|
}
|
|
|
|
QVector<QGLTrapezoid> trapezoids;
|
|
};
|
|
|
|
void QOpenGLImmediateModeTessellator::addTrap(const Trapezoid &trap)
|
|
{
|
|
trapezoids.append(toGLTrapezoid(trap));
|
|
}
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
static void drawTrapezoid(const QGLTrapezoid &trap, const qreal offscreenHeight, QGLContext *ctx)
|
|
{
|
|
qreal minX = qMin(trap.topLeftX, trap.bottomLeftX);
|
|
qreal maxX = qMax(trap.topRightX, trap.bottomRightX);
|
|
|
|
if (qFuzzyCompare(trap.top, trap.bottom) || qFuzzyCompare(minX, maxX) ||
|
|
(qFuzzyCompare(trap.topLeftX, trap.topRightX) && qFuzzyCompare(trap.bottomLeftX, trap.bottomRightX)))
|
|
return;
|
|
|
|
const qreal xpadding = 1.0;
|
|
const qreal ypadding = 1.0;
|
|
|
|
qreal topDist = offscreenHeight - trap.top;
|
|
qreal bottomDist = offscreenHeight - trap.bottom;
|
|
|
|
qreal reciprocal = bottomDist / (bottomDist - topDist);
|
|
|
|
qreal leftB = trap.bottomLeftX + (trap.topLeftX - trap.bottomLeftX) * reciprocal;
|
|
qreal rightB = trap.bottomRightX + (trap.topRightX - trap.bottomRightX) * reciprocal;
|
|
|
|
const bool topZero = qFuzzyIsNull(topDist);
|
|
|
|
reciprocal = topZero ? 1.0 / bottomDist : 1.0 / topDist;
|
|
|
|
qreal leftA = topZero ? (trap.bottomLeftX - leftB) * reciprocal : (trap.topLeftX - leftB) * reciprocal;
|
|
qreal rightA = topZero ? (trap.bottomRightX - rightB) * reciprocal : (trap.topRightX - rightB) * reciprocal;
|
|
|
|
qreal invLeftA = qFuzzyIsNull(leftA) ? 0.0 : 1.0 / leftA;
|
|
qreal invRightA = qFuzzyIsNull(rightA) ? 0.0 : 1.0 / rightA;
|
|
|
|
// fragment program needs the negative of invRightA as it mirrors the line
|
|
glTexCoord4f(topDist, bottomDist, invLeftA, -invRightA);
|
|
glMultiTexCoord4f(GL_TEXTURE1, leftA, leftB, rightA, rightB);
|
|
|
|
qreal topY = trap.top - ypadding;
|
|
qreal bottomY = trap.bottom + ypadding;
|
|
|
|
qreal bounds_bottomLeftX = leftA * (offscreenHeight - bottomY) + leftB;
|
|
qreal bounds_bottomRightX = rightA * (offscreenHeight - bottomY) + rightB;
|
|
qreal bounds_topLeftX = leftA * (offscreenHeight - topY) + leftB;
|
|
qreal bounds_topRightX = rightA * (offscreenHeight - topY) + rightB;
|
|
|
|
QPointF leftNormal(1, -leftA);
|
|
leftNormal /= qSqrt(leftNormal.x() * leftNormal.x() + leftNormal.y() * leftNormal.y());
|
|
QPointF rightNormal(1, -rightA);
|
|
rightNormal /= qSqrt(rightNormal.x() * rightNormal.x() + rightNormal.y() * rightNormal.y());
|
|
|
|
qreal left_padding = xpadding / qAbs(leftNormal.x());
|
|
qreal right_padding = xpadding / qAbs(rightNormal.x());
|
|
|
|
glVertex2d(bounds_topLeftX - left_padding, topY);
|
|
glVertex2d(bounds_topRightX + right_padding, topY);
|
|
glVertex2d(bounds_bottomRightX + right_padding, bottomY);
|
|
glVertex2d(bounds_bottomLeftX - left_padding, bottomY);
|
|
|
|
glTexCoord4f(0.0f, 0.0f, 0.0f, 1.0f);
|
|
}
|
|
#endif // !Q_WS_QWS
|
|
|
|
class QOpenGLTrapezoidToArrayTessellator : public QOpenGLTessellator
|
|
{
|
|
public:
|
|
QOpenGLTrapezoidToArrayTessellator() : vertices(0), allocated(0), size(0) {}
|
|
~QOpenGLTrapezoidToArrayTessellator() { free(vertices); }
|
|
GLfloat *vertices;
|
|
int allocated;
|
|
int size;
|
|
QRectF bounds;
|
|
void addTrap(const Trapezoid &trap);
|
|
void tessellate(const QPointF *points, int nPoints, bool winding) {
|
|
size = 0;
|
|
setWinding(winding);
|
|
bounds = QTessellator::tessellate(points, nPoints);
|
|
}
|
|
};
|
|
|
|
void QOpenGLTrapezoidToArrayTessellator::addTrap(const Trapezoid &trap)
|
|
{
|
|
// On OpenGL ES we convert the trap to 2 triangles
|
|
#ifndef QT_OPENGL_ES
|
|
if (size > allocated - 8) {
|
|
#else
|
|
if (size > allocated - 12) {
|
|
#endif
|
|
allocated = qMax(2*allocated, 512);
|
|
vertices = (GLfloat *)realloc(vertices, allocated * sizeof(GLfloat));
|
|
}
|
|
|
|
QGLTrapezoid t = toGLTrapezoid(trap);
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
vertices[size++] = t.topLeftX;
|
|
vertices[size++] = t.top;
|
|
vertices[size++] = t.topRightX;
|
|
vertices[size++] = t.top;
|
|
vertices[size++] = t.bottomRightX;
|
|
vertices[size++] = t.bottom;
|
|
vertices[size++] = t.bottomLeftX;
|
|
vertices[size++] = t.bottom;
|
|
#else
|
|
// First triangle
|
|
vertices[size++] = t.topLeftX;
|
|
vertices[size++] = t.top;
|
|
vertices[size++] = t.topRightX;
|
|
vertices[size++] = t.top;
|
|
vertices[size++] = t.bottomRightX;
|
|
vertices[size++] = t.bottom;
|
|
|
|
// Second triangle
|
|
vertices[size++] = t.bottomLeftX;
|
|
vertices[size++] = t.bottom;
|
|
vertices[size++] = t.topLeftX;
|
|
vertices[size++] = t.top;
|
|
vertices[size++] = t.bottomRightX;
|
|
vertices[size++] = t.bottom;
|
|
#endif
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
|
|
Qt::FillRule fill)
|
|
{
|
|
QOpenGLTrapezoidToArrayTessellator tessellator;
|
|
tessellator.tessellate(polygonPoints, pointCount, fill == Qt::WindingFill);
|
|
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon with" << pointCount << "points using fillPolygon_dev";
|
|
|
|
setGradientOps(cbrush, tessellator.bounds);
|
|
|
|
bool fast_style = current_style == Qt::LinearGradientPattern
|
|
|| current_style == Qt::SolidPattern;
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
GLenum geometry_mode = GL_QUADS;
|
|
#else
|
|
GLenum geometry_mode = GL_TRIANGLES;
|
|
#endif
|
|
|
|
if (use_fragment_programs && !(fast_style && has_fast_composition_mode)) {
|
|
composite(geometry_mode, tessellator.vertices, tessellator.size / 2);
|
|
} else {
|
|
glVertexPointer(2, GL_FLOAT, 0, tessellator.vertices);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(geometry_mode, 0, tessellator.size/2);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
}
|
|
|
|
|
|
inline void QOpenGLPaintEnginePrivate::lineToStencil(qreal x, qreal y)
|
|
{
|
|
tess_points.add(QPointF(x, y));
|
|
|
|
if (x > max_x)
|
|
max_x = x;
|
|
else if (x < min_x)
|
|
min_x = x;
|
|
if (y > max_y)
|
|
max_y = y;
|
|
else if (y < min_y)
|
|
min_y = y;
|
|
}
|
|
|
|
inline void QOpenGLPaintEnginePrivate::curveToStencil(const QPointF &cp1, const QPointF &cp2, const QPointF &ep)
|
|
{
|
|
qreal inverseScaleHalf = inverseScale / 2;
|
|
|
|
QBezier beziers[32];
|
|
beziers[0] = QBezier::fromPoints(tess_points.last(), cp1, cp2, ep);
|
|
QBezier *b = beziers;
|
|
while (b >= beziers) {
|
|
// check if we can pop the top bezier curve from the stack
|
|
qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
|
|
qreal d;
|
|
if (l > inverseScale) {
|
|
d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2) - (b->y4 - b->y1)*(b->x1 - b->x2) )
|
|
+ qAbs( (b->x4 - b->x1)*(b->y1 - b->y3) - (b->y4 - b->y1)*(b->x1 - b->x3) );
|
|
d /= l;
|
|
} else {
|
|
d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
|
|
qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
|
|
}
|
|
if (d < inverseScaleHalf || b == beziers + 31) {
|
|
// good enough, we pop it off and add the endpoint
|
|
lineToStencil(b->x4, b->y4);
|
|
--b;
|
|
} else {
|
|
// split, second half of the polygon goes lower into the stack
|
|
b->split(b+1, b);
|
|
++b;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::pathToVertexArrays(const QPainterPath &path)
|
|
{
|
|
const QPainterPath::Element &first = path.elementAt(0);
|
|
min_x = max_x = first.x;
|
|
min_y = max_y = first.y;
|
|
|
|
tess_points.reset();
|
|
tess_points_stops.clear();
|
|
lineToStencil(first.x, first.y);
|
|
|
|
for (int i=1; i<path.elementCount(); ++i) {
|
|
const QPainterPath::Element &e = path.elementAt(i);
|
|
switch (e.type) {
|
|
case QPainterPath::MoveToElement:
|
|
tess_points_stops.append(tess_points.size());
|
|
lineToStencil(e.x, e.y);
|
|
break;
|
|
case QPainterPath::LineToElement:
|
|
lineToStencil(e.x, e.y);
|
|
break;
|
|
case QPainterPath::CurveToElement:
|
|
curveToStencil(e, path.elementAt(i+1), path.elementAt(i+2));
|
|
i+=2;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
lineToStencil(first.x, first.y);
|
|
tess_points_stops.append(tess_points.size());
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::drawVertexArrays()
|
|
{
|
|
if (tess_points_stops.count() == 0)
|
|
return;
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_DOUBLE, 0, tess_points.data());
|
|
int previous_stop = 0;
|
|
foreach(int stop, tess_points_stops) {
|
|
glDrawArrays(GL_TRIANGLE_FAN, previous_stop, stop-previous_stop);
|
|
previous_stop = stop;
|
|
}
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::fillVertexArray(Qt::FillRule fillRule)
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
|
|
QRect rect = dirty_stencil.boundingRect();
|
|
|
|
if (use_system_clip)
|
|
rect = q->systemClip().intersected(dirty_stencil).boundingRect();
|
|
|
|
glStencilMask(~0);
|
|
|
|
if (!rect.isEmpty()) {
|
|
disableClipping();
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
const int left = rect.left();
|
|
const int width = rect.width();
|
|
const int bottom = device->size().height() - (rect.bottom() + 1);
|
|
const int height = rect.height();
|
|
|
|
glScissor(left, bottom, width, height);
|
|
|
|
glClearStencil(0);
|
|
glClear(GL_STENCIL_BUFFER_BIT);
|
|
dirty_stencil -= rect;
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
enableClipping();
|
|
}
|
|
|
|
// Enable stencil.
|
|
glEnable(GL_STENCIL_TEST);
|
|
|
|
// Disable color writes.
|
|
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
|
|
|
GLuint stencilMask = 0;
|
|
|
|
if (fillRule == Qt::OddEvenFill) {
|
|
stencilMask = 1;
|
|
|
|
// Enable stencil writes.
|
|
glStencilMask(stencilMask);
|
|
|
|
// Set stencil xor mode.
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
|
|
|
|
// Disable stencil func.
|
|
glStencilFunc(GL_ALWAYS, 0, ~0);
|
|
|
|
drawVertexArrays();
|
|
} else if (fillRule == Qt::WindingFill) {
|
|
stencilMask = ~0;
|
|
|
|
if (has_stencil_face_ext) {
|
|
QGL_FUNC_CONTEXT;
|
|
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
|
|
|
|
glActiveStencilFaceEXT(GL_BACK);
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
|
|
glStencilFunc(GL_ALWAYS, 0, ~0);
|
|
|
|
glActiveStencilFaceEXT(GL_FRONT);
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
|
|
glStencilFunc(GL_ALWAYS, 0, ~0);
|
|
|
|
drawVertexArrays();
|
|
|
|
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
|
|
} else {
|
|
glStencilFunc(GL_ALWAYS, 0, ~0);
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
glCullFace(GL_BACK);
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
|
|
drawVertexArrays();
|
|
|
|
glCullFace(GL_FRONT);
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
|
|
drawVertexArrays();
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
}
|
|
}
|
|
|
|
// Enable color writes.
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
glStencilMask(stencilMask);
|
|
|
|
setGradientOps(cbrush, QRectF(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y)));
|
|
|
|
bool fast_fill = has_fast_composition_mode && (current_style == Qt::LinearGradientPattern || current_style == Qt::SolidPattern);
|
|
|
|
if (use_fragment_programs && !fast_fill) {
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (fragment programs)";
|
|
QRectF rect(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y));
|
|
|
|
// Enable stencil func.
|
|
glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
|
|
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
|
|
composite(rect);
|
|
} else {
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (no fragment programs)";
|
|
|
|
// Enable stencil func.
|
|
glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
|
|
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
|
|
#ifndef QT_OPENGL_ES
|
|
glBegin(GL_QUADS);
|
|
glVertex2f(min_x, min_y);
|
|
glVertex2f(max_x, min_y);
|
|
glVertex2f(max_x, max_y);
|
|
glVertex2f(min_x, max_y);
|
|
glEnd();
|
|
#endif
|
|
}
|
|
|
|
// Disable stencil writes.
|
|
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
|
|
glStencilMask(0);
|
|
glDisable(GL_STENCIL_TEST);
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::fillPath(const QPainterPath &path)
|
|
{
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
if (use_stencil_method && !high_quality_antialiasing) {
|
|
pathToVertexArrays(path);
|
|
fillVertexArray(path.fillRule());
|
|
return;
|
|
}
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
if (high_quality_antialiasing)
|
|
drawOffscreenPath(path);
|
|
else {
|
|
QPolygonF poly = path.toFillPolygon(matrix);
|
|
fillPolygon_dev(poly.data(), poly.count(),
|
|
path.fillRule());
|
|
}
|
|
|
|
updateGLMatrix();
|
|
}
|
|
|
|
extern bool qt_isExtendedRadialGradient(const QBrush &brush);
|
|
|
|
static inline bool needsEmulation(Qt::BrushStyle style)
|
|
{
|
|
return !(style == Qt::SolidPattern
|
|
|| (style == Qt::LinearGradientPattern
|
|
&& (QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat)));
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::updateUseEmulation()
|
|
{
|
|
use_emulation = (!use_fragment_programs
|
|
&& ((has_pen && needsEmulation(pen_brush_style))
|
|
|| (has_brush && needsEmulation(brush_style))))
|
|
|| (has_pen && qt_isExtendedRadialGradient(cpen.brush()))
|
|
|| (has_brush && qt_isExtendedRadialGradient(cbrush));
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updatePen(const QPen &pen)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
Qt::PenStyle pen_style = pen.style();
|
|
d->pen_brush_style = pen.brush().style();
|
|
d->cpen = pen;
|
|
d->has_pen = (pen_style != Qt::NoPen) && (d->pen_brush_style != Qt::NoBrush);
|
|
d->updateUseEmulation();
|
|
|
|
if (pen.isCosmetic()) {
|
|
GLfloat width = pen.widthF() == 0.0f ? 1.0f : pen.widthF();
|
|
glLineWidth(width);
|
|
glPointSize(width);
|
|
}
|
|
|
|
if (d->pen_brush_style >= Qt::LinearGradientPattern
|
|
&& d->pen_brush_style <= Qt::ConicalGradientPattern)
|
|
{
|
|
d->setGLPen(Qt::white);
|
|
} else {
|
|
d->setGLPen(pen.color());
|
|
}
|
|
|
|
d->updateFastPen();
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateBrush(const QBrush &brush, const QPointF &origin)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
d->cbrush = brush;
|
|
d->brush_style = brush.style();
|
|
d->brush_origin = origin;
|
|
d->has_brush = (d->brush_style != Qt::NoBrush);
|
|
d->updateUseEmulation();
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateFont(const QFont &)
|
|
{
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateMatrix(const QTransform &mtx)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
d->matrix = mtx;
|
|
|
|
d->mv_matrix[0][0] = mtx.m11();
|
|
d->mv_matrix[0][1] = mtx.m12();
|
|
d->mv_matrix[0][2] = 0;
|
|
d->mv_matrix[0][3] = mtx.m13();
|
|
|
|
d->mv_matrix[1][0] = mtx.m21();
|
|
d->mv_matrix[1][1] = mtx.m22();
|
|
d->mv_matrix[1][2] = 0;
|
|
d->mv_matrix[1][3] = mtx.m23();
|
|
|
|
d->mv_matrix[2][0] = 0;
|
|
d->mv_matrix[2][1] = 0;
|
|
d->mv_matrix[2][2] = 1;
|
|
d->mv_matrix[2][3] = 0;
|
|
|
|
d->mv_matrix[3][0] = mtx.dx();
|
|
d->mv_matrix[3][1] = mtx.dy();
|
|
d->mv_matrix[3][2] = 0;
|
|
d->mv_matrix[3][3] = mtx.m33();
|
|
|
|
d->txop = mtx.type();
|
|
|
|
// 1/10000 == 0.0001, so we have good enough res to cover curves
|
|
// that span the entire widget...
|
|
d->inverseScale = qMax(1 / qMax( qMax(qAbs(mtx.m11()), qAbs(mtx.m22())),
|
|
qMax(qAbs(mtx.m12()), qAbs(mtx.m21())) ),
|
|
qreal(0.0001));
|
|
|
|
d->updateGLMatrix();
|
|
d->updateFastPen();
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::updateGLMatrix() const
|
|
{
|
|
glMatrixMode(GL_MODELVIEW);
|
|
#ifndef QT_OPENGL_ES
|
|
glLoadMatrixd(&mv_matrix[0][0]);
|
|
#else
|
|
glLoadMatrixf(&mv_matrix[0][0]);
|
|
#endif
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::disableClipping()
|
|
{
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_SCISSOR_TEST);
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::enableClipping()
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
if (!q->state()->hasClipping)
|
|
return;
|
|
|
|
if (q->state()->fastClip.isEmpty())
|
|
glEnable(GL_DEPTH_TEST);
|
|
else
|
|
updateDepthClip(); // this will enable the scissor test
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::updateDepthClip()
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
|
|
++q->state()->depthClipId;
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
if (!q->state()->hasClipping)
|
|
return;
|
|
|
|
QRect fastClip;
|
|
if (q->state()->clipEnabled) {
|
|
fastClip = q->state()->fastClip;
|
|
} else if (use_system_clip && q->systemClip().rects().count() == 1) {
|
|
fastClip = q->systemClip().rects().at(0);
|
|
}
|
|
|
|
if (!fastClip.isEmpty()) {
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
const int left = fastClip.left();
|
|
const int width = fastClip.width();
|
|
const int bottom = device->size().height() - (fastClip.bottom() + 1);
|
|
const int height = fastClip.height();
|
|
|
|
glScissor(left, bottom, width, height);
|
|
return;
|
|
}
|
|
|
|
#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
|
|
glClearDepthf(0.0f);
|
|
#else
|
|
glClearDepth(0.0f);
|
|
#endif
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthMask(GL_TRUE);
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
|
|
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
|
glDepthFunc(GL_ALWAYS);
|
|
|
|
const QVector<QRect> rects = q->state()->clipEnabled ? q->state()->clipRegion.rects() : q->systemClip().rects();
|
|
|
|
// rectangle count * 2 (triangles) * vertex count * component count (Z omitted)
|
|
QDataBuffer<GLfloat> clipVertex(rects.size()*2*3*2);
|
|
for (int i = 0; i < rects.size(); ++i) {
|
|
GLfloat x = GLfloat(rects.at(i).left());
|
|
GLfloat w = GLfloat(rects.at(i).width());
|
|
GLfloat h = GLfloat(rects.at(i).height());
|
|
GLfloat y = GLfloat(rects.at(i).top());
|
|
|
|
// First triangle
|
|
clipVertex.add(x);
|
|
clipVertex.add(y);
|
|
|
|
clipVertex.add(x);
|
|
clipVertex.add(y + h);
|
|
|
|
clipVertex.add(x + w);
|
|
clipVertex.add(y);
|
|
|
|
// Second triangle
|
|
clipVertex.add(x);
|
|
clipVertex.add(y + h);
|
|
|
|
clipVertex.add(x + w);
|
|
clipVertex.add(y + h);
|
|
|
|
clipVertex.add (x + w);
|
|
clipVertex.add(y);
|
|
}
|
|
|
|
if (rects.size()) {
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_FLOAT, 0, clipVertex.data());
|
|
|
|
glDrawArrays(GL_TRIANGLES, 0, rects.size()*2*3);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
updateGLMatrix();
|
|
}
|
|
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
glDepthMask(GL_FALSE);
|
|
glDepthFunc(GL_LEQUAL);
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::systemStateChanged()
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
if (q->painter()->hasClipping())
|
|
q->updateClipRegion(q->painter()->clipRegion(), Qt::ReplaceClip);
|
|
else
|
|
q->updateClipRegion(QRegion(), Qt::NoClip);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateClipRegion(const QRegion &clipRegion, Qt::ClipOperation op)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
// clipping is only supported when a stencil or depth buffer is
|
|
// available
|
|
if (!d->device->format().depth())
|
|
return;
|
|
|
|
d->use_system_clip = false;
|
|
QRegion sysClip = systemClip();
|
|
if (!sysClip.isEmpty()) {
|
|
if (d->pdev->devType() != QInternal::Widget) {
|
|
d->use_system_clip = true;
|
|
} else {
|
|
#ifndef Q_WS_QWS
|
|
// Only use the system clip if we're currently rendering a widget with a GL painter.
|
|
if (d->currentClipDevice) {
|
|
QWidgetPrivate *widgetPrivate = qt_widget_private(static_cast<QWidget *>(d->currentClipDevice)->window());
|
|
d->use_system_clip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
d->flushDrawQueue();
|
|
|
|
if (op == Qt::NoClip && !d->use_system_clip) {
|
|
state()->hasClipping = false;
|
|
state()->clipRegion = QRegion();
|
|
d->updateDepthClip();
|
|
return;
|
|
}
|
|
|
|
bool isScreenClip = false;
|
|
if (!d->use_system_clip) {
|
|
QVector<QRect> untransformedRects = clipRegion.rects();
|
|
|
|
if (untransformedRects.size() == 1) {
|
|
QPainterPath path;
|
|
path.addRect(untransformedRects[0]);
|
|
path = d->matrix.map(path);
|
|
|
|
if (path.contains(QRectF(QPointF(), d->device->size())))
|
|
isScreenClip = true;
|
|
}
|
|
}
|
|
|
|
QRegion region = isScreenClip ? QRegion() : clipRegion * d->matrix;
|
|
switch (op) {
|
|
case Qt::NoClip:
|
|
if (!d->use_system_clip)
|
|
break;
|
|
state()->clipRegion = sysClip;
|
|
break;
|
|
case Qt::IntersectClip:
|
|
if (isScreenClip)
|
|
return;
|
|
if (state()->hasClipping) {
|
|
state()->clipRegion &= region;
|
|
break;
|
|
}
|
|
// fall through
|
|
case Qt::ReplaceClip:
|
|
if (d->use_system_clip)
|
|
state()->clipRegion = region & sysClip;
|
|
else
|
|
state()->clipRegion = region;
|
|
break;
|
|
case Qt::UniteClip:
|
|
state()->clipRegion |= region;
|
|
if (d->use_system_clip)
|
|
state()->clipRegion &= sysClip;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (isScreenClip) {
|
|
state()->hasClipping = false;
|
|
state()->clipRegion = QRegion();
|
|
} else {
|
|
state()->hasClipping = op != Qt::NoClip || d->use_system_clip;
|
|
}
|
|
|
|
if (state()->hasClipping && state()->clipRegion.rects().size() == 1)
|
|
state()->fastClip = state()->clipRegion.rects().at(0);
|
|
else
|
|
state()->fastClip = QRect();
|
|
|
|
d->updateDepthClip();
|
|
}
|
|
|
|
void QOpenGLPaintEngine::updateRenderHints(QPainter::RenderHints hints)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
d->flushDrawQueue();
|
|
d->use_smooth_pixmap_transform = bool(hints & QPainter::SmoothPixmapTransform);
|
|
if ((hints & QPainter::Antialiasing) || (hints & QPainter::HighQualityAntialiasing)) {
|
|
if (d->use_fragment_programs && QGLOffscreen::isSupported()
|
|
&& (hints & QPainter::HighQualityAntialiasing)) {
|
|
d->high_quality_antialiasing = true;
|
|
} else {
|
|
d->high_quality_antialiasing = false;
|
|
if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
|
|
glEnable(GL_MULTISAMPLE);
|
|
}
|
|
} else {
|
|
d->high_quality_antialiasing = false;
|
|
if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
|
|
glDisable(GL_MULTISAMPLE);
|
|
}
|
|
|
|
if (d->high_quality_antialiasing) {
|
|
d->offscreen.initialize();
|
|
|
|
if (!d->offscreen.isValid()) {
|
|
DEBUG_ONCE_STR("Unable to initialize offscreen, disabling high quality antialiasing");
|
|
d->high_quality_antialiasing = false;
|
|
if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
|
|
glEnable(GL_MULTISAMPLE);
|
|
}
|
|
}
|
|
|
|
d->has_antialiasing = d->high_quality_antialiasing
|
|
|| ((hints & QPainter::Antialiasing)
|
|
&& (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers));
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::setPorterDuffData(float a, float b, float x, float y, float z)
|
|
{
|
|
porterduff_ab_data[0] = a;
|
|
porterduff_ab_data[1] = b;
|
|
|
|
porterduff_xyz_data[0] = x;
|
|
porterduff_xyz_data[1] = y;
|
|
porterduff_xyz_data[2] = z;
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEngine::updateCompositionMode(QPainter::CompositionMode composition_mode)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (!d->use_fragment_programs && composition_mode > QPainter::CompositionMode_Plus)
|
|
composition_mode = QPainter::CompositionMode_SourceOver;
|
|
|
|
d->composition_mode = composition_mode;
|
|
|
|
d->has_fast_composition_mode = (!d->high_quality_antialiasing && composition_mode <= QPainter::CompositionMode_Plus)
|
|
|| composition_mode == QPainter::CompositionMode_SourceOver
|
|
|| composition_mode == QPainter::CompositionMode_Destination
|
|
|| composition_mode == QPainter::CompositionMode_DestinationOver
|
|
|| composition_mode == QPainter::CompositionMode_DestinationOut
|
|
|| composition_mode == QPainter::CompositionMode_SourceAtop
|
|
|| composition_mode == QPainter::CompositionMode_Xor
|
|
|| composition_mode == QPainter::CompositionMode_Plus;
|
|
|
|
if (d->has_fast_composition_mode)
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODE_BLEND_MODE_MASK : COMPOSITION_MODE_BLEND_MODE_NOMASK;
|
|
else if (composition_mode <= QPainter::CompositionMode_Plus)
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SIMPLE_PORTER_DUFF : COMPOSITION_MODES_SIMPLE_PORTER_DUFF_NOMASK;
|
|
else
|
|
switch (composition_mode) {
|
|
case QPainter::CompositionMode_Multiply:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_MULTIPLY : COMPOSITION_MODES_MULTIPLY_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Screen:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SCREEN : COMPOSITION_MODES_SCREEN_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Overlay:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_OVERLAY : COMPOSITION_MODES_OVERLAY_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Darken:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DARKEN : COMPOSITION_MODES_DARKEN_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Lighten:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_LIGHTEN : COMPOSITION_MODES_LIGHTEN_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_ColorDodge:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORDODGE : COMPOSITION_MODES_COLORDODGE_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_ColorBurn:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORBURN : COMPOSITION_MODES_COLORBURN_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_HardLight:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_HARDLIGHT : COMPOSITION_MODES_HARDLIGHT_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_SoftLight:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SOFTLIGHT : COMPOSITION_MODES_SOFTLIGHT_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Difference:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DIFFERENCE : COMPOSITION_MODES_DIFFERENCE_NOMASK;
|
|
break;
|
|
case QPainter::CompositionMode_Exclusion:
|
|
d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_EXCLUSION : COMPOSITION_MODES_EXCLUSION_NOMASK;
|
|
break;
|
|
default:
|
|
Q_ASSERT(false);
|
|
}
|
|
|
|
switch(composition_mode) {
|
|
case QPainter::CompositionMode_DestinationOver:
|
|
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
|
|
d->setPorterDuffData(0, 1, 1, 1, 1);
|
|
break;
|
|
case QPainter::CompositionMode_Clear:
|
|
glBlendFunc(GL_ZERO, GL_ZERO);
|
|
d->setPorterDuffData(0, 0, 0, 0, 0);
|
|
break;
|
|
case QPainter::CompositionMode_Source:
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
d->setPorterDuffData(1, 0, 1, 1, 0);
|
|
break;
|
|
case QPainter::CompositionMode_Destination:
|
|
glBlendFunc(GL_ZERO, GL_ONE);
|
|
d->setPorterDuffData(0, 1, 1, 0, 1);
|
|
break;
|
|
case QPainter::CompositionMode_SourceIn:
|
|
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
|
|
d->setPorterDuffData(1, 0, 1, 0, 0);
|
|
break;
|
|
case QPainter::CompositionMode_DestinationIn:
|
|
glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
|
|
d->setPorterDuffData(0, 1, 1, 0, 0);
|
|
break;
|
|
case QPainter::CompositionMode_SourceOut:
|
|
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
|
|
d->setPorterDuffData(0, 0, 0, 1, 0);
|
|
break;
|
|
case QPainter::CompositionMode_DestinationOut:
|
|
glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
|
|
d->setPorterDuffData(0, 0, 0, 0, 1);
|
|
break;
|
|
case QPainter::CompositionMode_SourceAtop:
|
|
glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
d->setPorterDuffData(1, 0, 1, 0, 1);
|
|
break;
|
|
case QPainter::CompositionMode_DestinationAtop:
|
|
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
|
|
d->setPorterDuffData(0, 1, 1, 1, 0);
|
|
break;
|
|
case QPainter::CompositionMode_Xor:
|
|
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
d->setPorterDuffData(0, 0, 0, 1, 1);
|
|
break;
|
|
case QPainter::CompositionMode_SourceOver:
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
d->setPorterDuffData(1, 0, 1, 1, 1);
|
|
break;
|
|
case QPainter::CompositionMode_Plus:
|
|
glBlendFunc(GL_ONE, GL_ONE);
|
|
d->setPorterDuffData(1, 1, 1, 1, 1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
class QGLMaskGenerator
|
|
{
|
|
public:
|
|
QGLMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal stroke_width = -1)
|
|
: p(path),
|
|
m(matrix),
|
|
w(stroke_width)
|
|
{
|
|
}
|
|
|
|
virtual QRect screenRect() = 0;
|
|
virtual void drawMask(const QRect &rect) = 0;
|
|
|
|
QPainterPath path() const { return p; }
|
|
QTransform matrix() const { return m; }
|
|
qreal strokeWidth() const { return w; }
|
|
|
|
virtual ~QGLMaskGenerator() {}
|
|
|
|
private:
|
|
QPainterPath p;
|
|
QTransform m;
|
|
qreal w;
|
|
};
|
|
|
|
void QGLMaskTextureCache::setOffscreenSize(const QSize &sz)
|
|
{
|
|
Q_ASSERT(sz.width() == sz.height());
|
|
|
|
if (offscreenSize != sz) {
|
|
offscreenSize = sz;
|
|
clearCache();
|
|
}
|
|
}
|
|
|
|
void QGLMaskTextureCache::clearCache()
|
|
{
|
|
cache.clear();
|
|
|
|
int quad_tree_size = 1;
|
|
|
|
for (int i = block_size; i < offscreenSize.width(); i *= 2)
|
|
quad_tree_size += quad_tree_size * 4;
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
occupied_quadtree[i].resize(quad_tree_size);
|
|
|
|
occupied_quadtree[i][0].key = 0;
|
|
occupied_quadtree[i][0].largest_available_block = offscreenSize.width();
|
|
occupied_quadtree[i][0].largest_used_block = 0;
|
|
|
|
DEBUG_ONCE qDebug() << "QGLMaskTextureCache:: created quad tree of size" << quad_tree_size;
|
|
}
|
|
}
|
|
|
|
void QGLMaskTextureCache::setDrawableSize(const QSize &sz)
|
|
{
|
|
drawableSize = sz;
|
|
}
|
|
|
|
void QGLMaskTextureCache::maintainCache()
|
|
{
|
|
QGLTextureCacheHash::iterator it = cache.begin();
|
|
QGLTextureCacheHash::iterator end = cache.end();
|
|
|
|
while (it != end) {
|
|
CacheInfo &cache_info = it.value();
|
|
++cache_info.age;
|
|
|
|
if (cache_info.age > 1) {
|
|
quadtreeInsert(cache_info.loc.channel, 0, cache_info.loc.rect);
|
|
it = cache.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
//#define DISABLE_MASK_CACHE
|
|
|
|
QGLMaskTextureCache::CacheLocation QGLMaskTextureCache::getMask(QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *e)
|
|
{
|
|
#ifndef DISABLE_MASK_CACHE
|
|
engine = e;
|
|
|
|
quint64 key = hash(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());
|
|
|
|
if (key == 0)
|
|
key = 1;
|
|
|
|
CacheInfo info(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());
|
|
|
|
QGLTextureCacheHash::iterator it = cache.find(key);
|
|
|
|
while (it != cache.end() && it.key() == key) {
|
|
CacheInfo &cache_info = it.value();
|
|
if (info.stroke_width == cache_info.stroke_width && info.matrix == cache_info.matrix && info.path == cache_info.path) {
|
|
DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Using cached mask");
|
|
|
|
cache_info.age = 0;
|
|
return cache_info.loc;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
// mask was not found, create new mask
|
|
|
|
DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Creating new mask...");
|
|
|
|
createMask(key, info, maskGenerator);
|
|
|
|
cache.insert(key, info);
|
|
|
|
return info.loc;
|
|
#else
|
|
CacheInfo info(maskGenerator.path(), maskGenerator.matrix());
|
|
createMask(0, info, maskGenerator);
|
|
return info.loc;
|
|
#endif
|
|
}
|
|
|
|
#ifndef FloatToQuint64
|
|
#define FloatToQuint64(i) (quint64)((i) * 32)
|
|
#endif
|
|
|
|
quint64 QGLMaskTextureCache::hash(const QPainterPath &p, const QTransform &m, qreal w)
|
|
{
|
|
Q_ASSERT(sizeof(quint64) == 8);
|
|
|
|
quint64 h = 0;
|
|
|
|
for (int i = 0; i < p.elementCount(); ++i) {
|
|
h += FloatToQuint64(p.elementAt(i).x) << 32;
|
|
h += FloatToQuint64(p.elementAt(i).y);
|
|
h += p.elementAt(i).type;
|
|
}
|
|
|
|
h += FloatToQuint64(m.m11());
|
|
#ifndef Q_OS_WINCE // ###
|
|
//Compiler crashes for arm on WinCE
|
|
h += FloatToQuint64(m.m12()) << 4;
|
|
h += FloatToQuint64(m.m13()) << 8;
|
|
h += FloatToQuint64(m.m21()) << 12;
|
|
h += FloatToQuint64(m.m22()) << 16;
|
|
h += FloatToQuint64(m.m23()) << 20;
|
|
h += FloatToQuint64(m.m31()) << 24;
|
|
h += FloatToQuint64(m.m32()) << 28;
|
|
#endif
|
|
h += FloatToQuint64(m.m33()) << 32;
|
|
|
|
h += FloatToQuint64(w);
|
|
|
|
return h;
|
|
}
|
|
|
|
void QGLMaskTextureCache::createMask(quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator)
|
|
{
|
|
info.loc.screen_rect = maskGenerator.screenRect();
|
|
|
|
if (info.loc.screen_rect.isEmpty()) {
|
|
info.loc.channel = 0;
|
|
info.loc.rect = QRect();
|
|
return;
|
|
}
|
|
|
|
quadtreeAllocate(key, info.loc.screen_rect.size(), &info.loc.rect, &info.loc.channel);
|
|
|
|
int ch = info.loc.channel;
|
|
glColorMask(ch == 0, ch == 1, ch == 2, ch == 3);
|
|
|
|
maskGenerator.drawMask(info.loc.rect);
|
|
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
}
|
|
|
|
int QGLMaskTextureCache::quadtreeBlocksize(int node)
|
|
{
|
|
DEBUG_ONCE qDebug() << "Offscreen size:" << offscreenSize.width();
|
|
|
|
int blocksize = offscreenSize.width();
|
|
|
|
while (node) {
|
|
node = (node - 1) / 4;
|
|
blocksize /= 2;
|
|
}
|
|
|
|
return blocksize;
|
|
}
|
|
|
|
QPoint QGLMaskTextureCache::quadtreeLocation(int node)
|
|
{
|
|
QPoint location;
|
|
int blocksize = quadtreeBlocksize(node);
|
|
|
|
while (node) {
|
|
--node;
|
|
|
|
if (node & 1)
|
|
location.setX(location.x() + blocksize);
|
|
|
|
if (node & 2)
|
|
location.setY(location.y() + blocksize);
|
|
|
|
node /= 4;
|
|
blocksize *= 2;
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
void QGLMaskTextureCache::quadtreeUpdate(int channel, int node, int current_block_size)
|
|
{
|
|
while (node) {
|
|
node = (node - 1) / 4;
|
|
|
|
int first_child = node * 4 + 1;
|
|
|
|
int largest_available = 0;
|
|
int largest_used = 0;
|
|
|
|
bool all_empty = true;
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
largest_available = qMax(largest_available, occupied_quadtree[channel][first_child + i].largest_available_block);
|
|
largest_used = qMax(largest_used, occupied_quadtree[channel][first_child + i].largest_used_block);
|
|
|
|
if (occupied_quadtree[channel][first_child + i].largest_available_block < current_block_size)
|
|
all_empty = false;
|
|
}
|
|
|
|
current_block_size *= 2;
|
|
|
|
if (all_empty) {
|
|
occupied_quadtree[channel][node].largest_available_block = current_block_size;
|
|
occupied_quadtree[channel][node].largest_used_block = 0;
|
|
} else {
|
|
occupied_quadtree[channel][node].largest_available_block = largest_available;
|
|
occupied_quadtree[channel][node].largest_used_block = largest_used;
|
|
}
|
|
}
|
|
}
|
|
|
|
void QGLMaskTextureCache::quadtreeInsert(int channel, quint64 key, const QRect &rect, int node)
|
|
{
|
|
int current_block_size = quadtreeBlocksize(node);
|
|
QPoint location = quadtreeLocation(node);
|
|
QRect relative = rect.translated(-location);
|
|
|
|
if (relative.left() >= current_block_size || relative.top() >= current_block_size
|
|
|| relative.right() < 0 || relative.bottom() < 0)
|
|
return;
|
|
|
|
if (current_block_size == block_size // no more refining possible
|
|
|| (relative.top() < block_size && relative.bottom() >= (current_block_size - block_size)
|
|
&& relative.left() < block_size && relative.right() >= (current_block_size - block_size)))
|
|
{
|
|
if (key != 0) {
|
|
occupied_quadtree[channel][node].largest_available_block = 0;
|
|
occupied_quadtree[channel][node].largest_used_block = rect.width() * rect.height();
|
|
} else {
|
|
occupied_quadtree[channel][node].largest_available_block = current_block_size;
|
|
occupied_quadtree[channel][node].largest_used_block = 0;
|
|
}
|
|
|
|
occupied_quadtree[channel][node].key = key;
|
|
|
|
quadtreeUpdate(channel, node, current_block_size);
|
|
} else {
|
|
if (key && occupied_quadtree[channel][node].largest_available_block == current_block_size) {
|
|
// refining the quad tree, initialize child nodes
|
|
int half_block_size = current_block_size / 2;
|
|
|
|
int temp = node * 4 + 1;
|
|
for (int sibling = 0; sibling < 4; ++sibling) {
|
|
occupied_quadtree[channel][temp + sibling].largest_available_block = half_block_size;
|
|
occupied_quadtree[channel][temp + sibling].largest_used_block = 0;
|
|
occupied_quadtree[channel][temp + sibling].key = 0;
|
|
}
|
|
}
|
|
|
|
node = node * 4 + 1;
|
|
|
|
for (int sibling = 0; sibling < 4; ++sibling)
|
|
quadtreeInsert(channel, key, rect, node + sibling);
|
|
}
|
|
}
|
|
|
|
void QGLMaskTextureCache::quadtreeClear(int channel, const QRect &rect, int node)
|
|
{
|
|
const quint64 &key = occupied_quadtree[channel][node].key;
|
|
|
|
int current_block_size = quadtreeBlocksize(node);
|
|
QPoint location = quadtreeLocation(node);
|
|
|
|
QRect relative = rect.translated(-location);
|
|
|
|
if (relative.left() >= current_block_size || relative.top() >= current_block_size
|
|
|| relative.right() < 0 || relative.bottom() < 0)
|
|
return;
|
|
|
|
if (key != 0) {
|
|
QGLTextureCacheHash::iterator it = cache.find(key);
|
|
|
|
Q_ASSERT(it != cache.end());
|
|
|
|
while (it != cache.end() && it.key() == key) {
|
|
const CacheInfo &cache_info = it.value();
|
|
|
|
if (cache_info.loc.channel == channel
|
|
&& cache_info.loc.rect.left() <= location.x()
|
|
&& cache_info.loc.rect.top() <= location.y()
|
|
&& cache_info.loc.rect.right() >= location.x()
|
|
&& cache_info.loc.rect.bottom() >= location.y())
|
|
{
|
|
quadtreeInsert(channel, 0, cache_info.loc.rect);
|
|
engine->cacheItemErased(channel, cache_info.loc.rect);
|
|
cache.erase(it);
|
|
goto found;
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
|
|
// if we don't find the key there's an error in the quadtree
|
|
Q_ASSERT(false);
|
|
found:
|
|
Q_ASSERT(occupied_quadtree[channel][node].key == 0);
|
|
} else if (occupied_quadtree[channel][node].largest_available_block < current_block_size) {
|
|
Q_ASSERT(current_block_size >= block_size);
|
|
|
|
node = node * 4 + 1;
|
|
|
|
for (int sibling = 0; sibling < 4; ++sibling)
|
|
quadtreeClear(channel, rect, node + sibling);
|
|
}
|
|
}
|
|
|
|
bool QGLMaskTextureCache::quadtreeFindAvailableLocation(const QSize &size, QRect *rect, int *channel)
|
|
{
|
|
int needed_block_size = qMax(1, qMax(size.width(), size.height()));
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
int current_block_size = offscreenSize.width();
|
|
|
|
if (occupied_quadtree[i][0].largest_available_block >= needed_block_size) {
|
|
int node = 0;
|
|
|
|
while (current_block_size != occupied_quadtree[i][node].largest_available_block) {
|
|
Q_ASSERT(current_block_size > block_size);
|
|
Q_ASSERT(current_block_size > occupied_quadtree[i][node].largest_available_block);
|
|
|
|
node = node * 4 + 1;
|
|
current_block_size /= 2;
|
|
|
|
int sibling = 0;
|
|
|
|
while (occupied_quadtree[i][node + sibling].largest_available_block < needed_block_size)
|
|
++sibling;
|
|
|
|
Q_ASSERT(sibling < 4);
|
|
node += sibling;
|
|
}
|
|
|
|
*channel = i;
|
|
*rect = QRect(quadtreeLocation(node), size);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void QGLMaskTextureCache::quadtreeFindExistingLocation(const QSize &size, QRect *rect, int *channel)
|
|
{
|
|
// try to pick small masks to throw out, as large masks are more expensive to recompute
|
|
*channel = qrand() % 4;
|
|
for (int i = 0; i < 4; ++i)
|
|
if (occupied_quadtree[i][0].largest_used_block < occupied_quadtree[*channel][0].largest_used_block)
|
|
*channel = i;
|
|
|
|
int needed_block_size = qt_next_power_of_two(qMax(1, qMax(size.width(), size.height())));
|
|
|
|
int node = 0;
|
|
int current_block_size = offscreenSize.width();
|
|
|
|
while (current_block_size > block_size
|
|
&& current_block_size >= needed_block_size * 2
|
|
&& occupied_quadtree[*channel][node].key == 0)
|
|
{
|
|
node = node * 4 + 1;
|
|
|
|
int sibling = 0;
|
|
|
|
for (int i = 1; i < 4; ++i) {
|
|
if (occupied_quadtree[*channel][node + i].largest_used_block
|
|
<= occupied_quadtree[*channel][node + sibling].largest_used_block)
|
|
{
|
|
sibling = i;
|
|
}
|
|
}
|
|
|
|
node += sibling;
|
|
current_block_size /= 2;
|
|
}
|
|
|
|
*rect = QRect(quadtreeLocation(node), size);
|
|
}
|
|
|
|
void QGLMaskTextureCache::quadtreeAllocate(quint64 key, const QSize &size, QRect *rect, int *channel)
|
|
{
|
|
#ifndef DISABLE_MASK_CACHE
|
|
if (!quadtreeFindAvailableLocation(size, rect, channel)) {
|
|
quadtreeFindExistingLocation(size, rect, channel);
|
|
quadtreeClear(*channel, *rect);
|
|
}
|
|
|
|
quadtreeInsert(*channel, key, *rect);
|
|
#else
|
|
*channel = 0;
|
|
*rect = QRect(QPoint(), size);
|
|
#endif
|
|
}
|
|
|
|
class QGLTrapezoidMaskGenerator : public QGLMaskGenerator
|
|
{
|
|
public:
|
|
QGLTrapezoidMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram, qreal strokeWidth = -1.0);
|
|
|
|
QRect screenRect();
|
|
void drawMask(const QRect &rect);
|
|
|
|
private:
|
|
QRect screen_rect;
|
|
bool has_screen_rect;
|
|
|
|
QGLOffscreen *offscreen;
|
|
|
|
GLuint maskFragmentProgram;
|
|
|
|
virtual QVector<QGLTrapezoid> generateTrapezoids() = 0;
|
|
virtual QRect computeScreenRect() = 0;
|
|
};
|
|
|
|
class QGLPathMaskGenerator : public QGLTrapezoidMaskGenerator
|
|
{
|
|
public:
|
|
QGLPathMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
|
|
|
|
private:
|
|
QVector<QGLTrapezoid> generateTrapezoids();
|
|
QRect computeScreenRect();
|
|
|
|
QPolygonF poly;
|
|
};
|
|
|
|
class QGLLineMaskGenerator : public QGLTrapezoidMaskGenerator
|
|
{
|
|
public:
|
|
QGLLineMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal width, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
|
|
|
|
private:
|
|
QVector<QGLTrapezoid> generateTrapezoids();
|
|
QRect computeScreenRect();
|
|
|
|
QPainterPath transformedPath;
|
|
};
|
|
|
|
class QGLRectMaskGenerator : public QGLTrapezoidMaskGenerator
|
|
{
|
|
public:
|
|
QGLRectMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
|
|
|
|
private:
|
|
QVector<QGLTrapezoid> generateTrapezoids();
|
|
QRect computeScreenRect();
|
|
|
|
QPainterPath transformedPath;
|
|
};
|
|
|
|
class QGLEllipseMaskGenerator : public QGLMaskGenerator
|
|
{
|
|
public:
|
|
QGLEllipseMaskGenerator(const QRectF &rect, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram, int *maskVariableLocations);
|
|
|
|
QRect screenRect();
|
|
void drawMask(const QRect &rect);
|
|
|
|
private:
|
|
QRect screen_rect;
|
|
|
|
QRectF ellipseRect;
|
|
|
|
QGLOffscreen *offscreen;
|
|
|
|
GLuint maskFragmentProgram;
|
|
|
|
int *maskVariableLocations;
|
|
|
|
float vertexArray[4 * 2];
|
|
};
|
|
|
|
QGLTrapezoidMaskGenerator::QGLTrapezoidMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program, qreal stroke_width)
|
|
: QGLMaskGenerator(path, matrix, stroke_width)
|
|
, has_screen_rect(false)
|
|
, offscreen(&offs)
|
|
, maskFragmentProgram(program)
|
|
{
|
|
}
|
|
|
|
extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array);
|
|
extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array);
|
|
|
|
void QGLTrapezoidMaskGenerator::drawMask(const QRect &rect)
|
|
{
|
|
#ifdef QT_OPENGL_ES
|
|
Q_UNUSED(rect);
|
|
#else
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
QGLContext *ctx = offscreen->context();
|
|
offscreen->bind();
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_1D);
|
|
|
|
GLfloat vertexArray[4 * 2];
|
|
qt_add_rect_to_array(rect, vertexArray);
|
|
|
|
bool needs_scissor = rect != screen_rect;
|
|
|
|
if (needs_scissor) {
|
|
glEnable(GL_SCISSOR_TEST);
|
|
glScissor(rect.left(), offscreen->offscreenSize().height() - rect.bottom() - 1, rect.width(), rect.height());
|
|
}
|
|
|
|
QVector<QGLTrapezoid> trapezoids = generateTrapezoids();
|
|
|
|
// clear mask
|
|
glBlendFunc(GL_ZERO, GL_ZERO); // clear
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glBlendFunc(GL_ONE, GL_ONE); // add mask
|
|
glEnable(GL_FRAGMENT_PROGRAM_ARB);
|
|
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, maskFragmentProgram);
|
|
|
|
QPoint delta = rect.topLeft() - screen_rect.topLeft();
|
|
glBegin(GL_QUADS);
|
|
for (int i = 0; i < trapezoids.size(); ++i)
|
|
drawTrapezoid(trapezoids[i].translated(delta), offscreen->offscreenSize().height(), ctx);
|
|
glEnd();
|
|
|
|
if (needs_scissor)
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
#endif
|
|
}
|
|
|
|
QRect QGLTrapezoidMaskGenerator::screenRect()
|
|
{
|
|
if (!has_screen_rect) {
|
|
screen_rect = computeScreenRect();
|
|
has_screen_rect = true;
|
|
}
|
|
|
|
screen_rect = screen_rect.intersected(QRect(QPoint(), offscreen->drawableSize()));
|
|
|
|
return screen_rect;
|
|
}
|
|
|
|
QGLPathMaskGenerator::QGLPathMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program)
|
|
: QGLTrapezoidMaskGenerator(path, matrix, offs, program)
|
|
{
|
|
}
|
|
|
|
QRect QGLPathMaskGenerator::computeScreenRect()
|
|
{
|
|
poly = path().toFillPolygon(matrix());
|
|
return poly.boundingRect().toAlignedRect();
|
|
}
|
|
|
|
QVector<QGLTrapezoid> QGLPathMaskGenerator::generateTrapezoids()
|
|
{
|
|
QOpenGLImmediateModeTessellator tessellator;
|
|
tessellator.tessellate(poly.data(), poly.count(), path().fillRule() == Qt::WindingFill);
|
|
return tessellator.trapezoids;
|
|
}
|
|
|
|
QGLRectMaskGenerator::QGLRectMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program)
|
|
: QGLTrapezoidMaskGenerator(path, matrix, offs, program)
|
|
{
|
|
}
|
|
|
|
QGLLineMaskGenerator::QGLLineMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal width, QGLOffscreen &offs, GLuint program)
|
|
: QGLTrapezoidMaskGenerator(path, matrix, offs, program, width)
|
|
{
|
|
}
|
|
|
|
QRect QGLRectMaskGenerator::computeScreenRect()
|
|
{
|
|
transformedPath = matrix().map(path());
|
|
|
|
return transformedPath.controlPointRect().adjusted(-1, -1, 1, 1).toAlignedRect();
|
|
}
|
|
|
|
QRect QGLLineMaskGenerator::computeScreenRect()
|
|
{
|
|
transformedPath = matrix().map(path());
|
|
|
|
return transformedPath.controlPointRect().adjusted(-1, -1, 1, 1).toAlignedRect();
|
|
}
|
|
|
|
QVector<QGLTrapezoid> QGLLineMaskGenerator::generateTrapezoids()
|
|
{
|
|
QOpenGLImmediateModeTessellator tessellator;
|
|
QPointF last;
|
|
for (int i = 0; i < transformedPath.elementCount(); ++i) {
|
|
QPainterPath::Element element = transformedPath.elementAt(i);
|
|
|
|
Q_ASSERT(!element.isCurveTo());
|
|
|
|
if (element.isLineTo())
|
|
tessellator.tessellateRect(last, element, strokeWidth());
|
|
|
|
last = element;
|
|
}
|
|
|
|
return tessellator.trapezoids;
|
|
}
|
|
|
|
QVector<QGLTrapezoid> QGLRectMaskGenerator::generateTrapezoids()
|
|
{
|
|
Q_ASSERT(transformedPath.elementCount() == 5);
|
|
|
|
QOpenGLImmediateModeTessellator tessellator;
|
|
if (matrix().type() <= QTransform::TxScale) {
|
|
QPointF a = transformedPath.elementAt(0);
|
|
QPointF b = transformedPath.elementAt(1);
|
|
QPointF c = transformedPath.elementAt(2);
|
|
QPointF d = transformedPath.elementAt(3);
|
|
|
|
QPointF first = (a + d) * 0.5;
|
|
QPointF last = (b + c) * 0.5;
|
|
|
|
QPointF delta = a - d;
|
|
|
|
// manhattan distance (no rotation)
|
|
qreal width = qAbs(delta.x()) + qAbs(delta.y());
|
|
|
|
Q_ASSERT(qFuzzyIsNull(delta.x()) || qFuzzyIsNull(delta.y()));
|
|
|
|
tessellator.tessellateRect(first, last, width);
|
|
} else {
|
|
QPointF points[5];
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
points[i] = transformedPath.elementAt(i);
|
|
|
|
tessellator.tessellateConvex(points, 5);
|
|
}
|
|
return tessellator.trapezoids;
|
|
}
|
|
|
|
static QPainterPath ellipseRectToPath(const QRectF &rect)
|
|
{
|
|
QPainterPath path;
|
|
path.addEllipse(rect);
|
|
return path;
|
|
}
|
|
|
|
QGLEllipseMaskGenerator::QGLEllipseMaskGenerator(const QRectF &rect, const QTransform &matrix, QGLOffscreen &offs, GLuint program, int *locations)
|
|
: QGLMaskGenerator(ellipseRectToPath(rect), matrix),
|
|
ellipseRect(rect),
|
|
offscreen(&offs),
|
|
maskFragmentProgram(program),
|
|
maskVariableLocations(locations)
|
|
{
|
|
}
|
|
|
|
QRect QGLEllipseMaskGenerator::screenRect()
|
|
{
|
|
QPointF center = ellipseRect.center();
|
|
|
|
QPointF points[] = {
|
|
QPointF(ellipseRect.left(), center.y()),
|
|
QPointF(ellipseRect.right(), center.y()),
|
|
QPointF(center.x(), ellipseRect.top()),
|
|
QPointF(center.x(), ellipseRect.bottom())
|
|
};
|
|
|
|
qreal min_screen_delta_len = QREAL_MAX;
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
QPointF delta = points[i] - center;
|
|
|
|
// normalize
|
|
delta /= qSqrt(delta.x() * delta.x() + delta.y() * delta.y());
|
|
|
|
QPointF screen_delta(matrix().m11() * delta.x() + matrix().m21() * delta.y(),
|
|
matrix().m12() * delta.x() + matrix().m22() * delta.y());
|
|
|
|
min_screen_delta_len = qMin(min_screen_delta_len,
|
|
qreal(qSqrt(screen_delta.x() * screen_delta.x() + screen_delta.y() * screen_delta.y())));
|
|
}
|
|
|
|
const qreal padding = 2.0f;
|
|
|
|
qreal grow = padding / min_screen_delta_len;
|
|
|
|
QRectF boundingRect = ellipseRect.adjusted(-grow, -grow, grow, grow);
|
|
|
|
boundingRect = matrix().mapRect(boundingRect);
|
|
|
|
QPointF p(0.5, 0.5);
|
|
|
|
screen_rect = QRect((boundingRect.topLeft() - p).toPoint(),
|
|
(boundingRect.bottomRight() + p).toPoint());
|
|
|
|
return screen_rect;
|
|
}
|
|
|
|
void QGLEllipseMaskGenerator::drawMask(const QRect &rect)
|
|
{
|
|
#ifdef QT_OPENGL_ES
|
|
Q_UNUSED(rect);
|
|
#else
|
|
QGLContext *ctx = offscreen->context();
|
|
offscreen->bind();
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_1D);
|
|
|
|
// fragment program needs the inverse radii of the ellipse
|
|
glTexCoord2f(1.0f / (ellipseRect.width() * 0.5f),
|
|
1.0f / (ellipseRect.height() * 0.5f));
|
|
|
|
QTransform translate(1, 0, 0, 1, -ellipseRect.center().x(), -ellipseRect.center().y());
|
|
QTransform gl_to_qt(1, 0, 0, -1, 0, offscreen->drawableSize().height());
|
|
QTransform inv_matrix = gl_to_qt * matrix().inverted() * translate;
|
|
|
|
float m[3][4] = { { float(inv_matrix.m11()), float(inv_matrix.m12()), float(inv_matrix.m13()) },
|
|
{ float(inv_matrix.m21()), float(inv_matrix.m22()), float(inv_matrix.m23()) },
|
|
{ float(inv_matrix.m31()), float(inv_matrix.m32()), float(inv_matrix.m33()) } };
|
|
|
|
QPoint offs(screen_rect.left() - rect.left(), (offscreen->drawableSize().height() - screen_rect.top())
|
|
- (offscreen->offscreenSize().height() - rect.top()));
|
|
|
|
// last component needs to be 1.0f to avoid Nvidia bug on linux
|
|
float ellipse_offset[4] = { float(offs.x()), float(offs.y()), 0.0f, 1.0f };
|
|
|
|
GLfloat vertexArray[4 * 2];
|
|
qt_add_rect_to_array(rect, vertexArray);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO); // set mask
|
|
glEnable(GL_FRAGMENT_PROGRAM_ARB);
|
|
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, maskFragmentProgram);
|
|
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M0], m[0]);
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M1], m[1]);
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M2], m[2]);
|
|
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_ELLIPSE_OFFSET], ellipse_offset);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
|
#endif
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::drawOffscreenPath(const QPainterPath &path)
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
Q_UNUSED(path);
|
|
#else
|
|
DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::drawOffscreenPath()");
|
|
|
|
disableClipping();
|
|
|
|
GLuint program = qt_gl_program_cache()->getProgram(device->context(),
|
|
FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
|
|
QGLPathMaskGenerator maskGenerator(path, matrix, offscreen, program);
|
|
addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
|
|
|
|
enableClipping();
|
|
#endif
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::drawFastRect(const QRectF &r)
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
DEBUG_ONCE_STR("QOpenGLPaintEngine::drawRects(): drawing fast rect");
|
|
|
|
GLfloat vertexArray[10];
|
|
qt_add_rect_to_array(r, vertexArray);
|
|
|
|
if (has_pen)
|
|
QOpenGLCoordinateOffset::enableOffset(this);
|
|
|
|
if (has_brush) {
|
|
flushDrawQueue();
|
|
|
|
bool temp = high_quality_antialiasing;
|
|
high_quality_antialiasing = false;
|
|
|
|
q->updateCompositionMode(composition_mode);
|
|
|
|
setGradientOps(cbrush, r);
|
|
|
|
bool fast_style = current_style == Qt::LinearGradientPattern
|
|
|| current_style == Qt::SolidPattern;
|
|
|
|
if (fast_style && has_fast_composition_mode) {
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
} else {
|
|
composite(r);
|
|
}
|
|
|
|
high_quality_antialiasing = temp;
|
|
|
|
q->updateCompositionMode(composition_mode);
|
|
}
|
|
|
|
if (has_pen) {
|
|
if (has_fast_pen && !high_quality_antialiasing) {
|
|
setGradientOps(cpen.brush(), r);
|
|
|
|
vertexArray[8] = vertexArray[0];
|
|
vertexArray[9] = vertexArray[1];
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(GL_LINE_STRIP, 0, 5);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
} else {
|
|
QPainterPath path;
|
|
path.setFillRule(Qt::WindingFill);
|
|
|
|
qreal left = r.left();
|
|
qreal right = r.right();
|
|
qreal top = r.top();
|
|
qreal bottom = r.bottom();
|
|
|
|
path.moveTo(left, top);
|
|
path.lineTo(right, top);
|
|
path.lineTo(right, bottom);
|
|
path.lineTo(left, bottom);
|
|
path.lineTo(left, top);
|
|
|
|
strokePath(path, false);
|
|
}
|
|
|
|
QOpenGLCoordinateOffset::disableOffset(this);
|
|
}
|
|
}
|
|
|
|
bool QOpenGLPaintEnginePrivate::isFastRect(const QRectF &rect)
|
|
{
|
|
if (matrix.type() < QTransform::TxRotate) {
|
|
QRectF r = matrix.mapRect(rect);
|
|
return r.topLeft().toPoint() == r.topLeft()
|
|
&& r.bottomRight().toPoint() == r.bottomRight();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawRects(const QRect *rects, int rectCount)
|
|
{
|
|
struct RectF {
|
|
qreal x;
|
|
qreal y;
|
|
qreal w;
|
|
qreal h;
|
|
};
|
|
Q_ASSERT(sizeof(RectF) == sizeof(QRectF));
|
|
RectF fr[256];
|
|
while (rectCount) {
|
|
int i = 0;
|
|
while (i < rectCount && i < 256) {
|
|
fr[i].x = rects[i].x();
|
|
fr[i].y = rects[i].y();
|
|
fr[i].w = rects[i].width();
|
|
fr[i].h = rects[i].height();
|
|
++i;
|
|
}
|
|
drawRects((QRectF *)(void *)fr, i);
|
|
rects += i;
|
|
rectCount -= i;
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawRects(const QRectF *rects, int rectCount)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawRects(rects, rectCount);
|
|
return;
|
|
}
|
|
|
|
for (int i=0; i<rectCount; ++i) {
|
|
const QRectF &r = rects[i];
|
|
|
|
// optimization for rects which can be drawn aliased
|
|
if (!d->high_quality_antialiasing || d->isFastRect(r)) {
|
|
d->drawFastRect(r);
|
|
} else {
|
|
QPainterPath path;
|
|
path.addRect(r);
|
|
|
|
if (d->has_brush) {
|
|
d->disableClipping();
|
|
GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
|
|
FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
|
|
|
|
if (d->matrix.type() >= QTransform::TxProject) {
|
|
QGLPathMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
|
|
d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
|
|
} else {
|
|
QGLRectMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
|
|
d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
|
|
}
|
|
|
|
d->enableClipping();
|
|
}
|
|
|
|
if (d->has_pen) {
|
|
if (d->has_fast_pen)
|
|
d->strokeLines(path);
|
|
else
|
|
d->strokePath(path, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void addQuadAsTriangle(GLfloat *quad, GLfloat *triangle)
|
|
{
|
|
triangle[0] = quad[0];
|
|
triangle[1] = quad[1];
|
|
|
|
triangle[2] = quad[2];
|
|
triangle[3] = quad[3];
|
|
|
|
triangle[4] = quad[4];
|
|
triangle[5] = quad[5];
|
|
|
|
triangle[6] = quad[4];
|
|
triangle[7] = quad[5];
|
|
|
|
triangle[8] = quad[6];
|
|
triangle[9] = quad[7];
|
|
|
|
triangle[10] = quad[0];
|
|
triangle[11] = quad[1];
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPoints(const QPoint *points, int pointCount)
|
|
{
|
|
Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
|
|
QT_PointF fp[256];
|
|
while (pointCount) {
|
|
int i = 0;
|
|
while (i < pointCount && i < 256) {
|
|
fp[i].x = points[i].x();
|
|
fp[i].y = points[i].y();
|
|
++i;
|
|
}
|
|
drawPoints((QPointF *)(void *)fp, i);
|
|
points += i;
|
|
pointCount -= i;
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPoints(const QPointF *points, int pointCount)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawPoints(points, pointCount);
|
|
return;
|
|
}
|
|
|
|
d->setGradientOps(d->cpen.brush(), QRectF());
|
|
|
|
if (!d->cpen.isCosmetic() || d->high_quality_antialiasing) {
|
|
Qt::PenCapStyle capStyle = d->cpen.capStyle();
|
|
if (capStyle == Qt::FlatCap)
|
|
d->cpen.setCapStyle(Qt::SquareCap);
|
|
QPaintEngine::drawPoints(points, pointCount);
|
|
d->cpen.setCapStyle(capStyle);
|
|
return;
|
|
}
|
|
|
|
d->flushDrawQueue();
|
|
|
|
if (d->has_fast_pen) {
|
|
QVarLengthArray<GLfloat> vertexArray(6 * pointCount);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
int j = 0;
|
|
for (int i = 0; i < pointCount; ++i) {
|
|
QPointF mapped = d->matrix.map(points[i]);
|
|
|
|
GLfloat x = GLfloat(qRound(mapped.x()));
|
|
GLfloat y = GLfloat(qRound(mapped.y()));
|
|
|
|
vertexArray[j++] = x;
|
|
vertexArray[j++] = y - 0.5f;
|
|
|
|
vertexArray[j++] = x + 1.5f;
|
|
vertexArray[j++] = y + 1.0f;
|
|
|
|
vertexArray[j++] = x;
|
|
vertexArray[j++] = y + 1.0f;
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
|
|
glDrawArrays(GL_TRIANGLES, 0, pointCount*3);
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glPopMatrix();
|
|
return;
|
|
}
|
|
|
|
const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
|
|
|
|
if (sizeof(qreal) == sizeof(double)) {
|
|
Q_ASSERT(sizeof(QPointF) == 16);
|
|
glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
|
|
}
|
|
else {
|
|
Q_ASSERT(sizeof(QPointF) == 8);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(GL_POINTS, 0, pointCount);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawLines(const QLine *lines, int lineCount)
|
|
{
|
|
struct PointF {
|
|
qreal x;
|
|
qreal y;
|
|
};
|
|
struct LineF {
|
|
PointF p1;
|
|
PointF p2;
|
|
};
|
|
Q_ASSERT(sizeof(PointF) == sizeof(QPointF));
|
|
Q_ASSERT(sizeof(LineF) == sizeof(QLineF));
|
|
LineF fl[256];
|
|
while (lineCount) {
|
|
int i = 0;
|
|
while (i < lineCount && i < 256) {
|
|
fl[i].p1.x = lines[i].x1();
|
|
fl[i].p1.y = lines[i].y1();
|
|
fl[i].p2.x = lines[i].x2();
|
|
fl[i].p2.y = lines[i].y2();
|
|
++i;
|
|
}
|
|
drawLines((QLineF *)(void *)fl, i);
|
|
lines += i;
|
|
lineCount -= i;
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawLines(const QLineF *lines, int lineCount)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawLines(lines, lineCount);
|
|
return;
|
|
}
|
|
|
|
if (d->has_pen) {
|
|
QOpenGLCoordinateOffset offset(d);
|
|
if (d->has_fast_pen && !d->high_quality_antialiasing) {
|
|
//### gradient resolving on lines isn't correct
|
|
d->setGradientOps(d->cpen.brush(), QRectF());
|
|
|
|
bool useRects = false;
|
|
// scale or 90 degree rotation?
|
|
if (d->matrix.type() <= QTransform::TxTranslate
|
|
|| (!d->cpen.isCosmetic()
|
|
&& (d->matrix.type() <= QTransform::TxScale
|
|
|| (d->matrix.type() == QTransform::TxRotate
|
|
&& d->matrix.m11() == 0 && d->matrix.m22() == 0)))) {
|
|
useRects = true;
|
|
for (int i = 0; i < lineCount; ++i) {
|
|
if (lines[i].p1().x() != lines[i].p2().x()
|
|
&& lines[i].p1().y() != lines[i].p2().y()) {
|
|
useRects = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
GLfloat endCap = d->cpen.capStyle() == Qt::FlatCap ? 0.0f : 0.5f;
|
|
if (useRects) {
|
|
QVarLengthArray<GLfloat> vertexArray(12 * lineCount);
|
|
|
|
GLfloat quad[8];
|
|
for (int i = 0; i < lineCount; ++i) {
|
|
GLfloat x1 = lines[i].x1();
|
|
GLfloat x2 = lines[i].x2();
|
|
GLfloat y1 = lines[i].y1();
|
|
GLfloat y2 = lines[i].y2();
|
|
|
|
if (x1 == x2) {
|
|
if (y1 > y2)
|
|
qSwap(y1, y2);
|
|
|
|
quad[0] = x1 - 0.5f;
|
|
quad[1] = y1 - endCap;
|
|
|
|
quad[2] = x1 + 0.5f;
|
|
quad[3] = y1 - endCap;
|
|
|
|
quad[4] = x1 + 0.5f;
|
|
quad[5] = y2 + endCap;
|
|
|
|
quad[6] = x1 - 0.5f;
|
|
quad[7] = y2 + endCap;
|
|
} else {
|
|
if (x1 > x2)
|
|
qSwap(x1, x2);
|
|
|
|
quad[0] = x1 - endCap;
|
|
quad[1] = y1 + 0.5f;
|
|
|
|
quad[2] = x1 - endCap;
|
|
quad[3] = y1 - 0.5f;
|
|
|
|
quad[4] = x2 + endCap;
|
|
quad[5] = y1 - 0.5f;
|
|
|
|
quad[6] = x2 + endCap;
|
|
quad[7] = y1 + 0.5f;
|
|
}
|
|
|
|
addQuadAsTriangle(quad, &vertexArray[12*i]);
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
|
|
glDrawArrays(GL_TRIANGLES, 0, lineCount*6);
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
} else {
|
|
QVarLengthArray<GLfloat> vertexArray(4 * lineCount);
|
|
for (int i = 0; i < lineCount; ++i) {
|
|
const QPointF a = lines[i].p1();
|
|
vertexArray[4*i] = lines[i].x1();
|
|
vertexArray[4*i+1] = lines[i].y1();
|
|
vertexArray[4*i+2] = lines[i].x2();
|
|
vertexArray[4*i+3] = lines[i].y2();
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
|
|
glDrawArrays(GL_LINES, 0, lineCount*2);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 4*sizeof(GLfloat), vertexArray.constData() + 2);
|
|
glDrawArrays(GL_POINTS, 0, lineCount);
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
} else {
|
|
QPainterPath path;
|
|
path.setFillRule(Qt::WindingFill);
|
|
for (int i=0; i<lineCount; ++i) {
|
|
const QLineF &l = lines[i];
|
|
|
|
if (l.p1() == l.p2()) {
|
|
if (d->cpen.capStyle() != Qt::FlatCap) {
|
|
QPointF p = l.p1();
|
|
drawPoints(&p, 1);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
path.moveTo(l.x1(), l.y1());
|
|
path.lineTo(l.x2(), l.y2());
|
|
}
|
|
|
|
if (d->has_fast_pen && d->high_quality_antialiasing)
|
|
d->strokeLines(path);
|
|
else
|
|
d->strokePath(path, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
|
|
{
|
|
Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
|
|
QVarLengthArray<QT_PointF> p(pointCount);
|
|
for (int i=0; i<pointCount; ++i) {
|
|
p[i].x = points[i].x();
|
|
p[i].y = points[i].y();
|
|
}
|
|
drawPolygon((QPointF *)p.data(), pointCount, mode);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
if(pointCount < 2)
|
|
return;
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawPolygon(points, pointCount, mode);
|
|
return;
|
|
}
|
|
|
|
QRectF bounds;
|
|
if ((mode == ConvexMode && !d->high_quality_antialiasing && state()->brushNeedsResolving()) ||
|
|
((d->has_fast_pen && !d->high_quality_antialiasing) && state()->penNeedsResolving())) {
|
|
qreal minx = points[0].x(), miny = points[0].y(),
|
|
maxx = points[0].x(), maxy = points[0].y();
|
|
for (int i = 1; i < pointCount; ++i) {
|
|
const QPointF &pt = points[i];
|
|
if (minx > pt.x())
|
|
minx = pt.x();
|
|
if (miny > pt.y())
|
|
miny = pt.y();
|
|
if (maxx < pt.x())
|
|
maxx = pt.x();
|
|
if (maxy < pt.y())
|
|
maxy = pt.y();
|
|
}
|
|
bounds = QRectF(minx, maxx, maxx-minx, maxy-miny);
|
|
}
|
|
|
|
QOpenGLCoordinateOffset offset(d);
|
|
|
|
if (d->has_brush && mode != PolylineMode) {
|
|
if (mode == ConvexMode && !d->high_quality_antialiasing) {
|
|
//### resolving on polygon from points isn't correct
|
|
d->setGradientOps(d->cbrush, bounds);
|
|
|
|
const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
|
|
|
|
if (sizeof(qreal) == sizeof(double)) {
|
|
Q_ASSERT(sizeof(QPointF) == 16);
|
|
glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
|
|
}
|
|
else {
|
|
Q_ASSERT(sizeof(QPointF) == 8);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, pointCount);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
} else {
|
|
QPainterPath path;
|
|
path.setFillRule(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
|
|
path.moveTo(points[0]);
|
|
for (int i=1; i<pointCount; ++i)
|
|
path.lineTo(points[i]);
|
|
d->fillPath(path);
|
|
}
|
|
}
|
|
|
|
if (d->has_pen) {
|
|
if (d->has_fast_pen && !d->high_quality_antialiasing) {
|
|
d->setGradientOps(d->cpen.brush(), bounds);
|
|
QVarLengthArray<GLfloat> vertexArray(pointCount*2 + 2);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
|
|
int i;
|
|
for (i=0; i<pointCount; ++i) {
|
|
vertexArray[i*2] = points[i].x();
|
|
vertexArray[i*2+1] = points[i].y();
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
if (mode != PolylineMode) {
|
|
vertexArray[i*2] = vertexArray[0];
|
|
vertexArray[i*2+1] = vertexArray[1];
|
|
glDrawArrays(GL_LINE_STRIP, 0, pointCount+1);
|
|
} else {
|
|
glDrawArrays(GL_LINE_STRIP, 0, pointCount);
|
|
glDrawArrays(GL_POINTS, pointCount-1, 1);
|
|
}
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
} else {
|
|
QPainterPath path(points[0]);
|
|
for (int i = 1; i < pointCount; ++i)
|
|
path.lineTo(points[i]);
|
|
if (mode != PolylineMode)
|
|
path.lineTo(points[0]);
|
|
|
|
if (d->has_fast_pen)
|
|
d->strokeLines(path);
|
|
else
|
|
d->strokePath(path, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::strokeLines(const QPainterPath &path)
|
|
{
|
|
DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::strokeLines()");
|
|
|
|
qreal penWidth = cpen.widthF();
|
|
|
|
GLuint program = qt_gl_program_cache()->getProgram(device->context(),
|
|
FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
|
|
QGLLineMaskGenerator maskGenerator(path, matrix, penWidth == 0 ? 1.0 : penWidth,
|
|
offscreen, program);
|
|
|
|
disableClipping();
|
|
|
|
QBrush temp = cbrush;
|
|
QPointF origin = brush_origin;
|
|
|
|
cbrush = cpen.brush();
|
|
brush_origin = QPointF();
|
|
|
|
addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
|
|
|
|
cbrush = temp;
|
|
brush_origin = origin;
|
|
|
|
enableClipping();
|
|
}
|
|
|
|
Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
|
|
|
|
void QOpenGLPaintEnginePrivate::strokePath(const QPainterPath &path, bool use_cache)
|
|
{
|
|
QBrush old_brush = cbrush;
|
|
cbrush = cpen.brush();
|
|
|
|
qreal txscale = 1;
|
|
if (cpen.isCosmetic() || (qt_scaleForTransform(matrix, &txscale) && txscale != 1)) {
|
|
QTransform temp = matrix;
|
|
matrix = QTransform();
|
|
glPushMatrix();
|
|
|
|
if (has_antialiasing) {
|
|
glLoadIdentity();
|
|
} else {
|
|
float offs_matrix[] =
|
|
{ 1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0.5, 0.5, 0, 1 };
|
|
glLoadMatrixf(offs_matrix);
|
|
}
|
|
|
|
QPen pen = cpen;
|
|
if (txscale != 1)
|
|
pen.setWidthF(pen.widthF() * txscale);
|
|
if (use_cache)
|
|
fillPath(qt_opengl_stroke_cache()->getStrokedPath(temp.map(path), pen));
|
|
else
|
|
fillPath(strokeForPath(temp.map(path), pen));
|
|
|
|
glPopMatrix();
|
|
matrix = temp;
|
|
} else if (use_cache) {
|
|
fillPath(qt_opengl_stroke_cache()->getStrokedPath(path, cpen));
|
|
} else {
|
|
fillPath(strokeForPath(path, cpen));
|
|
}
|
|
|
|
cbrush = old_brush;
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::strokePathFastPen(const QPainterPath &path, bool needsResolving)
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
QRectF bounds;
|
|
if (needsResolving)
|
|
bounds = path.controlPointRect();
|
|
setGradientOps(cpen.brush(), bounds);
|
|
|
|
QBezier beziers[32];
|
|
for (int i=0; i<path.elementCount(); ++i) {
|
|
const QPainterPath::Element &e = path.elementAt(i);
|
|
switch (e.type) {
|
|
case QPainterPath::MoveToElement:
|
|
if (i != 0)
|
|
glEnd(); // GL_LINE_STRIP
|
|
glBegin(GL_LINE_STRIP);
|
|
glVertex2d(e.x, e.y);
|
|
|
|
break;
|
|
case QPainterPath::LineToElement:
|
|
glVertex2d(e.x, e.y);
|
|
break;
|
|
|
|
case QPainterPath::CurveToElement:
|
|
{
|
|
QPointF sp = path.elementAt(i-1);
|
|
QPointF cp2 = path.elementAt(i+1);
|
|
QPointF ep = path.elementAt(i+2);
|
|
i+=2;
|
|
|
|
qreal inverseScaleHalf = inverseScale / 2;
|
|
beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
|
|
QBezier *b = beziers;
|
|
while (b >= beziers) {
|
|
// check if we can pop the top bezier curve from the stack
|
|
qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
|
|
qreal d;
|
|
if (l > inverseScale) {
|
|
d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
|
|
- (b->y4 - b->y1)*(b->x1 - b->x2) )
|
|
+ qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
|
|
- (b->y4 - b->y1)*(b->x1 - b->x3) );
|
|
d /= l;
|
|
} else {
|
|
d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
|
|
qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
|
|
}
|
|
if (d < inverseScaleHalf || b == beziers + 31) {
|
|
// good enough, we pop it off and add the endpoint
|
|
glVertex2d(b->x4, b->y4);
|
|
--b;
|
|
} else {
|
|
// split, second half of the polygon goes lower into the stack
|
|
b->split(b+1, b);
|
|
++b;
|
|
}
|
|
}
|
|
} // case CurveToElement
|
|
default:
|
|
break;
|
|
} // end of switch
|
|
}
|
|
glEnd(); // GL_LINE_STRIP
|
|
#else
|
|
// have to use vertex arrays on embedded
|
|
QRectF bounds;
|
|
if (needsResolving)
|
|
bounds = path.controlPointRect();
|
|
setGradientOps(cpen.brush(), bounds);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
tess_points.reset();
|
|
QBezier beziers[32];
|
|
for (int i=0; i<path.elementCount(); ++i) {
|
|
const QPainterPath::Element &e = path.elementAt(i);
|
|
switch (e.type) {
|
|
case QPainterPath::MoveToElement:
|
|
if (i != 0) {
|
|
glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
|
|
glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
|
|
tess_points.reset();
|
|
}
|
|
tess_points.add(QPointF(e.x, e.y));
|
|
|
|
break;
|
|
case QPainterPath::LineToElement:
|
|
tess_points.add(QPointF(e.x, e.y));
|
|
break;
|
|
|
|
case QPainterPath::CurveToElement:
|
|
{
|
|
QPointF sp = path.elementAt(i-1);
|
|
QPointF cp2 = path.elementAt(i+1);
|
|
QPointF ep = path.elementAt(i+2);
|
|
i+=2;
|
|
|
|
qreal inverseScaleHalf = inverseScale / 2;
|
|
beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
|
|
QBezier *b = beziers;
|
|
while (b >= beziers) {
|
|
// check if we can pop the top bezier curve from the stack
|
|
qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
|
|
qreal d;
|
|
if (l > inverseScale) {
|
|
d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
|
|
- (b->y4 - b->y1)*(b->x1 - b->x2) )
|
|
+ qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
|
|
- (b->y4 - b->y1)*(b->x1 - b->x3) );
|
|
d /= l;
|
|
} else {
|
|
d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
|
|
qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
|
|
}
|
|
if (d < inverseScaleHalf || b == beziers + 31) {
|
|
// good enough, we pop it off and add the endpoint
|
|
tess_points.add(QPointF(b->x4, b->y4));
|
|
--b;
|
|
} else {
|
|
// split, second half of the polygon goes lower into the stack
|
|
b->split(b+1, b);
|
|
++b;
|
|
}
|
|
}
|
|
} // case CurveToElement
|
|
default:
|
|
break;
|
|
} // end of switch
|
|
}
|
|
glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
|
|
glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
#endif
|
|
}
|
|
|
|
static bool pathClosed(const QPainterPath &path)
|
|
{
|
|
QPointF lastMoveTo = path.elementAt(0);
|
|
QPointF lastPoint = lastMoveTo;
|
|
|
|
for (int i = 1; i < path.elementCount(); ++i) {
|
|
const QPainterPath::Element &e = path.elementAt(i);
|
|
switch (e.type) {
|
|
case QPainterPath::MoveToElement:
|
|
if (lastMoveTo != lastPoint)
|
|
return false;
|
|
lastMoveTo = lastPoint = e;
|
|
break;
|
|
case QPainterPath::LineToElement:
|
|
lastPoint = e;
|
|
break;
|
|
case QPainterPath::CurveToElement:
|
|
lastPoint = path.elementAt(i + 2);
|
|
i+=2;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return lastMoveTo == lastPoint;
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPath(const QPainterPath &path)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawPath(path);
|
|
return;
|
|
}
|
|
|
|
QOpenGLCoordinateOffset offset(d);
|
|
|
|
if (d->has_brush) {
|
|
bool path_closed = pathClosed(path);
|
|
|
|
bool has_thick_pen =
|
|
path_closed
|
|
&& d->has_pen
|
|
&& d->cpen.style() == Qt::SolidLine
|
|
&& d->cpen.isSolid()
|
|
&& d->cpen.color().alpha() == 255
|
|
&& d->txop < QTransform::TxProject
|
|
&& d->cpen.widthF() >= 2 / qSqrt(qMin(d->matrix.m11() * d->matrix.m11()
|
|
+ d->matrix.m21() * d->matrix.m21(),
|
|
d->matrix.m12() * d->matrix.m12()
|
|
+ d->matrix.m22() * d->matrix.m22()));
|
|
|
|
if (has_thick_pen) {
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::drawPath(): Using thick pen optimization, style:" << d->cbrush.style();
|
|
|
|
d->flushDrawQueue();
|
|
|
|
bool temp = d->high_quality_antialiasing;
|
|
d->high_quality_antialiasing = false;
|
|
|
|
updateCompositionMode(d->composition_mode);
|
|
|
|
d->fillPath(path);
|
|
|
|
d->high_quality_antialiasing = temp;
|
|
updateCompositionMode(d->composition_mode);
|
|
} else {
|
|
d->fillPath(path);
|
|
}
|
|
}
|
|
|
|
if (d->has_pen) {
|
|
if (d->has_fast_pen && !d->high_quality_antialiasing)
|
|
d->strokePathFastPen(path, state()->penNeedsResolving());
|
|
else
|
|
d->strokePath(path, true);
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::drawImageAsPath(const QRectF &r, const QImage &img, const QRectF &sr)
|
|
{
|
|
QBrush old_brush = cbrush;
|
|
QPointF old_brush_origin = brush_origin;
|
|
|
|
qreal scaleX = r.width() / sr.width();
|
|
qreal scaleY = r.height() / sr.height();
|
|
|
|
QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
|
|
brush_matrix.scale(scaleX, scaleY);
|
|
brush_matrix.translate(-sr.left(), -sr.top());
|
|
|
|
cbrush = QBrush(img);
|
|
cbrush.setTransform(brush_matrix);
|
|
brush_origin = QPointF();
|
|
|
|
QPainterPath p;
|
|
p.addRect(r);
|
|
fillPath(p);
|
|
|
|
cbrush = old_brush;
|
|
brush_origin = old_brush_origin;
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::drawTiledImageAsPath(const QRectF &r, const QImage &img, qreal sx, qreal sy,
|
|
const QPointF &offset)
|
|
{
|
|
QBrush old_brush = cbrush;
|
|
QPointF old_brush_origin = brush_origin;
|
|
|
|
QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
|
|
brush_matrix.scale(sx, sy);
|
|
brush_matrix.translate(-offset.x(), -offset.y());
|
|
|
|
cbrush = QBrush(img);
|
|
cbrush.setTransform(brush_matrix);
|
|
brush_origin = QPointF();
|
|
|
|
QPainterPath p;
|
|
p.addRect(r);
|
|
fillPath(p);
|
|
|
|
cbrush = old_brush;
|
|
brush_origin = old_brush_origin;
|
|
}
|
|
|
|
static const QRectF scaleRect(const QRectF &r, qreal sx, qreal sy)
|
|
{
|
|
return QRectF(r.x() * sx, r.y() * sy, r.width() * sx, r.height() * sy);
|
|
}
|
|
|
|
template <typename T>
|
|
static const T qSubImage(const T &image, const QRectF &src, QRectF *srcNew)
|
|
{
|
|
const int sx1 = qMax(0, qFloor(src.left()));
|
|
const int sy1 = qMax(0, qFloor(src.top()));
|
|
const int sx2 = qMin(image.width(), qCeil(src.right()));
|
|
const int sy2 = qMin(image.height(), qCeil(src.bottom()));
|
|
|
|
const T sub = image.copy(sx1, sy1, sx2 - sx1, sy2 - sy1);
|
|
|
|
if (srcNew)
|
|
*srcNew = src.translated(-sx1, -sy1);
|
|
|
|
return sub;
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
if (pm.depth() == 1) {
|
|
QPixmap tpx(pm.size());
|
|
tpx.fill(Qt::transparent);
|
|
QPainter p(&tpx);
|
|
p.setPen(d->cpen);
|
|
p.drawPixmap(0, 0, pm);
|
|
p.end();
|
|
drawPixmap(r, tpx, sr);
|
|
return;
|
|
}
|
|
|
|
const int sz = d->max_texture_size;
|
|
if (pm.width() > sz || pm.height() > sz) {
|
|
QRectF subsr;
|
|
const QPixmap sub = qSubImage(pm, sr, &subsr);
|
|
|
|
if (sub.width() <= sz && sub.height() <= sz) {
|
|
drawPixmap(r, sub, subsr);
|
|
} else {
|
|
const QPixmap scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
|
|
const qreal sx = scaled.width() / qreal(sub.width());
|
|
const qreal sy = scaled.height() / qreal(sub.height());
|
|
|
|
drawPixmap(r, scaled, scaleRect(subsr, sx, sy));
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
|
|
d->drawImageAsPath(r, pm.toImage(), sr);
|
|
else {
|
|
GLenum target = qt_gl_preferredTextureTarget();
|
|
d->flushDrawQueue();
|
|
QGLTexture *tex =
|
|
d->device->context()->d_func()->bindTexture(pm, target, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
drawTextureRect(pm.width(), pm.height(), r, sr, target, tex);
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &offset)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
if (pm.depth() == 1) {
|
|
QPixmap tpx(pm.size());
|
|
tpx.fill(Qt::transparent);
|
|
QPainter p(&tpx);
|
|
p.setPen(d->cpen);
|
|
p.drawPixmap(0, 0, pm);
|
|
p.end();
|
|
drawTiledPixmap(r, tpx, offset);
|
|
return;
|
|
}
|
|
|
|
QImage scaled;
|
|
const int sz = d->max_texture_size;
|
|
if (pm.width() > sz || pm.height() > sz) {
|
|
int rw = qCeil(r.width());
|
|
int rh = qCeil(r.height());
|
|
if (rw < pm.width() && rh < pm.height()) {
|
|
drawTiledPixmap(r, pm.copy(0, 0, rw, rh), offset);
|
|
return;
|
|
}
|
|
|
|
scaled = pm.toImage().scaled(sz, sz, Qt::KeepAspectRatio);
|
|
}
|
|
|
|
if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r))) {
|
|
if (scaled.isNull())
|
|
d->drawTiledImageAsPath(r, pm.toImage(), 1, 1, offset);
|
|
else {
|
|
const qreal sx = pm.width() / qreal(scaled.width());
|
|
const qreal sy = pm.height() / qreal(scaled.height());
|
|
d->drawTiledImageAsPath(r, scaled, sx, sy, offset);
|
|
}
|
|
} else {
|
|
d->flushDrawQueue();
|
|
|
|
QGLTexture *tex;
|
|
if (scaled.isNull())
|
|
tex = d->device->context()->d_func()->bindTexture(pm, GL_TEXTURE_2D, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
else
|
|
tex = d->device->context()->d_func()->bindTexture(scaled, GL_TEXTURE_2D, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, d->use_smooth_pixmap_transform);
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
glPushAttrib(GL_CURRENT_BIT);
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
#endif
|
|
glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
GLdouble tc_w = r.width()/pm.width();
|
|
GLdouble tc_h = r.height()/pm.height();
|
|
|
|
// Rotate the texture so that it is aligned correctly and the
|
|
// wrapping is done correctly
|
|
if (tex->options & QGLContext::InvertedYBindOption) {
|
|
glMatrixMode(GL_TEXTURE);
|
|
glPushMatrix();
|
|
glRotatef(180.0, 0.0, 1.0, 0.0);
|
|
glRotatef(180.0, 0.0, 0.0, 1.0);
|
|
}
|
|
|
|
GLfloat vertexArray[4*2];
|
|
GLfloat texCoordArray[4*2];
|
|
|
|
double offset_x = offset.x() / pm.width();
|
|
double offset_y = offset.y() / pm.height();
|
|
|
|
qt_add_rect_to_array(r, vertexArray);
|
|
qt_add_texcoords_to_array(offset_x, offset_y,
|
|
tc_w + offset_x, tc_h + offset_y, texCoordArray);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
if (tex->options & QGLContext::InvertedYBindOption)
|
|
glPopMatrix();
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
#ifndef QT_OPENGL_ES
|
|
glPopAttrib();
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
|
|
Qt::ImageConversionFlags)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
const int sz = d->max_texture_size;
|
|
if (image.width() > sz || image.height() > sz) {
|
|
QRectF subsr;
|
|
const QImage sub = qSubImage(image, sr, &subsr);
|
|
|
|
if (sub.width() <= sz && sub.height() <= sz) {
|
|
drawImage(r, sub, subsr, 0);
|
|
} else {
|
|
const QImage scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
|
|
const qreal sx = scaled.width() / qreal(sub.width());
|
|
const qreal sy = scaled.height() / qreal(sub.height());
|
|
|
|
drawImage(r, scaled, scaleRect(subsr, sx, sy), 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
|
|
d->drawImageAsPath(r, image, sr);
|
|
else {
|
|
GLenum target = qt_gl_preferredTextureTarget();
|
|
d->flushDrawQueue();
|
|
QGLTexture *tex =
|
|
d->device->context()->d_func()->bindTexture(image, target, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
drawTextureRect(image.width(), image.height(), r, sr, target, tex);
|
|
}
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawTextureRect(int tx_width, int tx_height, const QRectF &r,
|
|
const QRectF &sr, GLenum target, QGLTexture *tex)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
#ifndef QT_OPENGL_ES
|
|
glPushAttrib(GL_CURRENT_BIT);
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
#endif
|
|
glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
|
|
glEnable(target);
|
|
updateTextureFilter(target, GL_CLAMP_TO_EDGE, d->use_smooth_pixmap_transform);
|
|
|
|
qreal x1, x2, y1, y2;
|
|
if (target == GL_TEXTURE_2D) {
|
|
x1 = sr.x() / tx_width;
|
|
x2 = x1 + sr.width() / tx_width;
|
|
if (tex->options & QGLContext::InvertedYBindOption) {
|
|
y1 = 1 - (sr.bottom() / tx_height);
|
|
y2 = 1 - (sr.y() / tx_height);
|
|
} else {
|
|
y1 = sr.bottom() / tx_height;
|
|
y2 = sr.y() / tx_height;
|
|
}
|
|
} else {
|
|
x1 = sr.x();
|
|
x2 = sr.right();
|
|
y1 = sr.bottom();
|
|
y2 = sr.y();
|
|
}
|
|
|
|
GLfloat vertexArray[4*2];
|
|
GLfloat texCoordArray[4*2];
|
|
|
|
qt_add_rect_to_array(r, vertexArray);
|
|
qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray);
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glDisable(target);
|
|
#ifndef QT_OPENGL_ES
|
|
glPopAttrib();
|
|
#endif
|
|
}
|
|
|
|
#ifdef Q_WS_WIN
|
|
HDC
|
|
#else
|
|
Qt::HANDLE
|
|
#endif
|
|
QOpenGLPaintEngine::handle() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static const int x_margin = 1;
|
|
static const int y_margin = 0;
|
|
|
|
struct QGLGlyphCoord {
|
|
// stores the offset and size of a glyph texture
|
|
qreal x;
|
|
qreal y;
|
|
qreal width;
|
|
qreal height;
|
|
qreal log_width;
|
|
qreal log_height;
|
|
QFixed x_offset;
|
|
QFixed y_offset;
|
|
};
|
|
|
|
struct QGLFontTexture {
|
|
int x_offset; // glyph offset within the
|
|
int y_offset;
|
|
GLuint texture;
|
|
int width;
|
|
int height;
|
|
};
|
|
|
|
typedef QHash<glyph_t, QGLGlyphCoord*> QGLGlyphHash;
|
|
typedef QHash<QFontEngine*, QGLGlyphHash*> QGLFontGlyphHash;
|
|
typedef QHash<quint64, QGLFontTexture*> QGLFontTexHash;
|
|
typedef QHash<const QGLContext*, QGLFontGlyphHash*> QGLContextHash;
|
|
|
|
static inline void qt_delete_glyph_hash(QGLGlyphHash *hash)
|
|
{
|
|
qDeleteAll(*hash);
|
|
delete hash;
|
|
}
|
|
|
|
class QGLGlyphCache : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QGLGlyphCache() : QObject(0) { current_cache = 0; }
|
|
~QGLGlyphCache();
|
|
QGLGlyphCoord *lookup(QFontEngine *, glyph_t);
|
|
void cacheGlyphs(QGLContext *, QFontEngine *, glyph_t *glyphs, int numGlyphs);
|
|
void cleanCache();
|
|
void allocTexture(int width, int height, GLuint texture);
|
|
|
|
public slots:
|
|
void cleanupContext(const QGLContext *);
|
|
void fontEngineDestroyed(QObject *);
|
|
void widgetDestroyed(QObject *);
|
|
|
|
protected:
|
|
QGLGlyphHash *current_cache;
|
|
QGLFontTexHash qt_font_textures;
|
|
QGLContextHash qt_context_cache;
|
|
};
|
|
|
|
QGLGlyphCache::~QGLGlyphCache()
|
|
{
|
|
// qDebug() << "cleaning out the QGLGlyphCache";
|
|
cleanCache();
|
|
}
|
|
|
|
void QGLGlyphCache::fontEngineDestroyed(QObject *o)
|
|
{
|
|
// qDebug() << "fontEngineDestroyed()";
|
|
QFontEngine *fe = static_cast<QFontEngine *>(o); // safe, since only the type is used
|
|
QList<const QGLContext *> keys = qt_context_cache.keys();
|
|
const QGLContext *ctx = 0;
|
|
|
|
for (int i=0; i < keys.size(); ++i) {
|
|
QGLFontGlyphHash *font_cache = qt_context_cache.value(keys.at(i));
|
|
if (font_cache->find(fe) != font_cache->end()) {
|
|
ctx = keys.at(i);
|
|
QGLGlyphHash *cache = font_cache->take(fe);
|
|
qt_delete_glyph_hash(cache);
|
|
break;
|
|
}
|
|
}
|
|
|
|
quint64 font_key = (reinterpret_cast<quint64>(ctx) << 32) | reinterpret_cast<quint64>(fe);
|
|
QGLFontTexture *tex = qt_font_textures.take(font_key);
|
|
if (tex) {
|
|
#ifdef Q_WS_MAC
|
|
if (
|
|
# ifndef QT_MAC_USE_COCOA
|
|
aglGetCurrentContext() != 0
|
|
# else
|
|
qt_current_nsopengl_context() != 0
|
|
# endif
|
|
)
|
|
#endif
|
|
glDeleteTextures(1, &tex->texture);
|
|
delete tex;
|
|
}
|
|
}
|
|
|
|
void QGLGlyphCache::widgetDestroyed(QObject *)
|
|
{
|
|
// qDebug() << "widget destroyed";
|
|
cleanCache(); // ###
|
|
}
|
|
|
|
void QGLGlyphCache::cleanupContext(const QGLContext *ctx)
|
|
{
|
|
// qDebug() << "==> cleaning for: " << hex << ctx;
|
|
QGLFontGlyphHash *font_cache = qt_context_cache.take(ctx);
|
|
|
|
if (font_cache) {
|
|
QList<QFontEngine *> keys = font_cache->keys();
|
|
for (int i=0; i < keys.size(); ++i) {
|
|
QFontEngine *fe = keys.at(i);
|
|
qt_delete_glyph_hash(font_cache->take(fe));
|
|
quint64 font_key = (reinterpret_cast<quint64>(ctx) << 32) | reinterpret_cast<quint64>(fe);
|
|
QGLFontTexture *font_tex = qt_font_textures.take(font_key);
|
|
if (font_tex) {
|
|
#ifdef Q_WS_MAC
|
|
if (
|
|
# ifndef QT_MAC_USE_COCOA
|
|
aglGetCurrentContext() == 0
|
|
# else
|
|
qt_current_nsopengl_context() != 0
|
|
# endif
|
|
)
|
|
#endif
|
|
glDeleteTextures(1, &font_tex->texture);
|
|
delete font_tex;
|
|
}
|
|
}
|
|
delete font_cache;
|
|
}
|
|
// qDebug() << "<=== done cleaning, num tex:" << qt_font_textures.size() << "num ctx:" << qt_context_cache.size();
|
|
}
|
|
|
|
void QGLGlyphCache::cleanCache()
|
|
{
|
|
QGLFontTexHash::const_iterator it = qt_font_textures.constBegin();
|
|
if (QGLContext::currentContext()) {
|
|
while (it != qt_font_textures.constEnd()) {
|
|
#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
|
|
if (qt_current_nsopengl_context() == 0)
|
|
break;
|
|
#endif
|
|
glDeleteTextures(1, &it.value()->texture);
|
|
++it;
|
|
}
|
|
}
|
|
qDeleteAll(qt_font_textures);
|
|
qt_font_textures.clear();
|
|
|
|
QList<const QGLContext *> keys = qt_context_cache.keys();
|
|
for (int i=0; i < keys.size(); ++i) {
|
|
QGLFontGlyphHash *font_cache = qt_context_cache.value(keys.at(i));
|
|
QGLFontGlyphHash::Iterator it = font_cache->begin();
|
|
for (; it != font_cache->end(); ++it)
|
|
qt_delete_glyph_hash(it.value());
|
|
font_cache->clear();
|
|
}
|
|
qDeleteAll(qt_context_cache);
|
|
qt_context_cache.clear();
|
|
}
|
|
|
|
void QGLGlyphCache::allocTexture(int width, int height, GLuint texture)
|
|
{
|
|
uchar *tex_data = (uchar *) malloc(width*height*2);
|
|
memset(tex_data, 0, width*height*2);
|
|
glBindTexture(GL_TEXTURE_2D, texture);
|
|
#ifndef QT_OPENGL_ES
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8,
|
|
width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
|
|
#else
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
|
|
width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
|
|
#endif
|
|
free(tex_data);
|
|
}
|
|
|
|
#if 0
|
|
// useful for debugging the glyph cache
|
|
static QImage getCurrentTexture(const QColor &color, QGLFontTexture *font_tex)
|
|
{
|
|
ushort *old_tex_data = (ushort *) malloc(font_tex->width*font_tex->height*2);
|
|
glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
|
|
QImage im(font_tex->width, font_tex->height, QImage::Format_ARGB32);
|
|
for (int y=0; y<font_tex->height; ++y) {
|
|
for (int x=0; x<font_tex->width; ++x) {
|
|
im.setPixel(x, y, ((*(old_tex_data+x+y*font_tex->width)) << 24) | (0x00ffffff & color.rgb()));
|
|
}
|
|
}
|
|
delete old_tex_data;
|
|
return im;
|
|
}
|
|
#endif
|
|
|
|
void QGLGlyphCache::cacheGlyphs(QGLContext *context, QFontEngine *fontEngine,
|
|
glyph_t *glyphs, int numGlyphs)
|
|
{
|
|
QGLContextHash::const_iterator dev_it = qt_context_cache.constFind(context);
|
|
QGLFontGlyphHash *font_cache = 0;
|
|
const QGLContext *context_key = 0;
|
|
|
|
if (dev_it == qt_context_cache.constEnd()) {
|
|
// check for shared contexts
|
|
QList<const QGLContext *> contexts = qt_context_cache.keys();
|
|
for (int i=0; i<contexts.size(); ++i) {
|
|
const QGLContext *ctx = contexts.at(i);
|
|
if (ctx != context && QGLContext::areSharing(context, ctx)) {
|
|
context_key = ctx;
|
|
dev_it = qt_context_cache.constFind(context_key);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dev_it == qt_context_cache.constEnd()) {
|
|
// no shared contexts either - create a new entry
|
|
font_cache = new QGLFontGlyphHash;
|
|
// qDebug() << "new context" << context << font_cache;
|
|
qt_context_cache.insert(context, font_cache);
|
|
if (context->isValid()) {
|
|
if (context->device() && context->device()->devType() == QInternal::Widget) {
|
|
QWidget *widget = static_cast<QWidget *>(context->device());
|
|
connect(widget, SIGNAL(destroyed(QObject*)), SLOT(widgetDestroyed(QObject*)));
|
|
}
|
|
connect(QGLSignalProxy::instance(),
|
|
SIGNAL(aboutToDestroyContext(const QGLContext*)),
|
|
SLOT(cleanupContext(const QGLContext*)));
|
|
}
|
|
} else {
|
|
font_cache = dev_it.value();
|
|
}
|
|
Q_ASSERT(font_cache != 0);
|
|
|
|
QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(fontEngine);
|
|
QGLGlyphHash *cache = 0;
|
|
if (cache_it == font_cache->constEnd()) {
|
|
cache = new QGLGlyphHash;
|
|
font_cache->insert(fontEngine, cache);
|
|
connect(fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
|
|
} else {
|
|
cache = cache_it.value();
|
|
}
|
|
current_cache = cache;
|
|
|
|
quint64 font_key = (reinterpret_cast<quint64>(context_key ? context_key : context) << 32)
|
|
| reinterpret_cast<quint64>(fontEngine);
|
|
QGLFontTexHash::const_iterator it = qt_font_textures.constFind(font_key);
|
|
QGLFontTexture *font_tex;
|
|
if (it == qt_font_textures.constEnd()) {
|
|
GLuint font_texture;
|
|
glGenTextures(1, &font_texture);
|
|
GLint tex_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
|
|
GLint tex_width = qt_next_power_of_two(tex_height*30); // ###
|
|
GLint max_tex_size;
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
|
|
Q_ASSERT(max_tex_size > 0);
|
|
if (tex_width > max_tex_size)
|
|
tex_width = max_tex_size;
|
|
allocTexture(tex_width, tex_height, font_texture);
|
|
font_tex = new QGLFontTexture;
|
|
font_tex->texture = font_texture;
|
|
font_tex->x_offset = x_margin;
|
|
font_tex->y_offset = y_margin;
|
|
font_tex->width = tex_width;
|
|
font_tex->height = tex_height;
|
|
// qDebug() << "new font tex - width:" << tex_width << "height:"<< tex_height
|
|
// << hex << "tex id:" << font_tex->texture << "key:" << font_key << "num cached:" << qt_font_textures.size();
|
|
qt_font_textures.insert(font_key, font_tex);
|
|
} else {
|
|
font_tex = it.value();
|
|
glBindTexture(GL_TEXTURE_2D, font_tex->texture);
|
|
}
|
|
|
|
for (int i=0; i< numGlyphs; ++i) {
|
|
QGLGlyphHash::const_iterator it = cache->constFind(glyphs[i]);
|
|
if (it == cache->constEnd()) {
|
|
// render new glyph and put it in the cache
|
|
glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[i]);
|
|
int glyph_width = qRound(metrics.width.toReal())+2;
|
|
int glyph_height = qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2;
|
|
|
|
if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
|
|
int strip_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
|
|
font_tex->x_offset = x_margin;
|
|
font_tex->y_offset += strip_height;
|
|
if (font_tex->y_offset >= font_tex->height) {
|
|
// get hold of the old font texture
|
|
uchar *old_tex_data = (uchar *) malloc(font_tex->width*font_tex->height*2);
|
|
int old_tex_height = font_tex->height;
|
|
#ifndef QT_OPENGL_ES
|
|
glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
|
|
#endif
|
|
|
|
// realloc a larger texture
|
|
glDeleteTextures(1, &font_tex->texture);
|
|
glGenTextures(1, &font_tex->texture);
|
|
font_tex->height = qt_next_power_of_two(font_tex->height + strip_height);
|
|
allocTexture(font_tex->width, font_tex->height, font_tex->texture);
|
|
|
|
// write back the old texture data
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, font_tex->width, old_tex_height,
|
|
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
|
|
free(old_tex_data);
|
|
|
|
// update the texture coords and the y offset for the existing glyphs in
|
|
// the cache, because of the texture size change
|
|
QGLGlyphHash::iterator it = cache->begin();
|
|
while (it != cache->end()) {
|
|
it.value()->height = (it.value()->height * old_tex_height) / font_tex->height;
|
|
it.value()->y = (it.value()->y * old_tex_height) / font_tex->height;
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
QImage glyph_im(fontEngine->alphaMapForGlyph(glyphs[i]));
|
|
glyph_width = glyph_im.width();
|
|
Q_ASSERT(glyph_width >= 0);
|
|
// pad the glyph width to an even number
|
|
if (glyph_width%2 != 0)
|
|
++glyph_width;
|
|
|
|
QGLGlyphCoord *qgl_glyph = new QGLGlyphCoord;
|
|
qgl_glyph->x = qreal(font_tex->x_offset) / font_tex->width;
|
|
qgl_glyph->y = qreal(font_tex->y_offset) / font_tex->height;
|
|
qgl_glyph->width = qreal(glyph_width) / font_tex->width;
|
|
qgl_glyph->height = qreal(glyph_height) / font_tex->height;
|
|
qgl_glyph->log_width = qreal(glyph_width);
|
|
qgl_glyph->log_height = qgl_glyph->height * font_tex->height;
|
|
#ifdef Q_WS_MAC
|
|
qgl_glyph->x_offset = -metrics.x + 1;
|
|
qgl_glyph->y_offset = metrics.y - 2;
|
|
#else
|
|
qgl_glyph->x_offset = -metrics.x;
|
|
qgl_glyph->y_offset = metrics.y;
|
|
#endif
|
|
|
|
if (!glyph_im.isNull()) {
|
|
int idx = 0;
|
|
uchar *tex_data = (uchar *) malloc(glyph_width*glyph_im.height()*2);
|
|
memset(tex_data, 0, glyph_width*glyph_im.height()*2);
|
|
|
|
bool is8BitGray = false;
|
|
#ifdef Q_WS_QPA
|
|
if (glyph_im.format() == QImage::Format_Indexed8) {
|
|
is8BitGray = true;
|
|
}
|
|
#endif
|
|
glyph_im = glyph_im.convertToFormat(QImage::Format_Indexed8);
|
|
for (int y=0; y<glyph_im.height(); ++y) {
|
|
uchar *s = (uchar *) glyph_im.scanLine(y);
|
|
for (int x=0; x<glyph_im.width(); ++x) {
|
|
uchar alpha = is8BitGray ? *s : qAlpha(glyph_im.color(*s));
|
|
tex_data[idx] = alpha;
|
|
tex_data[idx+1] = alpha;
|
|
++s;
|
|
idx += 2;
|
|
}
|
|
if (glyph_im.width()%2 != 0)
|
|
idx += 2;
|
|
}
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, font_tex->x_offset, font_tex->y_offset,
|
|
glyph_width, glyph_im.height(),
|
|
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
|
|
free(tex_data);
|
|
}
|
|
if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
|
|
font_tex->x_offset = x_margin;
|
|
font_tex->y_offset += glyph_height + y_margin;
|
|
} else {
|
|
font_tex->x_offset += glyph_width + x_margin;
|
|
}
|
|
|
|
cache->insert(glyphs[i], qgl_glyph);
|
|
}
|
|
}
|
|
}
|
|
|
|
QGLGlyphCoord *QGLGlyphCache::lookup(QFontEngine *, glyph_t g)
|
|
{
|
|
Q_ASSERT(current_cache != 0);
|
|
// ### careful here
|
|
QGLGlyphHash::const_iterator it = current_cache->constFind(g);
|
|
if (it == current_cache->constEnd())
|
|
return 0;
|
|
else
|
|
return it.value();
|
|
}
|
|
|
|
Q_GLOBAL_STATIC(QGLGlyphCache, qt_glyph_cache)
|
|
|
|
//
|
|
// assumption: the context that this is called for has to be the
|
|
// current context
|
|
//
|
|
void qgl_cleanup_glyph_cache(QGLContext *ctx)
|
|
{
|
|
qt_glyph_cache()->cleanupContext(ctx);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
d->flushDrawQueue();
|
|
|
|
// make sure the glyphs we want to draw are in the cache
|
|
qt_glyph_cache()->cacheGlyphs(d->device->context(), textItem->fontEngine(), textItem->glyphs,
|
|
textItem->numGlyphs);
|
|
|
|
d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
|
|
qt_glColor4ubv(d->pen_color);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
#ifdef Q_WS_QWS
|
|
// XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
|
|
// text rendering to update the alpha in the window surface.
|
|
// XXX: This may not be needed as this behavior does seem to be caused by driver bug
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
|
|
#endif
|
|
|
|
// do the actual drawing
|
|
GLfloat vertexArray[4*2];
|
|
GLfloat texCoordArray[4*2];
|
|
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
bool antialias = !(textItem->fontEngine()->fontDef.styleStrategy & QFont::NoAntialias)
|
|
&& (d->matrix.type() > QTransform::TxTranslate);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
|
|
|
|
for (int i=0; i< textItem->numGlyphs; ++i) {
|
|
QGLGlyphCoord *g = qt_glyph_cache()->lookup(textItem->fontEngine(), textItem->glyphs[i]);
|
|
|
|
// we don't cache glyphs with no width/height
|
|
if (!g)
|
|
continue;
|
|
|
|
qreal x1, x2, y1, y2;
|
|
x1 = g->x;
|
|
y1 = g->y;
|
|
x2 = x1 + g->width;
|
|
y2 = y1 + g->height;
|
|
|
|
QPointF logical_pos((textItem->glyphPositions[i].x - g->x_offset).toReal(),
|
|
(textItem->glyphPositions[i].y + g->y_offset).toReal());
|
|
|
|
qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
|
|
qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
|
|
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
}
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
#ifdef Q_WS_QWS
|
|
// XXX: This may not be needed as this behavior does seem to be caused by driver bug
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
#endif
|
|
|
|
}
|
|
|
|
void QOpenGLPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
|
|
|
|
// fall back to drawing a polygon if the scale factor is large, or
|
|
// we use a gradient pen
|
|
if ((d->matrix.det() > 1) || (d->pen_brush_style >= Qt::LinearGradientPattern
|
|
&& d->pen_brush_style <= Qt::ConicalGradientPattern)) {
|
|
QPaintEngine::drawTextItem(p, textItem);
|
|
return;
|
|
}
|
|
|
|
// add the glyphs used to the glyph texture cache
|
|
QVarLengthArray<QFixedPoint> positions;
|
|
QVarLengthArray<glyph_t> glyphs;
|
|
QTransform matrix = QTransform::fromTranslate(qRound(p.x()), qRound(p.y()));
|
|
ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
|
|
|
|
{
|
|
QStaticTextItem staticTextItem;
|
|
staticTextItem.chars = const_cast<QChar *>(ti.chars);
|
|
staticTextItem.setFontEngine(ti.fontEngine);
|
|
staticTextItem.glyphs = glyphs.data();
|
|
staticTextItem.numChars = ti.num_chars;
|
|
staticTextItem.numGlyphs = glyphs.size();
|
|
staticTextItem.glyphPositions = positions.data();
|
|
drawStaticTextItem(&staticTextItem);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEngine::drawEllipse(const QRectF &rect)
|
|
{
|
|
#ifndef Q_WS_QWS
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (d->use_emulation) {
|
|
QPaintEngineEx::drawEllipse(rect);
|
|
return;
|
|
}
|
|
|
|
if (d->high_quality_antialiasing) {
|
|
if (d->has_brush) {
|
|
d->disableClipping();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
|
|
FRAGMENT_PROGRAM_MASK_ELLIPSE_AA, 0, true);
|
|
QGLEllipseMaskGenerator maskGenerator(rect,
|
|
d->matrix,
|
|
d->offscreen,
|
|
program,
|
|
mask_variable_locations[FRAGMENT_PROGRAM_MASK_ELLIPSE_AA]);
|
|
|
|
d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
|
|
|
|
d->enableClipping();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
}
|
|
|
|
if (d->has_pen) {
|
|
QPainterPath path;
|
|
path.addEllipse(rect);
|
|
|
|
d->strokePath(path, false);
|
|
}
|
|
} else {
|
|
DEBUG_ONCE_STR("QOpenGLPaintEngine::drawEllipse(): falling back to drawPath()");
|
|
|
|
QPainterPath path;
|
|
path.addEllipse(rect);
|
|
drawPath(path);
|
|
}
|
|
#else
|
|
QPaintEngineEx::drawEllipse(rect);
|
|
#endif
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::updateFragmentProgramData(int locations[])
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
Q_UNUSED(locations);
|
|
#else
|
|
QGL_FUNC_CONTEXT;
|
|
|
|
QSize sz = offscreen.offscreenSize();
|
|
|
|
float inv_mask_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
|
|
|
|
sz = drawable_texture_size;
|
|
|
|
float inv_dst_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
|
|
|
|
// default inv size 0.125f == 1.0f / 8.0f for pattern brushes
|
|
float inv_brush_texture_size_data[4] = { 0.125f, 0.125f };
|
|
|
|
// texture patterns have their own size
|
|
if (current_style == Qt::TexturePattern) {
|
|
QSize sz = cbrush.texture().size();
|
|
|
|
inv_brush_texture_size_data[0] = 1.0f / sz.width();
|
|
inv_brush_texture_size_data[1] = 1.0f / sz.height();
|
|
}
|
|
|
|
for (unsigned int i = 0; i < num_fragment_variables; ++i) {
|
|
int location = locations[i];
|
|
|
|
if (location < 0)
|
|
continue;
|
|
|
|
switch (i) {
|
|
case VAR_ANGLE:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, angle_data);
|
|
break;
|
|
case VAR_LINEAR:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, linear_data);
|
|
break;
|
|
case VAR_FMP:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp_data);
|
|
break;
|
|
case VAR_FMP2_M_RADIUS2:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp2_m_radius2_data);
|
|
break;
|
|
case VAR_INV_MASK_SIZE:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_mask_size_data);
|
|
break;
|
|
case VAR_INV_DST_SIZE:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_dst_size_data);
|
|
break;
|
|
case VAR_INV_MATRIX_M0:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[0]);
|
|
break;
|
|
case VAR_INV_MATRIX_M1:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[1]);
|
|
break;
|
|
case VAR_INV_MATRIX_M2:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[2]);
|
|
break;
|
|
case VAR_PORTERDUFF_AB:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_ab_data);
|
|
break;
|
|
case VAR_PORTERDUFF_XYZ:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_xyz_data);
|
|
break;
|
|
case VAR_INV_BRUSH_TEXTURE_SIZE:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_brush_texture_size_data);
|
|
break;
|
|
case VAR_MASK_OFFSET:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_offset_data);
|
|
break;
|
|
case VAR_MASK_CHANNEL:
|
|
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_channel_data);
|
|
break;
|
|
case VAR_DST_TEXTURE:
|
|
case VAR_MASK_TEXTURE:
|
|
case VAR_PALETTE:
|
|
case VAR_BRUSH_TEXTURE:
|
|
// texture variables, not handled here
|
|
break;
|
|
default:
|
|
qDebug() << "QOpenGLPaintEnginePrivate: Unhandled fragment variable:" << i;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::copyDrawable(const QRectF &rect)
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
Q_UNUSED(rect);
|
|
#else
|
|
ensureDrawableTexture();
|
|
|
|
DEBUG_ONCE qDebug() << "Refreshing drawable_texture for rectangle" << rect;
|
|
QRectF screen_rect = rect.adjusted(-1, -1, 1, 1);
|
|
|
|
int left = qMax(0, static_cast<int>(screen_rect.left()));
|
|
int width = qMin(device->size().width() - left, static_cast<int>(screen_rect.width()) + 1);
|
|
|
|
int bottom = qMax(0, static_cast<int>(device->size().height() - screen_rect.bottom()));
|
|
int height = qMin(device->size().height() - bottom, static_cast<int>(screen_rect.height()) + 1);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, drawable_texture);
|
|
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, left, bottom, left, bottom, width, height);
|
|
#endif
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::composite(const QRectF &rect, const QPoint &maskOffset)
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
Q_UNUSED(rect);
|
|
Q_UNUSED(maskOffset);
|
|
#else
|
|
GLfloat vertexArray[8];
|
|
qt_add_rect_to_array(rect, vertexArray);
|
|
|
|
composite(GL_TRIANGLE_FAN, vertexArray, 4, maskOffset);
|
|
#endif
|
|
}
|
|
|
|
|
|
void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset)
|
|
{
|
|
#ifdef QT_OPENGL_ES
|
|
Q_UNUSED(primitive);
|
|
Q_UNUSED(vertexArray);
|
|
Q_UNUSED(vertexCount);
|
|
Q_UNUSED(maskOffset);
|
|
#else
|
|
Q_Q(QOpenGLPaintEngine);
|
|
QGL_FUNC_CONTEXT;
|
|
|
|
if (current_style == Qt::NoBrush)
|
|
return;
|
|
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Using compositing program: fragment_brush ="
|
|
<< fragment_brush << ", fragment_composition_mode =" << fragment_composition_mode;
|
|
|
|
if (has_fast_composition_mode)
|
|
q->updateCompositionMode(composition_mode);
|
|
else {
|
|
qreal minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
|
|
|
|
for (int i = 0; i < vertexCount; ++i) {
|
|
qreal x = vertexArray[2 * i];
|
|
qreal y = vertexArray[2 * i + 1];
|
|
|
|
qreal tx, ty;
|
|
matrix.map(x, y, &tx, &ty);
|
|
|
|
minX = qMin(minX, tx);
|
|
minY = qMin(minY, ty);
|
|
maxX = qMax(maxX, tx);
|
|
maxY = qMax(maxY, ty);
|
|
}
|
|
|
|
QRectF r(minX, minY, maxX - minX, maxY - minY);
|
|
copyDrawable(r);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
}
|
|
|
|
int *locations = painter_variable_locations[fragment_brush][fragment_composition_mode];
|
|
|
|
int texture_locations[] = { locations[VAR_DST_TEXTURE],
|
|
locations[VAR_MASK_TEXTURE],
|
|
locations[VAR_PALETTE] };
|
|
|
|
int brush_texture_location = locations[VAR_BRUSH_TEXTURE];
|
|
|
|
GLuint texture_targets[] = { GL_TEXTURE_2D,
|
|
GL_TEXTURE_2D,
|
|
GL_TEXTURE_1D };
|
|
|
|
GLuint textures[] = { drawable_texture,
|
|
offscreen.offscreenTexture(),
|
|
grad_palette };
|
|
|
|
const int num_textures = sizeof(textures) / sizeof(*textures);
|
|
|
|
Q_ASSERT(num_textures == sizeof(texture_locations) / sizeof(*texture_locations));
|
|
Q_ASSERT(num_textures == sizeof(texture_targets) / sizeof(*texture_targets));
|
|
|
|
for (int i = 0; i < num_textures; ++i)
|
|
if (texture_locations[i] >= 0) {
|
|
glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
|
|
glBindTexture(texture_targets[i], textures[i]);
|
|
}
|
|
|
|
if (brush_texture_location >= 0) {
|
|
glActiveTexture(GL_TEXTURE0 + brush_texture_location);
|
|
|
|
if (current_style == Qt::TexturePattern)
|
|
device->context()->d_func()->bindTexture(cbrush.textureImage(), GL_TEXTURE_2D, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
else
|
|
device->context()->d_func()->bindTexture(qt_imageForBrush(current_style, false),
|
|
GL_TEXTURE_2D, GL_RGBA,
|
|
QGLContext::InternalBindOption);
|
|
|
|
updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, use_smooth_pixmap_transform);
|
|
}
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
|
|
glEnable(GL_FRAGMENT_PROGRAM_ARB);
|
|
GLuint program = qt_gl_program_cache()->getProgram(device->context(),
|
|
fragment_brush,
|
|
fragment_composition_mode, false);
|
|
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program);
|
|
|
|
mask_offset_data[0] = maskOffset.x();
|
|
mask_offset_data[1] = -maskOffset.y();
|
|
|
|
updateFragmentProgramData(locations);
|
|
|
|
glDrawArrays(primitive, 0, vertexCount);
|
|
|
|
glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
for (int i = 0; i < num_textures; ++i)
|
|
if (texture_locations[i] >= 0) {
|
|
glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
|
|
glBindTexture(texture_targets[i], 0);
|
|
}
|
|
|
|
if (brush_texture_location >= 0) {
|
|
glActiveTexture(GL_TEXTURE0 + brush_texture_location);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
if (!has_fast_composition_mode)
|
|
q->updateCompositionMode(composition_mode);
|
|
#endif
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::cacheItemErased(int channel, const QRect &rect)
|
|
{
|
|
bool isInDrawQueue = false;
|
|
|
|
foreach (const QDrawQueueItem &item, drawQueue) {
|
|
if (item.location.channel == channel && item.location.rect == rect) {
|
|
isInDrawQueue = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isInDrawQueue)
|
|
flushDrawQueue();
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::addItem(const QGLMaskTextureCache::CacheLocation &location)
|
|
{
|
|
drawQueue << QDrawQueueItem(opacity, cbrush, brush_origin, composition_mode, matrix, location);
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::drawItem(const QDrawQueueItem &item)
|
|
{
|
|
Q_Q(QOpenGLPaintEngine);
|
|
|
|
opacity = item.opacity;
|
|
brush_origin = item.brush_origin;
|
|
q->updateCompositionMode(item.composition_mode);
|
|
matrix = item.matrix;
|
|
cbrush = item.brush;
|
|
brush_style = item.brush.style();
|
|
|
|
mask_channel_data[0] = item.location.channel == 0;
|
|
mask_channel_data[1] = item.location.channel == 1;
|
|
mask_channel_data[2] = item.location.channel == 2;
|
|
mask_channel_data[3] = item.location.channel == 3;
|
|
|
|
setGradientOps(item.brush, item.location.screen_rect);
|
|
|
|
composite(item.location.screen_rect, item.location.rect.topLeft() - item.location.screen_rect.topLeft()
|
|
- QPoint(0, offscreen.offscreenSize().height() - device->size().height()));
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::flushDrawQueue()
|
|
{
|
|
#ifndef QT_OPENGL_ES
|
|
Q_Q(QOpenGLPaintEngine);
|
|
|
|
offscreen.release();
|
|
|
|
if (!drawQueue.isEmpty()) {
|
|
DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::flushDrawQueue():" << drawQueue.size() << "items";
|
|
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
qreal old_opacity = opacity;
|
|
QPointF old_brush_origin = brush_origin;
|
|
QPainter::CompositionMode old_composition_mode = composition_mode;
|
|
QTransform old_matrix = matrix;
|
|
QBrush old_brush = cbrush;
|
|
|
|
bool hqaa_old = high_quality_antialiasing;
|
|
|
|
high_quality_antialiasing = true;
|
|
|
|
foreach (const QDrawQueueItem &item, drawQueue)
|
|
drawItem(item);
|
|
|
|
opacity = old_opacity;
|
|
brush_origin = old_brush_origin;
|
|
q->updateCompositionMode(old_composition_mode);
|
|
matrix = old_matrix;
|
|
cbrush = old_brush;
|
|
brush_style = old_brush.style();
|
|
|
|
high_quality_antialiasing = hqaa_old;
|
|
|
|
setGLBrush(old_brush.color());
|
|
qt_glColor4ubv(brush_color);
|
|
|
|
drawQueue.clear();
|
|
|
|
glPopMatrix();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void QOpenGLPaintEngine::clipEnabledChanged()
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
d->updateDepthClip();
|
|
}
|
|
|
|
void QOpenGLPaintEngine::penChanged()
|
|
{
|
|
updatePen(state()->pen);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::brushChanged()
|
|
{
|
|
updateBrush(state()->brush, state()->brushOrigin);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::brushOriginChanged()
|
|
{
|
|
updateBrush(state()->brush, state()->brushOrigin);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::opacityChanged()
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
QPainterState *s = state();
|
|
d->opacity = s->opacity;
|
|
updateBrush(s->brush, s->brushOrigin);
|
|
updatePen(s->pen);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::compositionModeChanged()
|
|
{
|
|
updateCompositionMode(state()->composition_mode);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::renderHintsChanged()
|
|
{
|
|
updateRenderHints(state()->renderHints);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::transformChanged()
|
|
{
|
|
updateMatrix(state()->matrix);
|
|
}
|
|
|
|
extern QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path);
|
|
|
|
void QOpenGLPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
|
|
if (brush.style() == Qt::NoBrush)
|
|
return;
|
|
|
|
if ((!d->use_fragment_programs && needsEmulation(brush.style())) || qt_isExtendedRadialGradient(brush)) {
|
|
QPainter *p = painter();
|
|
QBrush oldBrush = p->brush();
|
|
p->setBrush(brush);
|
|
qt_draw_helper(p->d_ptr.data(), qt_painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
|
|
p->setBrush(oldBrush);
|
|
return;
|
|
}
|
|
|
|
QBrush old_brush = state()->brush;
|
|
updateBrush(brush, state()->brushOrigin);
|
|
|
|
const qreal *points = path.points();
|
|
const QPainterPath::ElementType *types = path.elements();
|
|
if (!types && path.shape() == QVectorPath::RectangleHint) {
|
|
QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
|
|
QPen old_pen = state()->pen;
|
|
updatePen(Qt::NoPen);
|
|
drawRects(&r, 1);
|
|
updatePen(old_pen);
|
|
} else {
|
|
d->fillPath(qt_painterPathFromVectorPath(path));
|
|
}
|
|
|
|
updateBrush(old_brush, state()->brushOrigin);
|
|
}
|
|
|
|
template <typename T> static inline bool isRect(const T *pts, int elementCount) {
|
|
return (elementCount == 5 // 5-point polygon, check for closed rect
|
|
&& pts[0] == pts[8] && pts[1] == pts[9] // last point == first point
|
|
&& pts[0] == pts[6] && pts[2] == pts[4] // x values equal
|
|
&& pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
|
|
) ||
|
|
(elementCount == 4 // 4-point polygon, check for unclosed rect
|
|
&& pts[0] == pts[6] && pts[2] == pts[4] // x values equal
|
|
&& pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
|
|
);
|
|
}
|
|
|
|
void QOpenGLPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
|
|
{
|
|
const qreal *points = path.points();
|
|
const QPainterPath::ElementType *types = path.elements();
|
|
if (!types && path.shape() == QVectorPath::RectangleHint) {
|
|
QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
|
|
updateClipRegion(QRegion(r.toRect()), op);
|
|
return;
|
|
}
|
|
|
|
QPainterPath p;
|
|
if (types) {
|
|
int id = 0;
|
|
for (int i=0; i<path.elementCount(); ++i) {
|
|
switch(types[i]) {
|
|
case QPainterPath::MoveToElement:
|
|
p.moveTo(QPointF(points[id], points[id+1]));
|
|
id+=2;
|
|
break;
|
|
case QPainterPath::LineToElement:
|
|
p.lineTo(QPointF(points[id], points[id+1]));
|
|
id+=2;
|
|
break;
|
|
case QPainterPath::CurveToElement: {
|
|
QPointF p1(points[id], points[id+1]);
|
|
QPointF p2(points[id+2], points[id+3]);
|
|
QPointF p3(points[id+4], points[id+5]);
|
|
p.cubicTo(p1, p2, p3);
|
|
id+=6;
|
|
break;
|
|
}
|
|
case QPainterPath::CurveToDataElement:
|
|
;
|
|
break;
|
|
}
|
|
}
|
|
} else if (!path.isEmpty()) {
|
|
p.moveTo(QPointF(points[0], points[1]));
|
|
int id = 2;
|
|
for (int i=1; i<path.elementCount(); ++i) {
|
|
p.lineTo(QPointF(points[id], points[id+1]));
|
|
id+=2;
|
|
}
|
|
}
|
|
if (path.hints() & QVectorPath::WindingFill)
|
|
p.setFillRule(Qt::WindingFill);
|
|
|
|
updateClipRegion(QRegion(p.toFillPolygon().toPolygon(), p.fillRule()), op);
|
|
return;
|
|
}
|
|
|
|
void QOpenGLPaintEngine::setState(QPainterState *s)
|
|
{
|
|
Q_D(QOpenGLPaintEngine);
|
|
QOpenGLPaintEngineState *new_state = static_cast<QOpenGLPaintEngineState *>(s);
|
|
QOpenGLPaintEngineState *old_state = state();
|
|
|
|
QPaintEngineEx::setState(s);
|
|
|
|
// are we in a save() ?
|
|
if (s == d->last_created_state) {
|
|
d->last_created_state = 0;
|
|
return;
|
|
}
|
|
|
|
if (isActive()) {
|
|
if (old_state->depthClipId != new_state->depthClipId)
|
|
d->updateDepthClip();
|
|
penChanged();
|
|
brushChanged();
|
|
opacityChanged();
|
|
compositionModeChanged();
|
|
renderHintsChanged();
|
|
transformChanged();
|
|
}
|
|
}
|
|
|
|
QPainterState *QOpenGLPaintEngine::createState(QPainterState *orig) const
|
|
{
|
|
const Q_D(QOpenGLPaintEngine);
|
|
|
|
QOpenGLPaintEngineState *s;
|
|
if (!orig)
|
|
s = new QOpenGLPaintEngineState();
|
|
else
|
|
s = new QOpenGLPaintEngineState(*static_cast<QOpenGLPaintEngineState *>(orig));
|
|
|
|
d->last_created_state = s;
|
|
return s;
|
|
}
|
|
|
|
//
|
|
// QOpenGLPaintEngineState
|
|
//
|
|
|
|
QOpenGLPaintEngineState::QOpenGLPaintEngineState(QOpenGLPaintEngineState &other)
|
|
: QPainterState(other)
|
|
{
|
|
clipRegion = other.clipRegion;
|
|
hasClipping = other.hasClipping;
|
|
fastClip = other.fastClip;
|
|
depthClipId = other.depthClipId;
|
|
}
|
|
|
|
QOpenGLPaintEngineState::QOpenGLPaintEngineState()
|
|
{
|
|
hasClipping = false;
|
|
depthClipId = 0;
|
|
}
|
|
|
|
QOpenGLPaintEngineState::~QOpenGLPaintEngineState()
|
|
{
|
|
}
|
|
|
|
void QOpenGLPaintEnginePrivate::ensureDrawableTexture()
|
|
{
|
|
if (!dirty_drawable_texture)
|
|
return;
|
|
|
|
dirty_drawable_texture = false;
|
|
|
|
#ifndef QT_OPENGL_ES
|
|
glGenTextures(1, &drawable_texture);
|
|
glBindTexture(GL_TEXTURE_2D, drawable_texture);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
|
|
drawable_texture_size.width(),
|
|
drawable_texture_size.height(), 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
#endif
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#include "qpaintengine_opengl.moc"
|