static glm::mat4 setMatrix(const Vector3i *Position, const Vector3i *Rotation, int scale)
{
return glm::translate(glm::vec3(*Position)) *
glm::rotate(UNDEG(DEG(Rotation->x)), glm::vec3(1.f, 0.f, 0.f)) *
glm::rotate(UNDEG(DEG(Rotation->y)), glm::vec3(0.f, 1.f, 0.f)) *
glm::rotate(UNDEG(DEG(Rotation->z)), glm::vec3(0.f, 0.f, 1.f)) *
glm::scale(glm::vec3(scale / 100.f));
}
void pie_MatRotY(uint16_t y)
{
/*
* a := angle
* c := cos(a)
* s := sin(a)
*
* curMatrix = curMatrix . rotationMatrix(a, 0, 1, 0)
*
* [ c 0 s 0 ]
* [ 0 1 0 0 ]
* curMatrix = curMatrix . [ -s 0 c 0 ]
* [ 0 0 0 1 ]
*/
if (y != 0)
{
int t;
int64_t cra = iCos(y), sra = iSin(y);
t = (cra*psMatrix->a - sra*psMatrix->g)>>16;
psMatrix->g = (sra*psMatrix->a + cra*psMatrix->g)>>16;
psMatrix->a = t;
t = (cra*psMatrix->b - sra*psMatrix->h)>>16;
psMatrix->h = (sra*psMatrix->b + cra*psMatrix->h)>>16;
psMatrix->b = t;
t = (cra*psMatrix->c - sra*psMatrix->i)>>16;
psMatrix->i = (sra*psMatrix->c + cra*psMatrix->i)>>16;
psMatrix->c = t;
glRotatef(UNDEG(y), 0.0f, 1.0f, 0.0f);
}
void renderParticle(ATPART *psPart, const glm::mat4 &viewMatrix)
{
Vector3i dv;
/* Transform it */
dv.x = psPart->position.x - player.p.x;
dv.y = psPart->position.y;
dv.z = -(psPart->position.z - player.p.z);
/* Make it face camera */
/* Scale it... */
const glm::mat4 modelMatrix = glm::translate(glm::vec3(dv)) *
glm::rotate(UNDEG(-player.r.y), glm::vec3(0.f, 1.f, 0.f)) *
glm::rotate(UNDEG(-player.r.x), glm::vec3(0.f, 1.f, 0.f)) *
glm::scale(glm::vec3(psPart->size / 100.f));
pie_Draw3DShape(psPart->imd, 0, 0, WZCOL_WHITE, 0, 0, viewMatrix * modelMatrix);
/* Draw it... */
}
void drawRadar()
{
float pixSizeH, pixSizeV;
CalcRadarPixelSize(&pixSizeH, &pixSizeV);
ASSERT_OR_RETURN(, radarBuffer, "No radar buffer allocated");
// Do not recalculate frustum window coordinates if position or zoom does not change
if (playerpos.x != player.p.x || playerpos.y != player.p.y || playerpos.z != player.p.z)
{
setViewingWindow();
}
playerpos = player.p; // cache position
if (frameSkip <= 0)
{
DrawRadarTiles();
DrawRadarObjects();
pie_DownLoadRadar(radarBuffer);
frameSkip = RADAR_FRAME_SKIP;
}
frameSkip--;
pie_SetRendMode(REND_ALPHA);
glm::mat4 radarMatrix = glm::translate(radarCenterX, radarCenterY, 0);
glm::mat4 orthoMatrix = glm::ortho(0.f, static_cast<float>(pie_GetVideoBufferWidth()), static_cast<float>(pie_GetVideoBufferHeight()), 0.f);
if (rotateRadar)
{
// rotate the map
radarMatrix *= glm::rotate(UNDEG(player.r.y), glm::vec3(0.f, 0.f, 1.f));
DrawNorth(orthoMatrix * radarMatrix);
}
pie_RenderRadar(orthoMatrix * radarMatrix);
DrawRadarExtras(orthoMatrix * radarMatrix * glm::translate(-radarWidth / 2.f - 1.f, -radarHeight / 2.f - 1.f, 0.f));
drawRadarBlips(-radarWidth / 2.0 - 1, -radarHeight / 2.0 - 1, pixSizeH, pixSizeV, orthoMatrix * radarMatrix);
}
// Call once per frame.
//
void driveUpdate(void)
{
DROID *psDroid;
PROPULSION_STATS *psPropStats;
AllInRange = true;
if(DirectControl) {
if(psDrivenDroid != NULL) {
if(bMultiMessages && (driveBumpTime < gameTime)) // send latest info about driven droid.
{
sendDroidInfo(psDrivenDroid, DORDER_MOVE, psDrivenDroid->pos.x, psDrivenDroid->pos.y, NULL, NULL, 0, 0, 0, false);
}
//TO BE DONE:
//clear the order on taking over the droid, to stop attacks..
//send some sort of message when droids stopo and get inrange.
// Check the driven droid is still selected
if(psDrivenDroid->selected == false) {
// if it's not then reset the driving system.
driveSelectionChanged();
return;
}
// Update the driven droid.
if(driveControl(psDrivenDroid)) {
// If control did something then force the droid's move status.
if(psDrivenDroid->sMove.Status != MOVEDRIVE) {
psDrivenDroid->sMove.Status = MOVEDRIVE;
ASSERT( (psDrivenDroid->droidType != DROID_TRANSPORTER),"Tried to control a transporter" );
driveDir = UNDEG(psDrivenDroid->rot.direction);
}
DoFollowRangeCheck = true;
}
// Is the driven droid under user control?
if(psDrivenDroid->sMove.Status == MOVEDRIVE) {
// Is it a command droid
if( (psDrivenDroid->droidType == DROID_COMMAND) &&
(psDrivenDroid->psGroup != NULL) ) {
driveMoveCommandFollowers(psDrivenDroid);
}
for(psDroid = apsDroidLists[selectedPlayer]; psDroid; psDroid = psDroid->psNext) {
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
if( (psDroid->selected) &&
(psDroid != psDrivenDroid) &&
(psDroid->droidType != DROID_TRANSPORTER) &&
//((psPropStats->propulsionType != PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_CYBORG)) ) {
((psPropStats->propulsionType != PROPULSION_TYPE_LIFT) || cyborgDroid(psDroid)) )
{
// Send new orders to it's followers.
driveMoveFollower(psDroid);
}
}
}
if(AllInRange) {
DoFollowRangeCheck = false;
}
if(driveBumpTime < gameTime) {
// Send next order in 1 second.
driveBumpTime = gameTime+GAME_TICKS_PER_SEC;
}
} else {
if(StartDriverMode(NULL) == false) {
// nothing
}
}
}
}
// Start droid driving mode.
//
bool StartDriverMode(DROID *psOldDroid)
{
DROID *psDroid;
DROID *psLastDriven;
IdleTime = gameTime;
psLastDriven = psDrivenDroid;
psDrivenDroid = NULL;
// Find a selected droid and make that the driven one.
for(psDroid = apsDroidLists[selectedPlayer]; psDroid; psDroid = psDroid->psNext)
{
if(psDroid->selected) {
if((psDrivenDroid == NULL) && (psDroid != psOldDroid)) {
// The first droid found becomes the driven droid.
if(!(DroidIsBuilding(psDroid) || DroidGoingToBuild(psDroid))) {
// psDroid->sMove.Status = MOVEDRIVE;
}
psDrivenDroid = psDroid;
debug( LOG_NEVER, "New driven droid\n" );
}
}
}
// If that failed then find any droid and make it the driven one.
if(psDrivenDroid == NULL) {
psLastDriven = NULL;
psDrivenDroid = intGotoNextDroidType(NULL,DROID_ANY,true);
// If it's the same droid then try again
if(psDrivenDroid == psOldDroid) {
psDrivenDroid = intGotoNextDroidType(NULL,DROID_ANY,true);
}
if(psDrivenDroid == psOldDroid) {
psDrivenDroid = NULL;
}
// If it failed then try for a transporter.
if(psDrivenDroid == NULL) {
psDrivenDroid = intGotoNextDroidType(NULL,DROID_TRANSPORTER,true);
}
// DBPRINTF(("Selected a new driven droid : %p\n",psDrivenDroid));
}
if(psDrivenDroid) {
driveDir = UNDEG(psDrivenDroid->rot.direction);
driveSpeed = 0;
driveBumpTime = gameTime;
setDrivingStatus(true);
if(DriveInterfaceEnabled)
{
debug( LOG_NEVER, "Interface enabled1 ! Disabling drive control\n" );
DriveControlEnabled = false;
DirectControl = false;
}
else
{
DriveControlEnabled = true;
DirectControl = true; // we are taking over the unit.
}
if(psLastDriven != psDrivenDroid) {
debug( LOG_NEVER, "camAllignWithTarget\n" );
camAllignWithTarget((BASE_OBJECT*)psDrivenDroid);
}
return true;
} else {
}
return false;
}
// multiple turrets display removed the pointless mountRotation
void displayComponentObject(DROID *psDroid, const glm::mat4 &viewMatrix)
{
Vector3i position, rotation;
Spacetime st = interpolateObjectSpacetime(psDroid, graphicsTime);
leftFirst = angleDelta(player.r.y - st.rot.direction) <= 0;
/* Get the real position */
position.x = st.pos.x - player.p.x;
position.z = -(st.pos.y - player.p.z);
position.y = st.pos.z;
if (isTransporter(psDroid))
{
position.y += bobTransporterHeight();
}
/* Get all the pitch,roll,yaw info */
rotation.y = -st.rot.direction;
rotation.x = st.rot.pitch;
rotation.z = st.rot.roll;
/* Translate origin */
/* Rotate for droid */
glm::mat4 modelMatrix = glm::translate(glm::vec3(position)) *
glm::rotate(UNDEG(rotation.y), glm::vec3(0.f, 1.f, 0.f)) *
glm::rotate(UNDEG(rotation.x), glm::vec3(1.f, 0.f, 0.f)) *
glm::rotate(UNDEG(rotation.z), glm::vec3(0.f, 0.f, 1.f));
if (graphicsTime - psDroid->timeLastHit < GAME_TICKS_PER_SEC && psDroid->lastHitWeapon == WSC_ELECTRONIC)
{
modelMatrix *= objectShimmy((BASE_OBJECT *) psDroid);
}
// now check if the projected circle is within the screen boundaries
if(!clipDroidOnScreen(psDroid, viewMatrix * modelMatrix))
{
return;
}
if (psDroid->lastHitWeapon == WSC_EMP && graphicsTime - psDroid->timeLastHit < EMP_DISABLE_TIME)
{
Vector3i position;
//add an effect on the droid
position.x = st.pos.x + DROID_EMP_SPREAD;
position.y = st.pos.z + rand() % 8;
position.z = st.pos.y + DROID_EMP_SPREAD;
effectGiveAuxVar(90 + rand() % 20);
addEffect(&position, EFFECT_EXPLOSION, EXPLOSION_TYPE_PLASMA, false, nullptr, 0);
}
if (psDroid->visible[selectedPlayer] == UBYTE_MAX)
{
//ingame not button object
//should render 3 mounted weapons now
if (displayCompObj(psDroid, false, viewMatrix * modelMatrix))
{
// did draw something to the screen - update the framenumber
psDroid->sDisplay.frameNumber = frameGetFrameNumber();
}
}
else
{
int frame = graphicsTime / BLIP_ANIM_DURATION + psDroid->id % 8192; // de-sync the blip effect, but don't overflow the int
if (pie_Draw3DShape(getImdFromIndex(MI_BLIP), frame, 0, WZCOL_WHITE, pie_ADDITIVE, psDroid->visible[selectedPlayer] / 2, viewMatrix * modelMatrix))
{
psDroid->sDisplay.frameNumber = frameGetFrameNumber();
}
}
}
// this is able to handle multiple weapon graphics now
// removed mountRotation,they get such stuff from psObj directly now
static bool displayCompObj(DROID *psDroid, bool bButton, const glm::mat4 &viewMatrix)
{
iIMDShape *psMoveAnim, *psStillAnim;
SDWORD iConnector;
PROPULSION_STATS *psPropStats;
SDWORD pieFlag, iPieData;
PIELIGHT brightness;
UDWORD colour;
UBYTE i;
bool didDrawSomething = false;
glm::mat4 modelMatrix(1.f);
if (graphicsTime - psDroid->timeLastHit < GAME_TICKS_PER_SEC / 4 && psDroid->lastHitWeapon == WSC_ELECTRONIC && !gamePaused())
{
colour = getPlayerColour(rand() % MAX_PLAYERS);
}
else
{
colour = getPlayerColour(psDroid->player);
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(didDrawSomething, psPropStats != nullptr, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
if (bButton)
{
pieFlag = pie_BUTTON;
brightness = WZCOL_WHITE;
}
else
{
pieFlag = pie_SHADOW;
brightness = pal_SetBrightness(psDroid->illumination);
// NOTE: Beware of transporters that are offscreen, on a mission! We should *not* be checking tiles at this point in time!
if (!isTransporter(psDroid) && !missionIsOffworld())
{
MAPTILE *psTile = worldTile(psDroid->pos.x, psDroid->pos.y);
if (psTile->jammerBits & alliancebits[psDroid->player])
{
pieFlag |= pie_ECM;
}
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
iPieData = 0;
}
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_PROPELLOR)
{
// FIXME: change when adding submarines to the game
modelMatrix *= glm::translate(glm::vec3(0.f, -world_coord(1) / 2.3f, 0.f));
}
iIMDShape *psShapeProp = (leftFirst ? getLeftPropulsionIMD(psDroid) : getRightPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewMatrix * modelMatrix))
{
didDrawSomething = true;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_BODY] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Get the body graphic now*/
iIMDShape *psShapeBody = BODY_IMD(psDroid, psDroid->player);
if (psShapeBody)
{
iIMDShape *strImd = psShapeBody;
if (psDroid->droidType == DROID_PERSON)
{
modelMatrix *= glm::scale(glm::vec3(.75f)); // FIXME - hideous....!!!!
}
if (strImd->objanimpie[psDroid->animationEvent])
{
strImd = psShapeBody->objanimpie[psDroid->animationEvent];
}
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
while (strImd)
{
if (drawShape(psDroid, strImd, colour, brightness, pieFlag, iPieData, viewModelMatrix))
{
didDrawSomething = true;
}
strImd = strImd->next;
}
}
/* Render animation effects based on movement or lack thereof, if any */
psMoveAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppMoveIMDList[psDroid->asBits[COMP_PROPULSION]];
psStillAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppStillIMDList[psDroid->asBits[COMP_PROPULSION]];
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
if (!bButton && psMoveAnim && psDroid->sMove.Status != MOVEINACTIVE)
{
if (pie_Draw3DShape(psMoveAnim, getModularScaledGraphicsTime(psMoveAnim->animInterval, psMoveAnim->numFrames), colour, brightness, pie_ADDITIVE, 200, viewModelMatrix))
{
didDrawSomething = true;
}
}
else if (!bButton && psStillAnim) // standing still
{
if (pie_Draw3DShape(psStillAnim, getModularScaledGraphicsTime(psStillAnim->animInterval, psStillAnim->numFrames), colour, brightness, 0, 0, viewModelMatrix))
{
didDrawSomething = true;
}
}
//don't change the screen coords of an object if drawing it in a button
if (!bButton)
{
/* set up all the screen coords stuff - need to REMOVE FROM THIS LOOP */
calcScreenCoords(psDroid, viewModelMatrix);
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR] == 0 &&
psDroid->asBits[COMP_ECM] == 0 &&
psDroid->asBits[COMP_BRAIN] == 0 &&
psDroid->asBits[COMP_REPAIRUNIT] == 0 &&
psDroid->asBits[COMP_CONSTRUCT] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
if (psShapeBody && psShapeBody->nconnectors)
{
/* vtol weapons attach to connector 2 (underneath);
* all others to connector 1 */
/* VTOL's now skip the first 5 connectors(0 to 4),
VTOL's use 5,6,7,8 etc now */
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT && psDroid->droidType == DROID_WEAPON)
{
iConnector = VTOL_CONNECTOR_START;
}
else
{
iConnector = 0;
}
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_TRANSPORTER:
case DROID_SUPERTRANSPORTER:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_WEAPON:
case DROID_COMMAND: // command droids have a weapon to store all the graphics
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
/* Double check that the weapon droid actually has any */
for (i = 0; i < psDroid->numWeaps; i++)
{
if ((psDroid->asWeaps[i].nStat > 0 || psDroid->droidType == DROID_DEFAULT)
&& psShapeBody->connectors)
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, i, graphicsTime);
glm::mat4 localModelMatrix = modelMatrix;
//to skip number of VTOL_CONNECTOR_START ground unit connectors
if (iConnector < VTOL_CONNECTOR_START)
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[i].xzy()));
}
else
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[iConnector + i].xzy()));
}
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
/* Get the mount graphic */
iIMDShape *psShape = WEAPON_MOUNT_IMD(psDroid, i);
int recoilValue = getRecoil(psDroid->asWeaps[i]);
localModelMatrix *= glm::translate(glm::vec3(0.f, 0.f, recoilValue / 3.f));
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
localModelMatrix *= glm::translate(glm::vec3(0, 0, recoilValue));
/* translate for weapon mount point */
if (psShape && psShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors->xzy()));
}
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//pitch the barrel down
localModelMatrix *= glm::rotate(UNDEG(-rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
else
{
//pitch the barrel up
localModelMatrix *= glm::rotate(UNDEG(rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
/* Get the weapon (gun?) graphic */
psShape = WEAPON_IMD(psDroid, i);
// We have a weapon so we draw it and a muzzle flash from weapon connector
if (psShape)
{
glm::mat4 localViewModelMatrix = viewMatrix * localModelMatrix;
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, localViewModelMatrix))
{
didDrawSomething = true;
}
drawMuzzleFlash(psDroid->asWeaps[i], psShape, MUZZLE_FLASH_PIE(psDroid, i), brightness, pieFlag, iPieData, localViewModelMatrix);
}
}
}
break;
case DROID_SENSOR:
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
case DROID_ECM:
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
iIMDShape *psShape = nullptr;
iIMDShape *psMountShape = nullptr;
switch (psDroid->droidType)
{
default:
ASSERT(false, "Bad component type");
break;
case DROID_SENSOR:
psMountShape = SENSOR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the sensor graphic, assuming it's there */
psShape = SENSOR_IMD(psDroid, psDroid->player);
break;
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
psMountShape = CONSTRUCT_MOUNT_IMD(psDroid, psDroid->player);
/* Get the construct graphic assuming it's there */
psShape = CONSTRUCT_IMD(psDroid, psDroid->player);
break;
case DROID_ECM:
psMountShape = ECM_MOUNT_IMD(psDroid, psDroid->player);
/* Get the ECM graphic assuming it's there.... */
psShape = ECM_IMD(psDroid, psDroid->player);
break;
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
psMountShape = REPAIR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the Repair graphic assuming it's there.... */
psShape = REPAIR_IMD(psDroid, psDroid->player);
break;
}
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
//sensor and cyborg and ecm uses connectors[0]
glm::mat4 localModelMatrix = modelMatrix;
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[0].xzy()));
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* Draw it */
if (psMountShape)
{
if (pie_Draw3DShape(psMountShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
/* translate for construct mount point if cyborg */
if (cyborgDroid(psDroid) && psMountShape && psMountShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psMountShape->connectors[0].xzy()));
}
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// In repair droid case only:
if ((psDroid->droidType == DROID_REPAIR || psDroid->droidType == DROID_CYBORG_REPAIR) &&
psShape->nconnectors && psDroid->action == DACTION_DROIDREPAIR)
{
Spacetime st = interpolateObjectSpacetime(psDroid, graphicsTime);
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors[0].xzy()));
localModelMatrix *= glm::translate(glm::vec3(0.f, -20.f, 0.f));
psShape = getImdFromIndex(MI_FLAME);
/* Rotate for droid */
localModelMatrix *= glm::rotate(UNDEG(st.rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.pitch), glm::vec3(1.f, 0.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.roll), glm::vec3(0.f, 0.f, 1.f));
//rotate Y
localModelMatrix *= glm::rotate(UNDEG(rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.y), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.x), glm::vec3(1.f, 0.f, 0.f));
if (pie_Draw3DShape(psShape, getModularScaledGraphicsTime(psShape->animInterval, psShape->numFrames), 0, brightness, pie_ADDITIVE, 140, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// localModelMatrix *= glm::rotate(UNDEG(player.r.x), glm::vec3(1.f, 0.f, 0.f)); // Not used?
// localModelMatrix *= glm::rotate(UNDEG(player.r.y), glm::vec3(0.f, 1.f, 0.f)); // Not used?
}
}
break;
}
case DROID_PERSON:
// no extra mounts for people
break;
default:
ASSERT(!"invalid droid type", "Whoa! Weirdy type of droid found in drawComponentObject!!!");
break;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
// now render the other propulsion side
psShapeProp = (leftFirst ? getRightPropulsionIMD(psDroid) : getLeftPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewModelMatrix)) // Safe to use viewModelMatrix because modelView has not been changed since it was calculated
{
didDrawSomething = true;
}
}
return didDrawSomething;
}
