{"id":931,"date":"2026-08-19T15:10:57","date_gmt":"2026-08-19T15:10:57","guid":{"rendered":"https:\/\/summergeometry.org\/sgi2026\/?p=931"},"modified":"2026-08-26T06:07:25","modified_gmt":"2026-08-26T06:07:25","slug":"research-and-production-for-games","status":"publish","type":"post","link":"https:\/\/summergeometry.org\/sgi2026\/research-and-production-for-games\/","title":{"rendered":"Research and Production for Games"},"content":{"rendered":"\n<h2 class=\"wp-block-heading\">Visualizing and Evaluating Skin Weight Transfer<\/h2>\n\n\n\n<p class=\"has-small-font-size wp-block-paragraph\">By Shannon Cudworth<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">My goal for this project was to implement visualization methods that help artists gauge the accuracy of skin weight transfer methods, which takes the skin weights from an already rigged mesh, and assigns the correct weights to the target mesh. I compared two different weight transfer methods. First, Maya\u2019s built-in copySkinWeights: which takes a vertex on the unrigged mesh, finds the closest point on the source mesh, and interpolates the weights at that point to determine the weights at the vertex. Next, a method developed by EpicGames, which copies the weights from the source mesh that have a high-confidence correspondence. For the remaining vertices, it computes the weights by interpolating from the transferred high-confidence weights.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">To begin, I downloaded a character with an animation from Mixamo and imported it into Maya. In my first pass comparison, I unbound the shirt from the character, and then rebound it using Maya\u2019s copySkinWeights and EpicGames\u2019 Weight Inpaint method. Below is a playblast of each character. Notice that with the copySkinWeights there is a jagged concave area in the upper back region, while with the Weight Inpaint method, that area is smooth.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Now, I wanted to develop a method to visually compare the two algorithms. I created a heatmap using the error formula.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Expanding on the previous idea, I wanted to develop a dynamic heat map that shows the areas with the highest deformation error over the entire animation. I created a node that took the display\/method mesh and reference mesh as inputs, and then took the 3D vertex position of each of the meshes. To calculate the deformation error, I calculated the Euclidean distance between the 3D vertex positions of the method I was evaluating and the 3D vertex position of the original mesh. This is calculated with:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><msub><mi>d<\/mi><mi>i<\/mi><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>=<\/mo><msub><mrow><mo fence=\"true\" form=\"prefix\">\u2016<\/mo><msubsup><mi>x<\/mi><mi>i<\/mi><mrow><mtext><\/mtext><mi>method<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>\u2212<\/mo><msubsup><mi>x<\/mi><mi>i<\/mi><mrow><mtext><\/mtext><mi>original<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo fence=\"true\" form=\"postfix\">\u2016<\/mo><\/mrow><mn>2<\/mn><\/msub><\/mrow><annotation encoding=\"application\/x-tex\">d_i(t) = \\left\\| x_i^{\\mathrm{method}}(t) &#8211; x_i^{\\mathrm{original}}(t) \\right\\|_2<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">where i represents the ith vertex of the matrix, <math><semantics><mrow><msubsup><mi>x<\/mi><mi>i<\/mi><mrow><mtext><\/mtext><mi>method<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">x_i^{\\mathrm{method}}(t)<\/annotation><\/semantics><\/math> is the 3D position of vertex i on the method mesh at frame t, <math><semantics><mrow><msubsup><mi>x<\/mi><mi>i<\/mi><mrow><mtext><\/mtext><mi>original<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">x_i^{\\mathrm{original}}(t)<\/annotation><\/semantics><\/math> is the 3D position of vertex i on the original method at frame t.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">To construct the heat map, we normalize and clamp with:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><msub><mover><mi>d<\/mi><mo stretchy=\"false\">~<\/mo><\/mover><mi>i<\/mi><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>=<\/mo><mrow><mi>min<\/mi><mo>\u2061<\/mo><\/mrow><mrow><mo fence=\"true\" form=\"prefix\">(<\/mo><mfrac><mrow><msub><mi>d<\/mi><mi>i<\/mi><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\" lspace=\"0em\" rspace=\"0em\">)<\/mo><\/mrow><mi>c<\/mi><\/mfrac><mo separator=\"true\">,<\/mo><mspace width=\"0.1667em\"><\/mspace><mn>1<\/mn><mo fence=\"true\" form=\"postfix\">)<\/mo><\/mrow><\/mrow><annotation encoding=\"application\/x-tex\">\\tilde{d}_i(t) = \\min\\left(\\frac{d_i(t)}{c},\\,1\\right)<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">where c is the maximum deformation distance.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">We then mapped the errors to colors and wrote all vertex colors to the output mesh with setVertexColors(). We then have our finished output mesh with our desired heatmap. As the animation changes, the input meshes will change, causing the heatmap to update with each frame. This was packaged into a UI for easier use.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Here is the heat map applied to a shirt that was rigged using Maya\u2019s copySkinWeights:<\/p>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"486\" style=\"aspect-ratio: 838 \/ 486;\" width=\"838\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/copySkinWeights_dancing_dynamicheatmap.mp4\"><\/video><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Here is the heat map applied to a shirt that was rigged using EpicGames Inpaint method:<\/p>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"486\" style=\"aspect-ratio: 838 \/ 486;\" width=\"838\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/inpaint_dynamic_heatmap.mp4\"><\/video><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Reference: <a href=\"https:\/\/www.dgp.toronto.edu\/~rinat\/projects\/RobustSkinWeightsTransfer\/index.html\">EpicGames Inpaint Method<\/a><\/p>\n\n\n\n<h2 class=\"wp-block-heading\">TextDeformer: How can words shape the (virtual) world<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Researched by: Jos\u00e9 Pablo Soto S\u00e1nchez<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Introduction<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Imagine handing a sculptor a block of clay and, instead of tools, just a sentence: &#8220;make this a giraffe.&#8221; No reference photos, no measurements, just words, and the expectation that the clay reshapes itself to match. That&#8217;s roughly what <a href=\"https:\/\/threedle.github.io\/TextDeformer\/\">TextDeformer<\/a> (Gao et al., SIGGRAPH 2023) does to a 3D mesh: given a source shape and a target text prompt, it deforms the geometry until a frozen vision-language model agrees that the render looks like the prompt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">What makes this interesting isn&#8217;t just the result it&#8217;s used purely as a differentiable critic. The actual &#8220;learning&#8221; happens directly on the geometry: a set of per-triangle Jacobian matrices gets optimized by gradient descent, the same way you&#8217;d optimize the weights of a network, except here the &#8220;weights&#8221; are literally how each triangle is allowed to stretch and rotate.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">This post walks through reproducing the official TextDeformer codebase end-to-end on consumer hardware, the math that makes text-to-geometry gradients possible at all, and the specific things that broke along the way and how they got fixed.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Background<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">A few terms are worth pinning down before the method section, since the pipeline sits at the intersection of graphics and vision-language modeling:<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Term<\/th><th>Plain-language definition<\/th><\/tr><\/thead><tbody><tr><td><strong>CLIP<\/strong><\/td><td>A frozen, pretrained model that embeds images and text into the same vector space, so cosine similarity between an image embedding and a text embedding measures &#8220;how well does this image match this caption.&#8221;<\/td><\/tr><tr><td><strong>Differentiable rendering<\/strong><\/td><td>Turning a 3D mesh + camera into a 2D image using operations (rasterization, shading) that support backpropagation, so pixel-level loss can flow gradients back to vertex positions.<\/td><\/tr><tr><td><strong>Jacobian (per-triangle)<\/strong><\/td><td>A 3\u00d73 matrix describing how a single triangle is locally stretched\/rotated relative to its original shape. TextDeformer optimizes one of these per face, directly.<\/td><\/tr><tr><td><strong>Poisson mesh reconstruction<\/strong><\/td><td>Given a target Jacobian per triangle, solving a linear system to recover the vertex positions whose actual local deformation best matches those targets, in a least-squares sense.<\/td><\/tr><tr><td><strong>Cotangent Laplacian<\/strong><\/td><td>A sparse matrix built from mesh geometry that encodes how each vertex relates to its neighbors; it&#8217;s the operator at the center of the Poisson solve.<\/td><\/tr><tr><td><strong>ViT patch<\/strong><\/td><td>A Vision Transformer splits an image into fixed-size square tiles (&#8220;patches&#8221;) and treats each one like a token \u2014 patch size determines how fine-grained the model&#8217;s spatial resolution is.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Method<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>CLIP-guided losses<\/strong><\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The core signal is cosine similarity between a rendered image&#8217;s CLIP embedding and the target text&#8217;s CLIP embedding:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><msub><mi class=\"mathcal\">\u2112<\/mi><mrow><mrow><mi mathvariant=\"normal\">\u0394<\/mi><\/mrow><mtext>clip<\/mtext><\/mrow><\/msub><mo>=<\/mo><mo form=\"prefix\" stretchy=\"false\">\u2212<\/mo><mrow><mi>cos<\/mi><mo>\u2061<\/mo><\/mrow><mo fence=\"false\" symmetric=\"true\" minsize=\"1.2em\" maxsize=\"1.2em\">(<\/mo><msub><mi>f<\/mi><mtext>img<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mover><mi>I<\/mi><mo stretchy=\"false\" class=\"tml-capshift\">^<\/mo><\/mover><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>\u2212<\/mo><msub><mi>f<\/mi><mtext>img<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><msub><mi>I<\/mi><mtext>base<\/mtext><\/msub><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo separator=\"true\">,<\/mo><mtext>&nbsp;<\/mtext><mtext>&nbsp;<\/mtext><msub><mi>f<\/mi><mtext>text<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mtext>target<\/mtext><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>\u2212<\/mo><msub><mi>f<\/mi><mtext>text<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mtext>base<\/mtext><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo fence=\"false\" symmetric=\"true\" minsize=\"1.2em\" maxsize=\"1.2em\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">\\mathcal{L}_{\\Delta\\text{clip}} = -\\cos\\big(f_{\\text{img}}(\\hat{I}) &#8211; f_{\\text{img}}(I_{\\text{base}}),\\ \\ f_{\\text{text}}(\\text{target}) &#8211; f_{\\text{text}}(\\text{base})\\big)\n<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">But optimizing this alone tends to drift toward whatever image maximizes similarity to the prompt, not necessarily a <em>smooth deformation<\/em> of the source shape. TextDeformer adds a delta-CLIP term that instead matches the <em>change<\/em> in image embedding against the <em>*change*<\/em> in text embedding, relative to a fixed base render\/prompt (e.g. &#8220;a cow&#8221;):<\/p>\n\n\n\n<p class=\"has-text-align-center wp-block-paragraph\"><math><semantics><mrow><msub><mi class=\"mathcal\">\u2112<\/mi><mtext>clip<\/mtext><\/msub><mo>=<\/mo><mo form=\"prefix\" stretchy=\"false\">\u2212<\/mo><mrow><mi>cos<\/mi><mo>\u2061<\/mo><\/mrow><mo fence=\"false\" symmetric=\"true\" minsize=\"1.2em\" maxsize=\"1.2em\">(<\/mo><msub><mi>f<\/mi><mtext>img<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mover><mi>I<\/mi><mo stretchy=\"false\" class=\"tml-capshift\">^<\/mo><\/mover><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo separator=\"true\">,<\/mo><mtext>&nbsp;<\/mtext><msub><mi>f<\/mi><mtext>text<\/mtext><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mtext>&#8220;a&nbsp;giraffe&#8221;<\/mtext><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo fence=\"false\" symmetric=\"true\" minsize=\"1.2em\" maxsize=\"1.2em\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">\\mathcal{L}_{\\text{clip}} = -\\cos\\big(f_{\\text{img}}(\\hat{I}),\\ f_{\\text{text}}(\\text{&#8220;a giraffe&#8221;})\\big)<\/annotation><\/semantics><\/math><\/p>\n\n\n\n<p class=\"wp-block-paragraph\">This directional formulation (used in prior CLIP-guided editing work) keeps the deformation anchored to the source identity instead of collapsing onto an unrelated &#8220;giraffe-like&#8221; blob.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Per-triangle Jacobians and the Poisson solve<\/strong><\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">This is the part that replaces a neural decoder entirely. Given the mesh&#8217;s gradient operator <math><semantics><mi>G<\/mi><annotation encoding=\"application\/x-tex\">G <\/annotation><\/semantics><\/math> (one 3\u00d73 block per face) and a diagonal mass matrix <math><semantics><mi>M<\/mi><annotation encoding=\"application\/x-tex\">M<\/annotation><\/semantics><\/math> of face areas, the cotangent Laplacian is built as:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><mi>L<\/mi><mo>=<\/mo><msup><mi>G<\/mi><mi>\u22a4<\/mi><\/msup><mi>M<\/mi><mi>G<\/mi><\/mrow><annotation encoding=\"application\/x-tex\">L = G^\\top M G\n<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\"><math><semantics><mi>L<\/mi><annotation encoding=\"application\/x-tex\">L<\/annotation><\/semantics><\/math> has a one-dimensional null space (constant functions), so the implementation drops the first row\/column to pin a single vertex before it&#8217;s usable for Cholesky factorization. To go from optimized per-face Jacobians <math><semantics><mi>J<\/mi><annotation encoding=\"application\/x-tex\">J<\/annotation><\/semantics><\/math> back to vertex positions <math><semantics><mi>v<\/mi><annotation encoding=\"application\/x-tex\">v<\/annotation><\/semantics><\/math>, the code solves the normal equations of a least-squares problem \u2014 find the <math><semantics><mi>v<\/mi><annotation encoding=\"application\/x-tex\">v<\/annotation><\/semantics><\/math> whose <em>actual<\/em> gradient <math><semantics><mrow><mi>G<\/mi><mi>v<\/mi><\/mrow><annotation encoding=\"application\/x-tex\">Gv<\/annotation><\/semantics><\/math> is as close as possible to the <em>target<\/em> Jacobians <math><semantics><mi>J<\/mi><annotation encoding=\"application\/x-tex\">J<\/annotation><\/semantics><\/math>, weighted by face area:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><msup><mi>v<\/mi><mo>\u2217<\/mo><\/msup><mo>=<\/mo><mrow><mi>arg<\/mi><mo>\u2061<\/mo><mspace width=\"0.1667em\"><\/mspace><\/mrow><munder><mi>min<\/mi><mi>v<\/mi><\/munder><mo>\u2061<\/mo><mi>\u2016<\/mi><mi>G<\/mi><mi>v<\/mi><mo>\u2212<\/mo><mi>J<\/mi><msubsup><mi>\u2016<\/mi><mi>M<\/mi><mn>2<\/mn><\/msubsup><mspace width=\"1em\"><\/mspace><mo stretchy=\"false\">\u27f9<\/mo><mspace width=\"1em\"><\/mspace><mi>L<\/mi><mspace width=\"0.1667em\"><\/mspace><mi>v<\/mi><mo>=<\/mo><msup><mi>G<\/mi><mi>\u22a4<\/mi><\/msup><mi>M<\/mi><mi>J<\/mi><\/mrow><annotation encoding=\"application\/x-tex\">v^* = \\arg\\min_v \\| Gv &#8211; J \\|_M^2 \\quad\\Longrightarrow\\quad L\\, v = G^\\top M J<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">That linear system is factorized once per mesh with a sparse Cholesky solver (`cholespy`, GPU-resident) and re-solved every optimization step as <math><semantics><mi>J<\/mi><annotation encoding=\"application\/x-tex\">J<\/annotation><\/semantics><\/math> changes \u2014 cheap after the one-time factorization. A Jacobian regularization term, <math><semantics><mrow><mi>\u2016<\/mi><mi>J<\/mi><mo>\u2212<\/mo><mi>I<\/mi><msup><mi>\u2016<\/mi><mn>2<\/mn><\/msup><\/mrow><annotation encoding=\"application\/x-tex\">\\| J &#8211; I \\|^2<\/annotation><\/semantics><\/math>, keeps triangles from stretching into degenerate shapes.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Rendering and camera augmentation<\/strong><\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Each step, a batch of random cameras (elevation drawn from a Beta distribution, azimuth uniform over 360\u00b0, random distance\/FOV\/lighting\/background) renders the current mesh via&nbsp;<code>nvdiffrast<\/code>&#8216;s differentiable rasterizer. Randomizing viewpoint and lighting every step is what prevents the optimizer from exploiting a single &#8220;good&#8221; camera angle instead of actually deforming the geometry.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Patch-level consistency loss<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">A second, separate CLIP ViT is used only for its intermediate patch features (via forward hooks on each transformer block). For pairs of cameras within the same batch that are close in elevation\/azimuth, the patches that project to the same 3D vertex are compared \u2014 encouraging the same surface point to look consistent from nearby viewpoints, which curbs the multi-view incoherence (&#8220;Janus-face&#8221;-style artifacts) common to CLIP-guided 3D optimization.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Implementation<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Getting the reference implementation running at all.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The repo pins specific commits for&nbsp;<code>nvdiffrast<\/code>&nbsp;and installs&nbsp;<code>igl<\/code>&nbsp;unpinned via conda-forge. The unpinned&nbsp;<code>igl<\/code>&nbsp;immediately caused a break: <code>igl.random_points_on_mesh<\/code>&nbsp; in&nbsp; <code>MeshProcessor.py<\/code>&nbsp;expected a 2-tuple return&nbsp;<code>(bary, face_idx)<\/code>, but the installed libigl build now returns a 3-tuple&nbsp;<code>(B, FI, P)<\/code>. Fixed by unpacking a third, unused value \u2014 a reminder that &#8220;no version pin&#8221; in a 2023 paper repo means the API surface has already drifted.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Fighting the GPU context, not the geometry.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The next failure had nothing to do with the algorithm:&nbsp; <code>dr.RasterizeGLContext()<\/code>&nbsp;threw&nbsp;<code>cudaGraphicsGLRegisterBuffer<\/code>&nbsp;(CUDA error 304,&nbsp;<code>cudaErrorOperatingSystem<\/code>) on first render.&nbsp;<code>[VERIFY: root cause inferred from the error code and hybrid-GPU laptop symptoms, not confirmed via driver-level logs]<\/code>&nbsp;\u2014 the working hypothesis is that Windows was creating the OpenGL context on the integrated GPU while CUDA ran on the discrete GPU, breaking the CUDA\u2194GL interop&nbsp;<code>nvdiffrast<\/code>&nbsp;relies on. The pinned&nbsp;<code>nvdiffrast<\/code>&nbsp;commit doesn&#8217;t expose the pure-CUDA rasterizer (<code>RasterizeCudaContext<\/code>&nbsp;isn&#8217;t present in this build), so the fix was OS-level: explicitly forcing the Python process to the discrete GPU in Windows&#8217; graphics settings, rather than a code change.<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"244\" src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57-1024x244.png\" alt=\"\" class=\"wp-image-963\" srcset=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57-1024x244.png 1024w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57-300x71.png 300w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57-768x183.png 768w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57-1200x286.png 1200w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-57.png 1227w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Finding the actual VRAM ceiling.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">With rendering working, the default config (<code>batch_size=25<\/code>,&nbsp;<code>train_res=512<\/code>) ran out of memory on a 6 GB laptop GPU (RTX 4050) partway through the first step. The batch dimension and the render resolution both scale memory close to linearly, so both got reduced (<code>batch_size=4<\/code>,&nbsp;<code>train_res=256<\/code>) until a full 2,500-step run completed without OOM. This became the baseline configuration for every later experiment.<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"532\" src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-1024x532.png\" alt=\"\" class=\"wp-image-965\" srcset=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-1024x532.png 1024w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-300x156.png 300w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-768x399.png 768w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-1536x798.png 1536w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59-1200x623.png 1200w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/image-59.png 1842w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Swapping CLIP backbones without breaking assumptions baked into the code.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><code>clip_model<\/code>&nbsp;and&nbsp;<code>consistency_clip_model<\/code>&nbsp;are independently configurable, but the consistency-loss implementation (<code>utilities\/clip_spatial.py<\/code>) hardcodes assumptions that only hold for the &#8220;Base&#8221; ViT variants: a&nbsp;<code>for i in range(12)<\/code>&nbsp;loop over transformer blocks (<code>ViT-L\/14<\/code>&nbsp;has 24), and an assertion that the patch stride evenly divides the patch size (<code>ViT-L\/14<\/code>&#8216;s 14px patch isn&#8217;t divisible by the default stride of 8, unlike 32px\/16px).&nbsp;<code>RN50<\/code>&nbsp;\u2014 a convolutional backbone \u2014 can&#8217;t be used for the consistency loss at all, since that code depends on ViT-style patch tokens that a ResNet simply doesn&#8217;t produce.&nbsp;<code>ViT-B\/32<\/code>,&nbsp;<code>ViT-B\/16<\/code>, and&nbsp;<code>RN50<\/code>&nbsp;(as the primary loss only) were compared under an identical seed\/mesh\/prompt to keep the comparison controlled;&nbsp;<code>ViT-B\/32<\/code>&nbsp;was kept as the default going forward, primarily because it fit the VRAM budget without further code changes.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Debugging a mesh, not the code.<\/strong><\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">A custom&nbsp;<code>tuna.obj<\/code>&nbsp;mesh failed with&nbsp;<code>CHOLMOD: not positive definite<\/code>&nbsp;inside the Cholesky factorization. The Laplacian&nbsp;<math xmlns=\"http:\/\/www.w3.org\/1998\/Math\/MathML\"><semantics><mrow><mi>L<\/mi><\/mrow><\/semantics><\/math><em>L<\/em>&nbsp;is only positive-definite after pinning&nbsp;<em>one<\/em>&nbsp;null-space direction \u2014 which is correct for a single connected mesh, but insufficient if the mesh has multiple disconnected components (each contributes its own null direction). The tuna model&#8217;s eyes turned out to be separate, unwelded geometry. Diagnosing this required leaving the codebase entirely and going into Maya: using&nbsp;<code>Mesh \u2192 Separate<\/code>&nbsp;to count connected shells,&nbsp;<code>Combine<\/code>&nbsp;+&nbsp;<code>Merge<\/code>&nbsp;(vertex welding by distance) to attempt reattachment, and re-running&nbsp;<code>Separate<\/code>&nbsp;as the verification step (if it can no longer split the mesh, it&#8217;s genuinely one piece). Welding never fully closed the gap without visibly displacing the eyes during remeshing, so the pragmatic fix was deleting the eye geometry outright, producing&nbsp;<code>tunaNoEyes.obj<\/code>&nbsp;\u2014 a reminder that not every mesh bug is worth solving at the mesh level when the pipeline&#8217;s actual requirement (single connected component) can be satisfied more simply.<\/p>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"512\" style=\"aspect-ratio: 512 \/ 512;\" width=\"512\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/video_log-3.mp4\"><\/video><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Stale caches and unattended runs.<\/strong><\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><code>MeshProcessor<\/code>&nbsp;caches differential operators and Jacobian&nbsp;<code>.npz<\/code>&nbsp;files under&nbsp;<code>&lt;output_path&gt;\/tmp\/<\/code>&nbsp;and silently reuses them if present \u2014 convenient for resuming, dangerous if the source mesh changes but the output path doesn&#8217;t: a later run against a re-exported (different vertex count)&nbsp;<code>tuna.obj<\/code>&nbsp;crashed in a sparse matrix multiply because the cached operators no longer matched. Once that class of bug was understood, a small driver script (<code>run_batch.py<\/code>) was written to chain multiple mesh\/prompt runs sequentially \u2014 the single 6 GB GPU rules out any parallelism \u2014 each with a fresh output directory and its own log file, so a several-hour unattended batch could run overnight without one failed run silently corrupting the next.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Results<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Five source\u2192target pairs were run to completion on the final configuration (<code>batch_size=4<\/code>,&nbsp;<code>train_res=256<\/code>,&nbsp;<code>ViT-B\/32<\/code>, single RTX 4050 Laptop GPU):<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th class=\"has-text-align-left\" data-align=\"left\">Source \u2192 Target<\/th><th class=\"has-text-align-left\" data-align=\"left\">Steps<\/th><th class=\"has-text-align-left\" data-align=\"left\">Wall-clock<\/th><\/tr><\/thead><tbody><tr><td>cow \u2192 giraffe (<code>spot.obj<\/code>)<\/td><td>5,000<\/td><td>1h 14m<\/td><\/tr><tr><td>fish \u2192 shark<\/td><td>10,000<\/td><td>2h 37m<\/td><\/tr><tr><td>eiffel tower \u2192 rocket<\/td><td>10,000<\/td><td>3h 21m<\/td><\/tr><tr><td>tuna \u2192 shark (<code>tunaNoEyes.obj<\/code>, remeshed)<\/td><td>10,000<\/td><td>2h 33m<\/td><\/tr><tr><td>guitar \u2192 axe<\/td><td>600<\/td><td>9m 39s<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"512\" style=\"aspect-ratio: 512 \/ 512;\" width=\"512\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/video_log-2.mp4\"><\/video><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Per-step cost stayed in a fairly narrow band (~0.89\u20131.2 s\/step) across meshes of similar triangle count, and scaled with&nbsp;<code>batch_size \u00d7 train_res<\/code>&nbsp;as expected from the rendering cost analysis above \u2014 the&nbsp;<code>guitar \u2192 axe<\/code>&nbsp;run at 600 steps was deliberately short (~10 minutes) as a fast-iteration sanity check rather than a converged result, and looks correspondingly less refined than the 10k-step runs.<\/p>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-8f761849 wp-block-group-is-layout-flex\">\n<figure class=\"wp-block-video\"><video height=\"512\" style=\"aspect-ratio: 512 \/ 512;\" width=\"512\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/video_log-1.mp4\"><\/video><\/figure>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"512\" style=\"aspect-ratio: 512 \/ 512;\" width=\"512\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/video_log.mp4\"><\/video><\/figure>\n<\/div>\n\n\n\n<h3 class=\"wp-block-heading\">Future Work<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Validate mesh topology before the Poisson solve, not during it.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The&nbsp;<code>tuna.obj<\/code>&nbsp;failure surfaced as a Cholesky exception deep inside training, three layers of traceback away from the actual cause (disconnected components). A pre-flight check \u2014 counting connected components with&nbsp;<code>igl<\/code>&nbsp;and failing fast with a clear message before any GPU work starts \u2014 would turn a confusing runtime crash into an immediate, actionable one, and is a small, self-contained addition to&nbsp;<code>MeshProcessor.py<\/code>.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\"><strong>Generalize the consistency-loss encoder beyond the &#8220;Base&#8221; ViT assumption.<\/strong>&nbsp;<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The hardcoded 12-layer loop and stride-divisibility requirement in&nbsp;<code>clip_spatial.py<\/code>&nbsp;make&nbsp;<code>ViT-L\/14<\/code>&nbsp;unusable for the consistency loss without a code change, and rule out testing community-trained checkpoints (e.g. LAION&#8217;s&nbsp;<code>ViT-B-32<\/code>&nbsp;retrained on LAION-2B via&nbsp;<code>open_clip<\/code>) that share the same architecture but arrive through a different loading path than OpenAI&#8217;s&nbsp;<code>clip<\/code>&nbsp;package. Both are architecture-family limitations, not fundamental ones \u2014 worth fixing before running a broader backbone ablation.<\/p>\n\n\n\n<h6 class=\"wp-block-heading\">Reference<\/h6>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"https:\/\/threedle.github.io\/TextDeformer\">https:\/\/threedle.github.io\/TextDeformer<\/a><\/p>\n\n\n\n<h2 class=\"wp-block-heading\">ShapeFlow: Morphing Between 3D Shapes<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">We also explored a method for morphing one 3D shape into another target 3D shape. We worked with ShapeFlow, a neural network that learns to deform an existing 3D shape into another through a continuous flow field. Given latent space encodings of a source and target shape, the model outputs a velocity field describing how each point on the source should move to arrive at the target. Because the flow is continuous and (under the right conditions) bijective, the resulting deformation is guaranteed to be free of self-intersections, and can optionally preserve volume. Both of these properties can be desirable for artists working with meshes, which makes ShapeFlow attractive for toolification. <\/p>\n\n\n\n<h4 class=\"wp-block-heading\">The Model<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">ShapeFlow&#8217;s creators frame the deformation of source shape <math><semantics><msub><mi>X<\/mi><mi>i<\/mi><\/msub><annotation encoding=\"application\/x-tex\">X_i<\/annotation><\/semantics><\/math> into target shape <math><semantics><msub><mi>X<\/mi><mi>j<\/mi><\/msub><annotation encoding=\"application\/x-tex\">X_j<\/annotation><\/semantics><\/math> as an advection process&#8211;the movement of a conserved property through fluid flow. Each point <math><semantics><mi>x<\/mi><annotation encoding=\"application\/x-tex\">x<\/annotation><\/semantics><\/math> on the source is carried along a flow field <math><semantics><mrow><mi>f<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>x<\/mi><mo separator=\"true\">,<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">f(x,t)<\/annotation><\/semantics><\/math> over an interpolation parameter <math><semantics><mrow><mi>t<\/mi><mo>\u2208<\/mo><mo form=\"prefix\" stretchy=\"false\">[<\/mo><mn>0,1<\/mn><mo form=\"postfix\" stretchy=\"false\">]<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">t\\in[0,1]<\/annotation><\/semantics><\/math>. Then, the points of the deformed source shape <math><semantics><msub><mi>\u03d5<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msub><annotation encoding=\"application\/x-tex\">\\phi_{ij}<\/annotation><\/semantics><\/math> are described as:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><msub><mrow><mi mathvariant=\"normal\">\u03a6<\/mi><\/mrow><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>x<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>=<\/mo><mi>x<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mn>1<\/mn><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo separator=\"true\">,<\/mo><mtext>&nbsp;where&nbsp;<\/mtext><mi>x<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>t<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>=<\/mo><mi>x<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mn>0<\/mn><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>+<\/mo><msubsup><mo>\u222b<\/mo><mn>0<\/mn><mi>t<\/mi><\/msubsup><msub><mi>f<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>x<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>\u03c4<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo separator=\"true\">,<\/mo><mi>\u03c4<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mspace width=\"0.2778em\"><\/mspace><mi>d<\/mi><mi>\u03c4<\/mi><\/mrow><annotation encoding=\"application\/x-tex\">\\Phi_{ij}(x)=x(1) , \\text{ where } x(t)=x(0)+\\int_0^t f_{ij}(x(\\tau),\\tau)\\;d\\tau<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Training seeks the mapping <math><semantics><msubsup><mrow><mi mathvariant=\"normal\">\u03a6<\/mi><\/mrow><mi>\u03b8<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msubsup><annotation encoding=\"application\/x-tex\">\\Phi_{\\theta}^{ij}<\/annotation><\/semantics><\/math> that minimizes the symmetric Chamfer distance between the deformed source and the target:<\/p>\n\n\n\n<div class=\"wp-block-math\"><math display=\"block\"><semantics><mrow><mi>m<\/mi><mi>i<\/mi><msub><mi>n<\/mi><mi>\u03b8<\/mi><\/msub><mspace width=\"1em\"><\/mspace><mi>C<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><msubsup><mrow><mi mathvariant=\"normal\">\u03a6<\/mi><\/mrow><mi>\u03b8<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><msub><mi>X<\/mi><mi>i<\/mi><\/msub><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo separator=\"true\">,<\/mo><msub><mi>X<\/mi><mi>j<\/mi><\/msub><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo>+<\/mo><mi>C<\/mi><mo form=\"prefix\" stretchy=\"false\">(<\/mo><msub><mi>X<\/mi><mi>i<\/mi><\/msub><mo separator=\"true\">,<\/mo><msubsup><mrow><mi mathvariant=\"normal\">\u03a6<\/mi><\/mrow><mi>\u03b8<\/mi><mrow><mi>j<\/mi><mi>i<\/mi><\/mrow><\/msubsup><mo form=\"prefix\" stretchy=\"false\">(<\/mo><msub><mi>X<\/mi><mi>j<\/mi><\/msub><mo form=\"postfix\" stretchy=\"false\">)<\/mo><mo form=\"postfix\" stretchy=\"false\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">min_\\theta \\quad C(\\Phi_{\\theta}^{ij}(X_i), X_j) + C(X_i, \\Phi_{\\theta}^{ji}(X_j))<\/annotation><\/semantics><\/math><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">So the output of ShapeFlow is this flow field or mapping <math><semantics><msubsup><mrow><mi mathvariant=\"normal\">\u03a6<\/mi><\/mrow><mi>\u03b8<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msubsup><annotation encoding=\"application\/x-tex\">\\Phi_{\\theta}^{ij}<\/annotation><\/semantics><\/math> that describes how each point on the source shape should advect in order for the source to become the target shape. How are the inputs to ShapeFlow created? What do we feed to the model?<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Recall, we said that the input to ShapeFlow is the pair of latent space encodings from the source and target shapes. For our implementation, we use an encoder that maps a mesh&#8217;s vertices to a latent space encoding using a single forward pass. The encoder is trained jointly with the deformer model, using the same Chamfer distance loss, so it learns to produce encodings that are useful for conditioning the flow field. <\/p>\n\n\n\n<h4 class=\"wp-block-heading\">The Toolification<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Our goal was to implement ShapeFlow as a Maya plug-in for artists&#8217; use in stylization and retopology of one mesh to another. To increase usability, we added blendshapes between the source mesh and the deformed source mesh by extracting and exporting intermediate results along the deformation path (sampling <math><semantics><mrow><msub><mi>\u03d5<\/mi><mrow><mi>i<\/mi><mi>j<\/mi><\/mrow><\/msub><mo form=\"prefix\" stretchy=\"false\">(<\/mo><mi>x<\/mi><mo form=\"postfix\" stretchy=\"false\">)<\/mo><\/mrow><annotation encoding=\"application\/x-tex\">\u03d5_{ij}(x)<\/annotation><\/semantics><\/math> at intermediate values of <math><semantics><mi>t<\/mi><annotation encoding=\"application\/x-tex\">t<\/annotation><\/semantics><\/math>). This way, an artist can scrub through the flow and select whichever stage best fits their needs. <\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Future Exploration &amp; Improvement<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">While implementing ShapeFlow as a Maya tool for artists, we ran into some areas of exploration for the performance of the tool. With more time we would have done more experimenting and development to ensure the model&#8217;s capabilities are consistent and high-performing for our desired use cases. On the SGI timeline we ultimately decided to balance exploration and execution and forge ahead with building out the tool while noting areas for improvement:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong> Initialization Sensitivity:<\/strong> Since the initialization of the model weights are random, results can vary widely based on whether one initialization was &#8220;good&#8221; for the specific meshes being used. <\/li>\n\n\n\n<li><strong>Loss Function Limitations:<\/strong> One of the use cases we wanted to develop ShapeFlow for was to create intermediate expressions for a given face mesh with certain extreme expressions. However, when morphing between meshes that differ only in a small region&#8211;for example puckered lips vs. a neutral expression&#8211;the region may be too small to affect the Chamfer distance loss during optimization. Other loss functions are worth evaluating for these cases.<\/li>\n\n\n\n<li><strong>Pretraining:<\/strong> If there are certain use cases (classes of objects, faces) that ShapeFlow will be used for, it might be beneficial to do pretraining on those types of shapes. Currently, our tool trains the deformer model from scratch every time. (This is also why the initialization sensitivity affects the results so strongly.) As a result, the model either will take an extremely long time with an appropriate  amount of training iterations, or be used after a lower number of training iterations with reduced fidelity. <\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">We did some manual tuning to get workable results on our test meshes, but making this robust enough for an artist&#8217;s workflow requires additional experimentation, testing, and development. <\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Results<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Below is a video demonstrating the Maya tool workflow. For the sake of time, in the video the model is only trained for 200 iterations (very low), which is one source of the poor or unfinished-looking output flow. <\/p>\n\n\n\n<figure class=\"wp-block-video\"><video height=\"1512\" style=\"aspect-ratio: 2554 \/ 1512;\" width=\"2554\" controls src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screen-Recording-2026-08-14-121458.mp4\"><\/video><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Below is an image showing how ShapeFlow can be used to produce a blend of two meshes. The ShapeFlow output (middle) is result of Toilet 1 (left) morphing into toilet 2 (right).<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"843\" src=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934-1024x843.png\" alt=\"\" class=\"wp-image-984\" srcset=\"https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934-1024x843.png 1024w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934-300x247.png 300w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934-768x632.png 768w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934-1200x988.png 1200w, https:\/\/summergeometry.org\/sgi2026\/wp-content\/uploads\/2026\/08\/Screenshot-2026-08-11-141934.png 1440w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n\n\n\n<h6 class=\"wp-block-heading\">Reference<\/h6>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"https:\/\/arxiv.org\/pdf\/2006.07982\">ShapeFlow<\/a><\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Visualizing and Evaluating Skin Weight Transfer By Shannon Cudworth My goal for this project was to implement visualization methods that help artists gauge the accuracy of skin weight transfer methods, which takes the skin weights from an already rigged mesh, and assigns the correct weights to the target mesh. I compared two different weight transfer [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[110],"tags":[],"ppma_author":[92,13,90],"class_list":["post-931","post","type-post","status-publish","format-standard","hentry","category-research"],"authors":[{"term_id":92,"user_id":0,"is_guest":1,"slug":"cap-shannon-cudworth","display_name":"shannon.cudworth","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","author_category":"","first_name":"","last_name":"","user_url":"","job_title":"","description":""},{"term_id":13,"user_id":0,"is_guest":1,"slug":"cap-0262205","display_name":"0262205","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","author_category":"","first_name":"","last_name":"","user_url":"","job_title":"","description":""},{"term_id":90,"user_id":0,"is_guest":1,"slug":"cap-scj2125","display_name":"scj2125","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","author_category":"","first_name":"","last_name":"","user_url":"","job_title":"","description":""}],"_links":{"self":[{"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/posts\/931","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/comments?post=931"}],"version-history":[{"count":10,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/posts\/931\/revisions"}],"predecessor-version":[{"id":1163,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/posts\/931\/revisions\/1163"}],"wp:attachment":[{"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/media?parent=931"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/categories?post=931"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/tags?post=931"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2026\/wp-json\/wp\/v2\/ppma_author?post=931"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}