Trying to add a new pass to render proxy mesh Normals in UV space

[aVersionOfReality]

I am trying to make a setup that will render Object Normals in UV space from a proxy mesh. Basically, a live baking setup (which I guess is also similar to rendering the Shadow Map). This is to solve the problem of mesh level Normal Transfer not being viable in real time rendering (hopefully I can get something working in Unity/Unreal in the long run too, but gotta start here.) I am looking for any input on how to get this working, or if there's a better way to approach it, or if this won't work at all and is a bad idea.

Here's the basic idea I have so far:

1. The mesh and proxy mesh share UVs (done using UV transfer.)
2. The mesh and proxy mesh are combined into one object (by geometry nodes), with some ID to determine which is which (currently vertex colors)
3. An extra render pass is run in which the Proxy mesh (monkey) is set to its UV map position as shown below. The non-proxy mesh would be scaled to 0 (not shown)

4. This UV space of the proxy mesh is then rendered with an orthographic camera, and a Normals shader.
   

5. When the mesh is rendered regularly, this rendered texture is used as the Normals.

I assume this would be something like this, with options for which UV map(s) to use, resolution, etc:

So I've got the basic theory. What I'm missing is how to setup another pass and camera. Is this mostly a matter of python or glsl? How is the shadow map camera done?

I've been looking up some general glsl info, but the problem I'm running into is that I don't know enough to separate general glsl info from any specific context. Lots of what I'm finding is written for other engines, and I don't know what's a glsl thing and what's a Unity thing vs Malt context thing. My glsl knowledge is the "node to code" sort. I don't know anything about pipeline.

[pragma37]

Assuming the meshes have different topology, and that they're animated so they need to be baked constantly, I would do something like:

• Create a custom plugin.
• Add a custom per-object parameter with a "bake toggle" and a "bake index".
• Add a custom python render node that filter the objects with the bake toggle, removes them from the scene, and renders the bake into a Texture Array at its "bake index" (this assumes all the baked textures have the same resolution), you don't need a camera for this.
• Add a TextureShaderResource that binds the texture array to materials.
• Add a GLSL node that declares the texture array uniform and a function that allows reading the texture at a given index.

I'll link you to some references in the code that do similar stuff:

• Custom Plugin with custom nodes
• Custom Parameters (You would do this by implementing the plugin register_pipeline_parameters function).
• Basics of rendering (this and this)
• Render from a Node
• TextureArray FBOs

Maybe start by supporting a single object and a single baked texture, then move on to multiple objects and the TextureArray.
Also, for learning low-level rendering you may have an easier time by playing with the MiniPipeline, since there's less stuff going on.