void StandardLightVisualiser::addEnvLightVisualiser( GroupPtr &output, Color3f multiplier, const std::string &textureName ) { IECoreGL::GroupPtr sphereGroup = new IECoreGL::Group(); Imath::M44f trans; trans.scale( V3f( 1, 1, -1 ) ); trans.rotate( V3f( -0.5 * M_PI, -0.5 * M_PI, 0 ) ); sphereGroup->setTransform( trans ); IECoreGL::SpherePrimitivePtr sphere = new IECoreGL::SpherePrimitive(); sphereGroup->addChild( sphere ); IECore::CompoundObjectPtr parameters = new CompoundObject; parameters->members()["lightMultiplier"] = new Color3fData( multiplier ); parameters->members()["previewOpacity"] = new FloatData( 1 ); parameters->members()["mapSampler"] = new StringData( textureName ); parameters->members()["defaultColor"] = new Color3fData( Color3f( textureName == "" ? 1.0f : 0.0f ) ); sphereGroup->getState()->add( new IECoreGL::ShaderStateComponent( ShaderLoader::defaultShaderLoader(), TextureLoader::defaultTextureLoader(), IECoreGL::Shader::defaultVertexSource(), "", environmentLightDrawFragSource(), parameters ) ); sphereGroup->getState()->add( new IECoreGL::DoubleSidedStateComponent( false ) ); output->addChild( sphereGroup ); }
Imath::M44f Transform::computeProcessedTransform( const ScenePath &path, const Gaffer::Context *context, const Imath::M44f &inputTransform ) const { const Space space = static_cast<Space>( spacePlug()->getValue() ); const Imath::M44f matrix = transformPlug()->matrix(); switch( space ) { case Local : return matrix * inputTransform; case Parent : return inputTransform * matrix; case World : { bool matchingAncestorFound = false; const Imath::M44f parentMatrix = relativeParentTransform( path, context, matchingAncestorFound ); if( matchingAncestorFound ) { // The ancestor will have the relative world matrix applied, // and we will inherit it, so we don't need to do anything at all. return inputTransform; } else { // We're all on our own, so we invert the parent // matrix to get back to world space, apply the matrix // we want to get a new world space, and then reapply // all of our original transform. return inputTransform * parentMatrix * matrix * parentMatrix.inverse(); } } case ResetLocal : return matrix; case ResetWorld : { bool matchingAncestorFound = false; const Imath::M44f parentMatrix = relativeParentTransform( path, context, matchingAncestorFound ); if( matchingAncestorFound ) { // We will be giving the ancestor the absolute // world space matrix we want, so we just have to // cancel out the relative matrix between us and // that ancestor. return parentMatrix.inverse(); } else { // We're all on our own, so we invert the parent // matrix to get back to world space, and then // apply the world space matrix we want. return matrix * parentMatrix.inverse(); } } default : // Should never get here. return Imath::M44f(); } }
void ofxAlembic::Reader::setTime(double time) { if (!m_root) return; Imath::M44f m; m.makeIdentity(); m_root->updateWithTime(time, m); current_time = time; }
void Viewport::roll(int deltaSide){ if(deltaSide != 0){ _roll += deltaSide; Imath::M44f mRoll; mRoll.setAxisAngle(Imath::V3f(0.f, 0.f, 1.f), (float)DEGTORAD(deltaSide)); _modelMatrix.setValue(mRoll * _modelMatrix); } }
void StandardLightVisualiser::addBasicLightVisualiser( ConstStringDataPtr type, GroupPtr &output, Color3f multiplier, float coneAngle, float penumbraAngle, const std::string *penumbraType, float lensRadius ) { bool indicatorFaceCamera = false; if( !type || type->readable() == "point" ) { output->addChild( const_pointer_cast<IECoreGL::Renderable>( pointRays() ) ); indicatorFaceCamera = true; } else if( type->readable() == "spot" ) { float innerAngle = 0; float outerAngle = 0; if( !penumbraType || *penumbraType == "inset" ) { outerAngle = coneAngle; innerAngle = coneAngle - 2.0f * penumbraAngle; } else if( *penumbraType == "outset" ) { outerAngle = coneAngle + 2.0f * penumbraAngle; innerAngle = coneAngle ; } else if( *penumbraType == "absolute" ) { outerAngle = coneAngle; innerAngle = penumbraAngle; } output->addChild( const_pointer_cast<IECoreGL::Renderable>( spotlightCone( innerAngle, outerAngle, lensRadius ) ) ); output->addChild( const_pointer_cast<IECoreGL::Renderable>( ray() ) ); } else if( type->readable() == "distant" ) { for ( int i = 0; i < 3; i++ ) { IECoreGL::GroupPtr rayGroup = new IECoreGL::Group(); Imath::M44f trans; trans.rotate( V3f( 0, 0, 2.0 * M_PI / 3.0 * i ) ); trans.translate( V3f( 0, 0.4, 0.5 ) ); rayGroup->addChild( const_pointer_cast<IECoreGL::Renderable>( ray() ) ); rayGroup->setTransform( trans ); output->addChild( rayGroup ); } } output->addChild( const_pointer_cast<IECoreGL::Renderable>( colorIndicator( multiplier, indicatorFaceCamera ) ) ); }
Imath::M44f AimConstraint::computeConstraint( const Imath::M44f &fullTargetTransform, const Imath::M44f &fullInputTransform ) const { // decompose into scale, shear, rotate and translate V3f s, h, r, t; extractSHRT( fullInputTransform, s, h, r, t ); // figure out the aim matrix const V3f toDir = ( fullTargetTransform.translation() - t ).normalized(); const M44f rotationMatrix = rotationMatrixWithUpDir( aimPlug()->getValue(), toDir, upPlug()->getValue() ); // rebuild, replacing rotate with the aim matrix M44f result; result.translate( t ); result.shear( h ); result = rotationMatrix * result; result.scale( s ); return result; }
void ofxAlembic::IXform::updateWithTimeInternal(double time, Imath::M44f& transform) { ISampleSelector ss(time, ISampleSelector::kNearIndex); M44f mat; M44d m = m_xform.getSchema().getValue(ss).getMatrix(); double *src = m.getValue(); float *dst = mat.getValue(); for (int i = 0; i < 16; i++) dst[i] = src[i]; transform = mat * transform; for (int i = 0; i < 16; i++) { xform.local_matrix.getPtr()[i] = mat.getValue()[i]; xform.global_matrix.getPtr()[i] = transform.getValue()[i]; } }
Imath::M44f PointConstraint::computeConstraint( const Imath::M44f &fullTargetTransform, const Imath::M44f &fullInputTransform ) const { const V3f worldPosition = fullTargetTransform.translation() + offsetPlug()->getValue(); M44f result = fullInputTransform; if( xEnabledPlug()->getValue() ) { result[3][0] = worldPosition[0]; } if( yEnabledPlug()->getValue() ) { result[3][1] = worldPosition[1]; } if( zEnabledPlug()->getValue() ) { result[3][2] = worldPosition[2]; } return result; }
void ViewportGadget::SelectionScope::begin( const ViewportGadget *viewportGadget, const Imath::Box2f &rasterRegion, const Imath::M44f &transform, IECoreGL::Selector::Mode mode ) { V2f viewport = viewportGadget->getViewport(); Box2f ndcRegion( rasterRegion.min / viewport, rasterRegion.max / viewport ); IECoreGL::ToGLConverterPtr converter = new IECoreGL::ToGLCameraConverter( const_cast<CameraController &>( viewportGadget->m_cameraController ).getCamera() ); IECoreGL::CameraPtr camera = staticPointerCast<IECoreGL::Camera>( converter->convert() ); /// \todo It would be better to base this on whether we have a depth buffer or not, but /// we don't have access to that information right now. m_depthSort = camera->isInstanceOf( IECoreGL::PerspectiveCamera::staticTypeId() ); camera->render( 0 ); glClearColor( 0.3f, 0.3f, 0.3f, 0.0f ); glClearDepth( 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); m_selector = SelectorPtr( new IECoreGL::Selector( ndcRegion, mode, m_selection ) ); glPushMatrix(); glMultMatrixf( transform.getValue() ); }
void SkeletonPrimitive::render( const State *state, IECore::TypeId style ) const { Imath::V3f from_vec(0.0, 0.0, 1.0), up(0.0, 1.0, 0.0); JointPrimitive jointPrimitive( m_jointsRadius, 1.0 ); // loop over global transforms for (unsigned int i=0; i<m_globalMatrices->readable().size(); i++) { Imath::M44f child_mtx; unsigned int numChildren = m_childrenIds[i].size(); if (numChildren > 0) { for (unsigned int j=0; j< numChildren; j++ ) { child_mtx = m_globalMatrices->readable()[ m_childrenIds[i][j] ]; Imath::V3f aim_vec = child_mtx.translation() - m_globalMatrices->readable()[i].translation(); float bone_length = aim_vec.length(); jointPrimitive.setLength( bone_length ); Imath::V3f up_vec = up*m_globalMatrices->readable()[i] - m_globalMatrices->readable()[i].translation(); Imath::M44f bone_mtx = Imath::rotationMatrixWithUpDir( from_vec, aim_vec.normalize(), up_vec ); Imath::M44f bone_offset_mtx; bone_offset_mtx.translate( m_globalMatrices->readable()[i].translation() ); // draw the jointPrimitive glPushMatrix(); glMultMatrixf( bone_offset_mtx.getValue() ); glMultMatrixf( bone_mtx.getValue() ); jointPrimitive.render( state, style ); glPopMatrix(); } } else { // a Null or Locator shape when the joint has no children glPushMatrix(); Imath::M44f mat = m_globalMatrices->readable()[i]; Imath::removeScaling(mat, false); glMultMatrixf( mat.getValue() ); glBegin( GL_LINES ); glVertex3f(-m_jointsRadius, 0.0, 0.0); glVertex3f( m_jointsRadius, 0.0, 0.0); glEnd(); glBegin( GL_LINES ); glVertex3f(0.0, -m_jointsRadius, 0.0); glVertex3f(0.0, m_jointsRadius, 0.0); glEnd(); glBegin( GL_LINES ); glVertex3f(0.0, 0.0, -m_jointsRadius); glVertex3f(0.0, 0.0, m_jointsRadius); glEnd(); glPopMatrix(); } if ( m_jointsAxis == true) { float l = m_jointsRadius*3.0; //// draw the axis lines for debug porpose ///// glPushMatrix(); Imath::M44f matNoSCale = m_globalMatrices->readable()[i]; Imath::removeScaling(matNoSCale, false); glMultMatrixf( matNoSCale.getValue() ); ///// store the current color and lighting mode ///// GLboolean light; float color[4]; glGetBooleanv(GL_LIGHTING, &light); glGetFloatv(GL_CURRENT_COLOR, color); glDisable(GL_LIGHTING); glBegin( GL_LINES ); glColor3ub(255, 0, 0); glVertex3f(0.0, 0.0, 0.0); glVertex3f(l, 0.0, 0.0); glEnd(); glBegin( GL_LINES ); glColor3ub(0, 255, 0); glVertex3f(0.0, 0.0, 0.0); glVertex3f(0.0, l, 0.0); glEnd(); glBegin( GL_LINES ); glColor3ub(0, 0, 255); glVertex3f(0.0, 0.0, 0.0); glVertex3f(0.0, 0.0, l); glEnd(); //// restore the color and the lighting modo to their initial state ///// glColor4f(color[0], color[1], color[2], color[3]); if (light==true) { glEnable(GL_LIGHTING); } glPopMatrix(); } } }
void ImmediateRendererImplementation::concatTransform( const Imath::M44f &matrix ) { glMultMatrixf( matrix.getValue() ); }
Imath::M44f SceneNode::getGlobalTransFloat(double time) { Imath::M44f ret; ret.makeIdentity(); return ret; }
void Renderer::loadMesh(const std::string& file) { Imath::M44f meshTransform; #if VOXELIZE_GPU Mesh* mesh = MeshLoader::loadFromOBJ(file.c_str()); if (mesh == NULL) return; createVoxelDataTexture(Imath::V3i(64)); meshTransform = computeMeshTransform(mesh->bounds(), m_glResources.m_volumeResolution); GPUVoxelizer voxelizer(m_shaderPath, m_logger); voxelizer.voxelizeMesh(mesh, meshTransform, m_glResources.m_volumeResolution, GLResourceConfiguration::TEXTURE_UNIT_MATERIAL_OFFSET); delete(mesh); #else std::vector<float> vertices; std::vector<unsigned int> indices; MeshLoader::loadFromOBJ(file.c_str(), vertices, indices); Imath::Box3f bounds = computeBounds(&vertices[0], vertices.size() / 3); meshTransform = computeMeshTransform(bounds, m_glResources.m_volumeResolution); // FIXME: I must be having a mismatch in the way I upload the matrices to // GLSL -- this transpose should not be necessary if the above matrix is // valid for the GPU voxelization. meshTransform.transpose(); Imath::V3f* verts = reinterpret_cast<Imath::V3f*>(&vertices[0]); for(size_t i = 0; i < vertices.size() / 3; ++i) { meshTransform.multVecMatrix(verts[i], verts[i]); // now transform the vertices from world space into voxel space, this would // be done by the vertex shader verts[i] *= m_glResources.m_volumeResolution; } const size_t numVoxels = (size_t)(m_glResources.m_volumeResolution.x * m_glResources.m_volumeResolution.y * m_glResources.m_volumeResolution.z); const size_t numTriangles = indices.size() / 3; GLint* materialOffsetTexels = (GLint*)malloc(numVoxels * sizeof(GLint)); for(size_t i = 0; i < numVoxels; ++i) materialOffsetTexels[i] = -1; CPUVoxelizer::voxelizeMesh(verts, &indices[0], numTriangles, m_glResources.m_volumeResolution, materialOffsetTexels); createVoxelDataTexture(m_glResources.m_volumeResolution); glBindTexture(GL_TEXTURE_3D, m_glResources.m_materialOffsetTexture); glTexImage3D(GL_TEXTURE_3D, 0, GL_R32I, m_glResources.m_volumeResolution.x, m_glResources.m_volumeResolution.y, m_glResources.m_volumeResolution.z, 0, GL_RED, GL_INT, materialOffsetTexels); free(materialOffsetTexels); #endif resetRender(); }
IECoreGL::ConstRenderablePtr StandardLightVisualiser::visualise( const IECore::InternedString &attributeName, const IECore::ObjectVector *shaderVector, IECoreGL::ConstStatePtr &state ) const { if( !shaderVector || shaderVector->members().size() == 0 ) { return NULL; } IECore::InternedString metadataTarget; const IECore::CompoundData *shaderParameters = NULL; if( const IECore::Shader *shader = IECore::runTimeCast<const IECore::Shader>( shaderVector->members().back().get() ) ) { metadataTarget = attributeName.string() + ":" + shader->getName(); shaderParameters = shader->parametersData(); } else if( const IECore::Light *light = IECore::runTimeCast<const IECore::Light>( shaderVector->members().back().get() ) ) { /// \todo Remove once all Light node derived classes are /// creating only shaders. metadataTarget = attributeName.string() + ":" + light->getName(); shaderParameters = light->parametersData().get(); } if( !shaderParameters ) { return NULL; } ConstStringDataPtr type = Metadata::value<StringData>( metadataTarget, "type" ); ConstM44fDataPtr orientation = Metadata::value<M44fData>( metadataTarget, "visualiserOrientation" ); const Color3f color = parameter<Color3f>( metadataTarget, shaderParameters, "colorParameter", Color3f( 1.0f ) ); const float intensity = parameter<float>( metadataTarget, shaderParameters, "intensityParameter", 1 ); const float exposure = parameter<float>( metadataTarget, shaderParameters, "exposureParameter", 0 ); const Color3f finalColor = color * intensity * pow( 2.0f, exposure ); if( type && type->readable() == "area" ) { const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" ); const bool flipNormal = parameter<bool>( metadataTarget, shaderParameters, "flipNormalParameter", 0 ); const bool doubleSided = parameter<bool>( metadataTarget, shaderParameters, "doubleSidedParameter", 0 ); const bool sphericalProjection = parameter<bool>( metadataTarget, shaderParameters, "sphericalProjectionParameter", 0 ); M44f projectionTransform = parameter<M44f>( metadataTarget, shaderParameters, "projectionTransformParameter", M44f() ); const std::vector<float> projectionTransformVector = parameter<std::vector<float> >( metadataTarget, shaderParameters, "projectionTransformParameter", std::vector<float>() ); if( projectionTransformVector.size() == 16 ) { projectionTransform = M44f( (float(*)[4])(&projectionTransformVector[0]) ); } addAreaLightVisualiser( state, finalColor, textureName, flipNormal, doubleSided, sphericalProjection, projectionTransform ); return NULL; } GroupPtr result = new Group; const float locatorScale = parameter<float>( metadataTarget, shaderParameters, "locatorScaleParameter", 1 ); Imath::M44f topTrans; if( orientation ) { topTrans = orientation->readable(); } topTrans.scale( V3f( locatorScale ) ); result->setTransform( topTrans ); if( type && type->readable() == "environment" ) { const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" ); addEnvLightVisualiser( result, finalColor, textureName ); } else { float coneAngle = parameter<float>( metadataTarget, shaderParameters, "coneAngleParameter", 0.0f ); float penumbraAngle = parameter<float>( metadataTarget, shaderParameters, "penumbraAngleParameter", 0.0f ); if( ConstStringDataPtr angleUnit = Metadata::value<StringData>( metadataTarget, "angleUnit" ) ) { if( angleUnit->readable() == "radians" ) { coneAngle *= 180.0 / M_PI; penumbraAngle *= 180 / M_PI; } } const std::string *penumbraType = NULL; ConstStringDataPtr penumbraTypeData = Metadata::value<StringData>( metadataTarget, "penumbraType" ); if( penumbraTypeData ) { penumbraType = &penumbraTypeData->readable(); } float lensRadius = 0.0f; if( parameter<bool>( metadataTarget, shaderParameters, "lensRadiusEnableParameter", true ) ) { lensRadius = parameter<float>( metadataTarget, shaderParameters, "lensRadiusParameter", 0.0f ); } addBasicLightVisualiser( type, result, finalColor, coneAngle, penumbraAngle, penumbraType, lensRadius / locatorScale ); } return result; }
bool RATDeepImageReader::open( bool throwOnFailure ) { if ( m_inputFile && fileName() == m_inputFileName ) { // we already opened the right file successfully return true; } delete m_ratPixel; delete m_inputFile; m_inputFile = new IMG_DeepShadow; m_inputFileName = ""; m_channelNames = ""; m_ratPixel = 0; m_depthChannel = 0; m_opacityChannel = 0; m_colorChannel = 0; m_dataWindow.max.x = 0; m_dataWindow.max.y = 0; m_worldToCamera = Imath::M44f(); m_worldToNDC = Imath::M44f(); bool success = true; if ( m_inputFile->open( fileName().c_str() ) && m_inputFile->depthInterp() == IMG_COMPRESS_DISCRETE ) { m_inputFileName = fileName(); m_ratPixel = new IMG_DeepPixelReader( *m_inputFile ); const IMG_DeepShadowChannel *channel = 0; unsigned numChannels = m_inputFile->getChannelCount(); for ( unsigned c=0; c < numChannels; ++c ) { channel = m_inputFile->getChannel( c ); std::string name = channel->getName(); if ( name == "Pz" ) { m_depthChannel = channel; } else if ( name == "Of" ) { m_opacityChannel = channel; } else if ( name == "C" ) { m_colorChannel = channel; } } if ( m_colorChannel ) { m_channelNames = "RGBA"; } else { m_colorChannel = m_opacityChannel; m_channelNames = "A"; } if ( !m_depthChannel || !m_opacityChannel || !m_colorChannel ) { success = false; } m_inputFile->resolution( m_dataWindow.max.x, m_dataWindow.max.y ); m_dataWindow.max.x -= 1; m_dataWindow.max.y -= 1; UT_Matrix4 wToC( 1 ); m_inputFile->getWorldToCamera( wToC ); m_worldToCamera = IECore::convert<Imath::M44f>( wToC ); UT_Matrix4 wToNDC( 1 ); m_inputFile->getWorldToNDC( wToNDC, true ); // wToNDC has flipped values and a scaling issue related to the far clipping plane // applying a matrix that seems to fix the issues in several examples Imath::M44f fix; fix.makeIdentity(); UT_Options *options = m_inputFile->getTBFOptions(); if ( options->hasOption( "camera:clip" ) ) { const UT_Vector2D clip = options->getOptionV2( "camera:clip" ); fix[2][2] = clip[1]; fix[3][3] = -1; } m_worldToNDC = IECore::convert<Imath::M44f>( wToNDC ) * fix; } else { success = false; } if ( !success ) { delete m_ratPixel; delete m_inputFile; m_inputFile = 0; m_inputFileName = ""; m_channelNames = ""; m_ratPixel = 0; m_depthChannel = 0; m_opacityChannel = 0; m_colorChannel = 0; m_dataWindow.max.x = 0; m_dataWindow.max.y = 0; m_worldToCamera = Imath::M44f(); m_worldToNDC = Imath::M44f(); if ( !throwOnFailure ) { return false; } else { throw IOException( std::string( "Failed to open file \"" ) + fileName() + "\"" ); } } return true; }