virtual void apply(osg::Geode &n) {
unsigned int nDraws = n.getNumDrawables();
for (unsigned int idraw = 0 ; idraw < nDraws; ++idraw) {
osg::Geometry *geom = n.getDrawable( idraw )->asGeometry();
osg::Vec3Array *v = static_cast<osg::Vec3Array*>(geom->getVertexArray());
osg::Vec4Array *vc = static_cast<osg::Vec4Array*>(geom->getColorArray());
osg::Vec3Array *vn = static_cast<osg::Vec3Array*>(geom->getNormalArray());
osg::Vec2Array *vt = static_cast<osg::Vec2Array*>(geom->getTexCoordArray(0));
if (geom) {
unsigned int nPrims = geom->getNumPrimitiveSets();
for (unsigned int iprim = 0; iprim < nPrims; ++iprim) {
osg::PrimitiveSet *p = geom->getPrimitiveSet(iprim);
for (GLsizei i = 0; i < p->getNumIndices(); ++i) {
_s.vertexPositions.col(_idx) = toE(v->at(p->index(i)));
if (_opts & ConvertVertexColors)
_s.vertexColors.col(_idx) = toE(vc->at(p->index(i)));
if (_opts & ConvertVertexNormals)
_s.vertexNormals.col(_idx) = toE(vn->at(p->index(i))).normalized();
if (_opts & ConvertVertexUVs) {
_s.vertexUVs.col(_idx) = toE(vt->at(p->index(i)));
}
++_idx;
}
}
}
}
traverse(n);
}
void Tree::dropCurrentElement(Vertex *v)
{
sabassert(stackTop && isElement(stackTop));
sabassert(stackTop == v);
sabassert(!pendingTextNode);
stackTop = v -> parent;
delete v;
toE(stackTop) -> contents.deppend();
}
Element* Tree::findStylesheet(Daddy& d)
{
Vertex *w;
int dContentsNumber = d.contents.number();
for (int i = 0; i < dContentsNumber; i++)
{
if (isElement(w = d.contents[i]))
{
const QName& wName = toE(w) -> name;
Tree& owner = w -> getOwner();
Str localStr;
// if (!strcmp(wName.getUri(), theXSLTNamespace) && /* _PH_ */
if (wName.getUri() == owner.stdPhrase(PHRASE_XSL_NAMESPACE) &&
((localStr = owner.expand(wName.getLocal()) ==
xslOpNames[XSL_STYLESHEET]) ||
(localStr == xslOpNames[XSL_TRANSFORM])))
return toE(w);
}
};
return NULL;
}
eFlag Tree::processVertexAfterParse(Sit S, Vertex *v, TreeConstructer* tc)
{
//be careful with this test, it might be moved deeper inside this
//function if needed
if (v -> vt & VT_TOP_FOREIGN)
{
popVertex();
return OK;
}
XSL_OP theOp;
if (isXSLElement(v))
{
XSLElement *x = toX(v);
theOp = x -> op;
if (theOp != XSL_IMPORT) updateImportStatus();
switch(theOp)
{
//catch xsl:use-attribute-sets
case XSL_ELEMENT:
case XSL_COPY:
{
E( extractUsedSets(S, toE(v)) );
popVertex();
}; break;
case XSL_IMPORT:
{
if (subtrees.getCurrent() -> getStructure() -> getTopLevelFound())
{
Err2(S, E_ELEM_CONTAINS_ELEM,
xslOpNames[XSL_STYLESHEET],
xslOpNames[XSL_IMPORT]);
}
}; // no break
case XSL_INCLUDE:
{
Attribute *a = NZ( x -> atts.find(XSLA_HREF) );
GP( Tree ) srcTree;
const Str& base = S.findBaseURI(a -> getSubtreeInfo() ->
getBaseURI());
Str absolute;
makeAbsoluteURI(S, a -> cont, base, absolute);
if (S.getProcessor())
{
E( S.getProcessor() -> readTreeFromURI(S, srcTree,
a -> cont, base,
FALSE) );
srcTree.keep();
}
else
{
//Str absolute;
//makeAbsoluteURI(a -> cont, base, absolute);
srcTree = new Tree(absolute, FALSE);
DataLine d;
E( d.open(S, absolute, DLMODE_READ, /* argList = */ NULL) );
E( (*srcTree).parse(S, &d) );
E( d.close(S) );
}
Element *theSheet=(*srcTree).findStylesheet((*srcTree).getRoot());
if (!theSheet)
Warn1(S, W_NO_STYLESHEET, (char*)(a -> cont));
dropCurrentElement(v);
if (!theSheet) // to prevent segfault after include/import failure
break;
OutputterObj source;
//we start a subtree to record where the nodes come from
//when including, we use the old structure
//when importing, Tree creates a new one
E( startSubtree(S, (*srcTree).getURI(), theOp) );
//set extension namespaces for subtree
//(*srcTree).speakDebug();
//merge it into the current tree
E( tc -> parseUsingSAXForAWhile(S, source, absolute,
TRUE,
(Tree*)srcTree,
theSheet -> namespaces) );
//first we have to deal with ext. and excl. namespaces
Attribute *attr;
QName q;
//exclusions
q.setLocal((*srcTree).unexpand("exclude-result-prefixes"));
attr = theSheet->atts.find(q);
if (attr)
E(pushNamespacePrefixes(S, attr->cont, XSLA_EXCL_RES_PREFIXES));
//extensions
q.setLocal((*srcTree).unexpand("extension-element-prefixes"));
attr = theSheet->atts.find(q);
if (attr)
E(pushNamespacePrefixes(S, attr->cont, XSLA_EXT_ELEM_PREFIXES));
if (theSheet)
E( theSheet -> contents.copy(S, source) );
E( tc -> parseUsingSAXForAWhileDone(S, source, TRUE) );
// end the subtree
E( endSubtree(S, theOp) );
}; break;
case XSL_OUTPUT:
{
int i, attsNumber = x -> atts.number();
Attribute *theAtt;
for (i = 0; i < attsNumber; i++)
{
theAtt = toA(x -> atts[i]);
switch(theAtt -> op)
{
case XSLA_METHOD:
{
QName q;
EQName eq;
E( x -> setLogical(S,
q, theAtt -> cont, FALSE) );
expandQ(q, eq);
E( outputDef.setItemEQName(S, XSLA_METHOD,
eq, v,
v -> getImportPrecedence()) );
}; break;
case XSLA_CDATA_SECT_ELEMS:
{
QName q;
Bool someRemains;
Str listPart;
char *p = theAtt -> cont;
do
{
someRemains = getWhDelimString(p, listPart);
if (someRemains)
{
E( x -> setLogical(S,
q, listPart, TRUE) );
EQName expanded;
expandQ(q, expanded);
E( outputDef.setItemEQName(S,
XSLA_CDATA_SECT_ELEMS,
expanded, v,
v -> getImportPrecedence()) );
};
}
while (someRemains);
}; break;
case XSLA_NONE: //skip other namespaces
break;
default:
{
E( outputDef.setItemStr(S, theAtt -> op, theAtt -> cont,
theAtt,
theAtt -> getImportPrecedence()) );
};
};
}
popVertex();
}; break;
case XSL_NAMESPACE_ALIAS:
{
Phrase style, result, sUri, rUri;
Attribute *sp = NZ( x -> atts.find(XSLA_STYLESHEET_PREFIX) );
Attribute *rp = NZ( x -> atts.find(XSLA_RESULT_PREFIX) );
if (sp -> cont == "#default") style = UNDEF_PHRASE;
else dict().insert(sp -> cont, style);
if (rp -> cont == "#default") result = UNDEF_PHRASE;
else dict().insert(rp -> cont, result);
int i;
i = pendingNS().findNdx(style);
if (i != -1)
sUri = toNS(pendingNS().operator[](i)) -> uri;
else
Err1(S, E_EX_NAMESPACE_UNKNOWN, (char*) sp -> cont);
i = pendingNS().findNdx(result);
if (i != -1)
rUri = toNS(pendingNS().operator[](i)) -> uri;
else
Err1(S, E_EX_NAMESPACE_UNKNOWN, (char*) rp -> cont);
aliases().insertAlias(sUri, rUri, result,
v -> getImportPrecedence(), x);
popVertex();
}; break;
case XSL_TEMPLATE:
{
E( insertRule(S, x) );
popVertex();
}; break;
case XSL_ATTRIBUTE_SET:
{
QName name;
E( x -> setLogical(S, name,
NZ( x -> atts.find(XSLA_NAME)) -> cont,
FALSE) );
AttSet *ptr = attSets().insert(name);
E( extractUsedSets(S, toE(v)) );
if (x -> attSetNames(FALSE))
{
for (int i = 0; i < x -> attSetNames(FALSE) -> number(); i++)
ptr -> insertUses(*(x -> attSetNames(FALSE) -> operator[] (i)));
}
XSLElement *son;
for (int i = 0; i < x -> contents.number(); i++)
{
sabassert(isXSLElement(x -> contents[i]) &&
toX(x -> contents[i]) -> op == XSL_ATTRIBUTE);
son = toX(x -> contents[i]);
E( son -> setLogical(S, name,
NZ( son -> atts.find(XSLA_NAME)) -> cont,
FALSE) );
ptr -> insertAttributeDef(son, name);
}
popVertex();
}; break;
case XSL_STYLESHEET:
case XSL_TRANSFORM:
{
popVertex();
}; break;
case XSL_VARIABLE:
case XSL_PARAM:
{
// only look at top-levels
Vertex *par = v -> parent;
if (par && isXSLElement(par) &&
(toX(par) -> op == XSL_STYLESHEET ||
toX(par) -> op == XSL_TRANSFORM))
{
// is top-level -> insert into directory,
//with error if there already is an entry
// with the same import precedence
// find name first
QName name;
E( x -> setLogical(S, name,
NZ( x -> atts.find(XSLA_NAME)) -> cont,
FALSE) );
E( toplevelVars.insert(S, name, x) );
}
popVertex();
}; break;
case XSL_STRIP_SPACE:
{
SpaceNameList &foo =
subtrees.getCurrent() -> getStructure() -> strippedNames();
E( getSpaceNames(S, *x, NZ(x -> atts.find(XSLA_ELEMENTS)) -> cont,
foo) );
popVertex();
}; break;
case XSL_PRESERVE_SPACE:
{
SpaceNameList &foo =
subtrees.getCurrent() -> getStructure() -> preservedNames();
E( getSpaceNames(S, *x, NZ(x -> atts.find(XSLA_ELEMENTS)) -> cont,
foo) );
popVertex();
}; break;
default:
popVertex();
}
//the literal output element may have some xsl features
}
else
{ //isXSLElement
updateImportStatus();
if (XSLTree) {
E( extractUsedSets(S, toE(v)) );
popVertex();
}
else {
popVertex();
}
}
return OK;
}
