--- Doctrine_before/Table.php   2010-07-29 17:18:08.681913517 +0200
+++ Doctrine_after/Table.php    2010-07-29 17:43:25.933158157 +0200
@@ -1160,7 +1160,7 @@
             return $this->_columnNames[$fieldName];
         }
 
-        return strtolower($fieldName);
+        return $fieldName;
     }
 
     /**
@@ -1187,8 +1187,10 @@
      */
     public function getFieldName($columnName)
     {
-        if (isset($this->_fieldNames[$columnName])) {
-            return $this->_fieldNames[$columnName];
+        foreach($this->_fieldNames as $k=>$v){
+            if(strtolower($k)==strtolower($columnName)){
+                return $v;
+            }
         }
         return $columnName;
     }
@@ -1309,10 +1311,9 @@
                 $fieldName = $parts[0];
             }
 
-            $name = strtolower($parts[0]);
+            $name = $parts[0];
         } else {
             $fieldName = $name;
-            $name = strtolower($name);
         }
 
         $name = trim($name);

La clave es getFieldName que acepte $columName en mayúsculas y en minúsculas porque a veces se pasa de una forma y a veces de otra.

// primero llamar al constructor
$('div').pluginName({name:'other_value'});
// luego llamar al método desde donde sea
$('div').pluginName('publicSubfunction','arg1_value');

El código del plugin sería:

(function($) {
 
var ver = '0.1';
 
function debug(s) {
  if ($.fn.pluginName.debug)
    log(s);
}
 
function log() {
  if(window.console && window.console.log)
    window.console.log('[image_list] ' + Array.prototype.join.call(arguments,' '));
};
 
$.fn.pluginName = function(options){
  if(typeof options == 'string'){
    return $.fn.pluginName[options].apply(this,Array.splice(arguments,1));
  }
  options = $.extend({}, $.fn.pluginName.defaults, $(this).data('pluginName'), options);
  $(this).data('image_list',options);
  return this;
};
 
$.fn.pluginName.defaults = {
  name: 'value'
};
 
var getOptions = function(options){
  return $.extend({}, $(this).data('pluginName'));
};
 
var privateFunction = function(){
};
 
$.fn.pluginName.publicSubfunction = function(arg1){
  var options = getOptions.call(this);
};
 
})(jQuery);

Investigando, he llegado a la conclusión de que el problema está en que el validador crea un objecto sfValidatedFile, pero al estar el formulario embedido, este objecto no se guarda correctamente. La solución es tan fácil como añadir el siguiente código a la clase de formulario base.

abstract class BaseFormDoctrine extends sfFormDoctrine
{
  protected function doProcessValuesUpdateObject($values)
  {
    $values = $this->processValues($values);
    foreach($this->embeddedForms as $k=>$form){
      if($form instanceof sfFormObject && isset($values[$k])){
        $values[$k] = $form->doProcessValuesUpdateObject($values[$k]);
      }
    }
    $this->doUpdateObject($values);
    return $values;
  }
 
  public function updateObject($values = null)
  {
    if (null === $values){
      $values = $this->values;
    }
    $this->doProcessValuesUpdateObject($values);
    return $this->getObject();
  }
 
}

Y nada más de momento. Espero que la próxima versión 2.0 de Symfony corrija éste y otros errores en el código, porque por lo demás el framework me encanta.

#include "DotSceneAttributes.h"

DotSceneAttributes::DotSceneAttributes(const String &n, const CEGUI::XMLAttributes &attribs)
{
    mName = n;
    mAttribs = attribs;
    children.clear();
    parent = 0;
}

DotSceneAttributes::~DotSceneAttributes()
{
    children.clear();
}

const String DotSceneAttributes::getName()
{
    return mName;
}

bool DotSceneAttributes::hasAttribute(const String &attribName)
{
    return mAttribs.exists(attribName);
}

const String DotSceneAttributes::getString(const String &attribName, const String &defaultValue)
{
    try{
        if(mAttribs.exists(attribName))
            return mAttribs.getValue(attribName).c_str();
    }catch(...)
    {
    }
    return defaultValue;
}

Real DotSceneAttributes::getReal(const String &attribName, Real defaultValue)
{
    try{
        if(mAttribs.exists(attribName))
            return StringConverter::parseReal(mAttribs.getValue(attribName).c_str());
    }catch(...)
    {
    }
    return defaultValue;
}

bool DotSceneAttributes::getBool(const String &attribName, bool defaultValue)
{
    try{
        if(mAttribs.exists(attribName))
            return mAttribs.getValueAsBool(attribName);
    }catch(...)
    {
    }
    return defaultValue;
}

Vector3 DotSceneAttributes::getVector3()
{
	return Vector3(
		StringConverter::parseReal(getString("x","0")),
		StringConverter::parseReal(getString("y","0")),
		StringConverter::parseReal(getString("z","0"))
	);
}

