15

To get that authentic inky look, your best bet is probably to assemble a library of images of ink splats, streaks, and dribbles. Then you can randomly select some number of them to position & rotate randomly over one-half the image. (With a bias toward the seam edge so the middle of the Rorschach test is densest. You might be able to use a particle ...


8

You can try perlin noise (using a proper black/white gradient) , and then apply the right/left mirroring


7

To complete what Josh said, Convolution Matrix is what you want: Convolution in Gimp Another link What you probably are looking for: Convolution Kernels in OpenGL


7

This can be implemented as a post-processing kind of effect. (When using Unity/XNA/Dx/OGL/...) Geometry method Start by creating a mesh that resembles the distortion effect you are looking to achieve. (e.g. model a half cylinder (or cone, sphere, cube, ...), make sure to set the texture coordinates). Render your 2D game as usual, but render the final ...


7

1) The planet is "cartoon" like because it doesn't use any textures and has a large detail size. 2) The misted effect I'd call atmospheric scattering. There's a GPU Gem about this: http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter16.html. Alternatively (or additionally), add a fresnel effect to your shader. Alternatively, I've seen people fake ...


5

Anti-aliasing in a deferred shader is a complex topic. WikiPedia lists a number of techniques for doing anti-aliasing in a deferred-compatible way. Typically you'll need to do it after lighting, otherwise you can end up with lighting artifacts. Most approaches I know of do another pass on the scene after the entire deferred pipeline is complete. If you ...


5

There are a few broad approaches to generating a tesselated, spherical surface mesh. Here a couple of the more common ones... Construct a cube with densely-subdivided planes, then expand those planes outward into a spherical form: this is simple enough -- for each surface point, calculate a vector from the origin (centre of cube) to that point, normalize ...


5

Cel shading must be done at the pixel shader level to look proper, same as most other lighting. If you do it in the vertex shader, the cel shading edges will be along triangle edges rather than smoothed across the model's shape. Many existing games can likely be easily modded to use cel shading techniques, as you need to only replace some shaders and ...


5

Welcome to the tutorial to discooridnated chromatic effect. The above is an example of screen distortion. It is necessary to understand the first type of screen distortion in order to understand the final effect listed second. It is achieved by having screen coordinate texture then applying the altered screen coordinate when rendering the final scene. ...


5

Coming from a graphic design background, one solution I usually use for making blurry images appear sharper is to overlay noise. Of course, adding random noise does not look good. The noise must be relevant to the underlying material. The classic case is making a material look weathered in Photoshop by using grunge textures and setting their layers to ...


4

After doing some googling around, it appears that OpenGL ES 2 actually does support non-pow2 textures, but not (necessarily) with mipmaps or repeat wrap mode (source). Fortunately, for postprocessing you don't need mipmaps or repeat wrap mode, so you can size the textures to match the framebuffer exactly.


4

This is a pixelation shader, it seems. What it does is, it divides the screen into tiny rectangles, the side of each rectangle is determined by the values dx and dy. The smaller the value of pixels, the more pixelated the screen is, as that increases the size of dx and dy and thus the size of the rectangles. The shader, after deciding the dimensions of the ...


4

You should perform the depth test in the fragment shader "manually". OpenGL doesn't support multiple depth tests, and that its just what you need to render the second nearest pixels, because: You need the second front pixels (GL_LESS over the actual depth buffer) You need the second front pixels (GL_GREATER over the depth buffer of the first framebuffer). ...


3

Basicly, postprocessing might be a bad way of doing "night time". "Night time" consist of alot of diffrent aspects floating into one bigger picture. To get similar results to what happens in the image here is not a simple task. The light and shadows play a big part of this, aswell as the moonlight that they have. What you could achive with post processing ...


3

Two things others didn't mention: The ripples in the water surface are made by Bump-mapping, where you use a texture to add fake depth to your objects(a.k.a. Normal mapping). You could even animate this with noise, so you don't need a texture, just GLSL noise generation.(Quite simple and awesome effect) The very subtle "fog" around the planet might be a ...


3

My suggestion would be to use surfarrays in conjunction with NumPy. Assuming you already have an algorithm for the post-processing effects you want, all you'll have to do is port it into NumPy syntax, which will probably just take some tinkering. Examples of usage can be found here, here, here, and here. After manipulating the surface, you just have to ...


