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. :)
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.
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.
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.
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.
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.
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 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.