mirror of
https://github.com/tribes2/engine.git
synced 2026-01-20 19:54:46 +00:00
964 lines
26 KiB
C++
964 lines
26 KiB
C++
//-----------------------------------------------------------------------------
|
|
// V12 Engine
|
|
//
|
|
// Copyright (c) 2001 GarageGames.Com
|
|
// Portions Copyright (c) 2001 by Sierra Online, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "console/consoleTypes.h"
|
|
#include "dgl/dgl.h"
|
|
#include "platformWIN32/platformGL.h"
|
|
#include "platform/platformAudio.h"
|
|
#include "audio/audioDataBlock.h"
|
|
#include "scenegraph/sceneGraph.h"
|
|
#include "scenegraph/sceneState.h"
|
|
#include "core/bitStream.h"
|
|
#include "game/particleEngine.h"
|
|
#include "game/shockwave.h"
|
|
#include "math/mathIO.h"
|
|
#include "terrain/terrData.h"
|
|
#include "math/mathUtils.h"
|
|
#include "sim/netConnection.h"
|
|
|
|
IMPLEMENT_CO_DATABLOCK_V1(ShockwaveData);
|
|
IMPLEMENT_CO_NETOBJECT_V1(Shockwave);
|
|
|
|
namespace
|
|
{
|
|
|
|
MRandomLCG sgRandom(0xdeadbeef);
|
|
|
|
} // namespace {}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//--------------------------------------
|
|
//
|
|
|
|
ShockwaveData::ShockwaveData()
|
|
{
|
|
soundProfile = NULL;
|
|
soundProfileId = 0;
|
|
|
|
scale.set(1, 1, 1);
|
|
|
|
dMemset( emitterList, 0, sizeof( emitterList ) );
|
|
dMemset( emitterIDList, 0, sizeof( emitterIDList ) );
|
|
|
|
delayMS = 0;
|
|
delayVariance = 0;
|
|
lifetimeMS = 1000;
|
|
lifetimeVariance = 0;
|
|
width = 4.0;
|
|
numSegments = 10;
|
|
velocity = 30.0;
|
|
height = 0.0;
|
|
numVertSegments = 1;
|
|
verticalCurve = 1.0;
|
|
acceleration = 0.0;
|
|
texWrap = 1.0;
|
|
is2D = false;
|
|
mapToTerrain = true;
|
|
orientToNormal = false;
|
|
renderBottom = false;
|
|
renderSquare = false;
|
|
|
|
dMemset( textureName, 0, sizeof( textureName ) );
|
|
|
|
U32 i;
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
times[i] = 1.0;
|
|
}
|
|
times[0] = 0.0;
|
|
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
colors[i].set( 1.0, 1.0, 1.0, 1.0 );
|
|
}
|
|
}
|
|
|
|
IMPLEMENT_SETDATATYPE(ShockwaveData)
|
|
IMPLEMENT_GETDATATYPE(ShockwaveData)
|
|
|
|
void ShockwaveData::initPersistFields()
|
|
{
|
|
Parent::initPersistFields();
|
|
|
|
Con::registerType(TypeShockwaveDataPtr, sizeof(ShockwaveData*),
|
|
REF_GETDATATYPE(ShockwaveData),
|
|
REF_SETDATATYPE(ShockwaveData));
|
|
|
|
addField("soundProfile", TypeAudioProfilePtr, Offset(soundProfile, ShockwaveData));
|
|
addField("scale", TypePoint3F, Offset(scale, ShockwaveData));
|
|
addField("emitter", TypeParticleEmitterDataPtr, Offset(emitterList, ShockwaveData), NUM_EMITTERS);
|
|
addField("delayMS", TypeS32, Offset(delayMS, ShockwaveData));
|
|
addField("delayVariance", TypeS32, Offset(delayVariance, ShockwaveData));
|
|
addField("lifetimeMS", TypeS32, Offset(lifetimeMS, ShockwaveData));
|
|
addField("lifetimeVariance", TypeS32, Offset(lifetimeVariance, ShockwaveData));
|
|
addField("width", TypeF32, Offset(width, ShockwaveData));
|
|
addField("numSegments", TypeS32, Offset(numSegments, ShockwaveData));
|
|
addField("numVertSegments", TypeS32, Offset(numVertSegments, ShockwaveData));
|
|
addField("velocity", TypeF32, Offset(velocity, ShockwaveData));
|
|
addField("height", TypeF32, Offset(height, ShockwaveData));
|
|
addField("verticalCurve", TypeF32, Offset(verticalCurve, ShockwaveData));
|
|
addField("acceleration", TypeF32, Offset(acceleration, ShockwaveData));
|
|
addField("times", TypeF32, Offset(times, ShockwaveData), NUM_TIME_KEYS);
|
|
addField("colors", TypeColorF, Offset(colors, ShockwaveData), NUM_TIME_KEYS);
|
|
addField("texture", TypeString, Offset(textureName, ShockwaveData), NUM_TEX);
|
|
addField("texWrap", TypeF32, Offset(texWrap, ShockwaveData));
|
|
addField("is2D", TypeBool, Offset(is2D, ShockwaveData));
|
|
addField("mapToTerrain", TypeBool, Offset(mapToTerrain, ShockwaveData));
|
|
addField("orientToNormal", TypeBool, Offset(orientToNormal, ShockwaveData));
|
|
addField("renderBottom", TypeBool, Offset(renderBottom, ShockwaveData));
|
|
addField("renderSquare", TypeBool, Offset(renderSquare, ShockwaveData));
|
|
|
|
}
|
|
|
|
bool ShockwaveData::onAdd()
|
|
{
|
|
if (Parent::onAdd() == false)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void ShockwaveData::packData(BitStream* stream)
|
|
{
|
|
Parent::packData(stream);
|
|
|
|
mathWrite(*stream, scale);
|
|
stream->write(delayMS);
|
|
stream->write(delayVariance);
|
|
stream->write(lifetimeMS);
|
|
stream->write(lifetimeVariance);
|
|
stream->write(width);
|
|
stream->write(numSegments);
|
|
stream->write(numVertSegments);
|
|
stream->write(velocity);
|
|
stream->write(height);
|
|
stream->write(verticalCurve);
|
|
stream->write(acceleration);
|
|
stream->write(texWrap);
|
|
stream->write(is2D);
|
|
stream->write(orientToNormal);
|
|
stream->write(mapToTerrain);
|
|
stream->write(renderBottom);
|
|
stream->write(renderSquare);
|
|
|
|
S32 i;
|
|
for( i=0; i<NUM_EMITTERS; i++ )
|
|
{
|
|
if( stream->writeFlag( emitterList[i] != NULL ) )
|
|
{
|
|
stream->writeRangedU32( emitterList[i]->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast );
|
|
}
|
|
}
|
|
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
stream->write( colors[i] );
|
|
}
|
|
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
stream->write( times[i] );
|
|
}
|
|
|
|
for( i=0; i<NUM_TEX; i++ )
|
|
{
|
|
if( textureName[i][0] )
|
|
{
|
|
stream->writeString(textureName[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShockwaveData::unpackData(BitStream* stream)
|
|
{
|
|
Parent::unpackData(stream);
|
|
|
|
mathRead(*stream, &scale);
|
|
stream->read(&delayMS);
|
|
stream->read(&delayVariance);
|
|
stream->read(&lifetimeMS);
|
|
stream->read(&lifetimeVariance);
|
|
stream->read(&width);
|
|
stream->read(&numSegments);
|
|
stream->read(&numVertSegments);
|
|
stream->read(&velocity);
|
|
stream->read(&height);
|
|
stream->read(&verticalCurve);
|
|
stream->read(&acceleration);
|
|
stream->read(&texWrap);
|
|
stream->read(&is2D);
|
|
stream->read(&orientToNormal);
|
|
stream->read(&mapToTerrain);
|
|
stream->read(&renderBottom);
|
|
stream->read(&renderSquare);
|
|
|
|
U32 i;
|
|
for( i=0; i<NUM_EMITTERS; i++ )
|
|
{
|
|
if( stream->readFlag() )
|
|
{
|
|
emitterIDList[i] = stream->readRangedU32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
|
|
}
|
|
}
|
|
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
stream->read( &colors[i] );
|
|
}
|
|
|
|
for( i=0; i<NUM_TIME_KEYS; i++ )
|
|
{
|
|
stream->read( ×[i] );
|
|
}
|
|
|
|
for( i=0; i<NUM_TEX; i++ )
|
|
{
|
|
textureName[i] = stream->readSTString();
|
|
}
|
|
}
|
|
|
|
bool ShockwaveData::preload(bool server, char errorBuffer[256])
|
|
{
|
|
if (Parent::preload(server, errorBuffer) == false)
|
|
return false;
|
|
|
|
if (!server) {
|
|
S32 i;
|
|
for( i=0; i<NUM_EMITTERS; i++ )
|
|
{
|
|
if( !emitterList[i] && emitterIDList[i] != 0 )
|
|
{
|
|
if( Sim::findObject( emitterIDList[i], emitterList[i] ) == false)
|
|
{
|
|
Con::errorf( ConsoleLogEntry::General, "ShockwaveData::onAdd: Invalid packet, bad datablockId(particle emitter): 0x%x", emitterIDList[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
for( i=0; i<NUM_TEX; i++ )
|
|
{
|
|
if (textureName[i] && textureName[i][0])
|
|
{
|
|
textureHandle[i] = TextureHandle(textureName[i], MeshTexture );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Shockwave
|
|
//--------------------------------------------------------------------------
|
|
Shockwave::Shockwave()
|
|
{
|
|
dMemset( mEmitterList, 0, sizeof( mEmitterList ) );
|
|
|
|
mDelayMS = 0;
|
|
mCurrMS = 0;
|
|
mEndingMS = 1000;
|
|
mActive = false;
|
|
mRadius = 0.0;
|
|
mVelocity = 1.0;
|
|
mHeight = 0.0;
|
|
mDataBlock = NULL;
|
|
|
|
mInitialPosition.set( 0.0, 0.0, 0.0 );
|
|
mInitialNormal.set( 0.0, 0.0, 1.0 );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Destructor
|
|
//--------------------------------------------------------------------------
|
|
Shockwave::~Shockwave()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Set initial state
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::setInitialState(const Point3F& point, const Point3F& normal, const F32 fade)
|
|
{
|
|
mInitialPosition = point;
|
|
mInitialNormal = normal;
|
|
mFade = fade;
|
|
mFog = 0.0f;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Init persist fields
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::initPersistFields()
|
|
{
|
|
Parent::initPersistFields();
|
|
|
|
addField("pos", TypePoint3F, Offset(mInitialPosition, Shockwave));
|
|
addField("normal", TypePoint3F, Offset(mInitialNormal, Shockwave));
|
|
|
|
//
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CONSOLE commands
|
|
//--------------------------------------------------------------------------
|
|
static void cSetInitialState(SimObject *obj, S32, const char** argv)
|
|
{
|
|
|
|
Shockwave* shock = static_cast<Shockwave*>(obj);
|
|
if( !shock ) return;
|
|
|
|
Point3F pos;
|
|
dSscanf( argv[2], "%f %f %f", &pos.x, &pos.y, &pos.z );
|
|
|
|
Point3F dir;
|
|
dSscanf( argv[3], "%f %f %f", &dir.x, &dir.y, &dir.z );
|
|
|
|
shock->setInitialState( pos, dir );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Console Init
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::consoleInit()
|
|
{
|
|
Con::addCommand("Shockwave", "setInitialState", cSetInitialState, "startFade( pos, normal )", 4, 4);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// OnAdd
|
|
//--------------------------------------------------------------------------
|
|
bool Shockwave::onAdd()
|
|
{
|
|
if(!Parent::onAdd())
|
|
return false;
|
|
|
|
mDelayMS = mDataBlock->delayMS + sgRandom.randI( -mDataBlock->delayVariance, mDataBlock->delayVariance );
|
|
mEndingMS = mDataBlock->lifetimeMS + sgRandom.randI( -mDataBlock->lifetimeVariance, mDataBlock->lifetimeVariance );
|
|
|
|
mVelocity = mDataBlock->velocity;
|
|
mHeight = mDataBlock->height;
|
|
|
|
mObjBox.min = Point3F( -1, -1, -1 );
|
|
mObjBox.max = Point3F( 1, 1, 1 );
|
|
resetWorldBox();
|
|
|
|
gClientContainer.addObject(this);
|
|
gClientSceneGraph->addObjectToScene(this);
|
|
|
|
removeFromProcessList();
|
|
gClientProcessList.addObject(this);
|
|
|
|
MatrixF trans(true);
|
|
trans.setPosition( mInitialPosition );
|
|
setTransform( trans );
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// OnRemove
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::onRemove()
|
|
{
|
|
for( int i=0; i<ShockwaveData::NUM_EMITTERS; i++ )
|
|
{
|
|
if( mEmitterList[i] )
|
|
{
|
|
mEmitterList[i]->deleteWhenEmpty();
|
|
mEmitterList[i] = NULL;
|
|
}
|
|
}
|
|
|
|
mSceneManager->removeObjectFromScene(this);
|
|
getContainer()->removeObject(this);
|
|
|
|
Parent::onRemove();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// On New Data Block
|
|
//--------------------------------------------------------------------------
|
|
bool Shockwave::onNewDataBlock(GameBaseData* dptr)
|
|
{
|
|
mDataBlock = dynamic_cast<ShockwaveData*>(dptr);
|
|
if (!mDataBlock || !Parent::onNewDataBlock(dptr))
|
|
return false;
|
|
|
|
scriptOnNewDataBlock();
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Prep render image
|
|
//--------------------------------------------------------------------------
|
|
bool Shockwave::prepRenderImage(SceneState* state, const U32 stateKey,
|
|
const U32 /*startZone*/, const bool /*modifyBaseState*/)
|
|
{
|
|
if (isLastState(state, stateKey))
|
|
return false;
|
|
setLastState(state, stateKey);
|
|
|
|
// This should be sufficient for most objects that don't manage zones, and
|
|
// don't need to return a specialized RenderImage...
|
|
if (state->isObjectRendered(this)) {
|
|
mFog = 0.0;
|
|
|
|
SceneRenderImage* image = new SceneRenderImage;
|
|
image->obj = this;
|
|
image->isTranslucent = true;
|
|
image->sortType = SceneRenderImage::Point;
|
|
state->setImageRefPoint(this, image);
|
|
state->insertRenderImage(image);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Render
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::renderObject(SceneState* state, SceneRenderImage*)
|
|
{
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on entry");
|
|
|
|
RectI viewport;
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
dglGetViewport(&viewport);
|
|
|
|
state->setupObjectProjection(this);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
if( mDataBlock->is2D )
|
|
{
|
|
render2DWave();
|
|
}
|
|
else
|
|
{
|
|
if( mDataBlock->renderSquare )
|
|
{
|
|
renderSquare();
|
|
}
|
|
else
|
|
{
|
|
renderWave();
|
|
}
|
|
}
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
dglSetViewport(viewport);
|
|
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on exit");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Process tick
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::processTick(const Move*)
|
|
{
|
|
mCurrMS += TickMs;
|
|
|
|
if( isServerObject() )
|
|
{
|
|
if( mCurrMS >= mEndingMS )
|
|
{
|
|
deleteObject();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// set object box
|
|
F32 outerRad = mRadius + mDataBlock->width * 0.5;
|
|
mObjBox.min = Point3F( -outerRad, -outerRad, -outerRad );
|
|
mObjBox.max = Point3F( outerRad, outerRad, outerRad );
|
|
resetWorldBox();
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Advance time
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::advanceTime(F32 dt)
|
|
{
|
|
if (dt == 0.0)
|
|
return;
|
|
|
|
updateColor();
|
|
updateWave( dt );
|
|
updateEmitters( dt );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Update emitters
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::updateEmitters( F32 dt )
|
|
{
|
|
Point3F pos = getPosition();
|
|
|
|
for( int i=0; i<ShockwaveData::NUM_EMITTERS; i++ )
|
|
{
|
|
if( mEmitterList[i] )
|
|
{
|
|
mEmitterList[i]->emitParticles( pos, pos, mInitialNormal, Point3F( 0.0, 0.0, 0.0 ), dt * 1000 );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Update wave
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::updateWave( F32 dt )
|
|
{
|
|
mVelocity += mDataBlock->acceleration * dt;
|
|
mRadius += mVelocity * dt;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Render wave
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::renderWave()
|
|
{
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
MatrixF orient(true);
|
|
|
|
if( mDataBlock->orientToNormal )
|
|
{
|
|
MatrixF rotMatrix( EulerF( M_PI/2.0, 0.0, 0.0 ) );
|
|
|
|
// set up gl modelview matrix
|
|
orient = MathUtils::createOrientFromDir( mInitialNormal );
|
|
orient.mul( rotMatrix );
|
|
}
|
|
|
|
orient.setPosition( mInitialPosition );
|
|
dglMultMatrix( &orient );
|
|
|
|
|
|
const F32 minGroundHeight = 0.1;
|
|
|
|
F32 innerRad = mRadius - mDataBlock->width * 0.5;
|
|
F32 outerRad = mRadius + mDataBlock->width * 0.5;
|
|
|
|
if( innerRad < 0.0 ) innerRad = 0.0;
|
|
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
glDepthMask(GL_FALSE);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
|
|
F32 texFactor = mDataBlock->texWrap;
|
|
|
|
F32 pt = 0.0;
|
|
F32 t = 0.0;
|
|
|
|
for( U32 i=1; i<mDataBlock->numSegments+1; i++ )
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, mDataBlock->textureHandle[0].getGLName());
|
|
|
|
pt = t;
|
|
t = F32(i) / F32(mDataBlock->numSegments);
|
|
|
|
Point3F vert[2];
|
|
vert[0].x = mSin( pt * M_PI * 2.0 );
|
|
vert[0].y = mCos( pt * M_PI * 2.0 );
|
|
vert[0].z = 0.0;
|
|
vert[1].x = mSin( t * M_PI * 2.0 );
|
|
vert[1].y = mCos( t * M_PI * 2.0 );
|
|
vert[1].z = 0.0;
|
|
|
|
Point3F outerPts[2];
|
|
Point3F innerPts[2];
|
|
|
|
glBegin( GL_QUADS );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( t * texFactor, 0.95 );
|
|
Point3F pnt = mInitialPosition + vert[1] * innerRad;
|
|
pnt.z = findHeight( pnt ) + minGroundHeight;
|
|
innerPts[0] = pnt;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( pt * texFactor, 0.95 );
|
|
pnt = mInitialPosition + vert[0] * innerRad;
|
|
pnt.z = findHeight( pnt ) + minGroundHeight;
|
|
innerPts[1] = pnt;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( pt * texFactor, 0.05 );
|
|
pnt = mInitialPosition + vert[0] * outerRad;
|
|
pnt.z = findHeight( pnt ) + minGroundHeight;
|
|
outerPts[0] = pnt;
|
|
pnt.z += mHeight;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( t * texFactor, 0.05 );
|
|
pnt = mInitialPosition + vert[1] * outerRad;
|
|
pnt.z = findHeight( pnt ) + minGroundHeight;
|
|
outerPts[1] = pnt;
|
|
pnt.z += mHeight;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
if( mDataBlock->renderBottom )
|
|
{
|
|
glTexCoord2f( t * texFactor, 0.05 );
|
|
glVertex3fv( outerPts[1] - mInitialPosition );
|
|
glTexCoord2f( pt * texFactor, 0.05 );
|
|
glVertex3fv( outerPts[0] - mInitialPosition );
|
|
glTexCoord2f( pt * texFactor, 0.95 );
|
|
glVertex3fv( innerPts[1] - mInitialPosition );
|
|
glTexCoord2f( t * texFactor, 0.95 );
|
|
glVertex3fv( innerPts[0] - mInitialPosition );
|
|
}
|
|
|
|
glEnd();
|
|
|
|
renderVerticalWall( outerPts[1], outerPts[0] );
|
|
|
|
}
|
|
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glDisable(GL_BLEND);
|
|
glDepthMask(GL_TRUE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Render vertical wall
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::renderVerticalWall( Point3F &pnt1, Point3F pnt2 )
|
|
{
|
|
Point3F p1 = pnt1;
|
|
Point3F p2 = pnt2;
|
|
|
|
p1.z += mHeight * 0.5;
|
|
p2.z += mHeight * 0.5;
|
|
|
|
Point3F dir1, dir2;
|
|
dir1 = p1 - mInitialPosition;
|
|
dir1.z = 0.0;
|
|
dir1.normalize();
|
|
dir2 = p2 - mInitialPosition;
|
|
dir2.z = 0.0;
|
|
dir2.normalize();
|
|
|
|
F32 vertRadius = mHeight * 0.5;
|
|
|
|
glBindTexture(GL_TEXTURE_2D, mDataBlock->textureHandle[1].getGLName());
|
|
|
|
glBegin( GL_QUAD_STRIP );
|
|
|
|
for( U32 i=0; i<mDataBlock->numVertSegments+1; i++ )
|
|
{
|
|
F32 t = F32(i) / F32(mDataBlock->numVertSegments);
|
|
|
|
glColor4f( mColor.red, mColor.green, mColor.blue, mColor.alpha );
|
|
|
|
F32 v = t;
|
|
|
|
if( mDataBlock->renderBottom )
|
|
{
|
|
v = 0.0;
|
|
}
|
|
else
|
|
{
|
|
if( v < 0.05 ) v = 0.05;
|
|
if( v > .95 ) v = 0.95;
|
|
}
|
|
|
|
glTexCoord2f( 0.0, v );
|
|
|
|
Point3F pnt = p1;
|
|
pnt.z += mCos( t * M_PI ) * vertRadius;
|
|
pnt += dir1 * mSin( t * M_PI ) * mDataBlock->verticalCurve;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
glTexCoord2f( 1.0, v );
|
|
|
|
pnt = p2;
|
|
pnt.z += mCos( t * M_PI ) * vertRadius;
|
|
pnt += dir2 * mSin( t * M_PI ) * mDataBlock->verticalCurve;
|
|
glVertex3fv( pnt - mInitialPosition );
|
|
|
|
}
|
|
|
|
glEnd();
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Find height
|
|
//----------------------------------------------------------------------------
|
|
F32 Shockwave::findHeight( Point3F &point )
|
|
{
|
|
if( mDataBlock->mapToTerrain )
|
|
{
|
|
TerrainBlock* pTerrain = mSceneManager->getCurrentTerrain();
|
|
if( !pTerrain ) return 0.0;
|
|
|
|
Point3F terrPt = point;
|
|
pTerrain->getWorldTransform().mulP(terrPt);
|
|
F32 h;
|
|
if (pTerrain->getHeight(Point2F(terrPt.x, terrPt.y), &h))
|
|
{
|
|
return h;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return point.z;
|
|
}
|
|
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Update color
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::updateColor()
|
|
{
|
|
F32 t = F32(mCurrMS) / F32(mEndingMS);
|
|
|
|
for( U32 i = 1; i < ShockwaveData::NUM_TIME_KEYS; i++ )
|
|
{
|
|
if( mDataBlock->times[i] >= t )
|
|
{
|
|
F32 firstPart = t - mDataBlock->times[i-1];
|
|
F32 total = (mDataBlock->times[i] -
|
|
mDataBlock->times[i-1]);
|
|
|
|
firstPart /= total;
|
|
|
|
mColor.interpolate( mDataBlock->colors[i-1],
|
|
mDataBlock->colors[i],
|
|
firstPart);
|
|
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Render billboarded shockwave
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::render2DWave()
|
|
{
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
// set up gl modelview matrix
|
|
MatrixF camTrans;
|
|
dglGetModelview(&camTrans);
|
|
Point3F camLookDir;
|
|
camTrans.getRow(1, &camLookDir);
|
|
Point3F negCamDir = -camLookDir;
|
|
MatrixF billBoard = MathUtils::createOrientFromDir( negCamDir );
|
|
billBoard.setPosition( getPosition() );
|
|
dglMultMatrix( &billBoard );
|
|
|
|
|
|
const F32 minGroundHeight = 0.1;
|
|
|
|
F32 innerRad = mRadius - mDataBlock->width * 0.5;
|
|
F32 outerRad = mRadius + mDataBlock->width * 0.5;
|
|
|
|
if( innerRad < 0.0 ) innerRad = 0.0;
|
|
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
glDepthMask(GL_FALSE);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
|
|
F32 texFactor = mDataBlock->texWrap;
|
|
|
|
F32 pt = 0.0;
|
|
F32 t = 0.0;
|
|
|
|
for( U32 i=1; i<mDataBlock->numSegments+1; i++ )
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, mDataBlock->textureHandle[0].getGLName());
|
|
|
|
pt = t;
|
|
t = F32(i) / F32(mDataBlock->numSegments);
|
|
|
|
Point3F vert[2];
|
|
vert[0].x = mSin( pt * M_PI * 2.0 );
|
|
vert[0].z = mCos( pt * M_PI * 2.0 );
|
|
vert[0].y = 0.0;
|
|
vert[1].x = mSin( t * M_PI * 2.0 );
|
|
vert[1].z = mCos( t * M_PI * 2.0 );
|
|
vert[1].y = 0.0;
|
|
|
|
Point3F outerPts[2];
|
|
|
|
glBegin( GL_QUADS );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( t * texFactor, 0.95 );
|
|
Point3F pnt = vert[1] * innerRad;
|
|
glVertex3fv( pnt );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( pt * texFactor, 0.95 );
|
|
pnt = vert[0] * innerRad;
|
|
glVertex3fv( pnt );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( pt * texFactor, 0.05 );
|
|
pnt = vert[0] * outerRad;
|
|
outerPts[0] = pnt;
|
|
glVertex3fv( pnt );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( t * texFactor, 0.05 );
|
|
pnt = vert[1] * outerRad;
|
|
outerPts[1] = pnt;
|
|
glVertex3fv( pnt );
|
|
|
|
glEnd();
|
|
|
|
}
|
|
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glDisable(GL_BLEND);
|
|
glDepthMask(GL_TRUE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Render wave
|
|
//----------------------------------------------------------------------------
|
|
void Shockwave::renderSquare()
|
|
{
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
MatrixF orient(true);
|
|
|
|
if( mDataBlock->orientToNormal )
|
|
{
|
|
MatrixF rotMatrix( EulerF( M_PI/2.0, 0.0, 0.0 ) );
|
|
|
|
// set up gl modelview matrix
|
|
orient = MathUtils::createOrientFromDir( mInitialNormal );
|
|
orient.mul( rotMatrix );
|
|
}
|
|
|
|
orient.setPosition( mInitialPosition );
|
|
dglMultMatrix( &orient );
|
|
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
glDepthMask(GL_FALSE);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, mDataBlock->textureHandle[0].getGLName());
|
|
|
|
|
|
glBegin( GL_QUADS );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( 0.0, 0.0 );
|
|
glVertex3f( -mRadius, -mRadius, 0.0 );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( 0.0, 1.0 );
|
|
glVertex3f( -mRadius, mRadius, 0.0 );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( 1.0, 1.0 );
|
|
glVertex3f( mRadius, mRadius, 0.0 );
|
|
|
|
glColor4fv( mColor );
|
|
glTexCoord2f( 1.0, 0.0 );
|
|
glVertex3f( mRadius, -mRadius, 0.0 );
|
|
|
|
glEnd();
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glDisable(GL_BLEND);
|
|
glDepthMask(GL_TRUE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// packUpdate
|
|
//--------------------------------------------------------------------------
|
|
U32 Shockwave::packUpdate(NetConnection* con, U32 mask, BitStream* stream)
|
|
{
|
|
U32 retMask = Parent::packUpdate(con, mask, stream);
|
|
|
|
if( stream->writeFlag(mask & GameBase::InitialUpdateMask) )
|
|
{
|
|
mathWrite(*stream, mInitialPosition);
|
|
mathWrite(*stream, mInitialNormal);
|
|
}
|
|
|
|
return retMask;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// unpackUpdate
|
|
//--------------------------------------------------------------------------
|
|
void Shockwave::unpackUpdate(NetConnection* con, BitStream* stream)
|
|
{
|
|
Parent::unpackUpdate(con, stream);
|
|
|
|
if( stream->readFlag() )
|
|
{
|
|
mathRead(*stream, &mInitialPosition);
|
|
mathRead(*stream, &mInitialNormal);
|
|
}
|
|
}
|