3

It looks like TextureWidth is an integer. The line: float pixelWidth = 1/TextureWidth; will be calculated using integer arithmetic, and so long as TextureWidth > 1, the result will be zero. This means the line: blur.x = TextureCoordinate.x + Pixels[i] * pixelWidth; will be equivalent to: blur.x = TextureCoordinate.x; and you will end up ...


3

I used this solution to make a water distortion effect. You could use the sin waves vertically instead of horizontally to possibly achieve your effect. I draw what might get distorted onto a FrameBuffer. I make regions of the buffer texture that will be redrawn with a distortion shader applied. GdxGame.java void create(){ scaleX = Gdx.graphics....


3

A potential solution is to use a visualization technique involving the rendering of pathlines, streamlines and streaklines. You're interested in rendering pathlines. Unfortunately, I can't show you a picture of how to achieve this, but I'll explain it shortly: you need to keep track of the trajectory your sword or swinging object leaves behind. You should ...


3

Still Godot 3.1 doesn't support FXAA, however there are some user implemented version. If you are using GLES3, use this: https://gist.github.com/cart/7d2da58eb28c75c0952787f29f3e562f If you are using GLES2, use this: https://github.com/atomius0/Godot-3.1-FXAA-Shader/blob/master/project/fxaa/fxaa.shader Steps to apply FXAA: Create ColorRect Node Set ...


2

In theory, you could use Shader Replacement to re-render your whole scene using shaders that offset the positions of everything slightly, and output with e.g. 25% alpha. So you'd render the scene normally, and then: Clear depth buffer Set shader replacement to offset everything 1px left and 25% alpha Render Clear depth buffer Set shader replacement to ...


2

This is probably the issue: https://www.opengl.org/wiki/Framebuffer_Object#Feedback_Loops Using a texture that is currently bound to an FBO that is current bound as the rendering target is undefined. You must unbind the FBO before using the texture. You can leave the texture bound to the FBO so long as the FBO itself is unbound. You need to bind a 2nd FBO ...


2

One idea I came up with but which isn't very satisfying is to have two image textures and automatically use them alternating. Also keeping track of which is the newer one to finally display it on the screen. This is actually the way it's commonly done, and the technique even has a name: "ping-ponging". There's some discussion on the technique here (look ...


2

I'd say 2-3 passes is pretty normal. I suspect 4 is not uncommon. For vertex-lit games, 1-2. Usually just the albedo pass then some post effect or another. For pixel lit, 3+ is going to be the norm. 1st pass is g-buffer, z-buffer, surface normals and diffuse/albedo info as you describe it. Building blocks. 2nd pass we try to fit all other ops, but in ...


2

Usually each post processing effect has it own pass unless the effects are "organically" coupled and/or are simple. For example, to simulate an old film camera, you could put the grayscale, sepia, noise, scratch and vignetting effects all inside the same shader, since each effect is a simple part of the goal effect. On the other hand, some other effects have ...


2

Yes it seems you do want a post processing effect. First Render your scene normally. Then sample this texture in your next Render technique but use a set alpha. something along the lines of: in vec2 Texcoord; out vec4 outColour; uniform sampler2D tex; void main() { outColour = texture( tex, Texcoord ); outColour += vec4( outcolour.rgb, 0.5f ); } ...


2

Simple lens shader that uses object's normals to distort the background. Render texture without this object, use it as "ScreenMapSampler" and then render all scene including this object in final frame. Not best implementation, but it works. struct PS_OUTPUT{float4 Color : COLOR0;}; struct VS_Lens { float4 Position: POSITION; float4 ScreenMapSamplingPos:...


2

So after experimenting a little more with Intel GPA following Sean Middleditch's comment, I noticed that messing around with state changes, including sampler states, seemed to give me no improvement whatsoever. But sampler states got me thinking about texture formats, so I had another look at the DirectX documentation for a texture format that might be ...


2

Bloom effect in Unity is actually a post effect which means it works after all the GameObjects have been rendered by the camera, and it can't be seperately affected. The only way you can do this is use two cameras, one for the main GameObjects and one for the background, and properly set the layer and Camera's culling mask of the cameras Check this doc for ...


Only top voted, non community-wiki answers of a minimum length are eligible