Wow, I am so sorry I didn't respond to your post in a timely manner! I'm only like 2 months late... Thank you so much for posting the PDF to the portals presentation, it was quite illuminating. Someone actually reached out with a correct solution (minus light teleportation), which put a swift end to all of my struggling. Keven Weber is the man who solved all my issues, along with the help of @toadstorm. I've attached the project file below if anyone is curious about it.
Thanks again for responding
KW__Portals.hipnc

Howdy partners,
So one of the g00ns (Flight404) in our lil chat group had a question on dynamically cutting a triangle by its edge duals (basically create a triangle with the midpoints of each edge, and then 3 other new triangles that each connect back to one of the input triangles points) which i thought was a fun problem. Luckily i have tons of experience in this area as I've been dealing with similar problems for that KD-Tree teaser thing I mentioned briefly at the end of my last post (go watch it). Unfortunately i can't think of a parallel method for solving the problem that doesn't create overlapping points on edges (since 2 prims can contain the same edge, solving on prims will double up points on shared edges), but I did get it running pretty fast. It's a QT 3.14 effect, and I've done my best to comment the code. It's all relatively simple, so hopefully you learn some stuff clicking through it!
Gosh I really need to update my website with this stuff...
JR_TriDiv.hip

Follow-Up: So I've been spinning my wheels on this for another week and really don't have a ton to show for it. I'm attaching the latest pass, I believe I've gotten the camera transforms all worked out, but i still really don't understand the clip-space portion of the problem. My current method is to use camera projected UV's as a way to define the clip space, and it seems pretty close. But it's definitely incorrect. I'm currently building it purely in SOPs as it's way to hard to debug rotations in /mat/, so hopefully this'll be easier to read/help with.
JR_PORTALS_v007_ODFORCE.hipnc

WeEEeeEee it's been a minute since I've posted anything in here!!!! I'm sure at this point principal component analysis (PCA), and covariance matrixes are old news to pretty much everyone, but with the release of H16.5 i thought it'd be fun to build a little a file that shows off how you can use smooth distance (defined by the edge transport node), to fuel a discrete curvature algorithm! Wow!
I've commented the covariance code, so hopefully it makes some kind of sense. I actually should just make a little blog post about PCA but until then, this'll have to do!
You're probably confused as to why this requires the edge transport node, and the reasoning is that without it (say you just do a pc-lookup to define the area we test the curvature against) you don't get an accurate curvature due to both errors in the mesh quality, and the fact that you're not doing a connectivity based curvature calculation in that case. However, those would easily outperform this method speed wise. Other methods, like those described in this Houdini Gubbins blog post are going to be faster as well (and maybe more accurate), however those come with issues of their own, like requiring the input mesh to be triangulated, among others.
Total side thing, but I've been working on some dynamic mesh slicing algorithms, and have been making a little short to show that off. Here's a sneak preview :)
EDIT: Read petz's breakdown below for far more accurate info on curvature values, mine is a total approximation (it's still a fun toy to play with), but his description is way more accurate in explaining the nuances of this stuff!!!
JR_Curvature_EdgeTransport.hipnc

Howdy my dudes,
I've been taking at a stab at building out a "portal" type shader for a few days now, and I'm pretty stuck. To elaborate, the goal is to basically to render from a second camera onto a texture (or render buffer), and then project it onto a piece of geometry to be rendered like any other object. Thus creating the illusion of looking into one portal, and out of a second portal (just like the game Portal). I've already solved rendering from the perspective of the other camera (I think.... I basically rebuilt fromNDC() in /mat/), however I'm currently stuck on how to project it properly back onto the geometry.
Let's define the current render camera as "CameraA" and the second, portal camera as "CameraB" for ease of explanation.
The issue that I'm running into is that the method I'm using requires me to sample the rendered scene from CameraB, as a texture. The reasoning being, that we need to clip the texture to make sure we're not looking at a squashed scene, but rather a scene that's clipped by the bounds of the portal geometry. However as far as I'm aware, there's nothing like Unity's render targets in Houdini. You could argue that, that's the purpose of the Render COP, however it's far slower than just shooting more rays into the scene from CameraB. Mestela sent me this lovely video by Roman Saldygashev in which he achieved the effect in mantra, so i know it's possible.
For even more context, I've been following along with this post by Tom Hulton and his implementation in Unity, http://tomhulton.blogspot.com/2015/08/portal-rendering-with-offscreen-render.html
Though in the attached file, I don't include the camera matching transformations he describes, let's just focus on the portal rendering....
I'm going to attach my test file to this post so all the smart people here can rip it to shreds. Please let me know if you think I'm totally approaching this problem incorrectly as well, as shader math is certainly not my strongest skill...
If anyone has a link to the "Stupid RenderMan Tricks" pdf that inspired both Roman's effect and Tom's effect, that'd be incredible, because all searches on my end have turned up empty, so i'm kinda just winging it right now.
JR_PORTALS_v004.hipnc

