mirror of
https://github.com/overte-org/overte.git
synced 2025-04-20 18:23:54 +02:00
Merge remote-tracking branch 'upstream/master' into agentlist-array
This commit is contained in:
Stephen Birarda
commit
5ddd9a9f4f
16 changed files with 429 additions and 482 deletions
|
|
@ -123,8 +123,7 @@ int main(int argc, const char* argv[]) {
|
|||
// put her hand out so somebody can shake it
|
||||
eve.setHandPosition(glm::vec3(eve.getPosition()[0] - 0.2,
|
||||
0.25,
|
||||
eve.getPosition()[2] + 0.1));
|
||||
|
||||
eve.getPosition()[2] + 0.1));
|
||||
// read eve's audio data
|
||||
AudioInjector eveAudioInjector("eve.raw");
|
||||
|
||||
|
|
@ -139,6 +138,8 @@ int main(int argc, const char* argv[]) {
|
|||
// int numIterationsLeftBeforeAudioSend = 0;
|
||||
// pthread_t injectAudioThread;
|
||||
|
||||
int handStateTimer = 0;
|
||||
|
||||
while (true) {
|
||||
// update the thisSend timeval to the current time
|
||||
gettimeofday(&thisSend, NULL);
|
||||
|
|
@ -170,7 +171,19 @@ int main(int argc, const char* argv[]) {
|
|||
// sleep for the correct amount of time to have data send be consistently timed
|
||||
if ((numMicrosecondsSleep = (DATA_SEND_INTERVAL_MSECS * 1000) - (usecTimestampNow() - usecTimestamp(&thisSend))) > 0) {
|
||||
usleep(numMicrosecondsSleep);
|
||||
}
|
||||
}
|
||||
|
||||
// simulate the effect of pressing and un-pressing the mouse button/pad
|
||||
handStateTimer++;
|
||||
if ( handStateTimer == 100 ) {
|
||||
eve.setHandState(1);
|
||||
}
|
||||
if ( handStateTimer == 150 ) {
|
||||
eve.setHandState(0);
|
||||
}
|
||||
if ( handStateTimer >= 200 ) {
|
||||
handStateTimer = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// stop the receive agent data thread
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ void usage(void)
|
|||
std::cout << " -c FLOAT,FLOAT,FLOAT,FLOAT X,Y,Z,YAW position in universe where audio will be originating from and direction. Defaults to 0,0,0,0" << std::endl;
|
||||
std::cout << " -a 0-255 Attenuation curve modifier, defaults to 255" << std::endl;
|
||||
std::cout << " -f FILENAME Name of audio source file. Required - RAW format, 22050hz 16bit signed mono" << std::endl;
|
||||
};
|
||||
}
|
||||
|
||||
bool processParameters(int parameterCount, char* parameterData[])
|
||||
{
|
||||
|
|
@ -91,9 +91,9 @@ bool processParameters(int parameterCount, char* parameterData[])
|
|||
}
|
||||
}
|
||||
return true;
|
||||
};_Position
|
||||
};
|
||||
|
||||
int main(int argc, const char* argv[]) {
|
||||
int main(int argc, char* argv[]) {
|
||||
|
||||
srand(time(0));
|
||||
int AUDIO_UDP_SEND_PORT = 1500 + (rand() % (int)(1500 - 2000 + 1));
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ int audioCallback (const void *inputBuffer,
|
|||
|
||||
// memcpy the three float positions
|
||||
for (int p = 0; p < 3; p++) {
|
||||
memcpy(currentPacketPtr, &data->linkedHead->getPosition()[p], sizeof(float));
|
||||
memcpy(currentPacketPtr, &data->linkedAvatar->getPosition()[p], sizeof(float));
|
||||
currentPacketPtr += sizeof(float);
|
||||
}
|
||||
|
||||
|
|
@ -165,7 +165,7 @@ int audioCallback (const void *inputBuffer,
|
|||
*(currentPacketPtr++) = 255;
|
||||
|
||||
// memcpy the corrected render yaw
|
||||
float correctedYaw = fmodf(data->linkedHead->getRenderYaw(), 360);
|
||||
float correctedYaw = fmodf(data->linkedAvatar->getRenderYaw(), 360);
|
||||
|
||||
if (correctedYaw > 180) {
|
||||
correctedYaw -= 360;
|
||||
|
|
@ -259,7 +259,7 @@ int audioCallback (const void *inputBuffer,
|
|||
// rotation of the head relative to body, this may effect flange effect!
|
||||
//
|
||||
//
|
||||
int lastYawMeasured = fabsf(data->linkedHead->getLastMeasuredHeadYaw());
|
||||
int lastYawMeasured = fabsf(data->linkedAvatar->getLastMeasuredHeadYaw());
|
||||
|
||||
if (!samplesLeftForFlange && lastYawMeasured > MIN_FLANGE_EFFECT_THRESHOLD) {
|
||||
// we should flange for one second
|
||||
|
|
@ -448,7 +448,7 @@ void Audio::setWalkingState(bool newWalkState) {
|
|||
* @return Returns true if successful or false if an error occurred.
|
||||
Use Audio::getError() to retrieve the error code.
|
||||
*/
|
||||
Audio::Audio(Oscilloscope *s, Head *linkedHead)
|
||||
Audio::Audio(Oscilloscope *s, Avatar *linkedAvatar)
|
||||
{
|
||||
// read the walking sound from the raw file and store it
|
||||
// in the in memory array
|
||||
|
|
@ -472,7 +472,7 @@ Audio::Audio(Oscilloscope *s, Head *linkedHead)
|
|||
|
||||
audioData = new AudioData();
|
||||
|
||||
audioData->linkedHead = linkedHead;
|
||||
audioData->linkedAvatar = linkedAvatar;
|
||||
|
||||
// setup a UDPSocket
|
||||
audioData->audioSocket = new UDPSocket(AUDIO_UDP_LISTEN_PORT);
|
||||
|
|
|
|||
|
|
@ -12,12 +12,12 @@
|
|||
#include <portaudio.h>
|
||||
#include "AudioData.h"
|
||||
#include "Oscilloscope.h"
|
||||
#include "Head.h"
|
||||
#include "Avatar.h"
|
||||
|
||||
class Audio {
|
||||
public:
|
||||
// initializes audio I/O
|
||||
Audio(Oscilloscope *s, Head *linkedHead);
|
||||
Audio(Oscilloscope *s, Avatar *linkedAvatar);
|
||||
|
||||
void render();
|
||||
void render(int screenWidth, int screenHeight);
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
#include <glm/glm.hpp>
|
||||
#include "AudioRingBuffer.h"
|
||||
#include "UDPSocket.h"
|
||||
#include "Head.h"
|
||||
#include "Avatar.h"
|
||||
|
||||
class AudioData {
|
||||
public:
|
||||
|
|
@ -23,7 +23,7 @@ class AudioData {
|
|||
|
||||
UDPSocket *audioSocket;
|
||||
|
||||
Head *linkedHead;
|
||||
Avatar *linkedAvatar;
|
||||
|
||||
// store current mixer address and port
|
||||
in_addr_t mixerAddress;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
//
|
||||
// Head.cpp
|
||||
// Avatar.cpp
|
||||
// interface
|
||||
//
|
||||
// Created by Philip Rosedale on 9/11/12.
|
||||
|
|
@ -11,7 +11,7 @@
|
|||
#include <vector>
|
||||
#include <lodepng.h>
|
||||
#include <SharedUtil.h>
|
||||
#include "Head.h"
|
||||
#include "Avatar.h"
|
||||
#include "Log.h"
|
||||
#include <AgentList.h>
|
||||
#include <AgentTypes.h>
|
||||
|
|
@ -41,14 +41,13 @@ vector<unsigned char> iris_texture;
|
|||
unsigned int iris_texture_width = 512;
|
||||
unsigned int iris_texture_height = 256;
|
||||
|
||||
Head::Head(bool isMine) {
|
||||
Avatar::Avatar(bool isMine) {
|
||||
|
||||
_orientation.setToIdentity();
|
||||
|
||||
_velocity = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
_thrust = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
_rotation = glm::quat( 0.0f, 0.0f, 0.0f, 0.0f );
|
||||
_nearOtherAvatar = false;
|
||||
_bodyYaw = -90.0;
|
||||
_bodyPitch = 0.0;
|
||||
_bodyRoll = 0.0;
|
||||
|
|
@ -60,7 +59,6 @@ Head::Head(bool isMine) {
|
|||
//_transmitterTimer = 0;
|
||||
_transmitterHz = 0.0;
|
||||
_transmitterPackets = 0;
|
||||
//_numOtherAvatars = 0;
|
||||
|
||||
initializeSkeleton();
|
||||
|
||||
|
|
@ -69,54 +67,51 @@ Head::Head(bool isMine) {
|
|||
|
||||
for (int i = 0; i < MAX_DRIVE_KEYS; i++) _driveKeys[i] = false;
|
||||
|
||||
_head.pupilSize = 0.10;
|
||||
_head.interPupilDistance = 0.6;
|
||||
_head.interBrowDistance = 0.75;
|
||||
_head.nominalPupilSize = 0.10;
|
||||
//_head.yaw = 0.0;
|
||||
//_head.pitch = 0.0;
|
||||
//_head.roll = 0.0;
|
||||
_head.pitchRate = 0.0;
|
||||
_head.yawRate = 0.0;
|
||||
_head.rollRate = 0.0;
|
||||
_head.eyebrowPitch[0] = -30;
|
||||
_head.eyebrowPitch[1] = -30;
|
||||
_head.eyebrowRoll [0] = 20;
|
||||
_head.eyebrowRoll [1] = -20;
|
||||
_head.mouthPitch = 0;
|
||||
_head.mouthYaw = 0;
|
||||
_head.mouthWidth = 1.0;
|
||||
_head.mouthHeight = 0.2;
|
||||
_head.eyeballPitch[0] = 0;
|
||||
_head.eyeballPitch[1] = 0;
|
||||
_head.eyeballScaleX = 1.2;
|
||||
_head.eyeballScaleY = 1.5;
|
||||
_head.eyeballScaleZ = 1.0;
|
||||
_head.eyeballYaw[0] = 0;
|
||||
_head.eyeballYaw[1] = 0;
|
||||
_head.pitchTarget = 0;
|
||||
_head.yawTarget = 0;
|
||||
_head.noiseEnvelope = 1.0;
|
||||
_head.pupilConverge = 10.0;
|
||||
_head.leanForward = 0.0;
|
||||
_head.leanSideways = 0.0;
|
||||
_head.eyeContact = 1;
|
||||
_head.eyeContactTarget = LEFT_EYE;
|
||||
_head.scale = 1.0;
|
||||
_head.audioAttack = 0.0;
|
||||
_head.averageLoudness = 0.0;
|
||||
_head.lastLoudness = 0.0;
|
||||
_head.browAudioLift = 0.0;
|
||||
_head.noise = 0;
|
||||
|
||||
_movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
_usingBodySprings = true;
|
||||
_springForce = 6.0f;
|
||||
_springVelocityDecay = 16.0f;
|
||||
_renderYaw = 0.0;
|
||||
_renderPitch = 0.0;
|
||||
|
||||
_sphere = NULL;
|
||||
_head.pupilSize = 0.10;
|
||||
_head.interPupilDistance = 0.6;
|
||||
_head.interBrowDistance = 0.75;
|
||||
_head.nominalPupilSize = 0.10;
|
||||
_head.pitchRate = 0.0;
|
||||
_head.yawRate = 0.0;
|
||||
_head.rollRate = 0.0;
|
||||
_head.eyebrowPitch[0] = -30;
|
||||
_head.eyebrowPitch[1] = -30;
|
||||
_head.eyebrowRoll [0] = 20;
|
||||
_head.eyebrowRoll [1] = -20;
|
||||
_head.mouthPitch = 0;
|
||||
_head.mouthYaw = 0;
|
||||
_head.mouthWidth = 1.0;
|
||||
_head.mouthHeight = 0.2;
|
||||
_head.eyeballPitch[0] = 0;
|
||||
_head.eyeballPitch[1] = 0;
|
||||
_head.eyeballScaleX = 1.2;
|
||||
_head.eyeballScaleY = 1.5;
|
||||
_head.eyeballScaleZ = 1.0;
|
||||
_head.eyeballYaw[0] = 0;
|
||||
_head.eyeballYaw[1] = 0;
|
||||
_head.pitchTarget = 0;
|
||||
_head.yawTarget = 0;
|
||||
_head.noiseEnvelope = 1.0;
|
||||
_head.pupilConverge = 10.0;
|
||||
_head.leanForward = 0.0;
|
||||
_head.leanSideways = 0.0;
|
||||
_head.eyeContact = 1;
|
||||
_head.eyeContactTarget = LEFT_EYE;
|
||||
_head.scale = 1.0;
|
||||
_head.audioAttack = 0.0;
|
||||
_head.averageLoudness = 0.0;
|
||||
_head.lastLoudness = 0.0;
|
||||
_head.browAudioLift = 0.0;
|
||||
_head.noise = 0;
|
||||
_movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
_usingBodySprings = true;
|
||||
_springForce = 6.0f;
|
||||
_springVelocityDecay = 16.0f;
|
||||
_renderYaw = 0.0;
|
||||
_renderPitch = 0.0;
|
||||
_sphere = NULL;
|
||||
_interactingOther = NULL;
|
||||
_interactingOtherIsNearby = false;
|
||||
|
||||
_handHolding.position = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
_handHolding.velocity = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
|
|
@ -129,38 +124,35 @@ Head::Head(bool isMine) {
|
|||
printLog("error %u: %s\n", error, lodepng_error_text(error));
|
||||
}
|
||||
}
|
||||
|
||||
_otherAvatar.handPosition = glm::vec3( 0.0f, 0.0f, 0.0f );
|
||||
_otherAvatar.handState = 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Head::Head(const Head &otherAvatar) {
|
||||
Avatar::Avatar(const Avatar &otherAvatar) {
|
||||
|
||||
_velocity = otherAvatar._velocity;
|
||||
_thrust = otherAvatar._thrust;
|
||||
_rotation = otherAvatar._rotation;
|
||||
_nearOtherAvatar = otherAvatar._nearOtherAvatar;
|
||||
_bodyYaw = otherAvatar._bodyYaw;
|
||||
_bodyPitch = otherAvatar._bodyPitch;
|
||||
_bodyRoll = otherAvatar._bodyRoll;
|
||||
_bodyYawDelta = otherAvatar._bodyYawDelta;
|
||||
_mousePressed = otherAvatar._mousePressed;
|
||||
_mode = otherAvatar._mode;
|
||||
_isMine = otherAvatar._isMine;
|
||||
_renderYaw = otherAvatar._renderYaw;
|
||||
_renderPitch = otherAvatar._renderPitch;
|
||||
_maxArmLength = otherAvatar._maxArmLength;
|
||||
_transmitterTimer = otherAvatar._transmitterTimer;
|
||||
_transmitterHz = otherAvatar._transmitterHz;
|
||||
_transmitterPackets = otherAvatar._transmitterPackets;
|
||||
_TEST_bigSphereRadius = otherAvatar._TEST_bigSphereRadius;
|
||||
_TEST_bigSpherePosition = otherAvatar._TEST_bigSpherePosition;
|
||||
_movedHandOffset = otherAvatar._movedHandOffset;
|
||||
_usingBodySprings = otherAvatar._usingBodySprings;
|
||||
_springForce = otherAvatar._springForce;
|
||||
_springVelocityDecay = otherAvatar._springVelocityDecay;
|
||||
_velocity = otherAvatar._velocity;
|
||||
_thrust = otherAvatar._thrust;
|
||||
_rotation = otherAvatar._rotation;
|
||||
_interactingOtherIsNearby = otherAvatar._interactingOtherIsNearby;
|
||||
_bodyYaw = otherAvatar._bodyYaw;
|
||||
_bodyPitch = otherAvatar._bodyPitch;
|
||||
_bodyRoll = otherAvatar._bodyRoll;
|
||||
_bodyYawDelta = otherAvatar._bodyYawDelta;
|
||||
_mousePressed = otherAvatar._mousePressed;
|
||||
_mode = otherAvatar._mode;
|
||||
_isMine = otherAvatar._isMine;
|
||||
_renderYaw = otherAvatar._renderYaw;
|
||||
_renderPitch = otherAvatar._renderPitch;
|
||||
_maxArmLength = otherAvatar._maxArmLength;
|
||||
_transmitterTimer = otherAvatar._transmitterTimer;
|
||||
_transmitterHz = otherAvatar._transmitterHz;
|
||||
_transmitterPackets = otherAvatar._transmitterPackets;
|
||||
_TEST_bigSphereRadius = otherAvatar._TEST_bigSphereRadius;
|
||||
_TEST_bigSpherePosition = otherAvatar._TEST_bigSpherePosition;
|
||||
_movedHandOffset = otherAvatar._movedHandOffset;
|
||||
_usingBodySprings = otherAvatar._usingBodySprings;
|
||||
_springForce = otherAvatar._springForce;
|
||||
_springVelocityDecay = otherAvatar._springVelocityDecay;
|
||||
_orientation.set( otherAvatar._orientation );
|
||||
|
||||
_sphere = NULL;
|
||||
|
|
@ -173,9 +165,6 @@ Head::Head(const Head &otherAvatar) {
|
|||
_head.interPupilDistance = otherAvatar._head.interPupilDistance;
|
||||
_head.interBrowDistance = otherAvatar._head.interBrowDistance;
|
||||
_head.nominalPupilSize = otherAvatar._head.nominalPupilSize;
|
||||
//_head.yaw = otherAvatar._head.yaw;
|
||||
//_head.pitch = otherAvatar._head.pitch;
|
||||
//_head.roll = otherAvatar._head.roll;
|
||||
_head.yawRate = otherAvatar._head.yawRate;
|
||||
_head.pitchRate = otherAvatar._head.pitchRate;
|
||||
_head.rollRate = otherAvatar._head.rollRate;
|
||||
|
|
@ -209,7 +198,6 @@ Head::Head(const Head &otherAvatar) {
|
|||
_head.browAudioLift = otherAvatar._head.browAudioLift;
|
||||
_head.noise = otherAvatar._head.noise;
|
||||
|
||||
|
||||
if (iris_texture.size() == 0) {
|
||||
switchToResourcesParentIfRequired();
|
||||
unsigned error = lodepng::decode(iris_texture, iris_texture_width, iris_texture_height, iris_texture_file);
|
||||
|
|
@ -219,25 +207,24 @@ Head::Head(const Head &otherAvatar) {
|
|||
}
|
||||
}
|
||||
|
||||
Head::~Head() {
|
||||
Avatar::~Avatar() {
|
||||
if (_sphere != NULL) {
|
||||
gluDeleteQuadric(_sphere);
|
||||
}
|
||||
}
|
||||
|
||||
Head* Head::clone() const {
|
||||
return new Head(*this);
|
||||
Avatar* Avatar::clone() const {
|
||||
return new Avatar(*this);
|
||||
}
|
||||
|
||||
void Head::reset() {
|
||||
void Avatar::reset() {
|
||||
_headPitch = _headYaw = _headRoll = 0;
|
||||
_head.leanForward = _head.leanSideways = 0;
|
||||
}
|
||||
|
||||
|
||||
//this pertains to moving the head with the glasses
|
||||
//---------------------------------------------------
|
||||
void Head::UpdateGyros(float frametime, SerialInterface * serialInterface, glm::vec3 * gravity)
|
||||
void Avatar::UpdateGyros(float frametime, SerialInterface * serialInterface, glm::vec3 * gravity)
|
||||
// Using serial data, update avatar/render position and angles
|
||||
{
|
||||
const float PITCH_ACCEL_COUPLING = 0.5;
|
||||
|
|
@ -276,28 +263,41 @@ void Head::UpdateGyros(float frametime, SerialInterface * serialInterface, glm::
|
|||
addLean(-measured_lateral_accel * frametime * HEAD_LEAN_SCALE, -measured_fwd_accel*frametime * HEAD_LEAN_SCALE);
|
||||
}
|
||||
|
||||
void Head::addLean(float x, float z) {
|
||||
void Avatar::addLean(float x, float z) {
|
||||
// Add Body lean as impulse
|
||||
_head.leanSideways += x;
|
||||
_head.leanForward += z;
|
||||
}
|
||||
|
||||
|
||||
void Head::setLeanForward(float dist){
|
||||
void Avatar::setLeanForward(float dist){
|
||||
_head.leanForward = dist;
|
||||
}
|
||||
|
||||
void Head::setLeanSideways(float dist){
|
||||
void Avatar::setLeanSideways(float dist){
|
||||
_head.leanSideways = dist;
|
||||
}
|
||||
|
||||
void Head::setMousePressed( bool d ) {
|
||||
void Avatar::setMousePressed( bool d ) {
|
||||
_mousePressed = d;
|
||||
}
|
||||
|
||||
void Head::simulate(float deltaTime) {
|
||||
void Avatar::simulate(float deltaTime) {
|
||||
|
||||
// update avatar skeleton
|
||||
updateSkeleton();
|
||||
|
||||
// reset hand and arm positions according to hand movement
|
||||
updateHandMovement( deltaTime );
|
||||
|
||||
if ( !_interactingOtherIsNearby ) {
|
||||
//initialize _handHolding
|
||||
_handHolding.position = _bone[ AVATAR_BONE_RIGHT_HAND ].position;
|
||||
_handHolding.velocity = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
}
|
||||
|
||||
_interactingOtherIsNearby = false;
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// if the avatar being simulated is mine, then loop through
|
||||
// all the other avatars to get information about them...
|
||||
//-------------------------------------------------------------
|
||||
|
|
@ -315,46 +315,60 @@ void Head::simulate(float deltaTime) {
|
|||
if ((*agent).getLinkedData() != NULL && (*agent).getType() == AGENT_TYPE_AVATAR) {
|
||||
Head *otherAvatar = (Head *)(*agent).getLinkedData();
|
||||
|
||||
// if ( _numOtherAvatars < MAX_OTHER_AVATARS )
|
||||
{
|
||||
|
||||
//------------------------------------------------------
|
||||
// check for collisions with other avatars and respond
|
||||
//------------------------------------------------------
|
||||
updateAvatarCollisionDetectionAndResponse
|
||||
(
|
||||
otherAvatar->getPosition(),
|
||||
otherAvatar->getGirth(),
|
||||
otherAvatar->getHeight(),
|
||||
otherAvatar->getBodyUpDirection(),
|
||||
deltaTime
|
||||
);
|
||||
|
||||
//-------------------------------------------------
|
||||
// test other avatar hand position for proximity
|
||||
//------------------------------------------------
|
||||
glm::vec3 v( _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position );
|
||||
v -= otherAvatar->getBonePosition( AVATAR_BONE_RIGHT_HAND );
|
||||
|
||||
float distance = glm::length( v );
|
||||
if ( distance < _maxArmLength ) {
|
||||
if ( distance < closestDistance ) {
|
||||
closestDistance = distance;
|
||||
_nearOtherAvatar = true;
|
||||
_otherAvatar.handPosition = otherAvatar->getBonePosition( AVATAR_BONE_RIGHT_HAND );
|
||||
_otherAvatar.handState = (int)otherAvatar->getHandState();
|
||||
}
|
||||
// check for collisions with other avatars and respond
|
||||
updateAvatarCollisionDetectionAndResponse
|
||||
(
|
||||
otherAvatar->getBonePosition( AVATAR_BONE_PELVIS_SPINE ),
|
||||
0.2,
|
||||
0.2,
|
||||
otherAvatar->getBodyUpDirection(),
|
||||
deltaTime
|
||||
);
|
||||
|
||||
// test other avatar hand position for proximity
|
||||
glm::vec3 v( _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position );
|
||||
v -= otherAvatar->getBonePosition( AVATAR_BONE_RIGHT_HAND );
|
||||
|
||||
float distance = glm::length( v );
|
||||
if ( distance < _maxArmLength ) {
|
||||
|
||||
//if ( distance < closestDistance ) { // perhaps I don't need this if we want to allow multi-avatar interactions
|
||||
{
|
||||
closestDistance = distance;
|
||||
_interactingOther = otherAvatar;
|
||||
_interactingOtherIsNearby = true;
|
||||
|
||||
// if I am holding hands with another avatar, a force is applied
|
||||
if (( _handState == 1 ) || ( _interactingOther->_handState == 1 )) {
|
||||
glm::vec3 vectorToOtherHand = _interactingOther->_handPosition - _handHolding.position;
|
||||
glm::vec3 vectorToMyHand = _bone[ AVATAR_BONE_RIGHT_HAND ].position - _handHolding.position;
|
||||
|
||||
_handHolding.velocity *= 0.7;
|
||||
_handHolding.velocity += ( vectorToOtherHand + vectorToMyHand ) * _handHolding.force * deltaTime;
|
||||
_handHolding.position += _handHolding.velocity;
|
||||
|
||||
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _handHolding.position;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}//if ( _isMine )
|
||||
// Set the vector we send for hand position to other people to be our right hand
|
||||
setHandPosition(_bone[ AVATAR_BONE_RIGHT_HAND ].position);
|
||||
|
||||
}//if ( _isMine )
|
||||
|
||||
|
||||
updateArmIKAndConstraints( deltaTime );
|
||||
|
||||
if (!_interactingOtherIsNearby) {
|
||||
_interactingOther = NULL;
|
||||
}
|
||||
|
||||
if ( usingBigSphereCollisionTest ) {
|
||||
//--------------------------------------------------------------
|
||||
|
||||
// test for avatar collision response (using a big sphere :)
|
||||
//--------------------------------------------------------------
|
||||
updateAvatarCollisionDetectionAndResponse
|
||||
(
|
||||
_TEST_bigSpherePosition,
|
||||
|
|
@ -377,23 +391,12 @@ void Head::simulate(float deltaTime) {
|
|||
}
|
||||
}
|
||||
|
||||
//------------------------
|
||||
// update avatar skeleton
|
||||
//------------------------
|
||||
updateSkeleton();
|
||||
|
||||
//------------------------------------------------------------
|
||||
// reset hand and arm positions according to hand movement
|
||||
//------------------------------------------------------------
|
||||
if (_usingBodySprings) {
|
||||
updateHandMovement( deltaTime );
|
||||
updateBodySprings( deltaTime );
|
||||
}
|
||||
|
||||
if ( _isMine ) { // driving the avatar around should only apply if this is my avatar (as opposed to an avatar being driven remotely)
|
||||
//-------------------------------------------------
|
||||
// this handles the avatar being driven around...
|
||||
//-------------------------------------------------
|
||||
// update body springs
|
||||
updateBodySprings( deltaTime );
|
||||
|
||||
// driving the avatar around should only apply if this is my avatar (as opposed to an avatar being driven remotely)
|
||||
if ( _isMine ) {
|
||||
|
||||
_thrust = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
|
||||
if (_driveKeys[FWD]) {
|
||||
|
|
@ -427,9 +430,7 @@ void Head::simulate(float deltaTime) {
|
|||
_bodyYawDelta += YAW_MAG * deltaTime;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
|
||||
float translationalSpeed = glm::length( _velocity );
|
||||
float rotationalSpeed = fabs( _bodyYawDelta );
|
||||
if ( translationalSpeed + rotationalSpeed > 0.2 )
|
||||
|
|
@ -441,43 +442,27 @@ void Head::simulate(float deltaTime) {
|
|||
_mode = AVATAR_MODE_INTERACTING;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------
|
||||
// update body yaw by body yaw delta
|
||||
//----------------------------------------------------------
|
||||
if (_isMine) {
|
||||
_bodyYaw += _bodyYawDelta * deltaTime;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
// decay body yaw delta
|
||||
//----------------------------------------------------------
|
||||
_bodyYawDelta *= (1.0 - TEST_YAW_DECAY * deltaTime);
|
||||
|
||||
//----------------------------------------------------------
|
||||
// add thrust to velocity
|
||||
//----------------------------------------------------------
|
||||
_velocity += glm::dvec3(_thrust * deltaTime);
|
||||
|
||||
//----------------------------------------------------------
|
||||
// update position by velocity
|
||||
//----------------------------------------------------------
|
||||
_position += (glm::vec3)_velocity * deltaTime;
|
||||
|
||||
//----------------------------------------------------------
|
||||
// decay velocity
|
||||
//----------------------------------------------------------
|
||||
_velocity *= ( 1.0 - LIN_VEL_DECAY * deltaTime );
|
||||
|
||||
//
|
||||
// Update Head information
|
||||
//
|
||||
|
||||
// we will be eventually getting head rotation from elsewhere. For now, just setting it to body rotation
|
||||
//_head.yaw = _bodyYaw;
|
||||
//_head.pitch = _bodyPitch;
|
||||
//_head.roll = _bodyRoll;
|
||||
|
||||
if (!_head.noise) {
|
||||
// Decay back toward center
|
||||
_headPitch *= (1.0f - DECAY * 2 * deltaTime);
|
||||
|
|
@ -573,23 +558,21 @@ void Head::simulate(float deltaTime) {
|
|||
}
|
||||
|
||||
|
||||
float Head::getGirth() {
|
||||
float Avatar::getGirth() {
|
||||
return COLLISION_BODY_RADIUS;
|
||||
}
|
||||
|
||||
float Head::getHeight() {
|
||||
float Avatar::getHeight() {
|
||||
return COLLISION_HEIGHT;
|
||||
}
|
||||
|
||||
|
||||
glm::vec3 Head::getBodyUpDirection() {
|
||||
glm::vec3 Avatar::getBodyUpDirection() {
|
||||
return _orientation.getUp();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// This is a workspace for testing avatar body collision detection and response
|
||||
//--------------------------------------------------------------------------------
|
||||
void Head::updateAvatarCollisionDetectionAndResponse
|
||||
void Avatar::updateAvatarCollisionDetectionAndResponse
|
||||
( glm::vec3 collisionPosition, float collisionGirth, float collisionHeight, glm::vec3 collisionUpVector, float deltaTime ) {
|
||||
|
||||
float myBodyApproximateBoundingRadius = 1.0f;
|
||||
|
|
@ -630,14 +613,9 @@ void Head::updateAvatarCollisionDetectionAndResponse
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void Head::render(bool lookingInMirror) {
|
||||
void Avatar::render(bool lookingInMirror) {
|
||||
|
||||
//---------------------------------------------------
|
||||
// show avatar position
|
||||
//---------------------------------------------------
|
||||
glColor4f( 0.5f, 0.5f, 0.5f, 0.6 );
|
||||
glPushMatrix();
|
||||
glTranslatef(_position.x, _position.y, _position.z);
|
||||
|
|
@ -646,9 +624,8 @@ void Head::render(bool lookingInMirror) {
|
|||
glPopMatrix();
|
||||
|
||||
if ( usingBigSphereCollisionTest ) {
|
||||
//---------------------------------------------------
|
||||
|
||||
// show TEST big sphere
|
||||
//---------------------------------------------------
|
||||
glColor4f( 0.5f, 0.6f, 0.8f, 0.7 );
|
||||
glPushMatrix();
|
||||
glTranslatef(_TEST_bigSpherePosition.x, _TEST_bigSpherePosition.y, _TEST_bigSpherePosition.z);
|
||||
|
|
@ -657,49 +634,38 @@ void Head::render(bool lookingInMirror) {
|
|||
glPopMatrix();
|
||||
}
|
||||
|
||||
//---------------------------------------------------
|
||||
// render body
|
||||
//---------------------------------------------------
|
||||
renderBody();
|
||||
|
||||
//---------------------------------------------------
|
||||
// render head
|
||||
//---------------------------------------------------
|
||||
renderHead(lookingInMirror);
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// if this is my avatar, then render my interactions with the other avatars
|
||||
//---------------------------------------------------------------------------
|
||||
// if this is my avatar, then render my interactions with the other avatar
|
||||
if ( _isMine )
|
||||
{
|
||||
if (_usingBodySprings) {
|
||||
if ( _nearOtherAvatar ) {
|
||||
if ( _interactingOtherIsNearby ) {
|
||||
|
||||
glm::vec3 v1( _bone[ AVATAR_BONE_RIGHT_HAND ].position );
|
||||
glm::vec3 v2( _otherAvatar.handPosition );
|
||||
|
||||
glLineWidth( 8.0 );
|
||||
glColor4f( 0.7f, 0.4f, 0.1f, 0.6 );
|
||||
glBegin( GL_LINE_STRIP );
|
||||
glVertex3f( v1.x, v1.y, v1.z );
|
||||
glVertex3f( v2.x, v2.y, v2.z );
|
||||
glEnd();
|
||||
}
|
||||
glm::vec3 v1( _bone[ AVATAR_BONE_RIGHT_HAND ].position );
|
||||
glm::vec3 v2( _interactingOther->_handPosition );
|
||||
|
||||
glLineWidth( 8.0 );
|
||||
glColor4f( 0.7f, 0.4f, 0.1f, 0.6 );
|
||||
glBegin( GL_LINE_STRIP );
|
||||
glVertex3f( v1.x, v1.y, v1.z );
|
||||
glVertex3f( v2.x, v2.y, v2.z );
|
||||
glEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Head::renderHead(bool lookingInMirror) {
|
||||
void Avatar::renderHead(bool lookingInMirror) {
|
||||
int side = 0;
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glEnable(GL_RESCALE_NORMAL);
|
||||
|
||||
//---------------------------------------------------
|
||||
// show head orientation
|
||||
//---------------------------------------------------
|
||||
//renderOrientationDirections( _bone[ AVATAR_BONE_HEAD ].position, _bone[ AVATAR_BONE_HEAD ].orientation, 0.2f );
|
||||
|
||||
glPushMatrix();
|
||||
|
|
@ -855,7 +821,7 @@ void Head::renderHead(bool lookingInMirror) {
|
|||
glPopMatrix();
|
||||
}
|
||||
|
||||
void Head::startHandMovement() {
|
||||
void Avatar::startHandMovement() {
|
||||
|
||||
if (!_usingBodySprings) {
|
||||
initializeBodySprings();
|
||||
|
|
@ -863,19 +829,19 @@ void Head::startHandMovement() {
|
|||
}
|
||||
}
|
||||
|
||||
void Head::stopHandMovement() {
|
||||
void Avatar::stopHandMovement() {
|
||||
//_usingBodySprings = false;
|
||||
}
|
||||
|
||||
void Head::setHandMovementValues( glm::vec3 handOffset ) {
|
||||
void Avatar::setHandMovementValues( glm::vec3 handOffset ) {
|
||||
_movedHandOffset = handOffset;
|
||||
}
|
||||
|
||||
AvatarMode Head::getMode() {
|
||||
AvatarMode Avatar::getMode() {
|
||||
return _mode;
|
||||
}
|
||||
|
||||
void Head::initializeSkeleton() {
|
||||
void Avatar::initializeSkeleton() {
|
||||
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
_bone[b].parent = AVATAR_BONE_NULL;
|
||||
|
|
@ -920,9 +886,7 @@ void Head::initializeSkeleton() {
|
|||
_bone[ AVATAR_BONE_RIGHT_SHIN ].parent = AVATAR_BONE_RIGHT_THIGH;
|
||||
_bone[ AVATAR_BONE_RIGHT_FOOT ].parent = AVATAR_BONE_RIGHT_SHIN;
|
||||
|
||||
//----------------------------------------------------------
|
||||
// specify the default pose position
|
||||
//----------------------------------------------------------
|
||||
_bone[ AVATAR_BONE_PELVIS_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.3, 0.0 );
|
||||
_bone[ AVATAR_BONE_MID_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.1, 0.0 );
|
||||
_bone[ AVATAR_BONE_CHEST_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 );
|
||||
|
|
@ -972,18 +936,14 @@ void Head::initializeSkeleton() {
|
|||
_bone[ AVATAR_BONE_RIGHT_SHIN ].radius = 0.015;
|
||||
_bone[ AVATAR_BONE_RIGHT_FOOT ].radius = 0.02;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// calculate bone length
|
||||
//----------------------------------------------------------------------------
|
||||
calculateBoneLengths();
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// generate world positions
|
||||
//----------------------------------------------------------------------------
|
||||
updateSkeleton();
|
||||
}
|
||||
|
||||
void Head::calculateBoneLengths() {
|
||||
void Avatar::calculateBoneLengths() {
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
_bone[b].length = glm::length( _bone[b].defaultPosePosition );
|
||||
}
|
||||
|
|
@ -994,16 +954,12 @@ void Head::calculateBoneLengths() {
|
|||
+ _bone[ AVATAR_BONE_RIGHT_HAND ].length;
|
||||
}
|
||||
|
||||
void Head::updateSkeleton() {
|
||||
//----------------------------------
|
||||
void Avatar::updateSkeleton() {
|
||||
// rotate body...
|
||||
//----------------------------------
|
||||
_orientation.setToIdentity();
|
||||
_orientation.yaw( _bodyYaw );
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// calculate positions of all bones by traversing the skeleton tree:
|
||||
//------------------------------------------------------------------------
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
if ( _bone[b].parent == AVATAR_BONE_NULL ) {
|
||||
_bone[b].orientation.set( _orientation );
|
||||
|
|
@ -1014,9 +970,7 @@ void Head::updateSkeleton() {
|
|||
_bone[b].position = _bone[ _bone[b].parent ].position;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// if this is not my avatar, then hand position comes from transmitted data
|
||||
//-------------------------------------------------------------------------------------
|
||||
if ( ! _isMine ) {
|
||||
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _handPosition;
|
||||
}
|
||||
|
|
@ -1035,7 +989,7 @@ void Head::updateSkeleton() {
|
|||
}
|
||||
}
|
||||
|
||||
void Head::initializeBodySprings() {
|
||||
void Avatar::initializeBodySprings() {
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
_bone[b].springyPosition = _bone[b].position;
|
||||
_bone[b].springyVelocity = glm::vec3( 0.0f, 0.0f, 0.0f );
|
||||
|
|
@ -1043,7 +997,7 @@ void Head::initializeBodySprings() {
|
|||
}
|
||||
|
||||
|
||||
void Head::updateBodySprings( float deltaTime ) {
|
||||
void Avatar::updateBodySprings( float deltaTime ) {
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
glm::vec3 springVector( _bone[b].springyPosition );
|
||||
|
||||
|
|
@ -1083,7 +1037,7 @@ void Head::updateBodySprings( float deltaTime ) {
|
|||
}
|
||||
}
|
||||
|
||||
glm::vec3 Head::getHeadLookatDirection() {
|
||||
glm::vec3 Avatar::getHeadLookatDirection() {
|
||||
return glm::vec3
|
||||
(
|
||||
_orientation.getFront().x,
|
||||
|
|
@ -1092,7 +1046,7 @@ glm::vec3 Head::getHeadLookatDirection() {
|
|||
);
|
||||
}
|
||||
|
||||
glm::vec3 Head::getHeadLookatDirectionUp() {
|
||||
glm::vec3 Avatar::getHeadLookatDirectionUp() {
|
||||
return glm::vec3
|
||||
(
|
||||
_orientation.getUp().x,
|
||||
|
|
@ -1101,7 +1055,7 @@ glm::vec3 Head::getHeadLookatDirectionUp() {
|
|||
);
|
||||
}
|
||||
|
||||
glm::vec3 Head::getHeadLookatDirectionRight() {
|
||||
glm::vec3 Avatar::getHeadLookatDirectionRight() {
|
||||
return glm::vec3
|
||||
(
|
||||
_orientation.getRight().x,
|
||||
|
|
@ -1110,7 +1064,7 @@ glm::vec3 Head::getHeadLookatDirectionRight() {
|
|||
);
|
||||
}
|
||||
|
||||
glm::vec3 Head::getHeadPosition() {
|
||||
glm::vec3 Avatar::getHeadPosition() {
|
||||
|
||||
if ( _usingBodySprings ) {
|
||||
return _bone[ AVATAR_BONE_HEAD ].springyPosition;
|
||||
|
|
@ -1120,13 +1074,13 @@ glm::vec3 Head::getHeadPosition() {
|
|||
}
|
||||
|
||||
|
||||
glm::vec3 Head::getBonePosition( AvatarBoneID b ) {
|
||||
glm::vec3 Avatar::getBonePosition( AvatarBoneID b ) {
|
||||
return _bone[b].position;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Head::updateHandMovement( float deltaTime ) {
|
||||
void Avatar::updateHandMovement( float deltaTime ) {
|
||||
glm::vec3 transformedHandMovement;
|
||||
|
||||
transformedHandMovement
|
||||
|
|
@ -1139,47 +1093,21 @@ void Head::updateHandMovement( float deltaTime ) {
|
|||
if (_isMine) {
|
||||
_handState = _mousePressed;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// if holding hands with another avatar, add a force to the hand...
|
||||
//---------------------------------------------------------------------
|
||||
if (( getHandState() == 1 )
|
||||
|| ( _otherAvatar.handState == 1 )) {
|
||||
if ( _nearOtherAvatar ) {
|
||||
|
||||
glm::vec3 vectorToOtherHand = _otherAvatar.handPosition - _handHolding.position;
|
||||
glm::vec3 vectorToMyHand = _bone[ AVATAR_BONE_RIGHT_HAND ].position - _handHolding.position;
|
||||
|
||||
_handHolding.velocity *= 0.7;
|
||||
_handHolding.velocity += ( vectorToOtherHand + vectorToMyHand ) * _handHolding.force * deltaTime;
|
||||
_handHolding.position += _handHolding.velocity;
|
||||
|
||||
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _handHolding.position;
|
||||
}
|
||||
}
|
||||
else {
|
||||
_handHolding.position = _bone[ AVATAR_BONE_RIGHT_HAND ].position;
|
||||
_handHolding.velocity = glm::vec3( 0.0, 0.0, 0.0 );
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
}
|
||||
|
||||
|
||||
void Avatar::updateArmIKAndConstraints( float deltaTime ) {
|
||||
|
||||
// determine the arm vector
|
||||
//-------------------------------------------------------------------------------
|
||||
glm::vec3 armVector = _bone[ AVATAR_BONE_RIGHT_HAND ].position;
|
||||
armVector -= _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
// test to see if right hand is being dragged beyond maximum arm length
|
||||
//-------------------------------------------------------------------------------
|
||||
float distance = glm::length( armVector );
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
// if right hand is being dragged beyond maximum arm length...
|
||||
//-------------------------------------------------------------------------------
|
||||
if ( distance > _maxArmLength ) {
|
||||
//-------------------------------------------------------------------------------
|
||||
// reset right hand to be constrained to maximum arm length
|
||||
//-------------------------------------------------------------------------------
|
||||
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
|
||||
glm::vec3 armNormal = armVector / distance;
|
||||
armVector = armNormal * _maxArmLength;
|
||||
|
|
@ -1189,35 +1117,27 @@ void Head::updateHandMovement( float deltaTime ) {
|
|||
_bone[ AVATAR_BONE_RIGHT_HAND ].position = constrainedPosition;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// set elbow position
|
||||
//-----------------------------------------------------------------------------
|
||||
glm::vec3 newElbowPosition = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
|
||||
newElbowPosition += armVector * ONE_HALF;
|
||||
glm::vec3 perpendicular = glm::cross( _orientation.getFront(), armVector );
|
||||
newElbowPosition += perpendicular * ( 1.0f - ( _maxArmLength / distance ) ) * ONE_HALF;
|
||||
_bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].position = newElbowPosition;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// set wrist position
|
||||
//-----------------------------------------------------------------------------
|
||||
glm::vec3 vv( _bone[ AVATAR_BONE_RIGHT_HAND ].position );
|
||||
vv -= _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].position;
|
||||
glm::vec3 newWristPosition = _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].position;
|
||||
newWristPosition += vv * 0.7f;
|
||||
_bone[ AVATAR_BONE_RIGHT_FOREARM ].position = newWristPosition;
|
||||
|
||||
// Set the vector we send for hand position to other people to be our right hand
|
||||
setHandPosition(_bone[ AVATAR_BONE_RIGHT_HAND ].position);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Head::renderBody() {
|
||||
//-----------------------------------------
|
||||
|
||||
void Avatar::renderBody() {
|
||||
|
||||
// Render bone positions as spheres
|
||||
//-----------------------------------------
|
||||
for (int b=0; b<NUM_AVATAR_BONES; b++) {
|
||||
//renderBoneAsBlock( (AvatarBoneID)b);
|
||||
|
||||
|
|
@ -1240,9 +1160,7 @@ void Head::renderBody() {
|
|||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Render lines connecting the bone positions
|
||||
//-----------------------------------------------------
|
||||
if ( _usingBodySprings ) {
|
||||
glColor3f( 0.4f, 0.5f, 0.6f );
|
||||
glLineWidth(3.0);
|
||||
|
|
@ -1270,9 +1188,7 @@ void Head::renderBody() {
|
|||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// if the hand is grasping, show it...
|
||||
//---------------------------------------------------------
|
||||
if (( _usingBodySprings ) && ( _handState == 1 )) {
|
||||
glPushMatrix();
|
||||
glTranslatef
|
||||
|
|
@ -1289,9 +1205,7 @@ void Head::renderBody() {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Head::renderBoneAsBlock( AvatarBoneID b ) {
|
||||
void Avatar::renderBoneAsBlock( AvatarBoneID b ) {
|
||||
glColor3fv( skinColor );
|
||||
glPushMatrix();
|
||||
glTranslatef( _bone[b].springyPosition.x, _bone[b].springyPosition.y, _bone[b].springyPosition.z );
|
||||
|
|
@ -1303,13 +1217,13 @@ void Head::renderBoneAsBlock( AvatarBoneID b ) {
|
|||
glPopMatrix();
|
||||
}
|
||||
|
||||
void Head::SetNewHeadTarget(float pitch, float yaw) {
|
||||
void Avatar::SetNewHeadTarget(float pitch, float yaw) {
|
||||
_head.pitchTarget = pitch;
|
||||
_head.yawTarget = yaw;
|
||||
}
|
||||
|
||||
// getting data from Android transmitte app
|
||||
void Head::processTransmitterData(unsigned char* packetData, int numBytes) {
|
||||
void Avatar::processTransmitterData(unsigned char* packetData, int numBytes) {
|
||||
// Read a packet from a transmitter app, process the data
|
||||
float accX, accY, accZ,
|
||||
graX, graY, graZ,
|
||||
|
|
@ -1,13 +1,13 @@
|
|||
//
|
||||
// Head.h
|
||||
// Avatar.h
|
||||
// interface
|
||||
//
|
||||
// Created by Philip Rosedale on 9/11/12.
|
||||
// Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
|
||||
//
|
||||
|
||||
#ifndef __interface__head__
|
||||
#define __interface__head__
|
||||
#ifndef __interface__avatar__
|
||||
#define __interface__avatar__
|
||||
|
||||
#include <AvatarData.h>
|
||||
#include <Orientation.h>
|
||||
|
|
@ -100,13 +100,6 @@ struct AvatarHandHolding
|
|||
float force;
|
||||
};
|
||||
|
||||
struct OtherAvatar
|
||||
{
|
||||
glm::vec3 handPosition;
|
||||
int handState;
|
||||
};
|
||||
|
||||
|
||||
struct AvatarBone
|
||||
{
|
||||
AvatarBoneID parent; // which bone is this bone connected to?
|
||||
|
|
@ -163,12 +156,12 @@ struct AvatarHead
|
|||
};
|
||||
|
||||
|
||||
class Head : public AvatarData {
|
||||
class Avatar : public AvatarData {
|
||||
public:
|
||||
Head(bool isMine);
|
||||
~Head();
|
||||
Head(const Head &otherHead);
|
||||
Head* clone() const;
|
||||
Avatar(bool isMine);
|
||||
~Avatar();
|
||||
Avatar(const Avatar &otherAvatar);
|
||||
Avatar* clone() const;
|
||||
|
||||
void reset();
|
||||
void UpdateGyros(float frametime, SerialInterface * serialInterface, glm::vec3 * gravity);
|
||||
|
|
@ -191,7 +184,6 @@ class Head : public AvatarData {
|
|||
glm::vec3 getHeadPosition();
|
||||
glm::vec3 getBonePosition( AvatarBoneID b );
|
||||
glm::vec3 getBodyUpDirection();
|
||||
//int getHandState();
|
||||
float getGirth();
|
||||
float getHeight();
|
||||
|
||||
|
|
@ -206,6 +198,7 @@ class Head : public AvatarData {
|
|||
void stopHandMovement();
|
||||
void setHandMovementValues( glm::vec3 movement );
|
||||
void updateHandMovement( float deltaTime );
|
||||
void updateArmIKAndConstraints( float deltaTime );
|
||||
|
||||
float getAverageLoudness() {return _head.averageLoudness;};
|
||||
void setAverageLoudness(float al) {_head.averageLoudness = al;};
|
||||
|
|
@ -230,10 +223,8 @@ class Head : public AvatarData {
|
|||
bool _isMine;
|
||||
glm::vec3 _TEST_bigSpherePosition;
|
||||
float _TEST_bigSphereRadius;
|
||||
OtherAvatar _otherAvatar;
|
||||
bool _mousePressed;
|
||||
float _bodyYawDelta;
|
||||
bool _nearOtherAvatar;
|
||||
bool _usingBodySprings;
|
||||
glm::vec3 _movedHandOffset;
|
||||
float _springVelocityDecay;
|
||||
|
|
@ -253,10 +244,10 @@ class Head : public AvatarData {
|
|||
timeval _transmitterTimer;
|
||||
float _transmitterHz;
|
||||
int _transmitterPackets;
|
||||
Avatar* _interactingOther;
|
||||
bool _interactingOtherIsNearby;
|
||||
|
||||
//-----------------------------
|
||||
// private methods...
|
||||
//-----------------------------
|
||||
void initializeSkeleton();
|
||||
void updateSkeleton();
|
||||
void initializeBodySprings();
|
||||
|
|
@ -55,7 +55,7 @@ class Log {
|
|||
public:
|
||||
|
||||
explicit Log(FILE* tPipeTo = stdout, unsigned bufferedLines = 1024,
|
||||
unsigned defaultLogWidth = 240, unsigned defaultCharWidth = 6, unsigned defaultCharHeight = 20);
|
||||
unsigned defaultLogWidth = 400, unsigned defaultCharWidth = 6, unsigned defaultCharHeight = 20);
|
||||
~Log();
|
||||
|
||||
void setLogWidth(unsigned pixels);
|
||||
|
|
|
|||
|
|
@ -34,7 +34,17 @@ float Stars::changeLOD(float fraction, float overalloc, float realloc) {
|
|||
return float(_ptrController->changeLOD(fraction, overalloc, realloc));
|
||||
}
|
||||
|
||||
void Stars::render(float fovDiagonal, float aspect, glm::mat4 const& view) {
|
||||
void Stars::render(float fovY, float aspect, float nearZ) {
|
||||
|
||||
// determine length of screen diagonal from quadrant height and aspect ratio
|
||||
float quadrantHeight = nearZ * tan(angleConvert<Degrees,Radians>(fovY) * 0.5f);
|
||||
float halfDiagonal = sqrt(quadrantHeight * quadrantHeight * (1.0f + aspect * aspect));
|
||||
|
||||
// determine fov angle in respect to the diagonal
|
||||
float fovDiagonal = atan(halfDiagonal / nearZ) * 2.0f;
|
||||
|
||||
// pull the modelview matrix off the GL stack
|
||||
glm::mat4 view; glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(view));
|
||||
|
||||
_ptrController->render(fovDiagonal, aspect, glm::affineInverse(view));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,9 +13,9 @@
|
|||
|
||||
namespace starfield { class Controller; }
|
||||
|
||||
/**
|
||||
* Starfield rendering component.
|
||||
*/
|
||||
//
|
||||
// Starfield rendering component.
|
||||
//
|
||||
class Stars {
|
||||
|
||||
starfield::Controller* _ptrController;
|
||||
|
|
@ -25,49 +25,49 @@ class Stars {
|
|||
Stars();
|
||||
~Stars();
|
||||
|
||||
/**
|
||||
* Reads input file from URL. Returns true upon success.
|
||||
*
|
||||
* The limit parameter allows to reduce the number of stars
|
||||
* that are loaded, keeping the brightest ones.
|
||||
*/
|
||||
//
|
||||
// Reads input file from URL. Returns true upon success.
|
||||
//
|
||||
// The limit parameter allows to reduce the number of stars
|
||||
// that are loaded, keeping the brightest ones.
|
||||
//
|
||||
bool readInput(const char* url, const char* cacheFile = 0l, unsigned limit = 200000);
|
||||
|
||||
/**
|
||||
* Renders the starfield from a local viewer's perspective.
|
||||
* The parameter specifies the field of view.
|
||||
*/
|
||||
void render(float fovDiagonal, float aspect, glm::mat4 const& view);
|
||||
//
|
||||
// Renders the starfield from a local viewer's perspective.
|
||||
// The parameters specifiy the field of view.
|
||||
//
|
||||
void render(float fovY, float aspect, float nearZ);
|
||||
|
||||
/**
|
||||
* Sets the resolution for FOV culling.
|
||||
*
|
||||
* The parameter determines the number of tiles in azimuthal
|
||||
* and altitudinal directions.
|
||||
*
|
||||
* GPU resources are updated upon change in which case 'true'
|
||||
* is returned.
|
||||
*/
|
||||
//
|
||||
// Sets the resolution for FOV culling.
|
||||
//
|
||||
// The parameter determines the number of tiles in azimuthal
|
||||
// and altitudinal directions.
|
||||
//
|
||||
// GPU resources are updated upon change in which case 'true'
|
||||
// is returned.
|
||||
//
|
||||
bool setResolution(unsigned k);
|
||||
|
||||
/**
|
||||
* Allows to alter the number of stars to be rendered given a
|
||||
* factor. The least brightest ones are omitted first.
|
||||
*
|
||||
* The further parameters determine when GPU resources should
|
||||
* be reallocated. Its value is fractional in respect to the
|
||||
* last number of stars 'n' that caused 'n * (1+overalloc)' to
|
||||
* be allocated. When the next call to setLOD causes the total
|
||||
* number of stars that could be rendered to drop below 'n *
|
||||
* (1-realloc)' or rises above 'n * (1+realloc)' GPU resources
|
||||
* are updated. Note that all parameters must be fractions,
|
||||
* that is within the range [0;1] and that 'overalloc' must be
|
||||
* greater than or equal to 'realloc'.
|
||||
*
|
||||
* The current level of detail is returned as a float in [0;1].
|
||||
*/
|
||||
//
|
||||
// Allows to alter the number of stars to be rendered given a
|
||||
// factor. The least brightest ones are omitted first.
|
||||
//
|
||||
// The further parameters determine when GPU resources should
|
||||
// be reallocated. Its value is fractional in respect to the
|
||||
// last number of stars 'n' that caused 'n * (1+overalloc)' to
|
||||
// be allocated. When the next call to setLOD causes the total
|
||||
// number of stars that could be rendered to drop below 'n *
|
||||
// (1-realloc)' or rises above 'n * (1+realloc)' GPU resources
|
||||
// are updated. Note that all parameters must be fractions,
|
||||
// that is within the range [0;1] and that 'overalloc' must be
|
||||
// greater than or equal to 'realloc'.
|
||||
//
|
||||
// The current level of detail is returned as a float in [0;1].
|
||||
//
|
||||
float changeLOD(float factor,
|
||||
float overalloc = 0.25, float realloc = 0.15);
|
||||
float overalloc = 0.25, float realloc = 0.15);
|
||||
|
||||
private:
|
||||
// don't copy/assign
|
||||
|
|
|
|||
|
|
@ -60,8 +60,8 @@ VoxelSystem::~VoxelSystem() {
|
|||
pthread_mutex_destroy(&bufferWriteLock);
|
||||
}
|
||||
|
||||
void VoxelSystem::setViewerHead(Head *newViewerHead) {
|
||||
viewerHead = newViewerHead;
|
||||
void VoxelSystem::setViewerAvatar(Avatar *newViewerAvatar) {
|
||||
viewerAvatar = newViewerAvatar;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -187,7 +187,7 @@ int VoxelSystem::treeToArrays(VoxelNode *currentNode, const glm::vec3& nodePosi
|
|||
int voxelsAdded = 0;
|
||||
|
||||
float halfUnitForVoxel = powf(0.5, *currentNode->octalCode) * (0.5 * TREE_SCALE);
|
||||
glm::vec3 viewerPosition = viewerHead->getPosition();
|
||||
glm::vec3 viewerPosition = viewerAvatar->getPosition();
|
||||
|
||||
// debug LOD code
|
||||
glm::vec3 debugNodePosition;
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include <AgentData.h>
|
||||
#include <VoxelTree.h>
|
||||
#include <ViewFrustum.h>
|
||||
#include "Head.h"
|
||||
#include "Avatar.h"
|
||||
#include "Util.h"
|
||||
#include "world.h"
|
||||
|
||||
|
|
@ -34,7 +34,7 @@ public:
|
|||
void render();
|
||||
void setVoxelsRendered(int v) {voxelsRendered = v;};
|
||||
int getVoxelsRendered() {return voxelsRendered;};
|
||||
void setViewerHead(Head *newViewerHead);
|
||||
void setViewerAvatar(Avatar *newViewerAvatar);
|
||||
void loadVoxelsFile(const char* fileName,bool wantColorRandomizer);
|
||||
void createSphere(float r,float xc, float yc, float zc, float s, bool solid, bool wantColorRandomizer);
|
||||
|
||||
|
|
@ -67,7 +67,7 @@ private:
|
|||
static float _minDistance;
|
||||
|
||||
int voxelsRendered;
|
||||
Head *viewerHead;
|
||||
Avatar *viewerAvatar;
|
||||
VoxelTree *tree;
|
||||
GLfloat *readVerticesArray;
|
||||
GLubyte *readColorsArray;
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@
|
|||
#include "MenuColumn.h"
|
||||
#include "Menu.h"
|
||||
#include "Camera.h"
|
||||
#include "Head.h"
|
||||
#include "Avatar.h"
|
||||
#include "Particle.h"
|
||||
#include "Texture.h"
|
||||
#include "Cloud.h"
|
||||
|
|
@ -107,7 +107,7 @@ Oscilloscope audioScope(256,200,true);
|
|||
|
||||
ViewFrustum viewFrustum; // current state of view frustum, perspective, orientation, etc.
|
||||
|
||||
Head myAvatar(true); // The rendered avatar of oneself
|
||||
Avatar myAvatar(true); // The rendered avatar of oneself
|
||||
Camera myCamera; // My view onto the world (sometimes on myself :)
|
||||
Camera viewFrustumOffsetCamera; // The camera we use to sometimes show the view frustum from an offset mode
|
||||
|
||||
|
|
@ -157,6 +157,8 @@ VoxelDetail paintingVoxel; // The voxel we're painting if we're paintin
|
|||
unsigned char dominantColor = 0; // The dominant color of the voxel we're painting
|
||||
bool perfStatsOn = false; // Do we want to display perfStats?
|
||||
|
||||
bool logOn = true; // Whether to show on-screen log
|
||||
|
||||
int noiseOn = 0; // Whether to add random noise
|
||||
float noise = 1.0; // Overall magnitude scaling for random noise levels
|
||||
|
||||
|
|
@ -382,7 +384,7 @@ void initDisplay(void)
|
|||
void init(void)
|
||||
{
|
||||
voxels.init();
|
||||
voxels.setViewerHead(&myAvatar);
|
||||
voxels.setViewerAvatar(&myAvatar);
|
||||
myAvatar.setRenderYaw(startYaw);
|
||||
|
||||
initializeHandController();
|
||||
|
|
@ -862,9 +864,10 @@ void display(void)
|
|||
if (::starsOn) {
|
||||
// should be the first rendering pass - w/o depth buffer / lighting
|
||||
|
||||
glm::mat4 view;
|
||||
glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(view));
|
||||
stars.render(angleConvert<Degrees,Radians>(whichCamera.getFieldOfView()), aspectRatio, view);
|
||||
|
||||
// finally render the starfield
|
||||
stars.render(whichCamera.getFieldOfView(), aspectRatio, whichCamera.getNearClip());
|
||||
|
||||
}
|
||||
|
||||
glEnable(GL_LIGHTING);
|
||||
|
|
@ -919,7 +922,7 @@ void display(void)
|
|||
if ( !::lookingInMirror ) balls.render();
|
||||
|
||||
// Render the world box
|
||||
if (!::lookingInMirror && statsOn) render_world_box();
|
||||
if (!::lookingInMirror && ::statsOn) { render_world_box(); }
|
||||
|
||||
// brad's frustum for debugging
|
||||
if (::frustumOn) renderViewFrustum(::viewFrustum);
|
||||
|
|
@ -961,13 +964,12 @@ void display(void)
|
|||
// Show detected levels from the serial I/O ADC channel sensors
|
||||
if (displayLevels) serialPort.renderLevels(WIDTH,HEIGHT);
|
||||
|
||||
// Display miscellaneous text stats onscreen
|
||||
if (statsOn) {
|
||||
glLineWidth(1.0f);
|
||||
glPointSize(1.0f);
|
||||
displayStats();
|
||||
logger.render(WIDTH, HEIGHT);
|
||||
}
|
||||
// Display stats and log text onscreen
|
||||
glLineWidth(1.0f);
|
||||
glPointSize(1.0f);
|
||||
|
||||
if (::statsOn) { displayStats(); }
|
||||
if (::logOn) { logger.render(WIDTH, HEIGHT); }
|
||||
|
||||
// Show menu
|
||||
if (::menuOn) {
|
||||
|
|
@ -1057,6 +1059,11 @@ int setNoise(int state) {
|
|||
return iRet;
|
||||
}
|
||||
|
||||
int setLog(int state) {
|
||||
int iRet = setValue(state, &::logOn);
|
||||
return iRet;
|
||||
}
|
||||
|
||||
int setGyroLook(int state) {
|
||||
int iRet = setValue(state, &::gyroLook);
|
||||
return iRet;
|
||||
|
|
@ -1071,7 +1078,7 @@ int setStars(int state) {
|
|||
}
|
||||
|
||||
int setStats(int state) {
|
||||
return setValue(state, &statsOn);
|
||||
return setValue(state, &::statsOn);
|
||||
}
|
||||
|
||||
int setMenu(int state) {
|
||||
|
|
@ -1196,7 +1203,8 @@ void initMenu() {
|
|||
|
||||
// Tools
|
||||
menuColumnTools = menu.addColumn("Tools");
|
||||
menuColumnTools->addRow("Stats (/)", setStats);
|
||||
menuColumnTools->addRow("Stats (/)", setStats);
|
||||
menuColumnTools->addRow("Log ", setLog);
|
||||
menuColumnTools->addRow("(M)enu", setMenu);
|
||||
|
||||
// Frustum Options
|
||||
|
|
@ -1354,7 +1362,7 @@ void key(unsigned char k, int x, int y)
|
|||
|
||||
// Process keypresses
|
||||
if (k == 'q' || k == 'Q') ::terminate();
|
||||
if (k == '/') statsOn = !statsOn; // toggle stats
|
||||
if (k == '/') ::statsOn = !::statsOn; // toggle stats
|
||||
if (k == '*') ::starsOn = !::starsOn; // toggle stars
|
||||
if (k == 'V' || k == 'v') ::showingVoxels = !::showingVoxels; // toggle voxels
|
||||
if (k == 'F') ::frustumOn = !::frustumOn; // toggle view frustum debugging
|
||||
|
|
@ -1603,7 +1611,7 @@ void mouseoverFunc( int x, int y)
|
|||
|
||||
void attachNewHeadToAgent(Agent *newAgent) {
|
||||
if (newAgent->getLinkedData() == NULL) {
|
||||
newAgent->setLinkedData(new Head(false));
|
||||
newAgent->setLinkedData(new Avatar(false));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -130,17 +130,18 @@ namespace starfield {
|
|||
|
||||
float halfPersp = perspective * 0.5f;
|
||||
|
||||
// determine dimensions based on a sought screen diagonal
|
||||
//
|
||||
// ww + hh = dd
|
||||
// a = h / w => h = wa
|
||||
// ww + ww aa = dd
|
||||
// ww = dd / (1 + aa)
|
||||
float diag = 2.0f * std::sin(halfPersp);
|
||||
// define diagonal and near distance
|
||||
float halfDiag = std::sin(halfPersp);
|
||||
float nearClip = std::cos(halfPersp);
|
||||
|
||||
float hw = 0.5f * sqrt(diag * diag / (1.0f + aspect * aspect));
|
||||
float hh = hw * aspect;
|
||||
// determine half dimensions based on the screen diagonal
|
||||
//
|
||||
// ww + hh = dd
|
||||
// a = w / h => w = ha
|
||||
// hh + hh aa = dd
|
||||
// hh = dd / (1 + aa)
|
||||
float hh = sqrt(halfDiag * halfDiag / (1.0f + aspect * aspect));
|
||||
float hw = hh * aspect;
|
||||
|
||||
// cancel all translation
|
||||
mat4 matrix = orientation;
|
||||
|
|
@ -154,6 +155,9 @@ namespace starfield {
|
|||
float azimuth = atan2(ahead.x,-ahead.z) + Radians::pi();
|
||||
float altitude = atan2(-ahead.y, hypotf(ahead.x, ahead.z));
|
||||
angleHorizontalPolar<Radians>(azimuth, altitude);
|
||||
float const eps = 0.002f;
|
||||
altitude = glm::clamp(altitude,
|
||||
-Radians::halfPi() + eps, Radians::halfPi() - eps);
|
||||
#if STARFIELD_HEMISPHERE_ONLY
|
||||
altitude = std::max(0.0f, altitude);
|
||||
#endif
|
||||
|
|
@ -162,24 +166,25 @@ namespace starfield {
|
|||
|
||||
// printLog("Stars.cpp: starting on tile #%d\n", tileIndex);
|
||||
|
||||
|
||||
#if STARFIELD_DEBUG_CULLING
|
||||
mat4 matrix_debug = glm::translate(
|
||||
glm::frustum(-hw, hw, -hh, hh, nearClip, 10.0f),
|
||||
vec3(0.0f, 0.0f, -4.0f)) * glm::affineInverse(matrix);
|
||||
mat4 matrix_debug = glm::translate(glm::frustum(-hw, hw, -hh, hh, nearClip, 10.0f),
|
||||
vec3(0.0f, 0.0f, -4.0f)) *
|
||||
glm::affineInverse(matrix);
|
||||
#endif
|
||||
|
||||
matrix = glm::frustum(-hw,hw, -hh,hh, nearClip,10.0f)
|
||||
* glm::affineInverse(matrix);
|
||||
matrix = glm::frustum(-hw,hw, -hh,hh, nearClip,10.0f) * glm::affineInverse(matrix);
|
||||
|
||||
this->_itrOutIndex = (unsigned*) _arrBatchOffs;
|
||||
this->_vecWxform = vec3(row(matrix, 3));
|
||||
this->_valHalfPersp = halfPersp;
|
||||
this->_valMinBright = minBright;
|
||||
|
||||
floodFill(_arrTile + tileIndex, TileSelection(*this,
|
||||
_arrTile, _arrTile + _objTiling.getTileCount(),
|
||||
(Tile**) _arrBatchCount));
|
||||
TileSelection::Cursor cursor;
|
||||
cursor.current = _arrTile + _objTiling.getTileIndex(azimuth, altitude);
|
||||
cursor.firstInRow = _arrTile + _objTiling.getTileIndex(0.0f, altitude);
|
||||
|
||||
floodFill(cursor, TileSelection(*this, _arrTile, _arrTile + _objTiling.getTileCount(),
|
||||
(TileSelection::Cursor*) _arrBatchCount));
|
||||
|
||||
#if STARFIELD_DEBUG_CULLING
|
||||
# define matrix matrix_debug
|
||||
|
|
@ -269,31 +274,35 @@ namespace starfield {
|
|||
|
||||
class TileSelection {
|
||||
|
||||
public:
|
||||
struct Cursor { Tile* current, * firstInRow; };
|
||||
private:
|
||||
Renderer& _refRenderer;
|
||||
Tile** const _arrStack;
|
||||
Tile** _itrStack;
|
||||
Cursor* const _arrStack;
|
||||
Cursor* _itrStack;
|
||||
Tile const* const _arrTile;
|
||||
Tile const* const _itrTilesEnd;
|
||||
Tile const* const _ptrTilesEnd;
|
||||
|
||||
public:
|
||||
|
||||
TileSelection(Renderer& renderer, Tile const* tiles,
|
||||
Tile const* tiles_end, Tile** stack) :
|
||||
Tile const* tiles_end, Cursor* stack) :
|
||||
|
||||
_refRenderer(renderer),
|
||||
_arrStack(stack),
|
||||
_itrStack(stack),
|
||||
_arrTile(tiles),
|
||||
_itrTilesEnd(tiles_end) {
|
||||
_ptrTilesEnd(tiles_end) {
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
// flood fill strategy
|
||||
|
||||
bool select(Tile* t) {
|
||||
bool select(Cursor const& c) {
|
||||
Tile* t = c.current;
|
||||
|
||||
if (t < _arrTile || t >= _itrTilesEnd ||
|
||||
if (t < _arrTile || t >= _ptrTilesEnd ||
|
||||
!! (t->flags & Tile::checked)) {
|
||||
|
||||
// out of bounds or been here already
|
||||
|
|
@ -311,7 +320,8 @@ namespace starfield {
|
|||
return false;
|
||||
}
|
||||
|
||||
bool process(Tile* t) {
|
||||
bool process(Cursor const& c) {
|
||||
Tile* t = c.current;
|
||||
|
||||
if (! (t->flags & Tile::visited)) {
|
||||
|
||||
|
|
@ -321,14 +331,39 @@ namespace starfield {
|
|||
return false;
|
||||
}
|
||||
|
||||
void right(Tile*& cursor) const { cursor += 1; }
|
||||
void left(Tile*& cursor) const { cursor -= 1; }
|
||||
void up(Tile*& cursor) const { cursor += yStride(); }
|
||||
void down(Tile*& cursor) const { cursor -= yStride(); }
|
||||
void right(Cursor& c) const {
|
||||
|
||||
void defer(Tile* t) { *_itrStack++ = t; }
|
||||
c.current += 1;
|
||||
if (c.current == c.firstInRow + _refRenderer._objTiling.getAzimuthalTiles()) {
|
||||
c.current = c.firstInRow;
|
||||
}
|
||||
}
|
||||
void left(Cursor& c) const {
|
||||
|
||||
if (c.current == c.firstInRow) {
|
||||
c.current = c.firstInRow + _refRenderer._objTiling.getAzimuthalTiles();
|
||||
}
|
||||
c.current -= 1;
|
||||
}
|
||||
void up(Cursor& c) const {
|
||||
|
||||
bool deferred(Tile*& cursor) {
|
||||
unsigned d = _refRenderer._objTiling.getAzimuthalTiles();
|
||||
c.current += d;
|
||||
c.firstInRow += d;
|
||||
}
|
||||
void down(Cursor& c) const {
|
||||
|
||||
unsigned d = _refRenderer._objTiling.getAzimuthalTiles();
|
||||
c.current -= d;
|
||||
c.firstInRow -= d;
|
||||
}
|
||||
|
||||
void defer(Cursor const& t) {
|
||||
|
||||
*_itrStack++ = t;
|
||||
}
|
||||
|
||||
bool deferred(Cursor& cursor) {
|
||||
|
||||
if (_itrStack != _arrStack) {
|
||||
cursor = *--_itrStack;
|
||||
|
|
@ -336,12 +371,6 @@ namespace starfield {
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned yStride() const {
|
||||
|
||||
return _refRenderer._objTiling.getAzimuthalTiles();
|
||||
}
|
||||
};
|
||||
|
||||
bool visitTile(Tile* t) {
|
||||
|
|
@ -362,6 +391,7 @@ namespace starfield {
|
|||
bool tileVisible(Tile* t, unsigned i) {
|
||||
|
||||
float slice = _objTiling.getSliceAngle();
|
||||
float halfSlice = 0.5f * slice;
|
||||
unsigned stride = _objTiling.getAzimuthalTiles();
|
||||
float azimuth = (i % stride) * slice;
|
||||
float altitude = (i / stride) * slice - Radians::halfPi();
|
||||
|
|
@ -371,14 +401,13 @@ namespace starfield {
|
|||
vec3 tileCenter = vec3(gx * exz, sin(altitude), gz * exz);
|
||||
float w = dot(_vecWxform, tileCenter);
|
||||
|
||||
float halfSlice = 0.5f * slice;
|
||||
float daz = halfSlice * cos(abs(altitude) - halfSlice);
|
||||
float daz = halfSlice * cos(std::max(0.0f, abs(altitude) - halfSlice));
|
||||
float dal = halfSlice;
|
||||
float adjustedNear = cos(_valHalfPersp + sqrt(daz * daz + dal * dal));
|
||||
|
||||
// printLog("Stars.cpp: checking tile #%d, w = %f, near = %f\n", i, w, nearClip);
|
||||
|
||||
return w > adjustedNear;
|
||||
return w >= adjustedNear;
|
||||
}
|
||||
|
||||
void updateVertexCount(Tile* t, BrightnessLevel minBright) {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
//
|
||||
// starfield/renderer/
|
||||
// starfield/renderer/Tiling.h
|
||||
// interface
|
||||
//
|
||||
// Created by Tobias Schwinger on 3/22/13.
|
||||
|
|
@ -51,6 +51,7 @@ namespace starfield {
|
|||
private:
|
||||
|
||||
unsigned discreteAngle(float unsigned_angle) const {
|
||||
|
||||
return unsigned(floor(unsigned_angle * _valRcpSlice + 0.5f));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,32 +9,31 @@
|
|||
#ifndef __hifi__FloodFill__
|
||||
#define __hifi__FloodFill__
|
||||
|
||||
/**
|
||||
* Line scanning, iterative flood fill algorithm.
|
||||
*
|
||||
* The strategy must obey the following contract:
|
||||
*
|
||||
* There is an associated cursor that represents a position on the image.
|
||||
* The member functions 'left(C&)', 'right(C&)', 'up(C&)', and 'down(C&)'
|
||||
* move it.
|
||||
* The state of a cursor can be deferred to temporary storage (typically a
|
||||
* stack or a queue) using the 'defer(C const&)' member function.
|
||||
* Calling 'deferred(C&)' restores a cursor's state from temporary storage
|
||||
* and removes it there.
|
||||
* The 'select(C const&)' and 'process(C const&)' functions control the
|
||||
* algorithm. The former is called to determine where to go. It may be
|
||||
* called multiple times but does not have to (and should not) return
|
||||
* 'true' more than once for a pixel to be selected (will cause memory
|
||||
* overuse, otherwise). The latter will never be called for a given pixel
|
||||
* unless previously selected. It may be called multiple times, in which
|
||||
* case it should return 'true' upon successful processing and 'false'
|
||||
* when an already processed pixel has been visited.
|
||||
*
|
||||
* Note: The terms "image" and "pixel" are used for illustratory purposes
|
||||
* and mean "undirected graph with 4-connected 2D grid topology" and "node",
|
||||
* respectively.
|
||||
*
|
||||
*/
|
||||
//
|
||||
// Line scanning, iterative flood fill algorithm.
|
||||
//
|
||||
// The strategy must obey the following contract:
|
||||
//
|
||||
// There is an associated cursor that represents a position on the image.
|
||||
// The member functions 'left(C&)', 'right(C&)', 'up(C&)', and 'down(C&)'
|
||||
// move it.
|
||||
// The state of a cursor can be deferred to temporary storage (typically a
|
||||
// stack or a queue) using the 'defer(C const&)' member function.
|
||||
// Calling 'deferred(C&)' restores a cursor's state from temporary storage
|
||||
// and removes it there.
|
||||
// The 'select(C const&)' and 'process(C const&)' functions control the
|
||||
// algorithm. The former is called to determine where to go. It may be
|
||||
// called multiple times but does not have to (and should not) return
|
||||
// 'true' more than once for a pixel to be selected (will cause memory
|
||||
// overuse, otherwise). The latter will never be called for a given pixel
|
||||
// unless previously selected. It may be called multiple times, in which
|
||||
// case it should return 'true' upon successful processing and 'false'
|
||||
// when an already processed pixel has been visited.
|
||||
//
|
||||
// Note: The terms "image" and "pixel" are used for illustratory purposes
|
||||
// and mean "undirected graph with 4-connected 2D grid topology" and "node",
|
||||
// respectively.
|
||||
//
|
||||
template< class Strategy, typename Cursor >
|
||||
void floodFill(Cursor const& position,
|
||||
Strategy const& strategy = Strategy());
|
||||
|
|
@ -63,57 +62,39 @@ struct floodFill_impl : Strategy {
|
|||
}
|
||||
|
||||
Cursor higher, lower, h,l, i;
|
||||
bool higherFound, lowerFound, hf, lf;
|
||||
do {
|
||||
|
||||
if (! process(position)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
higher = position; higherFound = false;
|
||||
up(higher); yTest(higher, higherFound);
|
||||
lower = position; lowerFound = false;
|
||||
down(lower); yTest(lower, lowerFound);
|
||||
higher = position;
|
||||
up(higher);
|
||||
if (select(higher)) { defer(higher); }
|
||||
|
||||
lower = position;
|
||||
down(lower);
|
||||
if (select(lower)) { defer(lower); }
|
||||
|
||||
i = position, h = higher, l = lower;
|
||||
hf = higherFound, lf = lowerFound;
|
||||
do {
|
||||
right(i), right(h), right(l); yTest(h,hf); yTest(l,lf);
|
||||
|
||||
} while (selectAndProcess(i));
|
||||
right(i), right(h), right(l);
|
||||
if (select(h)) { defer(h); }
|
||||
if (select(l)) { defer(l); }
|
||||
|
||||
} while (select(i) && process(i));
|
||||
|
||||
i = position, h = higher, l = lower;
|
||||
hf = higherFound, lf = lowerFound;
|
||||
do {
|
||||
left(i); left(h); left(l); yTest(h,hf); yTest(l,lf);
|
||||
left(i); left(h); left(l);
|
||||
if (select(h)) { defer(h); }
|
||||
if (select(l)) { defer(l); }
|
||||
|
||||
} while (selectAndProcess(i));
|
||||
} while (select(i) && process(i));
|
||||
|
||||
} while (deferred(position));
|
||||
}
|
||||
|
||||
bool selectAndProcess(Cursor const& i) {
|
||||
|
||||
if (select(i)) {
|
||||
|
||||
process(i);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void yTest(Cursor const& i, bool& state) {
|
||||
|
||||
if (! select(i)) {
|
||||
|
||||
state = false;
|
||||
|
||||
} else if (! state) {
|
||||
|
||||
state = true;
|
||||
defer(i);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template< class Strategy, typename Cursor >
|
||||
|
|
|
|||
Loading…
Reference in a new issue