You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
10 KiB
268 lines
10 KiB
/**
|
|
********************************************************************************
|
|
* Copyright (C) 2024 NEXTCHIP Inc. All rights reserved.
|
|
* This software is the confidential and proprietary information of
|
|
* NEXTCHIP, Inc. ("Confidential Information"). You shall not disclose such
|
|
* Confidential Information and shall use it only in accordance with
|
|
* the terms of the license agreement you entered into with NEXTCHIP.
|
|
********************************************************************************
|
|
|
|
********************************************************************************
|
|
* @file : nc_opengl_shader.c
|
|
*
|
|
* @brief : nc_opengl_shader source (GLSL)
|
|
*
|
|
* @author : Software Development Team. NextChip Inc.
|
|
*
|
|
* @date : 2024.08.09.
|
|
*
|
|
* @version : 1.0.0
|
|
********************************************************************************
|
|
* @note
|
|
*
|
|
********************************************************************************
|
|
*/
|
|
|
|
#include "nc_opengl_shader.h"
|
|
|
|
const char *fragmentShaderSourceVideo_yuv =
|
|
"precision mediump float;\n"
|
|
"varying vec2 vTexCoord;\n"
|
|
"uniform sampler2D texture1;\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" float Y0,Y1,U,V,R0,G0,B0,R1,G1,B1;\n"
|
|
" Y0 = texture2D(texture1, vTexCoord).r;\n"
|
|
" U = texture2D(texture1, vTexCoord).g;\n"
|
|
" Y1 = texture2D(texture1, vTexCoord).b;\n"
|
|
" V = texture2D(texture1, vTexCoord).a;\n"
|
|
" U = U - 0.5;\n"
|
|
" V = V - 0.5;\n"
|
|
" R0 = Y0 + 1.402 * V;\n"
|
|
" G0 = Y0 - 0.344136 * U - 0.714136 * V;\n"
|
|
" B0 = Y0 + 1.772 * U;\n"
|
|
" \n"
|
|
" R1 = Y1 + 1.402 * V;\n"
|
|
" G1 = Y1 - 0.344136 * U - 0.714136 * V;\n"
|
|
" B1 = Y1 + 1.772 * U;\n"
|
|
" \n"
|
|
" R0 = clamp(R0, 0.0, 1.0);\n"
|
|
" G0 = clamp(G0, 0.0, 1.0);\n"
|
|
" B0 = clamp(B0, 0.0, 1.0);\n"
|
|
" \n"
|
|
" R1 = clamp(R1, 0.0, 1.0);\n"
|
|
" G1 = clamp(G1, 0.0, 1.0);\n"
|
|
" B1 = clamp(B1, 0.0, 1.0);\n"
|
|
" \n"
|
|
" vec3 rgbColor = 0.5 * vec3(R0 + R1, G0 + G1, B0 + B1);\n"
|
|
" gl_FragColor = vec4(rgbColor, 1.0);\n"
|
|
"}\n";
|
|
|
|
const char *fragmentShaderSourceVideo =
|
|
"precision mediump float;\n"
|
|
"varying vec2 vTexCoord;\n"
|
|
"uniform sampler2D texture1;\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_FragColor = texture2D(texture1, vTexCoord);\n"
|
|
"}\n";
|
|
|
|
const char *vertexShaderSourceVideo =
|
|
"attribute vec4 aPosition;\n"
|
|
"attribute vec2 aTexCoord;\n"
|
|
"varying vec2 vTexCoord;\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_Position = aPosition;\n"
|
|
" vTexCoord = aTexCoord;\n"
|
|
"}\n";
|
|
|
|
const char *fragmentShaderSourceEx =
|
|
// Interpolated values from the vertex shaders
|
|
"precision mediump float;\n"
|
|
"varying vec2 UV;\n"
|
|
"varying vec3 Position_worldspace;\n"
|
|
"varying vec3 Normal_cameraspace;\n"
|
|
"varying vec3 EyeDirection_cameraspace;\n"
|
|
"varying vec3 LightDirection_cameraspace;\n"
|
|
// Values that stay constant for the whole mesh.
|
|
"uniform sampler2D myTextureSampler;\n"
|
|
"uniform mat4 MV;\n"
|
|
"uniform vec3 LightPosition_worldspace;\n"
|
|
"void main(){\n"
|
|
// Light emission properties
|
|
// You probably want to put them as uniforms
|
|
"vec3 LightColor = vec3(1,1,1);\n"
|
|
"float LightPower = 50.0;\n"
|
|
// Material properties
|
|
"vec3 MaterialDiffuseColor = texture2D( myTextureSampler, UV).rgb;\n"
|
|
"vec3 MaterialAmbiantColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;\n"
|
|
"vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);\n"
|
|
|
|
// Distance to the light
|
|
"float distance = length( LightPosition_worldspace - Position_worldspace );\n"
|
|
|
|
// Normal of the computed fragment, in camera space
|
|
"vec3 n = normalize( Normal_cameraspace );\n"
|
|
// Direction of the light (from the fragment to the light)
|
|
"vec3 l = normalize( LightDirection_cameraspace );\n"
|
|
// Cosine of the angle between the normal and the light direction,
|
|
// clamped above 0
|
|
// - light is at the vertical of the triangle -> 1
|
|
// - light is perpendicular to the triangle -> 0
|
|
// - light is behind the triangle -> 0
|
|
"float cosTheta = max(min(dot(n, l), 1.0), 0.0);\n"
|
|
|
|
// Eye vector (towards the camera)
|
|
"vec3 E = normalize(EyeDirection_cameraspace);\n"
|
|
// Direction in which the triangle reflects the light
|
|
"vec3 R = reflect(-l,n);\n"
|
|
// Cosine of the angle between the Eye vector and the Reflect vector,
|
|
// clamped to 0
|
|
// - Looking into the reflection -> 1
|
|
// - Looking elsewhere -> < 1
|
|
"float cosAlpha = max(min(dot(E, R), 1.0), 0.0);\n"
|
|
|
|
// Ambiant : simulates indirect lighting
|
|
// Diffuse : "color" of the object
|
|
// Specular : reflective highlight, like a mirror
|
|
// Output color = color of the texture at the specified UV
|
|
"gl_FragColor = vec4(MaterialAmbiantColor + MaterialDiffuseColor * LightColor * LightPower * cosTheta / (distance*distance) + MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5.0) / (distance*distance),1.0);\n"
|
|
"}\n";
|
|
|
|
const char *vertexShaderSourceEx =
|
|
"precision mediump float;\n"
|
|
// Input vertex data, different for all executions of this shader.
|
|
"attribute vec3 vertexPosition_modelspace;\n"
|
|
"attribute vec2 vertexUV;\n"
|
|
"attribute vec3 vertexNormal_modelspace;\n"
|
|
// Output data ; will be interpolated for each fragment.
|
|
"varying vec2 UV;\n"
|
|
"varying vec3 Position_worldspace;\n"
|
|
"varying vec3 Normal_cameraspace;\n"
|
|
"varying vec3 EyeDirection_cameraspace;\n"
|
|
"varying vec3 LightDirection_cameraspace;\n"
|
|
// Values that stay constant for the whole mesh.
|
|
"uniform mat4 MVP;\n"
|
|
"uniform mat4 V;\n"
|
|
"uniform mat4 M;\n"
|
|
"uniform vec3 LightPosition_worldspace;\n"
|
|
"void main(){\n"
|
|
// Output position of the vertex, in clip space : MVP * position
|
|
" gl_Position = MVP * vec4(vertexPosition_modelspace,1.0);\n"
|
|
// Position of the vertex, in worldspace : M * position
|
|
" Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;\n"
|
|
// Vector that goes from the vertex to the camera, in camera space.
|
|
// In camera space, the camera is at the origin (0,0,0).
|
|
" vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;\n"
|
|
" EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;\n"
|
|
|
|
// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.
|
|
" vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;\n"
|
|
" LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;\n"
|
|
|
|
// Normal of the the vertex, in camera space
|
|
" Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz;\n" // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.
|
|
// UV of the vertex. No special space for this one.
|
|
" UV = vertexUV;\n"
|
|
"}\n";
|
|
|
|
const char *fragmentShaderNpu =
|
|
"#version 300 es\n"
|
|
"precision mediump float;\n"
|
|
"uniform vec4 color;\n"
|
|
"uniform int drawingType;\n"
|
|
"uniform sampler2D s_texture;\n"
|
|
"uniform vec4 colors_array[10];\n"
|
|
"uniform vec2 viewportSize;\n"
|
|
"in vec2 v_texcoord;\n"
|
|
"flat in vec3 startPos;\n"
|
|
"in vec3 vertPos;\n"
|
|
"out vec4 fragColor;\n"
|
|
"void main() {\n"
|
|
// Type for drawing solid line
|
|
" if (drawingType == 0) {\n"
|
|
" fragColor = color;\n"
|
|
" }\n"
|
|
// Type for drawing dashed line
|
|
" if (drawingType == 1) {\n"
|
|
" vec2 dir = (vertPos.xy-startPos.xy) * viewportSize/2.0;\n"
|
|
" float dist = length(dir);\n"
|
|
" if(fract(dist/ 30.0) > 0.5) discard;\n"
|
|
" fragColor = color;\n"
|
|
" }\n"
|
|
// Type for drawing semantic segmentation results
|
|
" if (drawingType == 2) {\n"
|
|
" float id = texture(s_texture, v_texcoord).r * 255.0;\n"
|
|
" int index = int(id + 0.5);\n"
|
|
" fragColor = colors_array[index];\n"
|
|
" }\n"
|
|
"}\n";
|
|
|
|
const char *vertexShaderNpu =
|
|
"#version 300 es\n"
|
|
"in vec4 a_position;\n"
|
|
"in vec2 a_texcoord;\n"
|
|
"out vec2 v_texcoord;\n"
|
|
"flat out vec3 startPos;\n"
|
|
"out vec3 vertPos;\n"
|
|
"void main() {\n"
|
|
" gl_Position = a_position;\n"
|
|
" v_texcoord = a_texcoord;\n"
|
|
" startPos = a_position.xyz;\n"
|
|
" vertPos = a_position.xyz;\n"
|
|
"}\n";
|
|
|
|
const char *TextVertexShaderSource =
|
|
"precision mediump float;\n"
|
|
// Input vertex data, different for all executions of this shader.
|
|
"attribute vec2 vertexPosition_screenspace;\n"
|
|
"attribute vec2 vertexUV;\n"
|
|
// Output data ; will be interpolated for each fragment.
|
|
"varying vec2 UV;\n"
|
|
"void main(){\n"
|
|
// Output position of the vertex, in clip space
|
|
// map [0..800][0..600] to [-1..1][-1..1]
|
|
" vec2 vertexPosition_homoneneousspace = vertexPosition_screenspace - vec2(960,540);\n" // [0..800][0..600] -> [-400..400][-300..300]
|
|
" vertexPosition_homoneneousspace /= vec2(960,540);\n"
|
|
" gl_Position = vec4(vertexPosition_homoneneousspace,0,1);\n"
|
|
// UV of the vertex. No special space for this one.
|
|
" UV = vertexUV;\n"
|
|
"}\n";
|
|
|
|
const char *TextFragmentShaderSource =
|
|
// Interpolated values from the vertex shaders
|
|
"precision mediump float;\n"
|
|
"varying vec2 UV;\n"
|
|
// Values that stay constant for the whole mesh.
|
|
"uniform sampler2D myTextureSampler;\n"
|
|
"uniform vec4 colorModifier;\n"
|
|
"void main(){\n"
|
|
// Output color = color of the texture at the specified UV
|
|
" vec4 textureColor = texture2D(myTextureSampler, UV);\n"
|
|
" vec4 modifiedColor = textureColor * colorModifier;\n"
|
|
" gl_FragColor = modifiedColor;\n"
|
|
"}\n";
|
|
|
|
const char *fragmentShaderFont =
|
|
"precision mediump float;\n"
|
|
"varying vec2 TexCoords;\n"
|
|
"uniform sampler2D s_texture;\n"
|
|
"uniform vec3 color;\n"
|
|
"void main() {\n"
|
|
" vec4 sampled = vec4(1.0, 1.0, 1.0, texture2D(s_texture, TexCoords).a);\n"
|
|
" gl_FragColor = vec4(color, 1.0) * sampled;\n"
|
|
"}\n";
|
|
|
|
const char *vertexShaderFont =
|
|
"attribute vec2 a_position;\n"
|
|
"attribute vec2 a_texcoord;\n"
|
|
"uniform vec2 screenSize;\n"
|
|
"varying vec2 TexCoords;\n"
|
|
"void main() {\n"
|
|
" vec2 normalizedPosition = (a_position / screenSize) * 2.0 - 1.0;\n"
|
|
//" normalizedPosition.y = -normalizedPosition.y;\n"
|
|
" gl_Position = vec4(normalizedPosition, 0.0, 1.0);\n"
|
|
" TexCoords = a_texcoord;\n"
|
|
"}\n";
|