archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
74df307ca43df14b759fd9eb6a049a6c5d90dcda
blender-archive/source/blender/windowmanager/intern/wm_draw.c

908 lines
24 KiB
C
Raw Normal View History

doxygen: prevent GPL license block from being parsed as doxygen comment.
2011-02-23 10:52:22 +00:00
/*
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
correct fsf address
2010-02-12 13:34:04 +00:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
doxygen: blender/windowmanager tagged.
2011-02-25 14:04:21 +00:00
/** \file blender/windowmanager/intern/wm_draw.c
* \ingroup wm
Docs: doxygen file descriptions for BLF, GPU and WM
2014-01-19 23:14:24 +11:00
*
* Handle OpenGL buffers for windowing, also paint cursor.
doxygen: blender/windowmanager tagged.
2011-02-25 14:04:21 +00:00
*/
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include <stdlib.h>
#include <string.h>
#include "DNA_listBase.h"
#include "DNA_screen_types.h"
#include "DNA_windowmanager_types.h"
#include "DNA_userdef_types.h"
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
#include "DNA_view3d_types.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
split BKE_utildefines.h, now it only has blender specific defines like GS() MAKE_ID, FILE_MAXDIR, moved the generic defines to BLI_utildefines.h. no functional changes.
2011-01-07 18:36:47 +00:00
#include "BLI_utildefines.h"
static functions for getting power of 2 values were being copied about too much, add to the BLI_math api. - is_power_of_2_i - power_of_2_min_i - power_of_2_max_i
2011-12-16 09:25:07 +00:00
#include "BLI_math_base.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
use define for 0.375 = GLA_PIXEL_OFS, used all over the interface. also use M_SQRT1_2 in math_rotation.c
2012-08-05 17:27:52 +00:00
#include "BIF_gl.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include "BKE_context.h"
remove references to BKE_utildefines where its not needed. - move GS() define into DNA_ID.h - add BLI_utildefines as an automatic include with makesrna generated files.
2011-01-07 19:18:31 +00:00
grabcursor attribute stores full grab mode so we can better differentiate when it needs to wrap around cursor draw. Also add cocoa exception to wm_get_cursor_position (this should be fixed at the ghost level)
2009-12-09 04:51:35 +00:00
#include "GHOST_C-api.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
Cycles: optimization for 3D viewport border render with heavy scenes, the OpenGL render of objects could slow things down when redrawing the view each time a new sample is displayed. Now it does a partial redraw of the viewport with only the render border area, skipping OpenGL object drawing while the render is refining.
2013-04-14 21:42:58 +00:00
#include "ED_view3d.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include "ED_screen.h"
Fix #22123 and #22124: some problems with mutex locks, also tweak to how removing opengl textures from outside main thread is done so it happens as part of the main loop.
2010-04-25 10:49:13 +00:00
#include "GPU_draw.h"
Auto Save Auto save is now working again in 2.5. It will also remember now what the location of the original file was when recovering it, so that library links still work and saving the restored file does not save to the temp directory. There is also a new Recover Auto Save operator which will open the filebrowser in the temp directory and show the auto saved .blends. Implemenation Notes: * Timer storage was moved from window to windowmanager, so we can have windowmanager level timers too now, doesn't make sense to have autosave timer attached to a particular window. * FileGlobal now has a filename field storing where the file was saved. Note that this is only used when loading a file through the recover operators, regular file read doesn't use it, so copying the quit.blend manually over the original file will still work as expected. * Jobs timer no longer uses operator now, this seems more like an internal thing, changing keymaps should not make it possible to break the jobs manager. * Autosave is postponed by 10 seconds when a modal operator is running, e.g. transform or file browsing. * Moved setting G.sce in setup_app_data before depsgraph updates, these can use the filename for pointcaches.
2009-10-20 13:58:53 +00:00
#include "GPU_extensions.h"
Ghost Context Refactor https://developer.blender.org/D643 Separates graphics context creation from window code in Ghost so that they can vary separately.
2014-10-07 15:46:19 -05:00
#include "GPU_glew.h"
Auto Save Auto save is now working again in 2.5. It will also remember now what the location of the original file was when recovering it, so that library links still work and saving the restored file does not save to the temp directory. There is also a new Recover Auto Save operator which will open the filebrowser in the temp directory and show the auto saved .blends. Implemenation Notes: * Timer storage was moved from window to windowmanager, so we can have windowmanager level timers too now, doesn't make sense to have autosave timer attached to a particular window. * FileGlobal now has a filename field storing where the file was saved. Note that this is only used when loading a file through the recover operators, regular file read doesn't use it, so copying the quit.blend manually over the original file will still work as expected. * Jobs timer no longer uses operator now, this seems more like an internal thing, changing keymaps should not make it possible to break the jobs manager. * Autosave is postponed by 10 seconds when a modal operator is running, e.g. transform or file browsing. * Moved setting G.sce in setup_app_data before depsgraph updates, these can use the filename for pointcaches.
2009-10-20 13:58:53 +00:00
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
#include "RE_engine.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include "WM_api.h"
#include "WM_types.h"
#include "wm.h"
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
#include "wm_draw.h"
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#include "wm_window.h"
#include "wm_event_system.h"
/* swap */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
#define WIN_NONE_OK 0
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
#define WIN_BACK_OK 1
#define WIN_FRONT_OK 2
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
#define WIN_BOTH_OK 3
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* ******************* drawing, overlays *************** */
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_paintcursor_draw(bContext *C, ARegion *ar)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindowManager *wm = CTX_wm_manager(C);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (wm->paintcursors.first) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindow *win = CTX_wm_window(C);
bScreen *screen = win->screen;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wmPaintCursor *pc;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
Bugfix #33096 Code drawing paint cursors in regions didn't check for zero-sized regions well. Causing error prints: wmSubWindowScissorSet 0: doesn't exist Harmless, but nicer to handle it correct :)
2012-11-06 10:35:02 +00:00
if (ar->swinid && screen->subwinactive == ar->swinid) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (pc = wm->paintcursors.first; pc; pc = pc->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (pc->poll == NULL || pc->poll(C)) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ARegion *ar_other = CTX_wm_region(C);
grabcursor attribute stores full grab mode so we can better differentiate when it needs to wrap around cursor draw. Also add cocoa exception to wm_get_cursor_position (this should be fixed at the ghost level)
2009-12-09 04:51:35 +00:00
if (ELEM(win->grabcursor, GHOST_kGrabWrap, GHOST_kGrabHide)) {
Custom cursor draw function uses the real cursor position when cursor is grabbed (and not the coordinates from the event). Drawing a custom cursor anywhere but on the real cursor is no good. Also permit NULL poll function (equal to a function that always returns 1)
2009-12-07 18:08:19 +00:00
int x = 0, y = 0;
wm_get_cursor_position(win, &x, &y);
style cleanyp: split > 120 width lines.
2012-02-19 06:00:20 +00:00
pc->draw(C,
x - ar_other->winrct.xmin,
y - ar_other->winrct.ymin,
pc->customdata);
}
else {
pc->draw(C,
win->eventstate->x - ar_other->winrct.xmin,
win->eventstate->y - ar_other->winrct.ymin,
pc->customdata);
Custom cursor draw function uses the real cursor position when cursor is grabbed (and not the coordinates from the event). Drawing a custom cursor anywhere but on the real cursor is no good. Also permit NULL poll function (equal to a function that always returns 1)
2009-12-07 18:08:19 +00:00
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
}
}
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* ********************* drawing, swap ****************** */
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
static void wm_area_mark_invalid_backbuf(ScrArea *sa)
{
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (sa->spacetype == SPACE_VIEW3D)
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
((View3D *)sa->spacedata.first)->flag |= V3D_INVALID_BACKBUF;
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
}
Code cleanup: use bool for static methods
2014-02-05 22:36:15 +11:00
static bool wm_area_test_invalid_backbuf(ScrArea *sa)
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
{
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (sa->spacetype == SPACE_VIEW3D)
Code cleanup: use bool for static methods
2014-02-05 22:36:15 +11:00
return (((View3D *)sa->spacedata.first)->flag & V3D_INVALID_BACKBUF) != 0;
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
else
Fix for silly mistake in overlap draw mode code, still drawing too much.
2010-08-06 14:25:35 +00:00
return 1;
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
}
Cycles: optimization for 3D viewport border render with heavy scenes, the OpenGL render of objects could slow things down when redrawing the view each time a new sample is displayed. Now it does a partial redraw of the viewport with only the render border area, skipping OpenGL object drawing while the render is refining.
2013-04-14 21:42:58 +00:00
static void wm_region_test_render_do_draw(bScreen *screen, ScrArea *sa, ARegion *ar)
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
{
Cycles: optimization for 3D viewport border render with heavy scenes, the OpenGL render of objects could slow things down when redrawing the view each time a new sample is displayed. Now it does a partial redraw of the viewport with only the render border area, skipping OpenGL object drawing while the render is refining.
2013-04-14 21:42:58 +00:00
/* tag region for redraw from render engine preview running inside of it */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (sa->spacetype == SPACE_VIEW3D) {
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
RegionView3D *rv3d = ar->regiondata;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
RenderEngine *engine = (rv3d) ? rv3d->render_engine : NULL;
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (engine && (engine->flag & RE_ENGINE_DO_DRAW)) {
Cycles: optimization for 3D viewport border render with heavy scenes, the OpenGL render of objects could slow things down when redrawing the view each time a new sample is displayed. Now it does a partial redraw of the viewport with only the render border area, skipping OpenGL object drawing while the render is refining.
2013-04-14 21:42:58 +00:00
Scene *scene = screen->scene;
View3D *v3d = sa->spacedata.first;
rcti border_rect;
/* do partial redraw when possible */
if (ED_view3d_calc_render_border(scene, v3d, ar, &border_rect))
ED_region_tag_redraw_partial(ar, &border_rect);
else
ED_region_tag_redraw(ar);
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
engine->flag &= ~RE_ENGINE_DO_DRAW;
}
}
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/********************** draw all **************************/
/* - reference method, draw all each time */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_method_draw_full(bContext *C, wmWindow *win)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
bScreen *screen = win->screen;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ScrArea *sa;
ARegion *ar;
/* draw area regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, sa);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = sa->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_paintcursor_draw(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, NULL);
}
}
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
wm_area_mark_invalid_backbuf(sa);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, NULL);
}
ED_screen_draw(win);
/* draw overlapping regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid) {
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_region_do_draw(C, ar);
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, NULL);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen->do_draw_gesture)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wm_gesture_draw(win);
}
/****************** draw overlap all **********************/
/* - redraw marked areas, and anything that overlaps it */
/* - it also handles swap exchange optionally, assuming */
/* that on swap no clearing happens and we get back the */
/* same buffer as we swapped to the front */
/* mark area-regions to redraw if overlapped with rect */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_flush_regions_down(bScreen *screen, rcti *dirty)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
ScrArea *sa;
ARegion *ar;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next) {
for (ar = sa->regionbase.first; ar; ar = ar->next) {
minor refactor for rect functions. more consistent naming.
2012-07-15 00:29:56 +00:00
if (BLI_rcti_isect(dirty, &ar->winrct, NULL)) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->do_draw = RGN_DRAW;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
memset(&ar->drawrct, 0, sizeof(ar->drawrct));
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_NONE_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
}
}
/* mark menu-regions to redraw if overlapped with rect */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_flush_regions_up(bScreen *screen, rcti *dirty)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
ARegion *ar;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.first; ar; ar = ar->next) {
minor refactor for rect functions. more consistent naming.
2012-07-15 00:29:56 +00:00
if (BLI_rcti_isect(dirty, &ar->winrct, NULL)) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->do_draw = RGN_DRAW;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
memset(&ar->drawrct, 0, sizeof(ar->drawrct));
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_NONE_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
}
WM Draw Method added to do Overlap assuming swap exchange / flipping, and made that the default for windows software opengl because that seems to be working better at least on XP. Previously this could only be specified from the command line.
2010-02-01 10:02:53 +00:00
static void wm_method_draw_overlap_all(bContext *C, wmWindow *win, int exchange)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindowManager *wm = CTX_wm_manager(C);
bScreen *screen = win->screen;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ScrArea *sa;
ARegion *ar;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
static rcti rect = {0, 0, 0, 0};
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
/* after backbuffer selection draw, we need to redraw */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next)
for (ar = sa->regionbase.first; ar; ar = ar->next)
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && !wm_area_test_invalid_backbuf(sa))
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
ED_region_tag_redraw(ar);
Attempt to fix black 3d view with texture paint + overlap draw mode.
2010-07-22 10:02:02 +00:00
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* flush overlapping regions */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen->regionbase.first) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* flush redraws of area regions up to overlapping regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next)
for (ar = sa->regionbase.first; ar; ar = ar->next)
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_flush_regions_up(screen, &ar->winrct);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* flush between overlapping regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.last; ar; ar = ar->prev)
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_flush_regions_up(screen, &ar->winrct);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* flush redraws of overlapping regions down to area regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.last; ar; ar = ar->prev)
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_flush_regions_down(screen, &ar->winrct);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* flush drag item */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (rect.xmin != rect.xmax) {
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
wm_flush_regions_down(screen, &rect);
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
rect.xmin = rect.xmax = 0;
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (wm->drags.first) {
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* doesnt draw, fills rect with boundbox */
wm_drags_draw(C, win, &rect);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* draw marked area regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, sa);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = sa->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid) {
if (ar->do_draw) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_paintcursor_draw(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, NULL);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (exchange)
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_FRONT_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (exchange) {
if (ar->swap == WIN_FRONT_OK) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_paintcursor_draw(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_region_set(C, NULL);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_BOTH_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (ar->swap == WIN_BACK_OK)
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_FRONT_OK;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (ar->swap == WIN_BOTH_OK)
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ar->swap = WIN_BOTH_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
}
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
wm_area_mark_invalid_backbuf(sa);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, NULL);
}
/* after area regions so we can do area 'overlay' drawing */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen->do_draw) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_screen_draw(win);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (exchange)
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
screen->swap = WIN_FRONT_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (exchange) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (screen->swap == WIN_FRONT_OK) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_screen_draw(win);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
screen->swap = WIN_BOTH_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (screen->swap == WIN_BACK_OK)
screen->swap = WIN_FRONT_OK;
else if (screen->swap == WIN_BOTH_OK)
screen->swap = WIN_BOTH_OK;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
/* draw marked overlapping regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw) {
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_region_do_draw(C, ar);
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, NULL);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen->do_draw_gesture)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wm_gesture_draw(win);
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* needs pixel coords in screen */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (wm->drags.first) {
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
wm_drags_draw(C, win, NULL);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
#if 0
/******************** draw damage ************************/
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* - not implemented */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_method_draw_damage(bContext *C, wmWindow *win)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
wm_method_draw_all(C, win);
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
#endif
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/****************** draw triple buffer ********************/
/* - area regions are written into a texture, without any */
/* of the overlapping menus, brushes, gestures. these */
/* are redrawn each time. */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* */
/* - if non-power of two textures are supported, that is */
/* used. if not, multiple smaller ones are used, with */
/* worst case wasted space being 23.4% for 3x3 textures */
#define MAX_N_TEX 3
typedef struct wmDrawTriple {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
GLuint bind[MAX_N_TEX * MAX_N_TEX];
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
int x[MAX_N_TEX], y[MAX_N_TEX];
int nx, ny;
GLenum target;
} wmDrawTriple;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void split_width(int x, int n, int *splitx, int *nx)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
int a, newnx, waste;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* if already power of two just use it */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (is_power_of_2_i(x)) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
splitx[0] = x;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
(*nx)++;
return;
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (n == 1) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* last part, we have to go larger */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
splitx[0] = power_of_2_max_i(x);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
(*nx)++;
}
else {
/* two or more parts to go, use smaller part */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
splitx[0] = power_of_2_min_i(x);
newnx = ++(*nx);
split_width(x - splitx[0], n - 1, splitx + 1, &newnx);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (waste = 0, a = 0; a < n; a++)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
waste += splitx[a];
/* if we waste more space or use the same amount,
* revert deeper splits and just use larger */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (waste >= power_of_2_max_i(x)) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
splitx[0] = power_of_2_max_i(x);
memset(splitx + 1, 0, sizeof(int) * (n - 1));
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
else
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
*nx = newnx;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_draw_triple_free(wmWindow *win)
{
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->drawdata) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmDrawTriple *triple = win->drawdata;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glDeleteTextures(triple->nx * triple->ny, triple->bind);
Merge GSOC Sculpt Branch: 28499-30319 https://svn.blender.org/svnroot/bf-blender/branches/soc-2010-jwilkins See log of that branch for details.
2010-07-14 14:11:03 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
MEM_freeN(triple);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
win->drawdata = NULL;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
}
static void wm_draw_triple_fail(bContext *C, wmWindow *win)
{
wm_draw_window_clear(win);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
win->drawfail = 1;
WM Draw Method added to do Overlap assuming swap exchange / flipping, and made that the default for windows software opengl because that seems to be working better at least on XP. Previously this could only be specified from the command line.
2010-02-01 10:02:53 +00:00
wm_method_draw_overlap_all(C, win, 0);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
static int wm_triple_gen_textures(wmWindow *win, wmDrawTriple *triple)
{
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
const int winsize_x = WM_window_pixels_x(win);
const int winsize_y = WM_window_pixels_y(win);
2.5: Enable triple buffer drawing by default (if it doesn't work or flickers, kick me). Also removed proxy texture test since it does not seem to be implemented well by all drivers.
2009-02-06 16:51:09 +00:00
GLint maxsize;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
int x, y;
/* compute texture sizes */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (GLEW_ARB_texture_rectangle || GLEW_NV_texture_rectangle || GLEW_EXT_texture_rectangle) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
triple->target = GL_TEXTURE_RECTANGLE_ARB;
triple->nx = 1;
triple->ny = 1;
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
triple->x[0] = winsize_x;
triple->y[0] = winsize_y;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_non_power_of_two_support()) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
triple->target = GL_TEXTURE_2D;
triple->nx = 1;
triple->ny = 1;
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
triple->x[0] = winsize_x;
triple->y[0] = winsize_y;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
else {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
triple->target = GL_TEXTURE_2D;
triple->nx = 0;
triple->ny = 0;
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
split_width(winsize_x, MAX_N_TEX, triple->x, &triple->nx);
split_width(winsize_y, MAX_N_TEX, triple->y, &triple->ny);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* generate texture names */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glGenTextures(triple->nx * triple->ny, triple->bind);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (!triple->bind[0]) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* not the typical failure case but we handle it anyway */
printf("WM: failed to allocate texture for triple buffer drawing (glGenTextures).\n");
return 0;
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (y = 0; y < triple->ny; y++) {
for (x = 0; x < triple->nx; x++) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* proxy texture is only guaranteed to test for the cases that
* there is only one texture in use, which may not be the case */
Add function to query maximum texture size. Also, make texture upload functions aware of this limit.
2013-04-12 17:56:07 +00:00
maxsize = GPU_max_texture_size();
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (triple->x[x] > maxsize || triple->y[y] > maxsize) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glBindTexture(triple->target, 0);
style cleanyp: split > 120 width lines.
2012-02-19 06:00:20 +00:00
printf("WM: failed to allocate texture for triple buffer drawing "
"(texture too large for graphics card).\n");
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
return 0;
}
/* setup actual texture */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glBindTexture(triple->target, triple->bind[x + y * triple->nx]);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glTexImage2D(triple->target, 0, GL_RGB8, triple->x[x], triple->y[y], 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(triple->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(triple->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
style cleanup: also quiet a warning.
2012-06-17 11:36:28 +00:00
/* The current color is ignored if the GL_REPLACE texture environment is used. */
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
// glTexEnvi(triple->target, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(triple->target, 0);
/* not sure if this works everywhere .. */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (glGetError() == GL_OUT_OF_MEMORY) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
printf("WM: failed to allocate texture for triple buffer drawing (out of memory).\n");
return 0;
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
return 1;
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
static void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
{
Code Cleanup: avoid duplicate calls to WM_window_pixels_x/y
2014-01-15 10:41:13 +11:00
const int winsize_x = WM_window_pixels_x(win);
const int winsize_y = WM_window_pixels_y(win);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
float halfx, halfy, ratiox, ratioy;
int x, y, sizex, sizey, offx, offy;
glEnable(triple->target);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (y = 0, offy = 0; y < triple->ny; offy += triple->y[y], y++) {
for (x = 0, offx = 0; x < triple->nx; offx += triple->x[x], x++) {
Code Cleanup: avoid duplicate calls to WM_window_pixels_x/y
2014-01-15 10:41:13 +11:00
sizex = (x == triple->nx - 1) ? winsize_x - offx : triple->x[x];
sizey = (y == triple->ny - 1) ? winsize_y - offy : triple->y[y];
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* wmOrtho for the screen has this same offset */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
ratiox = sizex;
ratioy = sizey;
use define for 0.375 = GLA_PIXEL_OFS, used all over the interface. also use M_SQRT1_2 in math_rotation.c
2012-08-05 17:27:52 +00:00
halfx = GLA_PIXEL_OFS;
halfy = GLA_PIXEL_OFS;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
/* texture rectangle has unnormalized coordinates */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (triple->target == GL_TEXTURE_2D) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
ratiox /= triple->x[x];
ratioy /= triple->y[y];
halfx /= triple->x[x];
halfy /= triple->y[y];
}
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glBindTexture(triple->target, triple->bind[x + y * triple->nx]);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
glColor4f(1.0f, 1.0f, 1.0f, alpha);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glBegin(GL_QUADS);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glTexCoord2f(halfx, halfy);
glVertex2f(offx, offy);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glTexCoord2f(ratiox + halfx, halfy);
glVertex2f(offx + sizex, offy);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glTexCoord2f(ratiox + halfx, ratioy + halfy);
glVertex2f(offx + sizex, offy + sizey);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glTexCoord2f(halfx, ratioy + halfy);
glVertex2f(offx, offy + sizey);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glEnd();
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glBindTexture(triple->target, 0);
glDisable(triple->target);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_triple_copy_textures(wmWindow *win, wmDrawTriple *triple)
{
Code Cleanup: avoid duplicate calls to WM_window_pixels_x/y
2014-01-15 10:41:13 +11:00
const int winsize_x = WM_window_pixels_x(win);
const int winsize_y = WM_window_pixels_y(win);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
int x, y, sizex, sizey, offx, offy;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (y = 0, offy = 0; y < triple->ny; offy += triple->y[y], y++) {
for (x = 0, offx = 0; x < triple->nx; offx += triple->x[x], x++) {
Code Cleanup: avoid duplicate calls to WM_window_pixels_x/y
2014-01-15 10:41:13 +11:00
sizex = (x == triple->nx - 1) ? winsize_x - offx : triple->x[x];
sizey = (y == triple->ny - 1) ? winsize_y - offy : triple->y[y];
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glBindTexture(triple->target, triple->bind[x + y * triple->nx]);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glCopyTexSubImage2D(triple->target, 0, 0, 0, offx, offy, sizex, sizey);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glBindTexture(triple->target, 0);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
static void wm_draw_region_blend(wmWindow *win, ARegion *ar)
{
float fac = ED_region_blend_factor(ar);
/* region blend always is 1, except when blend timer is running */
if (fac < 1.0f) {
border render with cycles had 1 pixel offset on the top-right edge of the image, issue was caused by wmSubWindowScissorSet adding 1 to the ar->drawrct, now only add the padding when drawing the entire area
2013-08-05 04:52:27 +00:00
wmSubWindowScissorSet(win, win->screen->mainwin, &ar->winrct, true);
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
glEnable(GL_BLEND);
wm_triple_draw_textures(win, win->drawdata, 1.0f - fac);
glDisable(GL_BLEND);
}
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
static void wm_method_draw_triple(bContext *C, wmWindow *win)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindowManager *wm = CTX_wm_manager(C);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wmDrawTriple *triple;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
bScreen *screen = win->screen;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
ScrArea *sa;
ARegion *ar;
Code cleanup, unneeded variable, always true when used, not used when set
2014-07-22 11:57:03 +02:00
int copytex = 0;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->drawdata) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
glClearColor(0, 0, 0, 0);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wmSubWindowSet(win, screen->mainwin);
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
wm_triple_draw_textures(win, win->drawdata, 1.0f);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
else {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
win->drawdata = MEM_callocN(sizeof(wmDrawTriple), "wmDrawTriple");
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (!wm_triple_gen_textures(win, win->drawdata)) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_draw_triple_fail(C, win);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
return;
}
}
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
triple = win->drawdata;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* draw marked area regions */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, sa);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = sa->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw) {
Small drawing glitch, for UI with transparent overlapping regions; - The corner 'duplicate/merge area' widget was drawing too often. (Added comment in subwindow 'active' code, too many redraws are being sent on moving mouse over region eddges)
2012-12-22 11:52:53 +00:00
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
if (ar->overlap == 0) {
CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);
CTX_wm_region_set(C, NULL);
copytex = 1;
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
Fix #20374: Limit selection to visible would not work anymore after trying to select once but not selecting correctly, due the need backbuffer flag not being reset correctly in the 3d view.
2009-12-17 14:38:30 +00:00
wm_area_mark_invalid_backbuf(sa);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_area_set(C, NULL);
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (copytex) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wmSubWindowSet(win, screen->mainwin);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_triple_copy_textures(win, triple);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
Code cleanup, unneeded variable, always true when used, not used when set
2014-07-22 11:57:03 +02:00
if (wm->paintcursors.first) {
Keep brush overlays below panels in triple buffer mode.
2013-04-05 16:34:27 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next) {
for (ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->swinid && ar->swinid == screen->subwinactive) {
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, ar);
/* make region ready for draw, scissor, pixelspace */
ED_region_set(C, ar);
wm_paintcursor_draw(C, ar);
CTX_wm_region_set(C, NULL);
CTX_wm_area_set(C, NULL);
}
}
}
wmSubWindowSet(win, screen->mainwin);
}
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
/* draw overlapping area regions (always like popups) */
for (sa = screen->areabase.first; sa; sa = sa->next) {
CTX_wm_area_set(C, sa);
for (ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->swinid && ar->overlap) {
CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);
CTX_wm_region_set(C, NULL);
wm_draw_region_blend(win, ar);
}
}
CTX_wm_area_set(C, NULL);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* after area regions so we can do area 'overlay' drawing */
ED_screen_draw(win);
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
/* draw floating regions (menus) */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = screen->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid) {
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, ar);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_region_do_draw(C, ar);
UI: * Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
2009-03-25 20:49:15 +00:00
CTX_wm_menu_set(C, NULL);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
}
Bugfix #24847 When report error was drawn in info header, using border select or paint brushes flickered. Was caused by Triple Buffer method not checking for correct redraw case. Also made report redraws less aggressive, it was drawing the info header all over with 50 FPS for 10 seconds. Made it 20 FPS, and added code to only send notifiers for actual changes. As todo note for future: animated UI options could get better caching to cope with slower refreshes.
2010-11-24 16:34:38 +00:00
/* always draw, not only when screen tagged */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->gesture.first)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wm_gesture_draw(win);
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
/* needs pixel coords in screen */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (wm->drags.first) {
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
wm_drags_draw(C, win, NULL);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
}
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/****************** main update call **********************/
/* quick test to prevent changing window drawable */
Code cleanup: use bool for static methods
2014-02-05 22:36:15 +11:00
static bool wm_draw_update_test_window(wmWindow *win)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
{
ScrArea *sa;
ARegion *ar;
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
bool do_draw = false;
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (ar = win->screen->regionbase.first; ar; ar = ar->next) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->do_draw_overlay) {
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
wm_tag_redraw_overlay(win, ar);
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
ar->do_draw_overlay = false;
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw)
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
do_draw = true;
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
}
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = win->screen->areabase.first; sa; sa = sa->next) {
for (ar = sa->regionbase.first; ar; ar = ar->next) {
Cycles: optimization for 3D viewport border render with heavy scenes, the OpenGL render of objects could slow things down when redrawing the view each time a new sample is displayed. Now it does a partial redraw of the viewport with only the render border area, skipping OpenGL object drawing while the render is refining.
2013-04-14 21:42:58 +00:00
wm_region_test_render_do_draw(win->screen, sa, ar);
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar->swinid && ar->do_draw)
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
do_draw = true;
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
}
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
}
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (do_draw)
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
return 1;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_refresh)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
return 1;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_draw)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
return 1;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_draw_gesture)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
return 1;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_draw_paintcursor)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
return 1;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_draw_drag)
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
return 1;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
return 0;
}
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
static int wm_automatic_draw_method(wmWindow *win)
{
2.5: automatic draw method now uses overlap for Intel on all platforms.
2010-07-16 10:13:04 +00:00
/* Ideally all cards would work well with triple buffer, since if it works
style cleanup: comment blocks
2012-03-09 18:28:30 +00:00
* well gives the least redraws and is considerably faster at partial redraw
* for sculpting or drawing overlapping menus. For typically lower end cards
* copy to texture is slow though and so we use overlap instead there. */
2.5: automatic draw method now uses overlap for Intel on all platforms.
2010-07-16 10:13:04 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->drawmethod == USER_DRAW_AUTOMATIC) {
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
/* ATI opensource driver is known to be very slow at this */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_UNIX, GPU_DRIVER_OPENSOURCE))
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
return USER_DRAW_OVERLAP;
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
/* also Intel drivers are slow */
style cleanup: comments & spelling
2012-11-18 01:22:31 +00:00
#if 0 /* 2.64 BCon3 period, let's try if intel now works... */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_UNIX, GPU_DRIVER_ANY))
2.5: automatic draw method now uses overlap for Intel on all platforms.
2010-07-16 10:13:04 +00:00
return USER_DRAW_OVERLAP;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_WIN, GPU_DRIVER_ANY))
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
return USER_DRAW_OVERLAP_FLIP;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_MAC, GPU_DRIVER_ANY))
Another attempt to solve draw methods on Intel. Windows and mac now use overlap, while unixes use overlap flip. Also implemented recent fix for redrawing after backbuffer selection differently to avoid unneeded redraws.
2010-07-23 13:42:58 +00:00
return USER_DRAW_OVERLAP_FLIP;
style cleanup: comments & spelling
2012-11-18 01:22:31 +00:00
#endif
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
/* Windows software driver darkens color on each redraw */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_type_matches(GPU_DEVICE_SOFTWARE, GPU_OS_WIN, GPU_DRIVER_SOFTWARE))
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
return USER_DRAW_OVERLAP_FLIP;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_type_matches(GPU_DEVICE_SOFTWARE, GPU_OS_UNIX, GPU_DRIVER_SOFTWARE))
Fix [#23592] WM draw method detection fails for Mesa's software rasterizer. Reported and patched by Vinay Pawar. The drawing method will be set to Overlap on detection of Mesa software rasterizer.
2010-08-31 11:30:13 +00:00
return USER_DRAW_OVERLAP;
2.5: automatic draw method now uses overlap for Intel on all platforms.
2010-07-16 10:13:04 +00:00
/* drawing lower color depth again degrades colors each time */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (GPU_color_depth() < 24)
Fix #21349: triple buffer drawing doesn't work well with thousands of colors setting on Mac, just disabled it in that case.
2010-04-05 10:25:40 +00:00
return USER_DRAW_OVERLAP;
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
else
return USER_DRAW_TRIPLE;
}
else
return win->drawmethod;
}
code cleanup: use bools in UI and WM code, quiet some shadow warnings, remove unused function uiEmboss()
2013-04-04 02:05:11 +00:00
bool WM_is_draw_triple(wmWindow *win)
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
{
/* function can get called before this variable is set in drawing code below */
if (win->drawmethod != U.wmdrawmethod)
win->drawmethod = U.wmdrawmethod;
code cleanup: use bools in UI and WM code, quiet some shadow warnings, remove unused function uiEmboss()
2013-04-04 02:05:11 +00:00
return (USER_DRAW_TRIPLE == wm_automatic_draw_method(win));
Holiday coding log :) Nice formatted version (pictures soon): http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.66/Usability Short list of main changes: - Transparent region option (over main region), added code to blend in/out such panels. - Min size window now 640 x 480 - Fixed DPI for ui - lots of cleanup and changes everywhere. Icon image need correct size still, layer-in-use icon needs remake. - Macbook retina support, use command line --no-native-pixels to disable it - Timeline Marker label was drawing wrong - Trackpad and magic mouse: supports zoom (hold ctrl) - Fix for splash position: removed ghost function and made window size update after creation immediate - Fast undo buffer save now adds UI as well. Could be checked for regular file save even... Quit.blend and temp file saving use this now. - Dixed filename in window on reading quit.blend or temp saves, and they now add a warning in window title: "(Recovered)" - New Userpref option "Keep Session" - this always saves quit.blend, and loads on start. This allows keeping UI and data without actual saves, until you actually save. When you load startup.blend and quit, it recognises the quit.blend as a startup (no file name in header) - Added 3D view copy/paste buffers (selected objects). Shortcuts ctrl-c, ctrl-v (OSX, cmd-c, cmd-v). Coded partial file saving for it. Could be used for other purposes. Todo: use OS clipboards. - User preferences (themes, keymaps, user settings) now can be saved as a separate file. Old option is called "Save Startup File" the new one "Save User Settings". To visualise this difference, the 'save startup file' button has been removed from user preferences window. That option is available as CTRL+U and in File menu still. - OSX: fixed bug that stopped giving mouse events outside window. This also fixes "Continuous Grab" for OSX. (error since 2009)
2012-12-12 18:58:11 +00:00
}
Sculpt Mode Bugfixes: * #20833: layer brush doesn't work with multires. * #20946: sculpt mode partially removes parts of the mesh in the viewport. * #20420: grab brush stops after moving some distance. * #20906: sculpt grab tool moves in wrong direction. * #21132 and #21272: undo on object with subdivision surface modifier crashes. * #21115: subsurf + multires + sculpting + undo causes crash. * #20683: sculpt + multires apply + undo crash. * #19094: wrong outline in solid mode.
2010-03-22 11:59:36 +00:00
void wm_tag_redraw_overlay(wmWindow *win, ARegion *ar)
{
/* for draw triple gestures, paint cursors don't need region redraw */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ar && win) {
if (wm_automatic_draw_method(win) != USER_DRAW_TRIPLE)
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
ED_region_tag_redraw(ar);
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
win->screen->do_draw_paintcursor = true;
Fix #21470: changing brush settings redraws the 3d view unecessarily, added ED_region_tag_redraw_overlay to only redo overlay drawing, which in case of triple buffer is much faster.
2010-06-23 09:58:32 +00:00
}
Sculpt Mode Bugfixes: * #20833: layer brush doesn't work with multires. * #20946: sculpt mode partially removes parts of the mesh in the viewport. * #20420: grab brush stops after moving some distance. * #20906: sculpt grab tool moves in wrong direction. * #21132 and #21272: undo on object with subdivision surface modifier crashes. * #21115: subsurf + multires + sculpting + undo causes crash. * #20683: sculpt + multires apply + undo crash. * #19094: wrong outline in solid mode.
2010-03-22 11:59:36 +00:00
}
Fix #35337: sculpt performance regression, partial redraw was not working anymore due to paint cursor redraw problem.
2013-05-13 13:32:42 +00:00
void WM_paint_cursor_tag_redraw(wmWindow *win, ARegion *ar)
{
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
win->screen->do_draw_paintcursor = true;
Fix #35337: sculpt performance regression, partial redraw was not working anymore due to paint cursor redraw problem.
2013-05-13 13:32:42 +00:00
wm_tag_redraw_overlay(win, ar);
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
void wm_draw_update(bContext *C)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindowManager *wm = CTX_wm_manager(C);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wmWindow *win;
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
int drawmethod;
Fix #22123 and #22124: some problems with mutex locks, also tweak to how removing opengl textures from outside main thread is done so it happens as part of the main loop.
2010-04-25 10:49:13 +00:00
GPU_free_unused_buffers();
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (win = wm->windows.first; win; win = win->next) {
only apply workaround for [#33223] when using intel cards on windows.
2013-02-25 12:19:38 +00:00
#ifdef WIN32
if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_ANY, GPU_DRIVER_ANY)) {
GHOST_TWindowState state = GHOST_GetWindowState(win->ghostwin);
if (state == GHOST_kWindowStateMinimized) {
/* do not update minimized windows, it gives issues on intel drivers (see [#33223])
* anyway, it seems logical to skip update for invisible windows
*/
continue;
}
Fix #33223: Instant Crash on Window minimize Issue was caused by manipulating with triple buffers of minimized window. It's more like an Intel driver bug but we can workaround it in quite clear way by skipping draw of minimized windows.
2012-11-19 16:46:48 +00:00
}
only apply workaround for [#33223] when using intel cards on windows.
2013-02-25 12:19:38 +00:00
#endif
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->drawmethod != U.wmdrawmethod) {
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_draw_window_clear(win);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
win->drawmethod = U.wmdrawmethod;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (wm_draw_update_test_window(win)) {
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
CTX_wm_window_set(C, win);
/* sets context window+screen */
Fix #34997: when starting the game engine in one window and switching to a second window, the game would stop drawing in the first and mess up the OpenGL state of the second. Also fixes glPushAttrib/glPopAttrib getting out of sync in some cases.
2013-04-18 16:28:39 +00:00
wm_window_make_drawable(wm, win);
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
/* notifiers for screen redraw */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->screen->do_refresh)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
ED_screen_refresh(wm, win);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
drawmethod = wm_automatic_draw_method(win);
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (win->drawfail)
WM Draw Method added to do Overlap assuming swap exchange / flipping, and made that the default for windows software opengl because that seems to be working better at least on XP. Previously this could only be specified from the command line.
2010-02-01 10:02:53 +00:00
wm_method_draw_overlap_all(C, win, 0);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (drawmethod == USER_DRAW_FULL)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_method_draw_full(C, win);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (drawmethod == USER_DRAW_OVERLAP)
WM Draw Method added to do Overlap assuming swap exchange / flipping, and made that the default for windows software opengl because that seems to be working better at least on XP. Previously this could only be specified from the command line.
2010-02-01 10:02:53 +00:00
wm_method_draw_overlap_all(C, win, 0);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
else if (drawmethod == USER_DRAW_OVERLAP_FLIP)
WM Draw Method added to do Overlap assuming swap exchange / flipping, and made that the default for windows software opengl because that seems to be working better at least on XP. Previously this could only be specified from the command line.
2010-02-01 10:02:53 +00:00
wm_method_draw_overlap_all(C, win, 1);
style cleanup: follow style guide for/with/if spacing
2012-03-24 07:52:14 +00:00
else // if (drawmethod == USER_DRAW_TRIPLE)
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wm_method_draw_triple(C, win);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
win->screen->do_draw_gesture = false;
win->screen->do_draw_paintcursor = false;
win->screen->do_draw_drag = false;
2.5: WIP commit for WM compositing. * Drawing code from wm_event_system.c split into separate wm_draw.c file. Now there's 3 different draw methods implemented, not sure what survives or will be added but is useful for debugging. * Draw All: redraws everything each time, for reference. * Draw Overlap All: what the code did before this commit, only draw regions marked for redraw, and anything that overlaps them. * Triple Buffer: copies/retores all area regions into a texture, and blits that before drawing. Menus, brushes, gestures, etc are redrawn always on top of that. Currently "Draw Overlap All" is set hardcoded to be used still. Triple Buffer code is not complete, it doesn't handle window resize yet. Cards that don't support non power of two textures can need quite large textures as well, this could be split into multiple smaller ones.
2009-01-20 21:55:48 +00:00
wm_window_swap_buffers(win);
CTX_wm_window_set(C, NULL);
}
}
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
void wm_draw_window_clear(wmWindow *win)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
bScreen *screen = win->screen;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
ScrArea *sa;
ARegion *ar;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
int drawmethod = wm_automatic_draw_method(win);
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (drawmethod == USER_DRAW_TRIPLE)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_draw_triple_free(win);
/* clear screen swap flags */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen) {
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (sa = screen->areabase.first; sa; sa = sa->next)
for (ar = sa->regionbase.first; ar; ar = ar->next)
ar->swap = WIN_NONE_OK;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
screen->swap = WIN_NONE_OK;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
}
void wm_draw_region_clear(wmWindow *win, ARegion *ar)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
int drawmethod = wm_automatic_draw_method(win);
Fix automatic draw method detection not clearing things properly on e.g. resizing windows.
2010-02-01 10:39:36 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (ELEM(drawmethod, USER_DRAW_OVERLAP, USER_DRAW_OVERLAP_FLIP))
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wm_flush_regions_down(win->screen, &ar->winrct);
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
win->screen->do_draw = true;
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
}
Fix #28107: save screenshot operator option to save full screen or only a single editor was not working. Solution is to take full screenshot and crop it on save. Also fixed screenshot showing popup menu used to execute operator.
2011-12-05 16:37:31 +00:00
void WM_redraw_windows(bContext *C)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindow *win_prev = CTX_wm_window(C);
ScrArea *area_prev = CTX_wm_area(C);
ARegion *ar_prev = CTX_wm_region(C);
Fix #28107: save screenshot operator option to save full screen or only a single editor was not working. Solution is to take full screenshot and crop it on save. Also fixed screenshot showing popup menu used to execute operator.
2011-12-05 16:37:31 +00:00
wm_draw_update(C);
CTX_wm_window_set(C, win_prev);
CTX_wm_area_set(C, area_prev);
CTX_wm_region_set(C, ar_prev);
}
Copy Permalink