Support 9-patch image

Change-Id: Ie9f348608416a74009c242461ea5d4ee70318568

diff --git a/src/ui/animations/FUiAnim_GlNode.cpp b/src/ui/animations/FUiAnim_GlNode.cpp
index c877dd3..2e3fec7 100644 (file)
--- a/src/ui/animations/FUiAnim_GlNode.cpp
+++ b/src/ui/animations/FUiAnim_GlNode.cpp
@@ -82,6 +82,10 @@ _GlNode::_GlNode(void)
        , __childrenCount(0)
        , __backgroundColor(0.0f, 0.0f, 0.0f, 0.0f)     // fully transparent rectangle object by default
        , __objectColor(0.0f, 0.0f, 0.0f, 0.0f)
+       , __pVertices(null)
+       , __pIndices(null)
+       , __vertexCount(0)
+       , __indexCount(0)
        , __pLayer(null)
        , __activeLight()
        , __pMesh(null)
@@ -100,6 +104,8 @@ _GlNode::_GlNode(void)
        memset(__extraSurfaceUpdated, true, sizeof(bool) * EXTRA_SURFACE_MAX);
 
        __activeLight.Construct();
+
+       AllocateVertexBuffer(4, 6);
 }
 
 _GlNode::~_GlNode(void)
@@ -125,6 +131,18 @@ _GlNode::~_GlNode(void)
                }
        }
 