Quaternion DotSceneAttributes::getQuaternion()
{
	Quaternion orientation;

	if(hasAttribute("qx"))
	{
		orientation.x = StringConverter::parseReal(getString("qx","0"));
		orientation.y = StringConverter::parseReal(getString("qy","0"));
		orientation.z = StringConverter::parseReal(getString("qz","0"));
		orientation.w = StringConverter::parseReal(getString("qw","0"));
	}
	else if(hasAttribute("axisX"))
	{
		Vector3 axis;
		axis.x = StringConverter::parseReal(getString("axisX","0"));
		axis.y = StringConverter::parseReal(getString("axisY","0"));
		axis.z = StringConverter::parseReal(getString("axisZ","0"));
		Real angle = StringConverter::parseReal(getString("angle","0"));;
		orientation.FromAngleAxis(Angle(angle), axis);
	}
	else if(hasAttribute("angleX"))
	{
		Vector3 axis;
		axis.x = StringConverter::parseReal(getString("angleX","0"));
		axis.y = StringConverter::parseReal(getString("angleY","0"));
		axis.z = StringConverter::parseReal(getString("angleZ","0"));
		orientation.FromAxes(&axis);
	}

	return orientation;
}

ColourValue DotSceneAttributes::getColour()
{
	return ColourValue(
		StringConverter::parseReal(getString("r","0")),
		StringConverter::parseReal(getString("g","0")),
		StringConverter::parseReal(getString("b","0")),
		StringConverter::parseReal(getString("a","1"))
	);
}

DotSceneAttributes* DotSceneAttributes::addChild(DotSceneAttributes* child)
{
    child->setParent(this);
    children.push_back(*child);
    return child;
}

DotSceneAttributes* DotSceneAttributes::addChild(const String &n, const CEGUI::XMLAttributes &attribs)
{
    DotSceneAttributes *child = new DotSceneAttributes(n,attribs);
    return addChild(child);
}

void DotSceneAttributes::setParent(DotSceneAttributes* p)
{
    parent = p;
}

DotSceneAttributes* DotSceneAttributes::getParent()
{
    return parent;
}

DotSceneAttributes* DotSceneAttributes::getImmediateChild(const String &name)
{
    itChildren    = children.begin();
    itChildrenEnd = children.end();
    for(; itChildren != itChildrenEnd; ++itChildren ) {
	    if( itChildren->getName() == name ) {
			return &(*itChildren);
		}
    }
}

bool DotSceneAttributes::hasImmediateChild(const String &name)
{
    itChildren    = children.begin();
    itChildrenEnd = children.end();
    for(; itChildren != itChildrenEnd; ++itChildren ) {
	    if( itChildren->getName() == name ) {
			return true;
		}
    }
    return false;
}

DotSceneAttributes* DotSceneAttributes::getChild(const String &name)
{
    itChildren    = children.begin();
    itChildrenEnd = children.end();
    for(; itChildren != itChildrenEnd; ++itChildren ) {
	    if( itChildren->getName() == name ) {
			return &(*itChildren);
		}else if(itChildren->hasChild(name)){
            itChildren->getChild(name);
        }
    }
}

bool DotSceneAttributes::hasChild(const String &name)
{
    itChildren    = children.begin();
    itChildrenEnd = children.end();
    for(; itChildren != itChildrenEnd; ++itChildren ) {
	    if( itChildren->getName() == name ) {
			return true;
		}else if(itChildren->hasChild(name)){
			return true;
        }
    }
    return false;
}

Como el parser llama a dos callbacks, uno cuando empieza el elemento y uno cuando acaba, pasando como parámetro un objecto CEGUI::XMLAttributes que contiene los atributos del elemento XML. Así que primero he creado una clase adicional para encapsular XMLAttributes de todos los hijos del elemento, ya que hay varios elementos que necesitan acceder a valores de los hijos.

#include "DotSceneLoader.h"

