# I need help with this shader. How to change rotation direction?

4.2.1

### Question

I’m trying to use this shader that I found (Energy shield with impact effect - Godot Shaders) It is a shield effect shader. It makes the shield rotate as well. I want to use a semisphere instead of a complete sphere (So it will only block a part of my character when it cast it) but this shader makes the shield rotate in the X axis with a pivot point in the center. This would make it so the shield rotates aroung my character. Moving some values around (without having any idea what I was doing) I managed to make the shield rotate, still on the X axis but with a pivot point from the center of the shield. (This would work but I made all the shield meshes facing Z, not X, so I would have to rotate them all) And I want to understand how to change the direction in case I have to change afterwards.

This is the shader’s code. Can someone help me understand what mat4 means? I’m guessing it’s a matrix, but I can’t understand why each axis has it’s own matrix. I’m sorry for asking probably a dumb question. But I’m new to programming, and I’m even more at a loss with this shader language that I’ve no idea how to use.

What would I need to change to make it rotate around the Z axis with a pivot point in the center of the shield, so that when the player cast it, it rotates but keeps in place in the front of the player?.

``````shader_type spatial;

group_uniforms Shield_Color;
uniform vec3 _shield_color : source_color = vec3(0.0, 0.0, 1.0);
uniform float _shield_color_brightness : hint_range(0.25, 20.0, 0.05) = 10.0;
uniform float _shield_intensity : hint_range(0.25, 5.0, 0.05) = 2.0;

group_uniforms Shield_Transform;
uniform vec3 _rotation = vec3(0.1, 0.0, 0.0);
uniform float _shield_size : hint_range(0.0, 0.5, 0.01) = 0.0;

group_uniforms Shield_Pulse;
uniform float _shield_pulse_frequency = 1.0;
uniform float _shield_pulse_density = 1.0;
uniform float _shield_pulse_amplitude = 1.0;
uniform float _shield_pulse_blend = 1.0;

group_uniforms Impact_Shape;
uniform vec3 _impact_origin = vec3(1.0, 0.0, 0.0);
uniform float _impact_frequency = 5.0;
uniform float _impact_density = 5.0;
uniform float _impact_amplitude = 6.0;
uniform float _impact_blend = 0;
uniform float _impact_anim = 0.0;

// === IMPACT ===

float _GetRippleOrigin(vec3 vert, vec3 orig) {
// distance of each vertex from the origin
return length(orig - vert);
}

float b = clamp(blend, 0.0, radius);
}

float _ComputeRipple(vec3 vert, vec3 orig, float blend, float radius, float freq, float dens, float ampl, float anim) {
// calculate the intensity of the impact
float o = _GetRippleOrigin(vert, orig);
float i = sin(anim * freq - o * dens) / ampl;
}

// === SHIELD ===

float saturate(float x) {
return max(0, min(1, x));
}

float ComputeFresnel(vec3 norm, vec3 view_dir, float intensity) {
// dot product between mesh normals and view direction
float fresnel = saturate(1.0 - dot(norm, view_dir));
// modulate fresnel intensity
fresnel = pow(fresnel, intensity);
return fresnel;
}

vec3 Rotate(vec3 vert, vec3 speed) {
// build the 3 rotation matrices
speed = speed * TIME * 5.0;

mat4 xrot = mat4(
vec4(1.0, 0.0, 0.0, 0.0),
vec4(0.0, cos(speed.x), -sin(speed.x), 0.0),
vec4(0.0, sin(speed.x), cos(speed.x), 0.0),
vec4(0.0, 0.0, 0.0, 1.0));

mat4 yrot = mat4(
vec4(cos(speed.y), 0.0, -sin(speed.y), 0.0),
vec4(0.0, 1.0, 0.0, 0.0),
vec4(sin(speed.y), 0.0, cos(speed.y), 0.0),
vec4(0.0, 0.0, 0.0, 1.0));

mat4 zrot = mat4(
vec4(cos(speed.z), -sin(speed.z), 0.0, 0.0),
vec4(sin(speed.z), cos(speed.z), 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(0.0, 0.0, 0.0, 1.0));

return (xrot * yrot * zrot * vec4(vert, 1.0)).xyz;
}

void vertex() {
// rotate VERTICES in local space
VERTEX = Rotate(VERTEX, _rotation);
// ...and relative NORMALS for the fresnel effect to work
NORMAL = Rotate(NORMAL, _rotation);

// Local to World conversion to add impact ripple
vec3 w_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;

// normalize impact origin vector
vec3 imp_or = normalize(_impact_origin);

float impact_ripple = _ComputeRipple(w_pos,
_impact_origin,
_impact_blend,
_impact_frequency,
_impact_density,
_impact_amplitude,
_impact_anim);

VERTEX += NORMAL * (impact_ripple + _shield_size);
}

void fragment() {