The goal of the assignment is to add source code that maps two different textures to at least two of the shapes in the existing $3$D scene. code wont run completely

$*$ CreateGLTexture$()$

bool SceneManager::CreateGLTexture$($const char$*$ filename, std::string tag$)\{$

int width $=0$;

int height $=0$;

int colorChannels $=0$;

GLuint textureID $=0$;

$//$ indicate to always flip images vertically when loaded

stbi$\_$set$\_$flip$\_$vertically$\_$on$\_$load$($true$)$;

$//$ try to parse the image data from the specified image file

unsigned char$*$ image $=$ stbi$\_$load$($

filename,

&width,

&height,

&colorChannels,

$0)$;

$//$ if the image was successfully read from the image file

if $($image$)\{$

std::cout $<<$ "Successfully loaded image:" $<<$ filename $<<",$ width:" $<<$ width $<<",$ height:" $<<$ height $<<",$ channels:" $<<$ colorChannels $<<$ std::endl;

glGenTextures$(1,$ &textureID$)$;

glBindTexture$($GL$\_$TEXTURE$\_2$D$,$ textureID$)$;

$//$ set the texture wrapping parameters

glTexParameteri$($GL$\_$TEXTURE$\_2$D$,$ GL$\_$TEXTURE$\_$WRAP$\_$S$,$ GL$\_$REPEAT$)$;

glTexParameteri$($GL$\_$TEXTURE$\_2$D$,$ GL$\_$TEXTURE$\_$WRAP$\_$T$,$ GL$\_$REPEAT$)$;

$//$ set texture filtering parameters

glTexParameteri$($GL$\_$TEXTURE$\_2$D$,$ GL$\_$TEXTURE$\_$MIN$\_$FILTER, GL$\_$LINEAR$)$;

glTexParameteri$($GL$\_$TEXTURE$\_2$D$,$ GL$\_$TEXTURE$\_$MAG$\_$FILTER, GL$\_$LINEAR$)$;

$//$ if the loaded image is in RGB format

if $($colorChannels $==3)$

glTexImage$2$D$($GL$\_$TEXTURE$\_2$D$,0,$ GL$\_$RGB$8,$ width, height, $0,$ GL$\_$RGB$,$ GL$\_$UNSIGNED$\_$BYTE, image$)$;

$//$ if the loaded image is in RGBA format $-$ it supports transparency

else if $($colorChannels $==4)$

glTexImage$2$D$($GL$\_$TEXTURE$\_2$D$,0,$ GL$\_$RGBA$8,$ width, height, $0,$ GL$\_$RGBA, GL$\_$UNSIGNED$\_$BYTE, image$)$;

else$\{$

std::cout $<<$ "Not implemented to handle image with $"<<$ colorChannels $<<"$ channels" $<<$ std::endl;

return false;$\}$

$//$ generate the texture mipmaps for mapping textures to lower resolutions

glGenerateMipmap$($GL$\_$TEXTURE$\_2$D$)$;

$//$ free the image data from local memory

stbi$\_$image$\_$free$($image$)$;

glBindTexture$($GL$\_$TEXTURE$\_2$D$,0)$; $//$ Unbind the texture

$//$ register the loaded texture and associate it with the special tag string

m$\_$textureIDs$[$m$\_$loadedTextures$].$ID $=$ textureID;

m$\_$textureIDs$[$m$\_$loadedTextures$].$tag $=$ tag;

m$\_$loadedTextures$++$;

return true;$\}$

std::cout $<<$ "Could not load image:" $<<$ filename $<<$ std::endl;

$//$ Error loading the image

return false;$\}$

$*$ BindGLTextures$()$

void SceneManager::BindGLTextures$()\{$

for $($int i $=0$; i $<$ m$\_$loadedTextures; i$++)\{$

$//$ bind textures on corresponding texture units

glActiveTexture$($GL$\_$TEXTURE$0+$ i$)$;

glBindTexture$($GL$\_$TEXTURE$\_2$D$,$ m$\_$textureIDs$[$i$].$ID$)$; $\}\}$