const char DotSceneLoader::s_sSceneTagName[]               = "scene";
const char DotSceneLoader::s_sNodesTagName[]               = "nodes";
const char DotSceneLoader::s_sNodeTagName[]                = "node";
const char DotSceneLoader::s_sExternalsTagName[]           = "externals";
const char DotSceneLoader::s_sEnvironmentTagName[]         = "environment";
const char DotSceneLoader::s_sTerrainTagName[]             = "terrain";
const char DotSceneLoader::s_sOctreeTagName[]              = "octree";
const char DotSceneLoader::s_sLightTagName[]               = "light";
const char DotSceneLoader::s_sCameraTagName[]              = "camera";
const char DotSceneLoader::s_sEntityTagName[]              = "entity";
const char DotSceneLoader::s_sVertexBufferTagName[]        = "vertexbuffer";
const char DotSceneLoader::s_sIndexBufferTagName[]         = "indexbuffer";
const char DotSceneLoader::s_sParticleSystemTagName[]      = "particlesystem";
const char DotSceneLoader::s_sBillboardSetTagName[]        = "billboardset";
const char DotSceneLoader::s_sPlaneTagName[]               = "plane";
const char DotSceneLoader::s_sSkyPlaneTagName[]            = "skyplane";
const char DotSceneLoader::s_sLookTargetTagName[]          = "looktarget";
const char DotSceneLoader::s_sTrackTargetTagName[]         = "tracktarget";
const char DotSceneLoader::s_sFogTagName[]                 = "fog";
const char DotSceneLoader::s_sSkyBoxTagName[]              = "skybox";
const char DotSceneLoader::s_sSkyDomeTagName[]             = "skydome";
const char DotSceneLoader::s_sUserDataReferenceTagName[]   = "userdatareference";

const char DotSceneLoader::s_sLightTypePoint[]         = "point";
const char DotSceneLoader::s_sLightTypeDirectional[]   = "directional";
const char DotSceneLoader::s_sLightTypeSpot[]          = "spot";
const char DotSceneLoader::s_sLightTypeRadPoint[]      = "radpoint";

const char DotSceneLoader::s_sCameraProjectionPerspective[] = "perspective";
const char DotSceneLoader::s_sCameraProjectionOrtographic[] = "ortographic";

const char DotSceneLoader::s_sTargetRelativeToLocal[] = "local";
const char DotSceneLoader::s_sTargetRelativeToParent[] = "parent";
const char DotSceneLoader::s_sTargetRelativeToWorld[] = "world";

const char DotSceneLoader::s_sFogModeNone[] = "none";
const char DotSceneLoader::s_sFogModeExp[] = "exp";
const char DotSceneLoader::s_sFogModeExp2[] = "exp2";
const char DotSceneLoader::s_sFogModeLinear[] = "linear";

DotSceneLoader::DotSceneLoader(SceneManager *yourSceneMgr, SceneNode *pAttachNode, const String &sPrependNode)
{
	mSceneMgr = yourSceneMgr;
	m_sPrependNode = sPrependNode;
    pParentNode = pAttachNode;
    mAttributes = 0;
}

DotSceneLoader::~DotSceneLoader() {
    if(mAttributes){
        delete mAttributes;
    }
}

void DotSceneLoader::parseDotScene(const String &sceneName, const String &groupName)
{
    m_sGroupName = groupName;
	// set up shared object values
    try{
        CEGUI::System::getSingleton().getXMLParser()->parseXMLFile(*this, sceneName.c_str(), "", groupName);
	} catch(...) {
		//We'll just log, and continue on gracefully
		LogManager::getSingleton().logMessage("[DotSceneLoader] Error creating XmlDocument");
		return;
	}
}

void DotSceneLoader::elementStart(const CEGUI::String& name, const CEGUI::XMLAttributes& XMLattribs)
{
    DotSceneAttributes *attribs = new DotSceneAttributes(String(name.c_str()), XMLattribs);
    if(mAttributes){
        mAttributes->addChild(attribs);
    }
    mAttributes = attribs;

    if(name == s_sSceneTagName){
        processScene(mAttributes);
    }else if(name == s_sNodeTagName){
        processNode(mAttributes);
    }
}

void DotSceneLoader::elementEnd(const CEGUI::String& name)
{
    if(name == s_sNodesTagName){
        finishNodes(mAttributes);
    }else if(name == s_sNodeTagName){
        finishNode(mAttributes);
    }else if(name == s_sExternalsTagName){
        finishExternals(mAttributes);
    }else if(name == s_sEnvironmentTagName){
        finishEnvironment(mAttributes);
    }else if(name == s_sTerrainTagName){
        finishTerrain(mAttributes);
    }else if(name == s_sOctreeTagName){
        finishOctree(mAttributes);
    }else if(name == s_sLightTagName){
        finishLight(mAttributes);
    }else if(name == s_sCameraTagName){
        finishCamera(mAttributes);
    }else if(name == s_sEntityTagName){
        finishEntity(mAttributes);
    }else if(name == s_sVertexBufferTagName){
        finishVertexBuffer(mAttributes);
    }else if(name == s_sIndexBufferTagName){
        finishIndexBuffer(mAttributes);
    }else if(name == s_sParticleSystemTagName){
        finishParticleSystem(mAttributes);
    }else if(name == s_sBillboardSetTagName){
        finishBillboardSet(mAttributes);
    }else if(name == s_sPlaneTagName){
        finishPlane(mAttributes);
    }else if(name == s_sSkyPlaneTagName){
        finishSkyPlane(mAttributes);
    }else if(name == s_sLookTargetTagName){
        finishLookTarget(mAttributes);
    }else if(name == s_sTrackTargetTagName){
        finishTrackTarget(mAttributes);
    }else if(name == s_sFogTagName){
        finishFog(mAttributes);
    }else if(name == s_sSkyBoxTagName){
        finishSkyBox(mAttributes);
    }else if(name == s_sSkyDomeTagName){
        finishSkyDome(mAttributes);
    }
    // add user data
    for ( unsigned int i = 0 ; i < mAttributes->children.size(); i++ ){
        if ( mAttributes->children[i].getName() == s_sUserDataReferenceTagName){
            pParentNode->setUserAny(Any(mAttributes->children[i].getString("id","")));
        }
    }
    if(mAttributes->getParent()){
        mAttributes = mAttributes->getParent();
    }
}

