void Matrix44::setUpAndOrthonormalize(Vector3 up)
{
up.normalize();
//put the up vector in the matrix
m[4] = up.x;
m[5] = up.y;
m[6] = up.z;
//orthonormalize
Vector3 right,front;
right = rightVector();
if ( abs(right.dot( up )) < 0.99998 )
{
right = up.cross( frontVector() );
front = right.cross( up );
}
else
{
front = Vector3(right).cross( up );
right = up.cross( front );
}
right.normalize();
front.normalize();
m[8] = front.x;
m[9] = front.y;
m[10] = front.z;
m[0] = right.x;
m[1] = right.y;
m[2] = right.z;
}
void CoordinateFrame::getXYZYPRRadians(float& x, float& y, float& z,
float& yaw, float& pitch, float& roll) const {
x = translation.x;
y = translation.y;
z = translation.z;
const Vector3& look = lookVector();
if (abs(look.y) > 0.99f) {
// Looking nearly straight up or down
yaw = G3D::pi() + atan2(look.x, look.z);
pitch = asin(look.y);
roll = 0.0f;
} else {
// Yaw cannot be affected by others, so pull it first
yaw = G3D::pi() + atan2(look.x, look.z);
// Pitch is the elevation of the yaw vector
pitch = asin(look.y);
Vector3 actualRight = rightVector();
Vector3 expectedRight = look.cross(Vector3::unitY());
roll = 0;//acos(actualRight.dot(expectedRight)); TODO
}
}
void Matrix44::setFrontAndOrthonormalize(Vector3 front)
{
front.normalize();
//put the up vector in the matrix
m[8] = front.x;
m[9] = front.y;
m[10] = front.z;
//orthonormalize
Vector3 right,up;
right = rightVector();
if ( abs(right.dot( front )) < 0.99998 )
{
right = topVector().cross( front );
up = front.cross( right );
}
else
{
up = front.cross( right );
right = up.cross( front );
}
right.normalize();
up.normalize();
m[4] = up.x;
m[5] = up.y;
m[6] = up.z;
m[0] = right.x;
m[1] = right.y;
m[2] = right.z;
}
void GLSpriteRenderer::Render() {
SPADES_MARK_FUNCTION();
lastImage = NULL;
program->Use();
projectionViewMatrix(program);
rightVector(program);
upVector(program);
texture(program);
viewMatrix(program);
fogDistance(program);
fogColor(program);
positionAttribute(program);
spritePosAttribute(program);
colorAttribute(program);
projectionViewMatrix.SetValue(renderer->GetProjectionViewMatrix());
viewMatrix.SetValue(renderer->GetViewMatrix());
fogDistance.SetValue(renderer->GetFogDistance());
Vector3 fogCol = renderer->GetFogColor();
fogColor.SetValue(fogCol.x,fogCol.y,fogCol.z);
const client::SceneDefinition& def = renderer->GetSceneDef();
rightVector.SetValue(def.viewAxis[0].x,
def.viewAxis[0].y,
def.viewAxis[0].z);
upVector.SetValue(def.viewAxis[1].x,
def.viewAxis[1].y,
def.viewAxis[1].z);
texture.SetValue(0);
device->ActiveTexture(0);
device->EnableVertexAttribArray(positionAttribute(), true);
device->EnableVertexAttribArray(spritePosAttribute(), true);
device->EnableVertexAttribArray(colorAttribute(), true);
for(size_t i = 0; i < sprites.size(); i++){
Sprite& spr = sprites[i];
if(spr.image != lastImage){
Flush();
lastImage = spr.image;
SPAssert(vertices.empty());
}
Vertex v;
v.x = spr.center.x;
v.y = spr.center.y;
v.z = spr.center.z;
v.radius = spr.radius;
v.angle = spr.angle;
v.r = spr.color.x;
v.g = spr.color.y;
v.b = spr.color.z;
v.a = spr.color.w;
uint32_t idx = (uint32_t)vertices.size();
v.sx = -1; v.sy = -1;
vertices.push_back(v);
v.sx = 1; v.sy = -1;
vertices.push_back(v);
v.sx = -1; v.sy = 1;
vertices.push_back(v);
v.sx = 1; v.sy = 1;
vertices.push_back(v);
indices.push_back(idx);
indices.push_back(idx + 1);
indices.push_back(idx + 2);
indices.push_back(idx + 1);
indices.push_back(idx + 3);
indices.push_back(idx + 2);
}
Flush();
device->EnableVertexAttribArray(positionAttribute(), false);
device->EnableVertexAttribArray(spritePosAttribute(), false);
device->EnableVertexAttribArray(colorAttribute(), false);
}
void Polygon::updateGeometry()
{
angle = (float*)calloc(nVertices, sizeof(float));
edgeLength = (float*)calloc(nVertices, sizeof(float));
//locals
float angleSum = 0;
int isReflex;
int dotProduct;
float magnRightSqr;
float magnLeftSqr;
float cosOfAngleSqr;
float cosOfAngle;
Pair leftVector(0,0);
Pair rightVector(0,0);
for(int i = 0; i < nVertices; i++)
{
Pair leftVector = vertex[(nVertices-1+i) % nVertices] - vertex[i];
Pair rightVector = vertex[(i+1) % nVertices] - vertex[i];
isReflex = (rightVector.x*leftVector.y-rightVector.y*leftVector.x);
dotProduct = (rightVector.x*leftVector.x + rightVector.y*leftVector.y);
magnRightSqr = (rightVector.x*rightVector.x) + (rightVector.y*rightVector.y);
magnLeftSqr = (leftVector.x*leftVector.x) + (leftVector.y*leftVector.y);
cosOfAngleSqr = 0;
if(magnLeftSqr==0 || magnRightSqr ==0)
{
cosOfAngle = 1;
}
else
{
cosOfAngle = dotProduct/sqrt(magnLeftSqr*magnRightSqr);
}
angle[i] = acos(cosOfAngle);
/*
if(dotProduct<0)
{
angle[i] = PI - acos(cosOfAngle);
}
else
{
angle[i] = acos(cosOfAngle);
}
*/
if(isReflex<0)
{
angle[i] = 2*PI-angle[i];
}
angleSum += angle[i];
edgeLength[i] = sqrt((float)magnRightSqr);
}
if(angleSum >= PI*nVertices)
{
order = true;
for(int i=0; i<nVertices; i++)
{
angle[i] = 360 - angle[i]*180/PI;
}
}
else
{
order = false;
for(int i=0; i<nVertices; i++)
{
angle[i] = angle[i]*180/PI;
}
}
}
void GLSoftSpriteRenderer::Render() {
SPADES_MARK_FUNCTION();
lastImage = NULL;
program->Use();
device->Enable(IGLDevice::Blend, true);
device->BlendFunc(IGLDevice::One, IGLDevice::OneMinusSrcAlpha);
projectionViewMatrix(program);
rightVector(program);
frontVector(program);
viewOriginVector(program);
upVector(program);
texture(program);
depthTexture(program);
viewMatrix(program);
fogDistance(program);
fogColor(program);
zNearFar(program);
positionAttribute(program);
spritePosAttribute(program);
colorAttribute(program);
projectionViewMatrix.SetValue(renderer->GetProjectionViewMatrix());
viewMatrix.SetValue(renderer->GetViewMatrix());
fogDistance.SetValue(renderer->GetFogDistance());
Vector3 fogCol = renderer->GetFogColor();
fogCol *= fogCol; // linearize
fogColor.SetValue(fogCol.x, fogCol.y, fogCol.z);
const client::SceneDefinition &def = renderer->GetSceneDef();
rightVector.SetValue(def.viewAxis[0].x, def.viewAxis[0].y, def.viewAxis[0].z);
upVector.SetValue(def.viewAxis[1].x, def.viewAxis[1].y, def.viewAxis[1].z);
frontVector.SetValue(def.viewAxis[2].x, def.viewAxis[2].y, def.viewAxis[2].z);
viewOriginVector.SetValue(def.viewOrigin.x, def.viewOrigin.y, def.viewOrigin.z);
texture.SetValue(0);
depthTexture.SetValue(1);
zNearFar.SetValue(def.zNear, def.zFar);
device->ActiveTexture(1);
device->BindTexture(IGLDevice::Texture2D,
renderer->GetFramebufferManager()->GetDepthTexture());
device->ActiveTexture(0);
device->EnableVertexAttribArray(positionAttribute(), true);
device->EnableVertexAttribArray(spritePosAttribute(), true);
device->EnableVertexAttribArray(colorAttribute(), true);
thresLow = tanf(def.fovX * .5f) * tanf(def.fovY * .5f) * 1.8f;
thresRange = thresLow * .5f;
// full-resolution sprites
{
GLProfiler::Context measure(renderer->GetGLProfiler(), "Full Resolution");
for (size_t i = 0; i < sprites.size(); i++) {
Sprite &spr = sprites[i];
float layer = LayerForSprite(spr);
if (layer == 1.f)
continue;
if (spr.image != lastImage) {
Flush();
lastImage = spr.image;
SPAssert(vertices.empty());
}
Vertex v;
v.x = spr.center.x;
v.y = spr.center.y;
v.z = spr.center.z;
v.radius = spr.radius;
v.angle = spr.angle;
v.r = spr.color.x;
v.g = spr.color.y;
v.b = spr.color.z;
v.a = spr.color.w;
float fade = 1.f - layer;
v.r *= fade;
v.g *= fade;
v.b *= fade;
v.a *= fade;
uint32_t idx = (uint32_t)vertices.size();
v.sx = -1;
v.sy = -1;
vertices.push_back(v);
v.sx = 1;
v.sy = -1;
vertices.push_back(v);
v.sx = -1;
v.sy = 1;
vertices.push_back(v);
v.sx = 1;
v.sy = 1;
vertices.push_back(v);
indices.push_back(idx);
indices.push_back(idx + 1);
indices.push_back(idx + 2);
indices.push_back(idx + 1);
indices.push_back(idx + 3);
indices.push_back(idx + 2);
}
Flush();
}
// low-res sprites
IGLDevice::UInteger lastFb = device->GetInteger(IGLDevice::FramebufferBinding);
int sW = device->ScreenWidth(), sH = device->ScreenHeight();
int lW = (sW + 3) / 4, lH = (sH + 3) / 4;
int numLowResSprites = 0;
GLColorBuffer buf = renderer->GetFramebufferManager()->CreateBufferHandle(lW, lH, true);
device->BindFramebuffer(IGLDevice::Framebuffer, buf.GetFramebuffer());
device->ClearColor(0.f, 0.f, 0.f, 0.f);
device->Clear(IGLDevice::ColorBufferBit);
device->BlendFunc(IGLDevice::One, IGLDevice::OneMinusSrcAlpha);
device->Viewport(0, 0, lW, lH);
{
GLProfiler::Context measure(renderer->GetGLProfiler(), "Low Resolution");
for (size_t i = 0; i < sprites.size(); i++) {
Sprite &spr = sprites[i];
float layer = LayerForSprite(spr);
if (layer == 0.f)
continue;
if (spr.image != lastImage) {
Flush();
lastImage = spr.image;
SPAssert(vertices.empty());
}
numLowResSprites++;
Vertex v;
v.x = spr.center.x;
v.y = spr.center.y;
v.z = spr.center.z;
v.radius = spr.radius;
v.angle = spr.angle;
v.r = spr.color.x;
v.g = spr.color.y;
v.b = spr.color.z;
v.a = spr.color.w;
float fade = layer;
v.r *= fade;
v.g *= fade;
v.b *= fade;
v.a *= fade;
uint32_t idx = (uint32_t)vertices.size();
v.sx = -1;
v.sy = -1;
vertices.push_back(v);
v.sx = 1;
v.sy = -1;
vertices.push_back(v);
v.sx = -1;
v.sy = 1;
vertices.push_back(v);
v.sx = 1;
v.sy = 1;
vertices.push_back(v);
indices.push_back(idx);
indices.push_back(idx + 1);
indices.push_back(idx + 2);
indices.push_back(idx + 1);
indices.push_back(idx + 3);
indices.push_back(idx + 2);
}
Flush();
}
// finalize
device->ActiveTexture(1);
device->BindTexture(IGLDevice::Texture2D, 0);
device->ActiveTexture(0);
device->BindTexture(IGLDevice::Texture2D, 0);
device->EnableVertexAttribArray(positionAttribute(), false);
device->EnableVertexAttribArray(spritePosAttribute(), false);
device->EnableVertexAttribArray(colorAttribute(), false);
// composite downsampled sprite
device->BlendFunc(IGLDevice::One, IGLDevice::OneMinusSrcAlpha);
if (numLowResSprites > 0) {
GLProfiler::Context measure(renderer->GetGLProfiler(), "Finalize");
GLQuadRenderer qr(device);
// do gaussian blur
GLProgram *program =
renderer->RegisterProgram("Shaders/PostFilters/Gauss1D.program");
static GLProgramAttribute blur_positionAttribute("positionAttribute");
static GLProgramUniform blur_textureUniform("mainTexture");
static GLProgramUniform blur_unitShift("unitShift");
program->Use();
blur_positionAttribute(program);
blur_textureUniform(program);
blur_unitShift(program);
blur_textureUniform.SetValue(0);
device->ActiveTexture(0);
qr.SetCoordAttributeIndex(blur_positionAttribute());
device->Enable(IGLDevice::Blend, false);
// x-direction
GLColorBuffer buf2 =
renderer->GetFramebufferManager()->CreateBufferHandle(lW, lH, true);
device->BindTexture(IGLDevice::Texture2D, buf.GetTexture());
device->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
blur_unitShift.SetValue(1.f / lW, 0.f);
qr.Draw();
buf.Release();
// x-direction
GLColorBuffer buf3 =
renderer->GetFramebufferManager()->CreateBufferHandle(lW, lH, true);
device->BindTexture(IGLDevice::Texture2D, buf2.GetTexture());
device->BindFramebuffer(IGLDevice::Framebuffer, buf3.GetFramebuffer());
blur_unitShift.SetValue(0.f, 1.f / lH);
qr.Draw();
buf2.Release();
buf = buf3;
device->Enable(IGLDevice::Blend, true);
// composite
program = renderer->RegisterProgram("Shaders/PostFilters/PassThrough.program");
static GLProgramAttribute positionAttribute("positionAttribute");
static GLProgramUniform colorUniform("colorUniform");
static GLProgramUniform textureUniform("mainTexture");
static GLProgramUniform texCoordRange("texCoordRange");
positionAttribute(program);
textureUniform(program);
texCoordRange(program);
colorUniform(program);
program->Use();
textureUniform.SetValue(0);
texCoordRange.SetValue(0.f, 0.f, 1.f, 1.f);
colorUniform.SetValue(1.f, 1.f, 1.f, 1.f);
qr.SetCoordAttributeIndex(positionAttribute());
device->BindFramebuffer(IGLDevice::Framebuffer, lastFb);
device->BindTexture(IGLDevice::Texture2D, buf.GetTexture());
device->Viewport(0, 0, sW, sH);
qr.Draw();
device->BindTexture(IGLDevice::Texture2D, 0);
} else {
device->Viewport(0, 0, sW, sH);
device->BindFramebuffer(IGLDevice::Framebuffer, lastFb);
}
buf.Release();
}
int main()
{
//Create window, and limit frame rate
sf::RenderWindow window (sf::VideoMode(800, 600, 32), "Game", sf::Style::Default);
window.setFramerateLimit(60);
//------------------------TEXTURES------------------------------
//Declare textures
sf::Texture texture;
sf::Texture texture1;
sf::Texture texture2;
//Load image
if(!texture.loadFromFile("Sprites/main.png"))
{
return 1;
}
if(!texture1.loadFromFile("Sprites/background.png"))
{
return 1;
}
if(!texture2.loadFromFile("Sprites/house.png"))
{
return 1;
}
//------------------------SPRITES--------------------------
//Creates and places the sprites
sf::Sprite sprite;
sf::Sprite background;
sf::Sprite house;
sprite.setPosition(400, 300);
background.setPosition(0, 0);
house.setPosition(440, 300);
//Loads texture into sprite
sprite.setTexture(texture);
background.setTexture(texture1);
house.setTexture(texture2);
//-------------------------RECTANGLES--------------------------------
//Declares the rectangles
sf::IntRect front(1, 1, 18, 24);
sf::IntRect back (20, 1, 18, 24);
sf::IntRect left (20, 26, 18, 24);
sf::IntRect right (1, 26, 18, 24);
//Steps
sf::IntRect frontLeft(39, 1, 18, 24);
sf::IntRect frontRight(39, 26, 18, 24);
sf::IntRect backLeft();
sf::IntRect backRight();
sf::IntRect leftLeft();
sf::IntRect leftRight();
sf::IntRect rightLeft();
sf::IntRect rightRight();
sf::IntRect backgroundRect (0, 0, 800, 600);
sf::IntRect houseRect (0, 0, 17, 22);
//Crop sprites using rectangles defined above
sprite.setTextureRect(front);
background.setTextureRect(backgroundRect);
house.setTextureRect(houseRect);
//-----------------------SOUND------------------------------------------------------
//Declare the Sound Buffer
sf::SoundBuffer footstepsBuffer;
sf::SoundBuffer bumpBuffer;
//Loads the sound file
if(!footstepsBuffer.loadFromFile("Sounds/footsteps.wav"))
{
return 1;
}
if(!bumpBuffer.loadFromFile("Sounds/bump.wav"))
{
return 1;
}
//Declare sound
sf::Sound footsteps;
sf::Sound bump;
//Load Buffer into Sound
footsteps.setBuffer(footstepsBuffer);
bump.setBuffer(bumpBuffer);
//-------------------------------MAIN-----------------------------
//Main window loop
while(window.isOpen())
{
sf::Event event;
//Vectors used for collision
sf::Vector2i spritePosition(sprite.getPosition());
sf::Vector2i backgroundPosition(background.getPosition());
sf::Vector2i housePosition(house.getPosition());
//Sprite Vectors
sf::Vector2i backVector(back.width, back.height);
sf::Vector2i frontVector(front.width, front.height);
sf::Vector2i rightVector(right.width, right.height);
sf::Vector2i leftVector(left.width, left.height);
//House Vectors
sf::Vector2i houseVector(houseRect.width, houseRect.height);
while(window.pollEvent(event))
{
if(event.type == sf::Event::Closed)
{
window.close();
}
if(event.key.code == sf::Keyboard::Insert)
{
sf::Image screenshot = window.capture();
screenshot.saveToFile("Screenshot.png");
}
}
//-----------------------------------MOVEMENT----------------------------------------
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
{
//Change to stepping sprite
Sleep(250);
sprite.setTextureRect(back);
sprite.move(0, -24);
//Redeclaring the collision textures
sf::Vector2i spritePosition(sprite.getPosition());
sf::Vector2i housePosition(house.getPosition());
if(collision(spritePosition, backVector, housePosition, houseVector) == true)
{
sprite.move(0, 24);
bump.play();
}
else
{
footsteps.play();
}
}
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
{
//Change to stepping sprite
Sleep(250);
sprite.setTextureRect(front);
sprite.move(0, 24);
//Redeclaring the collision textures
sf::Vector2i spritePosition(sprite.getPosition());
sf::Vector2i housePosition(house.getPosition());
if(collision(spritePosition, frontVector, housePosition, houseVector) == true)
{
sprite.move(0, -24);
bump.play();
}
else
{
footsteps.play();
}
}
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
{
//Change to stepping sprite
Sleep(250);
sprite.setTextureRect(right);
sprite.move(19, 0);
//Redeclaring the collision textures
sf::Vector2i spritePosition(sprite.getPosition());
sf::Vector2i housePosition(house.getPosition());
if(collision(spritePosition, leftVector, housePosition, houseVector) == true)
{
sprite.move(-19, 0);
bump.play();
}
else
{
footsteps.play();
}
}
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
{
//Change to stepping sprite
Sleep(250);
sprite.setTextureRect(left);
sprite.move(-19, 0);
//Redeclaring the collision textures
sf::Vector2i spritePosition(sprite.getPosition());
sf::Vector2i housePosition(house.getPosition());
if(collision(spritePosition, rightVector, housePosition, houseVector) == true)
{
sprite.move(19, 0);
bump.play();
}
else
{
footsteps.play();
}
}
//Draw sequence
window.clear(); //(Red, Green, Blue, (optional) Alpha) Alpha is transperency
//Draw....
window.draw(background);
window.draw(house);
window.draw(sprite);
window.display();
std::cout << x << std::endl;
std::cout << y << std::endl;
}
return 0;
}
