GPencil: Enable binding to deforming meshes #100301

New Issue

Elisabetta Abbattista · 2022-08-09T18:42:19+02:00

2022-08-09 18:42:19 +02:00

CLICK HERE FOR THE VIDEO!
Most up-to-date code here, for Blender 3.5 Release branch
(#105935)

I am Elisabetta Abbattista. I work at MAD Entertainment, an animation studio you may recognize because of my co-workers’ involvement in the community – such as Ivan Cappiello and Corrado Piscitelli. We work with Blender and everyday we look for new techniques for our production. Lately we’ve been using Grease Pencil quite a lot, because we found it an amazing and versatile tool, though it still has a long way to go and a big room for improvement. We would like to improve Blender for everyone, so we thought that a good way to give some new functionality to Grease Pencil without giving up all its current features would be giving it a new modifier – the Grease Pencil equivalent of Surface Deform.

Reasons: we have rigged models with grease pencil strokes drawn on them. These gp’s should move together with the rigged models, but their weighting process is tedious and inaccurate. They should hang onto the mesh surface and deform along with it or a dedicated mesh cage.

Surface deform modifier implementation for grease pencil

What I’m looking for:
Feedback from developers about the actual feasibility of the goals and methods. I will post updates about the work done so far on the new modifier. The work is currently just started.

How we are going to do it:

Add the new file “blender/source/blender/gpencil_modifiers/intern/MOD_gpencilsurfacedeform.c” and edit the other relevant files accordingly.

Copy code from the Surface Deform modifier. We can look into both the Mesh Deform and Surface Deform modifiers. But since the strokes have to lay on the surface of mesh objects, it seems more convenient to use the same method of “Surface Deform” modifier to achieve this, even though it had been originally thought for clothes.
Write the deformation system for the grease pencil strokes and points.

  The Surface Deform modifier stores a transformation matrix for each of the affected vertices in its mesh, and applies it to the evaluated mesh.
 There isn’t consistency in the use of stroke/points deformation functions in grease pencil modifiers. Armature, lattice and shrinkwrap grease pencil modifiers use BKE functions external to the MOD_gmencilmodifiername.c file. Noise uses the “deformStroke” function itself. Hook uses functions within its file.  
We could follow the “Offset” grease pencil modifier way and  use the “deformStroke” function to apply a matrix it has generated to every gp point in the stroke.  
   So what we want to do is get this kind of reference and multiply it with the matrix we generate via the same method of Surface Deform.
       I suppose it’s better to have a separate function that takes the matrices from the modifier data like the mesh object modifier counterparts. Separate functions will also take care of generating these matrices on bind, and store them in the modifier data structures.

Add the Bind operator.

    In the Surface Deform and the Mesh Deform modifiers, the function responsible of deforming the vets is separated in two parts: the first part executes the bind functions, the second runs the functions for the actual deformations of vertices. 
  If the vertices are not bound, the parameter isDisabled, that checks if the depsgraph should not execute the modifier, is true.
  When the Bind operator is executed, it forces the modifier execution; if the modifier is executed when there are no verts bound, it runs the bind functions and then, after setting isDisabled to false, exits its own execution, ready to be called by the depsgraph to deform the vertices. When the vertices are already bound, it skips the first part and directly goes to the vert deformation functions.
   This could be the way our grease pencil modifier will act. We can use a similar exec function for the operator to the Surface Deform and Mesh Deform “Bind”(and Unbind) operators; similar UI also (make the text change between “Bind” and “Unbind” depending on the modifier state.

The grease pencil surface deform modifier should use the surface of a mesh to deform a grease pencil stroke. So all the computation made on the target mesh should be taken as it is from the “MOD_surfacedeform.c” file – this includes especially the functions “computeBindWeights” and “bindVert”. The internal weight system of the Surface Deform modifier helps smooth the deformation.

WORK DONE SO FAR

I started off copying the file MOD_surfacedeform.c from the /modifiers/intern/ folder, renamed it and put it in
/source/blender/gpencil_modifiers/intern/MOD_gpencilsurdeform.c

I copied off the data structures in /source/blender/makesdna/DNA_gpencil_modifier_types.h
and the main defaults DNA_gpencil_modifier_defaults.h

I added the Bind operator in /source/blender/editors/object/object_gpencil_modifier.c
and its reference in /source/blender/editors/object/object_ops.c

I also added all the references needed to add the modifier to the modifier list: /source/blender/gpencil_modifiers/MOD_gpencil_modifiertypes.h
/source/blender/gpencil_modifiers/intern/MOD_gpencil_util.c
/source/blender/makesdna/intern/dna_defaults.c

I added the RNA:
/source/blender/makesrna/intern/rna_gpencil_modifier.c

Finally, I edited the CmakeLists.txt accordingly.

I decided to internally name the new modifier “SurDeform” because of the name of the data structure: “SurfaceDeformGpencilModifierData” was too long and it overflowed. On the contrary, “SurDeformGpencilModifierData” is ok. I changed every internal name accordingly (modifierType_Gpencil_SurDeform, GPENCIL_OT_gpencilsurdeform_bind,
eGpencilModifierType_SurDeform, MOD_gpencilsurdeform.c) to avoid any confusion.

Now in the MOD_gpencilsurdeform.c file, I needed to fit the mesh modifier functions to the grease pencil modifier.
First off, the “deformVerts” function becomes “deformStroke”. This is tricky because we don’t have access to all the points in the grease pencil, but only the current stroke, and the strokes are evaluated one at a time.

So I added an extra structure in the makesdna/DNA_gpencil_modifier_types.h file: SDefGPStroke. I also renamed SDefBind and SdefVert to SDefGPBind and SDefGPVert.
The SDefGPStroke structure’s first variable, “verts”, is a pointer to the verts array of instances of the SDefGPVert structure.
Then it also contains “stroke_verts_num”, which is the total number of verts in the stroke, analogue to its SurfaceDeformModifierData counterpart.
A pointer to an array of SDefGPStroke’s is kept in the SurDeformGPencilModifierData structure.

The array of SDefGPStroke’s is allocated through a new function I made for the purpose in the MOD_gpencilsurdeform.c file, “static bool first_bind(uint strokes_num, SurDeformGpencilModifierData *smd)”. It is called during the first stroke’s bind, as the name suggests, and it’s only called if the pointer gps→prev is NULL, where “gps” is the bGPDstroke
passed to the deformStroke function, meaning this is the first stroke. This is because when the modifier calculation is forced outside of the depsgraph’s evaluation to execute the bind function, though the Bind operator, it should also cycle through each stroke and launch the bind function every time.
Accordingly, I edited the copyData and freeData functions, to include the new allocated array. I also edited these functions to fit the grease pencil modifier way, replacing the “BKE” functions with their grease pencil counterparts.

The flagsystem is unchanged. I disabled for now the extra functionalities of the modifier, because I ‘m not sure they can be useful in grease pencil but that will be addressed in the future, after the basic implementation of the modifier. Because of this, the only working flag is GP_MOD_SDEF_BIND and seems to work as intended, both as an indicator for the operator UI display of text (“Bind”/”Unbind”) and as an indicator of whether or not to proceed with the evaluation; it also makes an appearance in the isDisabled function, as a condition that has to be met for the modifier to be not considered disabled.

So what works now?
The modifier can be added on a Grease Pencil object; its UI and RNA properties work, so it can also be edited via Python. The Bind operator also works and can execute bind, and display “Bind” or “Unbind” text in the right way.

Now on to the things that don’t work yet.

- When the bind is executed, the array that holds the **bind vert data is sometimes empty**, and it has to be retried (click bind/unbind a few times) until on the fourth or fifth time it works and bind data is written. This problem has yet to be investigated.
- **Difference between smd_eval and smd_orig**. There are two modifiers in memory: the original and the evaluated one. It is not clear to me the reason why there’s two, and when, how and if one gets updated to the other one. This has caused confusion and failure of the deformVert function that is executed from the BLI_task_parallel_range function.

    The “deformVert” function, not to be confused with “deformVerts”, is a function from MOD_surfacedeform.c that deforms a single vertex according to the SDefDeformData
    structure that it’s fed.
    The execution of the function **crashes blender or does nothing altogether**; the debug shows a discrepancy in the stroke_verts_num variable we talked about earlier from the two modifiers in memory. This could be the reason why it doesn’t work, because it executes the function 0 times, or why it hangs, because it executes the deformVert function an undefined number of times! But the crash could be related to something else entirely, either way I’m gonna find out.
     I’m going to investigate this issue first because I want to see the GP points deforming!

Other proposals

Grease to mesh addon. The addon on Blender cloud by Simon Thonnes currently converts a grease pencil into a geometry – even animated ones.

    Though it doesn’t convert materials and other grease pencil functionalities like masks.
    The grease pencil is known to have problems in render, in the sense that it sometimes renders above objects that are in front of it – reason why the Grease to Mesh addon has been so useful.
    Converting Grease Pencil to a mesh before rendering could solve the above problem, so a functional way to do so can be found using the addon as a starting point.
    A similar interface, but could skip the intermediate part where it converts it to a curve and generate geometry using the bmesh module.

    - Stroke: generate a circle with as many vertices as the user input resolution, around the coordinates of the gp point with the stroke thickness as radius, and a tangent vector to the two edges touching a point can be used for the normal of this circle.
    - Fill: generate vertices on the coordinates of gp points and grid fill the resulting figure.
    - Booleans can be used for masks and materials can be converted using a premade node tree that simulates the grease pencil look, which can be later edited by the user.

    The addon seems possible to be created entirely in Python.

Work done so far:
- My version of the grease to mesh addon creates the geometry using bmesh.
- Masks are not yet supported.
- Materials are currently created with vertex colors and some corrective nodes, due to gamma issues issues with reading and recreating the grease pencil colors.

[CLICK HERE FOR THE VIDEO!](https://youtu.be/fiS-5CTulRM) [Most up-to-date code here, for Blender 3.5 Release branch](https://projects.blender.org/blender/blender/pulls/105935) (https://projects.blender.org/blender/blender/pulls/105935) I am Elisabetta Abbattista. I work at MAD Entertainment, an animation studio you may recognize because of my co-workers’ involvement in the community – such as Ivan Cappiello and Corrado Piscitelli. We work with Blender and everyday we look for new techniques for our production. Lately we’ve been using Grease Pencil quite a lot, because we found it an amazing and versatile tool, though it still has a long way to go and a big room for improvement. We would like to improve Blender for everyone, so we thought that a good way to give some new functionality to Grease Pencil without giving up all its current features would be giving it a new modifier – the Grease Pencil equivalent of Surface Deform. **Reasons**: we have rigged models with grease pencil strokes drawn on them. These gp’s should move together with the rigged models, but their weighting process is tedious and inaccurate. They should hang onto the mesh surface and deform along with it or a dedicated mesh cage. **Surface deform modifier implementation for grease pencil** **What I’m looking for**: Feedback from developers about the actual feasibility of the goals and methods. I will post updates about the work done so far on the new modifier. The work is currently just started. **How we are going to do it**: - Add the new file “blender/source/blender/gpencil_modifiers/intern/MOD_gpencilsurfacedeform.c” and edit the other relevant files accordingly. ``` ``` - Copy code from the Surface Deform modifier. We can look into both the Mesh Deform and Surface Deform modifiers. But since the strokes have to lay on the surface of mesh objects, it seems more convenient to use the same method of “Surface Deform” modifier to achieve this, even though it had been originally thought for clothes. - Write the deformation system for the grease pencil strokes and points. ``` The Surface Deform modifier stores a transformation matrix for each of the affected vertices in its mesh, and applies it to the evaluated mesh. There isn’t consistency in the use of stroke/points deformation functions in grease pencil modifiers. Armature, lattice and shrinkwrap grease pencil modifiers use BKE functions external to the MOD_gmencilmodifiername.c file. Noise uses the “deformStroke” function itself. Hook uses functions within its file. We could follow the “Offset” grease pencil modifier way and use the “deformStroke” function to apply a matrix it has generated to every gp point in the stroke. So what we want to do is get this kind of reference and multiply it with the matrix we generate via the same method of Surface Deform. I suppose it’s better to have a separate function that takes the matrices from the modifier data like the mesh object modifier counterparts. Separate functions will also take care of generating these matrices on bind, and store them in the modifier data structures. ``` - Add the Bind operator. ``` In the Surface Deform and the Mesh Deform modifiers, the function responsible of deforming the vets is separated in two parts: the first part executes the bind functions, the second runs the functions for the actual deformations of vertices. If the vertices are not bound, the parameter isDisabled, that checks if the depsgraph should not execute the modifier, is true. When the Bind operator is executed, it forces the modifier execution; if the modifier is executed when there are no verts bound, it runs the bind functions and then, after setting isDisabled to false, exits its own execution, ready to be called by the depsgraph to deform the vertices. When the vertices are already bound, it skips the first part and directly goes to the vert deformation functions. This could be the way our grease pencil modifier will act. We can use a similar exec function for the operator to the Surface Deform and Mesh Deform “Bind”(and Unbind) operators; similar UI also (make the text change between “Bind” and “Unbind” depending on the modifier state. ``` The grease pencil surface deform modifier should use the surface of a mesh to deform a grease pencil stroke. So all the computation made on the target mesh should be taken as it is from the “MOD_surfacedeform.c” file – this includes especially the functions “computeBindWeights” and “bindVert”. The internal weight system of the Surface Deform modifier helps smooth the deformation. **WORK DONE SO FAR** I started off copying the file MOD_surfacedeform.c from the /modifiers/intern/ folder, renamed it and put it in /source/blender/gpencil_modifiers/intern/MOD_gpencilsurdeform.c I copied off the data structures in /source/blender/makesdna/DNA_gpencil_modifier_types.h and the main defaults DNA_gpencil_modifier_defaults.h I added the Bind operator in /source/blender/editors/object/object_gpencil_modifier.c and its reference in /source/blender/editors/object/object_ops.c I also added all the references needed to add the modifier to the modifier list: /source/blender/gpencil_modifiers/MOD_gpencil_modifiertypes.h /source/blender/gpencil_modifiers/intern/MOD_gpencil_util.c /source/blender/makesdna/intern/dna_defaults.c I added the RNA: /source/blender/makesrna/intern/rna_gpencil_modifier.c Finally, I edited the CmakeLists.txt accordingly. I decided to internally name the new modifier “SurDeform” because of the name of the data structure: “SurfaceDeformGpencilModifierData” was too long and it overflowed. On the contrary, “SurDeformGpencilModifierData” is ok. I changed every internal name accordingly (modifierType_Gpencil_SurDeform, GPENCIL_OT_gpencilsurdeform_bind, eGpencilModifierType_SurDeform, MOD_gpencilsurdeform.c) to avoid any confusion. **Now in the MOD_gpencilsurdeform.c file**, I needed to fit the mesh modifier functions to the grease pencil modifier. First off, the “deformVerts” function becomes “deformStroke”. This is tricky because we don’t have access to all the points in the grease pencil, but only the current stroke, and the strokes are evaluated one at a time. So I added an **extra structure** in the makesdna/DNA_gpencil_modifier_types.h file: **SDefGPStroke**. I also renamed SDefBind and SdefVert to SDefGPBind and SDefGPVert. The SDefGPStroke structure’s first variable, “verts”, is a pointer to the verts array of instances of the SDefGPVert structure. Then it also contains “stroke_verts_num”, which is the total number of verts in the stroke, analogue to its SurfaceDeformModifierData counterpart. A pointer to an array of SDefGPStroke’s is kept in the SurDeformGPencilModifierData structure. **The array of SDefGPStroke’s is allocated** through a new function I made for the purpose in the MOD_gpencilsurdeform.c file, “static bool first_bind(uint strokes_num, SurDeformGpencilModifierData *smd)”. It is called during the first stroke’s bind, as the name suggests, and it’s only called if the pointer gps→prev is NULL, where “gps” is the bGPDstroke passed to the deformStroke function, meaning this is the first stroke. This is because when the modifier calculation is forced outside of the depsgraph’s evaluation to execute the bind function, though the Bind operator, it should also cycle through each stroke and launch the bind function every time. Accordingly, I edited the copyData and freeData functions, to include the new allocated array. I also edited these functions to fit the grease pencil modifier way, replacing the “BKE” functions with their grease pencil counterparts. The **flag**system is unchanged. I disabled for now the extra functionalities of the modifier, because I ‘m not sure they can be useful in grease pencil but that will be addressed in the future, after the basic implementation of the modifier. Because of this, the only working flag is GP_MOD_SDEF_BIND and seems to work as intended, both as an indicator for the operator UI display of text (“Bind”/”Unbind”) and as an indicator of whether or not to proceed with the evaluation; it also makes an appearance in the isDisabled function, as a condition that has to be met for the modifier to be not considered disabled. **So what works now?** The modifier can be added on a Grease Pencil object; its UI and RNA properties work, so it can also be edited via Python. The Bind operator also works and can execute bind, and display “Bind” or “Unbind” text in the right way. Now on to the things that *don’t* work yet. - When the bind is executed, the array that holds the **bind vert data is sometimes empty**, and it has to be retried (click bind/unbind a few times) until on the fourth or fifth time it works and bind data is written. This problem has yet to be investigated. - **Difference between smd_eval and smd_orig**. There are two modifiers in memory: the original and the evaluated one. It is not clear to me the reason why there’s two, and when, how and if one gets updated to the other one. This has caused confusion and failure of the deformVert function that is executed from the BLI_task_parallel_range function. ``` The “deformVert” function, not to be confused with “deformVerts”, is a function from MOD_surfacedeform.c that deforms a single vertex according to the SDefDeformData structure that it’s fed. The execution of the function **crashes blender or does nothing altogether**; the debug shows a discrepancy in the stroke_verts_num variable we talked about earlier from the two modifiers in memory. This could be the reason why it doesn’t work, because it executes the function 0 times, or why it hangs, because it executes the deformVert function an undefined number of times! But the crash could be related to something else entirely, either way I’m gonna find out. I’m going to investigate this issue first because I want to see the GP points deforming! ``` **Other proposals** - Grease to mesh addon. The addon on Blender cloud by Simon Thonnes currently converts a grease pencil into a geometry – even animated ones. ``` Though it doesn’t convert materials and other grease pencil functionalities like masks. The grease pencil is known to have problems in render, in the sense that it sometimes renders above objects that are in front of it – reason why the Grease to Mesh addon has been so useful. Converting Grease Pencil to a mesh before rendering could solve the above problem, so a functional way to do so can be found using the addon as a starting point. A similar interface, but could skip the intermediate part where it converts it to a curve and generate geometry using the bmesh module. ``` - Stroke: generate a circle with as many vertices as the user input resolution, around the coordinates of the gp point with the stroke thickness as radius, and a tangent vector to the two edges touching a point can be used for the normal of this circle. - Fill: generate vertices on the coordinates of gp points and grid fill the resulting figure. - Booleans can be used for masks and materials can be converted using a premade node tree that simulates the grease pencil look, which can be later edited by the user. ``` The addon seems possible to be created entirely in Python. ``` - **Work done so far**: - My version of the grease to mesh addon creates the geometry using bmesh. - Masks are not yet supported. - Materials are currently created with vertex colors and some corrective nodes, due to gamma issues issues with reading and recreating the grease pencil colors.

Elisabetta Abbattista self-assigned this 2022-08-09 18:42:19 +02:00

Elisabetta Abbattista commented

2022-08-09 18:42:19 +02:00

Added subscriber: @bettiabba

Antonio Vazquez commented

2022-08-09 20:16:20 +02:00

Added subscribers: @filedescriptor, @ChengduLittleA, @antoniov

Antonio Vazquez commented

2022-08-09 20:16:20 +02:00

Very interesting proposal. This modifier is a common request that I have received but hadn't time to look at it because I'm not an expert in the mesh deformation code.

Some general ideas:

All strokes are evaluated by frame for the current frame. This is different in meshes where all frames are computed at the same time. This is done due performance problems (we are working in a new data structure that will solve this).
The modifier evaluates stroke by stroke. This process select what strokes must be processed and apply the changes in the evaluation copy of the stroke.
For some modifiers, like lattice modifier, we have a function that makes an initial calculation and put in cache to avoid the calculation for each stroke.

About the code, the best is create a patch and keep updating it during the process. In this way different developers can look at your code and help you yo fix small issues or give you ideas.

I'm really very excited to see what are you going to do.

About add-ons, We have a claymation add-on that converts GPencil to meshes and with some improvements not included in Simon code, for example materials, and other code simplifications because I added some C core functions since Simon created the original add-on.

CC: @filedescriptor @ChengduLittleA

Very interesting proposal. This modifier is a common request that I have received but hadn't time to look at it because I'm not an expert in the mesh deformation code. Some general ideas: * All strokes are evaluated by frame for the current frame. This is different in meshes where all frames are computed at the same time. This is done due performance problems (we are working in a new data structure that will solve this). * The modifier evaluates stroke by stroke. This process select what strokes must be processed and apply the changes in the evaluation copy of the stroke. * For some modifiers, like lattice modifier, we have a function that makes an initial calculation and put in cache to avoid the calculation for each stroke. About the code, the best is create a patch and keep updating it during the process. In this way different developers can look at your code and help you yo fix small issues or give you ideas. I'm really very excited to see what are you going to do. About add-ons, We have a claymation add-on that converts GPencil to meshes and with some improvements not included in Simon code, for example materials, and other code simplifications because I added some C core functions since Simon created the original add-on. CC: @filedescriptor @ChengduLittleA

Antonio Vazquez changed title from ~~Enable grease pencil binding to deforming meshes~~ to GPencil: Enable binding to deforming meshes

2022-08-09 20:16:50 +02:00

Antonio Vazquez commented

2022-08-09 20:17:20 +02:00

Changed status from 'Needs Triage' to: 'Confirmed'

Antonio Vazquez commented

2022-08-09 20:17:44 +02:00

Added subscribers: @mendio, @pepe-school-land

Yuro commented

2022-08-14 09:28:37 +02:00

Added subscriber: @Yuro

hamza.SMA commented

2022-08-26 17:44:20 +02:00

Added subscriber: @hamza-el-barmaki

Ivan Cappiello commented

2022-10-30 16:51:39 +01:00

Added subscriber: @icappiello

Elisabetta Abbattista commented

2022-12-04 23:12:45 +01:00

Progress update:

The stroke deformation finally works! I submitted a diff file and attached it to this task. https://developer.blender.org/D16692

Currently working:

Bind of vertices and allocation of bind data for run time
Deformation of vertices along with the cage mesh in edit mode
Armature modifier on the cage mesh can drive the grease pencil deformation!

Currently not working:

Bind on Grease Pencil made of more than one stroke -- buggy
Blend write data (can't save the modifier data properly) -- buggy
Modifier options and parameters -- not yet implemented

Warning about the diff patch:
It's a patch for Blender 3.3. I worked on a fork of the blender-v3.3-release branch, because new GP modifiers are being added to the master branch and this caused a conflict of memory, so I switched to an old, stable release to have a more stable working enviromnent.

Progress update: The stroke deformation finally works! I submitted a diff file and attached it to this task. https://developer.blender.org/D16692 Currently working: - Bind of vertices and allocation of bind data for run time - Deformation of vertices along with the cage mesh in edit mode - Armature modifier on the cage mesh can drive the grease pencil deformation! Currently not working: - Bind on Grease Pencil made of more than one stroke -- buggy - Blend write data (can't save the modifier data properly) -- buggy - Modifier options and parameters -- not yet implemented Warning about the diff patch: It's a patch for Blender 3.3. I worked on a fork of the blender-v3.3-release branch, because new GP modifiers are being added to the master branch and this caused a conflict of memory, so I switched to an old, stable release to have a more stable working enviromnent.

Elisabetta Abbattista commented

2022-12-13 12:05:32 +01:00

Progress update:

Currentky working:

The modifier can now be saved and read in a blend file properly!
Now the bind and deformation work for more than one stroke.

Issue I'm investigating right now:

Error management in case strokes are added or removed after bind. The modifier should be unbinded and data freed.

Going to post updated code soon!

Progress update: Currentky working: - The modifier can now be saved and read in a blend file properly! - Now the bind and deformation work for more than one stroke. Issue I'm investigating right now: - Error management in case strokes are added or removed after bind. The modifier should be unbinded and data freed. Going to post updated code soon!

Elisabetta Abbattista commented

2023-01-18 21:42:33 +01:00

Progress update:

I updated the diff once more. Soon a video showcasing the modifier is going to come out!
I will demonstrate the two ues of the modifier:

For attaching grease pencil feaures to mesh models;
For rigging grease pencil models using a mesh cage!

Now working:

Various bugs that prevented the modifier from working most of the times are now fixed!
Works both with strokes and fills!
Works with rigged meshes!

Not yet working:

Sometimes it will crash.
Undo won't work most of the times
Options do nothing
Frame changing is not accounted for

Progress update: I updated the diff once more. Soon a video showcasing the modifier is going to come out! I will demonstrate the two ues of the modifier: 1) For attaching grease pencil feaures to mesh models; 2) For rigging grease pencil models using a mesh cage! Now working: - Various bugs that prevented the modifier from working most of the times are now fixed! - Works both with strokes and fills! - Works with rigged meshes! Not yet working: - Sometimes it will crash. - Undo won't work most of the times - Options do nothing - Frame changing is not accounted for

Adam Earle commented

2023-01-19 14:23:55 +01:00

Added subscriber: @AdamEarle

Adam Earle commented

2023-01-19 14:23:55 +01:00

What is it that you are really wanting to achieve here?

Can you create a fake example or diagram of the purpose? If I'm incorrect, apologies. This sounds like trying to get automatic tweens through some kind of rigging setup.
If so there is another way that this can be approached that could be more basic than the current approach and less technical for the animator on setup.

What is it that you are really wanting to achieve here? Can you create a fake example or diagram of the purpose? If I'm incorrect, apologies. This sounds like trying to get automatic tweens through some kind of rigging setup. If so there is another way that this can be approached that could be more basic than the current approach and less technical for the animator on setup.

Paolo Acampora commented

2023-01-19 20:02:02 +01:00

Added subscriber: @PaoloAcampora

Ross commented

2023-01-20 15:37:15 +01:00

Added subscriber: @4thDimension

Elisabetta Abbattista commented

2023-01-20 18:44:53 +01:00

Here is the explanatory video: https://youtu.be/fiS-5CTulRM

Adam Earle commented

2023-01-20 21:46:24 +01:00

WOW! Great presentation! It's exactly what I thought you were doing. I can see how everybody will be going crazy over this feature for hybrid animation. I am curious as to why you went in this direction, but that is for another time and space.
I will leave by saying, well done and my thoughts are with you so you can bring it across the finish line.

WOW! Great presentation! It's exactly what I thought you were doing. I can see how everybody will be going crazy over this feature for hybrid animation. I am curious as to why you went in this direction, but that is for another time and space. I will leave by saying, well done and my thoughts are with you so you can bring it across the finish line.

Daniel Martinez Lara commented

2023-01-21 11:38:43 +01:00

Great work and great video Elisabetta! I definitely have to test it :)

Max Cajazeiras commented

2023-01-22 11:11:51 +01:00

Added subscriber: @MaxCajazeiras

Jorge commented

2023-02-01 12:52:30 +01:00

Added subscriber: @JorgeVP

Philipp Oeser removed the

Download

What's New

Blender Studio

Manual

Developers Blog

Documentation

Benchmark

Blender Conference

Development Fund

One-time Donations

GPencil: Enable binding to deforming meshes #100301