Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-05 05:50:19 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of https://github.com/worklist/hifi into keep_local_voxels

Browse source
This commit is contained in:
ZappoMan 2013-10-13 13:37:10 -07:00
commit 69a5b319a2
18 changed files with 161 additions and 886 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

89
assignment-client/src/Agent.cpp
View file

@ -8,8 +8,6 @@
#include <curl/curl.h>
#include <QtScript/QScriptEngine>
#include <AvatarData.h>
#include <NodeList.h>
#include <UUID.h>
@ -22,9 +20,9 @@ Agent::Agent(const unsigned char* dataBuffer, int numBytes) :
Assignment(dataBuffer, numBytes),
_shouldStop(false)
{
}
void Agent::stop() {
_shouldStop = true;
}
@ -41,10 +39,27 @@ static size_t writeScriptDataToString(void *contents, size_t size, size_t nmemb,
return realSize;
}
QScriptValue vec3toScriptValue(QScriptEngine *engine, const glm::vec3 &vec3) {
QScriptValue obj = engine->newObject();
obj.setProperty("x", vec3.x);
obj.setProperty("y", vec3.y);
obj.setProperty("z", vec3.z);
return obj;
}
void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
vec3.x = object.property("x").toVariant().toFloat();
vec3.y = object.property("y").toVariant().toFloat();
vec3.z = object.property("z").toVariant().toFloat();
}
void Agent::run() {
NodeList* nodeList = NodeList::getInstance();
nodeList->setOwnerType(NODE_TYPE_AGENT);
nodeList->setNodeTypesOfInterest(&NODE_TYPE_VOXEL_SERVER, 1);
const char AGENT_NODE_TYPES_OF_INTEREST[2] = { NODE_TYPE_VOXEL_SERVER, NODE_TYPE_AUDIO_MIXER };
nodeList->setNodeTypesOfInterest(AGENT_NODE_TYPES_OF_INTEREST, sizeof(AGENT_NODE_TYPES_OF_INTEREST));
nodeList->getNodeSocket()->setBlocking(false);
@ -84,6 +99,9 @@ void Agent::run() {
QScriptEngine engine;
// register meta-type for glm::vec3 conversions
qScriptRegisterMetaType(&engine, vec3toScriptValue, vec3FromScriptValue);
QScriptValue agentValue = engine.newQObject(this);
engine.globalObject().setProperty("Agent", agentValue);
@ -93,14 +111,14 @@ void Agent::run() {
QScriptValue treeScaleValue = engine.newVariant(QVariant(TREE_SCALE));
engine.globalObject().setProperty("TREE_SCALE", treeScaleValue);
const long long VISUAL_DATA_SEND_INTERVAL_USECS = (1 / 60.0f) * 1000 * 1000;
// let the VoxelPacketSender know how frequently we plan to call it
voxelScripter.getVoxelPacketSender()->setProcessCallIntervalHint(VISUAL_DATA_SEND_INTERVAL_USECS);
voxelScripter.getVoxelPacketSender()->setProcessCallIntervalHint(INJECT_INTERVAL_USECS);
QScriptValue visualSendIntervalValue = engine.newVariant((QVariant(VISUAL_DATA_SEND_INTERVAL_USECS / 1000)));
engine.globalObject().setProperty("VISUAL_DATA_SEND_INTERVAL_MS", visualSendIntervalValue);
// hook in a constructor for audio injectorss
AudioInjector scriptedAudioInjector(BUFFER_LENGTH_SAMPLES_PER_CHANNEL);
QScriptValue audioInjectorValue = engine.newQObject(&scriptedAudioInjector);
engine.globalObject().setProperty("AudioInjector", audioInjectorValue);
qDebug() << "Downloaded script:" << scriptContents << "\n";
QScriptValue result = engine.evaluate(scriptContents);
@ -111,19 +129,20 @@ void Agent::run() {
qDebug() << "Uncaught exception at line" << line << ":" << result.toString() << "\n";
}
timeval thisSend;
timeval startTime;
gettimeofday(&startTime, NULL);
timeval lastDomainServerCheckIn = {};
int numMicrosecondsSleep = 0;
sockaddr_in senderAddress;
unsigned char receivedData[MAX_PACKET_SIZE];
ssize_t receivedBytes;
bool hasVoxelServer = false;
int thisFrame = 0;
bool firstDomainCheckIn = false;
while (!_shouldStop) {
// update the thisSend timeval to the current time
gettimeofday(&thisSend, NULL);
// if we're not hearing from the domain-server we should stop running
if (NodeList::getInstance()->getNumNoReplyDomainCheckIns() == MAX_SILENT_DOMAIN_SERVER_CHECK_INS) {
@ -136,38 +155,44 @@ void Agent::run() {
NodeList::getInstance()->sendDomainServerCheckIn();
}
if (!hasVoxelServer) {
for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
if (node->getType() == NODE_TYPE_VOXEL_SERVER) {
hasVoxelServer = true;
if (firstDomainCheckIn) {
// find the audio-mixer in the NodeList so we can inject audio at it
Node* audioMixer = NodeList::getInstance()->soloNodeOfType(NODE_TYPE_AUDIO_MIXER);
emit willSendAudioDataCallback();
if (audioMixer) {
int usecToSleep = usecTimestamp(&startTime) + (thisFrame++ * INJECT_INTERVAL_USECS) - usecTimestampNow();
if (usecToSleep > 0) {
usleep(usecToSleep);
}
scriptedAudioInjector.injectAudio(NodeList::getInstance()->getNodeSocket(), audioMixer->getPublicSocket());
}
}
if (hasVoxelServer) {
// allow the scripter's call back to setup visual data
emit willSendVisualDataCallback();
if (engine.hasUncaughtException()) {
int line = engine.uncaughtExceptionLineNumber();
qDebug() << "Uncaught exception at line" << line << ":" << engine.uncaughtException().toString() << "\n";
}
// release the queue of edit voxel messages.
voxelScripter.getVoxelPacketSender()->releaseQueuedMessages();
// since we're in non-threaded mode, call process so that the packets are sent
voxelScripter.getVoxelPacketSender()->process();
}
if (engine.hasUncaughtException()) {
int line = engine.uncaughtExceptionLineNumber();
qDebug() << "Uncaught exception at line" << line << ":" << engine.uncaughtException().toString() << "\n";
}
while (NodeList::getInstance()->getNodeSocket()->receive((sockaddr*) &senderAddress, receivedData, &receivedBytes)) {
if (!firstDomainCheckIn && receivedData[0] == PACKET_TYPE_DOMAIN) {
firstDomainCheckIn = true;
}
NodeList::getInstance()->processNodeData((sockaddr*) &senderAddress, receivedData, receivedBytes);
}
// sleep for the correct amount of time to have data send be consistently timed
if ((numMicrosecondsSleep = VISUAL_DATA_SEND_INTERVAL_USECS - (usecTimestampNow() - usecTimestamp(&thisSend))) > 0) {
usleep(numMicrosecondsSleep);
}
}
} else {

8
assignment-client/src/Agent.h
View file

@ -9,9 +9,13 @@
#ifndef __hifi__Agent__
#define __hifi__Agent__
#include <vector>
#include <QtScript/QScriptEngine>
#include <QtCore/QObject>
#include <QtCore/QUrl>
#include <AudioInjector.h>
#include <Assignment.h>
class Agent : public Assignment {
@ -23,9 +27,13 @@ public:
public slots:
void stop();
signals:
void willSendAudioDataCallback();
void willSendVisualDataCallback();
private:
static QScriptValue AudioInjectorConstructor(QScriptContext *context, QScriptEngine *engine);
bool volatile _shouldStop;
std::vector<AudioInjector*> _audioInjectors;
};
#endif /* defined(__hifi__Operative__) */

3
assignment-client/src/main.cpp
View file

@ -66,12 +66,13 @@ void childClient() {
// create a request assignment, accept assignments defined by the overidden type
Assignment requestAssignment(Assignment::RequestCommand, ::overiddenAssignmentType);
// if we're here we have no assignment, so send a request
qDebug() << "Waiting for assignment -" << requestAssignment << "\n";
while (true) {
if (usecTimestampNow() - usecTimestamp(&lastRequest) >= ASSIGNMENT_REQUEST_INTERVAL_USECS) {
gettimeofday(&lastRequest, NULL);
// if we're here we have no assignment, so send a request
nodeList->sendAssignment(requestAssignment);
}

20
interface/src/Application.cpp
View file

@ -105,6 +105,8 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
_profile(QString()),
_mouseX(0),
_mouseY(0),
_lastMouseMove(usecTimestampNow()),
_mouseHidden(false),
_touchAvgX(0.0f),
_touchAvgY(0.0f),
_isTouchPressed(false),
@ -909,6 +911,9 @@ void Application::keyPressEvent(QKeyEvent* event) {
case Qt::Key_8:
_swatch.handleEvent(event->key(), Menu::getInstance()->isOptionChecked(MenuOption::VoxelGetColorMode));
break;
case Qt::Key_At:
Menu::getInstance()->goToUser();
break;
default:
event->ignore();
break;
@ -979,6 +984,12 @@ void Application::keyReleaseEvent(QKeyEvent* event) {
}
void Application::mouseMoveEvent(QMouseEvent* event) {
_lastMouseMove = usecTimestampNow();
if (_mouseHidden) {
getGLWidget()->setCursor(Qt::ArrowCursor);
_mouseHidden = false;
}
if (activeWindow() == _window) {
_mouseX = event->x();
_mouseY = event->y();
@ -2120,6 +2131,15 @@ void Application::update(float deltaTime) {
_audio.setLastVelocity(_myAvatar.getVelocity());
_audio.eventuallyAnalyzePing();
#endif
// watch mouse position, if it hasn't moved, hide the cursor
uint64_t now = usecTimestampNow();
int elapsed = now - _lastMouseMove;
const int HIDE_CURSOR_TIMEOUT = 1 * 1000 * 1000; // 1 second
if (elapsed > HIDE_CURSOR_TIMEOUT) {
getGLWidget()->setCursor(Qt::BlankCursor);
_mouseHidden = true;
}
}
void Application::updateAvatar(float deltaTime) {

2
interface/src/Application.h
View file

@ -305,6 +305,8 @@ private:
int _mouseY;
int _mouseDragStartedX;
int _mouseDragStartedY;
uint64_t _lastMouseMove;
bool _mouseHidden;
float _touchAvgX;
float _touchAvgY;

3
interface/src/Menu.cpp
View file

@ -101,7 +101,7 @@ Menu::Menu() :
SLOT(goToLocation()));
addActionToQMenuAndActionHash(fileMenu,
MenuOption::GoToUser,
Qt::CTRL | Qt::SHIFT | Qt::Key_U,
Qt::Key_At,
this,
SLOT(goToUser()));
@ -300,7 +300,6 @@ Menu::Menu() :
&appInstance->getAvatar()->getHead().getFace(),
SLOT(cycleRenderMode()));
addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::UsePerlinFace, 0, false);
addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::LookAtVectors, 0, true);
addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::LookAtIndicator, 0, true);
addCheckableActionToQMenuAndActionHash(avatarOptionsMenu,

3
interface/src/Menu.h
View file

@ -66,6 +66,7 @@ public slots:
void saveSettings(QSettings* settings = NULL);
void importSettings();
void exportSettings();
void goToUser();
private slots:
void aboutApp();
@ -73,7 +74,6 @@ private slots:
void editPreferences();
void goToDomain();
void goToLocation();
void goToUser();
void bandwidthDetailsClosed();
void voxelStatsDetailsClosed();
void cycleFrustumRenderMode();
@ -212,7 +212,6 @@ namespace MenuOption {
const QString TestRaveGlove = "Test Rave Glove";
const QString TreeStats = "Calculate Tree Stats";
const QString TransmitterDrive = "Transmitter Drive";
const QString UsePerlinFace = "Use Perlin's Face";
const QString Quit = "Quit";
const QString UseVoxelShader = "Use Voxel Shader";
const QString VoxelsAsPoints = "Draw Voxels as Points";

21
interface/src/avatar/Head.cpp
View file

@ -84,7 +84,6 @@ Head::Head(Avatar* owningAvatar) :
_cameraYaw(_yaw),
_isCameraMoving(false),
_face(this),
_perlinFace(this),
_blendFace(this)
{
if (USING_PHYSICAL_MOHAWK) {
@ -291,18 +290,14 @@ void Head::render(float alpha, bool isMine) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_RESCALE_NORMAL);
if (Menu::getInstance()->isOptionChecked(MenuOption::UsePerlinFace) && isMine) {
_perlinFace.render();
} else {
renderMohawk();
renderHeadSphere();
renderEyeBalls();
renderEars();
renderMouth();
renderNose();
renderEyeBrows();
}
renderMohawk();
renderHeadSphere();
renderEyeBalls();
renderEars();
renderMouth();
renderNose();
renderEyeBrows();
}
if (_blendFace.isActive()) {

3
interface/src/avatar/Head.h
View file

@ -21,7 +21,6 @@
#include "BlendFace.h"
#include "Face.h"
#include "InterfaceConfig.h"
#include "PerlinFace.h"
#include "world.h"
#include "devices/SerialInterface.h"
#include "renderer/TextureCache.h"
@ -133,7 +132,6 @@ private:
float _cameraYaw;
bool _isCameraMoving;
Face _face;
PerlinFace _perlinFace;
BlendFace _blendFace;
QSharedPointer<Texture> _dilatedIrisTexture;
@ -156,7 +154,6 @@ private:
void updateHairPhysics(float deltaTime);
friend class BlendFace;
friend class PerlinFace;
};
#endif

10
interface/src/avatar/MyAvatar.cpp
View file

@ -221,12 +221,14 @@ void MyAvatar::simulate(float deltaTime, Transmitter* transmitter) {
// Damp avatar velocity
const float LINEAR_DAMPING_STRENGTH = 0.5f;
const float SPEED_BRAKE_POWER = _scale * 10.0f;
const float SQUARED_DAMPING_STRENGTH = 0.007f;
const float SQUARED_DAMPING_STRENGTH = 0.007f;
const float SLOW_NEAR_RADIUS = 5.f;
float linearDamping = LINEAR_DAMPING_STRENGTH;
const float AVATAR_DAMPING_FACTOR = 120.f;
if (_distanceToNearestAvatar < _scale * PERIPERSONAL_RADIUS) {
linearDamping *= 1.f + AVATAR_DAMPING_FACTOR * (PERIPERSONAL_RADIUS - _distanceToNearestAvatar);
const float NEAR_AVATAR_DAMPING_FACTOR = 50.f;
if (_distanceToNearestAvatar < _scale * SLOW_NEAR_RADIUS) {
linearDamping *= 1.f + NEAR_AVATAR_DAMPING_FACTOR *
((SLOW_NEAR_RADIUS - _distanceToNearestAvatar) / SLOW_NEAR_RADIUS);
}
if (_speedBrakes) {
applyDamping(deltaTime, _velocity, linearDamping * SPEED_BRAKE_POWER, SQUARED_DAMPING_STRENGTH * SPEED_BRAKE_POWER);

680
interface/src/avatar/PerlinFace.cpp
View file

@ -1,680 +0,0 @@
//
// PerlinFace.cpp
// interface
//
// Created by Clément Brisset on 9/4/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "PerlinFace.h"
#include "Head.h"
#include "Avatar.h"
#include "Application.h"
// The following points only reference the left part of the face.
enum {
BROW_RIGHT_TOP = 0, BROW_MID_TOP, BROW_LEFT, BROW_MID_BOTTOM, BROW_RIGHT_BOTTOM,
EYE_RIGHT, EYE_MID_TOP, EYE_LEFT, EYE_MID_BOTTOM,
EYEBALL_BOTTOM, EYEBALL_TOP, EYEBALL_MID,
NOSTRIL_TOP, NOSTRIL_LEFT, NOSTRIL_BOTTOM, NOSE_LEFT, NOSE_RIGHT,
MOUTH_TOP_OUT, MOUTH_MID_OUT, MOUTH_BOTTOM_OUT,
MOUTH_TOP_IN, MOUTH_MID_IN, MOUTH_BOTTOM_IN,
EAR_CENTER, EAR_BOTTOM_RIGHT, EAR_BOTTOM_LEFT, EAR_TOP_RIGHT, EAR_TOP_MID, EAR_TOP_LEFT, EAR_BACK,
CHIN_BOTTOM, CHIN_TIP, CHIN_IN,
CHICK_LEFT, CHICK_MID, CHICK_RIGHT,
FOREHEAD_RIGHT, FOREHEAD_LEFT,
JAW_BOTTOM, JAW_LEFT, JAW_BOTTOM_LEFT,
HAIR_SIDE_1, HAIR_SIDE_2, HAIR_SIDE_3, HAIR_SIDE_4, HAIR_SIDE_5,
HAIR_1, HAIR_2, HAIR_3, HAIR_4, HAIR_5, HAIR_6, HAIR_7, HAIR_8, HAIR_9,
NUM_VERTICES
};
static const float VERTICES[]
= { -5,70,44, -12,72,42, -22,68,35, -12,70,42, -5,68,44.5, // left brow
-6,60,43.7, -12,62,44, -19,60,38, -12,58,43, // left eye
-12,60,37, -14.1,62.1,37, -13.15,61.25,32, // left eyeball
-2,45,52, -5,44,47, -1,42.5,49, -4,47,48, -2,48.5,52.5, // left part nose
-4,38,50, -8,30.2,46, -3,23.5,46, // left out mouse
-2.1,35,48, -5,31,47, -1.5,29,47, // left in mouse
-26.5,55,14, -23.3,51.3,7, -26.5,50.7,7, -23,59,9, -26,61,7, -27.6,59.5,7, -13,50,0, // left ear
-6.1,16.8,44.5, -5,20.7,46.5, -3,23,45, // left chin
-22,51,37, -15,36,39, -13.6,26,38, // left chick
-10,84,34, -22,80,24, // left forehead
-6,22,20, -22,35,15, -19,31.5,10, // left jaw
-14,99,0, -27,85,0, -30,70,0, -30,52,-4, -28,30,0, // left hair side
// left hair line
-16,86,39, -12,95,27, -12,99,13, -12,97,-5, -15,91,-17, -18,80,-26, -16,60,-29, -10,40,-23, -15,30,-12,
5,70,44, 12,72,42, 22,68,35, 12,70,42, 5,68,44.5, // 0-4 right brow
6,60,43.7, 12,62,44, 19,60,38, 12,58,43, // 5-8 right eye
12,60,37, 14.1,62.1,37, 13.15,61.15,32, // 9-11 right eyeball
2,45,52, 5,44,47, 1,42.5,49, 4,47,48, 2,48.5,52.5, // 12-16 right part nose
4,38,50, 8,30.2,46, 3,23.5,46, // 17-19 right out mouse
2.1,35,48, 5,31,47, 1.5,29,47, // 20-22 right in mouse
26.5,55,14, 23.3,51.3,7, 26.5,50.7,7, 23,59,9, 26,61,7, 27.6,59.5,7, 13,50,0, // 23-29 right ear
6.1,16.8,44.5, 5,20.7,46.5, 3,23,45, // 30-32 right chin
22,51,37, 15,36,39, 13.6,26,38, // 33-35 right chick
10,84,34, 22,80,24, // 36-37 right forehead
6,22,20, 22,35,15, 19,31.5,10, // 38-40 right jaw
14,99,0, 27,85,0, 30,70,0, 30,52,-4, 28,30,0, // 41-45 right hair side
// 45-53 right hair line
16,86,39, 12,95,27, 12,99,13, 12,97,-5, 15,91,-17, 18,80,-26, 16,60,-29, 10,40,-23, 15,30,-12,
// Not used at the moment.
7,34,44, 7,29.2,42, // teeth
16,36,33, 16,16,0, 40,7,0, 40,0,0, 20,-40,-23}; // shoulders, back, misc
const int TRIANGLES_NUMBER = 206;
const int VERTEX_PER_TRIANGLE = 3;
const int FLOAT_PER_VERTEX = 3;
const GLfloat NO_SPECULAR_COLOR[] = { 0.0f, 0.0f, 0.0f, 1.0f };
glm::vec3* PerlinFace::_vertices = NULL;
GLfloat* PerlinFace::_triangles = NULL;
GLfloat* PerlinFace::_normals = NULL;
GLubyte* PerlinFace::_colors = NULL;
PerlinFace::PerlinFace(Head *owningHead)
: _owningHead(owningHead),
_initialized(false),
_vertexNumber(0),
_trianglesCount(0),
_oldNormals(NULL),
_newNormals(NULL),
_trianglesPos(NULL),
_normalsPos(NULL),
_colorsPos(NULL),
_vboID(0),
_nboID(0),
_cboID(0),
_browsD_L(0),
_browsD_R(0),
_browsU_C(0),
_browsU_L(0),
_browsU_R(0),
_mouthSize(0),
_mouthSmileLeft(0),
_mouthSmileRight(0),
_eyeBlink_L(0),
_eyeBlink_R(0),
_eyeOpen_L(0),
_eyeOpen_R(0) {
}
PerlinFace::~PerlinFace() {
if (_initialized) {
glDeleteBuffers(1, &_vboID);
glDeleteBuffers(1, &_nboID);
glDeleteBuffers(1, &_cboID);
delete[] _oldNormals;
delete[] _newNormals;
}
}
void staticCleanup() {
delete[] PerlinFace::_vertices;
delete[] PerlinFace::_triangles;
delete[] PerlinFace::_normals;
delete[] PerlinFace::_colors;
}
void PerlinFace::init() {
if (_initialized) {
return;
}
glGenBuffers(1, &_vboID);
glGenBuffers(1, &_nboID);
glGenBuffers(1, &_cboID);
_vertexNumber = sizeof(VERTICES) / (FLOAT_PER_VERTEX * sizeof(float));
_oldNormals = new glm::vec3[_vertexNumber];
_newNormals = new glm::vec3[_vertexNumber];
if (_vertices == NULL) {
_vertices = new glm::vec3[_vertexNumber];
for (int i = 0; i < _vertexNumber; ++i) {
_vertices[i] = getVec3(i);
}
_trianglesPos = _triangles = new GLfloat[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
_normalsPos = _normals = new GLfloat[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
_colorsPos = _colors = new GLubyte[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
atexit(staticCleanup);
}
_initialized = true;
}
void PerlinFace::update() {
if (!_initialized) {
init();
}
updatePositions();
updateVertices();
glBindBuffer(GL_ARRAY_BUFFER, _vboID);
glBufferData(GL_ARRAY_BUFFER,
FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLfloat),
_triangles,
GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, _nboID);
glBufferData(GL_ARRAY_BUFFER,
FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLfloat),
_normals,
GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, _cboID);
glBufferData(GL_ARRAY_BUFFER,
FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLubyte),
_colors,
GL_DYNAMIC_DRAW);
}
#include <renderer/ProgramObject.h>
void PerlinFace::render() {
glPushMatrix();
update();
// Jump to head position, orientation and scale
glm::quat orientation = _owningHead->getOrientation();
glm::vec3 axis = glm::axis(orientation);
glTranslatef(_owningHead->getPosition().x, _owningHead->getPosition().y, _owningHead->getPosition().z);
glScalef(_owningHead->getScale(), _owningHead->getScale(), _owningHead->getScale());
glRotatef(glm::angle(orientation), axis.x, axis.y, axis.z);
glPushMatrix(); { // This block use the coordinates system of perlin's face points.
// Correct head scale and offset from hard coded points coordinates.
glScalef(2.0f * BODY_BALL_RADIUS_HEAD_BASE / (_vertices[HAIR_2].y - _vertices[JAW_BOTTOM].y),
2.0f * BODY_BALL_RADIUS_HEAD_BASE / (_vertices[HAIR_2].y - _vertices[JAW_BOTTOM].y),
2.0f * BODY_BALL_RADIUS_HEAD_BASE / (_vertices[HAIR_2].y - _vertices[JAW_BOTTOM].y));
glTranslatef(0, -60.0f, 20.0f);
/**/
glEnableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, _vboID);
glVertexPointer(FLOAT_PER_VERTEX, GL_FLOAT, 0, 0);
glEnableClientState(GL_NORMAL_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, _nboID);
glNormalPointer(GL_FLOAT, 0, 0);
glEnableClientState(GL_COLOR_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, _cboID);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, VERTEX_PER_TRIANGLE * _trianglesCount);
// Draw eyes
glColor3d(0, 0, 0);
glBegin(GL_LINE_LOOP);
glVertex3d(_vertices[EYE_LEFT].x, _vertices[EYE_LEFT].y, _vertices[EYE_LEFT].z);
glVertex3d(_vertices[EYE_MID_TOP].x, _vertices[EYE_MID_TOP].y, _vertices[EYE_MID_TOP].z);
glVertex3d(_vertices[EYE_RIGHT].x, _vertices[EYE_RIGHT].y, _vertices[EYE_RIGHT].z);
glVertex3d(_vertices[EYE_MID_BOTTOM].x, _vertices[EYE_MID_BOTTOM].y, _vertices[EYE_MID_BOTTOM].z);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3d(_vertices[NUM_VERTICES + EYE_LEFT].x,
_vertices[NUM_VERTICES + EYE_LEFT].y,
_vertices[NUM_VERTICES + EYE_LEFT].z);
glVertex3d(_vertices[NUM_VERTICES + EYE_MID_TOP].x,
_vertices[NUM_VERTICES + EYE_MID_TOP].y,
_vertices[NUM_VERTICES + EYE_MID_TOP].z);
glVertex3d(_vertices[NUM_VERTICES + EYE_RIGHT].x,
_vertices[NUM_VERTICES + EYE_RIGHT].y,
_vertices[NUM_VERTICES + EYE_RIGHT].z);
glVertex3d(_vertices[NUM_VERTICES + EYE_MID_BOTTOM].x,
_vertices[NUM_VERTICES + EYE_MID_BOTTOM].y,
_vertices[NUM_VERTICES + EYE_MID_BOTTOM].z);
glEnd();
} glPopMatrix();
const float EYEBALL_RADIUS = 0.008f;
const float EYEBALL_COLOR[4] = { 0.9f, 0.9f, 0.8f, 1.0f };
const float IRIS_RADIUS = 0.0035;
const float IRIS_PROTRUSION = 0.0065f;
// render white ball of left eyeball
glm::vec3 eyePos = glm::vec3(0.024f, 0.0f, -0.032f);
Head::_irisProgram.bind();
_owningHead->_dilatedIrisTexture = Head::_irisTexture->getDilatedTexture(_owningHead->_pupilDilation);
glBindTexture(GL_TEXTURE_2D, _owningHead->_dilatedIrisTexture->getID());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glEnable(GL_TEXTURE_2D);
orientation = _owningHead->getOrientation();
glm::vec3 front = orientation * IDENTITY_FRONT;
// render left iris
glm::quat leftIrisRotation;
glPushMatrix(); {
glTranslatef(eyePos.x, eyePos.y, eyePos.z); //translate to eyeball position
//rotate the eyeball to aim towards the lookat position
glm::vec3 targetLookatVector = _owningHead->_lookAtPosition - eyePos;
leftIrisRotation = rotationBetween(front, targetLookatVector) * orientation;
glm::vec3 rotationAxis = glm::axis(leftIrisRotation);
glRotatef(glm::angle(leftIrisRotation), rotationAxis.x, rotationAxis.y, rotationAxis.z);
glTranslatef(0.0f, 0.0f, IRIS_PROTRUSION);
glScalef(IRIS_RADIUS * 2.0f,
IRIS_RADIUS * 2.0f,
IRIS_RADIUS); // flatten the iris
// this ugliness is simply to invert the model transform and get the eye position in model space
Head::_irisProgram.setUniform(Head::_eyePositionLocation, (glm::inverse(leftIrisRotation) *
(Application::getInstance()->getCamera()->getPosition() - eyePos) +
glm::vec3(0.0f, 0.0f, IRIS_PROTRUSION)) * glm::vec3(1.0f / (IRIS_RADIUS * 2.0f),
1.0f / (IRIS_RADIUS * 2.0f), 1.0f / IRIS_RADIUS));
glutSolidSphere(0.5f, 15, 15);
}
glPopMatrix();
eyePos.x = - eyePos.x;
// render right iris
glm::quat rightIrisRotation;
glPushMatrix(); {
glTranslatef(eyePos.x, eyePos.y, eyePos.z); //translate to eyeball position
//rotate the eyeball to aim towards the lookat position
glm::vec3 targetLookatVector = _owningHead->_lookAtPosition - eyePos;
rightIrisRotation = rotationBetween(front, targetLookatVector) * orientation;
glm::vec3 rotationAxis = glm::axis(rightIrisRotation);
glRotatef(glm::angle(rightIrisRotation), rotationAxis.x, rotationAxis.y, rotationAxis.z);
glTranslatef(0.0f, 0.0f, IRIS_PROTRUSION);
glScalef(IRIS_RADIUS * 2.0f,
IRIS_RADIUS * 2.0f,
IRIS_RADIUS); // flatten the iris
// this ugliness is simply to invert the model transform and get the eye position in model space
Head::_irisProgram.setUniform(Head::_eyePositionLocation, (glm::inverse(rightIrisRotation) *
(Application::getInstance()->getCamera()->getPosition() - eyePos) +
glm::vec3(0.0f, 0.0f, IRIS_PROTRUSION)) * glm::vec3(1.0f / (IRIS_RADIUS * 2.0f),
1.0f / (IRIS_RADIUS * 2.0f), 1.0f / IRIS_RADIUS));
glutSolidSphere(0.5f, 15, 15);
}
glPopMatrix();
Head::_irisProgram.release();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glPushMatrix();
glColor4fv(EYEBALL_COLOR);
glTranslatef(eyePos.x, eyePos.y, eyePos.z);
glutSolidSphere(EYEBALL_RADIUS, 30, 30);
glPopMatrix();
//render white ball of right eyeball
glPushMatrix();
glColor4fv(EYEBALL_COLOR);
glTranslatef(-eyePos.x, eyePos.y, eyePos.z);
glutSolidSphere(EYEBALL_RADIUS, 30, 30);
glPopMatrix();
glPopMatrix();
}
#include "Application.h"
void PerlinFace::updatePositions() {
const float BROWS_UP_MAX = 3;
const float BROWS_DOWN_MAX = 1;
const float BROWS_UP_CENTER_MAX = 1;
Faceshift* faceshift = Application::getInstance()->getFaceshift();
if (faceshift->isActive()) {
_browsD_L = faceshift->getBrowDownLeft();
_browsD_R = faceshift->getBrowDownRight();
_browsU_C = faceshift->getBrowUpCenter();
_browsU_L = faceshift->getBrowUpLeft();
_browsU_R = faceshift->getBrowUpRight();
_mouthSize = faceshift->getMouthSize();
_mouthSmileLeft = faceshift->getMouthSmileLeft();
_mouthSmileRight = faceshift->getMouthSmileRight();
_eyeBlink_L = faceshift->getLeftBlink();
_eyeBlink_R = faceshift->getRightBlink();
_eyeOpen_L = faceshift->getLeftEyeOpen();
_eyeOpen_R = faceshift->getRightEyeOpen();
}
// Update left brow
_vertices[BROW_LEFT].y = getVec3(BROW_LEFT).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
- _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[BROW_MID_TOP].y = getVec3(BROW_MID_TOP).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX;
_vertices[BROW_MID_BOTTOM].y = getVec3(BROW_MID_BOTTOM).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX;
_vertices[BROW_RIGHT_TOP].y = getVec3(BROW_RIGHT_TOP).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[BROW_RIGHT_BOTTOM].y = getVec3(BROW_RIGHT_BOTTOM).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
// Update right brow
_vertices[NUM_VERTICES + BROW_LEFT].y = getVec3(NUM_VERTICES + BROW_LEFT).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
- _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[NUM_VERTICES + BROW_MID_TOP].y = getVec3(NUM_VERTICES + BROW_MID_TOP).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX;
_vertices[NUM_VERTICES + BROW_MID_BOTTOM].y = getVec3(NUM_VERTICES + BROW_MID_BOTTOM).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX;
_vertices[NUM_VERTICES + BROW_RIGHT_TOP].y = getVec3(NUM_VERTICES + BROW_RIGHT_TOP).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[NUM_VERTICES + BROW_RIGHT_BOTTOM].y = getVec3(NUM_VERTICES + BROW_RIGHT_BOTTOM).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
const float MOUTH_UP_MAX = 6.5f;
const float MOUTH_SIDE_UP_MAX = 4.0f;
const float SMILE_FACTOR = 1.0f / 3.0f; // 0 = No smile, 1 = The Jocker.
// Mouth
_vertices[MOUTH_BOTTOM_IN].y = getVec3(MOUTH_BOTTOM_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[MOUTH_BOTTOM_OUT].y = getVec3(MOUTH_BOTTOM_OUT).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[MOUTH_MID_IN] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(MOUTH_MID_IN)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(CHICK_MID);
_vertices[MOUTH_MID_OUT] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(MOUTH_MID_OUT)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(CHICK_MID);
_vertices[NUM_VERTICES + MOUTH_BOTTOM_IN].y = getVec3(NUM_VERTICES + MOUTH_BOTTOM_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES + MOUTH_BOTTOM_OUT].y = getVec3(NUM_VERTICES + MOUTH_BOTTOM_OUT).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES + MOUTH_MID_IN] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(NUM_VERTICES + MOUTH_MID_IN)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(NUM_VERTICES + CHICK_MID);
_vertices[NUM_VERTICES + MOUTH_MID_OUT] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(NUM_VERTICES + MOUTH_MID_OUT)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(NUM_VERTICES + CHICK_MID);
// Jaw
_vertices[CHIN_IN].y = getVec3(CHIN_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[CHIN_TIP].y = getVec3(CHIN_TIP).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[CHIN_BOTTOM].y = getVec3(CHIN_BOTTOM).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_IN].y = getVec3(NUM_VERTICES + CHIN_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_TIP].y = getVec3(NUM_VERTICES + CHIN_TIP).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_BOTTOM].y = getVec3(NUM_VERTICES + CHIN_BOTTOM).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
// Eyelids
glm::vec3 topLeftEyelid = getVec3(EYE_MID_TOP);
glm::vec3 bottomLeftEyelid = getVec3(EYE_MID_BOTTOM);
glm::vec3 topRightEyelid = getVec3(NUM_VERTICES + EYE_MID_TOP);
glm::vec3 bottomRightEyelid = getVec3(NUM_VERTICES + EYE_MID_BOTTOM);
_vertices[EYE_MID_TOP] = (1.0f - (_eyeBlink_L - _eyeOpen_L / 2.0f)) * topLeftEyelid
+ (_eyeBlink_L - _eyeOpen_L / 2.0f) * (topLeftEyelid + bottomLeftEyelid) / 2.0f;
_vertices[EYE_MID_BOTTOM] = (1.0f - (_eyeBlink_L - _eyeOpen_L / 2.0f)) * bottomLeftEyelid
+ (_eyeBlink_L - _eyeOpen_L / 2.0f) * (topLeftEyelid + bottomLeftEyelid) / 2.0f;
_vertices[NUM_VERTICES + EYE_MID_TOP] = (1.0f - (_eyeBlink_R - _eyeOpen_R / 2.0f)) * topRightEyelid
+ (_eyeBlink_R - _eyeOpen_R / 2.0f) * (topRightEyelid + bottomRightEyelid) / 2.0f;
_vertices[NUM_VERTICES + EYE_MID_BOTTOM] = (1.0f - (_eyeBlink_R - _eyeOpen_R / 2.0f)) * bottomRightEyelid
+ (_eyeBlink_R - _eyeOpen_R / 2.0f) * (topRightEyelid + bottomRightEyelid) / 2.0f;
}
void PerlinFace::updateVertices() {
const GLubyte SKIN_COLOR[] = {255, 214, 163};
const GLubyte MOUSE_COLOR[] = {200, 159, 108};
const GLubyte HAIR_COLOR[] = {0, 0, 0};
_trianglesCount = 0;
_trianglesPos = _triangles;
_normalsPos = _normals;
_colorsPos = _colors;
std::swap(_oldNormals, _newNormals);
// Brows
addTriangles(BROW_LEFT, BROW_MID_TOP, BROW_MID_BOTTOM, 0, 0, 0);
addTriangles(BROW_MID_BOTTOM, BROW_MID_TOP, BROW_RIGHT_TOP, 0, 0, 0);
addTriangles(BROW_MID_BOTTOM, BROW_RIGHT_TOP, BROW_RIGHT_BOTTOM, 0, 0, 0);
// Forehead
addTriangles(FOREHEAD_LEFT, FOREHEAD_RIGHT, BROW_MID_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(FOREHEAD_LEFT, BROW_MID_TOP, BROW_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(FOREHEAD_RIGHT, BROW_RIGHT_TOP, BROW_MID_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(FOREHEAD_RIGHT, BROW_RIGHT_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(BROW_RIGHT_TOP, BROW_RIGHT_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Eyes
addTriangles(BROW_LEFT, BROW_MID_BOTTOM, EYE_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EYE_LEFT, BROW_MID_BOTTOM, EYE_MID_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(BROW_MID_BOTTOM, BROW_RIGHT_BOTTOM, EYE_MID_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EYE_MID_TOP, BROW_RIGHT_BOTTOM, EYE_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(BROW_RIGHT_BOTTOM, EYE_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Temp eye draw
addTriangles(EYE_LEFT, EYE_MID_TOP, EYEBALL_MID, 255, 255, 255);
addTriangles(EYE_MID_TOP, EYE_RIGHT, EYEBALL_MID, 255, 255, 255);
addTriangles(EYE_RIGHT, EYE_MID_BOTTOM, EYEBALL_MID, 255, 255, 255);
addTriangles(EYE_MID_BOTTOM, EYE_LEFT, EYEBALL_MID, 255, 255, 255);
// Chick
addTriangles(EAR_CENTER, FOREHEAD_LEFT, BROW_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(BROW_LEFT, CHICK_LEFT, EAR_CENTER, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(BROW_LEFT, EYE_LEFT, CHICK_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EYE_LEFT, EYE_MID_BOTTOM, CHICK_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EYE_MID_BOTTOM, EYE_RIGHT, NOSTRIL_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_LEFT, EYE_MID_BOTTOM, NOSTRIL_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_LEFT, NOSTRIL_LEFT, CHICK_MID, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_MID, NOSTRIL_LEFT, MOUTH_TOP_OUT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_MID, MOUTH_TOP_OUT, MOUTH_MID_OUT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_MID, MOUTH_MID_OUT, CHIN_TIP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_MID, CHIN_TIP, CHICK_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_RIGHT, CHIN_TIP, CHIN_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(CHICK_LEFT, CHICK_MID, CHICK_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_CENTER, CHICK_LEFT, JAW_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(JAW_LEFT, CHICK_LEFT, CHICK_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Nose
addTriangles(EYE_RIGHT, NOSE_LEFT, NOSTRIL_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EYE_RIGHT, NOSE_RIGHT, NOSE_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(NOSE_LEFT, NOSE_RIGHT, NOSTRIL_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(EYE_RIGHT, NOSE_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(NOSE_RIGHT, NOSTRIL_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(NOSTRIL_LEFT, NOSE_LEFT, NOSTRIL_TOP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(NOSTRIL_LEFT, NOSTRIL_TOP, NOSTRIL_BOTTOM, 0, 0, 0);
addJunction(NOSTRIL_TOP, NOSTRIL_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(NOSTRIL_LEFT, NOSTRIL_BOTTOM, MOUTH_TOP_OUT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(NOSTRIL_BOTTOM, MOUTH_TOP_OUT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Mouth
addTriangles(MOUTH_TOP_OUT, MOUTH_TOP_IN, MOUTH_MID_OUT, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addTriangles(MOUTH_TOP_IN, MOUTH_MID_IN, MOUTH_MID_OUT, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addTriangles(MOUTH_MID_OUT, MOUTH_MID_IN, MOUTH_BOTTOM_OUT, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addTriangles(MOUTH_MID_IN, MOUTH_BOTTOM_IN, MOUTH_BOTTOM_OUT, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addJunction(MOUTH_TOP_OUT, MOUTH_TOP_IN, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addJunction(MOUTH_BOTTOM_OUT, MOUTH_BOTTOM_IN, MOUSE_COLOR[0], MOUSE_COLOR[1], MOUSE_COLOR[2]);
addTriangles(MOUTH_MID_IN, MOUTH_TOP_IN, MOUTH_BOTTOM_IN, 0, 0, 0);
addJunction(MOUTH_TOP_IN, MOUTH_BOTTOM_IN, 0, 0, 0);
// Chin
addTriangles(MOUTH_MID_OUT, MOUTH_BOTTOM_OUT, CHIN_IN, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(MOUTH_MID_OUT, CHIN_IN, CHIN_TIP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(MOUTH_BOTTOM_OUT, CHIN_IN, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(CHIN_IN, CHIN_TIP, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(CHIN_TIP, CHIN_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Jaw
addTriangles(JAW_BOTTOM_LEFT, JAW_LEFT, CHICK_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(JAW_LEFT, JAW_BOTTOM_LEFT, EAR_CENTER, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(JAW_BOTTOM_LEFT, CHICK_RIGHT, CHIN_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(JAW_BOTTOM_LEFT, CHIN_BOTTOM, JAW_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addJunction(CHIN_BOTTOM, JAW_BOTTOM, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// Ear
addTriangles(FOREHEAD_LEFT, EAR_CENTER, EAR_TOP_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(JAW_BOTTOM_LEFT, EAR_BOTTOM_RIGHT, EAR_CENTER, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_BOTTOM_RIGHT, EAR_TOP_RIGHT, EAR_CENTER, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_BOTTOM_RIGHT, EAR_BOTTOM_LEFT, EAR_TOP_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_TOP_LEFT, EAR_TOP_MID, EAR_TOP_RIGHT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_TOP_RIGHT, EAR_BOTTOM_RIGHT, EAR_TOP_LEFT, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_TOP_RIGHT, EAR_TOP_MID, EAR_BACK, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_TOP_LEFT, EAR_TOP_MID, EAR_BACK, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_BOTTOM_LEFT, EAR_TOP_LEFT, EAR_BACK, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
addTriangles(EAR_BOTTOM_LEFT, EAR_BOTTOM_RIGHT, EAR_BACK, SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2]);
// hair
addTriangles(FOREHEAD_RIGHT, FOREHEAD_LEFT, HAIR_1, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, HAIR_2, HAIR_1, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, HAIR_3, HAIR_2, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, HAIR_SIDE_1, HAIR_3, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, HAIR_SIDE_2, HAIR_SIDE_1, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, HAIR_SIDE_3, HAIR_SIDE_2, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(FOREHEAD_LEFT, EAR_TOP_RIGHT, HAIR_SIDE_3, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(EAR_TOP_RIGHT, HAIR_SIDE_4, HAIR_SIDE_3, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(EAR_TOP_RIGHT, EAR_BOTTOM_RIGHT, HAIR_SIDE_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(EAR_BOTTOM_RIGHT, HAIR_SIDE_5, HAIR_SIDE_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(EAR_BOTTOM_RIGHT, JAW_BOTTOM_LEFT, HAIR_SIDE_5, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_3, HAIR_SIDE_1, HAIR_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_1, HAIR_SIDE_2, HAIR_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_2, HAIR_5, HAIR_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_2, HAIR_6, HAIR_5, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_2, HAIR_SIDE_3, HAIR_6, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_3, HAIR_7, HAIR_6, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_3, HAIR_SIDE_4, HAIR_7, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_4, HAIR_8, HAIR_7, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_4, HAIR_SIDE_5, HAIR_8, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_5, HAIR_9, HAIR_8, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_5, JAW_BOTTOM, HAIR_9, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addTriangles(HAIR_SIDE_5, JAW_BOTTOM, JAW_BOTTOM_LEFT, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(FOREHEAD_RIGHT, HAIR_1, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_1, HAIR_2, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_2, HAIR_3, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_3, HAIR_4, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_4, HAIR_5, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_5, HAIR_6, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_6, HAIR_7, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_7, HAIR_8, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_8, HAIR_9, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
addJunction(HAIR_9, JAW_BOTTOM, HAIR_COLOR[0], HAIR_COLOR[1], HAIR_COLOR[2]);
// Now that we have summed up the normals for each point, let's normalize them.
for (int i = 0; i < _vertexNumber; ++i) {
_newNormals[i] = glm::normalize(_newNormals[i]);
}
}
void PerlinFace::addTriangles(int vertexID1, int vertexID2, int vertexID3, GLubyte r, GLubyte g, GLubyte b) {
glm::vec3 normal = glm::normalize(glm::cross(_vertices[vertexID1] - _vertices[vertexID2],
_vertices[vertexID3] - _vertices[vertexID2]));
addVertex(r, g, b, vertexID1, normal);
addVertex(r, g, b, vertexID2, normal);
addVertex(r, g, b, vertexID3, normal);
++_trianglesCount;
vertexID1 += NUM_VERTICES;
vertexID2 += NUM_VERTICES;
vertexID3 += NUM_VERTICES;
normal = glm::normalize(glm::cross(_vertices[vertexID1] - _vertices[vertexID2],
_vertices[vertexID3] - _vertices[vertexID2]));
addVertex(r, g, b, vertexID3, normal);
addVertex(r, g, b, vertexID2, normal);
addVertex(r, g, b, vertexID1, normal);
++_trianglesCount;
}
void PerlinFace::addJunction(int vertexID1, int vertexID2, GLubyte r, GLubyte g, GLubyte b) {
glm::vec3 normal = glm::normalize(glm::cross(_vertices[vertexID1] - _vertices[NUM_VERTICES + vertexID1],
_vertices[vertexID2] - _vertices[NUM_VERTICES + vertexID1]));
addVertex(r, g, b, vertexID1, normal);
addVertex(r, g, b, NUM_VERTICES + vertexID1, normal);
addVertex(r, g, b, vertexID2, normal);
++_trianglesCount;
normal = glm::normalize(glm::cross(_vertices[vertexID2] - _vertices[NUM_VERTICES + vertexID1],
_vertices[NUM_VERTICES + vertexID2] - _vertices[NUM_VERTICES + vertexID1]));
addVertex(r, g, b, vertexID2, normal);
addVertex(r, g, b, NUM_VERTICES + vertexID1, normal);
addVertex(r, g, b, NUM_VERTICES + vertexID2, normal);
++_trianglesCount;
}
void PerlinFace::addVertex(GLubyte r, GLubyte g, GLubyte b, int vertexID, glm::vec3 normal) {
*_trianglesPos++ = _vertices[vertexID].x;
*_trianglesPos++ = _vertices[vertexID].y;
*_trianglesPos++ = _vertices[vertexID].z;
// use the normals of the previous frame for lighting
*_normalsPos++ = _oldNormals[vertexID].x;
*_normalsPos++ = _oldNormals[vertexID].y;
*_normalsPos++ = _oldNormals[vertexID].z;
// store all the normals associated to each point for next frame
_newNormals[vertexID].x += normal.x;
_newNormals[vertexID].y += normal.y;
_newNormals[vertexID].z += normal.z;
*_colorsPos++ = r;
*_colorsPos++ = g;
*_colorsPos++ = b;
}
glm::vec3 PerlinFace::getVec3(int vertexID) {
return glm::vec3(VERTICES[FLOAT_PER_VERTEX * vertexID],
VERTICES[FLOAT_PER_VERTEX * vertexID + 1],
-VERTICES[FLOAT_PER_VERTEX * vertexID + 2]); // Inverse Z axis to face the right direction
}

81
interface/src/avatar/PerlinFace.h
View file

@ -1,81 +0,0 @@
//
// PerlinFace.h
// interface
//
// Created by Clément Brisset on 9/4/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __interface__PerlinFace__
#define __interface__PerlinFace__
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <QObject>
#include "InterfaceConfig.h"
class Head;
class PerlinFace {
public:
PerlinFace(Head* owningHead);
~PerlinFace();
void update();
void render();
private:
void init();
void updatePositions();
void updateVertices();
void addTriangles(int vertexID1, int vertexID2, int vertexID3, GLubyte r, GLubyte g, GLubyte b);
void addJunction(int vertexID1, int vertexID2, GLubyte r, GLubyte g, GLubyte b);
void addVertex(GLubyte r, GLubyte g, GLubyte b, int vertexID, glm::vec3 normal);
glm::vec3 getVec3(int vertexID);
Head* _owningHead;
bool _initialized;
int _vertexNumber;
int _trianglesCount;
static glm::vec3* _vertices;
glm::vec3* _oldNormals;
glm::vec3* _newNormals;
static GLfloat* _triangles;
static GLfloat* _normals;
static GLubyte* _colors;
GLfloat* _trianglesPos;
GLfloat* _normalsPos;
GLubyte* _colorsPos;
GLuint _vboID;
GLuint _nboID;
GLuint _cboID;
float _browsD_L;
float _browsD_R;
float _browsU_C;
float _browsU_L;
float _browsU_R;
float _mouthSize;
float _mouthSmileLeft;
float _mouthSmileRight;
float _eyeBlink_L;
float _eyeBlink_R;
float _eyeOpen_L;
float _eyeOpen_R;
friend void staticCleanup();
};
#endif /* defined(__interface__Face__) */

40
libraries/audio/src/AudioInjector.cpp
View file

@ -21,8 +21,7 @@ AudioInjector::AudioInjector(const char* filename) :
_radius(0.0f),
_volume(MAX_INJECTOR_VOLUME),
_indexOfNextSlot(0),
_isInjectingAudio(false),
_lastFrameIntensity(0.0f)
_isInjectingAudio(false)
{
loadRandomIdentifier(_streamIdentifier, STREAM_IDENTIFIER_NUM_BYTES);
@ -52,8 +51,7 @@ AudioInjector::AudioInjector(int maxNumSamples) :
_radius(0.0f),
_volume(MAX_INJECTOR_VOLUME),
_indexOfNextSlot(0),
_isInjectingAudio(false),
_lastFrameIntensity(0.0f)
_isInjectingAudio(false)
{
loadRandomIdentifier(_streamIdentifier, STREAM_IDENTIFIER_NUM_BYTES);
@ -103,6 +101,11 @@ void AudioInjector::injectAudio(UDPSocket* injectorSocket, sockaddr* destination
int nextFrame = 0;
for (int i = 0; i < _numTotalSamples; i += BUFFER_LENGTH_SAMPLES_PER_CHANNEL) {
int usecToSleep = usecTimestamp(&startTime) + (nextFrame++ * INJECT_INTERVAL_USECS) - usecTimestampNow();
if (usecToSleep > 0) {
usleep(usecToSleep);
}
int numSamplesToCopy = BUFFER_LENGTH_SAMPLES_PER_CHANNEL;
if (_numTotalSamples - i < BUFFER_LENGTH_SAMPLES_PER_CHANNEL) {
@ -115,23 +118,6 @@ void AudioInjector::injectAudio(UDPSocket* injectorSocket, sockaddr* destination
memcpy(currentPacketPtr, _audioSampleArray + i, numSamplesToCopy * sizeof(int16_t));
injectorSocket->send(destinationSocket, dataPacket, sizeof(dataPacket));
// calculate the intensity for this frame
float lastRMS = 0;
for (int j = 0; j < BUFFER_LENGTH_SAMPLES_PER_CHANNEL; j++) {
lastRMS += _audioSampleArray[i + j] * _audioSampleArray[i + j];
}
lastRMS /= BUFFER_LENGTH_SAMPLES_PER_CHANNEL;
lastRMS = sqrtf(lastRMS);
_lastFrameIntensity = lastRMS / std::numeric_limits<int16_t>::max();
int usecToSleep = usecTimestamp(&startTime) + (++nextFrame * INJECT_INTERVAL_USECS) - usecTimestampNow();
if (usecToSleep > 0) {
usleep(usecToSleep);
}
}
_isInjectingAudio = false;
@ -152,3 +138,15 @@ void AudioInjector::addSamples(int16_t* sampleBuffer, int numSamples) {
_indexOfNextSlot += numSamples;
}
}
int16_t& AudioInjector::sampleAt(const int index) {
assert(index >= 0 && index < _numTotalSamples);
return _audioSampleArray[index];
}
void AudioInjector::insertSample(const int index, int sample) {
assert (index >= 0 && index < _numTotalSamples);
_audioSampleArray[index] = (int16_t) sample;
}

15
libraries/audio/src/AudioInjector.h
View file

@ -12,6 +12,9 @@
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/component_wise.hpp>
#include <QtCore/QObject>
#include <RegisteredMetaTypes.h>
#include <UDPSocket.h>
#include "AudioRingBuffer.h"
@ -22,7 +25,11 @@ const int MAX_INJECTOR_VOLUME = 0xFF;
const int INJECT_INTERVAL_USECS = floorf((BUFFER_LENGTH_SAMPLES_PER_CHANNEL / SAMPLE_RATE) * 1000000);
class AudioInjector {
class AudioInjector : public QObject {
Q_OBJECT
Q_PROPERTY(glm::vec3 position READ getPosition WRITE setPosition)
Q_PROPERTY(uchar volume READ getVolume WRITE setVolume);
public:
AudioInjector(const char* filename);
AudioInjector(int maxNumSamples);
@ -35,8 +42,6 @@ public:
unsigned char getVolume() const { return _volume; }
void setVolume(unsigned char volume) { _volume = volume; }
float getLastFrameIntensity() const { return _lastFrameIntensity; }
const glm::vec3& getPosition() const { return _position; }
void setPosition(const glm::vec3& position) { _position = position; }
@ -48,6 +53,9 @@ public:
void addSample(const int16_t sample);
void addSamples(int16_t* sampleBuffer, int numSamples);
public slots:
int16_t& sampleAt(const int index);
void insertSample(const int index, int sample);
private:
unsigned char _streamIdentifier[STREAM_IDENTIFIER_NUM_BYTES];
int16_t* _audioSampleArray;
@ -58,7 +66,6 @@ private:
unsigned char _volume;
int _indexOfNextSlot;
bool _isInjectingAudio;
float _lastFrameIntensity;
};
#endif /* defined(__hifi__AudioInjector__) */

32
libraries/avatars/src/AvatarData.cpp
View file

@ -53,38 +53,6 @@ AvatarData::~AvatarData() {
delete _handData;
}
void AvatarData::setPositionFromVariantMap(QVariantMap positionMap) {
_position = glm::vec3(positionMap.value("x").toFloat(),
positionMap.value("y").toFloat(),
positionMap.value("z").toFloat());
}
QVariantMap AvatarData::getPositionVariantMap() {
QVariantMap positionMap;
positionMap.insert("x", _position.x);
positionMap.insert("y", _position.y);
positionMap.insert("z", _position.z);
return positionMap;
}
void AvatarData::setHandPositionFromVariantMap(QVariantMap handPositionMap) {
_handPosition = glm::vec3(handPositionMap.value("x").toFloat(),
handPositionMap.value("y").toFloat(),
handPositionMap.value("z").toFloat());
}
QVariantMap AvatarData::getHandPositionVariantMap() {
QVariantMap positionMap;
positionMap.insert("x", _handPosition.x);
positionMap.insert("y", _handPosition.y);
positionMap.insert("z", _handPosition.z);
return positionMap;
}
void AvatarData::sendData() {
// called from Agent visual loop to send data

15
libraries/avatars/src/AvatarData.h
View file

@ -20,6 +20,8 @@
#include <QtCore/QUuid>
#include <QtCore/QVariantMap>
#include <RegisteredMetaTypes.h>
#include <NodeData.h>
#include "HeadData.h"
#include "HandData.h"
@ -49,8 +51,8 @@ class JointData;
class AvatarData : public NodeData {
Q_OBJECT
Q_PROPERTY(QVariantMap position READ getPositionVariantMap WRITE setPositionFromVariantMap)
Q_PROPERTY(QVariantMap handPosition READ getHandPositionVariantMap WRITE setHandPositionFromVariantMap)
Q_PROPERTY(glm::vec3 position READ getPosition WRITE setPosition)
Q_PROPERTY(glm::vec3 handPosition READ getHandPosition WRITE setHandPosition)
Q_PROPERTY(float bodyYaw READ getBodyYaw WRITE setBodyYaw)
Q_PROPERTY(float bodyPitch READ getBodyPitch WRITE setBodyPitch)
Q_PROPERTY(float bodyRoll READ getBodyRoll WRITE setBodyRoll)
@ -60,16 +62,11 @@ public:
~AvatarData();
const glm::vec3& getPosition() const { return _position; }
void setPosition(const glm::vec3 position) { _position = position; }
const glm::vec3& getHandPosition() const { return _handPosition; }
void setHandPosition(const glm::vec3 handPosition) { _handPosition = handPosition; }
void setPositionFromVariantMap(QVariantMap positionMap);
QVariantMap getPositionVariantMap();
void setHandPositionFromVariantMap(QVariantMap handPositionMap);
QVariantMap getHandPositionVariantMap();
int getBroadcastData(unsigned char* destinationBuffer);
int parseData(unsigned char* sourceBuffer, int numBytes);

6
libraries/shared/src/NodeList.cpp
View file

@ -285,6 +285,9 @@ void NodeList::reset() {
_checkInPacket = NULL;
_numBytesCheckInPacket = 0;
delete _nodeTypesOfInterest;
_nodeTypesOfInterest = NULL;
}
void NodeList::setNodeTypesOfInterest(const char* nodeTypesOfInterest, int numNodeTypesOfInterest) {
@ -437,7 +440,6 @@ void NodeList::sendAssignment(Assignment& assignment) {
}
Node* NodeList::addOrUpdateNode(sockaddr* publicSocket, sockaddr* localSocket, char nodeType, uint16_t nodeId) {
NodeList::iterator node = end();
if (publicSocket) {
@ -553,7 +555,7 @@ void* removeSilentNodes(void *args) {
node->lock();
if ((usecTimestampNow() - node->getLastHeardMicrostamp()) > NODE_SILENCE_THRESHOLD_USECS) {
qDebug() << "Killed " << *node << "\n";
nodeList->notifyHooksOfKilledNode(&*node);

16
libraries/shared/src/RegisteredMetaTypes.h Normal file
View file

@ -0,0 +1,16 @@
//
// RegisteredMetaTypes.h
// hifi
//
// Created by Stephen Birarda on 10/3/13.
// Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
//
// Used to register meta-types with Qt so that they can be used as properties for objects exposed to our
// Agent scripting.
#ifndef hifi_RegisteredMetaTypes_h
#define hifi_RegisteredMetaTypes_h
Q_DECLARE_METATYPE(glm::vec3)
#endif