void DotSceneLoader::text(const String& text)
{
}

void DotSceneLoader::processScene(DotSceneAttributes *attribs)
{
	// Process the scene parameters
	String version = attribs->getString("formatVersion", "unknown");

	String message = "[DotSceneLoader] Parsing dotScene file with version " + version;
	if(attribs->hasAttribute("ID"))
		message += ", id " + String(attribs->getString("ID",""));
	if(attribs->hasAttribute("sceneManager"))
		message += ", scene manager " + String(attribs->getString("sceneManager",""));
	if(attribs->hasAttribute("minOgreVersion"))
		message += ", min. Ogre version " + String(attribs->getString("minOgreVersion",""));
	if(attribs->hasAttribute("author"))
		message += ", author " + String(attribs->getString("author",""));

	LogManager::getSingleton().logMessage(message);
}

void DotSceneLoader::finishNodes(DotSceneAttributes *attribs)
{
}

void DotSceneLoader::processNode(DotSceneAttributes *attribs)
{
	// Construct the node's name
	String name = m_sPrependNode + attribs->getString("name","");

	String id = attribs->getString("id","");
	bool isTarget = attribs->getBool("isTarget",false);

	// Create the scene node
	SceneNode *pNode;
    if(pParentNode){
        if(attribs->hasAttribute("name")) {
            // Let Ogre choose the name
            pNode = pParentNode->createChildSceneNode();
        }else{
            // Provide the name
            pNode = pParentNode->createChildSceneNode(name);
        }
        pParentNode = pNode;
    }
}

void DotSceneLoader::finishNode(DotSceneAttributes *attribs)
{
	//finish other attributes
    if(pParentNode){
        if(attribs->hasImmediateChild("position")){
            pParentNode->setPosition(attribs->getImmediateChild("position")->getVector3());
        }
        if(attribs->hasImmediateChild("rotation")){
            Quaternion orientation = attribs->getImmediateChild("rotation")->getQuaternion();
            if(orientation != Quaternion::ZERO){
                pParentNode->setOrientation(orientation);
            }
        }
        if(attribs->hasImmediateChild("scale")){
            pParentNode->setScale(attribs->getImmediateChild("scale")->getVector3());
        }
        pParentNode->setInitialState();
        pParentNode = pParentNode->getParentSceneNode();
    }
}

void DotSceneLoader::finishExternals(DotSceneAttributes *attribs)
{
}

void DotSceneLoader::finishEnvironment(DotSceneAttributes *attribs)
{
    mSceneMgr->setAmbientLight(attribs->getImmediateChild("colourAmbient")->getColour());
	//! @todo Set the background colour of all viewports (RenderWindow has to be provided then)
	//mViewport->setBackgroundColour(attribs->getImmediateChild("colourBackground"))->getColour();

}

void DotSceneLoader::finishTerrain(DotSceneAttributes *attribs)
{
	//! @todo Implement this
}

void DotSceneLoader::finishOctree(DotSceneAttributes *attribs)
{
	//! @todo Implement this
}

