void
ColladaInstanceGeometry::read(ColladaElement *colElemParent)
{
    OSG_COLLADA_LOG(("ColladaInstanceGeometry::read\n"));

    ColladaGeometryRefPtr colGeo = getTargetElem();

    if(colGeo == NULL)
    {
        colGeo = dynamic_pointer_cast<ColladaGeometry>(
            ColladaElementFactory::the()->create(
                getTargetDOMElem(), getGlobal()));

        colGeo->read(this);
    }

    domInstance_geometryRef instGeo = getDOMElementAs<domInstance_geometry>();
    domBind_materialRef     bindMat = instGeo->getBind_material            ();

    if(bindMat == NULL)
    {
        SWARNING << "ColladaInstanceGeometry::read: "
                 << "No <bind_material> found." << std::endl;
        return;
    }

    readBindMaterial(bindMat);
}
Beispiel #2
0
ColladaInstanceEffect *
ColladaInstanceMaterial::getInstanceEffect(void) const
{
    domMaterialRef         material   = getTargetDOMElem            ();
    domInstance_effectRef  instEffect = material->getInstance_effect();

    return getUserDataAs<ColladaInstanceEffect>(instEffect);
}
void
ColladaInstanceController::read(void)
{
    OSG_COLLADA_LOG(("ColladaInstanceController::read\n"));

    ColladaControllerRefPtr colCont = getTargetElem();

    if(colCont == NULL)
    {
        colCont = dynamic_pointer_cast<ColladaController>(
            ColladaElementFactory::the()->create(
                getTargetDOMElem(), getGlobal()));

        colCont->read();
    }

	domInstance_controllerRef instCont = getDOMElementAs<domInstance_controller>();
	
	_joints = instCont->getSkeleton_array();

    domBind_materialRef     bindMat = instCont->getBind_material            ();

    if(bindMat == NULL)
    {
        SWARNING << "ColladaInstanceController::read: No <bind_material> found."
                 << std::endl;
        return;
    }

    domBind_material::domTechnique_commonRef  techCom      =
        bindMat->getTechnique_common();
    const domInstance_material_Array         &instMatArray =
        techCom->getInstance_material_array();

    for(UInt32 i = 0; i < instMatArray.getCount(); ++i)
    {
        ColladaInstanceMaterialRefPtr colInstMat =
            getUserDataAs<ColladaInstanceMaterial>(instMatArray[i]);

        if(colInstMat == NULL)
        {
            colInstMat = dynamic_pointer_cast<ColladaInstanceMaterial>(
                ColladaElementFactory::the()->create(
                    instMatArray[i], getGlobal()));

            colInstMat->read();
        }

        _matMap[colInstMat->getSymbol()] = colInstMat;

        OSG_COLLADA_LOG(("ColladaInstanceController::read: binding symbol [%s] "
                         "to target [%s]\n",
                         colInstMat->getSymbol().c_str(),
                         instMatArray[i]->getTarget().getURI()));
    }
}
ColladaEffect *
ColladaInstanceEffect::getTargetElem(void) const
{
    ColladaEffect *retVal     = NULL;
    domEffectRef   targetElem = getTargetDOMElem();

    if(targetElem != NULL)
    {
        retVal = getUserDataAs<ColladaEffect>(targetElem);
    }

    return retVal;
}
ColladaController *
ColladaInstanceController::getTargetElem(void) const
{
    ColladaController *retVal     = NULL;
    daeElementRef    targetElem = getTargetDOMElem();

    if(targetElem != NULL)
    {
        retVal = getUserDataAs<ColladaController>(targetElem);
    }

    return retVal;
}
Beispiel #6
0
ColladaMaterial *
ColladaInstanceMaterial::getTargetElem(void) const
{
    ColladaMaterial *retVal     = NULL;
    domMaterialRef   targetElem = getTargetDOMElem();

    if(targetElem != NULL)
    {
        retVal = getUserDataAs<ColladaMaterial>(targetElem);
    }

    return retVal;
}
Beispiel #7
0
ColladaNode *
ColladaInstanceNode::getTargetElem(void) const
{
    ColladaNode   *retVal     = NULL;
    daeElementRef  targetElem = getTargetDOMElem();

    if(targetElem != NULL)
    {
        retVal = getUserDataAs<ColladaNode>(targetElem);
    }

    return retVal;
}
ColladaGeometry *
ColladaInstanceGeometry::getTargetElem(void) const
{
    ColladaGeometry *retVal     = NULL;
    daeElementRef    targetElem = getTargetDOMElem();

    if(targetElem != NULL)
    {
        retVal = getUserDataAs<ColladaGeometry>(targetElem);
    }

    return retVal;
}
Beispiel #9
0
void
ColladaInstanceNode::read(void)
{
    OSG_COLLADA_LOG(("ColladaInstanceNode::read\n"));

    ColladaNodeRefPtr colNode = getTargetElem();

    if(colNode == NULL)
    {
        colNode = dynamic_pointer_cast<ColladaNode>(
            ColladaElementFactory::the()->create(
                getTargetDOMElem(), getGlobal()));

        colNode->read();
    }
}
void
ColladaInstanceEffect::read(ColladaElement *colElemParent)
{
    OSG_COLLADA_LOG(("ColladaInstanceEffect::read\n"));

    ColladaEffectRefPtr colEffect = getTargetElem();

    if(colEffect == NULL)
    {
        colEffect = dynamic_pointer_cast<ColladaEffect>(
            ColladaElementFactory::the()->create(
                getTargetDOMElem(), getGlobal()));

        colEffect->read(this);
    }

    domInstance_effectRef instEffect = getDOMElementAs<domInstance_effect>();

    const domInstance_effect::domTechnique_hint_Array &techHints =
        instEffect->getTechnique_hint_array();

    if(techHints.getCount() > 0)
    {
        SWARNING << "ColladaInstanceEffect::read: Ignoring ["
                 << techHints.getCount() << "] <technique_hint> elements."
                 << std::endl;
    }

    const domInstance_effect::domSetparam_Array &setParams =
        instEffect->getSetparam_array();

    if(setParams.getCount() > 0)
    {
        SWARNING << "ColladaInstanceEffect::read: Ignoring ["
                 << setParams.getCount() << "] <setparam> elements."
                 << std::endl;
    }
}
Beispiel #11
0
void
ColladaInstanceMaterial::read(void)
{
    OSG_COLLADA_LOG(("ColladaInstanceMaterial::read\n"));

    domInstance_materialRef instMat =
        getDOMElementAs<domInstance_material>();
    ColladaMaterialRefPtr   colMat  = getTargetElem();

    if(colMat == NULL)
    {
        colMat = dynamic_pointer_cast<ColladaMaterial>(
            ColladaElementFactory::the()->create(
                getTargetDOMElem(), getGlobal()));

        colMat->read();
    }

    if(instMat->getSymbol() != NULL)
    {
        _symbol = instMat->getSymbol();
    }
    else
    {
        SFATAL << "ColladaInstanceMaterial::read: No symbol."
               << std::endl;
    }

    _target = instMat->getTarget().str();

    const domInstance_material::domBind_Array &binds   =
        instMat->getBind_array();

    _bindStore.resize(binds.getCount());

    for(UInt32 i = 0; i < binds.getCount(); ++i)
    {
        std::string target   = binds[i]->getTarget();
        std::string semantic;

        if(binds[i]->getSemantic() != NULL)
        {
            semantic = binds[i]->getSemantic();
        }

        OSG_COLLADA_LOG(("ColladaInstanceMaterial::read: "
                         "<bind> semantic [%s] target [%s]\n",
                         semantic.c_str(), target.c_str()));

        _bindStore[i].semantic = semantic;
        _bindStore[i].target   = target;
    }

    const domInstance_material::domBind_vertex_input_Array &bindVerts =
        instMat->getBind_vertex_input_array();

    _bindVertexStore.resize(bindVerts.getCount());

    for(UInt32 i = 0; i < bindVerts.getCount(); ++i)
    {
        std::string semantic   = bindVerts[i]->getSemantic      ();
        std::string inSemantic = bindVerts[i]->getInput_semantic();
        UInt32      inSet      = bindVerts[i]->getInput_set     ();

        OSG_COLLADA_LOG(("ColladaInstanceMaterial::read "
                         "<bind_vertex_input> semantic [%s] "
                         "inSemantic [%s] inSet [%d]\n",
                         semantic.c_str(), inSemantic.c_str(), inSet));

        _bindVertexStore[i].semantic   = semantic;
        _bindVertexStore[i].inSemantic = inSemantic;
        _bindVertexStore[i].inSet      = inSet;
    }
}