erkaman

Source code is here: https://github.com/Erkaman/fluid_sim

this is some flashy fluid simulations made using the techniques described in the article "Fast Fluid Dynamics Simulation on the GPU".

The code is minimalistic and is written in only ~1000LOC of C++, and uses only OpenGL and no frameworks whatsoever, so the code should be pretty readable.

Finally, note that the primary focus was on making flashy simulations, and not on physical realism.

Some months ago, I interviewed for a job as a junior graphics programmer for various game companies, in order to break into the industry. Since computer graphics is a very niche field, there is not very much information out there on what questions are common during an interview for such a job. So I decided to compile this little list of common questions, and to write some general advice about how you can prepare for the interview. Hope someone finds this useful. :)

yeah, radial basis functions are awesome :)

global refinement and unrefinement steps are unnecessary, yes. It just makes the implementation of the demo so much easier. It is possible to only refine the patch, and then fuse the patch with the original mesh, and then global refinement is not necessary. But this is actually surprisingly tricky to robustly implement in practice, and did not implement it mostly due to time restrictions, and to keep the demo code short and readable.

Yeah, I think it's heavily inspired by that yes. Many techniques in geometry processing take heavy inspiration by image processing techniques.

I also appreciate the provided references.

I agree with you mostly. I just think that this is an interesting usage of variational calculus, which is not that well understood by other programmers, so I wanted to write this article about this, in order to introduce other programmers to the topic.

And also because I thought the literature about this out there wasn't really that readable, and I always think there is value in writing expository texts like this.

A blog post from me about smoothly filling holes in a 3D mesh. Small demo application can be found here:

https://github.com/Erkaman/hole_fixer

you can see more examples in the linked repo:

https://github.com/Erkaman/poisson_blend

yes, the mask is also pretty important. otherwise, you get lots of stuff from the background of your source image in your blended image, which often looks pretty bad.

since the technique is so simple, it's probably not hard at all to include into GIMP. Wouldn't surprise me if someone had already implemented a plugin for it.

In this artice, I describe a technique that can be used to seamlessly copy-and-paste one image into another. I also provide source code(https://github.com/Erkaman/poisson_blend), that demonstrates the concepts in the article.

Basically because it takes a lot of calculation and time to add them, so I didn't add the feature yet. I am working on making the calculation faster.

Hi, this is a demo that me and my friend have worked on for some weeks. Note that it takes a while to load the demo

In case the demo doesn't run, I have prepared a video of it here(https://www.youtube.com/watch?v=1bykYClXkRg)

This is a demo that implements laplacian deformation in Javascript. Laplacian deformation is a technique that allows you to deform an arbitrary mesh as if it were a cloth-like material. In the demo, you can grab handles on the mesh, and drag them. The vertices of the rest of the mesh are then smoothly updated, resulting in a deformation. The deformations produced by this technique tend to look natural, since the general shape of the mesh is preserved. This kind of technique is useful in 3D-modeling software.

Ah, thanks for the tip :-)

OP here. This is a small code example of how to use Vulkan for compute operations. Only ~400LOC. It's pretty short, and has plenty of comments, so it should be useful for people learning Vulkan, I hope.

Hello, I'm the writer of this demo. Because this is WebGL, this demo may or may not run, so here(https://github.com/Erkaman/webgl-rsm) you can see an image of what it should look like.

This is an implementation of Indirect Lighting using Reflective Shadow Maps(http://www.klayge.org/material/3_12/GI/rsm.pdf). This technique results in some nice color bleeding effects, which can be seen in the red glow on Lucy(statue) and the blue glow on the cute rabbit. This is light that has bounced from the colored walls.

The implementation details can be found in the repo: https://github.com/Erkaman/webgl-rsm#implementation-details

I'm the author. The source code is here: https://github.com/Erkaman/cute-deferred-shading

This is a cute little implementation of normal deferred shading. The focus of this implementation was readability and brevity, so that others can learn from the code. The entire renderer is only about 1400 lines of C++ code. Note that there are probably ways in which the implementation can be made faster, but such optimizations were not performed to keep things brief, and readable.

Hello, I'm the author. Some weeks ago, I posted here a reference implementation of automatic UV-mapping with harmonic mapping(https://github.com/Erkaman/auto_uv_map). I promised that I would write an article that explains the mathematics of the source code, and here it is.

I wanted to write this article because all the existing literature on this topic is pretty difficult, and I wanted to see if I could solve that issue by writing my own article about it. But as I was writing it, I discovered that this stuff is pretty damn hard to explain, and it made me sort of understand why all the existing literature is hard to read.

But my hope is that this article at least succeeds in explaining the intuition behind the technique. If there's anything that is not clear in the article, please ask here, and I will attempt to explain.

This is just a quick experiment where I tried generating clouds using vector graphics.