bool ObjectFatty::createBodyAtPosition( cocos2d::CCPoint position )
{
// Player physical body
b2dJson json;
m_body = json.j2b2Body( physicsWorld(), prototype() );
if( ! m_body || ! m_body->GetFixtureList() ) {
std::cout << "Simple inventory item prototype messed up" << std::endl;
return false;
}
m_body->SetUserData( this );
m_body->SetTransform( b2Vec2(position.x/PTM_RATIO, position.y/PTM_RATIO), m_body->GetAngle() );
setPosition(position);
b2BodyDef bodyDef;
bodyDef.type = b2_dynamicBody;
bodyDef.fixedRotation = true;
m_contactSensor = physicsWorld()->CreateBody(&bodyDef);
m_contactSensor->SetTransform( b2Vec2(position.x/PTM_RATIO, position.y/PTM_RATIO), m_body->GetAngle() );
m_bodies.push_back( m_contactSensor );
m_bodies.push_back( m_body );
b2RevoluteJointDef md;
md.Initialize(m_body, m_contactSensor, m_body->GetPosition());
md.maxMotorTorque = 200;
md.enableMotor = true;
m_motorJoint = (b2RevoluteJoint *)GameWorld::sharedGameWorld()->physicsWorld->CreateJoint(&md);
saveOriginalProperties();
return true;
}
////////////////////////////////////////////////////
// Creates a dummy sensor object to check collisions
// with other objects
////////////////////////////////////////////////////
bool ObjectGlue::createBodyAtPosition( cocos2d::CCPoint position )
{
b2dJson json;
m_body = json.j2b2Body( physicsWorld(), prototype() );
if( ! m_body || ! m_body->GetFixtureList() ) {
std::cout << "Glue inventory item prototype messed up" << std::endl;
return false;
}
m_body->SetUserData(this);
m_body->SetTransform( b2Vec2(position.x/PTM_RATIO, position.y/PTM_RATIO), m_body->GetAngle() );
setPosition(position);
m_bodies.push_back( m_body );
saveOriginalProperties();
return true;
}
int main(int argc, char** argv)
{
//Matrix4x4f mat = Matrix4x4f::PerspectiveProjection(90, 0.1, 100, 1.f/1.f);
//assert((mat * Matrix4x4f()) == mat); //works :)
if(1) //actual game
{
WAAF level;
if(!level.LoadFromFile("../data/level1.waa"))
{
std::cerr<<"Could not load data/level1.waa"<<std::endl;
system("pause");
return 0;
}
Player player;
player.position = level.GetPlayerPos();
// Physics Setup
//collision configuration contains default setup for memory, collision setup
btDefaultCollisionConfiguration collisionConfiguration;
//use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
btCollisionDispatcher collisionDispatcher(&collisionConfiguration);
btDbvtBroadphase broadphase;
//the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
btSequentialImpulseConstraintSolver solver;
//create physics world
btDiscreteDynamicsWorld physicsWorld(&collisionDispatcher, &broadphase, &solver, &collisionConfiguration);
//stuff copied from bullet samples
physicsWorld.getSolverInfo().m_splitImpulse=true;
physicsWorld.getSolverInfo().m_numIterations = 20;
//set gravity
physicsWorld.setGravity(btVector3(0,-10,0));
btRigidBody levelBody(btRigidBody::btRigidBodyConstructionInfo(0.f, NULL, level.GetPhysMesh()));
physicsWorld.addRigidBody(&levelBody);
btRigidBody::btRigidBodyConstructionInfo playerBodyInfo(10.f, NULL, &player.physShape);
playerBodyInfo.m_startWorldTransform.setOrigin(btVector3(player.position.X, player.position.Y, player.position.Z));
btRigidBody playerBody(playerBodyInfo);
physicsWorld.addRigidBody(&playerBody);
// Console Setup
if(!Console::Init())
{
std::cerr<<"Could not initialize console!"<<std::endl;
system("pause");
return 0;
}
// Renderer Setup
static const float FOV = 90;
static const float NEAR_CLIP = .1f;
static const float FAR_CLIP = 100.f;
AsciiRenderer renderer;
{
float width = Console::GetWidth();
float height = Console::GetHeight() - 1; //cannot use last line due to end-of-line cursor wrap
if(!renderer.Init(width, height, FOV, NEAR_CLIP, FAR_CLIP))
{
std::cerr<<"Could not initialize renderer!"<<std::endl;
Console::Destroy();
system("pause");
return 0;
}
}
// Main Loop
renderer.ApplyModelviewMatrix(Matrix4x4f::Translation(level.GetPlayerPos()));
bool running = true; //the game, not the player (I lost the game -.-)
//movement keys
bool moveForward = false;
bool moveLeft = false;
bool moveRight = false;
bool moveBack = false;
bool moveUp = false; //aka jump
bool menu = true;
ShowMenu(); //initial render
unsigned long long lastFrameTime = GetTimeMS();
float pitch = 0.f; //in rad
float yaw = 0.f;
float mouseScaleX = .05f / 180.f * 3.1415f;
float mouseScaleY = -.05f / 180.f * 3.1415f;
float movespeed = 1.f;
while(running)
{
MouseMoveEvent mouseMove;
mouseMove.X = 0;
mouseMove.Y = 0;
// Event Loop
Event ev;
while(Console::PollEvent(ev))
{
switch(ev.Type)
{
case KeyPressed:
{
switch(ev.Key.Code)
{
case KEYCODE_ESCAPE: // quit on escape pressed
{
if(menu)
{
running = false;
}
else
{
menu = true;
ShowMenu();
}
break;
}
case KEYCODE_RETURN:
{
menu = false;
break;
}
case KEYCODE_W:
{
moveForward = true;
break;
}
case KEYCODE_A:
{
moveLeft = true;
break;
}
case KEYCODE_S:
{
moveBack = true;
break;
}
case KEYCODE_D:
{
moveRight = true;
break;
}
case KEYCODE_SPACE:
{
moveUp = true;
break;
}
default:
{
break;
}
}
break;
}
case KeyReleased:
{
switch(ev.Key.Code)
{
case KEYCODE_W:
{
moveForward = false;
break;
}
case KEYCODE_A:
{
moveLeft = false;
break;
}
case KEYCODE_S:
{
moveBack = false;
break;
}
case KEYCODE_D:
{
moveRight = false;
break;
}
default:
{
break;
}
}
break;
}
case Resized: // change resolution when window resized
{
if(!renderer.Init(ev.Resize.SizeX, ev.Resize.SizeY - 1, FOV, NEAR_CLIP, FAR_CLIP))
{
std::cerr << "Could not change resolution!" << std::endl;
Console::Destroy();
system("pause");
return 0;
}
break;
}
case MouseMoved:
{
mouseMove = ev.MouseMove;
break;
}
case MouseButtonPressed:
{
break;
}
case MouseButtonReleased:
{
break;
}
case MouseWheelMoved:
{
break;
}
default:
{
break;
}
}
} //end event loop
// Game Logic
unsigned long long frameTime = GetTimeMS();
unsigned int deltaT = frameTime - lastFrameTime;
lastFrameTime = frameTime;
if(menu)
{
//no logic required in menu, just await events
}
else
{
yaw += mouseMove.X * mouseScaleX;
pitch += mouseMove.Y * mouseScaleY;
while(yaw > 360.f/ 180.f * 3.1415f) yaw -= 360.f/ 180.f * 3.1415f;
while(yaw < 0.f) yaw += 360.f;
//clip pitch to [-90°, 90°]
if(pitch < -3.1415f/2.f) pitch = -3.1415f/2.f;
if(pitch > 3.1415f/2.f) pitch = 3.1415f/2.f;
// move mouse cursor back to 100, 100 and queue mouse moves
Console::Update();
if(deltaT > 0)
{
physicsWorld.stepSimulation(deltaT); //should ideally be fixed - cba
//todo: updating goes here
}
btVector3 moveDir = CalculateMoveDir(moveLeft, moveForward, moveRight, moveBack, yaw);
moveDir = moveDir * deltaT * movespeed;
//playerBody.applyCentralForce(moveDir);
}
// Rendering
if(menu)
{
//menu is fixed, no rendering required
Sleep(5);
}
else
{
Matrix4x4f posMat;
posMat._14 = -playerBody.getWorldTransform().getOrigin().x();
posMat._24 = -playerBody.getWorldTransform().getOrigin().y();
posMat._34 = -playerBody.getWorldTransform().getOrigin().z();
renderer.SetModelviewMatrix(Matrix4x4f());
renderer.ApplyModelviewMatrix(Matrix4x4f::SimpleRotation(pitch , yaw));
renderer.ApplyModelviewMatrix(posMat);
// clear
renderer.ClearDepth();
renderer.ClearColor();
// render
level.Render(renderer);
// "switch buffers"
std::stringstream ss;
char const * const * const colBuf = renderer.GetColorBuffer();
for(unsigned int y = 0; y < renderer.GetHeight(); ++y)
{
ss << std::string(colBuf[y], renderer.GetWidth());// << "\n"; //if width is not correct
}
Console::GotoXY(0, 0);
Console::Write(ss.str());
}
}
Console::Destroy();
return 0;
}
}
bool Scene::loadMap()
{
// chargement des images
QPixmap *grassTile = new QPixmap(QCoreApplication::applicationDirPath() + "/data/tiles/GrassTile.png");
if (grassTile->isNull())
{
return false;
}
QPixmap *roadTile = new QPixmap(QCoreApplication::applicationDirPath() + "/data/tiles/RoadTile.png");
if (roadTile->isNull())
{
return false;
}
QPixmap *mudTile = new QPixmap(QCoreApplication::applicationDirPath() + "/data/tiles/MudTile.png");
if (mudTile->isNull())
{
return false;
}
// remplissage de la scène graphique avec les tuiles
for(int x=0;x<m_tilemap->width();x++)
{
for(int y=0;y<m_tilemap->height();y++)
{
QGraphicsPixmapItem *item;
switch(m_tilemap->tile(x,y))
{
case GroundType::Asphalt : item = new QGraphicsPixmapItem(*roadTile);
break;
case GroundType::Mud : item = new QGraphicsPixmapItem( *mudTile);
break;
default : item = new QGraphicsPixmapItem(*grassTile);
}
item->setPos(x*32,y*32);
this->graphicsScene()->addItem(item);
}
}
// ajoute des "murs" autour de la scène pour éviter que des objets ne sortent de la zone de jeu
Vector v1;
Vector v2(m_tilemap->width()*32,0.f);
Vector v3(0.f,m_tilemap->height()*32);
Vector v4(m_tilemap->width()*32,m_tilemap->height()*32);
b2BodyDef bodyDef;
bodyDef.type = b2_staticBody;
b2Body *body = physicsWorld()->CreateBody(&bodyDef);
b2EdgeShape lineUp;
lineUp.Set(v1,v2);
body->CreateFixture(&lineUp,1);
b2EdgeShape lineLeft;
lineLeft.Set(v1,v3);
body->CreateFixture(&lineLeft,1);
b2EdgeShape lineRight;
lineRight.Set(v2,v4);
body->CreateFixture(&lineRight,1);
b2EdgeShape lineBottom;
lineBottom.Set(v3,v4);
body->CreateFixture(&lineBottom,1);
return true;
}
void PaintGenerator::generateHeightmap(const std::vector<Math::Triangle3D>& _triangles,
Math::HexHeightMap& heightMap,
Misc::ProgressTracker* progress_tracker) {
if (_triangles.size() <= 0)
return;
#ifdef USE_BULLET_RAYCASTS
// bullet initialization
boost::shared_ptr<Physics::PhysicsWorld> physicsWorld(
new Physics::PhysicsWorld());
btRigidBody *meshBody
= Physics::PhysicsFactory::createRigidTriMesh(_triangles);
physicsWorld->registerRigidBody(meshBody);
#endif
#ifndef USE_BULLET_RAYCASTS
vector<ObjectSpatial*> triangles;
paintBound.setToObject(_triangles[0]);
triangles.push_back(new Triangle3D(_triangles[0]));
for (unsigned int i = 1; i < _triangles.size(); i++) {
paintBound.expandToInclude(_triangles[i]);
triangles.push_back(new Triangle3D(_triangles[i]));
}
triangleTree = new BSPTree3D(paintBound);
triangleTree->add(triangles);
#endif
Math::HexGrid hex_grid = heightMap.getHexGrid();
double cell_radius = hex_grid.getHexRadius();
vector< vector< vector<PaintCell*> > > cell_array;
int u_steps = hex_grid.numUIndices();
int v_steps = hex_grid.numVIndices();
cell_array.resize(u_steps);
for (int i = 0; i < u_steps; i++) {
cell_array[i].resize(v_steps);
}
if (progress_tracker) {
progress_tracker->setCurrentStage("Generating heightmap...");
progress_tracker->setTotalSteps(v_steps);
}
//Perform all raycasts
for (int v = 0; v < v_steps; v++) {
if (progress_tracker)
progress_tracker->setCurrentStep(v);
double v_pos = hex_grid.hexVPosition(v);
for (int u = 0; u < u_steps; u++) {
double u_pos = hex_grid.hexUPosition(u, v);
vector<double> vert_heights1;
vector<double> vert_heights2;
heightsAtPoint(u_pos-cell_radius, v_pos, vert_heights1);
for (unsigned int i = 0; i < vert_heights1.size(); i++)
heightMap.addVertexHeight(u*2, v, vert_heights1[i]);
heightsAtPoint(u_pos+cell_radius, v_pos, vert_heights2);
for (unsigned int i = 0; i < vert_heights2.size(); i++)
heightMap.addVertexHeight(u*2+1, v, vert_heights2[i]);
if (!vert_heights1.empty() && !vert_heights2.empty()) {
vector<double> center_heights;
heightsAtPoint(u_pos, v_pos, center_heights);
for (unsigned int i = 0; i < center_heights.size(); i++)
heightMap.addHexHeight(u, v, center_heights[i]);
}
}
}
#ifndef USE_BULLET_RAYCASTS
for (unsigned int i = 0; i < triangles.size(); i++)
delete triangles[i];
delete triangleTree;
#endif
}
void SceneObjectEntryPointSurf::onAdd() {
// Physics
std::shared_ptr<pge::SceneObjectPhysicsWorld> physicsWorld(new pge::SceneObjectPhysicsWorld());
getRenderScene()->addNamed(physicsWorld, "physWrld");
pge::SceneObjectRef lighting = getScene()->getNamed("lighting");
pge::SceneObjectLighting* pLighting = static_cast<pge::SceneObjectLighting*>(lighting.get());
pLighting->_ambientLight = pge::Vec3f(0.01f, 0.01f, 0.01f);
/*std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> light(new pge::SceneObjectDirectionalLightShadowed());
getRenderScene()->add(light);
light->create(pLighting, 2, 2048, 0.5f, 100.0f, 0.6f);
light->setDirection(pge::Vec3f(-0.4f, -1.0f, 0.6f).normalized());
light->setColor(pge::Vec3f(1.0f, 1.0f, 1.0f));*/
// GUI
/*std::shared_ptr<SceneObjectGUI> gui(new SceneObjectGUI());
getRenderScene()->addNamed(gui, "gui", false);
gui->_layer = 2.0f;*/
// Control
std::shared_ptr<SceneObjectOrbitCamera> camera(new SceneObjectOrbitCamera());
getRenderScene()->add(camera, false);
// Map
/*std::shared_ptr<pge::Map3DWS> map(new pge::Map3DWS());
map->_settings._pScene = getScene();
map->createAsset("resources/maps/horrorMap.3dw");
pge::addMapLights(*map, getScene());*/
std::shared_ptr<SceneObjectProp> prop(new SceneObjectProp());
getScene()->add(prop, true);
prop->create("resources/models/BlockGame.obj");
prop->calculateAABB();
std::shared_ptr<SceneObjectSurf> cartPole(new SceneObjectSurf());
getRenderScene()->add(cartPole, false);
cartPole->create();
cartPole->_layer = 100.0f;
std::shared_ptr<SceneObjectProp> sky(new SceneObjectProp());
getScene()->add(sky, true);
sky->create("resources/models/skybox1.obj");
sky->_transform = pge::Matrix4x4f::scaleMatrix(pge::Vec3f(100.0f, 100.0f, 100.0f));
sky->calculateAABB();
std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> directionalLight(new pge::SceneObjectDirectionalLightShadowed());
getScene()->add(directionalLight);
directionalLight->create(pLighting, 3, 2048, 0.2f, 100.0f, 0.6f);
directionalLight->setDirection(pge::Vec3f(-0.2523f, -0.9423f, -0.424f).normalized());
directionalLight->setColor(pge::Vec3f(0.7f, 0.7f, 0.7f));
// ------------------------------------------- Image Effects -------------------------------------------
std::shared_ptr<pge::SceneObjectEffectBuffer> effectBuffer(new pge::SceneObjectEffectBuffer());
getRenderScene()->addNamed(effectBuffer, "ebuf", false);
effectBuffer->create(0.5f);
std::shared_ptr<pge::Asset> assetBlurHorizontal;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontal.frag", assetBlurHorizontal);
std::shared_ptr<pge::Shader> blurShaderHorizontal = std::static_pointer_cast<pge::Shader>(assetBlurHorizontal);
std::shared_ptr<pge::Asset> assetBlurVertical;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVertical.frag", assetBlurVertical);
std::shared_ptr<pge::Shader> blurShaderVertical = std::static_pointer_cast<pge::Shader>(assetBlurVertical);
std::shared_ptr<pge::Asset> assetRenderImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImage.frag", assetRenderImage);
std::shared_ptr<pge::Shader> renderImageShader = std::static_pointer_cast<pge::Shader>(assetRenderImage);
std::shared_ptr<pge::Asset> assetRenderMultImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImageMult.frag", assetRenderMultImage);
std::shared_ptr<pge::Shader> renderImageMultShader = std::static_pointer_cast<pge::Shader>(assetRenderMultImage);
std::shared_ptr<pge::Asset> assetNoise;
getScene()->getAssetManager("tex2D", pge::Texture2D::assetFactory)->getAsset("resources/textures/noise.bmp", assetNoise);
std::shared_ptr<pge::Texture2D> noiseMap = std::static_pointer_cast<pge::Texture2D>(assetNoise);
noiseMap->bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
std::shared_ptr<pge::Asset> assetBlurHorizontalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontalEdgeAware.frag", assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderHorizontalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Asset> assetBlurVerticalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVerticalEdgeAware.frag", assetBlurVerticalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderVerticalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurVerticalEdgeAware);
// SSAO
/*std::shared_ptr<pge::Shader> ssaoShader(new pge::Shader());
ssaoShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssao.frag");
std::shared_ptr<pge::SceneObjectSSAO> ssao(new pge::SceneObjectSSAO());
getRenderScene()->add(ssao, false);
ssao->create(blurShaderHorizontal, blurShaderVertical, ssaoShader, renderImageShader, noiseMap);
ssao->_ssaoRadius = 0.1f;
ssao->_ssaoStrength = 1.0f;
ssao->_blurRadius = 0.002f;
ssao->_numBlurPasses = 1;*/
// SSR
std::shared_ptr<pge::TextureCube> cubeMap(new pge::TextureCube());
cubeMap->createAsset(
"resources/environmentmaps/skybox1/CloudyLightRaysLeft2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysRight2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysBack2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysFront2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysDown2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysUp2048.png "
);
std::shared_ptr<pge::Shader> ssrShader(new pge::Shader());
ssrShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssr.frag");
std::shared_ptr<pge::SceneObjectSSR> ssr(new pge::SceneObjectSSR());
getRenderScene()->add(ssr, false);
ssr->create(blurShaderHorizontalEdgeAware, blurShaderVerticalEdgeAware, ssrShader, renderImageShader, cubeMap, noiseMap);
ssr->_layer = 1.0f;
// Light Scattering
/*std::shared_ptr<pge::Shader> lightScatteringShader(new pge::Shader());
lightScatteringShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lightScattering.frag");
std::shared_ptr<pge::SceneObjectLightScattering> lightScattering(new pge::SceneObjectLightScattering());
getRenderScene()->add(lightScattering, false);
lightScattering->create(blurShaderHorizontal, blurShaderVertical, lightScatteringShader, renderImageShader);
lightScattering->_layer = 1.5f;
lightScattering->_lightSourcePosition = -light->getDirection() * 200.0f;
lightScattering->_lightSourceColor = pge::Vec3f(1.0f, 0.9f, 0.8f) * 0.5f;*/
// Depth of field
/*std::shared_ptr<pge::Shader> depthOfFieldBlurShaderHorizontal(new pge::Shader());
depthOfFieldBlurShaderHorizontal->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurHorizontal.frag");
std::shared_ptr<pge::Shader> depthOfFieldBlurShaderVertical(new pge::Shader());
depthOfFieldBlurShaderVertical->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurVertical.frag");
std::shared_ptr<pge::SceneObjectDepthOfField> depthOfField(new pge::SceneObjectDepthOfField());
getRenderScene()->add(depthOfField, false);
depthOfField->create(depthOfFieldBlurShaderHorizontal, depthOfFieldBlurShaderVertical, renderImageShader);
depthOfField->_layer = 1.5f;
depthOfField->_focalDistance = 9.0f;
depthOfField->_focalRange = 0.4f;
depthOfField->_blurRadius = 0.002f;
depthOfField->_numBlurPasses = 1;*/
// FXAA
std::shared_ptr<pge::Shader> lumaShader(new pge::Shader());
lumaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lumaRender.frag");
std::shared_ptr<pge::Shader> fxaaShader(new pge::Shader());
fxaaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/fxaa.frag");
std::shared_ptr<pge::SceneObjectFXAA> fxaa(new pge::SceneObjectFXAA());
getRenderScene()->add(fxaa, false);
fxaa->create(fxaaShader, lumaShader);
destroy();
}