void DotSceneLoader::finishLight(DotSceneAttributes *attribs)
{
	//finish attributes
	String name = attribs->getString("name","");
	String id = attribs->getString("id","");

	// Create the light
	Light *pLight = mSceneMgr->createLight(name);
	if(pParentNode)
		pParentNode->attachObject(pLight);

	String sValue = attribs->getString("type","");
	if(sValue == s_sLightTypePoint)
		pLight->setType(Light::LT_POINT);
	else if(sValue == s_sLightTypeDirectional)
		pLight->setType(Light::LT_DIRECTIONAL);
	else if(sValue == s_sLightTypeSpot)
		pLight->setType(Light::LT_SPOTLIGHT);
	else if(sValue == s_sLightTypeRadPoint)
		pLight->setType(Light::LT_POINT);

	pLight->setVisible(attribs->getBool("visible", true));
	pLight->setCastShadows(attribs->getBool("castshadows", true));
    if(attribs->hasImmediateChild("normal")){
        pLight->setDirection(attribs->getImmediateChild("normal")->getVector3());
    }
    if(attribs->hasImmediateChild("colourdiffuse")){
        pLight->setDiffuseColour(attribs->getImmediateChild("colourdiffuse")->getColour());
    }
    if(attribs->hasImmediateChild("coloursepcular")){
        pLight->setDiffuseColour(attribs->getImmediateChild("colourspecular")->getColour());
    }
    if(attribs->hasImmediateChild("lightrange")){
        DotSceneAttributes *range = attribs->getImmediateChild("lightrange");
        pLight->setSpotlightRange(Angle(range->getReal("inner",0.0)), Angle(range->getReal("outer",0.0)), range->getReal("falloff",1.0));
    }
    if(attribs->hasImmediateChild("lightattenuation")){
        DotSceneAttributes *atten = attribs->getImmediateChild("lightattenuation");
        pLight->setAttenuation(atten->getReal("range",0.0), atten->getReal("constant",0.0),
                atten->getReal("linear",0.0), atten->getReal("quadratic",0.0));
    }
}

void DotSceneLoader::finishCamera(DotSceneAttributes *attribs)
{
	//finish attributes
	String name = attribs->getString("name","");
	String id = attribs->getString("id","");
	Real fov = attribs->getReal("fov", 45);
	Real aspectRatio = attribs->getReal("aspectRatio", 1.3333);
	String projectionType = attribs->getString("projectionType", s_sCameraProjectionPerspective);

	// Create the camera
	Camera *pCamera = mSceneMgr->createCamera(name);
	if(pParentNode)
		pParentNode->attachObject(pCamera);

	// Set the field-of-view
	//! @todo Is this always in degrees?
	pCamera->setFOVy(Ogre::Degree(fov));

	// Set the aspect ratio
	pCamera->setAspectRatio(aspectRatio);

	// Set the projection type
	if(projectionType == s_sCameraProjectionPerspective)
		pCamera->setProjectionType(PT_PERSPECTIVE);
	else if(projectionType == s_sCameraProjectionOrtographic)
		pCamera->setProjectionType(PT_ORTHOGRAPHIC);

    if(attribs->hasImmediateChild("position")){
        pCamera->setPosition(attribs->getImmediateChild("position")->getVector3());
    }
    if(attribs->hasImmediateChild("rotation")){
        pCamera->setOrientation(attribs->getImmediateChild("rotation")->getQuaternion());
    }
    if(attribs->hasImmediateChild("lookat")){
        pCamera->lookAt(attribs->getImmediateChild("lookat")->getVector3());
    }
    if(attribs->hasImmediateChild("clipping")){
        DotSceneAttributes *clip = attribs->getImmediateChild("clipping");
        if(clip->hasAttribute("near")){
            pCamera->setNearClipDistance(clip->getReal("near",0));
        }
        if(clip->hasAttribute("far")){
            pCamera->setFarClipDistance(clip->getReal("far",0));
        }
    }
}

void DotSceneLoader::finishEntity(DotSceneAttributes *attribs)
{
	//finish attributes
	String name = attribs->getString("name","");
	String id = attribs->getString("id","");
	String meshFile = attribs->getString("meshFile","");
	String materialFile = attribs->getString("materialFile","");
	bool isStatic = attribs->getBool("static", false);;
	bool castShadows = attribs->getBool("castShadows", true);

	// Create the entity
	Entity *pEntity = 0;
	try {
		MeshManager::getSingleton().load(meshFile, m_sGroupName);
		pEntity = mSceneMgr->createEntity(name, meshFile);
		pEntity->setCastShadows(castShadows);
        if(pParentNode){
            pParentNode->attachObject(pEntity);
        }
		if(attribs->hasAttribute("materialFile")){
			pEntity->setMaterialName(materialFile);
        }
	} catch(Ogre::Exception &) {
		LogManager::getSingleton().logMessage("[DotSceneLoader] Error loading an entity!");
	}
}

void DotSceneLoader::finishVertexBuffer(DotSceneAttributes *attribs)
{
}

void DotSceneLoader::finishIndexBuffer(DotSceneAttributes *attribs)
{
}

void DotSceneLoader::finishParticleSystem(DotSceneAttributes *attribs)
{
	//finish attributes
	String name = attribs->getString("name","");
	String id = attribs->getString("id","");
	String file = attribs->getString("file","");

	// Create the particle system
	try {
		ParticleSystem *pParticles = mSceneMgr->createParticleSystem(name, file);
		pParentNode->attachObject(pParticles);
	} catch(Ogre::Exception &/*e*/) {
		LogManager::getSingleton().logMessage("[DotSceneLoader] Error creating a particle system!");
	}
}

