#include "SceneManager.h$"$

#ifndef STB$\_$IMAGE$\_$IMPLEMENTATION

#define STB$\_$IMAGE$\_$IMPLEMENTATION

#include $"$stb$\_$image.h$"$

#endif

#include

$//$ declaration of global variables

namespace

$\{$

const char$*$ g$\_$ModelName $=$ "model";

const char$*$ g$\_$ColorValueName $=$ "objectColor";

const char$*$ g$\_$TextureValueName $=$ "objectTexture";

const char$*$ g$\_$UseTextureName $=$ "bUseTexture";

const char$*$ g$\_$UseLightingName $=$ "bUseLighting";

$\}$

$/***********************************************************$

$*$ SceneManager$()$

$*$

$*$ The constructor for the class

$***********************************************************/$

SceneManager::SceneManager$($ShaderManager $*$pShaderManager$)$

$\{$

m$\_$pShaderManager $=$ pShaderManager;

m$\_$basicMeshes $=$ new ShapeMeshes$()$;

$\}$

$/***********************************************************$

$*$ ~SceneManager$()$

$*$

$*$ The destructor for the class

$***********************************************************/$

SceneManager::~SceneManager$()$

$\{$

m$\_$pShaderManager $=$ NULL;

delete m$\_$basicMeshes;

m$\_$basicMeshes $=$ NULL;

$\}$

$/***********************************************************$

$*$ CreateGLTexture$()$

$*$

$*$ This method is used for loading textures from image files,

$*$ configuring the texture mapping parameters in OpenGL,

$*$ generating the mipmaps, and loading the read texture into

$*$ the next available texture slot in memory.

$***********************************************************/$

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$()$

$*$

$*$ This method is used for binding the loaded textures to

$*$ OpenGL texture memory slots. There are up to $16$ slots.

$***********************************************************/$

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$()$

$*$

$*$ This method is used for freeing the memory in all the

$*$ used texture memory slots.

$***********************************************************/$

void SceneManager::DestroyGLTextures$()$

$\{$

for $($int i $=0$; i $$ m$\_$lo