void MainScene::initializeGL()
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
generateTextures();
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
int main(int argc, char** argv)
{
//Puck status text
strcpy(text[0],"Shoot the puck!");
strcpy(text[1],"What a goal!");
strcpy(text[2], "Everything, but net!");
strcpy(text[3], "The puck hits the left post!");
strcpy(text[4], "The puck hits the right post!");
strcpy(text[5], "The puck hits the crossbar!");
strcpy(text[6], "Shoot it a little harder, guy!");
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1000,1000);
glutInitWindowPosition(50,50);
glutCreateWindow("Hockey Guy");
glEnable(GL_DEPTH_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
readPPM(BOARDS);
generateTextures(0);
readPPM(ICE);
generateTextures(1);
readPPM(NET);
generateTextures(2);
readPPM(STICK);
generateTextures(3);
readPPM(WALL);
generateTextures(4);
myinit();
glutDisplayFunc(display);
glutIdleFunc(idle);
glutKeyboardFunc(keys);
glutSpecialFunc(special);
glutMainLoop();
return 0;
}
//--------------------------------------------------------------
void testApp::setup(){
initGL();
generateTextures();
generateScreenSpaceFrameBuffers();
printFramebufferInfo();
loadModels();
setupGUI();
cameraXPos =0;
cameraZPos = -100;
cameraRotation = 0;
camera = new Camera(cameraXPos,400,cameraZPos);
fboUsed = true;
blurStep = false;
showGui = true;
cameraRotate = false;
doRecording = false;
#ifdef DEBUG
glInfo glInfo;
glInfo.getInfo();
glInfo.printSelf();
#endif
// Setup variable for Near and Far Camera ranges
int w = ofGetWidth();
int h = ofGetHeight();
float halfFov, theTan, screenFov, aspect;
screenFov = 60.0f;
float eyeX = (float)w / 2.0;
float eyeY = (float)h / 2.0;
halfFov = PI * screenFov / 360.0;
theTan = tanf(halfFov);
float dist = eyeY / theTan;
nearDist = dist / 10.0; // near / far clip plane
farDist = dist * 10.0;
aspect = (float)w/(float)h;
totStrength = 1.38;
// Shaders for SSAO and Passing
// NOTE! Settings for shaders can ONLY be set when they are set active!!!
ssaoShader.loadShader("ssao");
if (!ssaoShader.bLoaded){
cout << "SSAO Shader not loaded correctly" << endl;
}
passShader.loadShader("pass");
if (!passShader.bLoaded){
cout << "PASS Shader not loaded correctly" << endl;
}
nmShader.loadShader("nm");
if (!nmShader.bLoaded){
cout << "NM Shader not loaded correctly" << endl;
}
ssao2Shader.loadShader("ssao2");
if (!ssao2Shader.bLoaded){
cout << "SSAO2 Shader not loaded correctly" << endl;
}
blurShader.loadShader("blur");
if (!blurShader.bLoaded){
cout << "Blur Shader not loaded correctly" << endl;
}
// Camera Recording Setup
saver.listCodecs();
saver.setCodecType(18);
saver.setCodecQualityLevel(OF_QT_SAVER_CODEC_QUALITY_NORMAL);
saver.setup(1280,720,"output.mov");
ofSetFrameRate(30);
}
void BuiltinResources::preprocess(bool forceImport, time_t lastUpdateTime)
{
// Hidden dependency: Textures need to be generated before shaders as they may use the default textures
generateTextures();
Path dataListsFilePath = mBuiltinRawDataFolder + DATA_LIST_JSON;
SPtr<DataStream> dataListStream = FileSystem::openFile(dataListsFilePath);
json dataListJSON = json::parse(dataListStream->getAsString().c_str());
json skinJSON = dataListJSON["Skin"];
json cursorsJSON = dataListJSON["Cursors"];
json iconsJSON = dataListJSON["Icons"];
json includesJSON = dataListJSON["Includes"];
json shadersJSON = dataListJSON["Shaders"];
Path rawSkinFolder = mBuiltinRawDataFolder + SKIN_FOLDER;
Path rawCursorFolder = mBuiltinRawDataFolder + CURSOR_FOLDER;
Path rawIconFolder = mBuiltinRawDataFolder + ICON_FOLDER;
Path rawShaderFolder = mBuiltinRawDataFolder + SHADER_FOLDER;
Path rawShaderIncludeFolder = mBuiltinRawDataFolder + SHADER_INCLUDE_FOLDER;
// Update DataList.json if needed
bool updatedDataLists = false;
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
rawCursorFolder,
BuiltinResourcesHelper::AssetType::Normal,
cursorsJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
rawIconFolder,
BuiltinResourcesHelper::AssetType::Normal,
iconsJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
rawShaderIncludeFolder,
BuiltinResourcesHelper::AssetType::Normal,
includesJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
rawShaderFolder,
BuiltinResourcesHelper::AssetType::Normal,
shadersJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
rawSkinFolder,
BuiltinResourcesHelper::AssetType::Sprite,
skinJSON);
dataListStream->close();
if(updatedDataLists)
{
FileSystem::remove(dataListsFilePath);
dataListJSON["Skin"] = skinJSON;
dataListJSON["Cursors"] = cursorsJSON;
dataListJSON["Icons"] = iconsJSON;
dataListJSON["Includes"] = includesJSON;
dataListJSON["Shaders"] = shadersJSON;
String jsonString = dataListJSON.dump(4).c_str();
dataListStream = FileSystem::createAndOpenFile(dataListsFilePath);
dataListStream->writeString(jsonString);
dataListStream->close();
}
Path skinFolder = mBuiltinDataFolder + SKIN_FOLDER;
Path iconFolder = mBuiltinDataFolder + ICON_FOLDER;
Path shaderIncludeFolder = mBuiltinDataFolder + SHADER_INCLUDE_FOLDER;
Path shaderDependenciesFile = mBuiltinDataFolder + "ShaderDependencies.json";
// If forcing import, clear all data folders since everything will be recreated anyway
if(forceImport)
{
FileSystem::remove(mEngineCursorFolder);
FileSystem::remove(iconFolder);
FileSystem::remove(shaderIncludeFolder);
FileSystem::remove(mEngineShaderFolder);
FileSystem::remove(skinFolder);
FileSystem::remove(shaderDependenciesFile);
}
// Read shader dependencies JSON
json shaderDependenciesJSON;
if(FileSystem::exists(shaderDependenciesFile))
{
SPtr<DataStream> stream = FileSystem::openFile(shaderDependenciesFile);
shaderDependenciesJSON = json::parse(stream->getAsString().c_str());
stream->close();
}
// Import cursors
{
BuiltinResourcesHelper::updateManifest(
mEngineCursorFolder,
cursorsJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
Vector<bool> importFlags = BuiltinResourcesHelper::generateImportFlags(
cursorsJSON,
rawCursorFolder,
lastUpdateTime,
forceImport);
BuiltinResourcesHelper::importAssets(
cursorsJSON,
importFlags,
rawCursorFolder,
mEngineCursorFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
}
// Import icons
{
BuiltinResourcesHelper::updateManifest(
iconFolder,
iconsJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
Vector<bool> importFlags = BuiltinResourcesHelper::generateImportFlags(
iconsJSON,
rawIconFolder,
lastUpdateTime,
forceImport);
BuiltinResourcesHelper::importAssets(
iconsJSON,
importFlags,
rawIconFolder,
iconFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
}
// Import shaders
{
BuiltinResourcesHelper::updateManifest(
shaderIncludeFolder,
includesJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
BuiltinResourcesHelper::updateManifest(
mEngineShaderFolder,
shadersJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
Vector<bool> includeImportFlags = BuiltinResourcesHelper::generateImportFlags(
includesJSON,
rawShaderIncludeFolder,
lastUpdateTime,
forceImport);
Vector<bool> shaderImportFlags = BuiltinResourcesHelper::generateImportFlags(
shadersJSON,
rawShaderFolder,
lastUpdateTime,
forceImport,
&shaderDependenciesJSON,
rawShaderIncludeFolder);
// Hidden dependency: Includes must be imported before shaders, but import flags for shaders must be generated
// before includes are imported, since the process checks if imports changed
BuiltinResourcesHelper::importAssets(
includesJSON,
includeImportFlags,
rawShaderIncludeFolder,
shaderIncludeFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal,
nullptr,
true);
BuiltinResourcesHelper::importAssets(
shadersJSON,
shaderImportFlags,
rawShaderFolder,
mEngineShaderFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal,
&shaderDependenciesJSON,
true);
}
// Import GUI sprites
{
BuiltinResourcesHelper::updateManifest(
skinFolder,
skinJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
Vector<bool> skinImportFlags = BuiltinResourcesHelper::generateImportFlags(
skinJSON,
rawSkinFolder,
lastUpdateTime,
forceImport);
BuiltinResourcesHelper::importAssets(
skinJSON,
skinImportFlags,
rawSkinFolder,
skinFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
}
// Update shader dependencies JSON
{
String jsonString = shaderDependenciesJSON.dump(4).c_str();
dataListStream = FileSystem::createAndOpenFile(shaderDependenciesFile);
dataListStream->writeString(jsonString);
dataListStream->close();
}
// Import font
BuiltinResourcesHelper::importFont(
mBuiltinRawDataFolder + DefaultFontFilename,
DefaultFontFilename,
mBuiltinDataFolder,
{ DefaultFontSize },
false,
UUID("c9f08cab-f9c9-47c4-96e0-1066a8d4455b"),
mResourceManifest);
// Generate & save GUI skin
{
SPtr<GUISkin> skin = generateGUISkin();
Path outputPath = mBuiltinDataFolder + (GUISkinFile + u8".asset");
HResource skinResource = gResources()._createResourceHandle(skin, UUID("c1bf9a9d-4355-4841-a538-25e67730ec4b"));
gResources().save(skinResource, outputPath, true);
mResourceManifest->registerResource(skinResource.getUUID(), outputPath);
}
// Generate & save meshes
generateMeshes();
Resources::instance().unloadAllUnused();
}
