void Graphics::ortho(const float left, const float right, const float bottom, const float top, const float near, const float far) {
setMatrix(getMatrix() * Matrix::ortho2D(left, right, bottom, top));
}
bool SkDrawMatrix::draw(SkAnimateMaker& maker) {
SkMatrix& concat = getMatrix();
maker.fCanvas->concat(concat);
return false;
}
//////////////////////////////////////////////////////////////////////////
// drawLine
void ScnCanvasComponent::drawLine( const MaVec2d& PointA, const MaVec2d& PointB, const RsColour& Colour, BcU32 Layer )
{
ScnCanvasComponentVertex* pVertices = allocVertices( 2 );
ScnCanvasComponentVertex* pFirstVertex = pVertices;
// Only draw if we can allocate vertices.
if( pVertices != NULL )
{
// Now copy in data.
BcU32 ABGR = Colour.asABGR();
pVertices->X_ = PointA.x();
pVertices->Y_ = PointA.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = PointB.x();
pVertices->Y_ = PointB.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->ABGR_ = ABGR;
// Quickly check last primitive.
BcBool AddNewPrimitive = BcTrue;
if( LastPrimitiveSection_ != BcErrorCode )
{
ScnCanvasComponentPrimitiveSection& PrimitiveSection = PrimitiveSectionList_[ LastPrimitiveSection_ ];
// If the last primitive was the same type as ours we can append to it.
// NOTE: Need more checks here later.
if( PrimitiveSection.Type_ == RsTopologyType::LINE_LIST &&
PrimitiveSection.Layer_ == Layer &&
PrimitiveSection.MaterialComponent_ == MaterialComponent_ )
{
PrimitiveSection.NoofVertices_ += 2;
// Matrix stack.
// TODO: Factor into a seperate function.
if( IsIdentity_ == BcFalse )
{
MaMat4d Matrix = getMatrix();
for( BcU32 Idx = 0; Idx < 2; ++Idx )
{
ScnCanvasComponentVertex* pVertex = &pFirstVertex[ Idx ];
MaVec3d Vertex = MaVec3d( pVertex->X_, pVertex->Y_, pVertex->Z_ ) * Matrix;
pVertex->X_ = Vertex.x();
pVertex->Y_ = Vertex.y();
pVertex->Z_ = Vertex.z();
pVertices->W_ = 1.0f;
}
}
AddNewPrimitive = BcFalse;
}
}
// Add primitive.
if( AddNewPrimitive == BcTrue )
{
addPrimitive( RsTopologyType::LINE_LIST, pFirstVertex, 2, Layer, BcTrue );
}
}
}
Vector SpotLight::getLightVector( HitProperties const& hp ) const {
return ( getMatrix().getTranslation() - hp.point ).normalized();
}
static void
zprMotion(int x, int y)
{
bool changed = false;
const int dx = x - _mouseX;
const int dy = y - _mouseY;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
if (dx==0 && dy==0)
return;
if (_mouseMiddle || (_mouseLeft && _mouseRight))
{
double s = exp((double)dy*0.01);
glTranslatef( zprReferencePoint[0], zprReferencePoint[1], zprReferencePoint[2]);
glScalef(s,s,s);
glTranslatef(-zprReferencePoint[0],-zprReferencePoint[1],-zprReferencePoint[2]);
changed = true;
}
else
if (_mouseLeft)
{
double ax,ay,az;
double bx,by,bz;
double angle;
ax = dy;
ay = dx;
az = 0.0;
angle = vlen(ax,ay,az)/(double)(viewport[2]+1)*180.0;
/* Use inverse matrix to determine local axis of rotation */
bx = _matrixInverse[0]*ax + _matrixInverse[4]*ay + _matrixInverse[8] *az;
by = _matrixInverse[1]*ax + _matrixInverse[5]*ay + _matrixInverse[9] *az;
bz = _matrixInverse[2]*ax + _matrixInverse[6]*ay + _matrixInverse[10]*az;
glTranslatef( zprReferencePoint[0], zprReferencePoint[1], zprReferencePoint[2]);
glRotatef(angle,bx,by,bz);
glTranslatef(-zprReferencePoint[0],-zprReferencePoint[1],-zprReferencePoint[2]);
changed = true;
}
else
if (_mouseRight)
{
double px,py,pz;
pos(&px,&py,&pz,x,y,viewport);
glLoadIdentity();
glTranslatef(px-_dragPosX,py-_dragPosY,pz-_dragPosZ);
glMultMatrixd(_matrix);
_dragPosX = px;
_dragPosY = py;
_dragPosZ = pz;
changed = true;
}
_mouseX = x;
_mouseY = y;
if (changed)
{
getMatrix();
glutPostRedisplay();
}
}
QPointF Canvas::worldToScene(QVector3D v) const
{
QMatrix4x4 M = getMatrix();
QVector3D w = M * v;
return QPointF(w.x(), w.y());
}
// Right hand effector's collision detection function for multiple objects.
// Purpose:
// - Determine closest object (based on center) that effector is touching.
// Notes:
// The list must be a list of Object instances, defined above.
// This function does not account for rotation of the object or the effector.
void RightVirtualHand::detectCollisions(arEffector& self, vector<arInteractable*>& objects)
{
// Return if grabbing an object.
if(getGrabbedObject() != 0) return;
// Set maximum distance for testing collision dection to 1000 ft.
float maxDistance = 1000.0;
// Track closest object and its distance. No object is initially closest.
arInteractable* closestObject = 0;
float closestDistance = maxDistance;
// Step through list of objects and test each one for collisions.
for(vector<arInteractable*>::iterator it=objects.begin(); it != objects.end(); ++it) {
// Get information about object's position and dimensions.
const arMatrix4 objectMatrix = (*it)->getMatrix();
arMatrix4 objectTransMatrix = ar_extractTranslationMatrix(objectMatrix);
const float objectX = objectTransMatrix[12];
const float objectY = objectTransMatrix[13];
const float objectZ = objectTransMatrix[14];
const float objectLength = ((Object*)(*it))->getLength();
const float objectHeight = ((Object*)(*it))->getHeight();
const float objectWidth = ((Object*)(*it))->getWidth();
// Get information about effector's position and dimensions.
arMatrix4 effectorTransMatrix = ar_extractTranslationMatrix(getMatrix());
const float effectorX = effectorTransMatrix[12];
const float effectorY = effectorTransMatrix[13];
const float effectorZ = effectorTransMatrix[14];
const float effectorLength = _size;
const float effectorHeight = _size;
const float effectorWidth = _size;
// Determine if effector is within object along X-axis.
if((objectX - objectLength/2.0) <= (effectorX + effectorLength/2.0) && (effectorX - effectorLength/2.0) <= (objectX + objectLength/2.0)) {
// Determine if effector is within object along Y-axis.
if((objectY - objectHeight/2.0) <= (effectorY + effectorHeight/2.0) && (effectorY - effectorHeight/2.0) <= (objectY + objectHeight/2.0)) {
// Determine if effector is within object along Z-axis.
if((objectZ - objectWidth/2.0) <= (effectorZ + effectorWidth/2.0) && (effectorZ - effectorWidth/2.0) <= (objectZ + objectWidth/2.0)) {
// Collision detected. Now use selector to determine distance to center of the object.
_selector.setMaxDistance(maxDistance);
float objectDistance = _selector.calcDistance(self, objectMatrix);
// Determine if object is closest so far.
if(objectDistance < closestDistance) {
// If so, remember object and distance to object.
closestObject = *it;
closestDistance = objectDistance;
}
}}}
}
// Check if an object was touched.
if(closestObject != 0) {
// If so, set selector's distance to match object's distance.
_selector.setMaxDistance(closestDistance);
setInteractionSelector(_selector);
//cout << "object was selected?" << '\n';
if(getOnButton(1) == 1)
{
//cout << "object was selected" << '\n';
Object* oby = (Object*)closestObject;
oby->_selected = !oby->_selected;
}
}
else {
// If not, set selector's distance to size of effector.
_selector.setMaxDistance(_size);
setInteractionSelector(_selector);
}
}
CMatrix CModelX::getFrameMatrix(int no, bool local) {
CFrameBone *f = (CFrameBone*)CFrameBone::getFrameByNo(no, pFrameRoot);
return (local) ? f->getSMatrix() : getMatrix() * f->getSMatrix();
}
void Gizmo::setCameraRay(const Vec3& origin, const Vec3& cursor_dir)
{
if (m_editor.getSelectedEntities().empty()) return;
if (m_is_transforming) return;
Matrix scale_mtx = Matrix::IDENTITY;
scale_mtx.m11 = scale_mtx.m22 = scale_mtx.m33 = m_scale;
Matrix gizmo_mtx;
getMatrix(gizmo_mtx);
Matrix mtx = gizmo_mtx * scale_mtx;
Vec3 pos = mtx.getTranslation();
m_camera_dir = (origin - pos).normalized();
m_transform_axis = Axis::NONE;
if (m_mode == Mode::TRANSLATE)
{
Matrix triangle_mtx = mtx;
if (dotProduct(gizmo_mtx.getXVector(), m_camera_dir) < 0) triangle_mtx.setXVector(-triangle_mtx.getXVector());
if (dotProduct(gizmo_mtx.getYVector(), m_camera_dir) < 0) triangle_mtx.setYVector(-triangle_mtx.getYVector());
if (dotProduct(gizmo_mtx.getZVector(), m_camera_dir) < 0) triangle_mtx.setZVector(-triangle_mtx.getZVector());
float t, tmin = FLT_MAX;
bool hit = Math::getRayTriangleIntersection(
origin, cursor_dir, pos, pos + triangle_mtx.getXVector() * 0.5f, pos + triangle_mtx.getYVector() * 0.5f, &t);
if (hit)
{
tmin = t;
m_transform_axis = Axis::XY;
}
hit = Math::getRayTriangleIntersection(
origin, cursor_dir, pos, pos + triangle_mtx.getYVector() * 0.5f, pos + triangle_mtx.getZVector() * 0.5f, &t);
if (hit && t < tmin)
{
tmin = t;
m_transform_axis = Axis::YZ;
}
hit = Math::getRayTriangleIntersection(
origin, cursor_dir, pos, pos + triangle_mtx.getXVector() * 0.5f, pos + triangle_mtx.getZVector() * 0.5f, &t);
if (hit && t < tmin)
{
m_transform_axis = Axis::XZ;
}
if (m_transform_axis != Axis::NONE) return;
float x_dist = Math::getLineSegmentDistance(origin, cursor_dir, pos, pos + mtx.getXVector());
float y_dist = Math::getLineSegmentDistance(origin, cursor_dir, pos, pos + mtx.getYVector());
float z_dist = Math::getLineSegmentDistance(origin, cursor_dir, pos, pos + mtx.getZVector());
float influenced_dist = m_scale * INFLUENCE_DISTANCE;
if (x_dist > influenced_dist && y_dist > influenced_dist && z_dist > influenced_dist)
{
m_transform_axis = Axis::NONE;
return;
}
if (x_dist < y_dist && x_dist < z_dist) m_transform_axis = Axis::X;
else if (y_dist < z_dist) m_transform_axis = Axis::Y;
else m_transform_axis = Axis::Z;
return;
}
if (m_mode == Mode::ROTATE)
{
Vec3 hit;
if (Math::getRaySphereIntersection(origin, cursor_dir, pos, m_scale, hit))
{
auto x = gizmo_mtx.getXVector();
float x_dist = fabs(dotProduct(hit, x) - dotProduct(x, pos));
auto y = gizmo_mtx.getYVector();
float y_dist = fabs(dotProduct(hit, y) - dotProduct(y, pos));
auto z = gizmo_mtx.getZVector();
float z_dist = fabs(dotProduct(hit, z) - dotProduct(z, pos));
float qq= m_scale * 0.15f;
if (x_dist > qq && y_dist > qq && z_dist > qq)
{
m_transform_axis = Axis::NONE;
return;
}
if (x_dist < y_dist && x_dist < z_dist) m_transform_axis = Axis::X;
else if (y_dist < z_dist) m_transform_axis = Axis::Y;
else m_transform_axis = Axis::Z;
}
}
}
/** Performs the transformation. */
void Scale::apply() {
State::push();
State::apply(getMatrix());
}
CMatrix CModelX::getFrameMatrix(const char *name, bool local) {
CFrameBone *f = (CFrameBone*)CFrameBone::getFrameByName(name, pFrameRoot);
return (local) ? f->getSMatrix() : getMatrix() * f->getSMatrix();
}
void Graphics::scale(const float x, const float y, const float z) {
setMatrix(getMatrix() * Matrix::scale(x, y, z));
}
void Graphics::rotate(const float angle, const float x, const float y, const float z) {
setMatrix(getMatrix() * Matrix::rotation(angle, x, y, z));
}
void Graphics::translate(const float x, const float y, const float z) {
setMatrix(getMatrix() * Matrix::translation(x, y, z));
}
void ASprite::computeMatrix()
{
//m_program->bind();
AMatrix4x4 viewMatrix = getViewPortMatrix() * getMatrix();
AMatrix4x4 lbmatrix = viewMatrix;
lbmatrix.translate(mx_offset,my_offset,0);
lbmatrix.rotate(m_angle,0,0,1);
lbmatrix.translate(-mx_offset,-my_offset,0);
m_program->setUniformValue("mvp_matrix", lbmatrix);//set shader
if(isNeedRealTime)
{
AMatrix4x4 ltmatrix = viewMatrix;
AMatrix4x4 rbmatrix = viewMatrix;
AMatrix4x4 rtmatrix = viewMatrix;
//ltmatrix.translate(0,m_geometric.height(),0);
//rbmatrix.translate(m_geometric.width(),0,0);
//rtmatrix.translate(m_geometric.width(),m_geometric.height(),0);
//ltmatrix.translate(0,-m_geometric.height(),0);
ltmatrix.translate(mx_offset,my_offset,0);
ltmatrix.rotate(m_angle,0,0,1);
ltmatrix.translate(-mx_offset,-my_offset,0);
ltmatrix.translate(0,m_geometric.height(),0);
rbmatrix.translate(mx_offset,my_offset,0);
rbmatrix.rotate(m_angle,0,0,1);
rbmatrix.translate(-mx_offset,-my_offset,0);
rbmatrix.translate(m_geometric.width(),0,0);
rtmatrix.translate(mx_offset,my_offset,0);
rtmatrix.rotate(m_angle,0,0,1);
rtmatrix.translate(-mx_offset,-my_offset,0);
rtmatrix.translate(m_geometric.width(),m_geometric.height(),0);
AMatrix4x4 currentMatrix = getViewPortMatrix().inverted();
AMatrix4x4 leftBottonMatrix = currentMatrix * lbmatrix;
AMatrix4x4 leftTopMatrix = currentMatrix * ltmatrix;
AMatrix4x4 rightBottonMatrix = currentMatrix * rbmatrix;
AMatrix4x4 rightTopMatrix = currentMatrix * rtmatrix;
float lbx = leftBottonMatrix.row(0).w();
float lby = leftBottonMatrix.row(1).w();
m_leftBottonX = lbx;
m_leftBottonY = lby;
float ltx = leftTopMatrix.row(0).w();
float lty = leftTopMatrix.row(1).w();
m_leftTopX = ltx;
m_leftTopY = lty;
float rbx = rightBottonMatrix.row(0).w();
float rby = rightBottonMatrix.row(1).w();
m_rightBottonX = rbx;
m_rightBottonY = rby;
float rtx = rightTopMatrix.row(0).w();
float rty = rightTopMatrix.row(1).w();
m_rightTopX = rtx;
m_rightTopY = rty;
}
}
void Gizmo::renderTranslateGizmo(PipelineInstance& pipeline)
{
if (!m_shader->isReady()) return;
Matrix scale_mtx = Matrix::IDENTITY;
scale_mtx.m11 = scale_mtx.m22 = scale_mtx.m33 = m_scale;
Matrix gizmo_mtx;
getMatrix(gizmo_mtx);
Matrix mtx = gizmo_mtx * scale_mtx;
Vertex vertices[9];
uint16 indices[9];
vertices[0].position = Vec3(0, 0, 0);
vertices[0].color = m_transform_axis == Axis::X ? SELECTED_COLOR : X_COLOR;
indices[0] = 0;
vertices[1].position = Vec3(1, 0, 0);
vertices[1].color = m_transform_axis == Axis::X ? SELECTED_COLOR : X_COLOR;
indices[1] = 1;
vertices[2].position = Vec3(0, 0, 0);
vertices[2].color = m_transform_axis == Axis::Y ? SELECTED_COLOR : Y_COLOR;
indices[2] = 2;
vertices[3].position = Vec3(0, 1, 0);
vertices[3].color = m_transform_axis == Axis::Y ? SELECTED_COLOR : Y_COLOR;
indices[3] = 3;
vertices[4].position = Vec3(0, 0, 0);
vertices[4].color = m_transform_axis == Axis::Z ? SELECTED_COLOR : Z_COLOR;
indices[4] = 4;
vertices[5].position = Vec3(0, 0, 1);
vertices[5].color = m_transform_axis == Axis::Z ? SELECTED_COLOR : Z_COLOR;
indices[5] = 5;
Lumix::TransientGeometry geom(vertices, 6, m_vertex_decl, indices, 6);
pipeline.render(geom,
mtx,
0,
6,
BGFX_STATE_PT_LINES | BGFX_STATE_DEPTH_TEST_LEQUAL,
m_shader->getInstance(0).m_program_handles[pipeline.getPassIdx()]);
if (dotProduct(gizmo_mtx.getXVector(), m_camera_dir) < 0) mtx.setXVector(-mtx.getXVector());
if (dotProduct(gizmo_mtx.getYVector(), m_camera_dir) < 0) mtx.setYVector(-mtx.getYVector());
if (dotProduct(gizmo_mtx.getZVector(), m_camera_dir) < 0) mtx.setZVector(-mtx.getZVector());
vertices[0].position = Vec3(0, 0, 0);
vertices[0].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR;
indices[0] = 0;
vertices[1].position = Vec3(0.5f, 0, 0);
vertices[1].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR;
indices[1] = 1;
vertices[2].position = Vec3(0, 0.5f, 0);
vertices[2].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR;
indices[2] = 2;
vertices[3].position = Vec3(0, 0, 0);
vertices[3].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR;
indices[3] = 3;
vertices[4].position = Vec3(0, 0.5f, 0);
vertices[4].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR;
indices[4] = 4;
vertices[5].position = Vec3(0, 0, 0.5f);
vertices[5].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR;
indices[5] = 5;
vertices[6].position = Vec3(0, 0, 0);
vertices[6].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR;
indices[6] = 6;
vertices[7].position = Vec3(0.5f, 0, 0);
vertices[7].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR;
indices[7] = 7;
vertices[8].position = Vec3(0, 0, 0.5f);
vertices[8].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR;
indices[8] = 8;
Lumix::TransientGeometry geom2(vertices, 9, m_vertex_decl, indices, 9);
auto program_handle = m_shader->getInstance(0).m_program_handles[pipeline.getPassIdx()];
pipeline.render(geom2, mtx, 0, 9, BGFX_STATE_DEPTH_TEST_LEQUAL, program_handle);
}
osg::Matrixd ViewingCore::getInverseMatrix() const
{
osg::Matrixd m;
m.invert( getMatrix() );
return( m );
}
Matrix4X4 * GLMath::getTransformation(void)
{
//_glMatrixMultiply(&transformation, getMatrix(_GL_MATRIXMODE_MODELVIEW), getMatrix(_GL_MATRIXMODE_PROJECTION));
_glMatrixMultiply(&transformation, getMatrix(_GL_MATRIXMODE_PROJECTION), getMatrix(_GL_MATRIXMODE_MODELVIEW));
return &transformation;
}
QVector3D Canvas::sceneToWorld(QPointF p) const
{
QMatrix4x4 M = getMatrix().inverted();
return M * QVector3D(p.x(), p.y(), 0);
}
SFC::DT getMatrix( int rows, int columns, const std::string &typeName ) {
return getMatrix( rows, columns, getBasicType( typeName ) );
}
const glm::mat4 &Transformation::getTranslationMatrix() const
{
if(dirty)
getMatrix();
return m_cacheTranslationMatrix;
}
Matrix4D ParametrizedRayGroup::getInverseMatrix(void){return getMatrix().invert();}
void
TextSnapshot_as::getTextRunInfo(size_t start, size_t end, as_object& ri) const
{
std::string::size_type pos = 0;
std::string::size_type len = end - start;
for (TextFields::const_iterator field = _textFields.begin(),
e = _textFields.end(); field != e; ++field) {
const Records& rec = field->second;
const SWFMatrix& mat = getMatrix(*field->first);
const boost::dynamic_bitset<>& selected = field->first->getSelected();
const std::string::size_type fieldStartIndex = pos;
for (Records::const_iterator j = rec.begin(), end = rec.end();
j != end; ++j) {
const SWF::TextRecord* tr = *j;
assert(tr);
const SWF::TextRecord::Glyphs& glyphs = tr->glyphs();
const SWF::TextRecord::Glyphs::size_type numGlyphs = glyphs.size();
if (pos + numGlyphs < start) {
pos += numGlyphs;
continue;
}
const Font* font = tr->getFont();
assert(font);
double x = tr->xOffset();
for (SWF::TextRecord::Glyphs::const_iterator k = glyphs.begin(),
e = glyphs.end(); k != e; ++k) {
if (pos < start) {
x += k->advance;
++pos;
continue;
}
as_object* el = new as_object(getGlobal(ri));
el->init_member("indexInRun", pos);
el->init_member("selected",
selected.test(pos - fieldStartIndex));
el->init_member("font", font->name());
el->init_member("color", tr->color().toRGBA());
el->init_member("height", twipsToPixels(tr->textHeight()));
const double factor = 65536.0;
el->init_member("matrix_a", mat.a() / factor);
el->init_member("matrix_b", mat.b() / factor);
el->init_member("matrix_c", mat.c() / factor);
el->init_member("matrix_d", mat.d() / factor);
const double xpos = twipsToPixels(mat.tx() + x);
const double ypos = twipsToPixels(mat.ty() + tr->yOffset());
el->init_member("matrix_tx", xpos);
el->init_member("matrix_ty", ypos);
callMethod(&ri, NSV::PROP_PUSH, el);
++pos;
x += k->advance;
if (pos - start > len) return;
}
}
}
}
Matrix4D ParametrizedRayGroup::getNormalMatrix(void){return getMatrix().invert().transpose();}
void ColorDisplayFilter::changed(ConstFieldMaskArg whichField,
UInt32 origin,
BitVector details)
{
Inherited::changed(whichField, origin, details);
if(0x0000 != (whichField & (ColorTableWidthFieldMask |
ColorTableHeightFieldMask |
ColorTableDepthFieldMask |
ColorTableFieldMask )))
{
UInt32 c;
std::vector<UChar8> vImageData;
UInt32 uiWidth = getColorTableWidth ();
UInt32 uiHeight = getColorTableHeight();
UInt32 uiDepth = getColorTableDepth ();
UInt32 uiSize = (uiWidth * uiHeight * uiDepth);
if(uiSize != getMFColorTable()->size() || uiDepth < 2)
{
// create default linear table
//FWARNING(("Wrong shading table size\n"));
uiWidth = uiHeight = 1;
uiDepth = 2;
vImageData.push_back(0);
vImageData.push_back(0);
vImageData.push_back(0);
vImageData.push_back(255);
vImageData.push_back(255);
vImageData.push_back(255);
}
else
{
const MFColor3f &vColors = *(this->getMFColorTable());
vImageData.resize(uiSize * 3);
for(c = 0; c < uiSize ; ++c)
{
vImageData[c * 3 + 0] = UChar8(vColors[c][0] * 255);
vImageData[c * 3 + 1] = UChar8(vColors[c][1] * 255);
vImageData[c * 3 + 2] = UChar8(vColors[c][2] * 255);
}
}
Image *pImg = this->getTableImage();
if(pImg == NULL)
{
// Make Cluster Local
ImageUnrecPtr pImage = Image::createLocal(FCLocal::Cluster);
pImg = pImage;
this->setTableImage(pImage);
}
pImg->set( Image::OSG_RGB_PF,
uiWidth, uiHeight, uiDepth,
1, 1, 0,
&vImageData[0]);
SimpleSHLChunk *pShader = this->getFilterShader();
if(pShader != NULL)
{
pShader->addUniformVariable("shadingWidth", Int32(uiWidth));
pShader->addUniformVariable("shadingHeight", Int32(uiHeight));
pShader->addUniformVariable("shadingDepth", Int32(uiDepth));
}
}
if(0x0000 != (whichField & (MatrixFieldMask)))
{
SimpleSHLChunk *pShader = this->getFilterShader();
if(pShader != NULL)
{
pShader->addUniformVariable("colorMatrix", getMatrix());
}
}
if(0x0000 != (whichField & (GammaFieldMask)))
{
SimpleSHLChunk *pShader = this->getFilterShader();
if(pShader != NULL)
{
pShader->addUniformVariable("gamma", getGamma());
}
}
}
//----------------------------------------------------- matrix.
ofMatrix4x4 QuadWarp::getMatrix() {
return getMatrix(&srcPoints[0], &dstPoints[0]);
}
void cameraInfoHandler(const sensor_msgs::ImageConstPtr& left
, const sensor_msgs::ImageConstPtr& right
, const sensor_msgs::ImageConstPtr& depth
, const sensor_msgs::CameraInfoConstPtr& leftCameraInfo
, const sensor_msgs::CameraInfoConstPtr& rightCameraInfo)
{
//TODO: calibarate cameras - assume cameras are calibrated
//rectification
static std::vector<std::vector<double> > leftCamMatData = {
{leftCameraInfo->K[0], leftCameraInfo->K[1], leftCameraInfo->K[2]},
{leftCameraInfo->K[3], leftCameraInfo->K[4], leftCameraInfo->K[5]},
{leftCameraInfo->K[6], leftCameraInfo->K[7], leftCameraInfo->K[8]}
};
static std::vector<std::vector<double> > rightCamMatData = {
{rightCameraInfo->K[0], rightCameraInfo->K[1], rightCameraInfo->K[2]},
{rightCameraInfo->K[3], rightCameraInfo->K[4], rightCameraInfo->K[5]},
{rightCameraInfo->K[6], rightCameraInfo->K[7], rightCameraInfo->K[8]}
};
static std::vector<std::vector<double> > rData = {
{leftCameraInfo->R[0], leftCameraInfo->R[1], leftCameraInfo->R[2]},
{leftCameraInfo->R[3], leftCameraInfo->R[4], leftCameraInfo->R[5]},
{leftCameraInfo->R[6], leftCameraInfo->R[7], leftCameraInfo->R[8]}
};
static std::vector<std::vector<double> > leftCamDData = {
{ leftCameraInfo->D[0] },
{ leftCameraInfo->D[1] },
{ leftCameraInfo->D[2] },
{ leftCameraInfo->D[3] },
{ leftCameraInfo->D[4] }
};
static std::vector<std::vector<double> > rightCamDData = {
{ rightCameraInfo->D[0] },
{ rightCameraInfo->D[1] },
{ rightCameraInfo->D[2] },
{ rightCameraInfo->D[3] },
{ rightCameraInfo->D[4] }
};
static std::vector<std::vector<double> > tData = {
{ rightCameraInfo->P[3] },
{ rightCameraInfo->P[7] },
{ rightCameraInfo->P[11] }
};
static cv::Mat leftCamMat = getMatrix(leftCamMatData);
static cv::Mat rightCamMat = getMatrix(rightCamMatData);
static cv::Mat leftCamD = getMatrix(leftCamDData);
static cv::Mat rightCamD = getMatrix(rightCamDData);
static cv::Mat R = getMatrix(rData);
static cv::Mat T = getMatrix(tData);
static cv::Mat R1, R2, P1, P2;
if (Q.empty())
{
cv::stereoRectify(
leftCamMat,
leftCamD,
rightCamMat,
rightCamD,
cv::Size(leftCameraInfo->width, leftCameraInfo->height),
R,
T,
R1,
R2,
P1,
P2,
Q
);
Q.convertTo(Q, CV_32FC1);
Q.at<float>(3, 3) = -Q.at<float>(3, 3);
std::cout << "Computed rectification matrices!" << std::endl;
}
if (leftCamMap1.empty() && leftCamMap2.empty())
{
cv::initUndistortRectifyMap(
leftCamMat,
leftCamD,
R1,
leftCamMat,
cv::Size(leftCameraInfo->width, leftCameraInfo->height),
CV_32FC1,
leftCamMap1,
leftCamMap2
);
std::cout << "Computed rectification map for left camera!" << std::endl;
}
if (rightCamMap1.empty() && rightCamMap2.empty())
{
cv::initUndistortRectifyMap(
rightCamMat,
rightCamD,
R2,
rightCamMat,
cv::Size(rightCameraInfo->width, rightCameraInfo->height),
CV_32FC1,
rightCamMap1,
rightCamMap2
);
std::cout << "Computed rectification map for right camera!" << std::endl;
}
}
ofMatrix4x4 QuadWarp::getMatrixInverse() {
return getMatrix(&dstPoints[0], &srcPoints[0]);
}
//////////////////////////////////////////////////////////////////////////
// drawSprite
void ScnCanvasComponent::drawSprite( const MaVec2d& Position, const MaVec2d& Size, BcU32 TextureIdx, const RsColour& Colour, BcU32 Layer )
{
ScnCanvasComponentVertex* pVertices = allocVertices( 6 );
ScnCanvasComponentVertex* pFirstVertex = pVertices;
const MaVec2d CornerA = Position;
const MaVec2d CornerB = Position + Size;
const ScnRect Rect = DiffuseTexture_.isValid() ? DiffuseTexture_->getRect( TextureIdx ) : ScnRect();
// Only draw if we can allocate vertices.
if( pVertices != NULL )
{
// Now copy in data.
BcU32 ABGR = Colour.asABGR();
pVertices->X_ = CornerA.x();
pVertices->Y_ = CornerA.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_;
pVertices->V_ = Rect.Y_;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = CornerB.x();
pVertices->Y_ = CornerA.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_ + Rect.W_;
pVertices->V_ = Rect.Y_;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = CornerA.x();
pVertices->Y_ = CornerB.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_;
pVertices->V_ = Rect.Y_ + Rect.H_;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = CornerA.x();
pVertices->Y_ = CornerB.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_;
pVertices->V_ = Rect.Y_ + Rect.H_;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = CornerB.x();
pVertices->Y_ = CornerA.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_ + Rect.W_;
pVertices->V_ = Rect.Y_;
pVertices->ABGR_ = ABGR;
++pVertices;
pVertices->X_ = CornerB.x();
pVertices->Y_ = CornerB.y();
pVertices->Z_ = 0.0f;
pVertices->W_ = 1.0f;
pVertices->U_ = Rect.X_ + Rect.W_;
pVertices->V_ = Rect.Y_ + Rect.H_;
pVertices->ABGR_ = ABGR;
// Quickly check last primitive.
BcBool AddNewPrimitive = BcTrue;
if( LastPrimitiveSection_ != BcErrorCode )
{
ScnCanvasComponentPrimitiveSection& PrimitiveSection = PrimitiveSectionList_[ LastPrimitiveSection_ ];
// If the last primitive was the same type as ours we can append to it.
// NOTE: Need more checks here later.
if( PrimitiveSection.Type_ == RsTopologyType::TRIANGLE_LIST &&
PrimitiveSection.Layer_ == Layer &&
PrimitiveSection.MaterialComponent_ == MaterialComponent_ )
{
PrimitiveSection.NoofVertices_ += 6;
// Matrix stack.
// TODO: Factor into a seperate function.
if( IsIdentity_ == BcFalse )
{
MaMat4d Matrix = getMatrix();
for( BcU32 Idx = 0; Idx < 6; ++Idx )
{
ScnCanvasComponentVertex* pVertex = &pFirstVertex[ Idx ];
MaVec3d Vertex = MaVec3d( pVertex->X_, pVertex->Y_, pVertex->Z_ ) * Matrix;
pVertex->X_ = Vertex.x();
pVertex->Y_ = Vertex.y();
pVertex->Z_ = Vertex.z();
pVertex->W_ = 1.0f;
}
}
AddNewPrimitive = BcFalse;
}
}
// Add primitive.
if( AddNewPrimitive == BcTrue )
{
addPrimitive( RsTopologyType::TRIANGLE_LIST, pFirstVertex, 6, Layer, BcTrue );
}
}
}
void Graphics::frustum(const float left, const float right, const float bottom, const float top, const float near, const float far) {
setMatrix(getMatrix() * Matrix::frustum(left, right, bottom, top, near, far));
}
