Merge branch 'next' of https://github.com/gameplay3d/GamePlay into next

Author: sgrenier

gameplay/gameplay.pro

@@ -9,8 +9,7 @@ TEMPLATE = lib
 CONFIG += staticlib
 CONFIG += c++11
 CONFIG -= qt
-
-#DEFINES += GP_NO_PLATFORM
+CONFIG(debug, debug|release): DEFINES += _DEBUG
 
 SOURCES += src/AbsoluteLayout.cpp \
     src/AIAgent.cpp \
@@ -548,18 +547,19 @@ linux: INCLUDEPATH += /usr/include/harfbuzz
 
 macx: OBJECTIVE_SOURCES += src/PlatformMacOSX.mm
 macx: OBJECTIVE_SOURCES += src/gameplay-main-macosx.mm
-macx: QMAKE_CXXFLAGS += -x c++ -stdlib=libc++ -w -arch x86_64
-macx: QMAKE_OBJECTIVE_CFLAGS += -x objective-c++ -stdlib=libc++ -w -arch x86_64
+macx: QMAKE_CXXFLAGS += -x c++ -x objective-c++ -stdlib=libc++ -w -arch x86_64
 macx: LIBS += -F/System/Library/Frameworks -framework GameKit
 macx: LIBS += -F/System/Library/Frameworks -framework IOKit
 macx: LIBS += -F/System/Library/Frameworks -framework QuartzCore
 macx: LIBS += -F/System/Library/Frameworks -framework OpenAL
 macx: LIBS += -F/System/Library/Frameworks -framework OpenGL
 macx: LIBS += -F/System/Library/Frameworks -framework Cocoa
+macx: LIBS += -F/System/Library/Frameworks -framework Foundation
 
 win32: SOURCES += src/PlatformWindows.cpp
 win32: SOURCES += src/gameplay-main-windows.cpp
 win32: DEFINES += WIN32 _UNICODE UNICODE
-win32: INCLUDEPATH += $$(DXSDK_DIR)Include
+win32: INCLUDEPATH += $$(DXSDK_DIR)/Include
 win32: QMAKE_CXXFLAGS_WARN_ON -= -w34100
 win32: QMAKE_CXXFLAGS_WARN_ON -= -w34189
+win32: QMAKE_CXXFLAGS_WARN_ON -= -w4302

gameplay/src/Mesh.cpp

@@ -251,7 +251,6 @@ bool Mesh::isDynamic() const
     return _dynamic;
 }
 
-
 Mesh::PrimitiveType Mesh::getPrimitiveType() const
 {
     return _primitiveType;
@@ -262,7 +261,19 @@ void Mesh::setPrimitiveType(PrimitiveType type)
     _primitiveType = type;
 }
 
-void Mesh::setVertexData(const float* vertexData, unsigned int vertexStart, unsigned int vertexCount)
+void* Mesh::mapVertexBuffer(MapAccess access)
+{
+    GL_ASSERT( glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer) );
+
+    return (void*)glMapBuffer(GL_ARRAY_BUFFER, access);
+}
+
+bool Mesh::unmapVertexBuffer()
+{
+    return glUnmapBuffer(GL_ARRAY_BUFFER);
+}
+
+void Mesh::setVertexData(const void* vertexData, unsigned int vertexStart, unsigned int vertexCount)
 {
     GL_ASSERT( glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer) );
 

gameplay/src/Mesh.h

@@ -47,6 +47,16 @@ class Mesh : public Ref
         POINTS = GL_POINTS
     };
 
+    /**
+     * Defines mapping access/usage.
+     */
+    enum MapAccess
+    {
+        MAP_READ_ONLY = GL_READ_ONLY,
+        MAP_WRITE_ONLY = GL_WRITE_ONLY,
+        MAP_READ_WRITE = GL_READ_WRITE
+    };
+
     /**
      * Constructs a new mesh with the specified vertex format.
      *
@@ -200,14 +210,47 @@ class Mesh : public Ref
      */
     void setPrimitiveType(Mesh::PrimitiveType type);
 
+    /**
+     * Maps the vertex buffer for the specified access.
+     *
+     * Mapping vertex data causes a synchronizing issue. To avoid gpu idle
+     * If GPU is still working with the buffer object, mapVertexBuffer will not
+     * return until GPU finishes its job with the corresponding buffer object.
+     *
+     * To avoid waiting (idle), you can call first setVertexBuffer with NULL pointer,
+     * then call mapVertexBuffer(). In this case, the previous data will be discarded
+     * and mapVertexBuffer() returns a new allocated pointer immediately even if GPU is
+     * still working with the previous data.
+     *
+     * However, this method is valid only if you want to update entire data set because
+     * you discard the previous data. If you want to change only portion of data or to
+     * read data, you better not release the previous data.
+     *
+     * After modifying the data of VBO, it must be unmapped the buffer object from the client's
+     * memory. unmapVertexBuffer returns true if success. When it returns false, the contents of
+     * vertex buffer become corrupted while the buffer was mapped. The corruption results from screen
+     * resolution change or window system specific events. In this case, the data must be resubmitted.
+     *
+     * @param access The access for which the data can be use. Ex. read, write, read_write.
+     * @return The mapped vertex buffer
+     */
+    void* mapVertexBuffer(Mesh::MapAccess access);
+
+    /**
+     * Unmaps the vertex buffer.
+     *
+     * @return false if unmapping buffer was unsuccessful
+     */
+    bool unmapVertexBuffer();
+
     /**
      * Sets the specified vertex data into the mapped vertex buffer.
      *
      * @param vertexData The vertex data to be set.
      * @param vertexStart The index of the starting vertex (0 by default).
      * @param vertexCount The number of vertices to be set (default is 0, for all vertices).
      */
