void ShellRenderer::execute(DrawStackArgList arguments) {
// state
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
if(gameGraphics->supportsMultisampling) glEnable(GL_MULTISAMPLE);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_TEXTURE_2D);
// enable shader
glUseProgram(gameGraphics->getProgramID("colorLighting"));
// set uniforms
glUniformMatrix4fv(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "pMatrix"), 1, GL_FALSE, (gameState->binoculars ? gameGraphics->ppBinoMatrixArray : gameGraphics->ppMatrixArray));
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "ambientColor"), 0.15f, 0.15f, 0.15f);
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "diffuseColor"), 0.5f, 0.5f, 0.5f);
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "specularColor"), 0.5f, 0.5f, 0.5f);
Vector4 lightPosition = Vector4(1.0f, 1.0f, -1.0f, 0.0f) * gameGraphics->currentCamera->lightMatrix;
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "lightPosition"), lightPosition.x, lightPosition.y, lightPosition.z);
glUniform1f(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "shininess"), 50.0f);
// set the overall drawing state
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffers["vertices"]);
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "position"), 3, GL_FLOAT, GL_FALSE, 10 * sizeof(GLfloat), (GLvoid*) 0);
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "normal"), 3, GL_FLOAT, GL_FALSE, 10 * sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "color"), 4, GL_FLOAT, GL_FALSE, 10 * sizeof(GLfloat), (GLvoid*) (6 * sizeof(GLfloat)));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "position"));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "normal"));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "color"));
// draw the geometry
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexBuffers["elements"]);
for(size_t i = 0; i < gameState->shells.size(); ++i) {
Matrix4 mvMatrix; mvMatrix.identity();
scaleMatrix(gameState->shellRadius, gameState->shellRadius, gameState->shellRadius, mvMatrix);
translateMatrix(gameState->shells[i].position.x, gameState->shells[i].position.y, gameState->shells[i].position.z, mvMatrix);
mvMatrix = mvMatrix * gameGraphics->currentCamera->mvMatrix;
float mvMatrixArray[] = {
mvMatrix.m11, mvMatrix.m12, mvMatrix.m13, mvMatrix.m14,
mvMatrix.m21, mvMatrix.m22, mvMatrix.m23, mvMatrix.m24,
mvMatrix.m31, mvMatrix.m32, mvMatrix.m33, mvMatrix.m34,
mvMatrix.m41, mvMatrix.m42, mvMatrix.m43, mvMatrix.m44
};
glUniformMatrix4fv(glGetUniformLocation(gameGraphics->getProgramID("colorLighting"), "mvMatrix"), 1, GL_FALSE, mvMatrixArray);
glDrawElements(GL_TRIANGLES, sphere.faceGroups[""].size() * 3, GL_UNSIGNED_INT, NULL);
}
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "position"));
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "normal"));
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorLighting"), "color"));
}
Matrix generateTransform(const TwoPoints *source, const TwoPoints *dest, int reflect){
double sourceMidX = (source->x1 + source->x2)*0.5;
double sourceMidY = (source->y1 + source->y2)*0.5;
double destMidX = (dest->x1 + dest->x2)*0.5;
double destMidY = (dest->y1 + dest->y2)*0.5;
Matrix translate1 = translateMatrix(-sourceMidX, -sourceMidY); /* translate the left point to the origin */
Matrix translate2 = translateMatrix(destMidX, destMidY); /* translate the origin to the left destination */
/* compute the scale that needs to be applyed to the image */
double sdist = sqrt(SQR(source->x1 - source->x2) + SQR(source->y1 - source->y2));
double ddist = sqrt(SQR(dest->x1 - dest->x2) + SQR(dest->y1 - dest->y2));
double s = ddist/sdist;
Matrix scale = scaleMatrix(s);
/* compute the rotation that needs to be applyed to the image */
double stheta = atan((source->y2 -source->y1)/(source->x2 - source->x1));
double dtheta = atan((dest->y2 -dest->y1)/(dest->x2 - dest->x1));
double theta = dtheta - stheta;
Matrix rotate = rotateMatrix(theta);
/* compute the reflection if nessicary */
Matrix reflection = reflectMatrix(reflect,0);
/* build the final transformation */
Matrix tmp1 = multiplyMatrix(scale, translate1);
Matrix tmp2 = multiplyMatrix(rotate, tmp1);
Matrix tmp3 = multiplyMatrix(reflection, tmp2);
Matrix transform = multiplyMatrix(translate2,tmp3);
/* free temporary matricies */
freeMatrix(translate1);
freeMatrix(translate2);
freeMatrix(scale);
freeMatrix(rotate);
freeMatrix(reflection);
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
/* return final transformation */
return transform;
}
void warpPlayer(portal_s* p, player_s* pl)
{
if(!p || !pl)return;
camera_s* c = &pl->camera;
camera_s new_camera = *c;
if(gravityGunObject)gravityGunObject = NULL; // TEMP : TODO better solution
float tmp1[4*4], tmp2[4*4];
transposeMatrix44(p->target->matrix, tmp1);
new_camera.position = vaddf(p->target->position, warpPortalVector(p, vsubf(c->position, p->position)));
multMatrix44((float*)new_camera.orientation, p->matrix, tmp2);
rotateMatrixY(tmp1, M_PI, true);
multMatrix44(tmp2, tmp1, (float*)new_camera.orientation);
memcpy(new_camera.modelview, new_camera.orientation, sizeof(mtx44));
translateMatrix((float*)new_camera.modelview, -new_camera.position.x, -new_camera.position.y, -new_camera.position.z);
pl->object.position = new_camera.position;
pl->object.speed = warpPortalVector(p, pl->object.speed);
*c = new_camera;
}
static void set3DView()
{
static const float nearZ = 0.01f, farZ = 100.0f;
mtx44 projection, modelView;
// standard perspective projection
initProjectionMatrix((float*) projection, 80.0f*M_PI/180.0f, 240.0f/400.0f, nearZ, farZ);
rotateMatrixZ((float*) projection, M_PI/2, false); //because framebuffer is sideways...
glPerspectiveProjectionMatrixfCTR((float*) projection,
nearZ, // must match the value passed to initProjectionMatrix
-5.0f, // depth of the plane that will converge at screen depth in stereo,
// e.g. everything further will be behind the screen, everything closer will pop out
0.2f // determine experimentally; allows you to mix multiple views in one coherent stereo
);
// poor man's camera control
loadIdentity44((float*) modelView);
translateMatrix((float*) modelView, position.x, position.y, position.z);
rotateMatrixX((float*) modelView, angle.x, false);
rotateMatrixY((float*) modelView, angle.y, false);
glModelviewMatrixfCTR((float*) modelView);
}
void ShipRenderer::execute(DrawStackArgList arguments) {
// state
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
if(gameGraphics->supportsMultisampling) glEnable(GL_MULTISAMPLE);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_TEXTURE_2D);
// enable shader
glUseProgram(gameGraphics->getProgramID("colorTextureLighting"));
// set uniforms
glUniform1i(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "texture"), 0);
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "ambientColor"), 0.15f, 0.15f, 0.15f);
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "diffuseColor"), 0.5f, 0.5f, 0.5f);
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "specularColor"), 0.8f, 0.8f, 0.8f);
Vector4 lightPosition = Vector4(1.0f, 1.0f, -1.0f, 0.0f) * gameGraphics->currentCamera->lightMatrix;
glUniform3f(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "lightPosition"), lightPosition.x, lightPosition.y, lightPosition.z);
glUniform1f(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "shininess"), 10.0f);
// set the overall drawing state
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffers["vertices"]);
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "position"), 3, GL_FLOAT, GL_FALSE, 12 * sizeof(GLfloat), (GLvoid*) 0);
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "normal"), 3, GL_FLOAT, GL_FALSE, 12 * sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "texCoord"), 2, GL_FLOAT, GL_FALSE, 12 * sizeof(GLfloat), (GLvoid*) (6 * sizeof(GLfloat)));
glVertexAttribPointer(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "color"), 4, GL_FLOAT, GL_FALSE, 12 * sizeof(GLfloat), (GLvoid*) (8 * sizeof(GLfloat)));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "position"));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "normal"));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "texCoord"));
glEnableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "color"));
for(size_t i = 0; i < gameState->ships.size(); ++i) {
// calculate the matrix for this ship position
Matrix4 shipMatrix; shipMatrix.identity();
rotateMatrix(Vector3(0.0f, 1.0f, 0.0f), radians(gameState->ships[i].rotation), shipMatrix);
translateMatrix(gameState->ships[i].position.x, gameState->ships[i].position.y, gameState->ships[i].position.z, shipMatrix);
Matrix4 mvMatrix = shipMatrix * gameGraphics->currentCamera->mvMatrix;
float mvMatrixArray[] = {
mvMatrix.m11, mvMatrix.m12, mvMatrix.m13, mvMatrix.m14,
mvMatrix.m21, mvMatrix.m22, mvMatrix.m23, mvMatrix.m24,
mvMatrix.m31, mvMatrix.m32, mvMatrix.m33, mvMatrix.m34,
mvMatrix.m41, mvMatrix.m42, mvMatrix.m43, mvMatrix.m44
};
// draw the ship
for(
std::map<std::string, std::vector<Mesh::Face> >::iterator itr =
shipMesh.faceGroups.begin();
itr != shipMesh.faceGroups.end();
++itr
) {
// don't draw the missile origin or submerged portion
if(itr->first == "missileorigin" || itr->first == "submerged")
continue;
// set the texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gameGraphics->getTextureID(std::string("structure/" + itr->first).c_str()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glUniformMatrix4fv(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "mvMatrix"), 1, GL_FALSE, mvMatrixArray);
glUniformMatrix4fv(glGetUniformLocation(gameGraphics->getProgramID("colorTextureLighting"), "pMatrix"), 1, GL_FALSE, (gameState->binoculars ? gameGraphics->ppBinoMatrixArray : gameGraphics->ppMatrixArray));
// draw the geometry
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexBuffers[std::string("elements_" + itr->first).c_str()]);
glDrawElements(GL_TRIANGLES, itr->second.size() * 3, GL_UNSIGNED_INT, NULL);
}
}
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "position"));
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "normal"));
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "texCoord"));
glDisableVertexAttribArray(glGetAttribLocation(gameGraphics->getProgramID("colorTextureLighting"), "color"));
}
void MapMatrix::createMatrix(const QSize& newSize)
{
const QPoint tempPoint(wgsToMap(mapCenterLat, mapCenterLon));
/* Set rotating and scaling */
const double scale = MAX_SCALE / cScale;
rotationArc = currentProjection->getRotationArc(tempPoint.x(), tempPoint.y());
// qDebug("rotationArc: %f", rotationArc);
double sinscaled = sin(rotationArc) * scale;
double cosscaled = cos(rotationArc) * scale;
worldMatrix = QTransform( cosscaled, sinscaled, -sinscaled, cosscaled, 0, 0 );
/* Set the translation */
const QPoint map = worldMatrix.map(tempPoint);
QTransform translateMatrix( 1, 0, 0, 1,
currentProjection->getTranslationX(newSize.width(),map.x()),
currentProjection->getTranslationY(newSize.height(),map.y()));
worldMatrix *= translateMatrix;
//trying to rotate around center
/*
QPoint curProjCenter= worldMatrix * QPoint(mapCenterLat, mapCenterLon);
worldMatrix.translate(-curProjCenter.x(),-curProjCenter.y());
worldMatrix.rotate(180);
worldMatrix.translate(curProjCenter.x(),curProjCenter.y());
*/
// Setting the viewBorder
bool result = true;
invertMatrix = worldMatrix.inverted( &result );
if( !result )
{
// Houston, wir haben ein Problem !!!
qFatal("Cumulus: Cannot invert worldMatrix! File=%s, Line=%d", __FILE__, __LINE__);
}
// Die Berechnung der Kartengrenze funktioniert so nur auf der
// Nordhalbkugel. Auf der Südhalbkugel stimmen die Werte nur
// näherungsweise.
//
QPoint tCenter = __mapToWgs(invertMatrix.map(QPoint(newSize.width() / 2, 0)));
QPoint tlCorner = __mapToWgs(invertMatrix.map(QPoint(0, 0)));
QPoint trCorner = __mapToWgs(invertMatrix.map(QPoint(newSize.width(), 0)));
QPoint blCorner = __mapToWgs(invertMatrix.map(QPoint(0, newSize.height())));
QPoint brCorner = __mapToWgs(invertMatrix.map(QPoint(newSize.width(),newSize.height())));
viewBorder.setTop(tCenter.y());
viewBorder.setLeft(tlCorner.x());
viewBorder.setRight(trCorner.x());
viewBorder.setBottom( qMin(blCorner.y(), brCorner.y()) );
mapBorder = invertMatrix.mapRect( QRect( 0, 0, newSize.width(), newSize.height() ) );
mapViewSize = newSize;
//create the map center area definition
int vqDist = -viewBorder.height() / 5;
int hqDist = viewBorder.width() / 5;
mapCenterArea=QRect(mapCenterLat - vqDist, mapCenterLon - hqDist, 2* vqDist, 2* hqDist);
vqDist = mapBorder.height() / 5;
hqDist = mapBorder.width() / 5;
mapCenterAreaProj=QRect(tempPoint.x() - vqDist,
tempPoint.y() - hqDist,
2* vqDist, 2* hqDist);
// fixed math mapping value assignment
m11 = (fp24p8_t)( worldMatrix.m11() * 16777216.0 );
m12 = (fp24p8_t)( worldMatrix.m12() * 16777216.0 );
m21 = (fp24p8_t)( worldMatrix.m21() * 16777216.0 );
m22 = (fp24p8_t)( worldMatrix.m22() * 16777216.0 );
dx = dtofp24p8( worldMatrix.dx() );
dy = dtofp24p8( worldMatrix.dy() );
emit displayMatrixValues(getScaleRange(), isSwitchScale());
}
inline Matrix4f toMatrix() {
return translateMatrix(position) * rotation.toMatrix() * scaleMatrix(scale);
}
inline Matrix4f getView() const {
return scaleMatrix(
{transform.scale.x, transform.scale.y, transform.scale.z}) *
transform.rotation.toMatrix() * translateMatrix(-transform.position);
}
