Fortunately creating water reflections in GameMaker is quite easy. Simply copy the application surface, flip it upside down, reduce the alpha, apply a effect/filter*/shader* for some extra spice, and you're done. It'll reflect anything that draws in the regular draw events, but nothing in the GUI events.

I find it works best when I copy from the application surface in draw-begin, and then draw the surface in the regular draw event.

Just remember to re-use the same surface every frame. A rookie mistake is creating a brand new surface each frame and filling up your GPU's VRAM.

I thought I’d share a clip showing some of the shaders I’ve developed for my isometric hiking RPG. I’m going for a painterly effect, so I spent some time fine-tuning these. The water is rendered as a surface texture (drawn using a vertex buffer at a fixed depth). Reflections are drawn onto the surface mirrored, including clouds.

Clouds are made procedurally using a generative Brownian noise fragment shader. A separate fragment shader applies a displacement map texture and wave/brushwork texture to the water surface, and the scrolls those textures on a loop to simulate water flowing. The secret sauce is an algorithm which morphs these textures and the flow direction such that the water automatically curves based on the map terrain.

Grass is also working with a vertex shader for wind movement, and displaces / shades based on player position.

I would've liked to show more, but seems like I can only post gifs to this subreddit.

its very basic and might be messy but boy does that make me happy when i see the text pop up!!!!

I just wanted to share the water reflections that I got in my game. My fellow Game Maker users will relate to the struggle of making good reflections. I wanted to share my process as well in case anybody wants to try this for themself!

1. A water surface that is masked by all of the fluids in your scene

2. Sliding static perline noise to give the water some texture

3. Draw all of your sprites that you want reflected upside down onto the water surface

4. Displacement shader with noise + bonus displacement textures for movement in the water

5. Highlight the edges of fluids to make them lighter (creates a sense of depth change on the edges)

idk what i want to do with this tbh, i might clean it up and package it up as a yyz file after i add more features to it

Thought folks here might find this interesting after my last post showing my flowing water shader. My game Rangefinder is in an isometric perspective and features hiking through lots of different types of terrain - which raises a problem, because trees will necessarily block the camera's view of the player! One solution I already implemented is an outline shader that shows your position when you are obscured, but that gets old when you are walking through a forest.

So this week I made a new shader which creates a "porthole" effect through trees when they block the camera view. This is done by measuring the distance of a pixel to the player via the "gl_Fragcoord" value in the fragment shader. But I found that a bit too artificial looking, so I added a generative cellular noise texture which simulates leaf motion at the edge of the porthole. That helps a little bit, and then I also did some dynamic hiding / showing of trees in front / behind the player. Dithering the transparency of these trees (also done in shader) further helps match the pixel art style.

That was great, but then I realized trees need shadows beneath them to provide the look of a shadowy forest floor. So I came up with a new method to add shadows to both my grass vertex buffer, and the "ground floor" vertex buffer. I create a surface which I draw shadows to, and pass that as a texture sample to a new shadow shader. This shader references the shadow texture sample to decide whether the vertex it's drawing should be shaded or not. This required coordinating screen coordinates (gl_Fragcoord) and texture coordinates (v_vTexcoord) which was a bit of a pain but worked out in the end. I used the same generative cellular noise texture here to simulate the shadows of moving leaves on the ground.

Next up I will need to also add the capability for objects under sprites to be in/out of shadow. Currently I only have "grass" vertices in there (which includes the grass, ferns, flowers, and mushrooms shown in this example - these also shade and deform when the player walks through them). Objects however are handled as individual instances which the player places in the IDE.

If you are interested in following my game Rangefinder, check out my itch io page where I'm posting dev updates. I recently showed off the first demo of the battle system, which also features a lot of custom Gamemaker shaders for effects like critical hits and such.

First, I created a sprite that is the same resolution as my game (320x240). This sprite is just a bunch of random shapes with sharp edges. Each is given a random color so I can differentiate between them.

Next, I made a copy of this sprite as a GIF. I moved all the shapes onto their own frame and placed them at the top left corner. Upload this GIF into GameMaker and leave the origin at the top left.

Now, onto the code. We'll need to know where to place each shape on screen. So I created a 2D array listing the top left pixel position of each shape in the original image. These should be precise.

We'll also need to know the origin of each shape in the GIF. So I created another 2D array with the rough origin of each shape. These don't need to be exact.

You could use this effect to show a sprite breaking apart, but for my example I'll be using a surface. Unfortunately surfaces are volatile, but we can use a buffer to fix that. If the surface is deleted, then reset it using buffer_set_surface(). I set the buffer right after building the surface, and then pass those both into the screen shatter object using a with(instance_create_depth()).

All of the info for the shapes are stored in an array of structs. Each shape gets its own position, origin, offset, surface, rotation, rotation speed, and movement speed. Be sure to set each shape's starting position at their offset + origin. We could give each shape their own alpha, but I chose to have them all share image_alpha for simplicity.

In the step event we do the following:

• Update the x and y positions

• Apply gravity (optional)

• Rotate angle

• Rotate x OR y scale, to provide a fake 3D rotation

  • Use a cos() to do this, and start your timer at 0.

  • If you rotate X and Y then the effect won't look good.

• Reduce image_alpha

And finally, the draw code:

• If the main surface doesn't exist, then re-create it from the buffer.

• Iterate through each struct in the array.

• If the surface doesn't exist, then create it based off the shape's size.

  • Clear the surface.

  • Draw the current shape's sprite at (0,0).

  • Disable alpha writing.

  • Draw the surface/sprite of the image you're shattering at (-offsetX, -offsetY).

  • Enable alpha writing.

  • Reset the surface target.

• Draw the shape's surface at its x and y position, with the rotation, scaling, and alpha applied.

Lastly, remember to free all of those surfaces and the buffer!