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.

Hello, I am the author. This is a reference implementation of automatic UV mapping using Harmonic Mapping. Because the existing literature on this topic is so hard to understand, it took me quite a while to figure out how to implement this. Because of that, I thought I'd publish a reference implementation of this technique, so that other who want to do automatic UV mapping don't have to go through all the pain that I did. To my knowledge, this is the first readable reference implementation of Harmonic Mapping. If you search quite a bit, you can find other implementations of Harmonic Mapping, but they are messy, poorly commented, and hard to understand. In difference to these, my implementation aims to be readable, and easy to integrate into other projects. Hopefully, I have achieved this goal.

But unfortunately, if you try and read the source code of my implementation, you may find that it is hard to understand why it actually works. Unless you grasp the underlying mathematics, it is probably difficult to understand the code. That is why I am currently working on writing an article that explains the underlying mathematics. I shall publish that article here once it is done. Until then, please be patient.

The original MNIST training data made the assumption that the digits are not flipped. But you could solve it by creating more training data by flipping the original digits. But then you suddenly end up with an awful lot of data, and then the training process would take days, literally.

Yeah, it was really painful. In order to speed up the process, I first implemented the network on the CPU, so that I could quickly verify my GPU implementation.

Yeah, reading from floating point textures with `glReadPixels` is not really supported on some cards or browsers, it seems.

Wow, so there are other people who have tried doing deep learning in WebGL! But I will also give it a try, and see if I can do it better than you.

Yeah, the MNIST dataset is not that great it seems. At least for recognising real handwritten digits.

I had plans to do that, but that means implementing all of TensorFlows functionality in Javascript, which is a huge pain and lots of work. But if we restricted all networks to a strict subset of TensorFlow, it can be done, I think.

I am storing all data in textures, and you can read data from textures by binding the texture to an fbo, set that fbo to the default fbo, and then read the data with `glReadPixels`

that kind of 4 doesn't exist in the training set. This works: http://imgur.com/gallery/xnFnF

Hmm, may be a problem with your graphics card. What's your graphics card and browser?