controlled by the wrong color, now it's controlled by "Menu Back" text color. This
is somewhat confusing but we like some other widgets the standard colors do not
work well on the dark background of popups.
This issue was caused by doing pespective interpolation of clone uv
coordinates in perspective view. To fix this we need to use perspective
correction for screen coordinates, but return regular barycentric
weights back for clone layer uv coordinate interpolation.
The bug only exists for multires smoothing. Other cases were handled by
BKE_pbvh_vertex_iter_begin, which culled hidden parts accordingly. Added
a manual check on the multires smoothing code.
texture if more than 1 texture is used
The problem here is that no flushing is done when the texface image
changes between rendered triangles. Added a compare function and
slightly modified the draw_tface_mapped__set_draw callback to compliant
with the new user data.
Issue goes back since we stopped using LISTROW button to draw item's name (i.e. since we have custom buttons in list items!).
This commit:
* Adds a new flag to uiBlock, UI_BLOCK_LIST_ITEM, to mark blocks used for each list item.
* Adds a new button type, LISTLABEL, which basically behaves exactly as LABEL, but uses wcol_list_item color set.
* When uiItemL is called, it checks whether current block has UI_BLOCK_LIST_ITEM set, and if so, switch produced button to LISTLABEL type.
* Adds a new helper func, ui_layout_list_set_labels_active, called after the active list item has been "drawn", to set all LISTLABEL buttons as UI_SELECT.
Note custom widget_state_label() was removed, in interface_widgets.c, as it did nothing more than default widget_state().
Thanks to Brecht for the review and advices.
in some cases. The dupli code would still do object updates during render indirectly,
while this is disabled for thread safety everywhere else, now we disable it for this
case as well.
Not a pretty solution but this is for the depgraph refactor to solve.
textures larger than 2048x2048.
Check if texture is over user preference or GPU limit in texture paint
mode and if it is, scale the partial redraw rectangle before uploading
to GPU. This should be faster than rescaling the whole texture.
Btw, there is a comment stating that bits 12-15 are the same for uiBlock->flag and uiBut->flag, this is obviously no more true currently (maybe it is now bits 14-17, i.e. ALIGN flags?).
Forward enum declaration is a bad idea, especially for C++ which requires
enum specification to dteermine which data type to use to store it.
Alternative would be to not use enum as an arument and pass it as int,
but actually would rather be strict on typing -- using explicit enum
as parameter type helps understanding the code and prevents possible
mistakes when using the function.
Added function called WM_set_locked_interface which does
two things:
- Prevents event queue from being handled, so no operators
or values are even possible to run or change. This prevents
any kind of "destructive" action performed from user while
rendering.
- Locks interface refresh for regions which does have lock
set to truth in their template. Currently it's just a 3D
viewport, but in the future more regions could be considered
unsafe, or we could want to lock different parts of
interface when doing different jobs.
This is needed because 3D viewport could be using or changing
the same data as renderer currently uses, leading to threading
conflict.
Notifiers are still allowed to handle, so render progress is
seen on the screen, but would need to doublecheck on this, in
terms some notifiers could be changing the data.
For now interface locking happens for render job only in case
"Lock Interface" checkbox is enabled.
Currently this option would only make rendering thread-safe, but
in the future more benefits are possible to gain from it. Namely,
if we'll make renderer using it's own graph, this option would
allow to free memory used by 3D viewport graph, which would help
keeping memory usage low (or even would allow renderer not to
copy anything in this case).
Initially thought this change will also allow to free DMs used
by viewport, but we couldn't actually do this. This is because
of modifiers which uses other objects (like boolean), They're
in fact using viewport DM. This is bad because of few reasons.
We currently need to have viewport DM when rendering.
And for sure even in background render viewport DMs are being
calculated. This sounds like 2x computing is needed: one is for
viewport DM and one is for RenderDM.
If we'll have local graphs, we'll be able to compute RenderDMs
only and store them in graph. This would require a bit more of
the memory, but would solve current issues with viewport DM
used for modifiers operands while rendering and it should give
quite noticeable speedup.
Other tools like backing would also benefit of this option,
but rather get approval of current way of locking first.
Callback handle was assigning to wrong storage in RE_draw_lock_cb.
So far it was completely harmless because all the callbacks are
using the same handle, so test_break_callback was using correct
handle, and since draw_lock_callback didn't use handle at all
nobody noticed this.
But this typo lead to draw_lock_callback using NULL instead of
real RenderJob, which is bad for the feature we're working in
GSoC branch.
by splitting the compositor module into 3 parts. The operating system limit is
32767, which gives less than 120 characters per file with 272 cpp files.
Campbell Barton
Gaia Clary
Brecht Van Lommel
Antonis Ryakiotakis
Bastien Montagne
Thomas Dinges
Sergey Sharybin