-    void setVertexData(const float* vertexData, unsigned int vertexStart = 0, unsigned int vertexCount = 0);
+    void setVertexData(const void* vertexData, unsigned int vertexStart = 0, unsigned int vertexCount = 0);
 
     /**
      * Creates and adds a new part of primitive data defining how the vertices are connected.

gameplay/src/MeshPart.cpp

@@ -82,9 +82,16 @@ IndexBufferHandle MeshPart::getIndexBuffer() const
     return _indexBuffer;
 }
 
-bool MeshPart::isDynamic() const
+void* MeshPart::mapIndexBuffer(Mesh::MapAccess access)
 {
-    return _dynamic;
+    GL_ASSERT( glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer) );
+
+    return (void*)glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, access);
+}
+
+bool MeshPart::unmapIndexBuffer()
+{
+    return glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
 }
 
 void MeshPart::setIndexData(const void* indexData, unsigned int indexStart, unsigned int indexCount)
@@ -123,4 +130,9 @@ void MeshPart::setIndexData(const void* indexData, unsigned int indexStart, unsi
     }
 }
 
+bool MeshPart::isDynamic() const
+{
+    return _dynamic;
+}
+
 }

gameplay/src/MeshPart.h

@@ -58,11 +58,37 @@ class MeshPart
     IndexBufferHandle getIndexBuffer() const;
 
     /**
-     * Determines if the indices are dynamic.
+     * Maps the index buffer for the specified access.
      *
-     * @return true if the part is dynamic; false otherwise.
+     * Mapping index data causes a synchronizing issue. To avoid gpu idle
+     * If GPU is still working with the buffer object, mapIndexBuffer will not
+     * return until GPU finishes its job with the corresponding buffer object.
+     *
+     * To avoid waiting (idle), you can call first setIndexData with NULL pointer,
+     * then call mapIndexBuffer(). In this case, the previous data will be discarded
+     * and mapIndexData() returns a new allocated pointer immediately even if GPU is
+     * still working with the previous data.
+     *
+     * However, this method is valid only if you want to update entire data set because
+     * you discard the previous data. If you want to change only portion of data or to
+     * read data, you better not release the previous data.
+     *
+     * After modifying the data of VBO, it must be unmapped the buffer object from the client's
+     * memory. unmapIndexBuffer returns true if success. When it returns false, the contents of
+     * index buffer become corrupted while the buffer was mapped. The corruption results from screen
+     * resolution change or window system specific events. In this case, the data must be resubmitted.
+     *
+     * @param access The access for which the data can be use. Ex. read, write, read_write.
+     * @return The mapped index buffer
      */
-    bool isDynamic() const;
+    void* mapIndexBuffer(Mesh::MapAccess access);
+
+    /**
+     * Unmaps the index buffer.
+     *
+     * @return false if unmapping buffer was unsuccessful
+     */
+    bool unmapIndexBuffer();
 
     /**
      * Sets the specified index data into the mapped index buffer.
@@ -74,6 +100,13 @@ class MeshPart
      */
     void setIndexData(const void* indexData, unsigned int indexStart, unsigned int indexCount);
 
