Category: production

https://henry123-boy.github.io/SpaTracker/

(more…)

It connects Nuke with the ComfyUI server, any plugin that comes out in ComfyUI can be used in nuke, rotos with sam, rescaling, image generation, inpaintins, normal generator, the nodes are IPAdapter, ControlNet, AnimateDiff, etc.

https://github.com/vinavfx/nuke_comfyui

https://renderman.pixar.com/whats-new

https://rmanwiki.pixar.com/display/REN26/RenderMan+26.0

https://www.keheka.com/creating-procedural-3d-fog-in-nuke/

https://www.procedural-anatomy.com/

https://www.nukepedia.com/gizmos/time/vectorframeblend

Blend up to 11 nearby frames together, while preserving all detail

VectorFrameBlend can average/median/min/max/plus up to +- 5 frames with full motion awareness. Compared to the last version or other similar solutions, I built it as technically correct as possible and it provides thorough settings to improve the filtering quality and edge cases (literally).

You can also use the ‘External’ mode and connect the ‘vec’ input to another VectorFrameBlend, to use its internally generated vectors.

This can be useful, if you want to analyse a certain layer (for example a diffuse color pass that holds a lot of clean details), but apply the frame blending on somewhere else. Apart from that, the tool can of course be used on live action plates, utility passes or whatever comes to mind.

(more…)

https://lightcraft.pro/

https://github.com/thunil/TecoGAN

https://github.com/magnoborgo/ComfyUINuke/

Open Shading Language (OSL) is a small but rich language for programmable shading in advanced renderers and other applications, ideal for describing materials, lights, displacement, and pattern generation.

https://open-shading-language.readthedocs.io/en/main/

https://github.com/AcademySoftwareFoundation/OpenShadingLanguage

https://github.com/sambler/osl-shaders

https://www.replikant.com/

https://www.awn.com/news/dreamworks-animation-release-moonray-open-source

https://openmoonray.org/

MoonRay is DreamWorks’ open-source, award-winning, state-of-the-art production MCRT renderer, which has been used on feature films such as How to Train Your Dragon: The Hidden World, Trolls World Tour, The Bad Guys, the upcoming Puss In Boots: The Last Wish, as well as future titles. MoonRay was developed at DreamWorks and is in continuous active development and includes an extensive library of production-tested, physically based materials, a USD Hydra render delegate, multi-machine and cloud rendering via the Arras distributed computation framework.

Note: it does not support osl and usd handling is limited. Cycles may still be a fair alternative.

https://www.cgchannel.com/2024/03/adobe-open-sources-its-usd-conversion-plugins/

Supir

https://github.com/Fanghua-Yu/SUPIR/issues/38

Civitai

https://civitai.com/tag/upscale

OpenModelDB

https://openmodeldb.info/

https://ltx.studio/

https://www.artstation.com/blogs/se_carri/XOBq/the-god-of-war-texture-optimization-algorithm-mip-flooding

“delve into an algorithm developed by Sean Feeley, a Senior Staff Environment Tech Artist that is part of the creative minds at Santa Monica Studio. This algorithm, originally designed to address edge inaccuracy on foliage, has the potential to revolutionize the way we approach texture optimization in the gaming industry. ”

https://unity-research.github.io/holo-gen/

https://splitthediff.com/performance-timers/

LightIt is a script for Maya and Arnold that will help you and improve your lighting workflow.
Thanks to preset studio lighting components (lights, backdrop…), high quality studio scenes and HDRI library manager.

https://www.artstation.com/artwork/393emJ

https://wzx.gumroad.com/l/lightit

A Zen of Python is a list of 19 guiding principles for writing beautiful code. Zen of Python was written by Tim Peters and later added to Python.

Here is how you can access the Zen of Python.

import this
print(this)

Output:

The Zen of Python, by Tim Peters

• Beautiful is better than ugly.
• Explicit is better than implicit.
• Simple is better than complex.
• Complex is better than complicated.
• Flat is better than nested.
• Sparse is better than dense.
• Readability counts.
• Special cases aren’t special enough to break the rules.
• Although practicality beats purity.
• Errors should never pass silently.
• Unless explicitly silenced.
• In the face of ambiguity, refuse the temptation to guess.
• There should be one– and preferably only one –obvious way to do it.
• Although that way may not be obvious at first unless you’re Dutch.
• Now is better than never.
• Although never is often better than *right* now.
• If the implementation is hard to explain, it’s a bad idea.
• If the implementation is easy to explain, it may be a good idea.
• Namespaces are one honking great idea — let’s do more of those!

https://hellothisistim.com/blog/comp-rules/

• • Rule 1: Keep it simple.
  • Rule 2: Faster is better.
  • Rule 3: Build trust.
  • Rule 4: You won’t be the last person to work on it.
  • Rule 5: Check your work.
  • Rule 6: Every rule has an exception.
  • Rule 7: Facilitate changes.

https://www.vizcom.ai/

This project implements RIFE – Real-Time Intermediate Flow Estimation for Video Frame Interpolation for The Foundry’s Nuke.

RIFE is a powerful frame interpolation neural network, capable of high-quality retimes and optical flow estimation.

This implementation allows RIFE to be used natively inside Nuke without any external dependencies or complex installations. It wraps the network in an easy-to-use Gizmo with controls similar to those in OFlow or Kronos.

https://github.com/rafaelperez/RIFE-for-Nuke

https://smerf-3d.github.io/