void DotSceneLoader::finishBillboardSet(DotSceneAttributes *attribs)
{
	//! @todo Implement this
}

void DotSceneLoader::finishPlane(DotSceneAttributes *attribs)
{
	//! @todo Implement this
    String name = attribs->getString("name","");
    Real distance  = attribs->getReal("distance",0.0);
    Real width = attribs->getReal("width",4000);
    Real height = attribs->getReal("height",4000);

    int xSegments = (int)attribs->getReal("xSegments",1);
    int ySegments = (int)attribs->getReal("ySegments",1);
    short unsigned int numTexCoordSets = (int)attribs->getReal("numTexCoordSets",1);
    Real uTile = attribs->getReal("uTile",1.0);
    Real vTile = attribs->getReal("vTile",1.0);
    String material = attribs->getString("material","");
    bool normals = attribs->getBool("normals",true);
    bool movablePlane = attribs->getBool("movablePlane",false);
    bool castShadows = attribs->getBool("castShadows",false);
    bool receiveShadows = attribs->getBool("receiveShadows",true);
    Vector3 normal= Vector3::UNIT_Y;
    Vector3 upVector = Vector3::ZERO;

    if(attribs->hasImmediateChild("normal")){
        normal = attribs->getImmediateChild("normal")->getVector3();
    }

    if(attribs->hasImmediateChild("upvector")){
        upVector = attribs->getImmediateChild("upvector")->getVector3();
    }
    Plane pPlane(normal, upVector);
    Entity *pEntity;

    try {
        MeshPtr ptr = MeshManager::getSingleton().createPlane(name, m_sGroupName, pPlane, width, height, xSegments,
                ySegments, normals, numTexCoordSets, uTile, vTile, upVector);
        pEntity = mSceneMgr->createEntity(name, name);
        pEntity->setMaterialName(material,m_sGroupName);
        pParentNode->attachObject(pEntity);
    }catch (Exception e){
        LogManager::getSingleton().logMessage("[DotSceneLoader] Error loading a plane");
    }

}

void DotSceneLoader::finishSkyPlane(DotSceneAttributes *attribs)
{
	//finish attributes
	String material = attribs->getString("material","");
	Real planeX = attribs->getReal("planeX", 0);
	Real planeY = attribs->getReal("planeY", -1);
	Real planeZ = attribs->getReal("planeZ", 0);
	Real planeD = attribs->getReal("planeD", 4000);
	Real scale = attribs->getReal("scale", 1000);
	Real bow = attribs->getReal("bow", 0);
	Real tiling = attribs->getReal("tiling", 10);
	bool drawFirst = attribs->getBool("drawFirst", true);

	// Setup the sky plane
	Plane plane;
	plane.normal = Vector3(planeX, planeY, planeZ);
	plane.d = planeD;
	mSceneMgr->setSkyPlane(true, plane, material, scale, tiling, drawFirst, bow, 1, 1, m_sGroupName);
}

void DotSceneLoader::finishLookTarget(DotSceneAttributes *attribs)
{
	//finish attributes
	String nodeName = attribs->getString("nodeName","");
    Vector3 localDirection = Vector3::ZERO;
    Vector3 position = Vector3::ZERO;
	Node::TransformSpace relativeTo = Node::TS_PARENT;
	String sValue = attribs->getString("relativeTo", s_sTargetRelativeToLocal);

    if(attribs->hasImmediateChild("position")){
        localDirection = attribs->getImmediateChild("position")->getVector3();
    }
    if(attribs->hasImmediateChild("localdirection")){
        localDirection = attribs->getImmediateChild("localDirection")->getVector3();
    }
	if(sValue ==  s_sTargetRelativeToLocal)
		relativeTo = Node::TS_LOCAL;
	else if(sValue == s_sTargetRelativeToParent)
		relativeTo = Node::TS_PARENT;
	else if(sValue ==  s_sTargetRelativeToWorld)
		relativeTo = Node::TS_WORLD;

	//! @todo Is this correct? Cause I don't have a clue actually
	// Setup the look target
	try
	{
		if(!nodeName.empty())
		{
			SceneNode *pLookNode = mSceneMgr->getSceneNode(nodeName);
			position = pLookNode->_getDerivedPosition();
		}

		pParentNode->lookAt(position, relativeTo, localDirection);
	}
	catch(Ogre::Exception &/*e*/)
	{
		LogManager::getSingleton().logMessage("[DotSceneLoader] Error processing a look target!");
	}

}