+    /**
+     * Determines if the indices are dynamic.
+     *
+     * @return true if the part is dynamic; false otherwise.
+     */
+    bool isDynamic() const;
+
 private:
 
     /**

gameplay/src/Node.cpp

@@ -218,23 +218,32 @@ Node* Node::getRootNode() const
 }
 
 Node* Node::findNode(const char* id, bool recursive, bool exactMatch) const
+{
+    return findNode(id, recursive, exactMatch, false);
+}
+
+Node* Node::findNode(const char* id, bool recursive, bool exactMatch, bool skipSkin) const
 {
     GP_ASSERT(id);
 
-    // If the drawable is a model with a mesh skin, search the skin's hierarchy as well.
-    Node* rootNode = NULL;
-    Model* model = dynamic_cast<Model*>(_drawable);
-    if (model)
+    // If not skipSkin hierarchy, try searching the skin hierarchy
+    if (!skipSkin)
     {
-        if (model->getSkin() != NULL && (rootNode = model->getSkin()->_rootNode) != NULL)
+        // If the drawable is a model with a mesh skin, search the skin's hierarchy as well.
+        Node* rootNode = NULL;
+        Model* model = dynamic_cast<Model*>(_drawable);
+        if (model)
         {
-            if ((exactMatch && rootNode->_id == id) || (!exactMatch && rootNode->_id.find(id) == 0))
-                return rootNode;
-
-            Node* match = rootNode->findNode(id, true, exactMatch);
-            if (match)
+            if (model->getSkin() != NULL && (rootNode = model->getSkin()->_rootNode) != NULL)
             {
-                return match;
+                if ((exactMatch && rootNode->_id == id) || (!exactMatch && rootNode->_id.find(id) == 0))
+                    return rootNode;
+
+                Node* match = rootNode->findNode(id, true, exactMatch, true);
+                if (match)
+                {
+                    return match;
+                }
             }
         }
     }
@@ -252,7 +261,7 @@ Node* Node::findNode(const char* id, bool recursive, bool exactMatch) const
     {
         for (Node* child = getFirstChild(); child != NULL; child = child->getNextSibling())
         {
-            Node* match = child->findNode(id, true, exactMatch);
+            Node* match = child->findNode(id, true, exactMatch, skipSkin);
             if (match)
             {
                 return match;
@@ -263,25 +272,35 @@ Node* Node::findNode(const char* id, bool recursive, bool exactMatch) const
 }
 
 unsigned int Node::findNodes(const char* id, std::vector<Node*>& nodes, bool recursive, bool exactMatch) const
+{
+    return findNodes(id, nodes, recursive, exactMatch, false);
+}
+
+unsigned int Node::findNodes(const char* id, std::vector<Node*>& nodes, bool recursive, bool exactMatch, bool skipSkin) const
 {
     GP_ASSERT(id);
 
     // If the drawable is a model with a mesh skin, search the skin's hierarchy as well.
     unsigned int count = 0;
-    Node* rootNode = NULL;
-    Model* model = dynamic_cast<Model*>(_drawable);
-    if (model)
+
+    if (!skipSkin)
     {
-        if (model->getSkin() != NULL && (rootNode = model->getSkin()->_rootNode) != NULL)
+        Node* rootNode = NULL;
+        Model* model = dynamic_cast<Model*>(_drawable);
+        if (model)
         {
-            if ((exactMatch && rootNode->_id == id) || (!exactMatch && rootNode->_id.find(id) == 0))
+            if (model->getSkin() != NULL && (rootNode = model->getSkin()->_rootNode) != NULL)
             {
-                nodes.push_back(rootNode);
-                ++count;
+                if ((exactMatch && rootNode->_id == id) || (!exactMatch && rootNode->_id.find(id) == 0))
+                {
+                    nodes.push_back(rootNode);
+                    ++count;
+                }
+                count += rootNode->findNodes(id, nodes, recursive, exactMatch, true);
             }
-            count += rootNode->findNodes(id, nodes, true, exactMatch);
         }
     }
+
     // Search immediate children first.
     for (Node* child = getFirstChild(); child != NULL; child = child->getNextSibling())
     {
@@ -297,7 +316,7 @@ unsigned int Node::findNodes(const char* id, std::vector<Node*>& nodes, bool rec
     {
         for (Node* child = getFirstChild(); child != NULL; child = child->getNextSibling())
         {
-            count += child->findNodes(id, nodes, true, exactMatch);
+            count += child->findNodes(id, nodes, recursive, exactMatch, skipSkin);
         }
     }
 

gameplay/src/Node.h

@@ -665,6 +665,39 @@ class Node : public Transform, public Ref
      */
     void setBoundsDirty();
 
+    /**
+     * Returns the first child node that matches the given ID.
+     *
+     * This method checks the specified ID against its immediate child nodes
+     * but does not check the ID against itself.
+     * If recursive is true, it also traverses the Node's hierarchy with a breadth first search.
+     *
+     * @param id The ID of the child to find.
+     * @param recursive True to search recursively all the node's children, false for only direct children.
+     * @param exactMatch true if only nodes whose ID exactly matches the specified ID are returned,
+     *        or false if nodes that start with the given ID are returned.
+     * @param skipSkin Set true to skip skin hierarchy, initial find may set false to include skin hierarchy.
+     *
+     * @return The Node found or NULL if not found.
+     */
+    Node* findNode(const char* id, bool recursive, bool exactMatch, bool skipSkin) const;
+
+
+    /**
+     * Returns all child nodes that match the given ID.
+     *
+     * @param id The ID of the node to find.
+     * @param nodes A vector of nodes to be populated with matches.
+     * @param recursive true if a recursive search should be performed, false otherwise.
+     * @param exactMatch true if only nodes whose ID exactly matches the specified ID are returned,
+     *        or false if nodes that start with the given ID are returned.
+     * @param skipSkin Set true to skip skin hierarchy, initial find may set false to include skin hierarchy.
+     * 
+     * @return The number of matches found.
+     * @script{ignore}
+     */
+    unsigned int findNodes(const char* id, std::vector<Node*>& nodes, bool recursive, bool exactMatch, bool skipSkin) const;
+
 private:
 
     /**