//===================================================================//
//==================Main Method=====================================//
//==================================================================//
int main()
{
//===================================================================//
//==================Things you need to start with====================//
//==================================================================//
glfwInit();
Window testWindow(500, 50, 800, 600, "testWindow");
glfwMakeContextCurrent(testWindow.getWindow());
// Callback
glfwSetKeyCallback(testWindow.getWindow(), key_callback);
cam.setKeySpeed(2.0);
cam.setNearFar(0.01, 100);
glewInit();
OpenGL3Context context;
//renderer = new Renderer(context);
Renderer renderer(context);
//===================================================================//
//==================Shaders for your program========================//
//==================================================================//
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/Vertex-Shaders/TextureShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/Fragment-Shaders/TextureShader3D.frag")));
ShaderProgram shader(vs, fs);
VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert")));
FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag")));
ShaderProgram shaderGBuffer(vsGBuffer, fsGBuffer);
VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag")));
ShaderProgram shaderSFQ(vsSfq, fsSfq);
FBO fboGBuffer(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false);
ParticleSystem* particle = new ParticleSystem(glm::vec3(0, 0, 0), (char*)RESOURCES_PATH "/XML/ComicCloudEffect.xml");
particle->m_type = ParticleType::FIGHT;
ParticleSystem* particle2 = new ParticleSystem(glm::vec3(0, 0, 0), (char*)RESOURCES_PATH "/XML/SwarmOfFliesEffect.xml");
particle2->m_type = ParticleType::SWARMOFFLIES;
ParticleSystem* particleFire = new ParticleSystem(glm::vec3(0, 0, 0), (char*)RESOURCES_PATH "/XML/Fire.xml");
particleFire->m_type = ParticleType::FIRE;
Node particleNode("ParticleNode");
particleNode.addParticleSystem(particle2);
particleNode.setCamera(&cam);
particleNode.setParticleActive(true);
Node particleNodeFire("ParticleNodeFire");
particleNodeFire.addParticleSystem(particleFire);
particleNodeFire.setCamera(&cam);
particleNodeFire.setParticleActive(true);
//===================================================================//
//==================A Graph for the AI-Unit=========================//
//==================================================================//
glm::vec3 posFood(10.0, 0.0, -5.0);
glm::vec3 posSpawn(3.0, 0.0, 3.0);
Graph<AStarNode, AStarAlgorithm> testGraph;
//===================================================================//
//==================A Decision-Tree for the AI-Unit==================//
//==================================================================//
DecisionTree defaultTree;
defaultTree.setAntTreeAggressiv();
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: AI==============================//
Teapot teaAnt;
Texture texPlayer((char*)RESOURCES_PATH "/Mesh/Snake.jpg");
SoundFileHandler sfh = SoundFileHandler(1000);
AStarNode defaultASNode();
Ant ant_Flick;
ant_Flick.setAntAfraid();
AntMesh ant;
Node aiNode("Flick");
aiNode.addGeometry(&ant);
aiNode.addTexture(&texPlayer);
aiNode.addTranslation(ant_Flick.getPosition().x, ant_Flick.getPosition().y, ant_Flick.getPosition().z);
aiNode.setObject(&ant_Flick);
ant_Flick.setSoundHandler(&sfh);
ant_Flick.setSourceName(MOVESOUND_AI, "AIFootsteps", RESOURCES_PATH "/Sound/Footsteps.wav");
sfh.disableLooping("AIFootsteps");
ant_Flick.setSourceName(DEATHSOUND_AI, "AIDeath", RESOURCES_PATH "/Sound/death.wav");
sfh.disableLooping("AIDeath");
ant_Flick.setSourceName(EATSOUND_AI, "AIEssen", RESOURCES_PATH "/Sound/Munching.wav");
sfh.disableLooping("AIEssen");
ant_Flick.setSourceName(DEATHSOUND_FLIES_AI, "Flies", RESOURCES_PATH "/Sound/Fliege_kurz.wav");
sfh.setGain("Flies", 7.0);
Rect screenFillingQuad;
screenFillingQuad.loadBufferData();
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: Player===========================//
Teapot teaPlayer;
Texture texCV((char*)RESOURCES_PATH "/cv_logo.bmp");
GekoMesh gekoMesh;
geko.setExp(0.0);
geko.setLevelThreshold(100.0);
geko.setLevel(0);
Node playerNode("Player");
playerNode.addGeometry(&gekoMesh);
playerNode.setObject(&geko);
playerNode.addTexture(&texCV);
sfh.generateSource(posFood, RESOURCES_PATH "/Sound/Rascheln.wav");
geko.setSoundHandler(&sfh);
geko.setSourceName(MOVESOUND, "SpielerFootsteps", RESOURCES_PATH "/Sound/Rascheln.wav");
//geko.setSourceName(BACKGROUNDMUSIC, "Hintergrund", RESOURCES_PATH "/Sound/jingle2.wav");
geko.setSourceName(FIGHTSOUND, "Kampfsound", RESOURCES_PATH "/Sound/punch.wav");
geko.setSourceName(EATSOUND, "Essen", RESOURCES_PATH "/Sound/Munching.wav");
geko.setSourceName(QUESTSOUND, "Quest", RESOURCES_PATH "/Sound/jingle.wav");
geko.setSourceName(ITEMSOUND, "Item", RESOURCES_PATH "/Sound/itempickup.wav");
geko.setSourceName(FIRESOUND, "Fire", RESOURCES_PATH "/Sound/Feuer_kurz.wav");
sfh.disableLooping("Essen");
sfh.disableLooping("Quest");
sfh.disableLooping("Item");
//sfh.generateSource("Feuer",posFood, RESOURCES_PATH "/Sound/Feuer kurz.wav");
playerNode.setCamera(&cam);
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: Tree===========================//
StaticObject treeStatic;
treeStatic.setTree();
TreeMesh tree;
Node treeNode("Tree");
treeNode.addGeometry(&tree);
treeNode.setObject(&treeStatic);
treeNode.addTranslation(posFood);
treeNode.getBoundingSphere()->radius = 3.0;
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: Plane===========================//
StaticObject terrainObject;
terrainObject.setClassType(ClassType::TERRAIN);
Plane terrain;
Texture terrainTex((char*)RESOURCES_PATH "/Grass.jpg");
Node terrainNode("Plane");
terrainNode.addGeometry(&terrain);
terrainNode.addTexture(&terrainTex);
terrainNode.setObject(&terrainObject);
terrainNode.addTranslation(0.0, -0.75, 0.0);
terrainNode.addRotation(90.0f, glm::vec3(1.0, 0.0, 0.0));
terrainNode.addScale(20.0, 20.0, 20.0);
//===================================================================//
//==================Setting up the Level and Scene==================//
//==================================================================//
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
testLevel.getFightSystem()->setParticle(particle);
//==================Add Camera to Scene============================//
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("PlayerViewCam");
//==================Set Input-Maps and activate one================//
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap(MapType::OBJECT);
iH.getActiveInputMap()->update(geko);
//==================Add Objects to the Scene=======================//
//==================Update the Bounding-Sphere 1st time============//
testScene.getScenegraph()->getRootNode()->addChildrenNode(&aiNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&playerNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&terrainNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&treeNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&particleNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&particleNodeFire);
testScene.getScenegraph()->addParticleSystem(particle);
testScene.getScenegraph()->addParticleSystem(particle2);
testScene.getScenegraph()->addParticleSystem(particleFire);
// ==============================================================
// == Questsystem ====================================================
// ==============================================================
//QuestHandler questhandler;
/*Quest questCollect(1);
questCollect.setActive(true);
Goal_Collect goalCollect(1);
Goal_Collect goalCollect3(3);
questCollect.addGoal(&goalCollect);
questCollect.addGoal(&goalCollect3);
ExpReward expReward(1);
expReward.setExp(100);
questCollect.addReward(&expReward);
Item cookie2(100);
cookie2.setName("Cookie100");
cookie2.setTypeId(ItemType::COOKIE);
ItemReward itemReward(2);
itemReward.addItem(&cookie2);
questCollect.addReward(&itemReward);
Quest questCollect2(2);
questCollect2.setActive(true);
Goal_Collect goalCollect2(2);
questCollect2.addGoal(&goalCollect2);
questCollect2.addReward(&expReward);
questCollect2.addReward(&itemReward);
goalCollect.setGoalCount(50);
goalCollect2.setGoalCount(50);
goalCollect3.setGoalCount(50);
goalCollect.setItemType(ItemType::BRANCH);
goalCollect2.setItemType(ItemType::BRANCH);
goalCollect3.setItemType(ItemType::COOKIE);
testLevel.getQuestHandler()->addQuest(&questCollect);
testLevel.getQuestHandler()->addQuest(&questCollect2);*/
Quest questKillAnt(1);
Quest questEatAnt(2);
Quest questCollectCookie(3);
Quest questCollectBranch(4);
Goal_Kill killAnt(1);
Goal_Eaten eatAnt(2);
Goal_Collect collectCookie(3);
Goal_Collect collectBranch(4);
questKillAnt.addGoal(&killAnt);
questEatAnt.addGoal(&eatAnt);
questCollectCookie.addGoal(&collectCookie);
questCollectBranch.addGoal(&collectBranch);
killAnt.setGoalCount(1);
eatAnt.setGoalCount(1);
collectCookie.setGoalCount(1);
collectBranch.setGoalCount(1);
collectBranch.setItemType(ItemType::BRANCH);
collectCookie.setItemType(ItemType::COOKIE);
ExpReward expReward(1);
expReward.setExp(100);
questKillAnt.addReward(&expReward);
questEatAnt.addReward(&expReward);
questCollectCookie.addReward(&expReward);
questCollectBranch.addReward(&expReward);
QuestGraph questGraph;
QuestGraphNode nodeStart;
nodeStart.setQuest(&questKillAnt);
questGraph.addNode(&nodeStart);
questKillAnt.setActive(true);
QuestGraphNode nodeSecond;
nodeSecond.setQuest(&questEatAnt);
nodeSecond.setParent(&nodeStart);
questGraph.addNode(&nodeSecond);
QuestGraphNode nodeThird;
nodeThird.setQuest(&questCollectCookie);
nodeThird.setParent(&nodeSecond);
questGraph.addNode(&nodeThird);
QuestGraphNode nodeFourth;
nodeFourth.setQuest(&questCollectBranch);
nodeFourth.setParent(&nodeThird);
questGraph.addNode(&nodeFourth);
testLevel.getQuestHandler()->addQuest(&questKillAnt);
testLevel.getQuestHandler()->addQuest(&questEatAnt);
testLevel.getQuestHandler()->addQuest(&questCollectBranch);
testLevel.getQuestHandler()->addQuest(&questCollectCookie);
testLevel.getQuestHandler()->setGraph(&questGraph);
//===================================================================//
//==================Setting up the Collision=========================//
//==================================================================//
CollisionTest collision;
collision.collectNodes(testScene.getScenegraph()->getRootNode());
//===================================================================//
//==================Setting up the Observers========================//
//==================================================================//
ObjectObserver aiObserver(&testLevel);
SoundObserver soundAIObserver(&testLevel);
ant_Flick.addObserver(&aiObserver);
ant_Flick.addObserver(&soundAIObserver);
ObjectObserver playerObserver(&testLevel);
SoundObserver soundPlayerObserver(&testLevel);
geko.addObserver(&playerObserver);
geko.addObserver(&soundPlayerObserver);
CollisionObserver colObserver(&testLevel);
collision.addObserver(&colObserver);
collision.addObserver(&soundPlayerObserver);
GravityObserver gravityObserver(&testLevel);
collision.addObserver(&gravityObserver);
QuestObserver questObserver(&testLevel);
/*questCollect.addObserver(&questObserver);
questCollect2.addObserver(&questObserver);
questCollect.addObserver(&soundPlayerObserver);
questCollect2.addObserver(&soundPlayerObserver);
goalCollect.addObserver(&questObserver);
goalCollect2.addObserver(&questObserver);
goalCollect3.addObserver(&questObserver);*/
questKillAnt.addObserver(&questObserver);
questEatAnt.addObserver(&questObserver);
questCollectCookie.addObserver(&questObserver);
questCollectBranch.addObserver(&questObserver);
killAnt.addObserver(&questObserver);
eatAnt.addObserver(&questObserver);
collectCookie.addObserver(&questObserver);
collectBranch.addObserver(&questObserver);
testLevel.getFightSystem()->addObserver(&questObserver);
//===================================================================//
//==================Setting up the Gravity===========================//
//==================================================================//
Gravity gravity;
playerNode.addGravity(&gravity);
aiNode.addGravity(&gravity);
//===================================================================//
//==================The Render-Loop==================================//
//==================================================================//
float lastTime = glfwGetTime();
sfh.playSource("Feuer");
sfh.playSource("Hintergrund");
sfh.setGain("Hintergrund", 0.5f);
//===================================================================//
//==================The Particle-System==============================//
//==================================================================//
//Effect* smBla = new Effect();
//smBla->loadEffect((char*)RESOURCES_PATH "/XML/ComicCloudEffect.xml");
//ParticleSystem* particle = new ParticleSystem(glm::vec3(0, 0, -10), smBla);
// ParticleSystem* particle = new ParticleSystem(glm::vec3(0, 0, 0), (char*)RESOURCES_PATH "/XML/ComicCloudEffect.xml");
//===================================================================//
//==================The GUI=========================================//
//==================================================================//
//========================================================================================================
//SETUP GUI
//Texture bricks((char*)RESOURCES_PATH "/bricks_diffuse.png");
//hud = new GUI("testGUI", HUD_WIDTH, HUD_HEIGHT);
//hud->setPosition((WINDOW_WIDTH / 2) - (HUD_WIDTH / 2), WINDOW_HEIGHT - HUD_HEIGHT);
//hud->setCollapsable(false);
//hud->setTitleBarVisible(false);
//hud->setBackgroundAlpha(0.5f);
//hud->setResizable(false);
//hud->setUseScrollbar(false);
//hud->setMoveable(false);
//int hp = playerNode.getPlayer()->getHealth();
//int hpMax = 10;
//int exp = playerNode.getPlayer()->getExp();
//int expMax = playerNode.getPlayer()->getLevelThreshold();
//GuiElement::ProgressBar *hpBar = new GuiElement::ProgressBar(&hp, hpMax, 300, glm::fvec4(1.0f, 0.0f, 0.0f, 1.0f));
//hud->addElement(hpBar);
//hud->addElement(new GuiElement::SameLine());
//hud->addElement(new GuiElement::Text("HP"));
//GuiElement::ProgressBar *expBar = new GuiElement::ProgressBar(&exp, expMax, 300, glm::fvec4(1.0f, 0.9960784f, 0.9529411f, 1.0f));
//hud->addElement(expBar);
//hud->addElement(new GuiElement::SameLine());
//hud->addElement(new GuiElement::Text("EXP"));
//hud->addElement(new GuiElement::Spacing());
//hud->addElement(new GuiElement::Separator());
//hud->addElement(new GuiElement::Spacing());
//hud->addElement(new GuiElement::Text("LVL"));
//int level = playerNode.getPlayer()->getLvl();
//hud->addElement(new GuiElement::SameLine());
//GuiElement::IntBox *lvlBox = new GuiElement::IntBox(&level, glm::fvec4(1.0f, 1.0f, 1.0f, 1.0f), glm::fvec4(0.7f, 0.7f, 0.7f, 1.0f));
//hud->addElement(lvlBox);
//hud->addElement(new GuiElement::SameLine());
//GuiElement::PushButton *inventoryButton = new GuiElement::PushButton("Inventory");
//hud->addElement(inventoryButton);
//hud->addElement(new GuiElement::SameLine());
//GuiElement::PushButton *questButton = new GuiElement::PushButton("Quests");
//hud->addElement(questButton);
//questWindow = new GuiElement::NestedWindow();
//questWindow->hide();
//GuiElement::Header *quest1 = new GuiElement::Header("Test the Quest");
//quest1->addElement(new GuiElement::Text("Quest description here bla bla bla"));
//GuiElement::Header *quest2 = new GuiElement::Header("Testwindow Questwindow");
//quest2->addElement(new GuiElement::Text("Quest description here too bla bla bla"));
//questWindow->addElement(quest1);
//questWindow->addElement(quest2);
//questWindow->setName("Quests");
//questWindow->setCollapsable(false);
//questWindow->setPosition(WINDOW_WIDTH - QUEST_WIDTH, (WINDOW_HEIGHT / 2) - (QUEST_HEIGHT / 2));
//questWindow->setSize(QUEST_WIDTH, QUEST_HEIGHT);
//hud->addNestedWindow(questWindow);
//inventoryWindow = new GuiElement::NestedWindow();
//inventoryWindow->hide();
//inventoryWindow->setName("Inventory");
//inventoryWindow->setCollapsable(false);
//inventoryWindow->setResizable(false);
//inventoryWindow->setPosition(WINDOW_WIDTH - QUEST_WIDTH, (WINDOW_HEIGHT / 2) - (QUEST_HEIGHT / 2));
//inventoryWindow->setSize(QUEST_WIDTH, QUEST_HEIGHT);
//hud->addNestedWindow(inventoryWindow);
//std::map<std::string, Texture*> *inventoryItems = new std::map<std::string, Texture*>();
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem1"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem2"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem3"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem4"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem5"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem6"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem7"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem8"), &bricks));
//inventoryItems->insert(std::pair<std::string, Texture*>(std::string("bricksItem9"), &bricks));
//GuiElement::Inventory *inventory = new GuiElement::Inventory(inventoryItems, 6);
//inventoryWindow->addElement(inventory);
// PlayerGUI playerGUI(HUD_WIDTH, HUD_HEIGHT, WINDOW_HEIGHT, WINDOW_WIDTH, QUEST_HEIGHT, QUEST_WIDTH, playerNode.getPlayer());
float testFloat = float(0.0f);
float testFloat2 = float(0.0f);
/*testLevel.addGUI(hud);
testLevel.getGUI("testGUI")->m_windowName;*/
while (!glfwWindowShouldClose(testWindow.getWindow()))
{
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float currentTime = glfwGetTime();
float deltaTime = currentTime - lastTime;
lastTime = currentTime;
fboGBuffer.bind();
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderGBuffer.bind();
shaderGBuffer.sendMat4("viewMatrix", cam.getViewMatrix());
shaderGBuffer.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shaderGBuffer);
ant_Flick.update();
geko.update();
geko.deleteKeyInput();
geko.setDeltaTime(currentTime);
collision.update();
//TEST
//particle->update(cam);
//particle->render(cam);
shaderGBuffer.unbind();
fboGBuffer.unbind();
//ScreenFillingQuad Render Pass
shaderSFQ.bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderSFQ.sendSampler2D("fboTexture", fboGBuffer.getColorTexture(2));
screenFillingQuad.renderGeometry();
shaderSFQ.unbind();
glfwSwapBuffers(testWindow.getWindow());
glfwPollEvents();
}
glfwDestroyWindow(testWindow.getWindow());
glfwTerminate();
return 0;
}
void BackendScene::generateVPL( size_t vplNum, const char* vplFile,size_t vpldepth )
{
this->vpls.clear();
SET_CLAMPING_DISTANCE( 0.05 * sceneradius );
//------------------------- READ FILE IF IT DOES EXIST--------------------------------------
if( strcmp(vplFile,"")){
FILE *ptr;
ptr = fopen(vplFile,"rb");
if (ptr)
{
size_t siz;
fread(&siz,sizeof(size_t),1,ptr);
vpls.resize(siz);
for (size_t i = 0 ; i<siz; ++i)
vpls[i].read(ptr);
fclose(ptr);
std::cout << "Vpl file read. Total # of vpls:"<< vpls.size()<<std::endl;
return;
}
else std::cout << "Unable to read vpl file."<< std::endl;
}
//------------------------- OTHERWISE GENERATE VPLS--------------------------------------
Random rnd(RND_SEED);
// Place VPLs that substitute the original lights (direct VPLs)
std::vector<Ref<Light> >::iterator it = allLights.begin();
for ( ; it !=allLights.end(); ++it)
{
// Replace TriangleLight
if( (*it).dynamicCast<TriangleLight>() )
{
Ref<TriangleLight> tr = (*it).dynamicCast<TriangleLight>();
Color I = tr->L * length(cross(tr->e1,tr->e2)) * 0.5;
int triangleSamples = 1024;
// HACK to avoid too many VPLs for many quads...
if (allLights.size() > 2000)
triangleSamples = 100;
for (int i=0 ; i < triangleSamples ; ++i)
{
Vector3f pos = uniformSampleTriangle(rnd.getFloat(),rnd.getFloat(),tr->v0,tr->v1,tr->v2);
this->vpls.push_back(vplVPL(pos, -tr->Ng, I * rcp((float)triangleSamples) ) );
}
}
// Replace SpotLight
else if ((*it).dynamicCast<SpotLight>())
{
Ref<SpotLight> sl = (*it).dynamicCast<SpotLight>();
if ( sl->cosAngleMax >= 0.05 || sl->cosAngleMin <= 0.95 )
throw std::runtime_error("Not supporting spotlights with other than 90 degree falloff for VPL generation.");
this->vpls.push_back(vplVPL(sl->P,sl->_D,sl->I));
}
// Replace environment map
else if ((*it).dynamicCast<HDRILight>())
{
Ref<HDRILight> hd = (*it).dynamicCast<HDRILight>();
int envmapSamples = 32768;
float dirlightdistance = DIR_LIGHT_DISTANCE;
for (int i=0 ; i < envmapSamples ; ++i)
{
Vector3f pos(uniformSampleSphere(rnd.getFloat(),rnd.getFloat()));
Vector3f dir = -pos;
pos *= dirlightdistance; pos += scenecenter;
// CHECK below line later it is not completely precise
Color I = hd->Le(-dir) * four_pi * rcp((float)envmapSamples) * dirlightdistance * dirlightdistance;
this->vpls.push_back(vplVPL(pos, -dir , I ));
}
}
else if ((*it).dynamicCast<DirectionalLight>())
{
Ref<DirectionalLight> sl = (*it).dynamicCast<DirectionalLight>();
float distance = 100000;
this->vpls.push_back(vplVPL(sl->_wo*distance,sl->_wo,sl->E*distance*distance));
}
else
throw std::runtime_error("Not supported light type for VPL generation.");
}
// Place VPLs (indirect VPLs)
size_t direct = this->vpls.size();
size_t orig = this->allLights.size();
if (vpldepth <=1) return;
while (this->vpls.size() < (vplNum+direct))
{
// Sample orig lights for photons
Ref<Light> vp = this->allLights[rnd.getInt(orig)];
Vector3f pos;
Sample3f dir;
Vec2f vr(rnd.getFloat(),rnd.getFloat());
Vec2f vs(rnd.getFloat(),rnd.getFloat());
Color I = vp->samplePhoton(dir,pos,vr,vs,sceneradius,scenecenter);
if (dir.pdf==0.0f) continue;
I *= (float) orig * rcp(dir.pdf);
// Generate a path for the photon and add VPLs
int maxdepth = int(vpldepth) - 1; // -1 because 1 for pt means only direct light
while ( maxdepth-- && (I != zero ) )
{
Ray ray (pos,dir,32*std::numeric_limits<float>::epsilon(), inf);
DifferentialGeometry dg;
rtcIntersect(this->scene,(RTCRay&)ray);
this->postIntersect(ray,dg);
if (!ray)//nothing is hit
break;
/*! face forward normals */
if (dot(dg.Ng, ray.dir) > 0)
{
dg.Ng = -dg.Ng; dg.Ns = -dg.Ns;
}
CompositedBRDF brdfs;
if (dg.material) dg.material->shade(ray, Medium::Vacuum(), dg, brdfs);
BRDFType diffuseBRDFTypes = (BRDFType)(DIFFUSE);
Vec2f s = Vec2f(rnd.getFloat(),rnd.getFloat());
Color c = brdfs.sample(-ray.dir,dg, dir,diffuseBRDFTypes,s,rnd.getFloat(),diffuseBRDFTypes);
if (c==zero || dir.pdf==0.0f) break;
// the dot prod should not be zero since then c would be zero
float dott = dot(dir,dg.Ns);
if (dott==0.0f) break;
Color contrib = I * c * rcp(dott) * rcp((float)vplNum) ;
//if (std::isnan(contrib.r) || std::isnan(contrib.g) || std::isnan(contrib.b))
// break;
this->vpls.push_back(vplVPL(dg.P,-dg.Ns,contrib));
Color contribScale = c * rcp(dir.pdf);
float rrProb = min(1.0f, reduce_avg(contribScale));
if(rrProb == 0.0f)break;
if (rnd.getFloat() > rrProb)
break;
I *= contribScale * rcp(rrProb);
pos = dg.P;
}
}
//------------------------------PERTURB VPLS WITH THE SAME POSITION-----------------------------------------------------------
auto vplComp = [] (const vplVPL& vp1,const vplVPL& vp2) { return vp1.P < vp2.P; };
std::sort(this->vpls.begin(),this->vpls.end(),vplComp);
std::vector<vplVPL>::iterator itt = this->vpls.begin();
while(itt != ( vpls.end() - 1 ) && itt != vpls.end())
{
vplVPL& v1 = *itt, & v2 = *(itt+1);
if(v1.P == v2.P)
{
v2.I += v1.I;
itt = this->vpls.erase(itt);
}
else
++itt;
}
//------------------------------WRITE OUT VPLS INTO A FILE-----------------------------------------------------------
// writing out the VPLs
FILE *ptr;
ptr = fopen(vplFile,"wb");
if (ptr)
{
size_t siz = this->vpls.size();
fwrite(&siz,sizeof(size_t),1,ptr);
if (vpls.size())
for (size_t i = 0 ; i<siz; ++i)
vpls[i].write(ptr);
fclose(ptr);
std::cout << "Vpl file written. Total # of vpls:"<< vpls.size()<<std::endl;
}
else std::cout << "Unable to write vpl file. Total # of vpls: "<<vpls.size() << std::endl;
return;
}
int main()
{
glfwInit();
GLFWwindow* window;
window = glfwCreateWindow(800, 600, "ParticleSystemScene", NULL, NULL);
glfwMakeContextCurrent(window);
//CAM
cam.setKeySpeed(4.0);
iH.setAllInputMaps(cam);
glfwSetKeyCallback(window, key_callback);
cam.setFOV(50);
cam.setNearFar(1, 100);
glewInit();
//TEXTURES
Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png");
Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png");
Texture* smokeBlackTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png");
Texture* smokeBlackTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png");
Texture* snowTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/particle/snowflake.png"); //TODO better Resolution
//FINAL EMITTER SNOW
Emitter* snow = new Emitter(0, glm::vec3(0.0, 10.0, -5.0), 0.0, 0.166, 100, 30.0, true);
snow->setVelocity(0);
snow->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 1.0), 0.5f);
snow->setAreaEmitting(false, true, 10.0, 10000);
snow->addTexture(snowTex, 0.0);
snow->defineLook(true, 0.04, 2.0);
snow->setMovable(true);
//FINAL EMITTER WHITE SMOKE
Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 5.0), 0.0, 0.4, 1, 8.0, true);
smokeWhite->setVelocity(2);
smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeWhite->addTexture(smokeWhiteTex1, 1.0);
smokeWhite->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.2f };
std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f };
smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 4.0, 4.0, false, 0.3);
smokeWhite->switchToGeometryShader();
//FINAL EMITTER BLACK SMOKE
Emitter* smokeBlack = new Emitter(0, glm::vec3(0.0, 0.0, -10.0), 0.0, 0.4, 1, 8.0, true);
smokeBlack->setVelocity(2);
smokeBlack->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeBlack->addTexture(smokeBlackTex1, 1.0);
smokeBlack->addTexture(smokeBlackTex2, 0.08);
std::vector<float> smokeBlackSize{ 0.1f, 0.4f, 0.8f, 1.2f };
std::vector<float> smokeBlackTime{ 0.0f, 0.2f, 0.75f, 1.0f };
smokeBlack->defineLook(true, smokeBlackSize, smokeBlackTime, 1.0, 4.0, 4.0, false, 0.3);
smokeBlack->switchToGeometryShader();
//PARTICLE SYSTEM
Effect* sn = new Effect();
sn->addEmitter(snow);
ParticleSystem* psSnow = new ParticleSystem(glm::vec3(0, 2, -5), sn);
Node snowNode("snowNode");
snowNode.setParticleActive(true);
snowNode.setCamera(&cam);
snowNode.addParticleSystem(psSnow);
Effect* smWhi = new Effect();
smWhi->addEmitter(smokeWhite);
ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(0, 0, 3), smWhi);
Node whiteSmokeNode("whiteSmokeNode");
whiteSmokeNode.setParticleActive(true);
whiteSmokeNode.setCamera(&cam);
whiteSmokeNode.addParticleSystem(psSmokeWhite);
Effect* smBla = new Effect();
smBla->addEmitter(smokeBlack);
ParticleSystem* psSmokeBlack = new ParticleSystem(glm::vec3(0, 0, -3), smBla);
Node blackSmokeNode("blackSmokeNode");
blackSmokeNode.setParticleActive(true);
blackSmokeNode.setCamera(&cam);
blackSmokeNode.addParticleSystem(psSmokeBlack);
// Shader
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag")));
ShaderProgram shader(vs, fs);
// Renderer
OpenGL3Context context;
Renderer renderer(context);
// Object
Teapot teapot;
teapot.loadBufferData();
Node teapotNode("teapotNode");
teapotNode.addGeometry(&teapot);
teapotNode.setCamera(&cam);
teapotNode.setModelMatrix(glm::translate(teapotNode.getModelMatrix(), glm::vec3(0.0, 0.0, -7.0)));
//need scene here mainly because of input
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
//Add Camera to Scene
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("Pilotview");
//Set Input-Maps and activate one
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap("Pilotview");
//Add Objects to the Scene
testScene.getScenegraph()->getRootNode()->addChildrenNode(&teapotNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&blackSmokeNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&snowNode);
//start the ParticleSystems
psSmokeBlack->start();
psSmokeWhite->start();
psSnow->start();
// getting the start time
double startTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
cam.setSensitivity(glfwGetTime() - startTime);
startTime = glfwGetTime();
glEnable(GL_DEPTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.bind();
shader.sendMat4("modelMatrix", teapotNode.getModelMatrix());
shader.sendMat4("viewMatrix", cam.getViewMatrix());
shader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shader);
shader.unbind();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void ThriftBuffer::write(const Object& data) {
VariableSerializer vs(m_serializerType);
String sdata = vs.serialize(VarNR(data), true);
write(sdata);
}
// -------------------------------------------------------------
// OptimizerImplementation::p_gatherProblem
// -------------------------------------------------------------
void
OptimizerImplementation::p_gatherProblem(void)
{
parallel::Communicator comm(this->communicator());
int nproc(comm.size());
int me(comm.rank());
// package up the local part of the problem into a string buffer;
// MPI serialization cannot be used directly because VariablePtr's
// are used in Expression's
std::string lbuf;
{
std::ostringstream oss;
boost::archive::binary_oarchive oa(oss);
oa & p_variables;
oa & p_constraints;
oa & p_objective;
oa & p_globalConstraints;
lbuf = oss.str();
}
// all processes get a copy of the other processor parts of the problem
std::vector<std::string> gbuf(nproc);
boost::mpi::all_gather(comm, lbuf, gbuf);
// extract the problem and put it in local variables as required
for (int p = 0; p < nproc; ++p) {
if (p != me) {
std::istringstream iss(gbuf[p]);
boost::archive::binary_iarchive ia(iss);
std::vector<VariablePtr> tmpvars;
std::vector<ConstraintPtr> tmpcons;
ConstraintMap tmpglobal;
ExpressionPtr tmpobj;
ia & tmpvars;
ia & tmpcons;
ia & tmpobj;
ia & tmpglobal;
for (std::vector<VariablePtr>::iterator v = tmpvars.begin();
v != tmpvars.end(); ++v) {
p_allVariables[(*v)->name()] = *v;
}
std::copy(tmpcons.begin(), tmpcons.end(),
std::back_inserter(p_allConstraints));
// ConstraintMap::const_iterator c;
// for (c = tmpglobal.begin(); c != tmpglobal.end(); ++c) {
// std::cout << me << ": " << p << ": " << c->second->name() << ": "
// << c->second->render() << std::endl;
// }
p_gatherGlobalConstraints(tmpglobal);
if (tmpobj) {
if (!p_fullObjective) {
p_fullObjective = tmpobj;
} else {
p_fullObjective = p_fullObjective + tmpobj;
}
}
} else {
std::copy(p_constraints.begin(), p_constraints.end(),
std::back_inserter(p_allConstraints));
// ConstraintMap::const_iterator c;
// for (c = p_globalConstraints.begin(); c != p_globalConstraints.end(); ++c) {
// std::cout << me << ": " << p << ": " << c->second->name() << ": "
// << c->second->render() << std::endl;
// }
p_gatherGlobalConstraints(p_globalConstraints);
if (p_objective) {
if (!p_fullObjective) {
p_fullObjective = p_objective;
} else {
p_fullObjective = p_fullObjective + p_objective;
}
}
}
comm.barrier();
}
// add global constraints to the constraints list
ConstraintMap::const_iterator c;
for (c = p_allGlobalConstraints.begin(); c != p_allGlobalConstraints.end(); ++c) {
// std::cout << me << ": after: " << c->second->name() << ": "
// << c->second->render() << std::endl;
p_allConstraints.push_back(c->second);
}
// make sure the locally defined variables are used on this processor
for (std::vector<VariablePtr>::iterator v = p_variables.begin();
v != p_variables.end(); ++v) {
p_allVariables[(*v)->name()] = *v;
}
// subsitute variables in constraints and objective so they are unique
VariableSubstituter vs(p_allVariables);
std::for_each(p_allConstraints.begin(), p_allConstraints.end(),
boost::bind(&Constraint::accept, _1, boost::ref(vs)));
p_fullObjective->accept(vs);
// uniquely name all constraints in parallel
if (nproc > 1) {
ConstraintRenamer r;
std::for_each(p_allConstraints.begin(), p_allConstraints.end(),
boost::bind(&Constraint::accept, _1, boost::ref(r)));
}
}
int main() {
glfwInit();
//our window
GLFWwindow* window;
window = glfwCreateWindow(800, 600, "ComputeShader", NULL, NULL);
glfwMakeContextCurrent(window);
cam.setName("PilotviewCam");
cam.setPosition(glm::vec4(0, 0, 2.0, 1.0));
cam.setNearFar(0.01f, 10.0f);
// Set all InputMaps and set one InputMap active
iH.setAllInputMaps(cam);
iH.changeActiveInputMap("Pilotview");
// Callback
glfwSetKeyCallback(window, key_callback);
glewInit();
/*MAGIC*/
ComputeShader cs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/simpleComputeShader.comp")));
ShaderProgram compute(cs);
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.frag")));
ShaderProgram render(vs, fs);
//GLuint render_vao;
//glGenVertexArrays(1, &render_vao);
//glBindVertexArray(render_vao);
GLuint position_ssbo;
glGenBuffers(1, &position_ssbo);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, position_ssbo);
glBufferData(GL_SHADER_STORAGE_BUFFER, PARTICLE_COUNT * sizeof(struct pos), NULL, GL_STATIC_DRAW);
GLint bufMask = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
struct pos* positions = (struct pos*)glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, PARTICLE_COUNT * sizeof(struct pos), bufMask);
for (int i = 0; i < PARTICLE_COUNT; i++)
{
positions[i].x = ((rand() % 100) / 100.0f) - 0.5;
positions[i].y = ((rand() % 100) / 100.0f) - 0.5;
positions[i].z = ((rand() % 100) / 100.0f) - 0.5;
positions[i].w = 1;
}
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
//glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
//glEnableVertexAttribArray(0);
//std::cout << "HIER MUSS 000 STEHEN: " << positions[1].x << positions[1].y << positions[1].z << std::endl;
/*END*/
float startCamTime = glfwGetTime();
double lastTime = glfwGetTime();
int nbFrames = 0;
while (!glfwWindowShouldClose(window))
{
// Measure speed
double currentTime = glfwGetTime();
nbFrames++;
if (currentTime - lastTime >= 1.0){ // If last prinf() was more than 1 sec ago
// printf and reset timer
printf("%f ms/frame\n", 1000.0 / double(nbFrames));
nbFrames = 0;
lastTime += 1.0;
}
cam.setSensitivity(glfwGetTime() - startCamTime);
startCamTime = cam.getSensitivity();
compute.bind();
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, position_ssbo);
compute.sendFloat("time", glfwGetTime());
glDispatchCompute(PARTICLE_GROUP_COUNT, 1, 1);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0);
glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT);
compute.unbind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
render.bind();
glBindBuffer(GL_ARRAY_BUFFER, position_ssbo);
render.sendMat4("viewMatrix", cam.getViewMatrix());
render.sendMat4("projectionMatrix", cam.getProjectionMatrix());
glVertexPointer(4, GL_FLOAT, 0, (void*)0);
glEnableClientState(GL_VERTEX_ARRAY);
//glPointSize(1.0);
glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT);
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);
render.unbind();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void TrajectoryGenerator::Set_CIRC(Pose3D StartPose, Pose3D ViaPose, Pose3D EndPose, double TotalTime , double AccelTime )
{
MotionPose mPose;
if(AccelTime >= TotalTime*0.5)
{
AccelTime = TotalTime*0.5;
}
int Er;
mRobot->ComputeIK(StartPose, angleforplanning, *angleforplanning, &Er);
mPose.StartPose = *angleforplanning;
mRobot->ComputeIK(ViaPose, angleforplanning, *angleforplanning, &Er);
mRobot->ComputeIK(EndPose, angleforplanning, *angleforplanning, &Er);
mPose.EndPose = *angleforplanning;
Pose3D SP, EP, VP;
SP = StartPose;
EP = EndPose;
VP = ViaPose;
mPose.StartPose3D = SP;
mPose.EndPose3D = EP;
mPose.ViaPose3D = VP;
vecd vs(3);
vs(0) = SP.x - VP.x;
vs(1) = SP.y - VP.y;
vs(2) = SP.z - VP.z;
vecd ve(3);
ve(0) = EP.x - VP.x;
ve(1) = EP.y - VP.y;
ve(2) = EP.z - VP.z;
double p, q;
p = ve.squaredNorm() * (vs.squaredNorm() - vs.dot(ve) ) / (2.0 * (vs.squaredNorm() * ve.squaredNorm() - vs.dot(ve) * vs.dot(ve) ));
q = vs.squaredNorm() * (vs.dot(ve) - ve.squaredNorm() ) / (2.0 * (vs.dot(ve) * vs.dot(ve) - vs.squaredNorm() * ve.squaredNorm() ));
vecd vc(3);
vc = p*vs + q*ve;
Position3D Center;
Center.x = vc(0) + VP.x;
Center.y = vc(1) + VP.y;
Center.z = vc(2) + VP.z;
mPose.CenterPosition = Center;
PoseList.push_back(mPose);
timeprofile mtime;
vecd cs(3), cv(3), ce(3);
cs(0) = SP.x - Center.x;
cs(1) = SP.y - Center.y;
cs(2) = SP.z - Center.z;
cv(0) = VP.x - Center.x;
cv(1) = VP.y - Center.y;
cv(2) = VP.z - Center.z;
ce(0) = EP.x - Center.x;
ce(1) = EP.y - Center.y;
ce(2) = EP.z - Center.z;
mtime.distance1 = acos(cs.dot(cv) / ( cs.norm() * cv.norm() ) );
mtime.distance = mtime.distance1 + acos(cv.dot(ce) / ( cv.norm() * ce.norm() ) );
double V = mtime.distance/(TotalTime-AccelTime);
double a = V/AccelTime;
mtime.Method = Circular;
mtime.ta = AccelTime;
mtime.tc = TotalTime - 2 * AccelTime;
mtime.td = AccelTime;
mtime.totoaltime = TotalTime;
mtime.a0[0] = 0.0;
mtime.a1[0] = 0.0;
mtime.a2[0] = 0.5*a;
mtime.a0[1] = -0.5*a*AccelTime*AccelTime;
mtime.a1[1] = V;
mtime.a2[1] = 0.0;
mtime.a0[2] = mtime.distance - 0.5*a*TotalTime*TotalTime;
mtime.a1[2] = a*TotalTime;
mtime.a2[2] = -0.5*a;
mTF.push_back(mtime);
mMF.push_back(mTF);
mTF.clear();
}
TEST_F(VectorStatisticsFixture, CvConstructor) {
vector_type points_;
VectorStatistics<> vs(points_);
}
WavesExample(void)
: make_plane(
Vec3f( 0.0f, 0.0f, 0.0f),
Vec3f(100.0f, 0.0f, 0.0f),
Vec3f( 0.0f, 0.0f,-100.0f),
50, 50
), plane_instr(make_plane.PatchInstructions())
, plane_indices(make_plane.PatchIndices())
, camera_matrix(prog, "CameraMatrix")
, camera_position(prog, "CameraPosition")
, anim_time(prog, "Time")
, prev_period(-1)
{
VertexShader vs(ObjectDesc("Vertex"));
vs.Source(StrLit(
"#version 410\n"
"uniform vec3 CameraPosition;"
"in vec3 Position;"
"out vec3 vertPosition;"
"out float vertDistance;"
"void main(void)"
"{"
" vertPosition = Position;"
" vertDistance = distance(CameraPosition, Position);"
"}"
));
vs.Compile();
prog.AttachShader(vs);
TessControlShader cs(ObjectDesc("TessControl"));
cs.Source(
"#version 410\n"
"layout(vertices = 3) out;"
"in vec3 vertPosition[];"
"in float vertDistance[];"
"out vec3 tecoPosition[];"
"int tessLevel(float dist)"
"{"
" return clamp(int(150.0 / (dist+0.1)), 1, 10);"
"}"
"void main(void)"
"{"
" tecoPosition[gl_InvocationID] ="
" vertPosition[gl_InvocationID];"
" if(gl_InvocationID == 0)"
" {"
" gl_TessLevelInner[0] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1]+"
" vertDistance[2] "
" )*0.333);"
" gl_TessLevelOuter[0] = tessLevel(("
" vertDistance[1]+"
" vertDistance[2] "
" )*0.5);"
" gl_TessLevelOuter[1] = tessLevel(("
" vertDistance[2]+"
" vertDistance[0] "
" )*0.5);"
" gl_TessLevelOuter[2] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1] "
" )*0.5);"
" }"
"}"
);
cs.Compile();
prog.AttachShader(cs);
TessEvaluationShader es(ObjectDesc("TessEvaluation"));
es.Source(
"#version 410\n"
"#define MaxWaves 5\n"
"layout(triangles, equal_spacing, ccw) in;"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"uniform vec3 LightPosition;"
"uniform vec3 CameraPosition;"
"uniform float Time;"
"uniform int WaveCount;"
"uniform vec3 WaveDirections[MaxWaves];"
"uniform vec3 WaveDimensions[MaxWaves];"
"in vec3 tecoPosition[];"
"out vec3 teevNormal;"
"out vec3 teevLightDir;"
"out vec3 teevViewDir;"
"out float teevDistance;"
"void main(void)"
"{"
" const vec3 Up = vec3(0.0, 1.0, 0.0);"
" vec3 Position ="
" gl_TessCoord.x * tecoPosition[0]+"
" gl_TessCoord.y * tecoPosition[1]+"
" gl_TessCoord.z * tecoPosition[2];"
" vec3 Pos = Position;"
" vec3 Nml = Up;"
" for(int w=0; w!=WaveCount; ++w)"
" {"
" vec3 Dir = WaveDirections[w];"
" vec3 Dim = WaveDimensions[w];"
" float Dist = dot(Position, Dir);"
" float u = Dim.y*sin(Dist/Dim.x + Time*Dim.z);"
" Pos += Up * u;"
" float w = (Dim.y/Dim.x)*cos(Dist/Dim.x + Time*Dim.z);"
" Nml -= Dir * w;"
" float d = -0.125*Dim.x*sin(2.0*Dist/Dim.x + Time*Dim.z);"
" Pos += Dir * d;"
" }"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(Pos, 1.0);"
" teevNormal = normalize(Nml);"
" teevLightDir = normalize(LightPosition - Pos);"
" teevViewDir = normalize(CameraPosition - Pos);"
" teevDistance = distance(CameraPosition, Pos);"
"}"
);
es.Compile();
prog.AttachShader(es);
FragmentShader fs(ObjectDesc("Fragment"));
fs.Source(StrLit(
"#version 410\n"
"uniform samplerCube EnvMap;"
"in vec3 teevNormal;"
"in vec3 teevLightDir;"
"in vec3 teevViewDir;"
"in float teevDistance;"
"out vec3 fragColor;"
"void main(void)"
"{"
" float Dim = clamp(30.0/teevDistance, 0.0, 1.0);"
" float LightRefl = dot(reflect(-teevLightDir, teevNormal), teevViewDir);"
" float LightHit = dot(teevNormal, teevLightDir);"
" float Diffuse = clamp(LightHit+0.1, 0.0, 1.0);"
" float Specular = pow(clamp(LightRefl, 0.0, 0.91), 32);"
" vec3 Environ=texture(EnvMap,reflect(-teevViewDir, teevNormal)).rgb;"
" vec3 WaterColor = vec3(0.4, 0.5, 0.5);"
" vec3 LightColor = vec3(1.0, 1.0, 1.0);"
" vec3 FogColor = vec3(0.9, 0.9, 0.9);"
" vec3 WaveColor ="
" LightColor*Specular+"
" WaterColor*Diffuse+"
" Environ*0.02;"
" fragColor = mix(WaveColor, FogColor, 1.0-Dim);"
"}"
));
fs.Compile();
prog.AttachShader(fs);
prog.Link();
prog.Use();
plane.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
Uniform<Vec3f>(prog, "LightPosition").Set(-100.0, 100.0, 20.0);
Uniform<Vec3f> wave_directions(prog, "WaveDirections");
Uniform<Vec3f> wave_dimensions(prog, "WaveDimensions");
Uniform<GLint>(prog, "WaveCount").Set(5);
wave_directions[0] = Normalized(Vec3f(1.0f, 0.0f, 1.0f));
wave_dimensions[0] = Vec3f(5.0f, 1.5f, 1.2f);
wave_directions[1] = Normalized(Vec3f(1.0f, 0.0f, 0.5f));
wave_dimensions[1] = Vec3f(4.0f, 0.8f, 1.2f);
wave_directions[2] = Normalized(Vec3f(1.0f, 0.0f, 0.1f));
wave_dimensions[2] = Vec3f(2.0f, 0.5f, 2.4f);
wave_directions[3] = Normalized(Vec3f(1.0f, 0.0f,-0.1f));
wave_dimensions[3] = Vec3f(1.5f, 0.2f, 3.7f);
wave_directions[4] = Normalized(Vec3f(1.0f, 0.0f, 0.4f));
wave_dimensions[4] = Vec3f(1.1f, 0.2f, 4.7f);
Texture::Active(0);
{
auto image = images::Squares(512, 512, 0.9f, 16, 16);
auto bound_tex = Bind(env_map, Texture::Target::CubeMap);
for(int i=0; i!=6; ++i)
Texture::Image2D(Texture::CubeMapFace(i), image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
bound_tex.SwizzleG(TextureSwizzle::Red);
bound_tex.SwizzleB(TextureSwizzle::Red);
}
UniformSampler(prog, "EnvMap").Set(0);
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
void QhullLinkedList_test::
t_QhullLinkedList_iterator()
{
RboxPoints rcube("c");
Qhull q(rcube,"QR0"); // rotated unit cube
QhullVertexList vs(q.endVertex(), q.endVertex());
QhullVertexListIterator i= vs;
QCOMPARE(vs.count(), 0);
QVERIFY(!i.hasNext());
QVERIFY(!i.hasPrevious());
i.toBack();
QVERIFY(!i.hasNext());
QVERIFY(!i.hasPrevious());
QhullVertexList vs2 = q.vertexList();
QhullVertexListIterator i2(vs2);
QCOMPARE(vs2.count(), 8);
i= vs2;
QVERIFY(i2.hasNext());
QVERIFY(!i2.hasPrevious());
QVERIFY(i.hasNext());
QVERIFY(!i.hasPrevious());
i2.toBack();
i.toFront();
QVERIFY(!i2.hasNext());
QVERIFY(i2.hasPrevious());
QVERIFY(i.hasNext());
QVERIFY(!i.hasPrevious());
// i at front, i2 at end/back, 4 neighbors
QhullVertexList vs3 = q.vertexList(); // same as vs2
QhullVertex v3(vs3.first());
QhullVertex v4= vs3.first();
QCOMPARE(v3, v4);
QVERIFY(v3==v4);
QhullVertex v5(v4.next());
QVERIFY(v4!=v5);
QhullVertex v6(v5.next());
QhullVertex v7(v6.next());
QhullVertex v8(vs3.last());
QCOMPARE(i2.peekPrevious(), v8);
i2.previous();
i2.previous();
i2.previous();
i2.previous();
QCOMPARE(i2.previous(), v7);
QCOMPARE(i2.previous(), v6);
QCOMPARE(i2.previous(), v5);
QCOMPARE(i2.previous(), v4);
QVERIFY(!i2.hasPrevious());
QCOMPARE(i.peekNext(), v4);
// i.peekNext()= 1.0; // compiler error
QCOMPARE(i.next(), v4);
QCOMPARE(i.peekNext(), v5);
QCOMPARE(i.next(), v5);
QCOMPARE(i.next(), v6);
QCOMPARE(i.next(), v7);
i.next();
i.next();
i.next();
QCOMPARE(i.next(), v8);
QVERIFY(!i.hasNext());
i.toFront();
QCOMPARE(i.next(), v4);
}//t_QhullLinkedList_iterator
int
verifysigner(uchar *sign, int len, uchar *data, ulong ndata)
{
Get sig;
int alg;
ulong issued, expires, now;
int footprint, r, n;
uchar buf[128], digest[SHA1dlen];
DigestState *ds;
volatile struct {mpint* b;} b;
volatile struct {mpint* s;} s;
SigAlgVec *sa;
Signerkey *key;
Skeyset *sigs;
/* alg[1] issued[4] expires[4] footprint[2] signer[n] sig[m] */
sigs = up->env->sigs;
if(sigs == nil)
return 1; /* not enforcing signed modules */
sig.p = sign;
sig.ep = sign+len;
alg = vc(&sig);
if(alg != 2)
return 0; /* we do only SHA1/RSA */
sa = findsigalg("rsa");
if(sa == nil)
return 0;
if(vs(buf, sizeof(buf), &sig, 4) < 0)
return 0;
now = osusectime()/1000000;
issued = G32(buf);
if(vs(buf, sizeof(buf), &sig, 4) < 0)
return 0;
if(issued != 0 && now < issued)
return 0;
expires = G32(buf);
if(expires != 0 && now >= expires)
return 0;
footprint = vc(&sig) << 8;
footprint |= vc(&sig);
if(footprint < 0)
return 0;
r = 0;
b.b = nil;
s.s = nil;
qlock(&sigs->l);
if(waserror())
goto out;
if((n = vs(buf, sizeof(buf)-NUMSIZE-1, &sig, -1)) < 0) /* owner */
goto out;
buf[n] = 0;
key = findsignerkey(sigs, sa->name, footprint, (char*)buf);
if(key == nil)
goto out;
n += snprint((char*)buf+n, NUMSIZE, " %lud", expires);
ds = sha1(buf, n, nil, nil);
sha1(data, ndata, digest, ds);
b.b = betomp(digest, SHA1dlen, nil);
if(b.b == nil)
goto out;
s.s = betomp(sig.p, sig.ep-sig.p, nil);
if(s.s == nil)
goto out;
r = (*sa->verify)(b.b, s.s, key->pk);
out:
qunlock(&sigs->l);
if(b.b != nil)
mpfree(b.b);
if(s.s != nil)
mpfree(s.s);
return r;
}
void Attributes::setDoubleAttr(const string& name, double value)
{
this->checkAttributeName(name);
SetDoubleAttrVisitor vs(name, value);
this->accept(vs);
}
forAllConstIter(dictionary, dict, iter)
{
if (iter().keyword() != "type" && iter().keyword() != "value")
{
if
(
iter().isStream()
&& iter().stream().size()
)
{
ITstream& is = iter().stream();
// Read first token
token firstToken(is);
if
(
firstToken.isWord()
&& firstToken.wordToken() == "nonuniform"
)
{
token fieldToken(is);
if (!fieldToken.isCompound())
{
if
(
fieldToken.isLabel()
&& fieldToken.labelToken() == 0
)
{
// Ignore nonuniform 0 entry
}
else
{
FatalIOErrorInFunction
(
dict
) << "\n token following 'nonuniform' "
"is not a compound"
<< exit(FatalIOError);
}
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<scalar>>::typeName
)
{
scalarField* fPtr = new scalarField;
fPtr->transfer
(
dynamicCast<token::Compound<List<scalar>>>
(
fieldToken.transferCompoundToken(is)
)
);
if (fPtr->size() != patchSize_)
{
FatalIOErrorInFunction
(
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< patchSize_ << ')'
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
scalarFields.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<vector>>::typeName
)
{
vectorField* fPtr = new vectorField;
fPtr->transfer
(
dynamicCast<token::Compound<List<vector>>>
(
fieldToken.transferCompoundToken(is)
)
);
if (fPtr->size() != patchSize_)
{
FatalIOErrorInFunction
(
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< patchSize_ << ')'
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
vectorFields.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<sphericalTensor>>::typeName
)
{
sphericalTensorField* fPtr = new sphericalTensorField;
fPtr->transfer
(
dynamicCast
<
token::Compound<List<sphericalTensor>>
>
(
fieldToken.transferCompoundToken(is)
)
);
if (fPtr->size() != patchSize_)
{
FatalIOErrorInFunction
(
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< patchSize_ << ')'
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
sphericalTensorFields.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<symmTensor>>::typeName
)
{
symmTensorField* fPtr = new symmTensorField;
fPtr->transfer
(
dynamicCast
<
token::Compound<List<symmTensor>>
>
(
fieldToken.transferCompoundToken(is)
)
);
if (fPtr->size() != patchSize_)
{
FatalIOErrorInFunction
(
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< patchSize_ << ')'
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
symmTensorFields.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<tensor>>::typeName
)
{
tensorField* fPtr = new tensorField;
fPtr->transfer
(
dynamicCast<token::Compound<List<tensor>>>
(
fieldToken.transferCompoundToken(is)
)
);
if (fPtr->size() != patchSize_)
{
FatalIOErrorInFunction
(
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< patchSize_ << ')'
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
tensorFields.insert(iter().keyword(), fPtr);
}
else
{
FatalIOErrorInFunction
(
dict
) << "\n compound " << fieldToken.compoundToken()
<< " not supported"
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
}
else if
(
firstToken.isWord()
&& firstToken.wordToken() == "uniform"
)
{
token fieldToken(is);
if (!fieldToken.isPunctuation())
{
scalarFields.insert
(
iter().keyword(),
new scalarField
(
patchSize_,
fieldToken.number()
)
);
}
else
{
// Read as scalarList.
is.putBack(fieldToken);
scalarList l(is);
if (l.size() == vector::nComponents)
{
vector vs(l[0], l[1], l[2]);
vectorFields.insert
(
iter().keyword(),
new vectorField(patchSize_, vs)
);
}
else if (l.size() == sphericalTensor::nComponents)
{
sphericalTensor vs(l[0]);
sphericalTensorFields_.insert
(
iter().keyword(),
new sphericalTensorField(patchSize_, vs)
);
}
else if (l.size() == symmTensor::nComponents)
{
symmTensor vs(l[0], l[1], l[2], l[3], l[4], l[5]);
symmTensorFields.insert
(
iter().keyword(),
new symmTensorField(patchSize_, vs)
);
}
else if (l.size() == tensor::nComponents)
{
tensor vs
(
l[0], l[1], l[2],
l[3], l[4], l[5],
l[6], l[7], l[8]
);
tensorFields.insert
(
iter().keyword(),
new tensorField(patchSize_, vs)
);
}
else
{
FatalIOErrorInFunction
(
dict
) << "\n unrecognised native type " << l
<< "\n on patch " << patchName_
<< exit(FatalIOError);
}
}
}
}
}
}
void CheckChaptersVerses::verses_check(unsigned int book, unsigned int chapter, const vector < ustring > &verses)
// This checks all the verses that are in 'book' and 'chapter'.
// It supports sequences in the form of \v 1,2,3,
// and ranges in the form of \v 1b-3 and \v 2-4a and \v 2b-5a.
{
// Check whether there are any verses at all. If not, stop further
// processing because the following code assumes there are verses.
if (verses.empty()) {
message(book, chapter, "1", _("Chapter has no verses"));
return;
}
// Check for verses in chapter 0, which indicates the \c 1 marker wasn't there.
if ((chapter == 0) && (verses.size() > 1)) {
message(book, chapter, "1", _("Chapter marker missing"));
}
// Transform the verses in the internally used encoding, so as to accomodate
// for sequences and ranges.
vector < unsigned int >expanded_verses;
vector < unsigned int >verses_pointers;
for (unsigned int i = 0; i < verses.size(); i++) {
// Do not work in the container, but on a copy.
ustring vs(verses[i]);
// If there is a range, take the beginning and the end and fill up in between.
if (vs.find("-") != string::npos) {
size_t position;
position = vs.find("-");
ustring start_range, end_range;
start_range = vs.substr(0, position);
vs.erase(0, ++position);
end_range = vs;
int start_expanded_verse = 2 * convert_to_int(number_in_string(start_range));
if (start_range.find("b") != string::npos)
start_expanded_verse++;
// Checking on range start.
if (start_range.find("a") != string::npos)
message(book, chapter, verses[i], _("Range starts with \"a\""));
int end_expanded_verse = 2 * convert_to_int(number_in_string(end_range));
if (end_range.find("a") == string::npos)
end_expanded_verse++;
// Check on range end.
if (end_range.find("b") != string::npos)
message(book, chapter, verses[i], _("Range ends with \"b\""));
for (int i2 = start_expanded_verse; i2 <= end_expanded_verse; i2++) {
expanded_verses.push_back(i2);
verses_pointers.push_back(i);
}
}
// If there is a sequence, take each verse in the sequence, and store it.
else if (vs.find(",") != string::npos) {
int iterations = 0;
do {
// In case of an unusual range formation, do not hang, but give message.
iterations++;
if (iterations > 50) {
message(book, chapter, verses[i], _("Unusual verse sequence"));
break;
}
size_t position = vs.find(",");
ustring verse;
if (position == string::npos) {
verse = vs;
vs.clear();
} else {
verse = vs.substr(0, position);
vs.erase(0, ++position);
}
store_expanded_verse(verse, i, expanded_verses, verses_pointers);
} while (!vs.empty());
}
// No range and no sequence: a "normal" verse.
else {
store_expanded_verse(vs, i, expanded_verses, verses_pointers);
}
}
// See whether it starts at verse 0 or 1.
if (expanded_verses[0] > 2)
message(book, chapter, verses[0], "Verse 1 missing");
// See whether the verses are within the limit.
for (unsigned int i = 0; i < expanded_verses.size(); i += 2) {
unsigned int verse;
verse = expanded_verses[i] / 2;
if (verse > highest_verse) {
message(book, chapter, convert_to_string(verse), _("Extra verse or wrong versification"));
}
}
// See whether there are verses or bits out of sequence.
int previous_verse = expanded_verses[0] - 1;
for (unsigned int i = 0; i < expanded_verses.size(); i++) {
ustring previous_verse_text;
unsigned int pointer = verses_pointers[i];
if (pointer == 0)
previous_verse_text = _("beginning");
else
previous_verse_text = verses[pointer - 1];
if ((int)expanded_verses[i] != previous_verse + 1) {
message(book, chapter, verses[pointer], _("Verse out of sequence following ") + previous_verse_text);
}
previous_verse = expanded_verses[i];
}
// Check whether we have enough verses.
int highverse = expanded_verses[expanded_verses.size() - 1];
highverse = highverse / 2;
if (highverse < (int)highest_verse) {
message(book, chapter, verses[verses.size() - 1], _("Not enough verses in chapter"));
}
// Clear storage.
expanded_verses.clear();
verses_pointers.clear();
}
TEST(SharedValueTest, ctorInt)
{
int i = -324523;
unsigned u = 0x334234u;
char c = -22;
short s = 289;
unsigned char uc = 244;
unsigned short us = 3467;
long long ll = -20398574395872907ll;
unsigned long long ull = 985734209239847656ull;
EXPECT_NO_THROW(Value v(i));
EXPECT_NO_THROW(Value v(u));
EXPECT_NO_THROW(Value v(c));
EXPECT_NO_THROW(Value v(s));
EXPECT_NO_THROW(Value v(uc));
EXPECT_NO_THROW(Value v(us));
EXPECT_NO_THROW(Value v(ll));
EXPECT_NO_THROW(Value v(ull));
Value vi(i);
EXPECT_EQ(vi.as<int>(), i);
Value vu(u);
EXPECT_EQ(vu.as<unsigned>(), u);
Value vc(c);
EXPECT_EQ(vc.as<char>(), c);
Value vs(s);
EXPECT_EQ(vs.as<short>(), s);
Value vuc(uc);
EXPECT_EQ(vuc.as<unsigned char>(), uc);
Value vus(us);
EXPECT_EQ(vus.as<unsigned short>(), us);
Value vll(ll);
EXPECT_NE(vll.as<long long>(), ll); // 32 bit storage overfflow
EXPECT_EQ(vll.as<long long>(), static_cast<long long>(int(ll)));
Value vull(ull);
EXPECT_NE(vull.as<unsigned long long>(), ull); // 32 bit storage overfflow
EXPECT_EQ(vull.as<unsigned long long>(), static_cast<unsigned long long>(int(ull)));
Value vllNoOverflow(-42424ll); // no 32 bit storage overflow
EXPECT_EQ(vllNoOverflow.as<long long>(), -42424ll);
Value vullNoOverflow(0x43424242ull); // no 32 bit storage overflow
EXPECT_EQ(vullNoOverflow.as<unsigned long long>(), 0x43424242ull);
EXPECT_EQ(vi.type(), typeid(int));
EXPECT_EQ(vu.type(), typeid(int));
EXPECT_EQ(vc.type(), typeid(int));
EXPECT_EQ(vs.type(), typeid(int));
EXPECT_EQ(vuc.type(), typeid(int));
EXPECT_EQ(vus.type(), typeid(int));
EXPECT_EQ(vll.type(), typeid(int));
EXPECT_EQ(vull.type(), typeid(int));
// copy
EXPECT_NO_THROW(Value v(vi));
EXPECT_NO_THROW(Value v(vu));
EXPECT_NO_THROW(Value v(vc));
EXPECT_NO_THROW(Value v(vs));
EXPECT_NO_THROW(Value v(vuc));
EXPECT_NO_THROW(Value v(vus));
EXPECT_NO_THROW(Value v(vll));
EXPECT_NO_THROW(Value v(vull));
Value vi2(vi);
EXPECT_EQ(vi2.as<int>(), i);
Value vu2(vu);
EXPECT_EQ(vu2.as<unsigned>(), u);
Value vc2(vc);
EXPECT_EQ(vc2.as<char>(), c);
Value vs2(vs);
EXPECT_EQ(vs2.as<short>(), s);
Value vuc2(vuc);
EXPECT_EQ(vuc2.as<unsigned char>(), uc);
Value vus2(vus);
EXPECT_EQ(vus2.as<unsigned short>(), us);
Value vll2(vll);
EXPECT_NE(vll.as<long long>(), ll);
EXPECT_EQ(vll2.as<long long>(), static_cast<long long>(int(vll)));
Value vull2(vull);
EXPECT_NE(vull.as<unsigned long long>(), ull);
EXPECT_EQ(vull2.as<unsigned long long>(), static_cast<unsigned long long>(int(vull)));
EXPECT_EQ(vi2.type(), typeid(int));
EXPECT_EQ(vu2.type(), typeid(int));
EXPECT_EQ(vc2.type(), typeid(int));
EXPECT_EQ(vs2.type(), typeid(int));
EXPECT_EQ(vuc2.type(), typeid(int));
EXPECT_EQ(vus2.type(), typeid(int));
EXPECT_EQ(vll2.type(), typeid(int));
EXPECT_EQ(vull2.type(), typeid(int));
}
VirtualState* ContentManager::LockLuaState()
{
for(auto it = m_luaStates.begin(); it != m_luaStates.end(); ++it)
{
RealState& hs = *it;
if(hs.trylock())
return &hs;
}
if(m_luaFb == LFB_FIND_LUA_STATE)
{
// Get our ticket
std::uint64_t ticket = m_luaSequenceManager.GetTicket();
bool inLoop = true;
// Focus on our duty
while(true) {
// Is our ticket the next one yet?
if(m_luaSequenceManager.ProcessTicket(ticket))
{
// It is! But we have to wait for a lua state to free...
while(inLoop) {
for(auto it = m_luaStates.begin(); it != m_luaStates.end(); ++it)
{
RealState& hs = *it;
if(hs.trylock())
{
// Found it!
// The next ticket can start searching now...
if(!m_luaSequenceManager.ValidateTicket(ticket))
{
// But if something had gone wrong,
// we must go back to the end of the line.
hs.unlock();
ticket = m_luaSequenceManager.GetTicket();
inLoop = false;
break;
}
return &hs;
}
}
// Sleep for a while...
std::this_thread::yield();
}
inLoop = true;
}
else
{
// Sleep for a while...
std::this_thread::yield();
}
}
}
else if(m_luaFb == LFB_CREATE_LUA_STATE)
{
std::unique_ptr<VirtualState> vs(new TempLocklessState);
InitLuaState(vs->State());
return vs.release();
}
return nullptr;
}
//enumerate all the possible vertex set upto size fragSize+1, and insert into the fragment table of the database
//fragSize+1 is the fragSize+1 value (see paper), gid is the gid in the Graph table of the database
//D is the distance matrix
// generate closely connected vertex set
//can reduce the size of the table significantly
void LoadGraph::insertFragments()
{
assert(fragSize>=2);
NodeSetList list1, list2;
for(int v1=0; v1<G->n()-fragSize+1; v1++)
{
for(int v2=v1+1; v2<G->n()-fragSize+2; v2++)
{
if((*pOrthinfolist)[v1][0]==0 || (*pOrthinfolist)[v2][0]==0)
continue;
NodeSet vs;
vs.push_back(v1);
vs.push_back(v2);
if(fragSize==2 && D[v1][v2]<=fragLimit)
{
vector<NodeOrtholog> vfset;
insertFragmentHelp(vs, 0, vfset);
}
else
list1.push_back(vs);
}
}
NodeSetList* prev_list, *curr_list;
prev_list=&list1; curr_list=&list2;
//we have k-subset, we want to generat k+1-subset
for(int k=2; k<fragSize; k++)
{
unsigned int numloop=prev_list->size();
NodeSetList::iterator prev_it;
for(unsigned int count=0; count<numloop; count++)
{
//debug(15, "count= "<<count<<endl);
prev_it=prev_list->begin();
NodeSet pvs=(*prev_it);//the vertex set
int i=pvs[pvs.size()-1]+1; //vertex set sorted by id
for(; i<G->n()-fragSize+k+1; i++)
{
//debug(15, "i="<<i<<endl);
if((*pOrthinfolist)[i][0]==0)
continue;
NodeSet vs(pvs);
vs.push_back(i);
if((int)vs.size()==fragSize)
{
//only work for fragment size=3
int numSmall=0;
bool ok=false;
for(unsigned int s=0; s<vs.size()-1; s++)
{
for(unsigned int t=s+1; t<vs.size(); t++)
{
if(D[ vs[s] ][ vs[t] ]<=fragLimit)
{
numSmall++;
if(numSmall>=2)
{ ok=true; break;}
}
}
if(ok) break;
}
if(ok)
{
vector<NodeOrtholog> vfset;
insertFragmentHelp(vs, 0, vfset);
}
}
else
curr_list->push_back(vs);
//debug(15, "after something");
}
prev_list->erase(prev_it);
}
//swap curr_map and prev_map
NodeSetList* temp=prev_list;
prev_list=curr_list;
curr_list=temp;
}
}
void initialize() override
{
OpenGLWindow::initialize();
//load shaders
{
QOpenGLShader vs(QOpenGLShader::Vertex);
vs.compileSourceFile("TessellationTerrain/main.vs.glsl");
mProgram.addShader(&vs);
QOpenGLShader tcs(QOpenGLShader::TessellationControl);
tcs.compileSourceFile("TessellationTerrain/main.tcs.glsl");
mProgram.addShader(&tcs);
QOpenGLShader tes(QOpenGLShader::TessellationEvaluation);
tes.compileSourceFile("TessellationTerrain/main.tes.glsl");
mProgram.addShader(&tes);
QOpenGLShader fs(QOpenGLShader::Fragment);
fs.compileSourceFile("TessellationTerrain/main.fs.glsl");
mProgram.addShader(&fs);
if (!mProgram.link())
qFatal("Error linking shaders");
}
//grab uniform locations
{
mUniforms.mvMatrix = mProgram.uniformLocation("mvMatrix");
mUniforms.mvpMatrix = mProgram.uniformLocation("mvpMatrix");
mUniforms.projMatrix = mProgram.uniformLocation("projMatrix");
mUniforms.dmapDepth = mProgram.uniformLocation("dmapDepth");
}
mVao.bind();
glPatchParameteri(GL_PATCH_VERTICES, 4);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//build displacment map
{
QVector<GLubyte> displacmentMap;
displacmentMap.reserve(mSize*mSize);
std::srand(35456);
for (int i=0; i<mSize*mSize; i++)
displacmentMap.append(randInt(0, 255));
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, mSize, mSize);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mSize, mSize, GL_R, GL_UNSIGNED_BYTE, &displacmentMap[0]);
}
//load terrain texture
{
glActiveTexture(GL_TEXTURE1);
mTerrainTexture = QSharedPointer<QOpenGLTexture>(new QOpenGLTexture(QImage("./Common/dirt.png").mirrored()));
mTerrainTexture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
mTerrainTexture->setMagnificationFilter(QOpenGLTexture::Linear);
}
}
Foam::genericFvPatchField<Type>::genericFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
calculatedFvPatchField<Type>(p, iF, dict, false),
actualTypeName_(dict.lookup("type")),
dict_(dict)
{
if (!dict.found("value"))
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, const dictionary&)",
dict
) << "\n Cannot find 'value' entry"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< nl
<< " which is required to set the"
" values of the generic patch field." << nl
<< " (Actual type " << actualTypeName_ << ")" << nl
<< "\n Please add the 'value' entry to the write function "
"of the user-defined boundary-condition\n"
" or link the boundary-condition into libfoamUtil.so"
<< exit(FatalIOError);
}
for
(
dictionary::const_iterator iter = dict_.begin();
iter != dict_.end();
++iter
)
{
if (iter().keyword() != "type" && iter().keyword() != "value")
{
if
(
iter().isStream()
&& iter().stream().size()
)
{
ITstream& is = iter().stream();
// Read first token
token firstToken(is);
if
(
firstToken.isWord()
&& firstToken.wordToken() == "nonuniform"
)
{
token fieldToken(is);
if (!fieldToken.isCompound())
{
if
(
fieldToken.isLabel()
&& fieldToken.labelToken() == 0
)
{
scalarFields_.insert
(
iter().keyword(),
new scalarField(0)
);
}
else
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n token following 'nonuniform' "
"is not a compound"
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<scalar> >::typeName
)
{
scalarField* fPtr = new scalarField;
fPtr->transfer
(
dynamicCast<token::Compound<List<scalar> > >
(
fieldToken.transferCompoundToken()
)
);
if (fPtr->size() != this->size())
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< this->size() << ')'
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
scalarFields_.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<vector> >::typeName
)
{
vectorField* fPtr = new vectorField;
fPtr->transfer
(
dynamicCast<token::Compound<List<vector> > >
(
fieldToken.transferCompoundToken()
)
);
if (fPtr->size() != this->size())
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< this->size() << ')'
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
vectorFields_.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<sphericalTensor> >::typeName
)
{
sphericalTensorField* fPtr = new sphericalTensorField;
fPtr->transfer
(
dynamicCast
<
token::Compound<List<sphericalTensor> >
>
(
fieldToken.transferCompoundToken()
)
);
if (fPtr->size() != this->size())
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< this->size() << ')'
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
sphericalTensorFields_.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<symmTensor> >::typeName
)
{
symmTensorField* fPtr = new symmTensorField;
fPtr->transfer
(
dynamicCast
<
token::Compound<List<symmTensor> >
>
(
fieldToken.transferCompoundToken()
)
);
if (fPtr->size() != this->size())
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< this->size() << ')'
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
symmTensorFields_.insert(iter().keyword(), fPtr);
}
else if
(
fieldToken.compoundToken().type()
== token::Compound<List<tensor> >::typeName
)
{
tensorField* fPtr = new tensorField;
fPtr->transfer
(
dynamicCast<token::Compound<List<tensor> > >
(
fieldToken.transferCompoundToken()
)
);
if (fPtr->size() != this->size())
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n size of field " << iter().keyword()
<< " (" << fPtr->size() << ')'
<< " is not the same size as the patch ("
<< this->size() << ')'
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
tensorFields_.insert(iter().keyword(), fPtr);
}
else
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n compound " << fieldToken.compoundToken()
<< " not supported"
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
else if
(
firstToken.isWord()
&& firstToken.wordToken() == "uniform"
)
{
token fieldToken(is);
if (!fieldToken.isPunctuation())
{
scalarFields_.insert
(
iter().keyword(),
new scalarField
(
this->size(),
fieldToken.number()
)
);
}
else
{
// Read as scalarList.
is.putBack(fieldToken);
scalarList l(is);
if (l.size() == vector::nComponents)
{
vector vs(l[0], l[1], l[2]);
vectorFields_.insert
(
iter().keyword(),
new vectorField(this->size(), vs)
);
}
else if (l.size() == sphericalTensor::nComponents)
{
sphericalTensor vs(l[0]);
sphericalTensorFields_.insert
(
iter().keyword(),
new sphericalTensorField(this->size(), vs)
);
}
else if (l.size() == symmTensor::nComponents)
{
symmTensor vs(l[0], l[1], l[2], l[3], l[4], l[5]);
symmTensorFields_.insert
(
iter().keyword(),
new symmTensorField(this->size(), vs)
);
}
else if (l.size() == tensor::nComponents)
{
tensor vs
(
l[0], l[1], l[2],
l[3], l[4], l[5],
l[6], l[7], l[8]
);
tensorFields_.insert
(
iter().keyword(),
new tensorField(this->size(), vs)
);
}
else
{
FatalIOErrorIn
(
"genericFvPatchField<Type>::genericFvPatchField"
"(const fvPatch&, const Field<Type>&, "
"const dictionary&)",
dict
) << "\n unrecognised native type " << l
<< "\n on patch " << this->patch().name()
<< " of field "
<< this->dimensionedInternalField().name()
<< " in file "
<< this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
}
}
}
}
}
void Stereo3D::render(FGLRenderer& renderer, GL_IRECT * bounds, float fov0, float ratio0, float fovratio0, bool toscreen, sector_t * viewsector, player_t * player)
{
if (doBufferHud)
LocalHudRenderer::unbind();
// Reset pitch and roll when leaving Rift mode
if ( (mode == OCULUS_RIFT) && ((int)mode != vr_mode) ) {
renderer.mAngles.Roll = 0;
renderer.mAngles.Pitch = 0;
}
setMode(vr_mode);
// Restore actual screen, instead of offscreen single-eye buffer,
// in case we just exited Rift mode.
adaptScreenSize = false;
GLboolean supportsStereo = false;
GLboolean supportsBuffered = false;
// Task: manually calibrate oculusFov by slowly yawing view.
// If subjects approach center of view too fast, oculusFov is too small.
// If subjects approach center of view too slowly, oculusFov is too large.
// If subjects approach correctly , oculusFov is just right.
// 90 is too large, 80 is too small.
// float oculusFov = 85 * fovratio; // Hard code probably wider fov for oculus // use vr_rift_fov
if (mode == OCULUS_RIFT) {
// if (false) {
renderer.mCurrentFoV = vr_rift_fov; // needed for Frustum angle calculation
// Adjust player eye height, but only in oculus rift mode...
if (player != NULL) { // null check to avoid aliens crash
if (savedPlayerViewHeight == 0) {
savedPlayerViewHeight = player->mo->ViewHeight;
}
fixed_t testHeight = savedPlayerViewHeight + FLOAT2FIXED(vr_view_yoffset);
if (player->mo->ViewHeight != testHeight) {
player->mo->ViewHeight = testHeight;
P_CalcHeight(player);
}
}
} else {
// Revert player eye height when leaving Rift mode
if ( (savedPlayerViewHeight != 0) && (player->mo->ViewHeight != savedPlayerViewHeight) ) {
player->mo->ViewHeight = savedPlayerViewHeight;
savedPlayerViewHeight = 0;
P_CalcHeight(player);
}
}
angle_t a1 = renderer.FrustumAngle();
switch(mode)
{
case MONO:
setViewportFull(renderer, bounds);
setMonoView(renderer, fov0, ratio0, fovratio0, player);
renderer.RenderOneEye(a1, toscreen, true);
renderer.EndDrawScene(viewsector);
break;
case GREEN_MAGENTA:
setViewportFull(renderer, bounds);
{ // Local scope for color mask
// Left eye green
LocalScopeGLColorMask colorMask(0,1,0,1); // green
setLeftEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, toscreen, false);
}
// Right eye magenta
colorMask.setColorMask(1,0,1,1); // magenta
setRightEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
} // close scope to auto-revert glColorMask
renderer.EndDrawScene(viewsector);
break;
case RED_CYAN:
setViewportFull(renderer, bounds);
{ // Local scope for color mask
// Left eye red
LocalScopeGLColorMask colorMask(1,0,0,1); // red
setLeftEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, toscreen, false);
}
// Right eye cyan
colorMask.setColorMask(0,1,1,1); // cyan
setRightEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
} // close scope to auto-revert glColorMask
renderer.EndDrawScene(viewsector);
break;
case SIDE_BY_SIDE:
{
// FIRST PASS - 3D
// Temporarily modify global variables, so HUD could draw correctly
// each view is half width
int oldViewwidth = viewwidth;
viewwidth = viewwidth/2;
// left
setViewportLeft(renderer, bounds);
setLeftEyeView(renderer, fov0, ratio0/2, fovratio0, player); // TODO is that fovratio?
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, false, false); // False, to not swap yet
}
// right
// right view is offset to right
int oldViewwindowx = viewwindowx;
viewwindowx += viewwidth;
setViewportRight(renderer, bounds);
setRightEyeView(renderer, fov0, ratio0/2, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
//
// SECOND PASS weapon sprite
renderer.EndDrawScene(viewsector); // right view
viewwindowx -= viewwidth;
renderer.EndDrawScene(viewsector); // left view
//
// restore global state
viewwidth = oldViewwidth;
viewwindowx = oldViewwindowx;
break;
}
case SIDE_BY_SIDE_SQUISHED:
{
// FIRST PASS - 3D
// Temporarily modify global variables, so HUD could draw correctly
// each view is half width
int oldViewwidth = viewwidth;
viewwidth = viewwidth/2;
// left
setViewportLeft(renderer, bounds);
setLeftEyeView(renderer, fov0, ratio0, fovratio0*2, player);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, toscreen, false);
}
// right
// right view is offset to right
int oldViewwindowx = viewwindowx;
viewwindowx += viewwidth;
setViewportRight(renderer, bounds);
setRightEyeView(renderer, fov0, ratio0, fovratio0*2, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, false, true);
}
//
// SECOND PASS weapon sprite
renderer.EndDrawScene(viewsector); // right view
viewwindowx -= viewwidth;
renderer.EndDrawScene(viewsector); // left view
//
// restore global state
viewwidth = oldViewwidth;
viewwindowx = oldViewwindowx;
break;
}
case OCULUS_RIFT:
{
if ( (oculusTexture == NULL) || (! oculusTexture->checkSize(SCREENWIDTH, SCREENHEIGHT)) ) {
if (oculusTexture)
delete(oculusTexture);
oculusTexture = new OculusTexture(SCREENWIDTH, SCREENHEIGHT);
}
if ( (hudTexture == NULL) || (! hudTexture->checkSize(SCREENWIDTH/2, SCREENHEIGHT)) ) {
if (hudTexture)
delete(hudTexture);
hudTexture = new HudTexture(SCREENWIDTH/2, SCREENHEIGHT);
hudTexture->bindToFrameBuffer();
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
hudTexture->unbind();
}
// Render unwarped image to offscreen frame buffer
if (doBufferOculus) {
oculusTexture->bindToFrameBuffer();
}
// FIRST PASS - 3D
// Temporarily modify global variables, so HUD could draw correctly
// each view is half width
int oldViewwidth = viewwidth;
viewwidth = viewwidth/2;
int oldScreenBlocks = screenblocks;
screenblocks = 12; // full screen
//
// TODO correct geometry for oculus
//
float ratio = vr_rift_aspect;
float fovy = 2.0*atan(tan(0.5*vr_rift_fov*3.14159/180.0)/ratio) * 180.0/3.14159;
float fovratio = vr_rift_fov/fovy;
//
// left
GL_IRECT riftBounds; // Always use full screen with Oculus Rift
riftBounds.width = SCREENWIDTH;
riftBounds.height = SCREENHEIGHT;
riftBounds.left = 0;
riftBounds.top = 0;
setViewportLeft(renderer, &riftBounds);
setLeftEyeView(renderer, vr_rift_fov, ratio, fovratio, player, false);
glEnable(GL_DEPTH_TEST);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, false, false);
}
// right
// right view is offset to right
int oldViewwindowx = viewwindowx;
viewwindowx += viewwidth;
setViewportRight(renderer, &riftBounds);
setRightEyeView(renderer, vr_rift_fov, ratio, fovratio, player, false);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, false, true);
}
// Second pass sprites (especially weapon)
int oldViewwindowy = viewwindowy;
const bool showSprites = true;
if (showSprites) {
// SECOND PASS weapon sprite
glEnable(GL_TEXTURE_2D);
screenblocks = 12;
float fullWidth = SCREENWIDTH / 2.0;
viewwidth = RIFT_HUDSCALE * fullWidth;
float left = (1.0 - RIFT_HUDSCALE) * fullWidth * 0.5; // left edge of scaled viewport
// TODO Sprite needs some offset to appear at correct distance, rather than at infinity.
int spriteOffsetX = (int)(0.021*fullWidth); // kludge to set weapon distance
viewwindowx = left + fullWidth - spriteOffsetX;
int spriteOffsetY = (int)(-0.01 * vr_weapon_height * viewheight); // nudge gun up/down
// Counteract effect of status bar on weapon position
if (oldScreenBlocks <= 10) { // lower weapon in status mode
spriteOffsetY += 0.227 * viewwidth; // empirical - lines up brutal doom down sight in 1920x1080 Rift mode
}
viewwindowy += spriteOffsetY;
renderer.EndDrawScene(viewsector); // right view
setViewportLeft(renderer, &riftBounds);
viewwindowx = left + spriteOffsetX;
renderer.EndDrawScene(viewsector); // left view
}
// Third pass HUD
if (doBufferHud) {
screenblocks = max(oldScreenBlocks, 10); // Don't vignette main 3D view
// Draw HUD again, to avoid flashing? - and render to screen
blitHudTextureToScreen(true); // HUD pass now occurs in main doom loop! Since I delegated screen->Update to stereo3d.updateScreen().
}
//
// restore global state
viewwidth = oldViewwidth;
viewwindowx = oldViewwindowx;
viewwindowy = oldViewwindowy;
// Update orientation for NEXT frame, after expensive render has occurred this frame
setViewDirection(renderer);
// Set up 2D rendering to write to our hud renderbuffer
if (doBufferHud) {
bindHudTexture(true);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
bindHudTexture(false);
LocalHudRenderer::bind();
}
break;
}
case LEFT_EYE_VIEW:
setViewportFull(renderer, bounds);
setLeftEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
renderer.EndDrawScene(viewsector);
break;
case RIGHT_EYE_VIEW:
setViewportFull(renderer, bounds);
setRightEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
renderer.EndDrawScene(viewsector);
break;
case QUAD_BUFFERED:
setViewportFull(renderer, bounds);
glGetBooleanv(GL_STEREO, &supportsStereo);
glGetBooleanv(GL_DOUBLEBUFFER, &supportsBuffered);
if (supportsStereo && supportsBuffered && toscreen)
{
// Right first this time, so more generic GL_BACK_LEFT will remain for other modes
glDrawBuffer(GL_BACK_RIGHT);
setRightEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_RIGHT, player, renderer);
renderer.RenderOneEye(a1, toscreen, false);
}
// Left
glDrawBuffer(GL_BACK_LEFT);
setLeftEyeView(renderer, fov0, ratio0, fovratio0, player);
{
ViewShifter vs(EYE_VIEW_LEFT, player, renderer);
renderer.RenderOneEye(a1, toscreen, true);
}
// Want HUD in both views
glDrawBuffer(GL_BACK);
} else { // mono view, in case hardware stereo is not supported
setMonoView(renderer, fov0, ratio0, fovratio0, player);
renderer.RenderOneEye(a1, toscreen, true);
}
renderer.EndDrawScene(viewsector);
break;
default:
setViewportFull(renderer, bounds);
setMonoView(renderer, fov0, ratio0, fovratio0, player);
renderer.RenderOneEye(a1, toscreen, true);
renderer.EndDrawScene(viewsector);
break;
}
}
Main()
{
mScale = 0.1f;
mOffset = 1.0f;
mDataOffset = 0;
isClicked = false;
screen = Vec2<unsigned int>(800, 600);
std::setlocale(LC_ALL, "en_US.UTF-8");
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
//glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
GLFWwindow* window = glfwCreateWindow(screen.x, screen.y, "test", nullptr, nullptr);
if (window == nullptr)
{
printf("cant create window");
return;
}
glfwSetWindowSizeCallback(window, windowSizeCallback);
glfwSetKeyCallback(window, keyCallback);
glfwSetMouseButtonCallback(window, clickCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwMakeContextCurrent(window);
glewExperimental = true;
glewInit();
int tmp;
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES , &tmp);
std::cout << "GL_MAX_ELEMENTS_VERTICES: " << tmp << std::endl;
int err = Pa_Initialize();
if (err != paNoError)
printf("error");
int num = Pa_GetDeviceCount();
const PaDeviceInfo* devInfo;
const PaHostApiInfo* apiInfo;
for (int i = 0; i < num; ++i) {
devInfo = Pa_GetDeviceInfo(i);
apiInfo = Pa_GetHostApiInfo(devInfo->hostApi);
printf("%i, %s on %s\n", i, devInfo->name, apiInfo->name);
}
float sampleRate = 44100.0f;
double t = glfwGetTime();
Kern k(sampleRate, 12, 4 * 16.352f, sampleRate / 2);
BlockMatrix<std::complex<double>> b(k.K, k.mN0, k.mB, 0.01);
mAudioData = new double[b.getWidth()];
mAudioLength = b.getWidth();
for (unsigned int i = 0; i < mAudioLength; ++i) {
mAudioData[i] = wave(55, sampleRate, i) + wave(110, sampleRate, i) + wave(220, sampleRate, i)
+ wave(440, sampleRate, i) + wave(880, sampleRate, i) + wave(1760, sampleRate, i)
+ wave(3520, sampleRate, i) + wave(7040, sampleRate, i);
}
printf("kernel time:%f\n", glfwGetTime() - t);
float drawArray[k.mB * 2];
std::complex<double> out[k.mB];
CQT::transform(mAudioData, out, b, mAudioLength);
t = glfwGetTime();
printf("transform time:%f\n", glfwGetTime() - t);
//glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(debugCallback, nullptr);
//glEnable(GL_DEBUG_OUTPUT);
printf("%s\n", glGetString(GL_VERSION));
Shader fs("res/shader/fragment.c", true, GL_FRAGMENT_SHADER);
Shader vs("res/shader/vertex.c", true, GL_VERTEX_SHADER);
Program* p = new Program();
p->attach(fs);
p->attach(vs);
p->build();
p->use();
Program p2;
Shader fs2("res/shader/fragment2.c", true, GL_FRAGMENT_SHADER);
Shader vs2("res/shader/vertex2.c", true, GL_VERTEX_SHADER);
p2.attach(fs2);
p2.attach(vs2);
p2.build();
p2.use();
int uniformData = p2.getUniformLocation("data");
unsigned int waterfallSize = 512;
tm = new TextureManager();
unsigned int waterfallTexture;
unsigned int waterfallId = tm->getFreeTexture();
glGenTextures(1, &waterfallTexture);
glActiveTexture(GL_TEXTURE0 + waterfallId);
glBindTexture( GL_TEXTURE0, waterfallTexture );
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
unsigned char* textureTmp = new unsigned char[waterfallSize * b.getWidth()];
glTexImage2D( GL_TEXTURE_2D_ARRAY, 0, GL_R8, b.getWidth(), waterfallSize, 0, GL_RED, GL_UNSIGNED_BYTE, textureTmp);
delete textureTmp;
float max = 0;
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 0] = (float)i / k.mB * 2.0f - 1.0f;
float tmp = std::abs(out[i]);
drawArray[2 * i + 1] = tmp;
max = std::max(tmp, max);
}
font = new Font(512, "res/font/DroidSans.woff", 32, tm);
print = new Print(font);
//print.set(&font, "res/shader/fontVertex.c", "res/shader/fontFragment.c");
print->setScreenSize(screen);
glm::vec2* vert = new glm::vec2[1024];
glm::vec2* debug = new glm::vec2[b.getWidth()];
for (unsigned int i = 0; i < b.getWidth(); ++i) {
debug[i].x = (float)i / b.getWidth() * 2.0f - 1.0f;
}
uint32_t vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
uint32_t vbo[2];
glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glEnableVertexAttribArray(0);
glBufferData(GL_ARRAY_BUFFER, k.mB * sizeof(glm::vec2), drawArray, GL_DYNAMIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_BLEND);
glfwSetWindowUserPointer(window, this);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
double time, timeo;
glfwSwapInterval(1);
PaStream* stream;
PaStreamParameters params;
params.device = 21;
params.channelCount = 1;
params.sampleFormat = paFloat32;
params.hostApiSpecificStreamInfo = nullptr;
params.suggestedLatency = 0.5;
err = Pa_OpenStream(&stream, ¶ms, nullptr, sampleRate, paFramesPerBufferUnspecified, 0, paCallback, this);
if (err != paNoError)
printf("error %i", err);
Pa_StartStream(stream);
while(!glfwWindowShouldClose(window))
{
timeo = time;
time = glfwGetTime();
CQT::transform(mAudioData, out, b, mAudioLength);
max = 0.0f;
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 0] = (float)i / k.mB * 2.0f - 1.0f;
float tmp = std::abs(out[i]);
drawArray[2 * i + 1] = tmp;
max = std::max(tmp, max);
}
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 1] = std::log(drawArray[2 * i +1]) * mScale + mOffset;
}
//printf("%f\n", drawArray[1]);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, k.mB * sizeof(glm::vec2), drawArray, GL_DYNAMIC_DRAW);
p->use();
glDrawArrays(GL_LINE_STRIP, 0, k.mB);
for (unsigned int i = 0; i < b.getWidth(); ++i) {
debug[i].y = mAudioData[i] / 15.0;
}
glBufferData(GL_ARRAY_BUFFER, b.getWidth() * sizeof(glm::vec2), debug, GL_DYNAMIC_DRAW);
glDrawArrays(GL_LINE_STRIP, 0, b.getWidth());
print->printfAt(-300.0f, 100.0f, 16.0f, 16.0f, u8"Fps:%03.3f", 1/(time-timeo));
glfwSwapBuffers(window);
glClear(GL_COLOR_BUFFER_BIT);
glfwPollEvents();
}
Pa_StopStream(stream);
Pa_CloseStream(stream);
Pa_Terminate();
std::cout << "Hello World. I'm Peach." << std::endl;
}
void HHVM_FUNCTION(debug_zval_dump, const Variant& variable) {
VariableSerializer vs(VariableSerializer::Type::DebugDump);
vs.serialize(variable, false);
}
int main()
{
glfwInit();
////our window
//GLFWwindow* window;
//window = glfwCreateWindow(800, 600, "ParticleSystemXML", NULL, NULL);
//glfwMakeContextCurrent(window);
//
////CAM
//cam.setKeySpeed(4.0);
//iH.setAllInputMaps(cam);
//glfwSetKeyCallback(window, key_callback);
//cam.setFOV(50);
//cam.setNearFar(1, 100);
Window testWindow(500, 50, 800, 600, "ParticleSystem");
glfwMakeContextCurrent(testWindow.getWindow());
// Callback
glfwSetKeyCallback(testWindow.getWindow(), key_callback);
cam.setKeySpeed(4.0);
cam.setNearFar(0.1, 100);
cam.setPosition(glm::vec4(0, 0, 8, 0));
glewInit();
//our renderer
OpenGL3Context context;
Renderer *renderer;
renderer = new Renderer(context);
//////////////////////Textures//////////////////////
Texture* fireTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/Fire2_M.png");
Texture* fireTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire1_M.png");
Texture* fireTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire3_M.png");
Texture* fireTex3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/flame02_L.png");
//Texture* fireFlickering1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_1.png");
//Texture* fireFlickering2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_2.png");
//Texture* fireFlickering3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_3.png");
//Texture* fireFlickering4 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_4.png");
Texture* fireSparkleTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle1_S.png");
Texture* fireSparkleTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle2.png");
Texture* texFireworkBlue = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_blue.png");
Texture* texFireworkRed = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_red.png");
Texture* texFireworkGreen = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_green.png");
Texture* texFireworkGold = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_gold.png");
Texture* texFireworkTail = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_tail.png");
Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png");
Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png");
Texture* smokeBlack1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png");
Texture* smokeBlack2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png");
//////////////////////Emitter//////////////////////
//Emitter explosion sparkle
Emitter* explosionSparkle = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.25, 0.01, 80, 1.25, true);
explosionSparkle->setVelocity(5);
//explosionSparkle->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.3), 3.0f);
explosionSparkle->usePhysicPointGravity(glm::vec3(0.0, 0.0, 0.0), 0.6, 10.0, 2, 4.0f, true);
explosionSparkle->addTexture(fireSparkleTex1, 1.0);
explosionSparkle->defineLook(true, 0.01, 0.0, 0.1);
//Emitter explosion fire
//TODO
//Emitter fire smoke
Emitter* fire = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.2, 2, 5.0, true);
fire->setVelocity(5);
fire->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 5.0), 0.5f);
fire->addTexture(fireTex1, 1.0);
fire->addTexture(fireTex2, 0.7);
fire->addTexture(smokeBlack2, 0.1);
//fire->addTexture(smokeBlack2, 0.1);
//fire->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> sizeF{ 0.05f, 0.5f, 0.75f, 1.0f };
std::vector<float> timeF{ 0.0f, 0.4f, 0.75f, 1.0f };
fire->defineLook(true, sizeF, timeF, 0.5, 4.0, 3.0, true, 0.3);
fire->switchToGeometryShader();
//Emitter fire flickering
Emitter* fireFlickering = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.2, 1, 2.0, true);
fireFlickering->setVelocity(5);
fireFlickering->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.5), 0.3f);
/*fireFlickering->addTexture(fireFlickering1, 1.0);
fireFlickering->addTexture(fireFlickering2, 0.7);
fireFlickering->addTexture(fireFlickering3, 0.5);
fireFlickering->addTexture(fireFlickering4, 0.3);*/
fireFlickering->defineLook(true, 0.1, 0.5, 1.0, 0.5, true, 0.3);
fireFlickering->switchToGeometryShader();
Emitter* fireSparkle = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.05, 3, 2.5, true);
fireSparkle->setVelocity(5);
fireSparkle->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.8), 0.5f);
fireSparkle->addTexture(fireSparkleTex1, 1.0);
fireSparkle->defineLook(true, 0.05, 0.5, 0.5);
//Emitter firework explosion
Emitter* fireworkExplosion = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.1, 0.01, 80, 2.0, true);
fireworkExplosion->setVelocity(6);
//fireworkExplosion->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.6), 3.0f);
fireworkExplosion->usePhysicPointGravity(glm::vec3(0.0, -2.0, 0.0), 0.9, 5.0, 2, 2.0f, true);
fireworkExplosion->addTexture(texFireworkRed, 1.0);
fireworkExplosion->defineLook(true, 0.04, 0.0, 0.5);
fireworkExplosion->setStartTime(2.0);
//Emitter firework tail
Emitter* fireworkTail = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 2.0, 0.01, 20, 0.5, true);
fireworkTail->setVelocity(5);
//fireworkTail->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 2.9), 0.2f);
fireworkTail->usePhysicPointGravity(glm::vec3(0.0, -4.0, 0.0), 30.6, 10.0, 2, 0.2f, true);
fireworkTail->addTexture(texFireworkTail, 1.0);
fireworkTail->defineLook(true, 0.001, 0.0, 0.1);
//FINAL EMITTER WHITE SMOKE
Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.4, 1, 8.0, true);
smokeWhite->setVelocity(2);
smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f);
smokeWhite->addTexture(smokeWhiteTex1, 1.0);
smokeWhite->addTexture(smokeWhiteTex2, 0.25);
std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.0f };
std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f };
smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 2.0, 1.0, false, 0.3);
smokeWhite->switchToGeometryShader();
//////////////////////Effect//////////////////////
Effect* efExplosion = new Effect();
efExplosion->addEmitter(explosionSparkle);
Effect* efFire = new Effect();
efFire->addEmitter(fire);
//efFire->addEmitter(fireFlickering);
efFire->addEmitter(fireSparkle);
efFire->saveEffect(RESOURCES_PATH "/XML/Effect_Fire.xml");
Effect* efFirework = new Effect();
efFirework->addEmitter(fireworkTail);
efFirework->addEmitter(fireworkExplosion);
//efFirework->saveEffect(RESOURCES_PATH "/XML/Effect_Firework.xml");
Effect* efFireworkTail = new Effect();
efFireworkTail->addEmitter(fireworkTail);
Effect* efFireworkExplosion = new Effect();
efFireworkExplosion->addEmitter(fireworkExplosion);
Effect* efSmWhi = new Effect();
efSmWhi->addEmitter(smokeWhite);
efSmWhi->saveEffect(RESOURCES_PATH "/XML/Effect_SmokeWhite.xml");
//////////////////////ParticleSystem//////////////////////
//ParticleSystem* psExplosion = new ParticleSystem(glm::vec3(0, -1, 0), efExplosion);
//ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), efFire);
ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), RESOURCES_PATH "/XML/Effect_Fire.xml");
ParticleSystem* psFirework = new ParticleSystem(glm::vec3(0, 0, 5), efFirework);
ParticleSystem* psFireworkTail = new ParticleSystem(glm::vec3(0, 0, 5), efFireworkTail);
ParticleSystem* psFireworkExplosion = new ParticleSystem(glm::vec3(0, 2, 5), efFireworkExplosion);
ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), efSmWhi);
//ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), RESOURCES_PATH "/XML/Effect_SmokeWhite.xml");
ParticleSystem* psFireworkRed = new ParticleSystem(glm::vec3(-6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkRed.xml");
ParticleSystem* psFireworkBlue = new ParticleSystem(glm::vec3(-2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkBlue.xml");
ParticleSystem* psFireworkGreen = new ParticleSystem(glm::vec3(2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGreen.xml");
ParticleSystem* psFireworkGold = new ParticleSystem(glm::vec3(6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGold.xml");
ParticleSystem* psComicCloud = new ParticleSystem(glm::vec3(0, -1, 3), RESOURCES_PATH "/XML/Effect_ComicCloud.xml");
//////////////////////Node//////////////////////
//Node nodeExplosion("nodeExplosion");
//nodeExplosion.setCamera(&cam);
//nodeExplosion.addParticleSystem(psExplosion);
//nodeExplosion.setParticleActive(true);
//
//Node fireNode("fireNode");
//fireNode.setCamera(&cam);
//fireNode.addParticleSystem(psFire);
//fireNode.setParticleActive(true);
//
//Node nodeFirework("fireworkNode");
//nodeFirework.setCamera(&cam);
//nodeFirework.addParticleSystem(psFirework);
//nodeFirework.setParticleActive(true);
//
//Node whiteSmokeNode("whiteSmokeNode");
//whiteSmokeNode.setCamera(&cam);
//whiteSmokeNode.addParticleSystem(psSmokeWhite);
//whiteSmokeNode.setParticleActive(true);
////Firework
//Node nodeFireworkRed("fireworkRedNode");
//nodeFireworkRed.setCamera(&cam);
//nodeFireworkRed.addParticleSystem(psFireworkRed);
//nodeFireworkRed.setParticleActive(true);
//Node nodeFireworkBlue("fireworBlueNode");
//nodeFireworkBlue.setCamera(&cam);
//nodeFireworkBlue.addParticleSystem(psFireworkBlue);
//nodeFireworkBlue.setParticleActive(true);
//Node nodeFireworkGreen("fireworkGreenNode");
//nodeFireworkGreen.setCamera(&cam);
//nodeFireworkGreen.addParticleSystem(psFireworkGreen);
//nodeFireworkGreen.setParticleActive(true);
//Node nodeFireworkGold("fireworkGoldNode");
//nodeFireworkGold.setCamera(&cam);
//nodeFireworkGold.addParticleSystem(psFireworkGold);
//nodeFireworkGold.setParticleActive(true);
// Shader
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag")));
ShaderProgram shader(vs, fs);
//need scene here mainly because of input
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
//Add Camera to Scene
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("Pilotview");
//Set Input-Maps and activate one
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap(MapType::CAMPILOTVIEW);
iH.getActiveInputMap()->update(cam);
//Object
Cube cube;
Texture bricks((char*)RESOURCES_PATH "/Wall/bricks_diffuse.png");
Node cube1("cube");
cube1.addGeometry(&cube);
cube1.addTexture(&bricks);
cube1.setModelMatrix(glm::translate(cube1.getModelMatrix(), glm::vec3(0.0, 0.0, 0.0)));
//cube1.setModelMatrix(glm::scale(cube1.getModelMatrix(), glm::vec3(0.5, 0.5, 0.5)));
testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube1);
//add nodes to the scenegraph
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeExplosion);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&fireNode);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFirework);
/*testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkRed);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkBlue);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGreen);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGold);*/
//using this, the ParticleSystems get rendered in order of their distance to the camera
testScene.getScenegraph()->addParticleSystem(psFire);
testScene.getScenegraph()->addParticleSystem(psSmokeWhite);
testScene.getScenegraph()->addParticleSystem(psFireworkBlue);
testScene.getScenegraph()->addParticleSystem(psFireworkRed);
testScene.getScenegraph()->addParticleSystem(psFireworkGreen);
testScene.getScenegraph()->addParticleSystem(psFireworkGold);
//testScene.getScenegraph()->addParticleSystem(psComicCloud);
////TEST
//Emitter* etest = new Emitter(0, glm::vec3(0, 0, 0), 0, 1, 1000000, 1, true);
//etest->setVelocity(6);
//etest->usePhysicPointGravity(glm::vec3(0, 0, 0), 0.5, 20, 1, -2.5, true);
//etest->defineLook(false, 0.005);
//Effect* eftest = new Effect();
//eftest->addEmitter(etest);
//ParticleSystem* pstest = new ParticleSystem(glm::vec3(0, 2, 0), eftest);
//testScene.getScenegraph()->addParticleSystem(pstest);
//pstest->start();
//start the ParticleSystems
psFire->start();
psSmokeWhite->start();
//psExplosion->start();
//psFirework->start();
psFireworkRed->start();
psFireworkBlue->start();
psFireworkGreen->start();
psFireworkGold->start();
//psComicCloud->start();
double startTime = glfwGetTime();
double lastTime = glfwGetTime();
int nbFrames = 0;
while (!glfwWindowShouldClose(testWindow.getWindow()))
{
// Measure speed
double currentTime = glfwGetTime();
nbFrames++;
if (currentTime - lastTime >= 1.0) { // If last prinf() was more than 1 sec ago
// printf and reset timer
//printf("%f ms/frame\n", 1000.0 / double(nbFrames));
nbFrames = 0;
lastTime += 1.0;
}
double dt = glfwGetTime() - startTime;
cam.setSensitivity(dt);
startTime = glfwGetTime();
/*glEnable(GL_DEPTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.bind();
shader.sendMat4("viewMatrix", cam.getViewMatrix());
shader.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shader);
testScene.renderParticleSystems();
shader.unbind();*/
//renderer->useBloom(true);
renderer->renderScene(testScene, testWindow);
//update Positions of firework ParticleSystems
glm::vec3 pos = psFireworkRed->getPosition();
psFireworkRed->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkBlue->getPosition();
psFireworkBlue->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkGreen->getPosition();
psFireworkGreen->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
pos = psFireworkGold->getPosition();
psFireworkGold->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z));
/*glfwSwapBuffers(testWindow.getWindow());
glfwPollEvents();*/
}
glfwDestroyWindow(testWindow.getWindow());
glfwTerminate();
return 0;
}
bool UnitEmitter::insert(UnitOrigin unitOrigin, RepoTxn& txn) {
Repo& repo = Repo::get();
UnitRepoProxy& urp = repo.urp();
int repoId = Repo::get().repoIdForNewUnit(unitOrigin);
if (repoId == RepoIdInvalid) {
return true;
}
m_repoId = repoId;
try {
{
m_lineTable = createLineTable(m_sourceLocTab, m_bclen);
urp.insertUnit[repoId].insert(*this, txn, m_sn, m_md5, m_bc,
m_bclen);
}
int64_t usn = m_sn;
urp.insertUnitLineTable(repoId, txn, usn, m_lineTable);
for (unsigned i = 0; i < m_litstrs.size(); ++i) {
urp.insertUnitLitstr[repoId].insert(txn, usn, i, m_litstrs[i]);
}
for (unsigned i = 0; i < m_arrays.size(); ++i) {
VariableSerializer vs(VariableSerializer::Type::Serialize);
urp.insertUnitArray[repoId].insert(
txn, usn, i,
vs.serializeValue(VarNR(m_arrays[i]), false /* limit */).toCppString()
);
}
for (auto& fe : m_fes) {
fe->commit(txn);
}
for (auto& pce : m_pceVec) {
pce->commit(txn);
}
for (int i = 0, n = m_mergeableStmts.size(); i < n; i++) {
switch (m_mergeableStmts[i].first) {
case MergeKind::Done:
case MergeKind::UniqueDefinedClass:
not_reached();
case MergeKind::Class: break;
case MergeKind::TypeAlias:
case MergeKind::ReqDoc: {
urp.insertUnitMergeable[repoId].insert(
txn, usn, i,
m_mergeableStmts[i].first, m_mergeableStmts[i].second, nullptr);
break;
}
case MergeKind::Define:
case MergeKind::PersistentDefine:
case MergeKind::Global: {
int ix = m_mergeableStmts[i].second;
urp.insertUnitMergeable[repoId].insert(
txn, usn, i,
m_mergeableStmts[i].first,
m_mergeableValues[ix].first, &m_mergeableValues[ix].second);
break;
}
}
}
if (RuntimeOption::RepoDebugInfo) {
for (size_t i = 0; i < m_sourceLocTab.size(); ++i) {
SourceLoc& e = m_sourceLocTab[i].second;
Offset endOff = i < m_sourceLocTab.size() - 1
? m_sourceLocTab[i + 1].first
: m_bclen;
urp.insertUnitSourceLoc[repoId]
.insert(txn, usn, endOff, e.line0, e.char0, e.line1, e.char1);
}
}
return false;
} catch (RepoExc& re) {
TRACE(3, "Failed to commit '%s' (0x%016" PRIx64 "%016" PRIx64 ") to '%s': %s\n",
m_filepath->data(), m_md5.q[0], m_md5.q[1],
repo.repoName(repoId).c_str(), re.msg().c_str());
return true;
}
}
void ThriftBuffer::write(CVarRef data) {
VariableSerializer vs(m_serializerType);
String sdata = vs.serialize(data, true);
write(sdata);
}
void rasterizer::draw_line(int x0, int y0, int x1, int y1, const zerging::color_rgba8 &c0, const zerging::color_rgba8 &c1)
{
int w = surface_->get_width();
int h = surface_->get_height();
if ((x0 < 0 || x0 > w) && (y0 < 0 || y0 > h) && (x1 < 0 || x1 > w) && (y1 < 0 || y1 > h)) {
// out of screen space...
return;
}
x0 = math::clamp<int>(x0, 0, w);
y0 = math::clamp<int>(y0, 0, h);
x1 = math::clamp<int>(x1, 0, w);
y1 = math::clamp<int>(y1, 0, h);
if (x0 == x1 && y0 == y1) {
surface_->set_texel(x0, y0, 1, c1);
return;
}
vec2 vs((float)x0, (float)y0);
vec2 ve((float)x1, (float)y1);
vec2 delta = ve - vs;
auto func = [&](bool xmajor, int vmi, int vma, int vmt) {
float delta_flag = 0.f;
const vec2* start;
const vec2* end;
const color_rgba8* cs;
const color_rgba8* ce;
if (xmajor) {
delta_flag = delta.x;
} else {
delta_flag = delta.y;
}
float diff_dir = math::abs(delta.x) > math::abs(delta.y) ? delta.x : delta.y;
if (delta_flag < 0) {
start = &ve;
end = &vs;
cs = &c1;
ce = &c0;
diff_dir = -diff_dir;
} else {
start = &vs;
end = &ve;
cs = &c0;
ce = &c1;
}
float fs = 0.f, fe = 0.f;
if (xmajor) {
fs = start->x;
fe = end->x;
} else {
fs = start->y;
fe = end->y;
}
int is = (int)math::floor(fs + 0.5f);
int ie = (int)math::floor(fe - 0.5f);
is = math::clamp<int>(is, vmi, int(vma - 1));
ie = math::clamp<int>(ie, vmi, int(vma));
// set the attribute of start point
float step = is + 0.5f - fs;
vec2 output = *start + (*end - *start) * step / diff_dir;
for (int i = is; i < ie; ++i) {
float ot, dt;
if (xmajor) {
ot = output.y;
dt = delta.y;
} else {
ot = output.x;
dt = delta.x;
}
if (ot >= vmt) {
if (dt > 0) break;
continue;
}
if (ot < 0) {
if (dt < 0) break;
continue;
}
++step;
float st_dir = step / diff_dir;
surface_->set_texel((size_t)output.x, (size_t)output.y, 1, lerp(*cs, *ce, st_dir));
output = *start + (*end - *start) * st_dir;
}
};
if (math::abs(delta.x) > math::abs(delta.y)) {
func(true, vp_left_, vp_right_, vp_bottom_);
}
else {
func(false, vp_top_, vp_bottom_, vp_right_);
}
}
static Program make(void)
{
Program prog;
Shader vs(ShaderType::Vertex);
vs.Source(
"#version 330\n"
"uniform vec2 Offset;"
"uniform float Scale;"
"in vec4 Position;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = Scale * (0.5*Position.xy + Offset);"
"}"
).Compile();
Shader fs(ShaderType::Fragment);
fs.Source(
"#version 330\n"
"uniform float Scale;"
"uniform sampler2D Tex;"
"in vec2 vertTexCoord;"
"out vec3 fragColor;"
"const vec2 offs[9] = vec2[9]("
" vec2(-1,-1),"
" vec2(-1, 0),"
" vec2(-1, 1),"
" vec2( 0,-1),"
" vec2( 0, 0),"
" vec2( 0, 1),"
" vec2( 1,-1),"
" vec2( 1, 0),"
" vec2( 1, 1) "
");"
"float dist(vec2 tc, vec2 ofs)"
"{"
" vec2 cc = floor(tc+ofs);"
" vec2 cp = texture(Tex, cc/textureSize(Tex, 0)).xy;"
" return distance(tc, cc+cp);"
"}"
"vec3 point_color(vec2 tc, vec2 ofs)"
"{"
" vec2 cc = floor(tc+ofs);"
" return texture(Tex, cc/textureSize(Tex, 0)).rgb;"
"}"
"vec3 voronoi(vec2 tc)"
"{"
" float md = 2.0;"
" int mc = 9;"
" for(int c=0; c<9; ++c)"
" {"
" float d = dist(tc, offs[c]);"
" if(md > d)"
" {"
" md = d;"
" mc = c;"
" }"
" }"
" return mix("
" point_color(tc, offs[mc])*mix(1.4, 0.5, md),"
" vec3(0, 0, 0),"
" pow(exp(1-md*512/Scale), 2.0)"
" );"
"}"
"void main(void)"
"{"
" fragColor = voronoi(vertTexCoord);"
"}"
).Compile();
prog << vs << fs;
prog.Link().Use();
return std::move(prog);
}
void RefData::dump() const {
VariableSerializer vs(VariableSerializer::Type::VarDump);
String ret(vs.serialize(tvAsCVarRef(&m_tv), true));
printf("RefData: %s", ret.c_str());
}
void f_debug_zval_dump(CVarRef variable) {
VariableSerializer vs(VariableSerializer::DebugDump);
vs.serialize(variable, false);
}
//===================================================================//
//==================Main Method=====================================//
//==================================================================//
int main()
{
//===================================================================//
//==================Things you need to start with====================//
//==================================================================//
glfwInit();
Window testWindow(500, 50, 800, 600, "Demo");
glfwMakeContextCurrent(testWindow.getWindow());
// Callback
glfwSetKeyCallback(testWindow.getWindow(), key_callback);
cam.setKeySpeed(2.0);
cam.setNearFar(0.01, 100);
glewInit();
OpenGL3Context context;
//renderer = new Renderer(context);
Renderer renderer(context);
//===================================================================//
//==================Shaders for your program========================//
//==================================================================//
VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/Vertex-Shaders/TextureShader3D.vert")));
FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/Fragment-Shaders/TextureShader3D.frag")));
ShaderProgram shader(vs, fs);
VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert")));
FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag")));
ShaderProgram shaderGBuffer(vsGBuffer, fsGBuffer);
VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert")));
FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag")));
ShaderProgram shaderSFQ(vsSfq, fsSfq);
VertexShader vsSkybox(loadShaderSource(SHADERS_PATH + std::string("/SkyboxShader/SkyboxShader.vert")));
FragmentShader fsSkybox(loadShaderSource(SHADERS_PATH + std::string("/SkyboxShader/SkyboxShader.frag")));
ShaderProgram shaderSkybox(vsSkybox, fsSkybox);
FBO fboGBuffer(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false);
SoundFileHandler sfh = SoundFileHandler(1000);
Rect screenFillingQuad;
screenFillingQuad.loadBufferData();
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: Terrain===========================//
StaticObject terrainObject;
terrainObject.setClassType(ClassType::TERRAIN);
Texture terrainTex((char*)RESOURCES_PATH "/Grass2.jpg");
Terrain terrain2((char*)RESOURCES_PATH "/heightmap.jpg", 0.0f, 0.0f);
Node terrainNode2("Terrain");
terrainNode2.addGeometry(&terrain2);
terrainNode2.addTexture(&terrainTex);
terrainNode2.setObject(&terrainObject);
//===================================================================//
//==================Object declarations - Geometry, Texture, Node=== //
//==========================Object: Player===========================//
Texture texCV((char*)RESOURCES_PATH "/cv_logo.bmp");
GekoMesh gekoMesh;
geko.setExp(0.0);
geko.setLevelThreshold(100.0);
geko.setLevel(0);
Node playerNode("Player");
playerNode.addGeometry(&gekoMesh);
playerNode.setObject(&geko);
playerNode.addTexture(&texCV);
sfh.generateSource(glm::vec3(geko.getPosition()), RESOURCES_PATH "/Sound/Rascheln.wav");
geko.setSoundHandler(&sfh);
geko.setSourceName(MOVESOUND, "SpielerFootsteps", RESOURCES_PATH "/Sound/Rascheln.wav");
//geko.setSourceName(BACKGROUNDMUSIC, "Hintergrund", RESOURCES_PATH "/Sound/jingle2.wav");
geko.setSourceName(FIGHTSOUND, "Kampfsound", RESOURCES_PATH "/Sound/punch.wav");
geko.setSourceName(EATSOUND, "Essen", RESOURCES_PATH "/Sound/Munching.wav");
geko.setSourceName(QUESTSOUND, "Quest", RESOURCES_PATH "/Sound/jingle.wav");
geko.setSourceName(ITEMSOUND, "Item", RESOURCES_PATH "/Sound/itempickup.wav");
geko.setSourceName(FIRESOUND, "Fire", RESOURCES_PATH "/Sound/Feuer_kurz.wav");
sfh.disableLooping("Essen");
sfh.disableLooping("Quest");
sfh.disableLooping("Item");
geko.setPosition(glm::vec4(terrain2.getResolutionX() / 2.0f, 10.0f, terrain2.getResolutionY() / 2.0f, 1.0));
//sfh.generateSource("Feuer",posFood, RESOURCES_PATH "/Sound/Feuer kurz.wav");
playerNode.setCamera(&cam);
//===================================================================//
//==================Setting up the Level and Scene==================//
//==================================================================//
Level testLevel("testLevel");
Scene testScene("testScene");
testLevel.addScene(&testScene);
testLevel.changeScene("testScene");
testLevel.setTerrain(&terrain2);
//==================Add Camera to Scene============================//
testScene.getScenegraph()->addCamera(&cam);
testScene.getScenegraph()->setActiveCamera("PlayerViewCam");
//==================Set Input-Maps and activate one================//
iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera()));
iH.changeActiveInputMap(MapType::OBJECT);
iH.getActiveInputMap()->update(geko);
//==================Add Objects to the Scene=======================//
//==================Update the Bounding-Sphere 1st time============//
/*Node translateNode("Translate");
translateNode.addTranslation(glm::vec3(terrain2.getResolutionX() / 2.0f, 0.0, terrain2.getResolutionY() / 2.0f));*/
testScene.getScenegraph()->getRootNode()->addChildrenNode(&terrainNode2);
testScene.getScenegraph()->getRootNode()->addChildrenNode(&playerNode);
//testScene.getScenegraph()->getRootNode()->addChildrenNode(&translateNode);
//testScene.getScenegraph()->getRootNode()->getChildrenNode("Translate")->addChildrenNode(&playerNode);
//===================================================================//
//==================Setting up the Observers========================//
//==================================================================//
ObjectObserver playerObserver(&testLevel);
SoundObserver soundPlayerObserver(&testLevel);
geko.addObserver(&playerObserver);
geko.addObserver(&soundPlayerObserver);
// ==============================================================
// == Object (Forest) ==========================================
// ==============================================================
TreeMesh tree;
glm::vec3 tmp;
std::stringstream name;
for (int i = 0; i<TreeData::forest1.size(); i++)
{
name << "Forest1Tree" << i;
std::string stringname = name.str();
StaticObject *treeStatic = new StaticObject();
treeStatic->setTree(50 / TreeData::forest1.size());
Node *treeNode = new Node(stringname);
treeNode->addGeometry(&tree);
treeNode->setObject(treeStatic);
tmp.x = TreeData::forest1[i].x;
tmp.z = TreeData::forest1[i].z;
tmp.y = terrain2.getHeight(glm::vec2(tmp.x, tmp.z));
treeNode->addTranslation(tmp);
treeNode->getBoundingSphere()->radius = 2.5;
testScene.getScenegraph()->getRootNode()->addChildrenNode(treeNode);
name.str("");
}
for (int i = 0; i<TreeData::forest2.size(); i++)
{
name << "Forest2Tree" << i;
std::string stringname = name.str();
StaticObject *treeStatic = new StaticObject();
treeStatic->setTree(50 / TreeData::forest2.size());
Node *treeNode = new Node(stringname);
treeNode->addGeometry(&tree);
treeNode->setObject(treeStatic);
tmp.x = TreeData::forest2[i].x;
tmp.z = TreeData::forest2[i].z;
tmp.y = terrain2.getHeight(glm::vec2(tmp.x, tmp.z));
treeNode->addTranslation(tmp);
treeNode->getBoundingSphere()->radius = 2.5;
testScene.getScenegraph()->getRootNode()->addChildrenNode(treeNode);
name.str("");
}
// ==============================================================
// == Object (Anthome) ==========================================
// ==============================================================
glm::vec3 posFood(10.0, 0.0, -5.0);
glm::vec3 posFood2((terrain2.getResolutionX() / 2.0f) + 10.0, 0.0, (terrain2.getResolutionY() / 2.0f) - 5.0);
glm::vec3 posSpawn(terrain2.getResolutionX() / 2.0f, 10.0, terrain2.getResolutionY() / 2.0f);
glm::vec3 posDefaultPlayer(0.0, 0.0, 0.0);
AntMesh antMesh;
DecisionTree *aggressivedecisionTree = new DecisionTree();
aggressivedecisionTree->setAntTreeAggressiv();
DecisionTree *afraidDecisionTree = new DecisionTree();
afraidDecisionTree->setAntTreeAfraid();
Graph<AStarNode, AStarAlgorithm>* antAggressiveGraph = new Graph<AStarNode, AStarAlgorithm>();
antAggressiveGraph->setExampleAntAggressiv(posSpawn, posFood2, posDefaultPlayer);
Graph<AStarNode, AStarAlgorithm>* antAfraidGraph = new Graph<AStarNode, AStarAlgorithm>();
antAfraidGraph->setExampleAntAfraid2(posSpawn, posDefaultPlayer);
AntHome antHome(posSpawn, antMesh, &playerObserver, &texCV, &texCV, aggressivedecisionTree, antAggressiveGraph, afraidDecisionTree, antAfraidGraph);
//antHome.generateGuards(5, &aiObserver, testScene.getScenegraph()->getRootNode());
antHome.generateWorkers(5, testScene.getScenegraph()->getRootNode());
/*antHome.addAntsToSceneGraph(testScene.getScenegraph()->getRootNode());*/
//===================================================================//
//==================Setting up the Collision=========================//
//==================================================================//
CollisionTest collision;
collision.collectNodes(testScene.getScenegraph()->getRootNode());
CollisionObserver colObserver(&testLevel);
collision.addObserver(&colObserver);
collision.addObserver(&soundPlayerObserver);
GravityObserver gravityObserver(&testLevel);
collision.addObserver(&gravityObserver);
//===================================================================//
//==================Setting up the Gravity===========================//
//==================================================================//
Gravity gravity;
playerNode.addGravity(&gravity);
//===================================================================//
//==================Setting up the Gravity===========================//
//==================================================================//
PlayerGUI playerGUI(HUD_WIDTH, HUD_HEIGHT, WINDOW_HEIGHT, WINDOW_WIDTH, QUEST_HEIGHT, QUEST_WIDTH, playerNode.getPlayer());
//===================================================================//
//==================The Render-Loop==================================//
//==================================================================//
float lastTime = glfwGetTime();
sfh.playSource("Hintergrund");
sfh.setGain("Hintergrund", 0.5f);
//TODO adjust the Rotation,to match the Terrain
glm::vec4 tmpPos;
glm::vec3 normalFromTerrain;
glm::vec3 rotateAxis;
glm::vec4 viewDirFromPlayer;
glm::vec3 up(0.0, 1.0, 0.0);
float lengthFromNormal;
float lengthFromUp;
float phi;
while (!glfwWindowShouldClose(testWindow.getWindow()))
{
float currentTime = glfwGetTime();
float deltaTime = currentTime - lastTime;
lastTime = currentTime;
//===================================================================//
//==================Update your Objects per Frame here =============//
//==================================================================//
collision.update();
//===================================================================//
//==================Input and update for the Player==================//
//==================================================================//
geko.update();
geko.setDeltaTime(currentTime);
tmpPos = testScene.getScenegraph()->searchNode("Player")->getPlayer()->getPosition();
viewDirFromPlayer = testScene.getScenegraph()->searchNode("Player")->getPlayer()->getViewDirection();
//ToDo calculate Normal funktioniert evtl falsch
normalFromTerrain = terrain2.calculateNormal(tmpPos.x, tmpPos.z);
rotateAxis = glm::cross(glm::vec3(viewDirFromPlayer), normalFromTerrain );
// lengthFromNormal = glm::length(normalFromTerrain);
// lengthFromUp = glm::length(up);
normalFromTerrain = glm::normalize(normalFromTerrain);
up = glm::normalize(up);
phi = glm::dot(up, normalFromTerrain);
phi = glm::atan(phi) * (180 / glm::pi<float>());
// phi = glm::acos(glm::dot(normalFromTerrain, up) / (lengthFromNormal * lengthFromUp));
//ToDo Rotation überschreibt die frühere Rotation
testScene.getScenegraph()->searchNode("Player")->addRotation(phi, rotateAxis);
antHome.updateAnts();
//===================================================================//
//==================Render your Objects==============================//
//==================================================================//
//renderer.renderScene(testScene, testWindow);
fboGBuffer.bind();
glClearColor(0.5, 0.5, 0.5, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderGBuffer.bind();
shaderGBuffer.sendMat4("viewMatrix", cam.getViewMatrix());
shaderGBuffer.sendMat4("projectionMatrix", cam.getProjectionMatrix());
testScene.render(shaderGBuffer);
shaderGBuffer.unbind();
fboGBuffer.unbind();
//ScreenFillingQuad Render Pass
shaderSFQ.bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderSFQ.sendSampler2D("fboTexture", fboGBuffer.getColorTexture(2));
screenFillingQuad.renderGeometry();
shaderSFQ.unbind();
renderer.renderGUI(*playerGUI.getHUD(), testWindow);
glfwSwapBuffers(testWindow.getWindow());
glfwPollEvents();
}
glfwDestroyWindow(testWindow.getWindow());
glfwTerminate();
return 0;
}
