Engine directory for ticket #1

Engine/lib/collada/include/modules/daeLIBXMLPlugin.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this 
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License 
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
+ * implied. See the License for the specific language governing permissions and limitations under the 
+ * License. 
+ */
+
+#ifndef __DAE_LIBXMLPLUGIN__
+#define __DAE_LIBXMLPLUGIN__
+
+#include <vector>
+#include <dae/daeElement.h>
+#include <dae/daeURI.h>
+#include <dae/daeIOPluginCommon.h>
+
+struct _xmlTextReader;
+struct _xmlTextWriter;
+class DAE;
+
+/**
+ * The @c daeLIBXMLPlugin class derives from @c daeIOPluginCommon and implements an XML
+ * input/output backend using libxml2 as a parser. When using this plugin, DAE::load() expects
+ * an rfc 2396 compliant URI,  any URI supported by libxml2 should be properly 
+ * handled including ones with network schemes and authority.  If the URI contains a fragment it will be ignored
+ * and the entire referenced document will be loaded.  DAE::saveAs will only
+ * handle a filename path at present (ie: no scheme or authority).
+ */
+class DLLSPEC daeLIBXMLPlugin : public daeIOPluginCommon
+{
+public:
+	// Constructor / destructor
+	/**
+	 * Constructor.
+	 */
+	daeLIBXMLPlugin(DAE& dae);
+	/**
+	 * Destructor.
+	 */
+	virtual ~daeLIBXMLPlugin();
+
+	// Operations
+	virtual daeInt write(const daeURI& name, daeDocument *document, daeBool replace);
+
+	/**
+	 * setOption allows you to set options for this IOPlugin. Which options a plugin supports is
+	 * dependent on the plugin itself. There is currently no list of options that plugins are
+	 * suggested to implement. daeLibXML2Plugin supports only one option, "saveRawBinary". Set to 
+	 * "true" to save float_array data as a .raw binary file. The daeRawResolver will convert the 
+	 * data back into COLLADA domFloat_array elements upon load.
+	 * @param option The option to set.
+	 * @param value The value to set the option.
+	 * @return Returns DAE_OK upon success.
+	 */
+	virtual daeInt setOption( daeString option, daeString value );
+
+	/**
+	 * getOption retrieves the value of an option from this IOPlugin. Which options a plugin supports is
+	 * dependent on the plugin itself.
+	 * @param option The option to get.
+	 * @return Returns the string value of the option or NULL if option is not valid.
+	 */
+	virtual daeString getOption( daeString option );
+
+private:
+	DAE& dae;
+	
+	_xmlTextWriter *writer;
+
+	FILE *rawFile;
+	unsigned long rawByteCount;
+	daeURI rawRelPath;
+	bool saveRawFile;
+
+	virtual daeElementRef readFromFile(const daeURI& uri);
+	virtual daeElementRef readFromMemory(daeString buffer, const daeURI& baseUri);
+	daeElementRef read(_xmlTextReader* reader);
+	daeElementRef readElement(_xmlTextReader* reader, daeElement* parentElement);
+
+	void writeElement( daeElement* element ); 
+	void writeAttribute( daeMetaAttribute* attr, daeElement* element);
+	void writeValue(daeElement* element);
+
+	void writeRawSource( daeElement* src );
+};
+
+#endif //__DAE_LIBXMLPLUGIN__