Uh oh, I'm back.
While putzing around, trying to come up with good ideas for my next blog post (covering discrete operators seems a bit too mathy, so I'm open to suggestions. Maybe building a cloth solver in VEX?), I spent some time revisiting an old idea I've been attempting to solve for the better part of a year, rolling up a curve. That's probably not the best way to describe the effect, so I'll let my below GIF do the talking.
This solution wouldn't have been anywhere close to possible without Stephen Bester (https://vimeo.com/user13305957) for a solid vex foundation of chained rotations, or Julian Johnson's transport frame file (http://julianjohnsonsblog.blogspot.com/2017/).
Above you'll see final effect in action. Still not sure how to describe it other than rolling up a curve...
I've attached the final OTL to this post along with the above example HIP! It works over multiple curves as well, so dont be afraid to try crazy stuff with it, it's pretty gosh darn fun! If you try it on a vertical line, you might need to change the up direction, or turn off "set up direction."
Maybe it's time to make a Github too...
<3 <3 <3
JR_CurveRoll.zip

Sorry for making this thread and then going silent for a while, a lot has happened over the past few months, including me moving to LA on a whim... But I'm back!!!! I have tons of new files to share, which I'll push out in the coming weeks.
Today I had a couple of hours to play with Houdini before going to an Escape Room (wish me luck), and I had been discussing the Laplace-Beltrami operator with a couple of buddies on discord for a long time, so i thought, why not implement one myself! After having thought about it for so long it actually didn't involve anything I hadn't already done, or covered in my blogs for that matter (go read them!!!!).
The implementation is based off this paper: http://www.cs.princeton.edu/courses/archive/fall10/cos526/papers/sorkine05.pdf
I did comment the wrangle so hopefully it makes sense. One caveat, is that this version does not include border weighting, so watch out for crazy minimization. For production, just use the attribute blur sop, this is more just me exploring weird math stuff that makes me question my art school degree...
<3 <3 <3
P.S. there's a little ray tracing demo in there as well, since my roommate wanted to understand normals, and I went a bit too far off the deep end in explaining it to him....
EDIT: Petz has brought up a few issues with this, I will make a revision soon
JR_Laplacian_v001.hip

You could also try something like Jeff Jones's Physarum Form Finding algorithm!
It's actually pretty simple to implement in Houdini, assuming you have the patience to read the paper!
http://eprints.uwe.ac.uk/15260/1/artl.2010.16.2.pdf

HI FRIENDS!
So over the past year I've been doing far too much Houdini in my free time, and I noticed that all of the people I look up to in the community have their own cute ODForce threads. So with the release of my latest blog post on Voronoi Diagrams and Remeshing, I thought it best to make one of those threads, to avoid flooding the Education section with tons of new posts...
Anyways here's a link to my new blog post: https://medium.com/@jakerice_7202/voronoi-for-the-people-60c0f11b0767
And if the link itself isn't enough, here are a couple of GIFs from the blog post, including one that didn't make the cut.
All credit for the post title goes to @mestela <3
Big thanks to @toadstorm for editing my grammar as well, and the whole ThinkProcedural discord for putting up with my insanity

Ah that's a very interesting distinction. After doing a bit more research it appears i need to compute the dual using the circumcenters of a deluanay triangulation in order to compute the dual. Radical, i might take a crack at that today since I have a bit of free time, will post result in a bit =)

Damn three of my favorite tech wizards all commenting on muh post! Thanks for the kind words!!! Another thing I neglected to mention in the post is that the dual of delaunay triangle graph is a voronoi diagram, so really this can also be used as a vex method of generating voronoi diagrams. What that means for us is, assuming you run it on a mesh generated from "Triangulate 2D," you should get a voronoi diagram of the input points! Neat!

Hi friends!
I just released an article on Medium walking through how I built a "Compute Dual" wrangle in VEX. As a quick summary, I basically wanted to know how the "Compute Dual" feature of the divide sop worked, so i slapped together a neat lil wrangle, to do just that!
CLICK ME TO GO TO THE ARTICLE!!!!!!!!
Here's a cute little gif showing off the construction of a dual graph. If you like it, please check out the article, it's free and it'd mean the whole world to me! =)
Love you fools,
Jake
http://jakericedesigns.com/