+       if (__pVertices)
+       {
+               delete [] __pVertices;
+               __pVertices = null;
+       }
+
+       if (__pIndices)
+       {
+               delete [] __pIndices;
+               __pIndices = null;
+       }
+
        if (__pMesh)
        {
                delete __pMesh;
@@ -369,163 +387,6 @@ _GlNode::SyncStatus(VisualElementSurface* pSurface, _VisualElementImpl& element)
 
                        // Set texture info
 //                     __pTextureInfo =  reinterpret_cast<TextureInfo*>(pSurfaceImpl->GetNativeHandle());
-
-                       // test for atlas
-//                     bool useAtlas = false;
-//                     float atlasWidth, atlasHeight;
-
-                       // Calc texture coordinates
-#ifdef __USE_TEXTURE_ATLAS__
-                       if (!pTextureInfo->atlas)
-                       {
-#endif
-                               if (__useStencil)
-                               {
-                                       if (element.__useContentBounds)
-                                       {
-                                               __pVertices[3]  = element.__contentBounds.x;
-                                               __pVertices[4]  = element.__contentBounds.y;
-
-                                               __pVertices[8]  = element.__contentBounds.x + element.__contentBounds.width;
-                                               __pVertices[9]  = element.__contentBounds.y;
-
-                                               __pVertices[13] = element.__contentBounds.x;
-                                               __pVertices[14] = element.__contentBounds.y + element.__contentBounds.height;
-
-                                               __pVertices[18] = element.__contentBounds.x + element.__contentBounds.width;
-                                               __pVertices[19] = element.__contentBounds.y + element.__contentBounds.height;
-                                       }
-                                       else
-                                       {
-                                               __pVertices[3]  = 0.0f;
-                                               __pVertices[4]  = 0.0f;
-
-                                               __pVertices[8]  = 1.0f;
-                                               __pVertices[9]  = 0.0f;
-
-                                               __pVertices[13] = 0.0f;
-                                               __pVertices[14] = 1.0f;
-
-                                               __pVertices[18] = 1.0f;
-                                               __pVertices[19] = 1.0f;
-                                       }
-                               }
-                               else
-                               {
-                                       if (element.__useContentBounds)
-                                       {
-                                               __pVertices[3]  = element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width;
-                                               __pVertices[4]  = element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height;
-
-                                               __pVertices[8]  = element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width;
-                                               __pVertices[9]  = element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height;
-
-                                               __pVertices[13] = element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width;
-                                               __pVertices[14] = element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height;
-
-                                               __pVertices[18] = element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width;
-                                               __pVertices[19] = element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height;
-                                       }
-                                       else
-                                       {
-                                               __pVertices[3]  = __visibleRect.Left() / __bounds.Width();
-                                               __pVertices[4]  = __visibleRect.Top() / __bounds.Height();
-
-                                               __pVertices[8]  = (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width();
-                                               __pVertices[9]  = __visibleRect.Top() / __bounds.Height();
-
-                                               __pVertices[13] = __visibleRect.Left() / __bounds.Width();
-                                               __pVertices[14] = (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height();
-
-                                               __pVertices[18] = (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width();
-                                               __pVertices[19] = (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height();
-                                       }
-                               }
-#ifdef __USE_TEXTURE_ATLAS__
-                       }
-                       else
-                       {
-
-                               _TextureAtlas* pAtlas = reinterpret_cast<_TextureAtlas*>(pTextureInfo->atlas);
-
-                               float atlasWidth = pAtlas->GetTextureInfo().width;
-                               float atlasHeight = pAtlas->GetTextureInfo().height;
-                               // use texture atlas
-                               if (__useStencil)
-                               {
-                                       if (element.__useContentBounds)
-                                       {
-                                               __pVertices[3]  = (pTextureInfo->x + element.__contentBounds.x * pTextureInfo->width) / atlasWidth;
-                                               __pVertices[4]  = (pTextureInfo->y + element.__contentBounds.y * pTextureInfo->height) / atlasHeight;
-
-                                               __pVertices[8]  = (pTextureInfo->x + (element.__contentBounds.x + element.__contentBounds.width) * pTextureInfo->width) / atlasWidth;
-                                               __pVertices[9]  = (pTextureInfo->y + element.__contentBounds.y * pTextureInfo->height) / atlasHeight;
-
-                                               __pVertices[13] = (pTextureInfo->x + element.__contentBounds.x * pTextureInfo->width) / atlasWidth;
-                                               __pVertices[14] = (pTextureInfo->y + (element.__contentBounds.y + element.__contentBounds.height) * pTextureInfo->height) / atlasHeight;
-
-                                               __pVertices[18] = (pTextureInfo->x + (element.__contentBounds.x + element.__contentBounds.width) * pTextureInfo->width) / atlasWidth;
-                                               __pVertices[19] = (pTextureInfo->y + (element.__contentBounds.y + element.__contentBounds.height) * pTextureInfo->height) / atlasHeight;
-                                       }
-                                       else
-                                       {
-                                               __pVertices[3]  = pTextureInfo->x / atlasWidth;
-                                               __pVertices[4]  = pTextureInfo->y / atlasHeight;
-
-                                               __pVertices[8]  = (pTextureInfo->x + pTextureInfo->width) / atlasWidth;
-                                               __pVertices[9]  = pTextureInfo->y / atlasHeight;
-
-                                               __pVertices[13] = pTextureInfo->x / atlasWidth;
-                                               __pVertices[14] = (pTextureInfo->y + pTextureInfo->height) / atlasHeight;
-
-                                               __pVertices[18] = (pTextureInfo->x + pTextureInfo->width) / atlasWidth;
-                                               __pVertices[19] = (pTextureInfo->y + pTextureInfo->height) / atlasHeight;
-                                       }
-                               }
-                               else
-                               {
-
-
-                                       if (element.__useContentBounds)
-                                       {
-                                               __pVertices[3]  = ((element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[4]  = ((element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[8]  = ((element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[9]  = ((element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[13] = ((element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[14] = ((element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[18] = ((element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[19] = ((element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-                                       }
-                                       else
-                                       {
-                                               __pVertices[3]  = (__visibleRect.Left() / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[4]  = (__visibleRect.Top() / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[8]  = ((__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[9]  = (__visibleRect.Top() / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[13] = (__visibleRect.Left() / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[14] = ((__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-
-                                               __pVertices[18] = ((__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
-                                               __pVertices[19] = ((__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
-                                       }
-                               }
-                       }
-#endif
-
-                       if (__pVertices[3] < 0.0f || __pVertices[4] < 0.0f || __pVertices[18] > 1.0f || __pVertices[19] > 1.0f)
-                       {
-                               __textureRepeated = true;
-                       }
-                       else
-                       {
-                               __textureRepeated = false;
-                       }
                }
        }
        else
@@ -642,144 +503,464 @@ _GlNode::SyncStatus(VisualElementSurface* pSurface, _VisualElementImpl& element)
                __pFilter = null;
        }
 
-       if (element.__decomposedMatrixToTop.GetMatrixType() >= MATRIX4_Scale || __pMesh)
+       ShaderProgram* pShaderProgram = element.GetSharedData().geometry.GetShaderProgram();
+
+       if (unlikely(pShaderProgram))
        {
-               __useTransform = true;
+               if (!__pShaderProgram || !pShaderProgram->Equals(*__pShaderProgram))
+               {
+                       if (__pShaderProgram)
+                       {
+                               delete __pShaderProgram;
+                               __pShaderProgram = null;
+                       }
+
+                       __pShaderProgram = new (std::nothrow) ShaderProgram(*pShaderProgram);
+                       SysAssertf(__pShaderProgram, "failed to create shader program");
+               }
        }
        else
        {
-               __useTransform = false;
+               if (__pShaderProgram)
+               {
+                       delete __pShaderProgram;
+                       __pShaderProgram = null;
+               }
        }
 
-       // Set vertices
-       if (__useStencil)
+       CalcVertexCoordinates(element);
+
+       if (__pMesh || __useTransform || __useStencil || __pFilter)
        {
-               if (__useTransform)
+               __findItemInQueue = false;
+       }
+       else
+       {
+               __findItemInQueue = true;
+       }
+
+       __syncNeeded = false;
+
+       return E_SUCCESS;
+}
+
+VisualElementSurface*
+_GlNode::GetSurface(void) const
+{
+       return __pSurface;
+}
+
+void
+_GlNode::CalcVertexCoordinates(_VisualElementImpl& element)
+{
+       float texX[4] = {0, };
+       float texY[4] = {0, };
+       float vertexX[4] = {0, };
+       float vertexY[4] = {0, };
+       int i = 0, index = 0, countX = 0, countY = 0;
+       int vertexCount, indexCount;
+
+       if (__pSurface)
+       {
+               _VisualElementSurfaceImpl* pSurfaceImpl = _VisualElementSurfaceImpl::GetInstance(*__pSurface);
+               TextureInfo* pTextureInfo =  reinterpret_cast<TextureInfo*>(pSurfaceImpl->GetNativeHandle());
+
+#ifdef __USE_TEXTURE_ATLAS__
+               if (!pTextureInfo->atlas)
                {
-                       __pVertices[0] = 0.0f;
-                       __pVertices[1] = 0.0f;
-                       __pVertices[2] = 0.0f;
+#endif
+                       if (__useStencil)
+                       {
+                               if (pTextureInfo->useBorder)
+                               {
+                                       // TODO: consider the case: __bounds.width < left border + right border
+                                       texX[0] = 0.0f;
+                                       texX[1] = (float)pTextureInfo->leftBorder / (float)pTextureInfo->width;
+                                       texX[2] = (float)(pTextureInfo->width - pTextureInfo->rightBorder) / (float)pTextureInfo->width;
+                                       texX[3] = 1.0f;
+
+                                       texY[0] = 0.0f;
+                                       texY[1] = (float)pTextureInfo->topBorder / (float)pTextureInfo->height;
+                                       texY[2] = (float)(pTextureInfo->height - pTextureInfo->bottomBorder) / (float)pTextureInfo->height;
+                                       texY[3] = 1.0f;
+
+                                       vertexX[0] = 0.0f;
+                                       vertexX[1] = pTextureInfo->leftBorder;
+                                       vertexX[2] = __bounds.Width() - pTextureInfo->rightBorder;
+                                       vertexX[3] = __bounds.Width();
+
+                                       vertexY[0] = 0.0f;
+                                       vertexY[1] = pTextureInfo->topBorder;
+                                       vertexY[2] = __bounds.Height() - pTextureInfo->bottomBorder;
+                                       vertexY[3] = __bounds.Height();
+
+                                       countX = countY = 4;
+
+                                       __textureRepeated = false;
+                               }
+                               else
+                               {
+                                       if (element.__useContentBounds)
+                                       {
+                                               texX[0] = element.__contentBounds.x;
+                                               texX[1] = element.__contentBounds.x + element.__contentBounds.width;
+
+                                               texY[0] = element.__contentBounds.y;
+                                               texY[1] = element.__contentBounds.y + element.__contentBounds.height;
+
+                                               if (texX[0] < 0.0f || texY[0] < 0.0f || texX[1] > 1.0f || texY[1] > 1.0f)
+                                               {
+                                                       __textureRepeated = true;
+                                               }
+                                               else
+                                               {
+                                                       __textureRepeated = false;
+                                               }
+                                       }
+                                       else
+                                       {
+                                               texX[0] = 0.0f;
+                                               texX[1] = 1.0f;
 
-                       __pVertices[5] = __bounds.Width();
-                       __pVertices[6] = 0.0f;
-                       __pVertices[7] = 0.0f;
+                                               texY[0] = 0.0f;
+                                               texY[1] = 1.0f;
+
+                                               __textureRepeated = false;
+                                       }
 
-                       __pVertices[10] = 0.0f;
-                       __pVertices[11] = __bounds.Height();
-                       __pVertices[12] = 0.0f;
+                                       vertexX[0] = 0.0f;
+                                       vertexX[1] = __bounds.Width();
 
-                       __pVertices[15] = __bounds.Width();
-                       __pVertices[16] = __bounds.Height();
-                       __pVertices[17] = 0.0f;
+                                       vertexY[0] = 0.0f;
+                                       vertexY[1] = __bounds.Height();
+
+                                       countX = countY = 2;
+                               }
+                       }
+                       else
+                       {
+                               float x1 = __visibleRect.Left() / __bounds.Width();
+                               float y1 = __visibleRect.Top() / __bounds.Height();
+                               float x2 = __visibleRect.Right() / __bounds.Width();
+                               float y2 = __visibleRect.Bottom() / __bounds.Height();
+
+                               if (pTextureInfo->useBorder)
+                               {
+                                       // TODO: consider the case: __bounds.width < left border + right border
+                                       float borderX1 = (float)pTextureInfo->leftBorder / (float)pTextureInfo->width;
+                                       float borderY1 = (float)pTextureInfo->topBorder / (float)pTextureInfo->height;
+                                       float borderX2 = (float)(pTextureInfo->width - pTextureInfo->rightBorder) / (float)pTextureInfo->width;
+                                       float borderY2 = (float)(pTextureInfo->height - pTextureInfo->bottomBorder) / (float)pTextureInfo->height;
+
+                                       if (x1 < borderX1)
+                                       {
+                                               texX[countX] = x1;
+                                               vertexX[countX++] = __visibleRect.Left();
+
+                                               texX[countX] = borderX1;
+                                               vertexX[countX++] = __visibleRect.Left() + (borderX1 - x1) * pTextureInfo->width;
+                                       }
+                                       else
+                                       {
+                                               texX[countX] = x1;
+                                               vertexX[countX++] = __visibleRect.Left();
+                                       }
+
+                                       if (x2 > borderX2)
+                                       {
+                                               texX[countX] = borderX2;
+                                               vertexX[countX++] = __visibleRect.Right() - (x2 - borderX2) * pTextureInfo->width;
+
+                                               texX[countX] = x2;
+                                               vertexX[countX++] = __visibleRect.Right();
+                                       }
+                                       else
+                                       {
+                                               texX[countX] = x2;
+                                               vertexX[countX++] = __visibleRect.Right();
+                                       }
+
+                                       if (y1 < borderY1)
+                                       {
+                                               texY[countY] = y1;
+                                               vertexY[countY++] = __visibleRect.Top();
+
+                                               texY[countY] = borderY1;
+                                               vertexY[countY++] = __visibleRect.Top() + (borderY1 - y1) * pTextureInfo->height;
+                                       }
+                                       else
+                                       {
+                                               texY[countY] = y1;
+                                               vertexY[countY++] = __visibleRect.Top();
+                                       }
+
+                                       if (y2 > borderY2)
+                                       {
+                                               texY[countY] = borderY2;
+                                               vertexY[countY++] = __visibleRect.Bottom() - (y2 - borderY2) * pTextureInfo->height;
+
+                                               texY[countY] = y2;
+                                               vertexY[countY++] = __visibleRect.Bottom();
+                                       }
+                                       else
+                                       {
+                                               texY[countY] = y2;
+                                               vertexY[countY++] = __visibleRect.Bottom();
+                                       }
+
+                                       __textureRepeated = false;
+                               }
+                               else
+                               {
+                                       if (element.__useContentBounds)
+                                       {
+                                               texX[0] = element.__contentBounds.x + x1 * element.__contentBounds.width;
+                                               texX[1] = element.__contentBounds.x + x2 * element.__contentBounds.width;
+
+                                               texY[0] = element.__contentBounds.y + y1 * element.__contentBounds.height;
+                                               texY[1] = element.__contentBounds.y + y2 * element.__contentBounds.height;
+
+                                               if (texX[0] < 0.0f || texY[0] < 0.0f || texX[1] > 1.0f || texY[1] > 1.0f)
+                                               {
+                                                       __textureRepeated = true;
+                                               }
+                                               else
+                                               {
+                                                       __textureRepeated = false;
+                                               }
+                                       }
+                                       else
+                                       {
+                                               texX[0] = x1;
+                                               texX[1] = x2;
+
+                                               texY[0] = y1;
+                                               texY[1] = y2;
+
+                                               __textureRepeated = false;
+                                       }
+
+                                       vertexX[0] = __visibleRect.Left();
+                                       vertexX[1] = __visibleRect.Right();
+
+                                       vertexY[0] = __visibleRect.Top();
+                                       vertexY[1] = __visibleRect.Bottom();
+
+                                       countX = countY = 2;
+                               }
+                       }
+#ifdef __USE_TEXTURE_ATLAS__
                }
                else
                {
-                       __pVertices[0] = __transform.matrix[3][0];
-                       __pVertices[1] = __transform.matrix[3][1];
-                       __pVertices[2] = 0.0f;
+                       _TextureAtlas* pAtlas = reinterpret_cast<_TextureAtlas*>(pTextureInfo->atlas);
+
+                       float atlasWidth = pAtlas->GetTextureInfo().width;
+                       float atlasHeight = pAtlas->GetTextureInfo().height;
+
+                       // TODO: implement texture border code
 
-                       __pVertices[5] = __transform.matrix[3][0] + __bounds.Width();
-                       __pVertices[6] = __transform.matrix[3][1];
-                       __pVertices[7] = 0.0f;
+                       // use texture atlas
+                       if (__useStencil)
+                       {
+                               if (element.__useContentBounds)
+                               {
+                                       __pVertices[3]  = (pTextureInfo->x + element.__contentBounds.x * pTextureInfo->width) / atlasWidth;
+                                       __pVertices[4]  = (pTextureInfo->y + element.__contentBounds.y * pTextureInfo->height) / atlasHeight;
 
-                       __pVertices[10] = __transform.matrix[3][0];
-                       __pVertices[11] = __transform.matrix[3][1] + __bounds.Height();
-                       __pVertices[12] = 0.0f;
+                                       __pVertices[8]  = (pTextureInfo->x + (element.__contentBounds.x + element.__contentBounds.width) * pTextureInfo->width) / atlasWidth;
+                                       __pVertices[9]  = (pTextureInfo->y + element.__contentBounds.y * pTextureInfo->height) / atlasHeight;
 
-                       __pVertices[15] = __transform.matrix[3][0] + __bounds.Width();
-                       __pVertices[16] = __transform.matrix[3][1] + __bounds.Height();
-                       __pVertices[17] = 0.0f;
+                                       __pVertices[13] = (pTextureInfo->x + element.__contentBounds.x * pTextureInfo->width) / atlasWidth;
+                                       __pVertices[14] = (pTextureInfo->y + (element.__contentBounds.y + element.__contentBounds.height) * pTextureInfo->height) / atlasHeight;
 
-                       __transform.matrix[3][0] = 0.0f;
-                       __transform.matrix[3][1] = 0.0f;
+                                       __pVertices[18] = (pTextureInfo->x + (element.__contentBounds.x + element.__contentBounds.width) * pTextureInfo->width) / atlasWidth;
+                                       __pVertices[19] = (pTextureInfo->y + (element.__contentBounds.y + element.__contentBounds.height) * pTextureInfo->height) / atlasHeight;
+
+                                       if (__pVertices[3] < 0.0f || __pVertices[4] < 0.0f || __pVertices[18] > 1.0f || __pVertices[19] > 1.0f)
+                                       {
+                                               __textureRepeated = true;
+                                       }
+                                       else
+                                       {
+                                               __textureRepeated = false;
+                                       }
+                               }
+                               else
+                               {
+                                       __pVertices[3]  = pTextureInfo->x / atlasWidth;
+                                       __pVertices[4]  = pTextureInfo->y / atlasHeight;
+
+                                       __pVertices[8]  = (pTextureInfo->x + pTextureInfo->width) / atlasWidth;
+                                       __pVertices[9]  = pTextureInfo->y / atlasHeight;
+
+                                       __pVertices[13] = pTextureInfo->x / atlasWidth;
+                                       __pVertices[14] = (pTextureInfo->y + pTextureInfo->height) / atlasHeight;
+
+                                       __pVertices[18] = (pTextureInfo->x + pTextureInfo->width) / atlasWidth;
+                                       __pVertices[19] = (pTextureInfo->y + pTextureInfo->height) / atlasHeight;
+                               }
+                       }
+                       else
+                       {
+                               if (element.__useContentBounds)
+                               {
+                                       __pVertices[3]  = ((element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[4]  = ((element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[8]  = ((element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[9]  = ((element.__contentBounds.y + __visibleRect.Top() / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[13] = ((element.__contentBounds.x + __visibleRect.Left() / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[14] = ((element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[18] = ((element.__contentBounds.x + (__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * element.__contentBounds.width) * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[19] = ((element.__contentBounds.y + (__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * element.__contentBounds.height) * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       if (__pVertices[3] < 0.0f || __pVertices[4] < 0.0f || __pVertices[18] > 1.0f || __pVertices[19] > 1.0f)
+                                       {
+                                               __textureRepeated = true;
+                                       }
+                                       else
+                                       {
+                                               __textureRepeated = false;
+                                       }
+                               }
+                               else
+                               {
+                                       __pVertices[3]  = (__visibleRect.Left() / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[4]  = (__visibleRect.Top() / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[8]  = ((__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[9]  = (__visibleRect.Top() / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[13] = (__visibleRect.Left() / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[14] = ((__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+
+                                       __pVertices[18] = ((__visibleRect.Left() + __visibleRect.Width()) / __bounds.Width() * pTextureInfo->width + pTextureInfo->x) / atlasWidth;
+                                       __pVertices[19] = ((__visibleRect.Top() + __visibleRect.Height()) / __bounds.Height() * pTextureInfo->height + pTextureInfo->y) / atlasHeight;
+                               }
+                       }
                }
+#endif
        }
        else
        {
-               if (__useTransform)
+               if (__useStencil)
                {
-                       __pVertices[0] = __visibleRect.Left();
-                       __pVertices[1] = __visibleRect.Top();
-                       __pVertices[2] = 0.0f;
-
-                       __pVertices[5] = __visibleRect.Left() + __visibleRect.Width();
-                       __pVertices[6] = __visibleRect.Top();
-                       __pVertices[7] = 0.0f;
-
-                       __pVertices[10] = __visibleRect.Left();
-                       __pVertices[11] = __visibleRect.Top() + __visibleRect.Height();
-                       __pVertices[12] = 0.0f;
+                       vertexX[0] = 0.0f;
+                       vertexX[1] = __bounds.Width();
 
-                       __pVertices[15] = __visibleRect.Left() + __visibleRect.Width();
-                       __pVertices[16] = __visibleRect.Top() + __visibleRect.Height();
-                       __pVertices[17] = 0.0f;
+                       vertexY[0] = 0.0f;
+                       vertexY[1] = __bounds.Height();
                }
                else
                {
-                       __pVertices[0] = __transform.matrix[3][0] + __visibleRect.Left();
-                       __pVertices[1] = __transform.matrix[3][1] + __visibleRect.Top();
-                       __pVertices[2] = 0.0f;
+                       vertexX[0] = __visibleRect.Left();
+                       vertexX[1] = __visibleRect.Right();
 
-                       __pVertices[5] = __transform.matrix[3][0] + __visibleRect.Left() + __visibleRect.Width();
-                       __pVertices[6] = __transform.matrix[3][1] + __visibleRect.Top();
-                       __pVertices[7] = 0.0f;
+                       vertexY[0] = __visibleRect.Top();
+                       vertexY[1] = __visibleRect.Bottom();
+               }
 
-                       __pVertices[10] = __transform.matrix[3][0] + __visibleRect.Left();
-                       __pVertices[11] = __transform.matrix[3][1] + __visibleRect.Top() + __visibleRect.Height();
-                       __pVertices[12] = 0.0f;
+               countX = countY = 2;
+       }
 
-                       __pVertices[15] = __transform.matrix[3][0] + __visibleRect.Left() + __visibleRect.Width();
-                       __pVertices[16] = __transform.matrix[3][1] + __visibleRect.Top() + __visibleRect.Height();
-                       __pVertices[17] = 0.0f;
+       if (element.__decomposedMatrixToTop.GetMatrixType() >= MATRIX4_Scale || __pMesh)
+       {
+               __useTransform = true;
+       }
+       else
+       {
+               __useTransform = false;
 
-                       __transform.matrix[3][0] = 0.0f;
-                       __transform.matrix[3][1] = 0.0f;
+               for (i = 0; i < countX; i++)
+               {
+                       vertexX[i] += __transform.matrix[3][0];
+               }
+
+               for (i = 0; i < countY; i++)
+               {
+                       vertexY[i] += __transform.matrix[3][1];
                }
+
+               __visibleRect.OffsetRect(__transform.matrix[3][0], __transform.matrix[3][1]);
+
+               __transform.matrix[3][0] = 0.0f;
+               __transform.matrix[3][1] = 0.0f;
        }
 
-       ShaderProgram* pShaderProgram = element.GetSharedData().geometry.GetShaderProgram();
+       vertexCount = countX * countY;
+       indexCount = (countX - 1) * (countY - 1) * 6;
 
-       if (unlikely(pShaderProgram))
+       AllocateVertexBuffer(vertexCount, indexCount);
+
+       // set vertex buffer
+       for (int y = 0; y < countY; y++)
        {
-               if (!__pShaderProgram || !pShaderProgram->Equals(*__pShaderProgram))
+               for (int x = 0; x < countX; x++)
                {
-                       if (__pShaderProgram)
-                       {
-                               delete __pShaderProgram;
-                               __pShaderProgram = null;
-                       }
-
-                       __pShaderProgram = new (std::nothrow) ShaderProgram(*pShaderProgram);
-                       SysAssertf(__pShaderProgram, "failed to create shader program");
+                       // x, y, z
+                       __pVertices[index++] = vertexX[x];
+                       __pVertices[index++] = vertexY[y];
+                       __pVertices[index++] = 0.0f;
+
+                       // s, t
+                       __pVertices[index++] = texX[x];
+                       __pVertices[index++] = texY[y];
                }
        }
-       else
+
+       index = 0;
+
+       // set index buffer
+       for (int y = 0; y < countY - 1; y++)
        {
-               if (__pShaderProgram)
+               i = y * countX;
+
+               for (int x = 0; x < countX - 1; x++)
                {
-                       delete __pShaderProgram;
-                       __pShaderProgram = null;
+                       __pIndices[index++] = i;
+                       __pIndices[index++] = i + 1;
+                       __pIndices[index++] = i + countX;
+
+                       __pIndices[index++] = i + 1;
+                       __pIndices[index++] = i + countX;
+                       __pIndices[index++] = i + countX + 1;
+
+                       i++;
                }
        }
+}
 
-       if (__pMesh || __useTransform || __useStencil || __pFilter)
-       {
-               __findItemInQueue = false;
-       }
-       else
+bool
+_GlNode::AllocateVertexBuffer(int vertexCount, int indexCount)
+{
+       if (__vertexCount != vertexCount)
        {
-               __findItemInQueue = true;
-       }
+               if (__pVertices)
+               {
+                       delete [] __pVertices;
+                       __pVertices = null;
+               }
 
-       __syncNeeded = false;
+               __pVertices = new (std::nothrow) float[vertexCount * 5];
+               SysTryReturnResult(NID_UI_ANIM, __pVertices, false, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 
-       return E_SUCCESS;
-}
+               if (__pIndices)
+               {
+                       delete [] __pIndices;
+                       __pIndices = null;
+               }
 
-VisualElementSurface*
-_GlNode::GetSurface(void) const
-{
-       return __pSurface;
+               __pIndices = new (std::nothrow) unsigned short int[indexCount];
+               SysTryReturnResult(NID_UI_ANIM, __pIndices, false, "[E_OUT_OF_MEMORY] Memory allocation failed.");
+
+               __vertexCount = vertexCount;
+               __indexCount = indexCount;
+       }
+
+       return true;
 }
 
 }}}            // Tizen::Ui::Animations

diff --git a/src/ui/animations/FUiAnim_GlNode.h b/src/ui/animations/FUiAnim_GlNode.h
index e5d097f..44ed010 100644 (file)
--- a/src/ui/animations/FUiAnim_GlNode.h
+++ b/src/ui/animations/FUiAnim_GlNode.h
@@ -77,6 +77,10 @@ public:
        result SyncStatus(VisualElementSurface* pSurface, _VisualElementImpl& element);
 
 private:
+       void CalcVertexCoordinates(_VisualElementImpl& element);
+       bool AllocateVertexBuffer(int vertexCount, int indexCount);
+
+private:
        _GlNode(const _GlNode& rhs);              // no impl.
        _GlNode& operator =(const _GlNode& rhs);  // no impl.
 
@@ -107,7 +111,10 @@ private:
        _Colorf __backgroundColor;
        _Colorf __objectColor;  // These color values are premultiplied by alpha.
 
-       float __pVertices[20];  // (vertex (x, y, z), texture (s, t)) * 4
+       float* __pVertices;             // (vertex (x, y, z), texture (s, t))
+       unsigned short int* __pIndices;
+       int __vertexCount;
+       int __indexCount;
 
        _NativeLayer* __pLayer;
        Tizen::Base::Collection::ArrayList __activeLight;

diff --git a/src/ui/animations/FUiAnim_GlRenderManager.cpp b/src/ui/animations/FUiAnim_GlRenderManager.cpp
index e3d4864..1edb604 100644 (file)
--- a/src/ui/animations/FUiAnim_GlRenderManager.cpp
+++ b/src/ui/animations/FUiAnim_GlRenderManager.cpp
@@ -61,7 +61,6 @@
 #include "FUiAnimVisualElementFilter.h"
 #include "FUiAnim_VisualElementFilterImpl.h"
 
-
 #include "FUiAnim_GlLoader.h"
 #include "FUiAnim_Debug.h"
 
@@ -104,11 +103,10 @@ using namespace Tizen::Ui::Animations;
 #define        CHECK_GL_CONTEXT()      ASSERT(__pGlContext, "Invalid render manager status(no context)");
 #endif
 
-#define VERTEX_BUFFER_STRIDE           3
-#define TEX_COORD_BUFFER_STRIDE                2
-
-#define        VE_RENDER_OBJECT_VERTEX_COUNT_MAX       120
+#define        VE_RENDER_OBJECT_VERTEX_COUNT_MAX       100
+#define VE_RENDER_OBJECT_INDEX_COUNT_MAX       150
 #define        VE_RENDER_QUEUE_COUNT_MAX                       100
+
 #define OFFSET (UNIFORM_VEC3_LIGHT_ATTENUATION - UNIFORM_INT_LIGHT_TYPE + 1)
 
 #define SURF_IMPL(__SURF)      static_cast<_GlVisualElementSurfaceImpl*>(_VisualElementSurfaceImpl::GetInstance(__SURF))
@@ -141,7 +139,7 @@ _GlRenderQueue::_RenderObject::_RenderObject(void)
        , __pMaterial(null)
        , __pFilter(null)
        , __pVertexBuffer(null)
-       , __pTexCoordBuffer(null)
+       , __pIndexBuffer(null)
        , __geoType(0)
        , __pVertices(null)
        , __pTexCoords(null)
@@ -149,6 +147,9 @@ _GlRenderQueue::_RenderObject::_RenderObject(void)
        , __pNormals(null)
        , __pIndices(null)
        , __vertexCount(0)
+       , __indexCount(0)
+       , __vertexStride(0)
+       , __texCoordStride(0)
        , __pProgram(null)
        , __aPosition(-1)
        , __aTexCoord(-1)
@@ -183,17 +184,17 @@ _GlRenderQueue::_RenderObject::Construct(void)
 {
        result r = E_SUCCESS;
 
-       __pVertexBuffer = new (std::nothrow) float[VE_RENDER_OBJECT_VERTEX_COUNT_MAX * VERTEX_BUFFER_STRIDE];
+       __pVertexBuffer = new (std::nothrow) float[VE_RENDER_OBJECT_VERTEX_COUNT_MAX * 5];
        SysTryCatch(NID_UI_ANIM, __pVertexBuffer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 
-       __pTexCoordBuffer = new (std::nothrow) float[VE_RENDER_OBJECT_VERTEX_COUNT_MAX * TEX_COORD_BUFFER_STRIDE];
-       SysTryCatch(NID_UI_ANIM, __pTexCoordBuffer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
+       __pIndexBuffer = new (std::nothrow) unsigned short int[VE_RENDER_OBJECT_INDEX_COUNT_MAX];
+       SysTryCatch(NID_UI_ANIM, __pIndexBuffer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 
        return E_SUCCESS;
 
 CATCH:
        delete [] __pVertexBuffer;
-       delete [] __pTexCoordBuffer;
+       delete [] __pIndexBuffer;
 
        return r;
 }
@@ -204,8 +205,8 @@ _GlRenderQueue::_RenderObject::Release(void)
        delete [] __pVertexBuffer;
        __pVertexBuffer = null;
 
-       delete [] __pTexCoordBuffer;
-       __pTexCoordBuffer = null;
+       delete [] __pIndexBuffer;
+       __pIndexBuffer = null;
 
        return E_SUCCESS;
 }
@@ -382,7 +383,6 @@ _GlRenderQueue::_RenderObject::GetShaderProgram(int type)
 void
 _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsigned int stencilIndex, bool colorMask)
 {
-       int vertexIndex = 0, textureIndex = 0;
        int shaderType = 0;
        static _GlCompositor* pCompositor  = null;
 
@@ -449,38 +449,19 @@ _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsign
                __useDepthTest = false;
                __pMesh = null;
 
-               __bounds.SetRect(pNode->__pVertices[0], pNode->__pVertices[1],
-                               pNode->__pVertices[15] - pNode->__pVertices[0], pNode->__pVertices[16] - pNode->__pVertices[1]);
-
-               __vertexCount = 6;
-
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[0];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[1];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[2];
+               __bounds = pNode->__visibleRect;
 
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[5];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[6];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[7];
-
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[10];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[11];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[12];
-
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[5];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[6];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[7];
-
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[10];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[11];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[12];
+               __geoType = GL_TRIANGLES;
 
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[15];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[16];
-               __pVertexBuffer[vertexIndex++] = pNode->__pVertices[17];
+               memcpy(__pVertexBuffer, pNode->__pVertices, pNode->__vertexCount * 5 * sizeof(float));
+               memcpy(__pIndexBuffer, pNode->__pIndices, pNode->__indexCount * sizeof(unsigned short int));
 
-               __geoType = GL_TRIANGLES;
+               __vertexStride = 5 * sizeof(float);
+               __vertexCount = pNode->__vertexCount;
+               __indexCount = pNode->__indexCount;
 
                __pVertices = __pVertexBuffer;
+               __pIndices = __pIndexBuffer;
 
                if (pNode->__pSurface)
                {
@@ -505,25 +486,8 @@ _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsign
                                __isTexUpdated = false;
                        }
 
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[3];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[4];
-
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[8];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[9];
-
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[13];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[14];
-
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[8];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[9];
-
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[13];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[14];
-
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[18];
-                       __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[19];
-
-                       __pTexCoords = __pTexCoordBuffer;
+                       __pTexCoords = &(__pVertexBuffer[3]);
+                       __texCoordStride = 5 * sizeof(float);
 
                        if (_FloatCompare(pNode->__opacity, 1.0f))
                        {
@@ -597,10 +561,11 @@ _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsign
                        return;
                }
 
-               __pVertices = pMeshImpl->__pVertices;
-
                __vertexCount = pMeshImpl->__countOfVertex;
 
+               __pVertices = pMeshImpl->__pVertices;
+               __vertexStride = 3 * sizeof(float);
+
                if (pNode->__pSurface && pMeshImpl->IsTextureCoordinateEnabled())
                {
                        __pSurfaceInfo = SURF_IMPL(*pNode->__pSurface);
@@ -625,6 +590,7 @@ _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsign
                        }
 
                        __pTexCoords = pMeshImpl->__pTexCoordinates;
+                       __texCoordStride = 2 * sizeof(float);
 
                        if (_FloatCompare(pNode->__opacity, 1.0f))
                        {
@@ -737,7 +703,8 @@ _GlRenderQueue::_RenderObject::SetObject(_GlNode* pNode, bool useStencil, unsign
        {
                __pProgram = GetShaderProgram(shaderType);
        }
-       if(__pProgram)
+
+       if (__pProgram)
        {
                __pProgram =  new ShaderProgram(*__pProgram);
 
@@ -835,62 +802,19 @@ _GlRenderQueue::_RenderObject::ResetObject(void)
 void
 _GlRenderQueue::_RenderObject::AddVertices(_GlNode* pNode)
 {
-       int vertexIndex, textureIndex;
-
-       vertexIndex = __vertexCount * VERTEX_BUFFER_STRIDE;
-       textureIndex = __vertexCount * TEX_COORD_BUFFER_STRIDE;
-
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[0];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[1];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[2];
-
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[5];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[6];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[7];
-
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[10];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[11];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[12];
-
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[5];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[6];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[7];
+       float* pVertexBuffer = __pVertexBuffer + __vertexCount * 5;
 
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[10];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[11];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[12];
+       memcpy(pVertexBuffer, pNode->__pVertices, pNode->__vertexCount * 5 * sizeof(float));
 
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[15];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[16];
-       __pVertexBuffer[vertexIndex++] = pNode->__pVertices[17];
-
-       if (pNode->__pSurface)
+       for (int i = 0; i < pNode->__indexCount; i++)
        {
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[3];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[4];
-
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[8];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[9];
-
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[13];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[14];
-
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[8];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[9];
-
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[13];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[14];
-
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[18];
-               __pTexCoordBuffer[textureIndex++] = pNode->__pVertices[19];
+               __pIndexBuffer[__indexCount + i] = pNode->__pIndices[i] + __vertexCount;
        }
 
-       __vertexCount += 6;
-
-       _Rectanglef bounds = _Rectanglef(pNode->__pVertices[0], pNode->__pVertices[1],
-                       pNode->__pVertices[15] - pNode->__pVertices[0], pNode->__pVertices[16] - pNode->__pVertices[1]);
+       __vertexCount += pNode->__vertexCount;
+       __indexCount += pNode->__indexCount;
 
-       __bounds.Union(bounds);
+       __bounds.Union(pNode->__visibleRect);
 
        return;
 }
@@ -971,7 +895,8 @@ _GlRenderQueue::FindRenderObject(_GlNode* pNode)
 //                     && __pRenderQueue[index].__pMaterial == pNode->__pMaterial      // TODO: check light
                        )
                {
-                       if (unlikely(__pRenderQueue[index].__vertexCount >= VE_RENDER_OBJECT_VERTEX_COUNT_MAX - 6))
+                       if (unlikely(__pRenderQueue[index].__vertexCount >= VE_RENDER_OBJECT_VERTEX_COUNT_MAX - pNode->__vertexCount
+                                                || __pRenderQueue[index].__indexCount >= VE_RENDER_OBJECT_INDEX_COUNT_MAX - pNode->__indexCount))
                        {
                                PRINT("_GlRenderManager::FindRenderObject: Vertex buffer is full. Use next slot.\n");
                                return -1;
@@ -981,7 +906,7 @@ _GlRenderQueue::FindRenderObject(_GlNode* pNode)
                        return index;
                }
 
-               if (__pRenderQueue[index].__bounds.IsIntersected(bounds))
+               if (__pRenderQueue[index].__bounds.IsIntersected(pNode->__visibleRect))
                {
                        return -1;
                }
@@ -1118,6 +1043,14 @@ _GlRenderManager::_GlRenderManager(void)
 //     __pTempNode->__pVertices[18] = 1.0f;
 //     __pTempNode->__pVertices[19] = 1.0f;
 
+       // index buffer
+//     __pTempNode->__pIndices[0] = 0;
+//     __pTempNode->__pIndices[1] = 1;
+//     __pTempNode->__pIndices[2] = 2;
+//     __pTempNode->__pIndices[3] = 1;
+//     __pTempNode->__pIndices[4] = 2;
+//     __pTempNode->__pIndices[5] = 3;
+
 //     __pTempNode->__transform.SetAsIdentity();
 //     __pTempNode->__useTransform = false;
 //     __pTempNode->__textureRepeated = false;
@@ -1518,8 +1451,8 @@ _GlRenderManager::CommandHandlerFlush(void)//(_GlLayer* pLayer)
                pGlContext->UseShaderProgram(pProgramImpl);
 
                // Set attribute
-               glVertexAttribPointer(pRenderObjects[i].__aPosition, 3, GL_FLOAT, GL_FALSE, VERTEX_BUFFER_STRIDE * sizeof(float), pRenderObjects[i].__pVertices);
-               glVertexAttribPointer(pRenderObjects[i].__aTexCoord, 2, GL_FLOAT, GL_FALSE, TEX_COORD_BUFFER_STRIDE * sizeof(float), pRenderObjects[i].__pTexCoords);
+               glVertexAttribPointer(pRenderObjects[i].__aPosition, 3, GL_FLOAT, GL_FALSE, pRenderObjects[i].__vertexStride, pRenderObjects[i].__pVertices);
+               glVertexAttribPointer(pRenderObjects[i].__aTexCoord, 2, GL_FLOAT, GL_FALSE, pRenderObjects[i].__texCoordStride, pRenderObjects[i].__pTexCoords);
                glVertexAttribPointer(pRenderObjects[i].__aColor, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), pRenderObjects[i].__pColors);
                glVertexAttribPointer(pRenderObjects[i].__aNormal, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), pRenderObjects[i].__pNormals);
 

diff --git a/src/ui/animations/FUiAnim_GlRenderManager.h b/src/ui/animations/FUiAnim_GlRenderManager.h
index 8401a68..8cff117 100644 (file)
--- a/src/ui/animations/FUiAnim_GlRenderManager.h
+++ b/src/ui/animations/FUiAnim_GlRenderManager.h
@@ -39,7 +39,6 @@
 #include "FUiAnim_ShaderProgramGenerator.h"
 #include "FUiAnim_InternalTypes.h"
 
-
 #define MAX_LIGHT_COUNT 8
 
 namespace Tizen { namespace Ui { namespace Animations
@@ -272,7 +271,7 @@ public:
 
 
                float* __pVertexBuffer;
-               float* __pTexCoordBuffer;
+               unsigned short int* __pIndexBuffer;
 
                unsigned int __geoType;
 
@@ -284,6 +283,8 @@ public:
 
                int __vertexCount;
                int __indexCount;
+               int __vertexStride;
+               int __texCoordStride;
 
                ShaderProgram* __pProgram;
 

diff --git a/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.cpp b/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.cpp
index c75dfd6..308dc9e 100644 (file)
--- a/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.cpp
+++ b/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.cpp
@@ -46,6 +46,7 @@
 
 //#define PRINT(...) fprintf(stderr, __VA_ARGS__)
 #define PRINT(...)
+
 #define TEXTURE_MIN_SIZE  120
 #define DEFAULT_BPP_32 32
 
@@ -62,6 +63,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        : _VisualElementSurfaceImpl(size)
        , __textureInfo()
        , __pLayer(null)
+       , __imageName()
 {
        ClearLastResult();
 
@@ -90,6 +92,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        __textureInfo.fboId = 0;
        __textureInfo.depthBufferId = 0;
        __textureInfo.stencilBufferId = 0;
+       __textureInfo.useBorder = false;
 
 #ifdef VE_USE_GL_MULTI_CONTEXT
        __textureInfo.pGlContext = (_GlContext*)__pLayer->GetContext();
@@ -139,6 +142,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
     : _VisualElementSurfaceImpl(size)
        , __textureInfo()
        , __pLayer(null)
+       , __imageName()
 {
        ClearLastResult();
 
@@ -167,7 +171,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        __textureInfo.fboId = 0;
        __textureInfo.depthBufferId = 0;
        __textureInfo.stencilBufferId = 0;
-
+       __textureInfo.useBorder = false;
 
 #ifdef VE_USE_GL_MULTI_CONTEXT
        __textureInfo.pGlContext = (_GlContext*)__pLayer->GetContext();
@@ -183,7 +187,6 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        {
                SysAssertf(false, "Cannot initialize GL texture for surface");
        }
-
 }
 
 #ifndef BUILD_UI_CORE
@@ -191,6 +194,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        : _VisualElementSurfaceImpl(FloatDimension(bitmap.GetWidthF(),bitmap.GetHeightF()))
        , __textureInfo()
        , __pLayer(null)
+       , __imageName()
 {
        ClearLastResult();
 
@@ -203,6 +207,7 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        __textureInfo.fboId = 0;
        __textureInfo.depthBufferId = 0;
        __textureInfo.stencilBufferId = 0;
+       __textureInfo.useBorder = false;
 
 #ifdef VE_USE_GL_MULTI_CONTEXT
        __textureInfo.pGlContext = (_GlContext*)__pLayer->GetContext();
@@ -214,7 +219,6 @@ _GlVisualElementSurfaceImpl::_GlVisualElementSurfaceImpl(const Handle layer, con
        __textureInfo.type = TEXTURE_NORMAL;
 //#endif
 
-
     // WARNING: By default, we assume 32bit-packed stride (for Osp 2.0 compatibility and etc.)
        Tizen::Graphics::Bitmap* pBitmap = _BitmapImpl::CloneN(bitmap);
 

diff --git a/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.h b/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.h
index 4024657..c5b6ac1 100644 (file)
--- a/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.h
+++ b/src/ui/animations/FUiAnim_GlVisualElementSurfaceImpl.h
@@ -69,6 +69,12 @@ struct TextureInfo
        void* atlas;
        int atlasId;
        int atlasIndex;
+
+       bool useBorder;
+       int leftBorder;
+       int rightBorder;
+       int topBorder;
+       int bottomBorder;
 };
 
 class _GlVisualElementSurfaceImpl