bool
sd::core::AttributeKey::addNewKey(const std::string& name) {
if(containsKey(name))
return false;
m_existingKeys.push_back(AttributeKey(name));
return true;
}
char*
XMLEntity::ToString(bool encoded, int level)
{
string text = "";
string indent = "";
string character_data = EscapeText(CharacterData());
for(int i=0; i<level; ++i) indent += "\t";
text = indent;
text += "<";
text += Name();
for(int i=0; i < CountAttributes(); ++i) {
text += " ";
text += AttributeKey(i);
text += "=";
text += "\"";
text += EscapeText(AttributeValue(i));
text += "\"";
}
if (character_data.size() == 0 && CountChildren() == 0) text += "/";
text += ">";
text += character_data;
if (CountChildren() > 0)
{
text += "\n";
for (int i=0; i < CountChildren(); ++i)
{
char *str = Child(i)->ToString(encoded, level + 1);
if (str)
{
text += str;
free(str);
}
}
text += indent;
}
if (CountChildren() > 0 || character_data.size() > 0)
{
text += "</";
text += Name();
text += ">";
}
text += "\n";
return strdup(text.c_str());
}
void Context::addAttributes( std::map<text::attributes::AttributeKey,text::attributes::AttributeValue> & attributes, const Alternative::BindingMap & bindings ) const {
for ( Alternative::BindingMap::const_iterator it = bindings.begin(), e = bindings.end(); it != e; ++ it ) {
Expression::ValueListPtr v = it->second->evaluate( 0, Variable(), *this );
AttributeKey key = it->first;
AttributeValue value = v->empty() ? AttributeValue::UNDEFINED : v->back();
if ( key == AttributeKey::UNDEFINED ) {
for ( uint attr = 0; attr < AttributeKey::count(); ++ attr ) {
AttributeKey k = AttributeKey( attr );
AttributeValue v = value.getContainer().getAttribute( k );
if ( v != AttributeValue::UNDEFINED )
attributes.insert( std::make_pair( k, v ) );
}
} else {
attributes.insert( std::make_pair( key, value ) );
}
}
}
//-----------------------------------------------------------------------------
// Name : BuildAttributeTable ()
// Desc : Build a list of combined textures / materials etc. in addition to a
// per-surface attribute ID.
//-----------------------------------------------------------------------------
bool iwfMesh::BuildAttributeTable()
{
unsigned __int16 AttributeCapacity = 0;
Attribute ** ppTempAttributes = NULL, *pAttribute = NULL, TestAttribute;
AttributeKey * pLookupRoot = NULL, *pAttributeKey = NULL;
// Release previous attribute details if already built
if ( Attributes != NULL )
{
for ( unsigned __int16 i = 0; i < AttributeCount; ++i )
{
if ( Attributes[i].TexIndices )
delete []Attributes[i].TexIndices;
if ( Attributes[i].MatIndices )
delete []Attributes[i].MatIndices;
if ( Attributes[i].ShaderIndices )
delete []Attributes[i].ShaderIndices;
if ( Attributes[i].SamplerIndices )
delete []Attributes[i].SamplerIndices;
if ( Attributes[i].BlendModes )
delete []Attributes[i].BlendModes;
} // Next Attribute
delete []Attributes;
} // End if attributes
if ( AttributeTable != NULL )
delete []AttributeTable;
// Reset variables
Attributes = NULL;
AttributeTable = NULL;
AttributeCount = 0;
// If there are no surfaces, just return here.
if ( SurfacePool.SurfaceCount == 0 )
return true;
// Allocate enough space in the attribute table for all surfaces
AttributeTable = new unsigned __int16[ SurfacePool.SurfaceCount ];
// Iterate through each surface in the mesh
for ( unsigned int i = 0; i < SurfacePool.SurfaceCount; ++i )
{
iwfSurfacePool::Surface * pSurface = &SurfacePool.Surfaces[i];
// Collect attribute details for this surface
TestAttribute.ChannelCount = pSurface->ChannelCount;
TestAttribute.RenderEffect = ( pSurface->Components & IWF_SCOMPONENT_EFFECT ) ? pSurface->RenderEffect : -1;
// Temporarily "borrow" the pointers from the surface (saves allocation)
TestAttribute.TexIndices = pSurface->TexIndices;
TestAttribute.MatIndices = pSurface->MatIndices;
TestAttribute.ShaderIndices = pSurface->ShaderIndices;
TestAttribute.SamplerIndices = pSurface->SamplerIndices;
TestAttribute.BlendModes = pSurface->BlendModes;
// Has relevant styles?
TestAttribute.AlphaBlended = false;
TestAttribute.AlphaTested = false;
if ( pSurface->Components & IWF_SCOMPONENT_STYLE )
{
if ( pSurface->Style & IWF_SURFACE_ALPHA_BLENDED )
TestAttribute.AlphaBlended = true;
else if ( pSurface->Style & IWF_SURFACE_ALPHA_TESTED )
TestAttribute.AlphaTested = true;
} // End if styles set
// Check to see if blend modes were specified. If they were
// activate the alpha blended flag if they're anything other
// than the default.
if ( TestAttribute.BlendModes )
{
// Any that are other than the default?
for ( unsigned int j = 0; j < TestAttribute.ChannelCount; ++j )
{
if ( TestAttribute.BlendModes[j].SrcBlendMode != 0x2 /* BLEND_ONE */ ||
TestAttribute.BlendModes[j].DestBlendMode != 0x1 /* BLEND_ZERO */ )
{
// Enable alpha blending for this attribute as a whole.
TestAttribute.AlphaBlended = true;
break;
} // End if !ONE->ZERO
} // Next channel
} // End if has blend modes
// Does this exist in the lookup table?
pAttribute = NULL;
pAttributeKey = NULL;
if ( pLookupRoot != NULL )
pAttributeKey = pLookupRoot->find( &AttributeKey( &TestAttribute ) );
// No attribute found, create a new one
if ( pAttributeKey == NULL )
{
// Allocate a new attribute
pAttribute = new Attribute();
pAttribute->RenderEffect = TestAttribute.RenderEffect;
pAttribute->ChannelCount = TestAttribute.ChannelCount;
pAttribute->AlphaBlended = TestAttribute.AlphaBlended;
pAttribute->AlphaTested = TestAttribute.AlphaTested;
if ( pSurface->TexIndices != NULL )
{
pAttribute->TexIndices = new __int16[ pSurface->ChannelCount ];
memcpy( pAttribute->TexIndices, pSurface->TexIndices, pSurface->ChannelCount * 2 );
} // End if textures specified
if ( pSurface->MatIndices != NULL )
{
pAttribute->MatIndices = new __int16[ pSurface->ChannelCount ];
memcpy( pAttribute->MatIndices, pSurface->MatIndices, pSurface->ChannelCount * 2 );
} // End if materials specified
if ( pSurface->ShaderIndices != NULL )
{
pAttribute->ShaderIndices = new __int16[ pSurface->ChannelCount ];
memcpy( pAttribute->ShaderIndices, pSurface->ShaderIndices, pSurface->ChannelCount * 2 );
} // End if shaders specified
if ( pSurface->SamplerIndices != NULL )
{
pAttribute->SamplerIndices = new __int16[ pSurface->ChannelCount ];
memcpy( pAttribute->SamplerIndices, pSurface->SamplerIndices, pSurface->ChannelCount * 2 );
} // End if samplers specified
if ( pSurface->BlendModes != NULL )
{
pAttribute->BlendModes = new iwfBlendMode[ pSurface->ChannelCount ];
memcpy( pAttribute->BlendModes, pSurface->BlendModes, pSurface->ChannelCount * sizeof(iwfBlendMode) );
} // End if blend modes specified
// Insert into the attribute lookup table
pAttributeKey = new AttributeKey( pAttribute, AttributeCount );
if ( pLookupRoot == NULL )
pLookupRoot = pAttributeKey;
else
pLookupRoot->insert( pAttributeKey );
// Insert into the temporary attribute pointer table
if ( AttributeCount + 1 > AttributeCapacity )
{
Attribute ** pBuffer = new Attribute*[AttributeCapacity+50];
if ( ppTempAttributes != NULL )
{
memcpy( pBuffer, ppTempAttributes, AttributeCount * sizeof(Attribute*) );
delete []ppTempAttributes;
} // End if old data
ppTempAttributes = pBuffer;
AttributeCapacity += 50;
} // End if grow buffer
ppTempAttributes[AttributeCount++] = pAttribute;
} // End if not already inserted
// Store the attribute ID for this surface
AttributeTable[i] = pAttributeKey->nIndex;
} // Next Surface
// Build the final combined attribute table
if ( AttributeCount > 0 )
{
Attributes = new Attribute[ AttributeCount ];
for ( unsigned __int16 i = 0; i < AttributeCount; ++i )
Attributes[i] = *ppTempAttributes[i];
} // End if any attributes
// Clean up
if ( ppTempAttributes != NULL )
delete []ppTempAttributes;
if ( pLookupRoot != NULL )
delete pLookupRoot;
// Success!
return true;
}
