/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and /or associated documentation files
 * (the "Materials "), to deal in the Materials without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Materials,
 * and to permit persons to whom the Materials are furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
 * THE USE OR OTHER DEALINGS IN THE MATERIALS.
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */

#include "GLESArray.h"
#include "glesInternal.h"
#include "GLESBuffer.h"
#include "GLESContext.h"

GLESArrayPointer::GLESArrayPointer() :
    m_pointer(NULL),
    m_stride(0),
    m_size(4),
    m_type(GL_FLOAT)
{
}

GLESArrayPointer::GLESArrayPointer(const void* pointer, int stride, int size, GLenum type) :
    m_pointer(static_cast<const char*>(pointer)),
    m_stride(stride),
    m_size(size),
    m_type(type)
{
}

GLESArray::GLESArray() :
    m_size(4),
    m_type(GL_FLOAT),
    m_stride(0),
    m_pointer(NULL),
    m_ownsData(false),
    m_buffer(NULL)
{
}

GLESArray::GLESArray(int size, GLenum type, int stride, void* pointer, const GLESBuffer* buffer, bool ownsData) :
    m_size(size),
    m_type(type),
    m_stride(stride),
    m_pointer(pointer),
    m_ownsData(ownsData),
    m_buffer(buffer)
{
}

GLESArray::~GLESArray()
{
    if(m_ownsData)
    {
        delete[] m_pointer;
    }
}

GLESArrayPointer GLESArray::ArrayPointer() const
{
	int stride;
	if(m_stride)
	{
		stride = m_stride;
	}
	else
	{
		switch(m_type)
		{
		case GL_BYTE:
			stride = sizeof(GLbyte);
			break;
		case GL_SHORT:
			stride = sizeof(GLshort);
			break;
		case GL_FLOAT:
			stride = sizeof(GLfloat);
			break;
		case GL_UNSIGNED_BYTE:
			stride = sizeof(GLubyte);
			break;
		default:
			GLES_ASSERT(false);
		}
	}
	return GLESArrayPointer(m_pointer, m_size * stride, m_size, m_type);
}

GLESArray* GLESArray::Convert(int count) const
{
	if(m_type == GL_BYTE)
	{
		const char* oldPtr = NULL;
		unsigned int size = m_size;
		if(m_buffer)
		{
			oldPtr = static_cast<const char*>(m_buffer->data);
			size = GLES_MIN(m_buffer->size / sizeof(GLbyte), count * size);
		}
		else
		{
			oldPtr = static_cast<const char*>(m_pointer);
		}

		GLshort* newArr = GLES_NEW GLshort[count * m_size];
		if(newArr == NULL)
		{
			return NULL;
		}
		int stride = m_stride ? m_stride : sizeof(GLbyte);
		for(unsigned int i = 0; i < count * size; i++)
		{
			newArr[i] = *reinterpret_cast<const GLbyte*>(oldPtr);
			oldPtr += stride;
		}
		return GLES_NEW GLESArray(size, GL_SHORT, 0, newArr, NULL, true);
	}
	else if(m_type == GL_FIXED)
	{
		const char* oldPtr = NULL;
		unsigned int size = m_size;
		if(m_buffer)
		{
			oldPtr = static_cast<const char*>(m_buffer->data);
			size = GLES_MIN(m_buffer->size / sizeof(GLfixed), count * size);
		}
		else
		{
			oldPtr = static_cast<const char*>(m_pointer);
		}

		GLfloat* newArr = GLES_NEW GLfloat[count * m_size];
		if(newArr == NULL)
		{
			return NULL;
		}
		int stride = m_stride ? m_stride : sizeof(GLfixed);
		for(unsigned int i = 0; i < count * size; i++)
		{
			newArr[i] = X_TO_F(*reinterpret_cast<const GLfixed*>(oldPtr));
			oldPtr += stride;
		}
		return GLES_NEW GLESArray(size, GL_FLOAT, 0, newArr, NULL, true);
	}
	else
	{
		return GLES_NEW GLESArray(m_size, m_type, m_stride, m_buffer ? m_buffer->data : m_pointer, NULL);
	}

    return NULL;
}