i need help. i need two right triangles that can look like the one in the picture with the colors ty in advance

#include $//$ cout, cerr

#include $//$ EXIT$\_$FAILURE

#include $//$ GLEW library

#include $//$ GLFW library

using namespace std; $//$ Uses the standard namespace

$//$ Unnamed namespace

namespace

$\{$

const char$*$ const WINDOW$\_$TITLE $=$ "Tutorial $2\mathrm{.}7"$; $//$ Macro for window title

$//$ Variables for window width and height

const int WINDOW$\_$WIDTH $=800$;

const int WINDOW$\_$HEIGHT $=600$;

$//$ Stores the GL data relative to a given mesh

struct GLMesh

$\{$

GLuint vao; $//$ Handle for the vertex array object

GLuint vbo; $//$ Handle for the vertex buffer object

GLuint nvertices; $//$ Number of vertices of the mesh

$\}$;

$//$ Main GLFW window

GLFWwindow$*$ gWindow $=$ nullptr;

$//$ Triangle mesh data

GLMesh gMesh;

$//$ Shader program

GLuint gProgramId;

$\}$

$/*$ User$-$defined Function prototypes to:

$*$ initialize the program, set the window size,

$*$ redraw graphics on the window when resized,

$*$ and render graphics on the screen

$*/$

bool UInitialize$($int$,$ char$*[],$ GLFWwindow$**$ window$)$;

void UResizeWindow$($GLFWwindow$*$ window, int width, int height$)$;

void UProcessInput$($GLFWwindow$*$ window$)$;

void UCreateMesh$($GLMesh& mesh$)$;

void UDestroyMesh$($GLMesh& mesh$)$;

void URender$()$;

bool UCreateShaderProgram$($const char$*$ vtxShaderSource, const char$*$ fragShaderSource, GLuint& programId$)$;

void UDestroyShaderProgram$($GLuint programId$)$;

$//$ Vertex Shader Program Source Code

const char$*$ vertexShaderSource $="$#version $440$ core

$"$

"layout $($location $=0)$ in vec$3$ aPos;

$"$

"layout $($location $=1)$ in vec$4$ colorFromVBO;

$"$

"out vec$4$ colorFromVS;

$"$

"void main$()$

$"$

$"\{$

$"$

$"$ gl$\_$Position $=$ vec$4($aPos$.$x$,$ aPos.y$,$ aPos.z$,1\mathrm{.}0)$;

$"$

$"$ colorFromVS $=$ colorFromVBO;

$"$

$"\}$

$\backslash 0"$;

$//$ Fragment Shader Program Source Code

const char$*$ fragmentShaderSource $="$#version $440$ core

$"$

$"$in vec$4$ colorFromVS;

$"$

"out vec$4$ FragColor;

$"$

"void main$()$

$"$

$"\{$

$"$

$"$ FragColor $=$ colorFromVS;

$"$

$"\}$

$\backslash 0"$;

$//$ main function. Entry point to the OpenGL program

int main$($int argc, char$*$ argv$[])$

$\{$

if $(!$UInitialize$($argc$,$ argv, &gWindow$))$

return EXIT$\_$FAILURE;

$//$ Create the mesh

UCreateMesh$($gMesh$)$; $//$ Calls the function to create the Vertex Buffer Object

$//$ Create the shader program

if $(!$UCreateShaderProgram$($vertexShaderSource$,$ fragmentShaderSource, gProgramId$))$

return EXIT$\_$FAILURE;

$//$ Sets the background color of the window to black $($it will be implicitely used by glClear$)$

glClearColor$(0\mathrm{.}0$f$,0\mathrm{.}0$f$,0\mathrm{.}0$f$,1\mathrm{.}0$f$)$;

$//$ render loop

$//-----------$

while $(!$glfwWindowShouldClose$($gWindow$))$

$\{$

$//$ input

$//-----$

UProcessInput$($gWindow$)$;

$//$ Render this frame

URender$()$;

glfwPollEvents$()$;

$\}$

$//$ Release mesh data

UDestroyMesh$($gMesh$)$;

$//$ Release shader program

UDestroyShaderProgram$($gProgramId$)$;

exit$($EXIT$\_$SUCCESS$)$; $//$ Terminates the program successfully

$\}$

$//$ Initialize GLFW$,$ GLEW, and create a window

bool UInitialize$($int argc, char$*$ argv$[],$ GLFWwindow$**$ window$)$

$\{$

$//$ GLFW: initialize and configure

$//------------------------------$

glfwInit$()$;

glfwWindowHint$($GLFW$\_$CONTEXT$\_$VERSION$\_$MAJOR, $4)$;

glfwWindowHint$($GLFW$\_$CONTEXT$\_$VERSION$\_$MINOR, $4)$;

glfwWindowHint$($GLFW$\_$OPENGL$\_$PROFILE, GLFW$\_$OPENGL$\_$CORE$\_$PROFILE$)$;

#ifdef $\_\_$APPLE$\_\_$

glfwWindowHint$($GLFW$\_$OPENGL$\_$FORWARD$\_$COMPAT, GL$\_$TRUE$)$;

#endif

$//$ GLFW: window creation

$//---------------------$

$*$ window $=$ glfwCreateWindow$($WINDOW$\_$WIDTH, WINDOW$\_$HEIGHT, WINDOW$\_$TITLE, NULL, NULL$)$;

if $(*$window $==$ NULL$)$

$\{$

std::cout $$ "Failed to create GLFW window" $$ std::endl;

glfwTerminate$()$;

return false;

$\}$

glfwMakeContextCurrent$(*$window$)$;

glfwSetFramebufferSizeCallback$(*$window$,$ UResizeWindow$)$;

$//$ GLEW: initialize

$//----------------$

$//$ Note: if using GLEW version $1\mathrm{.}13$ or earlier

glewExperimental $=$ GL$\_$TRUE;

GLenum GlewInitResult $=$ glewInit$()$;

if $($GLEW$\_$OK $!=$ GlewInitResult$)$

$\{$

std::cerr $$ glewGetErrorString$($GlewInitResult$)$ std::endl;

return false;

$\}$

$//$ Displays GPU OpenGL version

cout $$ "INFO: OpenGL Version: $"$ glGetString$($GL$\_$VERSION$)$ endl;

return true;

$\}$

$//$ process all input: query GLFW whether relevant keys are pressed$/$released this frame and react accordingly

void UProcessInput$($GLFWwindow$*$ window$)$

$\{$

if $($glfwGetKey$($window$,$ GLFW$\_$KEY$\_$ESCAPE$)==$ GLFW$\_$PRESS$)$

glfwSetWindowShouldClose$($window$,$ true$)$;

$\}$

$//$ glfw: whenever the window size changed $($by OS or user resize$)$ this callback function executes

void UResizeWindow$($GLFWwindow$*$ window, int width, int height$)$

$\{$

glViewport$(0,0,$ width, height$)$;

$\}$

$//$ Functioned called to render a frame

void URender$()$

$\{$

$//$ Clear the background

glClearColor$(0\mathrm{.}0$f$,0\mathrm{.}0$f