void DotSceneLoader::finishTrackTarget(DotSceneAttributes *attribs)
{
	// Process attributes
	String nodeName = attribs->getString("nodeName","");
    Vector3 offset = attribs->getImmediateChild("offset")->getVector3();
    Vector3 localDirection = Vector3::ZERO;

    if(attribs->hasImmediateChild("localdirection")){
        localDirection = attribs->getImmediateChild("localDirection")->getVector3();
    }
	// Setup the track target
	try
	{
		SceneNode *pTrackNode = mSceneMgr->getSceneNode(nodeName);
		pParentNode->setAutoTracking(true, pTrackNode, localDirection, offset);
	}
	catch(Ogre::Exception &/*e*/)
	{
		LogManager::getSingleton().logMessage("[DotSceneLoader] Error processing a track target!");
	}
}

void DotSceneLoader::finishFog(DotSceneAttributes *attribs)
{
	// Process attributes
	Real expDensity = attribs->getReal("expdensity", 0.001);
	Real linearStart = attribs->getReal("linearStart", 0.0);
	Real linearEnd = attribs->getReal("linearEnd", 1.0);
    ColourValue colourDiffuse = ColourValue::ZERO;

    if(attribs->hasImmediateChild("colourdiffuse")){
        colourDiffuse = attribs->getImmediateChild("colourdiffuse")->getColour();
    }

	FogMode mode = FOG_NONE;
	String sMode = attribs->getString("mode",s_sFogModeExp);
	if(sMode == s_sFogModeNone)
		mode = FOG_NONE;
	else if(sMode == s_sFogModeExp)
		mode = FOG_EXP;
	else if(sMode == s_sFogModeExp2)
		mode = FOG_EXP2;
	else if(sMode == s_sFogModeLinear)
		mode = FOG_LINEAR;

	mSceneMgr->setFog(mode, colourDiffuse, expDensity, linearStart, linearEnd);
}

void DotSceneLoader::finishSkyBox(DotSceneAttributes *attribs)
{
	// Process attributes
	String material = attribs->getString("material","");
	Real distance = attribs->getReal("distance", 5000);
	bool drawFirst = attribs->getBool("drawFirst", true);
    Quaternion rotation = Quaternion::ZERO;

    if(attribs->hasImmediateChild("rotation")){
        rotation = attribs->getImmediateChild("rotation")->getQuaternion();
    }

	// Setup the sky box
	mSceneMgr->setSkyBox(true, material, distance, drawFirst, rotation, m_sGroupName);
}

void DotSceneLoader::finishSkyDome(DotSceneAttributes *attribs)
{
	// Process attributes
	String material = attribs->getString("material","");
	Real curvature = attribs->getReal("curvature", 10);
	Real tiling = attribs->getReal("tiling", 8);
	Real distance = attribs->getReal("distance", 4000);
	bool drawFirst = attribs->getBool("drawfirst", true);
    Quaternion rotation = Quaternion::ZERO;

    if(attribs->hasImmediateChild("rotation")){
        rotation = attribs->getImmediateChild("rotation")->getQuaternion();
    }

	// Setup the sky dome
	mSceneMgr->setSkyDome(true, material, curvature, tiling, distance, drawFirst, rotation, 16, 16, -1, m_sGroupName);
}

Y esto es todo de momento. Seguiré informando, ahora estoy con el tema de las animaciones de esqueleto.

De momento he escrito un plugin para importar los datos de una base de datos a la otra que incluso importa los multimedias. El problema que tengo ahora es que muchas historias estaban escritas usando Textile, así que me toca ir formateándolas de nuevo. A parte hay muchas imágenes que están subidas directamente al ftp de la época que usaba Movable Type. También estoy haciendo un tema parecido al original. En cuanto esté todo acabado, el dominio de hipocondria.org volverá a funciona, eso sí con los comentarios desactivados.

Brainfck parte de un espacio de bytes de memoria que podemos considerar infinito y en el que sólo disponemos de un puntero. Las instrucciones disponibles hacen lo siguiente:

