Draw Shockwave

/// @function           shockwave_draw();
/// @description        Draw the shockwave effect

// Check for the texture surface and create as required
if !surface_exists(wave_surf)
{
// No texture surface so create it
var _num = 0;
while (!surface_exists(wave_surf))
    {
    if wave_view != -1
        {
        // A view has been apecified so create the surface the size of it
        var ww = camera_get_view_width(view_camera[wave_view]);
        var hh = camera_get_view_height(view_camera[wave_view]);
        wave_surf = surface_create(ww, hh);
        }
    else
        {
        // No view has been specified so create the surface the size of the room
        wave_surf = surface_create(room_width, room_height);
        }
    // Check to make sure the surface was created and show an error if it repeatedly fails
    if _num++ > 25
        {
        show_debug_message("Shockwave: Couldn't Create Effect Surface! Destroying Instance...");
        instance_destroy();
        exit; // Exit the draw event to prevent errors
        }
    }
// Set wave texture variables
wave_surf_t = surface_get_texture(wave_surf);
wave_surf_w = surface_get_width(wave_surf);
wave_surf_h = surface_get_height(wave_surf);
// show_debug_message("Shockwave: Effect Surface Created!");
// Copy the application surface to the texture surface
surface_set_target(wave_surf);
draw_surface_stretched(application_surface, 0, 0, wave_surf_w, wave_surf_h);
surface_reset_target();
}
else
{
// Texture surface exists, so update the shockwave effect if required
if wave_update
    {
    surface_set_target(wave_surf);
    draw_surface_stretched(application_surface, 0, 0, wave_surf_w, wave_surf_h);
    surface_reset_target();
    }

// Check effect radius and continue or destroy as necessary
wave_radius += wave_speed;
if (wave_radius > wave_max_radius)
    {
    instance_destroy();
    exit;
    }

// Setup local vars for drawing the primitives that the effect uses
// Note that we pre-calculate as much as possible before running the
// main draw loop so that the loop has to do as little as possible.
var _xx, _yy, _cosx, _siny, _wave_dir;
var _wave_ang = 360 / wave_segment;                             // The angle size of each "segment" of the wave effect
var _wave_offset_inside = max(wave_radius - wave_width, 0);     // Calculate the offset from the edge of the wave inwards
var _wave_offset_outside = wave_radius + wave_width;            // Calculate the offset from the edge of the wave outwards
var _wave_multi = 0;                                            // Prepare the "counter" variable that will increment as we create vertices
var _wave_tex_x = 1 / wave_surf_w;                              // Calculate the pixel ratio for the texture (value between 0 - 1) on the x axis
var _wave_tex_y = 1 / wave_surf_h;                              // Calculate the pixel ratio for the texture (value between 0 - 1) on the y axis

// Check for the view being active and if it is store its position
// We'll use this later when calculating the texture position.
if wave_view > -1
    {
    var _vx = camera_get_view_x(view_camera[wave_view]);
    var _vy = camera_get_view_y(view_camera[wave_view]);
    }
else
    {
    var _vx = 0;
    var _vy = 0;
    }

// Start drawing to the vertex buffer
vertex_begin(wave_vb_inside, wave_vf);
vertex_begin(wave_vb_outside, wave_vf);

// Run a loop to create each vertice of the primitive that will draw the shockwave
repeat (wave_segment + 1)
    {
    _wave_dir = _wave_multi * _wave_ang;            // Get the current drawing angle
    _cosx = dcos(_wave_dir);                        // Precaculate x component for position (this saves using lengthdir_x everywhere in the code)
    _siny = -(dsin(_wave_dir));                     // Precaculate y component for position (this saves using lengthdir_y everywhere in the code)
    _xx = x + (_cosx * wave_radius);                // Get the x position of the vertice for the radius of the wave
    _yy = y + (_siny * wave_radius);                // Get the y position of the vertice for the radius of the wave
    // Add radius vertices for both outer and inner rings
    vertex_position(wave_vb_outside, _xx, _yy);
    vertex_position(wave_vb_inside, _xx, _yy);
    _xx = _xx - _vx + (_cosx *  -wave_push);        // Get the x texture position
    _yy = _yy - _vy + (_siny * -wave_push);         // Get the y texture position
    // Add texture coordinates to the vertices
    vertex_texcoord(wave_vb_outside, _wave_tex_x * _xx , _wave_tex_y * _yy);
    vertex_texcoord(wave_vb_inside, _wave_tex_x * _xx, _wave_tex_y * _yy);
    // Add colour data to the vertices
    vertex_colour(wave_vb_outside, wave_blend, image_alpha);
    vertex_colour(wave_vb_inside, wave_blend, image_alpha);

    // Draw the outer vertices (same as above but using the offset value to offset it outwards from the wave radius)
    _xx = x + (_cosx * _wave_offset_outside);
    _yy = y + (_siny * _wave_offset_outside);
    vertex_position(wave_vb_outside, _xx, _yy);
    vertex_texcoord(wave_vb_outside, _wave_tex_x * (_xx - _vx) , _wave_tex_y * (_yy - _vy));
    vertex_colour(wave_vb_outside, wave_blend, 0);

    // Draw the inner vertices (same as above but using the offset value to offset it inwards from the wave radius)
    _xx = x + (_cosx * _wave_offset_inside);
    _yy = y + (_siny * _wave_offset_inside);
    vertex_position(wave_vb_inside, _xx, _yy);
    vertex_texcoord(wave_vb_inside, _wave_tex_x * (_xx - _vx) , _wave_tex_y * (_yy - _vy));
    vertex_colour(wave_vb_inside, wave_blend, 0);

    ++_wave_multi;
    }

// End the defining of the vertex buffers
vertex_end(wave_vb_inside);
vertex_end(wave_vb_outside);

// Check for additive blending (this can be removed if you never use additive blending)
if wave_additive
    {
    gpu_set_blendmode(bm_add);
    }

// Draw the primitives in the buffers
vertex_submit(wave_vb_inside,  pr_trianglestrip, wave_surf_t);
vertex_submit(wave_vb_outside, pr_trianglestrip, wave_surf_t);

// Reset additive if enabled (this can be removed if you never use additive blending)
if wave_additive
    {
    gpu_set_blendmode(bm_normal);
    }

// Set total alpha (the wave will fade as it gets bigger)
image_alpha -= wave_alpha;
}