lvfulong
309 lines
11 KiB
C++
309 lines
11 KiB
C++
/**
|
|
@file JCGlobalValue.cpp
|
|
@brief
|
|
@author James
|
|
@version 1.0
|
|
@date 2018_5_30
|
|
*/
|
|
|
|
#include "JCGlobalValue.h"
|
|
#include <util/Log.h>
|
|
#include <math/Matrix32.h>
|
|
#include <memory.h>
|
|
#include <string.h>
|
|
#if __APPLE__
|
|
#include <OpenGLES/ES3/gl.h>
|
|
#include <OpenGLES/ES3/glext.h>
|
|
#else
|
|
#include <GLES3/gl3.h>
|
|
#include <EGL/egl.h>
|
|
#include <EGL/eglext.h>
|
|
#endif
|
|
|
|
//------------------------------------------------------------------------------
|
|
namespace laya
|
|
{
|
|
#define SAVE_DATA_NUM 20
|
|
JCGlobalValue::JCGlobalValue()
|
|
{
|
|
m_nStrideSize = 0;
|
|
m_pCurrentValue = NULL;
|
|
m_pBuffer = NULL;
|
|
m_nCurrentBufferPos = 0;
|
|
m_nSaveDataSize = 0;
|
|
m_pDefaultValue = NULL;
|
|
}
|
|
JCGlobalValue::~JCGlobalValue()
|
|
{
|
|
for (int i = 0, n = m_vValueDesc.size(); i < n; i++)
|
|
{
|
|
delete m_vValueDesc[i];
|
|
m_vValueDesc[i] = NULL;
|
|
}
|
|
m_vValueDesc.clear();
|
|
if (m_pBuffer)
|
|
{
|
|
delete[] m_pBuffer;
|
|
m_pBuffer = NULL;
|
|
}
|
|
if (m_pDefaultValue)
|
|
{
|
|
delete m_pDefaultValue;
|
|
m_pDefaultValue = NULL;
|
|
}
|
|
m_pCurrentValue = NULL;
|
|
}
|
|
ValueDesc* JCGlobalValue::getValueDesc(int nID)
|
|
{
|
|
return m_vValueDesc[nID];
|
|
}
|
|
void JCGlobalValue::createDefaultValue()
|
|
{
|
|
//计算总体的大小
|
|
ValueDesc* pLast = m_vValueDesc[m_vValueDesc.size() - 1];
|
|
m_nStrideSize = pLast->m_nOffset + pLast->m_nDataSize;
|
|
|
|
//分配好默认的值
|
|
m_pDefaultValue = new char[m_nStrideSize];
|
|
for (int i = 0, n = m_vValueDesc.size(); i < n; i++)
|
|
{
|
|
ValueDesc* pValueDesc = m_vValueDesc[i];
|
|
memcpy(m_pDefaultValue + pValueDesc->m_nOffset, pValueDesc->m_pDefaultValue, pValueDesc->m_nDataSize);
|
|
//这段数据可以不要了
|
|
delete pValueDesc->m_pDefaultValue;
|
|
pValueDesc->m_pDefaultValue = NULL;
|
|
}
|
|
}
|
|
void JCGlobalValue::clone(JCGlobalValue* pValueData)
|
|
{
|
|
m_nStrideSize = pValueData->m_nStrideSize;
|
|
m_pDefaultValue = new char[m_nStrideSize];
|
|
memcpy(m_pDefaultValue,pValueData->m_pDefaultValue,m_nStrideSize);
|
|
int n = pValueData->m_vValueDesc.size();
|
|
m_vValueDesc.resize(n);
|
|
for (int i = VALUE_INTERIOR_TYPE_COUNT; i < n; i++)
|
|
{
|
|
ValueDesc* pTemp = pValueData->m_vValueDesc[i];
|
|
ValueDesc* pValueDesc = new ValueDesc();
|
|
pValueDesc->m_nModifyType = pTemp->m_nModifyType;
|
|
pValueDesc->m_nDataType = pTemp->m_nDataType;
|
|
pValueDesc->m_nSize = pTemp->m_nSize;
|
|
pValueDesc->m_nDataSize = pTemp->m_nDataSize;
|
|
pValueDesc->m_nOffset = pTemp->m_nOffset;
|
|
pValueDesc->m_pDefaultValue = NULL;
|
|
m_vValueDesc[i] = pValueDesc;
|
|
}
|
|
//分配整体的buffer
|
|
m_nSaveDataSize = SAVE_DATA_NUM * m_nStrideSize;
|
|
m_pBuffer = new char[m_nSaveDataSize];
|
|
reset();
|
|
}
|
|
void JCGlobalValue::endValueDefine()
|
|
{
|
|
createDefaultValue();
|
|
//分配整体的buffer
|
|
m_nSaveDataSize = SAVE_DATA_NUM * m_nStrideSize;
|
|
m_pBuffer = new char[m_nSaveDataSize];
|
|
reset();
|
|
}
|
|
int JCGlobalValue::addValueDefine(VALUE_MODIFY_TYPE nModifyType, int nDataType, int nSize, char* pDefaultValue,int nDefaultValueSize)
|
|
{
|
|
ValueDesc* pValueDesc = new ValueDesc();
|
|
pValueDesc->m_nModifyType = nModifyType;
|
|
pValueDesc->m_nSize = nSize;
|
|
pValueDesc->m_nDataType = nDataType;
|
|
pValueDesc->m_nDataSize = nSize * 4;
|
|
//new 默认值
|
|
pValueDesc->m_pDefaultValue = new char[pValueDesc->m_nDataSize];
|
|
memset(pValueDesc->m_pDefaultValue, 0, pValueDesc->m_nDataSize);
|
|
if (nDefaultValueSize == pValueDesc->m_nDataSize)
|
|
{
|
|
memcpy(pValueDesc->m_pDefaultValue, pDefaultValue, pValueDesc->m_nDataSize);
|
|
}
|
|
int nVectorSize = m_vValueDesc.size();
|
|
if (nVectorSize == 0)
|
|
{
|
|
pValueDesc->m_nOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
ValueDesc* pLast = m_vValueDesc[nVectorSize - 1];
|
|
pValueDesc->m_nOffset = pLast->m_nOffset + pLast->m_nDataSize;
|
|
}
|
|
m_vValueDesc.push_back(pValueDesc);
|
|
return nVectorSize;
|
|
}
|
|
bool JCGlobalValue::reset()
|
|
{
|
|
memset(m_pBuffer, 0, m_nSaveDataSize);
|
|
//放入一段默认的
|
|
memcpy(m_pBuffer, m_pDefaultValue, m_nStrideSize);
|
|
//当前的data指向默认
|
|
m_pCurrentValue = m_pBuffer;
|
|
m_nCurrentBufferPos = 0;
|
|
return true;
|
|
}
|
|
bool JCGlobalValue::save()
|
|
{
|
|
m_nCurrentBufferPos += m_nStrideSize;
|
|
if (m_nCurrentBufferPos >= m_nSaveDataSize )
|
|
{
|
|
int nEnlargeSize = SAVE_DATA_NUM * m_nStrideSize;
|
|
char* pBuffer = new char[m_nSaveDataSize + nEnlargeSize];
|
|
memset(pBuffer, 0, m_nSaveDataSize + nEnlargeSize);
|
|
memcpy(pBuffer, m_pBuffer, m_nSaveDataSize);
|
|
m_nSaveDataSize += nEnlargeSize;
|
|
memcpy(pBuffer + m_nCurrentBufferPos, m_pCurrentValue, m_nStrideSize);
|
|
if (m_pBuffer)
|
|
{
|
|
delete[] m_pBuffer;
|
|
m_pBuffer = NULL;
|
|
}
|
|
m_pBuffer = pBuffer;
|
|
}
|
|
else
|
|
{
|
|
memcpy(m_pBuffer + m_nCurrentBufferPos, m_pCurrentValue, m_nStrideSize);
|
|
}
|
|
//重新指向新的位置
|
|
m_pCurrentValue = m_pBuffer + m_nCurrentBufferPos;
|
|
return true;
|
|
}
|
|
bool JCGlobalValue::restore()
|
|
{
|
|
if (m_nCurrentBufferPos > 0)
|
|
{
|
|
m_nCurrentBufferPos -= m_nStrideSize;
|
|
m_pCurrentValue = m_pBuffer + m_nCurrentBufferPos;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
LOGE("JCContextSaveData::restore save and restore don't make a pair.");
|
|
return false;
|
|
}
|
|
}
|
|
ValueDesc* JCGlobalValue::setValue(int nValueID, char* pData, VALUE_OPERATE_TYPE nOpreateType)
|
|
{
|
|
ValueDesc* pValueDesc = m_vValueDesc[nValueID];
|
|
if (pValueDesc->m_nDataType == GL_INT )
|
|
{
|
|
int* iCurData = (int*)(m_pCurrentValue + pValueDesc->m_nOffset);
|
|
int* iData = (int*)pData;
|
|
switch (nOpreateType)
|
|
{
|
|
case VALUE_OPERATE_ADD:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)iCurData[i] *= iData[i];
|
|
break;
|
|
case VALUE_OPERATE_SUB:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)iCurData[i] -= iData[i];
|
|
break;
|
|
case VALUE_OPERATE_MUL:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)iCurData[i] *= iData[i];
|
|
break;
|
|
case VALUE_OPERATE_DIV:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)iCurData[i] /= iData[i];
|
|
break;
|
|
case VALUE_OPERATE_SET:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)iCurData[i] = iData[i];
|
|
break;
|
|
case VALUE_OPERATE_BYTE4_COLOR_MUL:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)
|
|
{
|
|
int color1 = iCurData[i];
|
|
int color2 = iData[i];
|
|
int b = color1 & 255;
|
|
int g = (color1 >> 8) & 255;
|
|
int r = (color1 >> 16) & 255;
|
|
int a = (color1 >> 24) & 255;
|
|
int b1 = color2 & 255;
|
|
int g1 = (color2 >> 8) & 255;
|
|
int r1 = (color2 >> 16) & 255;
|
|
int a1 = (color2 >> 24) & 255;
|
|
b *= b1 / 255.0f;
|
|
g *= g1 / 255.0f;
|
|
r *= r1 / 255.0f;
|
|
a *= a1 / 255.0f;
|
|
iCurData[i] = (a << 24) + (r << 16) + (g << 8) + b;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if (pValueDesc->m_nDataType == GL_FLOAT)
|
|
{
|
|
float* fCurData = (float*)(m_pCurrentValue + pValueDesc->m_nOffset);
|
|
float* fData = (float*)pData;
|
|
switch (nOpreateType)
|
|
{
|
|
case VALUE_OPERATE_ADD:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)fCurData[i] *= fData[i];
|
|
break;
|
|
case VALUE_OPERATE_SUB:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)fCurData[i] -= fData[i];
|
|
break;
|
|
case VALUE_OPERATE_MUL:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)fCurData[i] *= fData[i];
|
|
break;
|
|
case VALUE_OPERATE_DIV:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)fCurData[i] /= fData[i];
|
|
break;
|
|
case VALUE_OPERATE_SET:
|
|
for (int i = 0; i < pValueDesc->m_nSize; i++)fCurData[i] = fData[i];
|
|
break;
|
|
case VALUE_OPERATE_M2_MUL:
|
|
{
|
|
//TODO
|
|
}
|
|
break;
|
|
case VALUE_OPERATE_M3_MUL:
|
|
{
|
|
//TODO
|
|
}
|
|
break;
|
|
case VALUE_OPERATE_M4_MUL:
|
|
{
|
|
//TODO
|
|
}
|
|
break;
|
|
case VALUE_OPERATE_M32_MUL:
|
|
Matrix32::mul(fCurData, fData,fCurData);
|
|
break;
|
|
case VALUE_OPERATE_M32_TRANSLATE:
|
|
Matrix32::translate(fCurData, fData[0], fData[1]);
|
|
break;
|
|
case VALUE_OPERATE_M32_SCALE:
|
|
Matrix32::scale(fCurData, fData[0], fData[1]);
|
|
break;
|
|
case VALUE_OPERATE_M32_ROTATE:
|
|
Matrix32::rotate(fCurData, fData[0]);
|
|
break;
|
|
case VALUE_OPERATE_M32_SCALE_PIVOT:
|
|
Matrix32::translate(fCurData,fData[2], fData[3]);
|
|
Matrix32::scale(fCurData, fData[0], fData[1]);
|
|
Matrix32::translate(fCurData, -fData[2], -fData[3]);
|
|
break;
|
|
case VALUE_OPERATE_M32_ROTATE_PIVOT:
|
|
Matrix32::translate(fCurData, fData[1], fData[2]);
|
|
Matrix32::rotate(fCurData, fData[0]);
|
|
Matrix32::translate(fCurData, -fData[1], -fData[2]);
|
|
break;
|
|
case VALUE_OPERATE_M32_TRANSFORM_PIVOT:
|
|
Matrix32::translate(fCurData, fData[6], fData[7]);
|
|
Matrix32::mul(fCurData, fData, fCurData);
|
|
Matrix32::translate(fCurData, -fData[6], -fData[7]);
|
|
break;
|
|
}
|
|
}
|
|
return pValueDesc;
|
|
}
|
|
void JCGlobalValue::copyValue(int nValueID, char* pData, int nDataLength)
|
|
{
|
|
ValueDesc* pValueDesc = m_vValueDesc[nValueID];
|
|
memcpy(m_pCurrentValue + pValueDesc->m_nOffset, pData, nDataLength);
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------END FILE--------------------------------
|