• > mueve el puntero un espacio hacia delante
• < mueve el puntero un espacio hacia atrás
• + aumenta el valor del espacio apuntado en uno
• - decrementa el valor del espacio apuntado en uno
• . imprime el valor del espacio apuntado en formato char
• , lee un char y lo guarda en el espacio apuntado
• [ comienzo de bucle que se repite mientras el espacio apuntado no sea cero
• [ final de bucle

Con estos sencillos bloques tenemos que ir construyendo patrones que podamos utilizar para realizar tareas repetitivas que en un programa en otro lenguaje serían obvias. La idea es que cada patrón utilice un bloque de bytes lo más reducido posible sin modificar el resto de la memoria.

Vaciar un espacio

[-]

Este código vacía el espacio apuntado, ya que repite el bucle hasta que el espacio queda a cero. Otra opción es mover el puntero por encima de todas las direcciones en las que hemos trabajado, ya que las direcciones no usadas empiezan estando a cero.

Imprimir una cadena

La manera óptima en cuanto a memoria de imprimir una cadena es coger un espacio, reducirlo a cero, luego sumar hasta obtener el carácter ascii deseado, imprimirlo y luego volver a reducirlo a cero y sumar hasta obtener el siguiente carácter.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
[-]
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
[-]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
[-]
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
[-]

Como escribir tantos mases es un coñazo, lo mejor es escribir una función en otro lenguaje más sencillo que luego genere el código Brainfck. Una función en Python que generara este código a partir de una cadena dada sería:

def print_string(str):
    bf = ""
    for c in str:
        for i in range(ord(c)):
            bf += "+"
        bf += ".[-]"
    return bf

El código se podría optimizar para que nunca se resetee la posición, que se sume o se reste cada vez para obtener el valor deseado.

def print_string_opti(str):
    bf = ""
    l = 0;
    for c in str:
        c = ord(c)
        if l < c:
            for i in range(c-l):
                bf += "+"
        elif l > c:
            for i in range(l-c):
                bf += "-"
        bf += "."
        l = c
    bf += "[-]"
    return bf

Mover un espacio

Mover un espacio es bastante fácil. Nos metemos en un bucle y cada vez restamos uno del espacio actual y sumamos uno del siguiente, que al final quedará con el mismo valor que el original. El original quedará a cero.

>[-]<
[->+<]

Este código también se puede adaptar para hacer una negación, osea si el puntero actual vale cero, el siguiente no lo vale y si no vale cero, el siguiente vale cero. Ponemos el siguiente al principio a 1, luego entramos en el bucle con el anterior sólo si no vale cero y entonces vaciamos el siguiente.

>[-]+<
[>[-]<[-]]

Copiar un espacio

Copiar un espacio es parecido a moverlo, pero en vez de moverlo a un sitio lo movemos a dos.

>[-]>[-]<<
[->+>+<<]

Claro que el problema aquí es que hemos avanzado una posición. Lo que podemos hacer es volver a mover el valor 2 posiciones hacia atrás para tener la posición original igual y la copia en la siguiente posición.

>[-]>[-]<<
[->+>+<<]
>>[-<<+>>]<<

Una condición

Una cosa muy normal en otros lenguajes es la extresión if, que en Brainfck no existe. Veamos como podemos simularla.

En Brainfck lo más sencillo es la condición de si el espacio actual no vale cero, porque al hacer un bucle, sólo se entra si el espacio actual no vale cero. Así que entramos en el bucle, subimos el puntero, ejecutamos el código, bajamos el puntero y luego vaciamos el espacio actual para no volver a entrar en el bucle. Veamos como queda:

[> código si espacio no es cero <[-]]

Para hacer una condición sólo si el puntero vale cero, usaremos primero la negación y luego el mismo código.

>[-]+<
[>[-]<[-]]>
[> código si espacio es cero <[-]]

Para hacer un if else podemos usar el mismo sistema:

>[-]+<
[>> código si el espacio no es cero <[-]<[-]]>
[> código si espacio es cero <[-]]

Algo más complicado es comparar una posición con un valor estático. Esto se debe a que al restar la posición, no queremos restar a cero, ya que algunos compiladores de Brainfck podrían dar un error. Así que cada vez que restamos, tenemos que hacer una copia del valor para ver si es cero. Así que copiaremos el valor un elemento por encima y luego si ese elemento no es cero, restaremos al original. Y así repetimos. Así no restará nunca a cero, pero si llegamos antes a cero de lo esperado, se contará como válido. Necesitaremos un registro de memoria adicional que empezará con el valor esperado y al que iremos restando sólo si el introducido no vale cero. Al acabar, si ese valor no es cero querá decir que no hemos llegado al final. Como es muy coñazo ponerlo en Brainfck, lo pongo directamente en Python

def copy():
    return  ">[-]>[-]<<[->+>+<<]>>[-<<+>>]<<"

def compare(c):
    bf = ""
    for i in range(ord(c)):
        bf += copy()
        bf += ">>>+<<<"
        bf += ">[>>-<<<->[-]]<"
    bf += ">>>[<<<+>>>[-]]<<<"
    return bf

Comparar cadenas

Para comparar una cadena, solo hace falta concadenar varias comparaciones de las anteriores. Tenemos una posición que marca si se ha detectado un carácter erróneo, vale 1 si todo va bien o 0 si ha fallado. Así la siguiente comparación sólo se hace si el marcador vale 1.

def compare_str(str):
    bf = "[-]+"
    for c in str:
        bf += "[>,"
        bf += compare(c)
        bf += "<[-]]"
        bf += "+>[<->[-]]<"
    return bf

Pues eso es todo desde el mundo de Brainfck por ahora.