///
// Load texture from disk
//
GLuint LoadTexture ( char *fileName )
{
int width,
height;
char *buffer = esLoadTGA ( fileName, &width, &height );
GLuint texId;
if ( buffer == NULL )
{
esLogMessage ( "Error loading (%s) image.\n", fileName );
return 0;
}
glGenTextures ( 1, &texId );
glBindTexture ( GL_TEXTURE_2D, texId );
glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
free ( buffer );
return texId;
}
//
///
/// \brief Load a vertex and fragment shader, create a program object, link program.
// Errors output to log.
/// \param vertShaderSrc Vertex shader source code
/// \param fragShaderSrc Fragment shader source code
/// \return A new program object linked with the vertex/fragment shader pair, 0 on failure
//
GLuint ESUTIL_API esLoadProgram ( const char *vertShaderSrc, const char *fragShaderSrc )
{
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
// Load the vertex/fragment shaders
vertexShader = esLoadShader ( GL_VERTEX_SHADER, vertShaderSrc );
if ( vertexShader == 0 )
return 0;
fragmentShader = esLoadShader ( GL_FRAGMENT_SHADER, fragShaderSrc );
if ( fragmentShader == 0 )
{
glDeleteShader( vertexShader );
return 0;
}
// Create the program object
programObject = glCreateProgram ( );
if ( programObject == 0 )
return 0;
glAttachShader ( programObject, vertexShader );
glAttachShader ( programObject, fragmentShader );
// Link the program
glLinkProgram ( programObject );
// Check the link status
glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
if ( !linked )
{
GLint infoLen = 0;
glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char* infoLog = malloc (sizeof(char) * infoLen );
glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
esLogMessage ( "Error linking program:\n%s\n", infoLog );
free ( infoLog );
}
glDeleteProgram ( programObject );
return 0;
}
// Free up no longer needed shader resources
glDeleteShader ( vertexShader );
glDeleteShader ( fragmentShader );
return programObject;
}
GLuint ESUTIL_API esLoadShader ( GLenum type, const char *shaderSrc )
{
GLuint shader;
GLint compiled;
shader = glCreateShader ( type );
if ( shader == 0 )
return 0;
glShaderSource ( shader, 1, &shaderSrc, NULL );
glCompileShader ( shader );
glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled );
if ( !compiled )
{
GLint infoLen = 0;
glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char* infoLog = new char[infoLen];
glGetShaderInfoLog ( shader, infoLen, NULL, infoLog );
esLogMessage ( "Error compiling shader:\n%s\n", infoLog );
delete[] infoLog;
}
glDeleteShader ( shader );
return 0;
}
return shader;
}
void CSceneManager::loadScene(char *sceneFileLocation)
{
char buf[256], name[64], uniformName[64];
float x, y, z;
CObject *newObject = NULL;
FILE *fin = fopen(sceneFileLocation, "r");
if(fin == NULL)
{
esLogMessage("ERROR: reading sm %s", sceneFileLocation);
exit(1);
}
while(fscanf(fin, "%s", buf) != EOF)
{
if(!strcmp(buf, "OBJECT"))
{
if(newObject != NULL)
m_objects.push_back(newObject);
fscanf(fin, "%s\n", name);
newObject = new CObject(name);
}
else if(!strcmp(buf, "MODEL"))
{
fscanf(fin, "%s\n", name);
newObject->setModel(m_resourceManager->getModel(name));
}
else if(!strcmp(buf, "TEXTURE"))
{
fscanf(fin, "%s %s\n", name, uniformName);
newObject->addTexture(m_resourceManager->getTexture(name), uniformName);
}
else if(!strcmp(buf, "SHADER"))
{
fscanf(fin, "%s\n", name);
newObject->setShader(m_resourceManager->getShader(name));
}
else if(!strcmp(buf, "POS"))
{
fscanf(fin, "%f %f %f\n", &x, &y, &z);
newObject->translate(x, y, z);
}
else if(!strcmp(buf, "ROT"))
{
fscanf(fin, "%f %f %f\n", &x, &y, &z);
newObject->rotate(x, y, z);
}
else if(!strcmp(buf, "SCA"))
{
fscanf(fin, "%f %f %f\n", &x, &y, &z);
newObject->scale(x, y, z);
}
}
m_objects.push_back(newObject); // add last object
//esLogMessage("[SCENE] loaded <%s>", newObject->getName());
}
void CScene::init()
{
m_totalTime = 0;
//float aspect = 1600.0f / 900;
esLogMessage("[CScene->init()] %i %i", s_windowWidth, s_windowHeight);
float aspect = ((float)s_windowWidth) / s_windowHeight;
esMatrixLoadIdentity(&m_projectionMatrix);
esPerspective(&m_projectionMatrix, 50.0f, aspect, 0.2f, 2500.0f);
}
GLuint ESUTIL_API esLoadProgram ( const char *vertShaderSrc, const char *fragShaderSrc )
{
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
vertexShader = esLoadShader ( GL_VERTEX_SHADER, vertShaderSrc );
if ( vertexShader == 0 )
return 0;
fragmentShader = esLoadShader ( GL_FRAGMENT_SHADER, fragShaderSrc );
if ( fragmentShader == 0 )
{
glDeleteShader( vertexShader );
return 0;
}
programObject = glCreateProgram ( );
if ( programObject == 0 )
return 0;
glAttachShader ( programObject, vertexShader );
glAttachShader ( programObject, fragmentShader );
glLinkProgram ( programObject );
glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
if ( !linked )
{
GLint infoLen = 0;
glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char* infoLog =new char[infoLen];
glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
esLogMessage ( "Error linking program:\n%s\n", infoLog );
delete[] infoLog;
}
glDeleteProgram ( programObject );
return 0;
}
glDeleteShader ( vertexShader );
glDeleteShader ( fragmentShader );
return programObject;
}
///
// Load texture from disk
//
static GLuint LoadTexture ( char *fileName )
{
int width,
height;
char hasAlpha =0;
char *buffer=NULL;
GLuint texId;
if(strstr(fileName,"tga")!=NULL){
buffer=esLoadTGA ( fileName, &width, &height );
}else if(strstr(fileName,"bmp") !=NULL){
Image *image1;
// allocate space for texture we will use
image1 = (Image *) malloc(sizeof(Image));
if(esLoadBMP ( fileName, image1 ) == 0)
{
return 0;
}
width = image1->sizeX;
height = image1->sizeY;
buffer=image1->data;
}else if(strstr(fileName,"png") !=NULL){
buffer= esLoadPNG(fileName,&width, &height, &hasAlpha);
} else if(strstr(fileName,"jpg") !=NULL){
#if 0
texId = SOIL_load_OGL_texture(fileName,
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID,
SOIL_FLAG_POWER_OF_TWO |
SOIL_FLAG_MIPMAPS |
SOIL_FLAG_COMPRESS_TO_DXT);
return texId;
#endif
}
if ( buffer == NULL )
{
esLogMessage ( "Error loading (%s) image.\n", fileName );
return 0;
}
glGenTextures ( 1, &texId );
glBindTexture ( GL_TEXTURE_2D, texId );
glTexImage2D ( GL_TEXTURE_2D, 0, hasAlpha ? GL_RGBA : GL_RGB, width, height, 0, hasAlpha ? GL_RGBA : GL_RGB , GL_UNSIGNED_BYTE, buffer);
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
free ( buffer );
return texId;
}
void Key ( ESContext *esContext, unsigned char key, bool bIsPressed)
{
if (bIsPressed)
{
switch(key)
{
case 'O':
esLogMessage("\n pressed O - switched to moving light source\n");
bIsLightSource = true;
break;
case 'P':
esLogMessage("\n pressed P - switched to moving main camera\n");
bIsLightSource = false;
break;
}
}
if(bIsLightSource)
lighViewCamera.ProcessKey(key, bIsPressed); //moving light source to test shadow
else
mainCamera.ProcessKey(key, bIsPressed);
}
bool MainMenuState::update(ESContext* ctx, float deltaTime)
{
// Read mouse values
float mouseX = float(getMouseAxisX());
float mouseY = float(getMouseAxisY());
// Convert mouse coordinates to map coordinates.
vec2 mouseInMapCoordinates = m_map->screenToMapCoordinates(mouseX, mouseY);
//esLogMessage("Mouse in map: <%2.2f, %2.2f>", mouseInMapCoordinates.x, mouseInMapCoordinates.y);
GameObject* pickedObject = m_map->getLayer("Objects")->pick(mouseInMapCoordinates);
std::string start = "Start";
std::string exit = "Exit";
if (pickedObject != 0)
{
std::string test1 = pickedObject->getName();
if (test1.compare(start) == 0 && getMouseButtonState(MOUSE_LEFT))
{
esLogMessage("%s pressed!", pickedObject->getName().c_str());
getApp()->setState(new GameRunningState(getApp()));
return true;
}
else if (test1.compare(exit) == 0 && getMouseButtonState(MOUSE_LEFT))
{
esLogMessage("%s pressed!", pickedObject->getName().c_str());
return false;
}
}
else
{
// Update map. this will update all GameObjects inside a map layers.
m_map->update(deltaTime);
}
}
///
// Create a shader object, load the shader source, and
// compile the shader.
//
GLuint LoadShader ( GLenum type, const char *shaderSrc )
{
GLuint shader;
GLint compiled;
// Create the shader object
shader = glCreateShader ( type );
if ( shader == 0 )
{
return 0;
}
// Load the shader source
glShaderSource ( shader, 1, &shaderSrc, NULL );
// Compile the shader
glCompileShader ( shader );
// Check the compile status
glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled );
if ( !compiled )
{
GLint infoLen = 0;
glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char *infoLog = malloc ( sizeof ( char ) * infoLen );
glGetShaderInfoLog ( shader, infoLen, NULL, infoLog );
esLogMessage ( "Error compiling shader:\n%s\n", infoLog );
free ( infoLog );
}
glDeleteShader ( shader );
return 0;
}
return shader;
}
///
// esLoadTGA()
//
// Loads a 8-bit, 24-bit or 32-bit TGA image from a file
//
char *ESUTIL_API esLoadTGA ( void *ioContext, const char *fileName, int *width, int *height )
{
char *buffer;
esFile *fp;
TGA_HEADER Header;
size_t bytesRead;
// Open the file for reading
fp = esFileOpen ( ioContext, fileName );
if ( fp == NULL )
{
// Log error as 'error in opening the input file from apk'
esLogMessage ( "esLoadTGA FAILED to load : { %s }\n", fileName );
return NULL;
}
bytesRead = esFileRead ( fp, sizeof ( TGA_HEADER ), &Header );
*width = Header.Width;
*height = Header.Height;
if ( Header.ColorDepth == 8 ||
Header.ColorDepth == 24 || Header.ColorDepth == 32 )
{
int bytesToRead = sizeof ( char ) * ( *width ) * ( *height ) * Header.ColorDepth / 8;
// Allocate the image data buffer
buffer = ( char * ) malloc ( bytesToRead );
if ( buffer )
{
bytesRead = esFileRead ( fp, bytesToRead, buffer );
esFileClose ( fp );
return ( buffer );
}
}
return ( NULL );
}
GameRunningState2::GameRunningState2(GameApp* app)
: GameState(app)
, m_tmap(0)
, m_gameObject(0)
, m_pongComponents(0)
, m_score1(0)
, m_score2(0)
{
esLogMessage("Initializing secret level!");
m_tmap = new TmxMap();
m_pongComponents = new PongGameComponents(m_tmap);
bool load = m_tmap->loadMapFile("assets/level_pong.tmx", m_pongComponents);
if (load)
{
m_tmap->getCamera()->setPosition(vec2(m_tmap->getWidth()/2.22f, m_tmap->getHeight()/2.2f));
}
// Player 1 score
m_scoreFont1 = static_cast<GameObject*>(m_pongComponents->createNewEntity(m_pongComponents, "Score", nullptr, PropertySet()));
m_scoreFont1->getComponent<TextComponent>()->getText()->setText(std::to_string(m_score1));
m_scoreFont1->getComponent<TextComponent>()->getText()->setColor(255, 255, 255, 1);
m_scoreFont1->setSize(vec2(64.0f, 64.0f) * 20.0f);
m_scoreFont1->setPosition(7.0f, 6.0f);
// Player 2 score
m_scoreFont2 = static_cast<GameObject*>(m_pongComponents->createNewEntity(m_pongComponents, "Score", nullptr, PropertySet()));
m_scoreFont2->getComponent<TextComponent>()->getText()->setText(std::to_string(m_score2));
m_scoreFont2->getComponent<TextComponent>()->getText()->setColor(255, 255, 255, 1);
m_scoreFont2->setSize(vec2(64.0f, 64.0f) * 20.0f);
m_scoreFont2->setPosition(15.0f, 6.0f);
// You only need 5 points to win
// Player 1 win text
m_p1Win = static_cast<GameObject*>(m_pongComponents->createNewEntity(m_pongComponents, "Score", nullptr, PropertySet()));
// Player 2 win text
m_p2Win = static_cast<GameObject*>(m_pongComponents->createNewEntity(m_pongComponents, "Score", nullptr, PropertySet()));
}
GLuint LoadShader(GLenum type, const char *shaderSrc){
GLuint shader;
GLuint compile_status;
//Create shader object
shader = glCreateShader(type);
if(shader == 0)
return 0;
//Load shader src
glShaderSource(shader,1,&shaderSrc,NULL);
//Compile shader
glCompileShader(shader);
//Check Compile Status
glGetShaderiv(shader,GL_COMPILE_STATUS,&compile_status);
if(compile_status == 0){
GLint LogLen=0;
glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&LogLen);
if(LogLen > 1){
char *Log = malloc(sizeof(char)*LogLen);
glGetShaderInfoLog(shader,LogLen,NULL,Log);
esLogMessage("Error compiling shader:\n%s\n",Log);
free(Log);
}
glDeleteShader(shader);
return 0;
}
return shader;
}
// Initialize the shader and program object
int Init(ESContext *esContext){
esContext->userData = malloc(sizeof(UserData));
UserData *userData = esContext->userData;
GLbyte vShaderStr[] =
"attribute vec3 vPosition; \n"
"void main() \n"
"{ \n"
" gl_Position = vec4(vPosition,1.0); \n"
"} \n";
GLbyte fShaderStr[] =
"precision mediump float;\n"\
"void main() \n"
"{ \n"
" gl_FragColor = vec4(1.0,1.0,1.0,1.0); \n"
"} \n";
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint link_status;
//Load vertex and fragment shaders
vertexShader = LoadShader(GL_VERTEX_SHADER,vShaderStr);
fragmentShader = LoadShader(GL_FRAGMENT_SHADER,fShaderStr);
//Create program Object
programObject = glCreateProgram();
if(programObject == 0)
return 0;
//Attach shader to the program
glAttachShader(programObject , vertexShader);
glAttachShader(programObject , fragmentShader);
//Bind attributes
glBindAttribLocation(programObject,0,"vPosition");
//Link the program
glLinkProgram(programObject);
//Check the link status
glGetProgramiv(programObject,GL_LINK_STATUS,&link_status);
if(link_status == 0){
GLint LogLen = 0;
glGetProgramiv(programObject,GL_INFO_LOG_LENGTH,&LogLen);
if(LogLen > 1){
char* Log = malloc(sizeof(char)*LogLen);
glGetProgramInfoLog(programObject,LogLen,NULL,Log);
esLogMessage("Error linking program:\n%s\n",Log);
free(Log);
}
glDeleteProgram(programObject);
return GL_FALSE;
}
//Store Program Object
userData->programObject = programObject;
glClearColor(0.0f,0.0f,0.0f,0.0f);
return GL_TRUE;
}
///
// Initialize the shader and program object
//
int Init ( ESContext *esContext )
{
UserData *userData = esContext->userData;
GLbyte vShaderStr[] =
"attribute vec4 vPosition; \n"
"void main() \n"
"{ \n"
" gl_Position = vPosition; \n" //gl_Position == vVertices[]
"} \n";
GLbyte fShaderStr[] =
"precision mediump float;\n"\
"void main() \n"
"{ \n"
" gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );\n"
"} \n";
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
// Load the vertex/fragment shaders
vertexShader = LoadShader ( GL_VERTEX_SHADER, vShaderStr );
fragmentShader = LoadShader ( GL_FRAGMENT_SHADER, fShaderStr );
// Create the program object
programObject = glCreateProgram ( );
if ( programObject == 0 )
return 0;
glAttachShader ( programObject, vertexShader );
glAttachShader ( programObject, fragmentShader );
// Bind vPosition to attribute 0
glBindAttribLocation ( programObject, 0, "vPosition" ); // link "vPosition" variable in the GL shader code to GL attribute at index 0
// Link the program
glLinkProgram ( programObject );
// Check the link status
glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
if ( !linked )
{
GLint infoLen = 0;
glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char* infoLog = malloc (sizeof(char) * infoLen );
glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
esLogMessage ( "Error linking program:\n%s\n", infoLog );
free ( infoLog );
}
glDeleteProgram ( programObject );
return FALSE;
}
// Store the program object
userData->programObject = programObject;
glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
return TRUE;
}
///
// Initialize the shader and program object
//
int Init ( ESContext *esContext )
{
UserData *userData = esContext->userData;
char vShaderStr[] =
"#version 300 es \n"
"layout(location = 0) in vec4 vPosition; \n"
"void main() \n"
"{ \n"
" gl_Position = vPosition; \n"
"} \n";
char fShaderStr[] =
"#version 300 es \n"
"precision mediump float; \n"
"out vec4 fragColor; \n"
"void main() \n"
"{ \n"
" fragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 ); \n"
"} \n";
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
// Load the vertex/fragment shaders
vertexShader = LoadShader ( GL_VERTEX_SHADER, vShaderStr );
fragmentShader = LoadShader ( GL_FRAGMENT_SHADER, fShaderStr );
// Create the program object
programObject = glCreateProgram ( );
if ( programObject == 0 )
{
return 0;
}
glAttachShader ( programObject, vertexShader );
glAttachShader ( programObject, fragmentShader );
// Link the program
glLinkProgram ( programObject );
// Check the link status
glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
if ( !linked )
{
GLint infoLen = 0;
glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
char *infoLog = malloc ( sizeof ( char ) * infoLen );
glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
esLogMessage ( "Error linking program:\n%s\n", infoLog );
free ( infoLog );
}
glDeleteProgram ( programObject );
return FALSE;
}
// Store the program object
userData->programObject = programObject;
glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );
return TRUE;
}
GameRunningState2::~GameRunningState2()
{
// Delete your game content
esLogMessage("Deinit");
}
