QIDITECH/QIDIStudio
1
0
Fork 0
mirror of https://github.com/QIDITECH/QIDIStudio.git synced 2026-01-31 00:48:41 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix some bug

Browse Source
This commit is contained in:
wjyLearn
2025-10-24 17:20:44 +08:00
parent 81ea36fdd8
commit 82268132e9
352 changed files with 33179 additions and 13515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
resources/shaders/140/gcode.fs Normal file
View File

@@ -0,0 +1,168 @@
#version 140
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
#define INTENSITY_AMBIENT 0.3
const mat3 KTravel_Colors = mat3(0.505, 0.064, 0.028,
0.219, 0.282, 0.609,
0.112, 0.422, 0.103);
uniform vec2 u_isTopLayer_hasCustomOptins;
uniform mat3 normal_matrix;
uniform float emission_factor;
uniform vec3 u_rangeType_isUnlit_topLayerIndex;
uniform vec4 u_isRangeView_isRangeVaild_topLayerOnly_viewType;
uniform vec2 u_pathDataRange;
uniform sampler2D s_color_range_texture;
uniform samplerBuffer s_per_move_data_texture;
in float moveId;
in vec3 frag_normal;
in vec3 frag_pos;
out vec4 frag_color;
bool is_top_layer()
{
return u_isTopLayer_hasCustomOptins.x > 0.5;
}
vec4 extrusion_color(vec3 type_rangeData_deltaExtruder)
{
vec4 final_color = vec4(0.25, 0.25, 0.25, 1.0); // Neutral_Color
float path_data = type_rangeData_deltaExtruder.y;
if (u_isRangeView_isRangeVaild_topLayerOnly_viewType.x > 0.5)
{
float view_type = u_isRangeView_isRangeVaild_topLayerOnly_viewType.w;
if (view_type < 0.5 || (view_type > 8.5 && view_type < 9.5)) // Summer or ColorPrint
{
if (int(path_data + 0.5) > int(u_pathDataRange.y + 0.5))
{
final_color = vec4(0.5, 0.5, 0.5, 1.0);
return final_color;
}
}
else if (view_type > 9.5 && view_type < 10.5) // FilamentId
{
float path_data2 = type_rangeData_deltaExtruder.z;
float id = path_data / (u_pathDataRange.y - u_pathDataRange.x);
float role = path_data2 / (u_pathDataRange.y - u_pathDataRange.x);
final_color = vec4(id, role, id, 1.0);
return final_color;
}
// helio
else if (view_type > 11.5 && view_type < 14.5)
{
if (path_data < u_pathDataRange.x - 0.01)
{
final_color = vec4(0.5, 0.5, 0.5, 1.0);
return final_color;
}
}
// end helio
vec2 uv = vec2(0.0, 0.5);
if (u_isRangeView_isRangeVaild_topLayerOnly_viewType.y > 0.5)
{
if (u_rangeType_isUnlit_topLayerIndex.x < 0.5)
{
uv.x = (path_data - u_pathDataRange.x) / (u_pathDataRange.y - u_pathDataRange.x);
}
else
{
uv.x = (log(path_data) - u_pathDataRange.x) / (u_pathDataRange.y - u_pathDataRange.x);
}
uv.x = clamp(uv.x, 0.0, 1.0);
}
final_color = texture(s_color_range_texture, uv);
}
return final_color;
}
vec4 get_base_color(vec3 type_rangeData_deltaExtruder)
{
vec4 final_color = vec4(0.0, 0.0, 0.0, 1.0);
float path_type = type_rangeData_deltaExtruder.x;
if (path_type > 7.5 && path_type < 8.5) //EMoveType::Travel
{
bool is_top_layer_only = u_isRangeView_isRangeVaild_topLayerOnly_viewType.z > 0.5;
if (!is_top_layer_only || is_top_layer())
{
float view_type = u_isRangeView_isRangeVaild_topLayerOnly_viewType.w;
if ((view_type > 3.5 && view_type < 4.5) || (view_type > 7.5 && view_type < 8.5))
{
final_color = extrusion_color(type_rangeData_deltaExtruder);
}
else
{
float flag = sign(type_rangeData_deltaExtruder.z);
final_color.rgb = KTravel_Colors[int(flag) + 1];
}
}
else
{
final_color = vec4(0.25, 0.25, 0.25, 1.0); // Neutral_Color
}
}
else if (path_type > 8.5 && path_type < 9.5)
{
final_color = vec4(1.0, 1.0, 0.0, 1.0); // Wipe_Color
}
else if (path_type > 9.5 && path_type < 10.5)
{
bool is_top_layer_only = u_isRangeView_isRangeVaild_topLayerOnly_viewType.z > 0.5;
if (!is_top_layer_only || is_top_layer())
{
final_color = extrusion_color(type_rangeData_deltaExtruder);
}
else
{
final_color = vec4(0.25, 0.25, 0.25, 1.0); // Neutral_Color
}
}
return final_color;
}
void main()
{
vec4 custom_option_color = vec4(0.5, 0.5, 0.5, 1.0);
vec3 type_rangeData_deltaExtruder = texelFetch(s_per_move_data_texture, int(moveId)).rgb;
vec4 base_color = get_base_color(type_rangeData_deltaExtruder);
vec4 mixed_color = mix(custom_option_color, base_color, u_isTopLayer_hasCustomOptins.y > 0.5 ? 0.0 : 1.0);
// x = tainted, y = specular;
vec2 intensity = vec2(0.0, 0.0);
float t_emission_factor = 1.0;
if (u_rangeType_isUnlit_topLayerIndex.y < 0.5)
{
vec3 norm = normal_matrix * normalize(frag_normal);
norm = normalize(norm);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(norm, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(frag_pos.xyz), reflect(-LIGHT_TOP_DIR, norm)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(norm, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
t_emission_factor = emission_factor;
}
frag_color = vec4(vec3(intensity.y) + mixed_color.rgb * (intensity.x + t_emission_factor), mixed_color.a);
}

110
resources/shaders/140/gcode.vs Normal file
View File

@@ -0,0 +1,110 @@
#version 140
uniform mat4 view_model_matrix;
uniform mat4 projection_matrix;
uniform samplerBuffer s_position_texture;
uniform samplerBuffer s_width_height_data_texture;
uniform samplerBuffer s_segment_texture;
out float moveId;
out vec3 frag_normal;
out vec3 frag_pos;
void main()
{
vec4 seg_startEnd_hasPrev_prevIndex = texelFetch(s_segment_texture, gl_InstanceID);
int start_index = int(seg_startEnd_hasPrev_prevIndex.x);
int end_index = int(seg_startEnd_hasPrev_prevIndex.y);
bool hasPrev = seg_startEnd_hasPrev_prevIndex.z > 0.5;
vec4 startPos_mid = texelFetch(s_position_texture, start_index);
vec4 endPos_mid = texelFetch(s_position_texture, end_index);
vec3 line = endPos_mid.xyz - startPos_mid.xyz;
vec3 line_dir = vec3(1.0, 0.0, 0.0);
float line_len = length(line);
line_dir = line / max(line_len, 1e-6);
vec3 right_dir = vec3(line_dir.y, -line_dir.x, 0.0);
vec3 up = vec3(0.0, 0.0, 1.0);
if (length(right_dir) < 1e-4)
{
up = vec3(1.0, 0.0, 0.0);
right_dir = cross(line_dir, up);
}
else
{
right_dir = normalize(right_dir);
line_dir = normalize(line_dir);
up = cross(right_dir, line_dir);
}
vec3 base_pos = gl_VertexID < 4 ? startPos_mid.xyz : endPos_mid.xyz;
moveId = endPos_mid.w + 0.5;
vec2 width_height = texelFetch(s_width_height_data_texture, int(moveId)).rg;
float width = width_height.x;
float height = width_height.y;
float half_width = 0.5 * width;
float half_height = 0.5 * height;
vec3 d_up = half_height * up;
vec3 d_right = half_width * right_dir;
vec3 d_down = -half_height * up;
vec3 d_left = -half_width * right_dir;
vec3 position = base_pos - half_height * up;
if (0 == gl_VertexID || 4 == gl_VertexID)
{
position = position + d_up;
frag_normal = up;
}
else if (1 == gl_VertexID || 5 == gl_VertexID)
{
position = position + d_right;
frag_normal = right_dir;
}
else if (2 == gl_VertexID || 6 == gl_VertexID)
{
position = position + d_down;
frag_normal = -up;
}
else if (3 == gl_VertexID || 7 == gl_VertexID)
{
position = position + d_left;
frag_normal = -right_dir;
}
if (gl_VertexID > 7) {
int prev_start_index = int(seg_startEnd_hasPrev_prevIndex.w);
vec4 prevPos_mid = texelFetch(s_position_texture, prev_start_index);
if (hasPrev) {
vec3 prev_dir = startPos_mid.xyz - prevPos_mid.xyz;
prev_dir = prev_dir / max(length(prev_dir), 1e-6);
prev_dir = normalize(prev_dir);
vec3 prev_right_dir = vec3(prev_dir.y, -prev_dir.x, 0.0);
prev_right_dir = normalize(prev_right_dir);
vec3 prev_left_dir = -prev_right_dir;
vec3 prev_up = cross(prev_right_dir, prev_dir);
vec3 prev_second_pos = startPos_mid.xyz - half_height * prev_up;
if (8 == gl_VertexID)
{
position = prev_second_pos + half_width * prev_left_dir;
frag_normal = prev_left_dir;
}
else if (9 == gl_VertexID)
{
position = prev_second_pos + half_width * prev_right_dir;
frag_normal = prev_right_dir;
}
}
}
vec4 final_position = view_model_matrix * vec4(position, 1.0);
frag_pos = final_position.xyz;
frag_normal = normalize(frag_normal);
gl_Position = projection_matrix * final_position;
}

50
resources/shaders/140/gcode_custom_effect.fs Normal file
View File

@@ -0,0 +1,50 @@
#version 140
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
#define INTENSITY_AMBIENT 0.3
const mat3 KTravel_Colors = mat3(0.505, 0.064, 0.028,
0.219, 0.282, 0.609,
0.112, 0.422, 0.103);
uniform mat3 normal_matrix;
uniform float emission_factor;
uniform vec4 u_base_color;
in vec3 frag_normal;
in vec3 frag_pos;
out vec4 frag_color;
void main()
{
// x = tainted, y = specular;
vec2 intensity = vec2(0.0, 0.0);
float t_emission_factor = emission_factor;
vec3 norm = normal_matrix * normalize(frag_normal);
norm = normalize(norm);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(norm, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(frag_pos.xyz), reflect(-LIGHT_TOP_DIR, norm)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(norm, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
frag_color = vec4(vec3(intensity.y) + u_base_color.rgb * (intensity.x + t_emission_factor), u_base_color.a);
}

79
resources/shaders/140/gcode_options.fs Normal file
View File

@@ -0,0 +1,79 @@
#version 140
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
#define INTENSITY_AMBIENT 0.3
uniform float u_is_top_layer;
uniform mat3 normal_matrix;
uniform vec4 u_isUnlit_optionTextureSize_topLayerOnly_emissionFactor;
uniform sampler2D s_option_color_texture;
uniform samplerBuffer s_per_move_data_texture;
in float moveId;
in vec3 frag_normal;
in vec3 frag_pos;
out vec4 frag_color;
bool is_top_layer()
{
return u_is_top_layer > 0.5;
}
vec4 get_base_color(float moveType)
{
vec4 final_color = vec4(0.0, 0.0, 0.0, 1.0);
bool is_top_layer_only = u_isUnlit_optionTextureSize_topLayerOnly_emissionFactor.z > 0.5;
if (!is_top_layer_only || is_top_layer())
{
final_color = texture(s_option_color_texture, vec2((moveType - 1.0 + 0.5) / u_isUnlit_optionTextureSize_topLayerOnly_emissionFactor.y, 0.5));
}
else
{
final_color = vec4(0.25, 0.25, 0.25, 1.0); // Neutral_Color
}
return final_color;
}
void main()
{
float moveType = texelFetch(s_per_move_data_texture, int(moveId)).r;
vec4 base_color = get_base_color(moveType);
// x = tainted, y = specular;
vec2 intensity = vec2(0.0, 0.0);
float t_emission_factor = 1.0;
if (u_isUnlit_optionTextureSize_topLayerOnly_emissionFactor.x < 0.5)
{
vec3 norm = normal_matrix * normalize(frag_normal);
norm = normalize(norm);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(norm, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(frag_pos.xyz), reflect(-LIGHT_TOP_DIR, norm)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(norm, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
t_emission_factor = u_isUnlit_optionTextureSize_topLayerOnly_emissionFactor.w;
}
frag_color = vec4(vec3(intensity.y) + base_color.rgb * (intensity.x + t_emission_factor), base_color.a);
}

39
resources/shaders/140/gcode_options.vs Normal file
View File

@@ -0,0 +1,39 @@
#version 140
in vec3 v_position;
in vec3 v_normal;
uniform mat4 view_model_matrix;
uniform mat4 projection_matrix;
uniform samplerBuffer s_position_texture;
uniform samplerBuffer s_width_height_data_texture;
uniform samplerBuffer s_segment_texture;
out float moveId;
out vec3 frag_normal;
out vec3 frag_pos;
void main()
{
vec4 seg_startEnd_hasPrev = texelFetch(s_segment_texture, gl_InstanceID);
int end_index = int(seg_startEnd_hasPrev.y);
vec4 endPos_mid = texelFetch(s_position_texture, end_index);
moveId = endPos_mid.w + 0.5;
vec2 width_height = texelFetch(s_width_height_data_texture, int(moveId)).rg;
float width = 1.5 * width_height.x;
float height = width_height.y;
mat4 model_matrix = mat4(
width, 0.0, 0.0, 0.0,
0.0, width, 0.0, 0.0,
0.0, 0.0, 1.5 * height, 0.0,
endPos_mid.x, endPos_mid.y, endPos_mid.z - 0.5 * height, 1.0);
vec4 final_position = view_model_matrix * model_matrix * vec4(v_position, 1.0);
frag_pos = final_position.xyz;
frag_normal = normalize(v_normal);
gl_Position = projection_matrix * final_position;
}