ofRectangle ofxSymbolInstance::getBoundingBox(ofMatrix4x4 mat) {
// cout << "bounding box" << endl;
ofRectangle rect(0,0,0,0);
mat.preMult(this->mat);
switch (type) {
case BITMAP_INSTANCE: {
ofVec2f p0 = mat.preMult(ofVec3f(0,0,0));
ofVec2f p1 = mat.preMult(ofVec3f(bitmapItem->getWidth(),bitmapItem->getHeight()));
rect = ofRectangle(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y);
} break;
case SYMBOL_INSTANCE: {
for (vector<layer>::iterator liter=layers.begin();liter!=layers.end();liter++) {
frame &f = liter->frames[liter->currentFrame];
vector<ofxSymbolInstance>::iterator iter=f.instances.begin();
while (iter!=f.instances.end()) {
rect = iter->getBoundingBox(mat);
iter++;
if (rect.width!=0 || rect.height!=0) {
break;
}
}
while (iter!=f.instances.end()) {
ofRectangle iterect = iter->getBoundingBox();
if (iterect.width!=0 || iterect.height!=0) {
ofVec2f p0(rect.x,rect.y);
ofVec2f p1(p0.x+rect.width,p0.y+rect.height);
ofVec2f q0(iterect.x,iterect.y);
ofVec2f q1(q0.x+iterect.width,q0.y+iterect.height);
ofVec2f pos(MIN(p0.x,q0.x),MIN(p0.y,q0.y));
rect = ofRectangle(pos.x,pos.y,MAX(p1.x,q1.x)-pos.x,MAX(p1.y,q1.y)-pos.y);
// cout << rect.x << "\t" << rect.y << "\t" << rect.width << "\t" << rect.height << endl;
}
iter++;
}
}
} break;
default:
break;
}
return rect;
}
//--------------------------------------------------------------
ofMatrix4x4 Path3D::zForward(ofMatrix4x4 originalMat){
ofVec3f pos = originalMat.getTranslation();
ofVec3f y = originalMat.getRowAsVec3f(1); // local y-axis
originalMat.setTranslation(0,0,0);
originalMat.rotate(90, y.x, y.y, y.z); // rotate about the y
originalMat.setTranslation(pos);
return originalMat;
}
//--------------------------------------------------------------
ofMatrix4x4 Path3D::zOut(ofMatrix4x4 originalMat){
ofVec3f pos = originalMat.getTranslation();
ofVec3f x = originalMat.getRowAsVec3f(0); // local x-axis
originalMat.setTranslation(0,0,0);
originalMat.rotate(-90, x.x, x.y, x.z); // rotate about the y
originalMat.setTranslation(pos);
return originalMat;
}
//--------------------------------------------------------------
ofMatrix4x4 Path3D::flip(ofMatrix4x4 originalMat){
ofVec3f pos = originalMat.getTranslation();
ofVec3f z = originalMat.getRowAsVec3f(2); // local y-axis
originalMat.setTranslation(0,0,0);
originalMat.rotate(180, z.x, z.y, z.z); // rotate about the y
originalMat.setTranslation(pos);
return originalMat;
}
void Model::draw(ofMatrix4x4 camMvpMatrix)
{
diffuseTex.bind();
shader.begin();
ofPushStyle();
GLuint matLoc = glGetUniformLocation(shader.getProgram(), "camMvpMatrix");
if (matLoc != -1)
{
glUniformMatrix4fv(matLoc, 1, GL_FALSE, camMvpMatrix.getPtr());
}
shader.setUniformTexture("modelTransTexture", modelTransTexture, 1);
for (auto p : pieces)
{
shader.setUniformTexture("animationTexture", p.instancedAnimTextre, 2);
shader.setUniformTexture("diffuseTex", diffuseTex, 3);
p.material.begin();
ofEnableBlendMode(p.blendmode);
p.vbo.drawElements(GL_TRIANGLES, p.vbo.getNumIndices());
p.material.end();
}
ofPopStyle();
shader.end();
diffuseTex.unbind();
}
void collisionTester::setTransformFromOF(ofMatrix4x4& mat, ofVec3f& s, btCollisionObject& obj){
btTransform trans;
trans.setFromOpenGLMatrix(mat.getPtr());
obj.setWorldTransform(trans);
obj.getCollisionShape()->setLocalScaling(btVector3(s.x, s.y, s.z));
}
ramPyramidPrimitive::ramPyramidPrimitive(const ofMatrix4x4& mat, float size)
{
size *= 0.5;
mesh.addVertex(ofVec3f(1, 1, 1) * size);
mesh.addVertex(ofVec3f(-1, 1, -1) * size);
mesh.addVertex(ofVec3f(-1, -1, 1) * size);
mesh.addVertex(ofVec3f(1, -1, -1) * size);
mesh.addTriangle(0, 1, 2);
mesh.addTriangle(0, 2, 3);
mesh.addTriangle(0, 3, 1);
mesh.addTriangle(3, 2, 1);
body = getWorld().addMesh(mesh, mat.getTranslation(), mat.getRotate().getEuler());
}
static inline aiMatrix4x4 ofMatrix4x4ToAiMatrix44(const ofMatrix4x4 &m)
{
const float *d = m.getPtr();
return aiMatrix4x4(d[0], d[4], d[8], d[12],
d[1], d[5], d[9], d[13],
d[2], d[6], d[10], d[14],
d[3], d[7], d[11], d[15]);
}
ofVec3f ofkUnProjectionHelper::getProjectionPoint(float ofScreenPosX, float ofScreenPosY, ofMatrix4x4 modelView, ofMatrix4x4 projection, float viewWidth, float viewHeight )
{
GLdouble modelMAT[16];
GLdouble projectionMAT[16];
GLint view[4];
for(int i = 0 ; i < 16 ; i++)
{
modelMAT[i] = modelView.getPtr()[i];
projectionMAT[i] = projection.getPtr()[i];
}
view[0] = 0;
view[1] = 0;
view[2] = viewWidth;
view[3] = viewHeight;
return getProjectionPoint(ofScreenPosX, ofScreenPosY, modelMAT, projectionMAT, view);
}
ofVec3f ofkMatrixHelper::getProjectionPoint(ofVec3f pos, const ofMatrix4x4 modelView, ofMatrix4x4 projection, const int *_view)
{
GLdouble modelMAT[16];
GLdouble projectionMAT[16];
GLint view[4];
for(int i = 0 ; i < 16 ; i++)
{
modelMAT[i] = modelView.getPtr()[i];
projectionMAT[i] = projection.getPtr()[i];
}
view[0] = _view[0];
view[1] = _view[1];
view[2] = _view[2];
view[3] = _view[3];
return getProjectionPoint(pos,modelMAT, projectionMAT,view);
}
ofRectangle ofRectangleTransform(const ofRectangle & rect, const ofMatrix4x4 & mat) {
ofVec3f tl = rect.getTopLeft();
ofVec3f br = rect.getBottomRight();
tl = mat.preMult(tl);
br = mat.preMult(br);
ofRectangle r;
r.setPosition(tl);
r.growToInclude(br);
return r;
}
void ofxARToolkitPlus::getTranslationAndOrientation(int markerIndex, ofVec3f &translation, ofMatrix4x4 &orientation) {
ARToolKitPlus::ARMarkerInfo marker = tracker->getDetectedMarker(markerIndex);
getTransMat( &marker, c, m34 );
// Translation
translation.set(m34[0][3], m34[1][3], m34[2][3]);
// Orientation
orientation.set(m34[0][0], m34[0][1], m34[0][2], 0,
m34[1][0], m34[1][1], m34[1][2], 0,
m34[2][0], m34[2][1], m34[2][2], 0,
0, 0, 0, 1);
}
ofMatrix4x4 headTracking::getLastHeadView(ofMatrix4x4 headView)
{
if (!mTracker.isReady()) {
return headView;
}
ofOrientation fooRot = ofGetOrientation();
double rotation = 0.0;
if (fooRot == OF_ORIENTATION_DEFAULT) {
rotation = 0.0;
} else if (fooRot == OF_ORIENTATION_90_LEFT) {
rotation = 90.0;
} else if (fooRot == OF_ORIENTATION_90_RIGHT) {
rotation = 180.0;
} else {
rotation = 270.0;
}
if (fooRot != mDisplayRotation) {
mDisplayRotation = fooRot;
mSensorToDisplay.makeRotationMatrix(
ofQuaternion(0.0, ofVec3f(1, 0, 0), -rotation, ofVec3f(0, 0, 1),
0.0, ofVec3f(0, 1, 0)));
mEkfToHeadTracker.makeRotationMatrix(
ofQuaternion(0.0, ofVec3f(1, 0, 0), rotation, ofVec3f(0, 0, 1),
0.0, ofVec3f(0, 1, 0)));
}
double secondsSinceLastGyroEvent = (ofGetElapsedTimeMicros() -
mLastGyroEventTimeNanos) * 1E-6;
double secondsToPredictForward = secondsSinceLastGyroEvent + 0.0166666666;
mTmpHeadView = mTracker.getPredictedGLMatrix(secondsToPredictForward);
mTmpHeadView2.makeFromMultiplicationOf(mSensorToDisplay, mTmpHeadView);
headView.makeFromMultiplicationOf(mTmpHeadView2, mEkfToHeadTracker);
if (mNeckModelEnabled) {
mTmpHeadView.makeFromMultiplicationOf(mNeckModelTranslation, headView);
mTmpHeadView.translate(ofVec3f(0, 0.075, 0.0));
headView = mTmpHeadView;
}
return headView;
}
//----------------------------------------------------------
void ofGLRenderer::loadViewMatrix(const ofMatrix4x4 & m){
int matrixMode;
glGetIntegerv(GL_MATRIX_MODE,&matrixMode);
matrixStack.loadViewMatrix(m);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(m.getPtr());
glMatrixMode(matrixMode);
if(lightingEnabled){
for(size_t i=0;i<ofLightsData().size();i++){
shared_ptr<ofLight::Data> lightData = ofLightsData()[i].lock();
if(lightData && lightData->isEnabled){
glLightfv(GL_LIGHT0 + lightData->glIndex, GL_POSITION, &lightData->position.x);
}
}
}
}
void ofxIcp::compute(const vector<ofPoint> & initial, const vector<ofPoint> & target, vector<ofPoint> & output, ofMatrix4x4 & transformation, double & error, int & iterations){
vector<cv::Point3d> initial_cv;
vector<cv::Point3d> target_cv;
toCV(initial, initial_cv);
toCV(target, target_cv);
cv::Mat transformation_matrix;
vector<cv::Point3d> output_cv;
compute(initial_cv, target_cv, output_cv, transformation_matrix, error, iterations);
toOF(output_cv, output);
transformation.set(transformation_matrix.ptr<double>());
}
bool ofxSymbolInstance::getChildMat(ofxSymbolInstance *child,ofMatrix4x4 &mat) {
if (this==child) {
mat = this->mat;
return true;
}
for (vector<layer>::iterator liter=layers.begin();liter!=layers.end();liter++) {
frame &f = liter->frames[liter->currentFrame];
for (vector<ofxSymbolInstance>::iterator iter=f.instances.begin(); iter!=f.instances.end(); iter++) {
if (iter->getChildMat(child, mat)) {
mat.postMult(this->mat);
return true;
}
}
}
return false;
}
void ofxPolyline2Mesh::pushSegment(const ofColor& c2, const ofColor& c1,
const ofMatrix4x4 &m)
{
for (int i = 0; i < shape.size(); i++)
{
const ofVec3f &p = m.preMult(shape[i]);
current_segments[i] = p;
}
for (int i = 0; i < shape.size() - 1; i++)
{
const ofVec3f &p1 = last_segments[i];
const ofVec3f &p2 = current_segments[i];
const ofVec3f &n1 = last_segments[i + 1];
const ofVec3f &n2 = current_segments[i + 1];
const ofVec3f norm = (p2 - p1).crossed((n1 - p1)).normalized();
mesh.addNormal(norm);
mesh.addColor(c1);
mesh.addVertex(p1);
mesh.addNormal(norm);
mesh.addColor(c2);
mesh.addVertex(p2);
mesh.addNormal(norm);
mesh.addColor(c1);
mesh.addVertex(n1);
mesh.addNormal(norm);
mesh.addColor(c1);
mesh.addVertex(n1);
mesh.addNormal(norm);
mesh.addColor(c2);
mesh.addVertex(p2);
mesh.addNormal(norm);
mesh.addColor(c2);
mesh.addVertex(n2);
}
}
void ofxARToolkitPlus::getMultiMarkerTranslationAndOrientation(ofVec3f &translation, ofMatrix4x4 &orientation) {
const ARToolKitPlus::ARMultiMarkerInfoT *multiMarkerConst = tracker->getMultiMarkerConfig();
if(multiMarkerConst != NULL) {
// Create a copy of the ARMultiMarkerInfoT struct
ARToolKitPlus::ARMultiMarkerInfoT mm;
size_t mmSize = sizeof(ARToolKitPlus::ARMultiMarkerInfoT);
memcpy(&mm, multiMarkerConst, mmSize);
// Copy and pass in the markers
int numberOfMarkers = tracker->getNumDetectedMarkers();
#ifdef TARGET_WIN32
ARToolKitPlus::ARMarkerInfo *marker = new ARToolKitPlus::ARMarkerInfo[numberOfMarkers];
#else
ARToolKitPlus::ARMarkerInfo marker[numberOfMarkers];
#endif
for (int i=0; i<numberOfMarkers; i++) {
marker[i] = tracker->getDetectedMarker(i);
}
float result = tracker->rppMultiGetTransMat(marker, numberOfMarkers, &mm);
// Check for error - yes this does occur
if(result < 0 || result >= INT_MAX) {
tracker->arMultiGetTransMat(marker, numberOfMarkers, &mm);
ofLog(OF_LOG_VERBOSE, "RPP failed on multimarker");
}
// Translation
translation.set(mm.trans[0][3], mm.trans[1][3], mm.trans[2][3]);
// Orientation
orientation.set(mm.trans[0][0], mm.trans[0][1], mm.trans[0][2], 0,
mm.trans[1][0], mm.trans[1][1], mm.trans[1][2], 0,
mm.trans[2][0], mm.trans[2][1], mm.trans[2][2], 0,
0, 0, 0, 1);
#ifdef TARGET_WIN32
free(marker);
#endif
} else {
ofLog(OF_LOG_VERBOSE, "MultiMarkerConfig file NULL");
}
}
//----------------------------------------
void ofNode::setTransformMatrix(const ofMatrix4x4 &m44) {
setTransformMatrix(m44.getPtr());
}
void Shader::setUniform( const char* name, ofMatrix4x4& _value, bool transpose ){
if(uniforms.count( name )){
begin();
glUniformMatrix4fv(uniforms[name].loc,1, transpose, _value.getPtr() );
}
}
void ofxMesh::transform(const ofMatrix4x4 trans) {
for (int i=0; i<getNumVertices(); i++) {
getVertices()[i] = trans.preMult(getVertices()[i]);
}
}
void ofQuaternion::get(ofMatrix4x4& matrix) const {
matrix.makeRotationMatrix(*this);
}
void ofQuaternion::set(const ofMatrix4x4& matrix) {
*this = matrix.getRotate();
}
//--------------------------------------------------------------
void ofShader::setUniformMatrix4f(const char* name, const ofMatrix4x4 & m) {
if(bLoaded)
glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, m.getPtr());
}
void applyMatrix(const ofMatrix4x4& matrix) {
glMultMatrixf((GLfloat*) matrix.getPtr());
}
//----------------------------------------------------------
void ofGLRenderer::loadMatrix (const ofMatrix4x4 & m){
loadMatrix( m.getPtr() );
}
//--------------------------------------------------------------
void ofShader::setUniformMatrix4f(const string & name, const ofMatrix4x4 & m, int count) const{
if(bLoaded) {
int loc = getUniformLocation(name);
if (loc != -1) glUniformMatrix4fv(loc, count, GL_FALSE, m.getPtr());
}
}
void VDB::transform(ofMatrix4x4 & mat) {
tempTransform.postMult(mat);
math::Mat4d vMat(mat.getPtr());
grid->transform().postMult(vMat);
}
//----------------------------------------------------------
void ofGLRenderer::multMatrix (const ofMatrix4x4 & m){
multMatrix( m.getPtr() );
}
void ofxOpenVR::setCurrentHMDMatrix(ofMatrix4x4 & mat) {
_mat4HMDPose.set(mat.getPtr());
}