Engine/lib/collada/include/modules/daeSTLDatabase.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this 
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License 
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
+ * implied. See the License for the specific language governing permissions and limitations under the 
+ * License. 
+ */
+
+#ifndef __DAE_STLDATABASE__
+#define __DAE_STLDATABASE__
+
+#include <stdio.h>
+
+#include <vector>
+#include <map>
+#include <string>
+#include <algorithm>
+#include <functional>
+
+#include <dae/daeElement.h>
+#include <dae/daeDatabase.h>
+
+/**
+ * The @c daeSTLDatabase class derives from @c daeDatabase and implements
+ * the default database.
+ */
+class DLLSPEC daeSTLDatabase : public daeDatabase
+{
+public:
+	/**
+	  * Constructor
+	  */
+	daeSTLDatabase(DAE& dae);
+	/**
+	  * Destructor
+	  */
+	virtual ~daeSTLDatabase();
+
+public:
+	// Element Types of all Elements
+	virtual daeUInt getTypeCount();
+	virtual daeString getTypeName(daeUInt index);
+	virtual daeInt setMeta(daeMetaElement *_topMeta);
+
+	// Documents
+	virtual daeInt insertDocument(daeString name, daeElement* dom, daeDocument** document = NULL);
+	virtual daeInt insertDocument(daeString name, daeDocument** document = NULL);
+	virtual daeInt createDocument(daeString name, daeElement* dom, daeDocument** document = NULL);
+	virtual daeInt createDocument(daeString name, daeDocument** document = NULL);
+	virtual daeInt insertDocument( daeDocument *c );
+
+	virtual daeInt removeDocument(daeDocument* document);
+	virtual daeUInt getDocumentCount();
+	virtual daeDocument* getDocument(daeUInt index);
+	virtual daeDocument* getDocument(daeString name, bool skipUriNormalization = false);
+	virtual daeString getDocumentName(daeUInt index);
+	virtual daeBool isDocumentLoaded(daeString name);
+
+	// Elements 
+	virtual daeInt insertElement(daeDocument* document, daeElement* element);
+	virtual daeInt removeElement(daeDocument* document, daeElement* element); 
+	virtual daeInt changeElementID(daeElement* element, daeString newID);
+	virtual daeInt changeElementSID(daeElement* element, daeString newSID); // Not implemented
+	virtual daeInt clear();
+
+	virtual std::vector<daeElement*> idLookup(const std::string& id);
+
+	virtual void typeLookup(daeInt typeID,
+	                        std::vector<daeElement*>& matchingElements,
+	                        daeDocument* doc = NULL);
+
+	// Currently not implemented, but you can uncomment some code in daeSTLDatabase.cpp to get
+	// it working.
+	virtual void sidLookup(const std::string& sid,
+	                       std::vector<daeElement*>& matchingElements,
+	                       daeDocument* doc = NULL);
+
+	// Deprecated. Don't use these. Use idLookup or typeLookup instead.
+	virtual daeUInt getElementCount(daeString name = NULL,
+	                                daeString type = NULL,
+	                                daeString file = NULL);
+	virtual daeInt getElement(daeElement** pElement, 
+	                          daeInt index,
+	                          daeString name = NULL,
+	                          daeString type = NULL,
+	                          daeString file = NULL);
+
+private:
+
+	std::map< std::string, std::vector< daeElement* > > elements; // type name --> element lookup table (deprecated)
+
+	std::multimap<daeInt, daeElement*> typeMap; // type ID --> element lookup table
+	typedef std::multimap<daeInt, daeElement*>::iterator typeMapIter;
+	typedef std::pair<daeInt, daeElement*> typeMapPair;
+	typedef std::pair<typeMapIter, typeMapIter> typeMapRange;
+
+	std::multimap< std::string, daeElement* > elementsIDMap; //map for elements keyed on ID
+	typedef std::multimap<std::string, daeElement*>::iterator idMapIter;
+	typedef std::pair<std::string, daeElement*> idMapPair;
+	typedef std::pair<idMapIter, idMapIter> idMapRange;
+
+	std::multimap< std::string, daeElement* > sidMap; // sid --> element lookup table
+	typedef std::multimap<std::string, daeElement*>::iterator sidMapIter;
+	typedef std::pair<std::string, daeElement*> sidMapPair;
+	typedef std::pair<sidMapIter, sidMapIter> sidMapRange;
+
+	std::vector<daeDocument*> documents;
+	daeMetaElement* topMeta;
+
+	daeInt insertChildren( daeDocument *c, daeElement *element );
+	daeInt removeChildren( daeDocument *c, daeElement *element );
+};
+
+#endif // __DAE_STLDATABASE__

Engine/lib/collada/include/modules/stdErrPlugin.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this 
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License 
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
+ * implied. See the License for the specific language governing permissions and limitations under the 
+ * License. 
+ */
+
+#ifndef _STDERR_PLUGIN_
+#define _STDERR_PLUGIN_
+
+#include <dae/daeTypes.h>
+#include <dae/daeErrorHandler.h>
+
+/**
+ * The @c stdErrPlugin class is the default implementation of daeErrorHandler. It routes the Error
+ * and Warning messaged to stdout.
+ */
+class DLLSPEC stdErrPlugin : public daeErrorHandler {
+public:
+	stdErrPlugin();
+	virtual ~stdErrPlugin();
+
+public:
+	void handleError( daeString msg );
+	void handleWarning( daeString msg );
+};
+
+/**
+ * The @c quietErrorHandler class is an alternative implementation of daeErrorHandler. It suppresses
+ * error and warning messages. The easiest way to use it is like this:
+ *   daeErrorHandler::setErrorHandler(&quietErrorHandler::getInstance());
+ */
+class DLLSPEC quietErrorHandler : public daeErrorHandler {
+public:
+	quietErrorHandler() { }
+	void handleError(daeString msg) { }
+	void handleWarning(daeString msg) { }
+
+	static quietErrorHandler& getInstance() { return theInstance; }
+
+private:
+	static quietErrorHandler theInstance;
+};
+
+#endif