$*$ DestroyGLTextures$()$

void SceneManager::DestroyGLTextures$()\{$

for $($int i $=0$; i $<$ m$\_$loadedTextures; i$++)\{$

glGenTextures$(1,$ &m$\_$textureIDs$[$i$].$ID$)$;$\}\}$

$*$ FindTextureID$()$

int SceneManager::FindTextureID$($std::string tag$)\{$

int textureID $=-1$;

int index $=0$;

bool bFound $=$ false;

while $(($index $<$ m$\_$loadedTextures$)$ && $($bFound $==$ false$))\{$

if $($m$\_$textureIDs$[$index$].$tag.compare$($tag$)==0)\{$

textureID $=$ m$\_$textureIDs$[$index$].$ID;

bFound $=$ true;$\}$

else

index$++$;$\}$

return$($textureID$)$;$\}$

$*$ FindTextureSlot$()$

int SceneManager::FindTextureSlot$($std::string tag$)\{$

int textureSlot $=-1$;

int index $=0$;

bool bFound $=$ false;

while $(($index $<$ m$\_$loadedTextures$)$ && $($bFound $==$ false$))\{$

if $($m$\_$textureIDs$[$index$].$tag.compare$($tag$)==0)\{$

textureSlot $=$ index;

bFound $=$ true;$\}$

else

index$++$;$\}$

return$($textureSlot$)$;$\}$

$*$ SetTransformations$()$

void SceneManager::SetTransformations$($

glm::vec$3$ scaleXYZ,

float XrotationDegrees,

float YrotationDegrees,

float ZrotationDegrees,

glm::vec$3$ positionXYZ$)\{$

$//$ variables for this method

glm::mat$4$ modelView;

glm::mat$4$ scale;

glm::mat$4$ rotationX;

glm::mat$4$ rotationY;

glm::mat$4$ rotationZ;

glm::mat$4$ translation;

$//$ set the scale value in the transform buffer

scale $=$ glm::scale$($scaleXYZ$)$;

$//$ set the rotation values in the transform buffer

rotationX $=$ glm::rotate$($glm::radians$($XrotationDegrees$),$ glm::vec$3(1\mathrm{.}0$f$,0\mathrm{.}0$f$,0\mathrm{.}0$f$))$;

rotationY $=$ glm::rotate$($glm::radians$($YrotationDegrees$),$ glm::vec$3(0\mathrm{.}0$f$,1\mathrm{.}0$f$,0\mathrm{.}0$f$))$;

rotationZ $=$ glm::rotate$($glm::radians$($ZrotationDegrees$),$ glm::vec$3(0\mathrm{.}0$f$,0\mathrm{.}0$f$,1\mathrm{.}0$f$))$;

$//$ set the translation value in the transform buffer

translation $=$ glm::translate$($positionXYZ$)$;

modelView $=$ translation $*$ rotationZ $*$ rotationY $*$ rotationX $*$ scale;

if $($NULL $!=$ m$\_$pShaderManager$)\{$

m$\_$pShaderManager$->$setMat$4$Value$($g$\_$ModelName, modelView$)$;$\}\}$

$*$ SetShaderColor$()$

void SceneManager::SetShaderColor$($

float redColorValue,

float greenColorValue,

float blueColorValue,

float alphaValue$)$

$//$ variables for this method

glm::vec$4$ currentColor;

currentColor.r $=$ redColorValue;

currentColor.g $=$ greenColorValue;

currentColor.b $=$ blueColorValue;

currentColor.a $=$ alphaValue;

if $($NULL $!=$ m$\_$pShaderManager$)\{$

m$\_$pShaderManager$->$setIntValue$($g$\_$UseTextureName, false$)$;

m$\_$pShaderManager$->$setVec$4$Value$($g$\_$ColorValueName, currentColor$)$;$\}\}$

$*$ SetShaderTexture$()$

void SceneManager::SetShaderTexture$($

std::string textu