void FieldContainer::dumpFieldInfo(void) const
{
const TypeObject &oType = this->getType();
fprintf(stderr, "Dump Container (%s) Field Info\n",
oType.getCName());
for(UInt32 i = 1; i <= oType.getNumFieldDescs(); ++i)
{
FieldDescriptionBase *pDesc = oType.getFieldDesc(i);
if(pDesc != NULL)
{
UInt32 uiTmp = (_bvChanged & pDesc->getFieldMask()) != 0x0000;
UInt32 uiTmp1 = 0x0000;
fprintf(stderr, WS30" ch : %x\r",
uiTmp);
uiTmp = (pDesc->getFlags() & Field::FClusterLocal) != 0x0000;
uiTmp1 = (_pFieldFlags->_bClusterLocalFlags &
pDesc ->getFieldMask() ) == 0x0000;
fprintf(stderr, WS30" cl : %x | %x\r",
uiTmp,
uiTmp1);
uiTmp = (pDesc->getFlags() & Field::FThreadLocal) != 0x0000;
uiTmp1 = (_pFieldFlags->_bThreadLocalFlags &
pDesc ->getFieldMask() ) == 0x0000;
fprintf(stderr, WS30" tl : %x | %x\r",
uiTmp,
uiTmp1);
fprintf(stderr, "(%d) : %s :\r",
i,
pDesc->getCName());
fprintf(stderr, "\n");
#if 0
fprintf(stderr, "0x%016"PRIx64" 0x%016"PRIx64"\n",
_pFieldFlags->_bClusterLocalFlags,
pDesc ->getFieldMask());
#endif
}
else
{
fprintf(stderr, "(%d) : NULL\n", i);
}
}
}
Int32 OSGLoader::mapExtIntFieldType(const Char8 *szFieldname,
const Int32 iFieldTypeId)
{
Int32 returnValue = Inherited::mapExtIntFieldType(szFieldname,
iFieldTypeId);
if(returnValue < 0 && szFieldname != NULL && _pCurrentFC != NULL)
{
FieldDescriptionBase *pFieldDesc =
_pCurrentFC->getFieldDescription(szFieldname);
if(pFieldDesc != NULL)
{
const FieldType &oFieldType = pFieldDesc->getFieldType();
PINFO << "FieldTypeId invalid, trying to fix. " << std::endl;
PINFO << oFieldType.getContentType().getCName()
<< " comparing with "
<< FieldTraits<FieldContainer *>::getType().getCName()
<< std::endl;
if(oFieldType.getContentType().isDerivedFrom(
FieldTraits<FieldContainer *>::getType()) == true)
{
PINFO << "FieldContainer * or derived class, "
<< "parsing as Node"
<< std::endl;
if(oFieldType.getCardinality() == FieldType::SingleField)
{
returnValue = ScanParseSkel::OSGsfNode;
}
else
{
returnValue = ScanParseSkel::OSGmfNode;
}
}
}
}
return returnValue;
}
void FieldContainerType::unmarkFieldsClusterLocal(const BitVector bvFieldMasks)
{
if(_pPrototype != NULL)
{
BitVector bCurrent = 0x0002;
for(UInt32 i = 1; i <= this->getNumFieldDescs(); ++i)
{
FieldDescriptionBase *pDesc = this->getFieldDesc(i);
if(0x0000 != (bCurrent & bvFieldMasks) && pDesc != NULL)
{
pDesc->setFlags(pDesc->getFlags() & ~Field::FClusterLocal);
_pPrototype->_pFieldFlags->_bClusterLocalFlags |=
pDesc->getFieldMask();
}
bCurrent <<= 1;
}
}
}
UInt32 OSGLoader::getFieldType(const Char8 *szFieldname)
{
UInt32 returnValue = 0;
FieldDescriptionBase *pFieldDesc = NULL;
if(szFieldname == NULL)
return returnValue;
if(_pCurrentFC != NULL)
{
pFieldDesc = _pCurrentFC->getFieldDescription(szFieldname);
PINFO << "GF : " << szFieldname << " " << pFieldDesc << std::endl;
if(pFieldDesc != NULL)
{
returnValue = pFieldDesc->getFieldType().getScanTypeId();
}
}
return returnValue;
}
/* one or more fields failed to be exposed to Python. */
bool PyFieldAccessHandler::exposeAllFieldsToPython()
{
for(UInt32 idx = 1; idx <= _pPythonScript->getType().getNumFieldDescs(); ++idx)
{
FieldDescriptionBase *desc = _pPythonScript->getType().getFieldDesc(idx);
assert(desc);
#ifdef OSGPY_DEBUG_CODEGENERATION
std::string tmp = (desc->isDynamic()) ? "dynamic. Analyzing..." : "static. Skip...";
std::cout << "Processing field '" << desc->getName() << "' | "
<< tmp << std::endl;
#endif
if(desc->isDynamic() == true)
{
if(exposeFieldToPython(desc->getName(), desc->getFieldId()) == true)
{
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << "Successfully exposed field '" << desc->getName()
<< "'" << std::endl << std::endl;
#endif
}
else
{
std::cerr << "Error exposing field " << desc->getName()
<< std::endl;
_pPyInterpreter->activate();
_pPyInterpreter->dumpError();
_pPyInterpreter->clearError();
_pPyInterpreter->deactivate();
std::cerr << "The field will not be accessible in Python!"
<< std::endl << std::endl;
}
}
}
return true;
}
/*!
Tries to write the image object to the given output stream.
Returns true on success.
*/
bool EXRImageFileType::write(const Image *image,
std::ostream &os,
const std::string &mimetype)
{
#ifdef OSG_WITH_IMF
if (!os.good())
return false;
if(image->getDataType() != Image::OSG_FLOAT16_IMAGEDATA)
{
FWARNING(("EXRImageFileType::write: Image has non float data type!\n"));
return false;
}
if(image->getComponents() != 4)
{
FWARNING(("EXRImageFileType::write: Image has != 4 components!\n"));
return false;
}
if (image->getSideCount() == 6)
{
FWARNING(("EXRImageFileType::write: NYI for cubemaps\n")); //TODO
return false;
}
try
{
Int32 width = image->getWidth();
Int32 height = image->getHeight();
const char *dummy = "";
StdOStream file(os, dummy);
Imf::Header header(width, height);
#if 0
// now add custom attributes
ImageGenericAtt *att = dynamic_cast<ImageGenericAtt *>(
image->findAttachment(
ImageGenericAtt::getClassType().getGroupId()));
if(att != NULL)
{
FieldContainerType &fcType = att->getType();
Int32 count = att->getType().getNumFieldDescs();
for(Int32 i = 1; i <= count; ++i)
{
FieldDescriptionBase *fDesc = fcType.getFieldDesc(i);
Field *field = att->getField(i);
if(fDesc != NULL && field != NULL)
{
SFString *strField = dynamic_cast<SFString*>(field);
if(strField != NULL)
{
Imf::StringAttribute imfAttr(
strField->getValue().c_str());
header.insert(fDesc->getCName(), imfAttr);
}
}
}
}
#endif
// we write each side as 4 channels out
// side 0 RGBA
// side 1 R1G1B1A1
// ...
for(Int32 side=0;side<image->getSideCount();++side)
{
char cn[20];
sprintf(cn, "%d", side);
char name[20];
sprintf(name, "R%s", side == 0 ? "" : cn);
header.channels().insert(name, Imf::Channel(Imf::HALF));
sprintf(name, "G%s", side == 0 ? "" : cn);
header.channels().insert(name, Imf::Channel(Imf::HALF));
sprintf(name, "B%s", side == 0 ? "" : cn);
header.channels().insert(name, Imf::Channel(Imf::HALF));
sprintf(name, "A%s", side == 0 ? "" : cn);
header.channels().insert(name, Imf::Channel(Imf::HALF));
}
Imf::OutputFile stream(file, header);
Imf::FrameBuffer frame_buffer;
// we need to do a vertical flip so we write single scan lines out.
for(int i=height-1;i>=0;--i)
{
for(Int32 side=0;side<image->getSideCount();++side)
{
const char *data = (reinterpret_cast<const char *>(image->getData(0, 0, side))) + i * (sizeof(Real16) * 4 * width);
// writePixels() adds the current scan line index as an offset to the
// base address we need to eliminate this!
data -= stream.currentScanLine() * (sizeof(Real16) * 4 * width);
char cn[20];
sprintf(cn, "%d", side);
char name[20];
sprintf(name, "R%s", side == 0 ? "" : cn);
frame_buffer.insert(name, Imf::Slice(Imf::HALF,
const_cast<char *>(data), sizeof(Real16) * 4, sizeof(Real16) * 4 * width));
sprintf(name, "G%s", side == 0 ? "" : cn);
frame_buffer.insert(name, Imf::Slice(Imf::HALF,
const_cast<char *>(data) + 1 * sizeof(Real16), sizeof(Real16) * 4, sizeof(Real16) * 4 * width));
sprintf(name, "B%s", side == 0 ? "" : cn);
frame_buffer.insert(name, Imf::Slice(Imf::HALF,
const_cast<char *>(data) + 2 * sizeof(Real16), sizeof(Real16) * 4, sizeof(Real16) * 4 * width));
sprintf(name, "A%s", side == 0 ? "" : cn);
frame_buffer.insert(name, Imf::Slice(Imf::HALF,
const_cast<char *>(data) + 3 * sizeof(Real16), sizeof(Real16) * 4, sizeof(Real16) * 4 * width));
}
stream.setFrameBuffer(frame_buffer);
stream.writePixels(1);
}
return true;
}
catch(std::exception &e)
{
FFATAL(( "Error while trying to write OpenEXR Image from stream: %s\n",
e.what() ));
return false;
}
#else
SWARNING << getMimeType()
<< " write is not compiled into the current binary "
<< std::endl;
return false;
#endif
}
/*-------------------------------------------------------------------------*\
- private -
\*-------------------------------------------------------------------------*/
void GenericFieldContainerEditor::updateFieldsPanel(FieldContainer* fc)
{
_FieldsContainer->clearChildren();
UInt32 NumFields(fc->getType().getNumFieldDescs());
FieldDescriptionBase* Desc;
FieldEditorComponentUnrecPtr TheEditor;
LabelUnrecPtr TheLabel;
ComponentRecPtr TheToolTip;
GridBagLayoutConstraintsRefPtr LayoutConstraints;
PanelRefPtr FieldPanel;
UInt32 NumRows(0),NumRowsForField(1);
BorderLayoutRefPtr TheBorderLayout = BorderLayout::create();
BorderLayoutConstraintsRefPtr WestConstraint = BorderLayoutConstraints::create();
WestConstraint->setRegion(BorderLayoutConstraints::BORDER_WEST);
BorderLayoutConstraintsRefPtr CenterConstraint = BorderLayoutConstraints::create();
CenterConstraint->setRegion(BorderLayoutConstraints::BORDER_CENTER);
//Backgrounds
ColorLayerRefPtr HeaderBgLayer = ColorLayer::create();
HeaderBgLayer->setColor(Color4f(0.7f,0.7f,0.7f,1.0f));
ColorLayerRefPtr LightBgLayer = ColorLayer::create();
LightBgLayer->setColor(Color4f(0.9f,0.9f,0.9f,1.0f));
ColorLayerRefPtr DarkBgLayer = ColorLayer::create();
DarkBgLayer->setColor(Color4f(0.8f,0.8f,0.8f,1.0f));
LayoutConstraints = GridBagLayoutConstraints::create();
LayoutConstraints->setGridX(0);
LayoutConstraints->setGridY(NumRows);
LayoutConstraints->setGridHeight(1);
LayoutConstraints->setGridWidth(2);
LayoutConstraints->setFill(GridBagLayoutConstraints::FILL_BOTH);
LabelRecPtr FieldsLabel = Label::create();
FieldsLabel->setAlignment(Vec2f(0.5f,0.5f));
FieldsLabel->setText("Fields");
FieldsLabel->setBackgrounds(HeaderBgLayer);
FieldsLabel->setConstraints(LayoutConstraints);
FieldsLabel->setFont(_BoldFont);
_FieldsContainer->pushToChildren(FieldsLabel);
++NumRows;
if(_GenericNameAttachmentEditor->isTypeEditable(fc->getType()))
{
//Create the Label
TheLabel = Label::create();
TheLabel->setText("Name");
TheLabel->setBackgrounds(NULL);
TheLabel->setConstraints(WestConstraint);
TheLabel->setPreferredSize(Vec2f(160.0f,22.0f));
//Attach the Generic Name Editor
_GenericNameAttachmentEditor->setCommandManager(_CmdManager);
_GenericNameAttachmentEditor->attachContainer(fc);
_GenericNameAttachmentEditor->setConstraints(CenterConstraint);
//Create the Panel
LayoutConstraints = GridBagLayoutConstraints::create();
LayoutConstraints->setGridX(0);
LayoutConstraints->setGridY(NumRows);
LayoutConstraints->setGridHeight(1);
LayoutConstraints->setGridWidth(1);
LayoutConstraints->setFill(GridBagLayoutConstraints::FILL_BOTH);
FieldPanel = Panel::createEmpty();
FieldPanel->setInset(Vec4f(1.0f,1.0f,1.0f,1.0f));
FieldPanel->pushToChildren(TheLabel);
FieldPanel->pushToChildren(_GenericNameAttachmentEditor);
FieldPanel->setLayout(TheBorderLayout);
FieldPanel->setConstraints(LayoutConstraints);
FieldPanel->setBackgrounds(LightBgLayer);
_FieldsContainer->pushToChildren(FieldPanel);
++NumRows;
}
UInt32 UsedFieldCount(0);
for(UInt32 i(1) ; i<=NumFields ; ++i)
{
Desc = fc->getFieldDescription(i);
if(Desc != NULL &&
!Desc->isInternal() &&
Desc->getFieldType().getClass() != FieldType::ParentPtrField &&
//HACK: Stop the pixel field from being editable on Images
!(fc->getType().isDerivedFrom(Image::getClassType()) &&
Desc->getFieldId() == Image::PixelFieldId))
{
//Create the Editor
TheEditor = FieldEditorFactory::the()->createDefaultEditor(fc, Desc->getFieldId(), _CmdManager);
if(TheEditor != NULL)
{
NumRowsForField = TheEditor->getNumRequestedRows();
pushToEditors(TheEditor);
TheEditor->setConstraints(CenterConstraint);
//Create the Label
TheLabel = Label::create();
TheLabel->setText(Desc->getCName());
TheLabel->setBackgrounds(NULL);
TheLabel->setConstraints(WestConstraint);
TheLabel->setPreferredSize(Vec2f(160.0f,22.0f));
TheToolTip = createFieldToolTip(Desc);
TheLabel->setToolTip(TheToolTip);
//Create the Panel
LayoutConstraints = GridBagLayoutConstraints::create();
LayoutConstraints->setGridX(0);
LayoutConstraints->setGridY(NumRows);
LayoutConstraints->setGridHeight(NumRowsForField);
LayoutConstraints->setGridWidth(1);
LayoutConstraints->setFill(GridBagLayoutConstraints::FILL_BOTH);
FieldPanel = Panel::createEmpty();
FieldPanel->setInset(Vec4f(1.0f,1.0f,1.0f,1.0f));
FieldPanel->pushToChildren(TheLabel);
FieldPanel->pushToChildren(TheEditor);
FieldPanel->setLayout(TheBorderLayout);
FieldPanel->setConstraints(LayoutConstraints);
if((UsedFieldCount%2) == 0)
{
FieldPanel->setBackgrounds(DarkBgLayer);
}
else
{
FieldPanel->setBackgrounds(LightBgLayer);
}
_FieldsContainer->pushToChildren(FieldPanel);
NumRows += NumRowsForField;
TheEditor->setPreferredSize(Vec2f(50.0f,22.0f * NumRowsForField));
++UsedFieldCount;
}
}
}
//Set the number of rows for the grid layout
dynamic_cast<GridBagLayout*>(_FieldsContainer->getLayout())->setRows(NumRows);
_FieldsContainer->setPreferredSize(Vec2f(400.0f, NumRows*24.0f));
}
void
OSBGeometryElement::postReadV100(void)
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100\n"));
OSBRootElement *root = editRoot();
Geometry *geo =
dynamic_cast<Geometry*>(getContainer());
UInt32 indexMappingSize = UInt32(_indexMapping.size());
if(indexMappingSize <= 1)
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting single index.\n" ));
if(_indicesPacked)
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting packed indices.\n" ));
geo->setIndices(_indices);
}
else
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting non-packed indices.\n" ));
// indices stored in container with id _indicesId
// create PtrFieldInfo structure to set all entries of field
// "propIndices" to the container with id _indicesId
FieldDescriptionBase *indFieldDesc =
geo->getFieldDescription("propIndices");
UInt32 indFieldId = indFieldDesc->getFieldId();
root->editPtrFieldList().push_back(PtrFieldInfo(geo, indFieldId));
PtrFieldInfo &indFieldPFI = root->editPtrFieldList().back();
for(UInt32 i = 0; i < Geometry::MaxAttribs; ++i)
{
indFieldPFI.editIdStore().push_back(_indicesId);
}
}
}
else
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting multi index.\n" ));
OSBGeometryHelper gh;
if(_indicesPacked)
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting packed indices.\n" ));
// create 16 bit or 32 bit indices
if(_indices16Bit)
{
GeoUInt16Property *ui16Indices =
dynamic_pointer_cast<GeoUInt16Property>(_indices);
gh.splitMultiIndex<GeoUInt16Property *>(
_indexMapping, ui16Indices, geo);
}
else
{
GeoUInt32Property *ui32Indices =
dynamic_pointer_cast<GeoUInt32Property>(_indices);
gh.splitMultiIndex<GeoUInt32Property *>(
_indexMapping, ui32Indices, geo);
}
}
else
{
OSG_OSB_LOG(("OSBGeometryElement::postReadV100: "
"Converting non-packed indices.\n" ));
FieldContainerIdMapConstIt mapIt =
root->getIdMap().find(_indicesId);
if(mapIt != root->getIdMap().end())
{
_indices = dynamic_cast<GeoIntegralProperty *>(
FieldContainerFactory::the()->getContainer(mapIt->second));
}
else
{
FWARNING(("OSBGeometryElement::postReadV100: "
"Could not find indices property.\n"));
return;
}
if(_indices->getFormatSize() == sizeof(UInt16))
{
GeoUInt16Property *ui16Indices =
dynamic_pointer_cast<GeoUInt16Property>(_indices);
gh.splitMultiIndex<GeoUInt16Property *>(
_indexMapping, ui16Indices, geo);
}
else if(_indices->getFormatSize() == sizeof(UInt32))
{
GeoUInt32Property *ui32Indices =
dynamic_pointer_cast<GeoUInt32Property>(_indices);
gh.splitMultiIndex<GeoUInt32Property *>(
_indexMapping, ui32Indices, geo);
}
}
}
}
void
OSBGeometryElement::readV100(void)
{
OSG_OSB_LOG(("OSBGeometryElement::readV100:\n"));
OSBRootElement *root = editRoot();
BinaryReadHandler *rh = editRoot()->getReadHandler();
OSBGeometryHelper gh;
GeometryUnrecPtr geo = Geometry::create();
setContainer(geo);
// The "properties" mfield can be thought of the unification of the
// "positions", "normals", etc sfields of the 1.x Geometry.
// For the conversion the PtrFieldInfo structure for the "properties"
// mfield is filled with the corresponding ids of the sfields from the
// file. The remapping after postRead will fill in the right pointers.
FieldDescriptionBase *propFieldDesc =
geo->getFieldDescription("properties");
UInt32 propFieldId = propFieldDesc->getFieldId();
root->editPtrFieldList().push_back(PtrFieldInfo(geo, propFieldId));
PtrFieldInfo &propFieldPFI = root->editPtrFieldList().back();
propFieldPFI.editIdStore().resize(Geometry::MaxAttribs);
while(true)
{
std::string fieldName;
std::string fieldTypeName;
UInt32 fieldSize;
PtrFieldListIt ptrFieldIt;
if(!readFieldHeader("", fieldName, fieldTypeName, fieldSize))
{
OSG_OSB_LOG(("OSBGeometryElement::readV100: "
"Reading stopped at field: [%s].\n", fieldName.c_str()));
break;
}
if(fieldName == "indexMapping")
{
// read into temporary field
MField<UInt16> indexMappingField;
indexMappingField.copyFromBin(*rh);
// copy to member for use in postRead
indexMappingField.getValues().swap(_indexMapping);
}
else if(fieldName == "indices")
{
// read container id of indices property
// postRead will handle the conversion of multi indices
rh->getValue(_indicesId);
}
else if(fieldName == "positions")
{
UInt32 positionsId;
rh->getValue(positionsId);
propFieldPFI.editIdStore()[Geometry::PositionsIndex] = positionsId;
}
else if(fieldName == "normals")
{
UInt32 normalsId;
rh->getValue(normalsId);
propFieldPFI.editIdStore()[Geometry::NormalsIndex] = normalsId;
}
else if(fieldName == "colors")
{
UInt32 colorsId;
rh->getValue(colorsId);
propFieldPFI.editIdStore()[Geometry::ColorsIndex] = colorsId;
}
else if(fieldName == "secondaryColors")
{
UInt32 secondaryColorsId;
rh->getValue(secondaryColorsId);
propFieldPFI.editIdStore()[Geometry::SecondaryColorsIndex] =
secondaryColorsId;
}
else if(fieldName == "texCoords")
{
UInt32 texCoordsId;
rh->getValue(texCoordsId);
propFieldPFI.editIdStore()[Geometry::TexCoordsIndex] =
texCoordsId;
}
else if(fieldName == "texCoords1")
{
UInt32 texCoordsId1;
rh->getValue(texCoordsId1);
propFieldPFI.editIdStore()[Geometry::TexCoords1Index] =
texCoordsId1;
}
else if(fieldName == "texCoords2")
{
UInt32 texCoordsId2;
rh->getValue(texCoordsId2);
propFieldPFI.editIdStore()[Geometry::TexCoords2Index] =
texCoordsId2;
}
else if(fieldName == "texCoords3")
{
UInt32 texCoordsId3;
rh->getValue(texCoordsId3);
propFieldPFI.editIdStore()[Geometry::TexCoords3Index] =
texCoordsId3;
}
else if(fieldName == "texCoords4")
{
UInt32 texCoordsId4;
rh->getValue(texCoordsId4);
propFieldPFI.editIdStore()[Geometry::TexCoords4Index] =
texCoordsId4;
}
else if(fieldName == "texCoords5")
{
UInt32 texCoordsId5;
rh->getValue(texCoordsId5);
propFieldPFI.editIdStore()[Geometry::TexCoords5Index] =
texCoordsId5;
}
else if(fieldName == "texCoords6")
{
UInt32 texCoordsId6;
rh->getValue(texCoordsId6);
propFieldPFI.editIdStore()[Geometry::TexCoords6Index] =
texCoordsId6;
}
else if(fieldName == "texCoords7")
{
UInt32 texCoordsId7;
rh->getValue(texCoordsId7);
propFieldPFI.editIdStore()[Geometry::TexCoords7Index] =
texCoordsId7;
}
else if(fieldName == "pindices")
{
UInt32 maxValue;
UInt32 propSize;
UInt32 byteSize;
_indicesPacked = true;
gh.readPackedIntegralPropertyHeader(rh, maxValue,
propSize, byteSize);
if(root->getOptions().unpack16BitIndices())
{
if(maxValue > TypeTraits<UInt16>::getMax())
{
GeoUInt32PropertyUnrecPtr ui32Indices =
GeoUInt32Property::create();
gh.readPackedIntegralProperty(rh, ui32Indices, maxValue,
propSize, byteSize );
_indices16Bit = false;
_indices = ui32Indices;
}
else
{
GeoUInt16PropertyUnrecPtr ui16Indices =
GeoUInt16Property::create();
gh.readPackedIntegralProperty(rh, ui16Indices, maxValue,
propSize, byteSize );
_indices16Bit = true;
_indices = ui16Indices;
}
}
else
{
GeoUInt32PropertyUnrecPtr ui32Indices =
GeoUInt32Property::create();
gh.readPackedIntegralProperty(rh, ui32Indices, maxValue,
propSize, byteSize );
_indices16Bit = false;
_indices = ui32Indices;
}
}
else if(fieldName == "qpositions")
{
// Quantized positions are stored inside the geometry object, not
// in the geo-property. They are always of type Pnt3f.
GeoPnt3fPropertyUnrecPtr propPos = GeoPnt3fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(rh, resolution, minValue,
maxValue, propSize );
gh.readQuantizedVectorProperty(rh, propPos, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propPos, Geometry::PositionsIndex);
}
else if(fieldName == "qnormals")
{
// Quantized normals are stored inside the geometry object, not
// in the geo-property. They are always of type Vec3f.
GeoVec3fPropertyUnrecPtr propNorm = GeoVec3fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(
rh, resolution, minValue, maxValue, propSize);
gh.readQuantizedVectorProperty(
rh, propNorm, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propNorm, Geometry::NormalsIndex);
}
else if(fieldName == "qtexCoords")
{
// Quantized texCoords are stored inside the geometry object, not
// in the geo-property. They are always of type Vec2f.
GeoVec2fPropertyUnrecPtr propTexCoords = GeoVec2fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(
rh, resolution, minValue, maxValue, propSize);
gh.readQuantizedVectorProperty(
rh, propTexCoords, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propTexCoords, Geometry::NormalsIndex);
}
else
{
// 1.x Geometry has _sfVbo, it can be skipped
readFieldContent(fieldName, fieldTypeName, fieldSize,
"'vbo'", ptrFieldIt );
}
}
}
void FieldAnimation::changed(ConstFieldMaskArg whichField,
UInt32 origin,
BitVector details)
{
Inherited::changed(whichField, origin, details);
//Do not respond to changes that have a Sync origin
if(origin & ChangedOrigin::Sync)
{
return;
}
if(whichField & FieldNameFieldMask)
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldName().c_str());
if( f == NULL )
{
SWARNING << "Could not find Field "<< getFieldName() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return;
}
else
{
setFieldId(f->getFieldId());
//commitChanges();
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
return;
}
}
else if((whichField & FieldIdFieldMask) ||
(whichField & ContainerFieldMask))
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldId());
if( f == NULL )
{
SWARNING << "Could not find Field ID"<< getFieldId() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return;
}
else
{
if(getAnimator()->getDataType() == NULL)
{
SWARNING << "Cannot update animation, because the animator attached to this animation does not work on any data types." << std::endl;
return;
}
//Check if it's the right type
if(getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType()
!= *getAnimator()->getDataType())
{
SWARNING << "The data type of the field: "
<< getContainer()->getFieldDescription(getFieldId())->getName()
<< " with type: "
<< getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType().getCName()
<< " connected to this animation is not the same data type: "
<< getAnimator()->getDataType()->getCName()
<< ", that the animator works on." << std::endl;
return;
}
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
return;
}
}
if(whichField & IndexFieldMask)
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldId());
if( f == NULL )
{
SWARNING << "Could not find Field ID"<< getFieldId() << " in Field Container " << getContainer()->getTypeName() << std::endl;
}
else
{
//Check if animator supports any types
if(getAnimator()->getDataType() == NULL)
{
SWARNING << "Cannot update animation, because the animator attached to this animation does not work on any data types." << std::endl;
}
//Check if it's the right type
if(getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType()
!= *getAnimator()->getDataType())
{
SWARNING << "The data type of the field: "
<< getContainer()->getFieldDescription(getFieldId())->getName()
<< " with type: "
<< getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType().getCName()
<< " connected to this animation is not the same data type: "
<< getAnimator()->getDataType()->getCName()
<< ", that the animator works on." << std::endl;
}
GetFieldHandlePtr TheFieldHandle = getContainer()->getField( getFieldId() );
if( getIndex() > 0 )
{
if(TheFieldHandle->getCardinality() != FieldType::MultiField)
{
SWARNING << "Cannot attach to index: " << getIndex()
<< " of field " << getContainer()->getFieldDescription(getFieldId())->getName()
<< " because it has cardinality 1." << std::endl;
}
else if(getIndex() < TheFieldHandle->size())
{
SWARNING << "Cannot attach to index: " << getIndex()
<< " of field " << getContainer()->getFieldDescription(getFieldId())->getName()
<< " because that index is out of bounds on a field of size " << TheFieldHandle->size() << "." << std::endl;
}
}
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
}
}
}
Action::ResultE
bindEnterDefault(NodeCore *core, Action *action)
{
AnimBindAction *bindAct = dynamic_cast<AnimBindAction *>(action);
Animation *anim = bindAct->getAnim ();
const AnimTemplate *animTmpl = bindAct->getTemplate();
AnimTargetAttachment *targetAtt = getTargetAtt(core);
FDEBUG(("bindEnterDefault: core [%p] targetAtt [%p]\n",
core, targetAtt));
if(targetAtt == NULL)
return Action::Continue;
Int32 srcIdx = 0;
while((srcIdx = animTmpl->findTargetId(targetAtt->getTargetId(),
srcIdx )) != -1)
{
std::string targetId;
std::string subTargetId;
bindAct->splitTargetId(
animTmpl->getTargetIds(srcIdx), targetId, subTargetId);
FDEBUG(("bindEnterDefault: targetId [%s] subTargetId [%s]\n",
targetId.c_str(), subTargetId.c_str()));
// create the channel
AnimDataSource *src = animTmpl->getSources (srcIdx);
AnimChannelUnrecPtr channel = src ->createChannel( );
anim->editMFChannels()->push_back(channel);
FieldDescriptionBase *fDesc =
core->getType().getFieldDesc(subTargetId.c_str());
if(fDesc == NULL)
{
SWARNING << "bindEnterDefault: no field for subTargetId ["
<< subTargetId << "] found." << std::endl;
continue;
}
// create the blender
UInt32 fId = fDesc->getFieldId();
if(targetAtt->getMFBlenders()->size() <= fId)
targetAtt->editMFBlenders()->resize(fId + 1, NULL);
AnimBlenderUnrecPtr blender = targetAtt->getBlenders(fId);
if(blender == NULL)
{
blender = src->createBlender();
(*targetAtt->editMFBlenders())[fId] = blender;
}
// connect
blender->addChannel(channel );
blender->connectTo (core, fDesc->getName());
++srcIdx;
}
return Action::Continue;
}
Action::ResultE
AnimBindAction::bindFields(AttachmentContainer *attCon)
{
AnimTargetAttachment *targetAtt = getTargetAtt(attCon);
if(targetAtt == NULL)
return Action::Continue;
Animation *anim = getAnim();
DataSourceMapIt dsIt = _dsMap.begin();
DataSourceMapIt dsEnd = _dsMap.end ();
while(dsIt != dsEnd)
{
if(dsIt->first.find(targetAtt->getTargetId()) != 0)
{
++dsIt;
continue;
}
std::string targetId;
std::string subTargetId;
splitTargetId(dsIt->first, targetId, subTargetId);
if(targetId != targetAtt->getTargetId())
{
++dsIt;
continue;
}
SINFO << "AnimBindAction::bindFields: binding source '"
<< dsIt->first << "' to '" << targetId << "' - '"
<< subTargetId << "'" << std::endl;
FieldDescriptionBase *fDesc =
attCon->getType().getFieldDesc(subTargetId.c_str());
if(fDesc == NULL)
{
SWARNING << "AnimBindAction::bindFields: no Field for "
<< "subTargetId [" << subTargetId << "] found."
<< std::endl;
++dsIt;
continue;
}
// create channel
AnimChannelUnrecPtr channel = dsIt->second->createChannel();
anim->editMFChannels()->push_back(channel);
// create blender
UInt32 fId = fDesc->getFieldId();
if(targetAtt->getMFBlenders()->size() <= fId)
targetAtt->editMFBlenders()->resize(fId + 1, NULL);
AnimBlenderUnrecPtr blender = targetAtt->getBlenders(fId);
if(blender == NULL)
{
blender = dsIt->second->createBlender();
targetAtt->editMFBlenders()->replace(fId, blender);
}
// on create all fields are marked as changed - this causes
// the blender to write to its destination even though
// it has no valid input data - avoid it by committing before
// connecting the blender to its dest
commitChanges();
blender->addChannel(channel );
blender->connectTo (attCon, fDesc->getName());
// remove bound data source from map
DataSourceMapIt eraseIt = dsIt;
++dsIt;
_dsMap.erase(eraseIt);
}
if(_dsMap.empty() == true)
{
return Action::Quit;
}
else
{
return Action::Continue;
}
}
/*! Reads the contents of a field from the stream. It is intended to be used
in conjunction with readFieldHeader and uses the information obtained
by it (\a fieldName, \a fieldTypeName, \a fieldSize ).
If a field is not to be read, but skipped instead, its name can be passed
in the \a excludeFields argument. The string has the format:
"'name1' 'name2' 'name3'", the spaces between the "'" are mandatory.
\param[in] fieldName Name of the field.
\param[in] fieldTypeName Type of the field.
\param[in] fieldSize Size in bytes of the field.
\param[in] excludeFields
\param[out] ptrFieldIt Iterator that points to the PtrFieldInfo structure
that was created, if this is a "pointer field" - only valid if true is
returned.
\return True, if the field is a "pointer field", i.e. a field holding
pointers to other FieldContainers, false otherwise.
*/
bool
OSBCommonElement::readFieldContent(
const std::string &fieldName,
const std::string &fieldTypeName,
const UInt32 fieldSize,
const std::string &excludeFields,
PtrFieldListIt &ptrFieldIt )
{
OSG_OSB_LOG(("OSBCommonElement::readFieldContent: [%s] [%s] [%u]\n",
fieldName.c_str(), fieldTypeName.c_str(), fieldSize));
BinaryReadHandler *rh = editRoot()->getReadHandler();
bool isPtrField = false;
FieldDescriptionBase *fieldDesc =
getContainer()->getFieldDescription(fieldName.c_str());
if((!excludeFields.empty() ) &&
(excludeFields.find("'" + fieldName + "'") != std::string::npos) )
{
OSG_OSB_LOG(("OSBCommonElement::readFieldContent: "
"Skipping excluded field [%s] [%s]\n",
fieldName.c_str(), fieldTypeName.c_str()));
rh->skip(fieldSize);
return false;
}
if(fieldDesc == 0)
{
DynFieldContainerInterface *pIf =
dynamic_cast<DynFieldContainerInterface *>(getContainer());
if(pIf != NULL)
{
pIf->addField(fieldTypeName.c_str(), fieldName.c_str());
fieldDesc = getContainer()->getFieldDescription(fieldName.c_str());
}
}
if(fieldDesc == 0)
{
FWARNING(("OSBCommonElement::readFieldContent: "
"Skipping unknown field [%s] [%s].\n",
fieldName.c_str(), fieldTypeName.c_str()));
rh->skip(fieldSize);
return false;
}
const FieldType &fieldType = fieldDesc->getFieldType();
UInt32 fieldId = fieldDesc->getFieldId ();
BitVector fieldMask = fieldDesc->getFieldMask();
if(fieldType.getContentType().isDerivedFrom(
FieldTraits<FieldContainer *>::getMapType()) == true)
{
ptrFieldIt = readAttachmentMapField(fieldId, fieldSize);
isPtrField = true;
}
else if(fieldType.getContentType().isDerivedFrom(
FieldTraits<FieldContainer *>::getType()) == true)
{
if(fieldType.getClass() == FieldType::ParentPtrField)
{
rh->skip(fieldSize);
isPtrField = false;
}
else
{
if(fieldType.getCardinality() == FieldType::SingleField)
{
ptrFieldIt = readPtrSingleField(fieldId);
isPtrField = true;
}
else if(fieldType.getCardinality() == FieldType::MultiField)
{
ptrFieldIt = readPtrMultiField(fieldId, fieldSize);
isPtrField = true;
}
}
}
else
{
getContainer()->copyFromBin(*rh, fieldMask);
isPtrField = false;
}
return isPtrField;
}
bool FieldContainerType::setPrototype(FieldContainer *pPrototype)
{
bool returnValue = false;
if(this->isAbstract() == false)
{
if(pPrototype != NULL)
{
TypePredicates::IsBaseOf baseTypePred(pPrototype->getType());
if(baseTypePred(this) == true)
{
pPrototype->addReferenceUnrecorded();
_pPrototype->subReferenceUnrecorded();
_pPrototype = pPrototype;
BitVector bCurrent = 0x0002;
for(UInt32 i = 1; i <= this->getNumFieldDescs(); ++i)
{
FieldDescriptionBase *pDesc = this->getFieldDesc(i);
if(pDesc == NULL)
continue;
if(0x0000 == (bCurrent &
_pPrototype->_pFieldFlags->_bThreadLocalFlags))
{
pDesc->setFlags(pDesc->getFlags() |
Field::FThreadLocal);
}
else
{
pDesc->setFlags(pDesc->getFlags() &
~Field::FThreadLocal);
}
if(0x0000 == (bCurrent &
_pPrototype->_pFieldFlags->_bClusterLocalFlags))
{
pDesc->setFlags(pDesc->getFlags() |
Field::FClusterLocal);
}
else
{
pDesc->setFlags(pDesc->getFlags() &
~Field::FClusterLocal);
}
bCurrent <<= 1;
}
returnValue = true;
}
else
{
FWARNING(("can not set unrelated container of type %s "
"as prototype for type %s\n",
pPrototype->getType().getCName(),
this->getCName()));
}
}
else
{
FWARNING(("can not delete prototype of a concrete object\n"));
}
}
else
{
FWARNING(("can not set prototype of an abstract object\n"));
}
return returnValue;
}
/*\return true if no Python error was set, false otherwise */
bool PyFieldAccessHandler::generateCorePythonCode(const std::string& fieldName,
bool& getAccess,
bool& editAccess,
bool& setAccess)
{
FieldDescriptionBase *desc =
_pPythonScript->getType().getFieldDesc(fieldName.c_str());
FieldType::Class classType = desc->getFieldType().getClass();
std::string fieldTypeName(desc->getFieldType().getName());
std::string valueTypeName(fieldTypeName);
removeFieldQualifier (valueTypeName);
removeRefCountQualifier(valueTypeName);
std::string setAccessMethod ("unsupported");
std::string editAccessMethod("unsupported");
std::string getAccessMethod ("unsupported");
switch(classType)
{
case FieldType::ValueField:
{
if(desc->isSField())
{
setAccessMethod = "setValueSField_" + valueTypeName;
getAccessMethod = "getValueSField_" + valueTypeName;
// The following types cannot be changed using the
// editAccessMethod, as Python does not provide access via a
// reference for them. They have to be set with the
// setAccessMethod.
if(valueTypeName != "Bool" &&
valueTypeName != "Int32" &&
valueTypeName != "Int64" &&
valueTypeName != "UInt32" &&
valueTypeName != "UInt64" &&
valueTypeName != "Real32" &&
valueTypeName != "Real64" &&
valueTypeName != "Time" &&
valueTypeName != "String" )
{
editAccessMethod = "changeValueSField_" + valueTypeName;
}
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " VALUE single-field" << std::endl;
#endif
}
else
{
setAccessMethod = "setValueMField_" + valueTypeName;
editAccessMethod = "changeValueMField_" + valueTypeName;
getAccessMethod = "getValueMField_" + valueTypeName;
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " VALUE multi-field" << std::endl;
#endif
}
}
break;
case FieldType::PtrField:
{
if(desc->isSField())
{
setAccessMethod = "setPtrSField";
editAccessMethod = "changePtrSField";
getAccessMethod = "getPtrSField";
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " pointer single-field" << std::endl;
#endif
}
else
{
setAccessMethod = "unsupported";
editAccessMethod = "changePointerMField";
getAccessMethod = "getPointerMField";
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " pointer multi-field" << std::endl;
#endif
}
}
break;
default:
{
std::string tmp("unknown");
if(classType == FieldType::ChildPtrField)
{
tmp = "ChildPtrField";
}
else if (classType == FieldType::ParentPtrField)
{
tmp = "ParentPtrField";
}
if(desc->isSField())
{
std::cerr << " UNSUPPORTED single-field type: " << tmp << std::endl;
}
else
{
std::cerr << " UNSUPPORTED multi-field type: " << tmp << std::endl;
}
assert(false);
}
}
std::string pyCode;
if(setAccessMethod != "unsupported")
{
setAccess = true;
const std::string setMethod = "def _set_" + fieldName + "(self, value):\n"
" _fieldAccessHandler." + setAccessMethod + "('" + fieldName + "', value)\n";
pyCode += setMethod;
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " 'set' support: yes" << std::endl;
#endif
}
#ifdef OSGPY_DEBUG_CODEGENERATION
else
{
std::cout << " 'set' support: no" << std::endl;
}
#endif
if(editAccessMethod != "unsupported")
{
editAccess = true;
const std::string editMethod = "def _edit_" + fieldName + "(self):\n"
" return _fieldAccessHandler." + editAccessMethod + "('" + fieldName + "')\n";
pyCode += editMethod;
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " 'edit' support: yes" << std::endl;
#endif
}
#ifdef OSGPY_DEBUG_CODEGENERATION
else
{
std::cout << " 'edit' support: no" << std::endl;
}
#endif
if(getAccessMethod != "unsupported")
{
getAccess = true;
const std::string getMethod = "def _get_" + fieldName + "(self):\n"
" return _fieldAccessHandler." + getAccessMethod + "('" + fieldName + "')\n";
pyCode += getMethod;
#ifdef OSGPY_DEBUG_CODEGENERATION
std::cout << " 'get' support: yes" << std::endl;
#endif
}
#ifdef OSGPY_DEBUG_CODEGENERATION
else
{
std::cout << " 'get' support: no" << std::endl;
}
std::cout << std::endl << "Generated Python glue code:" << std::endl;
std::cout << pyCode << std::endl;
#endif
return(_pPyInterpreter->run(pyCode));
}
void FieldAnimation::changed(ConstFieldMaskArg whichField,
UInt32 origin,
BitVector details)
{
Inherited::changed(whichField, origin, details);
if(whichField & FieldNameFieldMask)
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldName().c_str());
if( f == NULL )
{
SWARNING << "Could not find Field "<< getFieldName() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return;
}
else
{
setFieldId(f->getFieldId());
commitChanges();
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
return;
}
}
else if((whichField & FieldIdFieldMask) ||
(whichField & ContainerFieldMask))
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldId());
if( f == NULL )
{
SWARNING << "Could not find Field ID"<< getFieldId() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return;
}
else
{
//Check if it's the right type
if(getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType() != getAnimator()->getDataType())
{
SWARNING << "The data type of the field: " << getContainer()->getFieldDescription(getFieldId())->getName() << " with type: " << getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType().getCName() << " connected to this animation is not the same data type: " << getAnimator()->getDataType().getCName() << ", that the animator works on." << std::endl;
return;
}
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
return;
}
}
if(whichField & IndexFieldMask)
{
if(getContainer() != NULL)
{
FieldDescriptionBase * f = getContainer()->getFieldDescription(getFieldId());
if( f == NULL )
{
SWARNING << "Could not find Field ID"<< getFieldId() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return;
}
else
{
//Check if it's the right type
if(getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType() != getAnimator()->getDataType())
{
SWARNING << "The data type of the field: " << getContainer()->getFieldDescription(getFieldId())->getName() << " with type: " << getContainer()->getFieldDescription(getFieldId())->getFieldType().getContentType().getCName() << " connected to this animation is not the same data type: " << getAnimator()->getDataType().getCName() << ", that the animator works on." << std::endl;
return;
}
const Field* TheField = getContainer()->getField( getFieldId() )->getField();
if( getIndex() >= 0 &&
TheField->getCardinality() != FieldType::MultiField &&
getIndex() < TheField->getSize())
{
SWARNING << "If the Index for the field animation is > 0 then the animated field must be a multi field and the index must be less than the size of this field." << getAnimator()->getDataType().getCName() << "." << std::endl;
return;
}
else if( getIndex() < 0 &&
TheField->getCardinality() != FieldType::SingleField)
{
SWARNING << "If the Index for the field animation is < 0 then the animated field must be a single field." << getAnimator()->getDataType().getCName() << std::endl;
}
}
}
else
{
SWARNING << "There is no Field Container defined to Animate" << std::endl;
return;
}
}
}