void Camera::setCamera(const VisualizationParameterSet& visParams, const int generateCubeMap)
{
// set the camera
if(generateCubeMap > 0)
{
graphicsManager->setCubeMapCamera(generateCubeMap, graphicsManager->reflectionObject ?
graphicsManager->reflectionObject->getPosition() : Vector3d());
return;
}
else
{
Vector3d forwardVec(1.0,0.0,0.0);
Vector3d upVec(0.0,0.0,1.0);
// if the camera is bound to a physical object and motion blur is active
// the camera needs to be transformed across the render passes
if(visParams.mb_mode != MOTIONBLUR_OFF)
{
if(visParams.mb_mode == MOTIONBLUR_6PASSES ||
visParams.mb_mode == MOTIONBLUR_12PASSES ||
visParams.mb_mode == MOTIONBLUR_24PASSES ||
visParams.mb_mode == MOTIONBLUR_ACCUMULATION)
{
if(cycle_order_offset >= 0 && visParams.mb_renderPasses > 1)
{
float pos_offset = cycle_order_offset -
((float)(visParams.mb_currentPass-1.0f)/(visParams.mb_renderPasses-1.0f))*graphicsManager->getExposure2Physic();
GLHelper::getGLH()->setInterpolatedCameraLookAt( previous_positions, previous_rotations, pos_offset);
}
else
GLHelper::getGLH()->setMatrix(position, rotation);
}
else if(visParams.mb_mode == MOTIONBLUR_VELOCITY_BUFFER ||
visParams.mb_mode == MOTIONBLUR_VELOCITY_BUFFER_2 ||
visParams.mb_mode == MOTIONBLUR_VELOCITY_BUFFER_2_GEO)
{
forwardVec.rotate(rotation);
upVec.rotate(rotation);
gluLookAt(position.v[0], position.v[1], position.v[2],
position.v[0] + forwardVec.v[0],
position.v[1] + forwardVec.v[1],
position.v[2] + forwardVec.v[2],
upVec.v[0], upVec.v[1], upVec.v[2]);
}
}
else
{
forwardVec.rotate(rotation);
upVec.rotate(rotation);
gluLookAt(position.v[0], position.v[1], position.v[2],
position.v[0] + forwardVec.v[0],
position.v[1] + forwardVec.v[1],
position.v[2] + forwardVec.v[2],
upVec.v[0], upVec.v[1], upVec.v[2]);
}
}
}
U32 ForestWindEmitter::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
{
U32 retMask = Parent::packUpdate( con, mask, stream );
mathWrite( *stream, mObjToWorld );
if ( stream->writeFlag( mask & EnabledMask ) )
stream->writeFlag( mEnabled );
if ( stream->writeFlag( mask & WindMask ) )
{
stream->write( mWindStrength );
stream->write( mWindRadius );
stream->writeFlag( mRadialEmitter );
stream->write( mWindGustStrength );
stream->write( mWindGustFrequency );
stream->write( mWindGustYawAngle );
stream->write( mWindGustYawFrequency );
stream->write( mWindGustWobbleStrength );
stream->write( mWindTurbulenceStrength );
stream->write( mWindTurbulenceFrequency );
// The wind direction should be normalized!
if ( mWindDirection.isZero() )
{
VectorF forwardVec( 0, 0, 0 );
mWorldToObj.getColumn( 1, &mWindDirection );
}
else
mWindDirection.normalize();
stream->writeNormalVector( mWindDirection, 8 );
stream->writeFlag( mHasMount );
}
return retMask;
}
void Camera::move(float forward, float right, float up, float upAngle, float leftAngle) {
position += vec3(0,up,0);
vec3 forwardVec(
sin(horizontalAngle),
0,
cos(horizontalAngle)
);
vec3 rightVec(
sin(horizontalAngle - 3.14f/2.0f),
0,
cos(horizontalAngle - 3.14f/2.0f)
);
position += forwardVec * forward;
position += rightVec * right;
horizontalAngle += leftAngle;
verticalAngle += upAngle;
updateViewMatrix();
updateProjectionMatrix();
}
void DistanceSensor::renderingInstructions(ImagingBuffer<float>& buffer)
{
// set viewport
glViewport(0, 0, buffer.resolutionX, buffer.resolutionY);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(Functions::toDeg(angleY), tan(angleX/2) / tan(angleY/2), minRange, maxRange);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// clear the viewport
glClearDepth(1.0);
Surface* backgroundSurface = simulation->getBackgroundSurface();
glClearColor(backgroundSurface->color[0], backgroundSurface->color[1],
backgroundSurface->color[2], backgroundSurface->color[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// set the visual parameters
VisualizationParameterSet visParams;
visParams.surfaceStyle = VisualizationParameterSet::FLAT_SHADING;
visParams.drawForSensor = true;
simulation->enableStateDL(visParams.surfaceStyle);
// set the camera
Vector3d forwardVec(1.0,0.0,0.0);
Vector3d upVec(0.0,0.0,1.0);
forwardVec.rotate(rotation);
upVec.rotate(rotation);
gluLookAt(position.v[0], position.v[1], position.v[2],
position.v[0] + forwardVec.v[0], position.v[1] + forwardVec.v[1],
position.v[2] + forwardVec.v[2],
upVec.v[0], upVec.v[1], upVec.v[2]);
glGetDoublev(GL_MODELVIEW_MATRIX, buffer.modelViewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, buffer.projectionMatrix);
glGetIntegerv(GL_VIEWPORT, buffer.viewPort);
rootNode->draw(visParams);
glFlush();
simulation->disableStateDL(visParams.surfaceStyle);
}
void Actor::walkForward() {
float dist = g_grim->getPerSecond(_walkRate);
// Limit the amount of the movement per frame, otherwise with low fps
// scripts that use WalkActorForward and proximity may break.
if ((dist > 0 && dist > _walkRate / 5.f) || (dist < 0 && dist < _walkRate / 5.f))
dist = _walkRate / 5.f;
_walking = false;
if (! _constrain) {
Math::Vector3d forwardVec(-_moveYaw.getSine() * _pitch.getCosine(),
_moveYaw.getCosine() * _pitch.getCosine(), _pitch.getSine());
// EMI: Y is up-down, sectors use an X-Z plane for movement
if (g_grim->getGameType() == GType_MONKEY4) {
float temp = forwardVec.z();
forwardVec.z() = forwardVec.y();
forwardVec.y() = temp;
}
_pos += forwardVec * dist;
_walkedCur = true;
return;
}
bool backwards = false;
if (dist < 0) {
dist = -dist;
backwards = true;
}
int tries = 0;
while (dist > 0.0f) {
Math::Vector3d forwardVec(-_moveYaw.getSine() * _pitch.getCosine(),
_moveYaw.getCosine() * _pitch.getCosine(), _pitch.getSine());
// EMI: Y is up-down, sectors use an X-Z plane for movement
if (g_grim->getGameType() == GType_MONKEY4) {
float temp = forwardVec.z();
forwardVec.z() = forwardVec.y();
forwardVec.y() = temp;
}
if (backwards)
forwardVec = -forwardVec;
Sector *currSector = NULL, *prevSector = NULL, *startSector = NULL;
Sector::ExitInfo ei;
g_grim->getCurrSet()->findClosestSector(_pos, &currSector, &_pos);
if (!currSector) { // Shouldn't happen...
moveTo(_pos + forwardVec * dist);
_walkedCur = true;
return;
}
startSector = currSector;
float oldDist = dist;
while (currSector) {
prevSector = currSector;
Math::Vector3d puckVec = currSector->getProjectionToPuckVector(forwardVec);
puckVec /= puckVec.getMagnitude();
currSector->getExitInfo(_pos, puckVec, &ei);
float exitDist = (ei.exitPoint - _pos).getMagnitude();
if (dist < exitDist) {
moveTo(_pos + puckVec * dist);
_walkedCur = true;
return;
}
_pos = ei.exitPoint;
dist -= exitDist;
if (exitDist > 0.0001)
_walkedCur = true;
// Check for an adjacent sector which can continue
// the path
currSector = g_grim->getCurrSet()->findPointSector(ei.exitPoint + (float)0.0001 * puckVec, Sector::WalkType);
// EMI: some sectors are significantly higher/lower than others.
if (currSector && g_grim->getGameType() == GType_MONKEY4) {
float planeDist = currSector->distanceToPoint(_pos);
if (fabs(planeDist) < 1.f)
_pos -= planeDist * currSector->getNormal();
}
if (currSector == prevSector || currSector == startSector)
break;
}
int turnDir = 1;
if (ei.angleWithEdge > 90) {
ei.angleWithEdge = 180 - ei.angleWithEdge;
ei.edgeDir = -ei.edgeDir;
turnDir = -1;
}
if (ei.angleWithEdge > _reflectionAngle)
return;
ei.angleWithEdge += (float)1.0f;
turnTo(0, _moveYaw + ei.angleWithEdge * turnDir, 0);
if (oldDist <= dist + 0.001f) {
// If we didn't move at all, keep trying a couple more times
// in case we can move in the new direction.
tries++;
if (tries > 3)
break;
}
}
}
