open source
This commit is contained in:
lvfulong
@@ -0,0 +1,144 @@
|
||||
/**
|
||||
@file JCImage.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
#include "JCImage.h"
|
||||
#include <util/Log.h>
|
||||
#include "JCImageManager.h"
|
||||
#include <util/JCCommonMethod.h>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
JCImage::JCImage()
|
||||
{
|
||||
m_pFileResManager = NULL;
|
||||
m_pImageManager = NULL;
|
||||
m_nID = 0;
|
||||
m_nTouchTime = 0;
|
||||
m_bPushBitmapData = false;
|
||||
m_bPremultiplyAlpha = false;
|
||||
}
|
||||
JCImage::~JCImage()
|
||||
{
|
||||
m_kBitmapData.releaseData();
|
||||
}
|
||||
void JCImage::setManager(void* pFileResManager, JCImageManager* pImageManager)
|
||||
{
|
||||
m_pFileResManager = (JCFileResManager*)pFileResManager;
|
||||
m_pImageManager = pImageManager;
|
||||
}
|
||||
void JCImage::setPremultiplyAlpha(bool bPremultiplyAlpha)
|
||||
{
|
||||
m_bPremultiplyAlpha = bPremultiplyAlpha;
|
||||
}
|
||||
int JCImage::getWidth()
|
||||
{
|
||||
return m_kBitmapData.m_nWidth;
|
||||
}
|
||||
int JCImage::getHeight()
|
||||
{
|
||||
return m_kBitmapData.m_nHeight;
|
||||
}
|
||||
char* JCImage::getImageData()
|
||||
{
|
||||
return m_kBitmapData.m_pImageData;
|
||||
}
|
||||
void JCImage::setImageID(int nID)
|
||||
{
|
||||
m_nID = nID;
|
||||
m_kBitmapData.m_nImageID = nID;
|
||||
}
|
||||
bool JCImage::premultiplyAlpha(BitmapData* pBitmapData)
|
||||
{
|
||||
if (pBitmapData == NULL)return false;
|
||||
if (pBitmapData->m_nImageType != ImgType_png && pBitmapData->m_nImageType != ImgType_gif)return false;
|
||||
int w = pBitmapData->m_nWidth*4;
|
||||
int h = pBitmapData->m_nHeight;
|
||||
for (int i = 0; i < h; i++)
|
||||
{
|
||||
for (int j = 0; j < w; j+=4)
|
||||
{
|
||||
int n = i*w + j;
|
||||
unsigned char* base = (unsigned char*)(pBitmapData->m_pImageData+n);
|
||||
unsigned char alpha = base[3];
|
||||
if (alpha != 0xFF)
|
||||
{
|
||||
unsigned int red = base[0];
|
||||
unsigned int green = base[1];
|
||||
unsigned int blue = base[2];
|
||||
red = red * alpha / 255;
|
||||
green = green * alpha / 255;
|
||||
blue = blue * alpha / 255;
|
||||
base[0] = (unsigned char)red;
|
||||
base[1] = (unsigned char)green;
|
||||
base[2] = (unsigned char)blue;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void JCImage::releaseBitmapData()
|
||||
{
|
||||
m_kBitmapData.releaseData();
|
||||
}
|
||||
bool JCImage::enableImage()
|
||||
{
|
||||
if (m_kBitmapData.m_pImageData == NULL)
|
||||
{
|
||||
if (m_pFileResManager)
|
||||
{
|
||||
JCFileRes* pRes = m_pFileResManager->getRes(m_sUrl);
|
||||
JCBuffer kBuffer;
|
||||
if (pRes && pRes->loadFromCache(kBuffer, false))
|
||||
{
|
||||
if (m_bPushBitmapData == false)
|
||||
{
|
||||
if (loadImageMemSync(kBuffer.m_pPtr, kBuffer.m_nLen, m_kBitmapData) == false)
|
||||
{
|
||||
LOGE("JCImage::gpuRestoreRes decode image error url=%s", m_sUrl.c_str());
|
||||
m_kBitmapData.releaseData();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int nImageLenght = m_kBitmapData.m_nWidth * m_kBitmapData.m_nHeight * 4;
|
||||
if (kBuffer.m_nLen == nImageLenght)
|
||||
{
|
||||
m_kBitmapData.m_pImageData = new char[nImageLenght];
|
||||
memcpy(m_kBitmapData.m_pImageData, kBuffer.m_pPtr, nImageLenght);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGE("JCImage::gpuRestoreRes image lenght != buffer.lenght");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGE("JCImage::gpuRestoreRes load file error url=%s", m_sUrl.c_str());
|
||||
m_kBitmapData.releaseData();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if(m_bPremultiplyAlpha)
|
||||
{
|
||||
premultiplyAlpha(&m_kBitmapData);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
@file JCImage.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
#ifndef __JCImage_H__
|
||||
#define __JCImage_H__
|
||||
|
||||
#include <resource/JCFileResManager.h>
|
||||
#include <imageLib/JCImageRW.h>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCImageManager;
|
||||
/**
|
||||
* @brief
|
||||
*/
|
||||
class JCImage
|
||||
{
|
||||
public:
|
||||
|
||||
/** @brief构造函数
|
||||
*/
|
||||
JCImage();
|
||||
|
||||
/** @brief析构函数
|
||||
*/
|
||||
virtual ~JCImage();
|
||||
|
||||
void setManager(void* pFileResManager, JCImageManager* pImageManager);
|
||||
|
||||
int getWidth();
|
||||
|
||||
int getHeight();
|
||||
|
||||
void setImageID(int nID);
|
||||
|
||||
char* getImageData();
|
||||
|
||||
virtual bool enableImage();
|
||||
|
||||
void releaseBitmapData();
|
||||
|
||||
void setPremultiplyAlpha(bool bPremultiplyAlpha);
|
||||
|
||||
virtual void updateTexImage() {}
|
||||
|
||||
virtual bool isVideo() const { return false; }
|
||||
|
||||
public:
|
||||
|
||||
static bool premultiplyAlpha( BitmapData* pBitmapData );
|
||||
|
||||
public:
|
||||
double m_nTouchTime;
|
||||
BitmapData m_kBitmapData;
|
||||
std::string m_sUrl;
|
||||
JCFileResManager* m_pFileResManager;
|
||||
JCImageManager* m_pImageManager;
|
||||
bool m_bPushBitmapData; //是否为pushBitmapData的，正常的url为false，如果是js调用的pushBitmapData为true
|
||||
private:
|
||||
int m_nID;
|
||||
bool m_bPremultiplyAlpha;
|
||||
};
|
||||
}
|
||||
#endif //__JCImage_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,244 @@
|
||||
/**
|
||||
@file JCImageManager.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
//包含头文件
|
||||
#include "JCImageManager.h"
|
||||
#include <util/Log.h>
|
||||
#include <util/JCCommonMethod.h>
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
namespace laya
|
||||
{
|
||||
JCImageManager::JCImageManager( )
|
||||
{
|
||||
m_nDeleteMaxNum = 0;
|
||||
m_nCountImageID = 0;
|
||||
m_nReleaseSpaceTime = 20000;
|
||||
}
|
||||
JCImageManager::~JCImageManager()
|
||||
{
|
||||
clearAllImage();
|
||||
clearImageIDs();
|
||||
}
|
||||
void JCImageManager::setReleaseSpaceTime(int nTime)
|
||||
{
|
||||
m_nReleaseSpaceTime = nTime;
|
||||
LOGI("JCImageManager::setReleaseSpaceTime=%d",nTime);
|
||||
}
|
||||
void JCImageManager::setImage(int nID, JCImage* pImage)
|
||||
{
|
||||
bool bSucess = true;
|
||||
int nSize = (int)m_vImages.size();
|
||||
if (nID == nSize)
|
||||
{
|
||||
m_vImages.push_back( pImage );
|
||||
}
|
||||
else if( nID < nSize )
|
||||
{
|
||||
if (m_vImages[nID] == NULL)
|
||||
{
|
||||
m_vImages[nID] = pImage;
|
||||
}
|
||||
else
|
||||
{
|
||||
bSucess = false;
|
||||
LOGE("JCImageManager::setImage error m_vImages[%d] != NULL",nID );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int nOldSize = m_vImages.size();
|
||||
m_vImages.resize( nID + 1 );
|
||||
m_vImages[nID] = pImage;
|
||||
}
|
||||
if (bSucess)
|
||||
{
|
||||
pImage->setImageID(nID);
|
||||
pImage->m_nTouchTime = tmGetCurms();
|
||||
m_vOccupiedMemImages[nID] = pImage;
|
||||
}
|
||||
}
|
||||
JCImage* JCImageManager::getImage(int nID)
|
||||
{
|
||||
if ((size_t)nID < m_vImages.size())
|
||||
{
|
||||
return m_vImages[nID];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
bool JCImageManager::deleteImage(int nID)
|
||||
{
|
||||
if (nID == -1) return false;
|
||||
m_vDeleteList.push_back(nID);
|
||||
return true;
|
||||
}
|
||||
bool JCImageManager::_deleteImage(int nID)
|
||||
{
|
||||
if (nID == -1) return false;
|
||||
if (nID < (int)m_vImages.size())
|
||||
{
|
||||
if (m_vImages[nID])
|
||||
{
|
||||
removeImageFromMap(nID);
|
||||
delete m_vImages[nID];
|
||||
m_vImages[nID] = NULL;
|
||||
}
|
||||
}
|
||||
removeImageID(nID);
|
||||
return true;
|
||||
}
|
||||
void JCImageManager::removeImageFromMap(int nID)
|
||||
{
|
||||
MapImageIter iter = m_vOccupiedMemImages.find(nID);
|
||||
if (iter != m_vOccupiedMemImages.end())
|
||||
{
|
||||
iter = m_vOccupiedMemImages.erase(iter);
|
||||
}
|
||||
}
|
||||
void JCImageManager::clearAllImage()
|
||||
{
|
||||
for (VectorImageIter iter = m_vImages.begin(); iter != m_vImages.end(); iter++)
|
||||
{
|
||||
JCImage* pImage = *iter;
|
||||
if (pImage)
|
||||
{
|
||||
delete pImage;
|
||||
pImage = NULL;
|
||||
}
|
||||
}
|
||||
m_vImages.clear();
|
||||
m_vOccupiedMemImages.clear();
|
||||
}
|
||||
void JCImageManager::resetRenderThread()
|
||||
{
|
||||
clearAllImage();
|
||||
}
|
||||
void JCImageManager::removeImageID(int nID)
|
||||
{
|
||||
m_kMutex.lock();
|
||||
if (nID >= 0 && (size_t)nID < m_vImageIDs.size())
|
||||
{
|
||||
m_vImageIDs[nID] = -1;
|
||||
}
|
||||
m_kMutex.unlock();
|
||||
}
|
||||
void JCImageManager::clearImageIDs()
|
||||
{
|
||||
m_kMutex.lock();
|
||||
m_vImageIDs.clear();
|
||||
m_kMutex.unlock();
|
||||
}
|
||||
int JCImageManager::getImageID()
|
||||
{
|
||||
m_kMutex.lock();
|
||||
for (int i = 0,n = m_vImageIDs.size(); i < n; i++ )
|
||||
{
|
||||
if (m_vImageIDs[i] == -1)
|
||||
{
|
||||
m_vImageIDs[i] = i;
|
||||
m_kMutex.unlock();
|
||||
return i;
|
||||
}
|
||||
}
|
||||
m_vImageIDs.push_back(m_nCountImageID);
|
||||
m_kMutex.unlock();
|
||||
return m_nCountImageID++;
|
||||
}
|
||||
void JCImageManager::resetJSThread()
|
||||
{
|
||||
clearImageIDs();
|
||||
m_nCountImageID = 0;
|
||||
}
|
||||
void JCImageManager::_batchHandleDeleteImage()
|
||||
{
|
||||
if (m_vDeleteList.size() <= 0)return;
|
||||
int n = m_vDeleteList.size();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
_deleteImage(m_vDeleteList[i]);
|
||||
}
|
||||
if (n > m_nDeleteMaxNum)
|
||||
{
|
||||
m_nDeleteMaxNum = n;
|
||||
m_vDeleteList.reserve(m_nDeleteMaxNum);
|
||||
}
|
||||
m_vDeleteList.clear();
|
||||
}
|
||||
void JCImageManager::update(int nFrameCount)
|
||||
{
|
||||
_batchHandleDeleteImage();
|
||||
if (nFrameCount % 5 == 0)
|
||||
{
|
||||
if (m_vOccupiedMemImages.size() > 0)
|
||||
{
|
||||
double nCurentTime = tmGetCurms();
|
||||
for (MapImageIter iter = m_vOccupiedMemImages.begin(); iter != m_vOccupiedMemImages.end(); )
|
||||
{
|
||||
JCImage* pImage = iter->second;
|
||||
if (pImage && (nCurentTime - pImage->m_nTouchTime) > m_nReleaseSpaceTime)
|
||||
{
|
||||
pImage->releaseBitmapData();
|
||||
iter = m_vOccupiedMemImages.erase(iter);
|
||||
}
|
||||
else
|
||||
{
|
||||
iter++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void JCImageManager::printCorpseImages(const char* sFileName)
|
||||
{
|
||||
#ifdef WIN32
|
||||
FILE* fp = fopen(sFileName, "w");
|
||||
char sBuffer[2048] = { 0 };
|
||||
int nSizeCount = 0;
|
||||
for (int i = 0, n = m_vImages.size(); i < n; i++ )
|
||||
{
|
||||
JCImage* pImage = m_vImages[i];
|
||||
if (pImage && pImage->m_kBitmapData.m_pImageData )
|
||||
{
|
||||
int nCurrentSize = pImage->m_kBitmapData.m_nHeight*pImage->m_kBitmapData.m_nWidth * 4;
|
||||
nSizeCount += nCurrentSize;
|
||||
sprintf(sBuffer, "image id=%d,memorySize=%d,url=%s\n", i, nCurrentSize,pImage->m_sUrl.c_str());
|
||||
LOGI(sBuffer);
|
||||
if (fp)
|
||||
{
|
||||
fputs(sBuffer, fp);
|
||||
}
|
||||
}
|
||||
}
|
||||
sprintf(sBuffer, "memory size count=%d", nSizeCount);
|
||||
LOGI(sBuffer);
|
||||
if (fp)
|
||||
{
|
||||
fputs(sBuffer, fp);
|
||||
fclose(fp);
|
||||
}
|
||||
#else
|
||||
char sBuffer[2048] = { 0 };
|
||||
int nSizeCount = 0;
|
||||
for (int i = 0, n = m_vImages.size(); i < n; i++)
|
||||
{
|
||||
JCImage* pImage = m_vImages[i];
|
||||
if (pImage && pImage->m_kBitmapData.m_pImageData)
|
||||
{
|
||||
int nCurrentSize = pImage->m_kBitmapData.m_nHeight*pImage->m_kBitmapData.m_nWidth * 4;
|
||||
nSizeCount += nCurrentSize;
|
||||
LOGI("image id=%d,memorySize=%d,url=%s\n", i, nCurrentSize, pImage->m_sUrl.c_str());
|
||||
}
|
||||
}
|
||||
LOGI(sBuffer, "memory size count=%d", nSizeCount);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
@file JCImageManager.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
#ifndef __JCImageManager_H__
|
||||
#define __JCImageManager_H__
|
||||
|
||||
#include "../Image/JCImage.h"
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <thread>
|
||||
#include <mutex>
|
||||
|
||||
/**
|
||||
* @brief
|
||||
*/
|
||||
namespace laya
|
||||
{
|
||||
class JCImageManager
|
||||
{
|
||||
public:
|
||||
|
||||
typedef std::vector<JCImage*> VectorImage;
|
||||
typedef VectorImage::iterator VectorImageIter;
|
||||
|
||||
typedef std::vector<int> VectorImageID;
|
||||
typedef VectorImageID::iterator VectorImageIDIter;
|
||||
|
||||
typedef std::map<int, JCImage*> MapImage;
|
||||
typedef MapImage::iterator MapImageIter;
|
||||
|
||||
public:
|
||||
|
||||
/** @brief构造函数
|
||||
*/
|
||||
JCImageManager();
|
||||
|
||||
/** @brief析构函数
|
||||
*/
|
||||
~JCImageManager();
|
||||
|
||||
void setImage( int nID,JCImage* pImage );
|
||||
|
||||
bool deleteImage( int nID );
|
||||
|
||||
void clearAllImage();
|
||||
|
||||
JCImage* getImage( int nID );
|
||||
|
||||
void resetRenderThread();
|
||||
|
||||
void printCorpseImages( const char* sFileName );
|
||||
|
||||
public:
|
||||
|
||||
int getImageID();
|
||||
|
||||
void resetJSThread();
|
||||
|
||||
void removeImageID(int nID);
|
||||
|
||||
void clearImageIDs();
|
||||
|
||||
void removeImageFromMap( int nID );
|
||||
|
||||
void update(int nFrameCount);
|
||||
|
||||
void setReleaseSpaceTime(int nTime);
|
||||
|
||||
private:
|
||||
|
||||
void _batchHandleDeleteImage();
|
||||
|
||||
bool _deleteImage(int nID);
|
||||
|
||||
public:
|
||||
|
||||
VectorImageID m_vImageIDs; ///<imageID
|
||||
|
||||
VectorImage m_vImages; ///<完整的Image的容器
|
||||
|
||||
//当Image把数据merge到显卡上，Image的内存数据就会删除掉，如果迟迟没有merge到显卡，这部分数据只会保留一段时间
|
||||
MapImage m_vOccupiedMemImages; ///<占用内存的Image容器
|
||||
|
||||
int m_nCountImageID; ///<imageID
|
||||
|
||||
int m_nReleaseSpaceTime; ///<删除的间隔时间
|
||||
|
||||
std::recursive_mutex m_kMutex; ///<线程锁
|
||||
|
||||
private:
|
||||
|
||||
int m_nDeleteMaxNum; ///<为了效率保存最大的值
|
||||
std::vector<int> m_vDeleteList; ///<删除列表
|
||||
|
||||
};
|
||||
}
|
||||
#endif //__JCImageManager_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,48 @@
|
||||
/**
|
||||
@file JCImage.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
#include "JCVideo.h"
|
||||
#include <util/Log.h>
|
||||
#include "JCImageManager.h"
|
||||
#include <util/JCCommonMethod.h>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
JCVideo::JCVideo() : JCImage()
|
||||
{
|
||||
m_kBitmapData.m_pImageData = 0;
|
||||
m_videoHandler = nullptr;
|
||||
}
|
||||
JCVideo::~JCVideo()
|
||||
{
|
||||
if(m_videoHandler)
|
||||
{
|
||||
delete m_videoHandler;
|
||||
m_videoHandler = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void JCVideo::setVideoHandler(IVideoHandler* handler)
|
||||
{
|
||||
m_videoHandler = handler;
|
||||
}
|
||||
|
||||
void JCVideo::updateTexImage()
|
||||
{
|
||||
if (m_videoHandler && m_videoHandler->isFrameUpdated())
|
||||
{
|
||||
m_videoHandler->updateBitmapData(&m_kBitmapData);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
@file JCImage.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_13
|
||||
*/
|
||||
|
||||
#ifndef __JCVideo_H__
|
||||
#define __JCVideo_H__
|
||||
|
||||
#include <resource/JCFileResManager.h>
|
||||
#include <imageLib/JCImageRW.h>
|
||||
#include "JCImage.h"
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCImageManager;
|
||||
/**
|
||||
* @brief
|
||||
*/
|
||||
|
||||
class IVideoHandler
|
||||
{
|
||||
public:
|
||||
virtual ~IVideoHandler() {}
|
||||
|
||||
virtual bool isFrameUpdated() = 0;
|
||||
virtual void updateBitmapData(BitmapData* bitmapData) = 0;
|
||||
};
|
||||
|
||||
|
||||
class JCVideo : public JCImage
|
||||
{
|
||||
public:
|
||||
|
||||
/** @brief构造函数
|
||||
*/
|
||||
JCVideo();
|
||||
|
||||
/** @brief析构函数
|
||||
*/
|
||||
~JCVideo();
|
||||
|
||||
void setVideoHandler(IVideoHandler* handler);
|
||||
|
||||
virtual bool isVideo() const override {
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual void updateTexImage();
|
||||
virtual bool enableImage() override { return true; }
|
||||
|
||||
private:
|
||||
IVideoHandler* m_videoHandler;
|
||||
};
|
||||
}
|
||||
#endif //__JCVideo_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,354 @@
|
||||
namespace laya
|
||||
{
|
||||
struct CMD_ii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
};
|
||||
struct CMD_if
|
||||
{
|
||||
int i;
|
||||
float j;
|
||||
};
|
||||
struct CMD_iff
|
||||
{
|
||||
int i;
|
||||
float x;
|
||||
float y;
|
||||
};
|
||||
struct CMD_ifff
|
||||
{
|
||||
int i;
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
struct CMD_iffff
|
||||
{
|
||||
int i;
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
};
|
||||
struct CMD_ifffffffff
|
||||
{
|
||||
int i;
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
float x1;
|
||||
float y1;
|
||||
float w1;
|
||||
float h1;
|
||||
};
|
||||
struct CMD_iif
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
float x;
|
||||
};
|
||||
struct CMD_iiff
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
float x;
|
||||
float y;
|
||||
};
|
||||
struct CMD_iifff
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
struct CMD_iiffff
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
};
|
||||
struct CMD_iii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
};
|
||||
struct CMD_iiifii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
float l;
|
||||
int m;
|
||||
int n;
|
||||
};
|
||||
struct CMD_iiii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
int l;
|
||||
};
|
||||
struct CMD_iiiii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
int l;
|
||||
int m;
|
||||
};
|
||||
struct CMD_iiiiii
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
int l;
|
||||
int m;
|
||||
int n;
|
||||
};
|
||||
struct CMD_iiiiiii
|
||||
{
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
int d;
|
||||
int e;
|
||||
int f;
|
||||
int g;
|
||||
};
|
||||
struct CMD_iiiiiiii
|
||||
{
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
int d;
|
||||
int e;
|
||||
int f;
|
||||
int g;
|
||||
int h;
|
||||
};
|
||||
struct CMD_iiiiiiiii
|
||||
{
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
int d;
|
||||
int e;
|
||||
int f;
|
||||
int g;
|
||||
int h;
|
||||
int k;
|
||||
};
|
||||
struct CMD_iiiiiiiiiii
|
||||
{
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
int d;
|
||||
int e;
|
||||
int f;
|
||||
int g;
|
||||
int h;
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
};
|
||||
struct CMD_fi
|
||||
{
|
||||
float x;
|
||||
int y;
|
||||
};
|
||||
struct CMD_ff
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
};
|
||||
struct CMD_ffi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
int i;
|
||||
};
|
||||
struct CMD_ifi
|
||||
{
|
||||
int a;
|
||||
float b;
|
||||
int c;
|
||||
};
|
||||
struct CMD_ffii
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
int i;
|
||||
int j;
|
||||
};
|
||||
struct CMD_fff
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
struct CMD_fffiiii
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
int h;
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
};
|
||||
struct CMD_ffff
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
};
|
||||
struct CMD_ffffi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
int i;
|
||||
};
|
||||
struct CMD_ffffiii
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
};
|
||||
struct CMD_ffffiif
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
int i;
|
||||
int j;
|
||||
float k;
|
||||
};
|
||||
struct CMD_fffffiiifi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float r;
|
||||
float s;
|
||||
float e;
|
||||
int f;
|
||||
int l;
|
||||
int m;
|
||||
float w;
|
||||
int v;
|
||||
};
|
||||
struct CMD_fffiiifi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float r;
|
||||
int f;
|
||||
int l;
|
||||
int m;
|
||||
float w;
|
||||
int v;
|
||||
};
|
||||
struct CMD_ffffiiif
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
int i;
|
||||
int j;
|
||||
int m;
|
||||
float k;
|
||||
};
|
||||
struct CMD_fffiifi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float r;
|
||||
int i;
|
||||
int j;
|
||||
float k;
|
||||
int l;
|
||||
};
|
||||
struct CMD_fffff
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
float i;
|
||||
};
|
||||
struct CMD_ffffifi
|
||||
{
|
||||
float fx;
|
||||
float fy;
|
||||
float tx;
|
||||
float ty;
|
||||
int c;
|
||||
float w;
|
||||
int i;
|
||||
};
|
||||
struct CMD_fffffi
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float w;
|
||||
float h;
|
||||
float i;
|
||||
int j;
|
||||
};
|
||||
struct CMD_ffffff
|
||||
{
|
||||
float a;
|
||||
float b;
|
||||
float c;
|
||||
float d;
|
||||
float tx;
|
||||
float ty;
|
||||
};
|
||||
struct CMDMatrix4x4
|
||||
{
|
||||
float matrix[16];
|
||||
};
|
||||
struct CMDIBVB
|
||||
{
|
||||
int ibId;
|
||||
int vbId;
|
||||
int vertType;
|
||||
int shaderId;
|
||||
int imgId;
|
||||
int startIndex;
|
||||
int offset;
|
||||
int numElement;
|
||||
float x;
|
||||
float y;
|
||||
float mat[6];
|
||||
};
|
||||
struct CMDSkinMesh
|
||||
{
|
||||
int ibId;
|
||||
int vbId;
|
||||
int vertType;
|
||||
int numElement;
|
||||
int startIndex;
|
||||
int imgId;
|
||||
int shaderId;
|
||||
float mat[6];
|
||||
float x;
|
||||
float y;
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
@file JCIDGenerator.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_12
|
||||
*/
|
||||
|
||||
#include "JCIDGenerator.h"
|
||||
|
||||
namespace laya
|
||||
{
|
||||
JCIDGenerator::JCIDGenerator()
|
||||
{
|
||||
}
|
||||
JCIDGenerator::~JCIDGenerator()
|
||||
{
|
||||
}
|
||||
bool JCIDGenerator::deleteID(GLuint nFakeID)
|
||||
{
|
||||
//只设置为无效，不从vector中删除
|
||||
if (nFakeID >= 0 && nFakeID < m_vIDTable.size())
|
||||
{
|
||||
m_vIDTable[nFakeID] = 0;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool JCIDGenerator::setRealID(GLuint nFakeID,GLuint nRealID)
|
||||
{
|
||||
if (nFakeID == m_vIDTable.size())
|
||||
{
|
||||
m_vIDTable.push_back(nRealID);
|
||||
}
|
||||
else if (nFakeID > m_vIDTable.size())
|
||||
{
|
||||
int nLastSize = m_vIDTable.size();
|
||||
m_vIDTable.resize(nFakeID +1);
|
||||
//把中间的空的，全部填充成无效的
|
||||
for (int i = nLastSize,n=m_vIDTable.size(); i < n; i++)
|
||||
{
|
||||
m_vIDTable[i] = 0;
|
||||
}
|
||||
m_vIDTable[nFakeID] = nRealID;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_vIDTable[nFakeID] = nRealID;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void JCIDGenerator::reset()
|
||||
{
|
||||
m_vIDTable.clear();
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
@file JCIDGenerator.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_12
|
||||
*/
|
||||
|
||||
#ifndef __JCIDGenerator_H__
|
||||
#define __JCIDGenerator_H__
|
||||
|
||||
#include <string>
|
||||
#include "util/Log.h"
|
||||
#include <vector>
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES3/gl.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#endif
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCIDGenerator
|
||||
{
|
||||
public:
|
||||
|
||||
JCIDGenerator();
|
||||
|
||||
~JCIDGenerator();
|
||||
|
||||
bool deleteID(GLuint nFakeID);
|
||||
|
||||
bool setRealID(GLuint fakeID,GLuint realID);
|
||||
|
||||
GLuint getRealID(GLuint fakeID)
|
||||
{
|
||||
return fakeID < m_vIDTable.size() ? m_vIDTable[fakeID] : 0;
|
||||
}
|
||||
|
||||
void reset();
|
||||
|
||||
protected:
|
||||
|
||||
std::vector<GLuint> m_vIDTable;
|
||||
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCIDGenerator_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,249 @@
|
||||
/**
|
||||
@file JCLayaGL.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2018_5_25
|
||||
*/
|
||||
|
||||
#ifndef __JCLayaGL_H__
|
||||
#define __JCLayaGL_H__
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <unordered_map>
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES3/gl.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#endif
|
||||
#include "../Image/JCImageManager.h"
|
||||
#include "JCIDGenerator.h"
|
||||
#include <Manager/JCArrayBufferManager.h>
|
||||
#include "../RenderEx/JCGlobalValue.h"
|
||||
#include "../Manager/JCOrderResManager.h"
|
||||
#include "../RenderEx/JCRegister.h"
|
||||
#include <buffer/JCCommandEncoderBuffer.h>
|
||||
|
||||
//1024*1024*4
|
||||
#define TEX_IMAGE2D_DUMMY_MAX_SIZE 4194304
|
||||
|
||||
|
||||
namespace laya
|
||||
{
|
||||
typedef GLuint WebGLShader;
|
||||
typedef GLuint WebGLProgram;
|
||||
typedef GLuint WebGLBuffer;
|
||||
typedef GLuint WebGLFramebuffer;
|
||||
typedef GLuint WebGLRenderbuffer;
|
||||
typedef GLuint WebGLTexture;
|
||||
typedef GLuint WebGLUniformLocation;
|
||||
class JCWebGLPlus;
|
||||
/**
|
||||
* @brief
|
||||
*/
|
||||
class JCLayaGL
|
||||
{
|
||||
public:
|
||||
JCLayaGL(int nWidth,int nHeight,JCArrayBufferManager* pArrayBuferManager, JCImageManager* pImageManager,JCIDGenerator* pIDGenerator,JCIDGenerator* pProgramLocationTable,JCRegister* pRegister,JCWebGLPlus* pWebGLPlus);
|
||||
static void _texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels);
|
||||
static void _createVertexArray(GLuint& vao);
|
||||
static void _bindVertexArray(GLuint vao);
|
||||
static void _deleteVertexArray(GLuint& vao);
|
||||
virtual ~JCLayaGL();
|
||||
virtual bool isContextLost();
|
||||
virtual void* getExtension(const std::string& name);
|
||||
virtual void activeTexture(GLenum texture);
|
||||
virtual void attachShader(WebGLProgram program, WebGLShader shader);
|
||||
virtual void bindAttribLocation(WebGLProgram program, GLuint index, const std::string& name);
|
||||
virtual void bindBuffer(GLenum target, WebGLBuffer buffer);
|
||||
virtual void bindFramebuffer(GLenum target, WebGLFramebuffer framebuffer);
|
||||
virtual void bindRenderbuffer(GLenum target, WebGLRenderbuffer renderbuffer);
|
||||
virtual void bindTexture(GLenum target, WebGLTexture texture);
|
||||
virtual void blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
|
||||
virtual void blendEquation(GLenum mode);
|
||||
virtual void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
|
||||
virtual void blendFunc(GLenum sfactor, GLenum dfactor);
|
||||
virtual void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
|
||||
virtual void bufferData_size(GLenum target, GLsizeiptr size, GLenum usage);
|
||||
virtual void bufferData(GLenum target, int dataSize, char* data, GLenum usage);
|
||||
virtual void bufferSubData(GLenum target, GLintptr offset,int dataSize, char* data);
|
||||
virtual GLenum checkFramebufferStatus(GLenum target);
|
||||
virtual void clear(GLbitfield mask);
|
||||
virtual void clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
|
||||
virtual void clearDepth(GLclampf depth);
|
||||
virtual void clearStencil(GLint s);
|
||||
virtual void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
|
||||
virtual void compileShader(WebGLShader shader);
|
||||
virtual void compressedTexImage2D(GLenum target, GLint level, GLenum internalformat,GLsizei width, GLsizei height, GLint border,int dataSize,char* data);
|
||||
virtual void compressedTexSubImage2D(GLenum target, GLint level,GLint xoffset, GLint yoffset,GLsizei width, GLsizei height, GLenum format, int dataSize,char* data );
|
||||
virtual void copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
|
||||
virtual void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
virtual WebGLBuffer createBuffer(int fakeID);
|
||||
virtual WebGLFramebuffer createFramebuffer(int fakeID);
|
||||
virtual WebGLProgram createProgram(int fakeID);
|
||||
virtual WebGLRenderbuffer createRenderbuffer(int fakeID);
|
||||
virtual WebGLShader createShader(int fakeID,GLenum type);
|
||||
virtual WebGLTexture createTexture(int fakeID);
|
||||
virtual void cullFace(GLenum mode);
|
||||
virtual void deleteBuffer(WebGLBuffer buffer);
|
||||
virtual void deleteFramebuffer(WebGLFramebuffer framebuffer);
|
||||
virtual void deleteProgram(WebGLProgram program);
|
||||
virtual void deleteRenderbuffer(WebGLRenderbuffer renderbuffer);
|
||||
virtual void deleteShader(WebGLShader shader);
|
||||
virtual void deleteTexture(WebGLTexture texture);
|
||||
virtual void depthFunc(GLenum func);
|
||||
virtual void depthMask(GLboolean flag);
|
||||
virtual void depthRange(GLclampf zNear, GLclampf zFar);
|
||||
virtual void detachShader(WebGLProgram program, WebGLShader shader);
|
||||
virtual void disable(GLenum cap);
|
||||
virtual void disableVertexAttribArray(GLuint index);
|
||||
virtual void drawArrays(GLenum mode, GLint first, GLsizei count);
|
||||
virtual void drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);
|
||||
virtual void enable(GLenum cap);
|
||||
virtual void enableVertexAttribArray(GLuint index);
|
||||
virtual void finish();
|
||||
virtual void flush();
|
||||
virtual void framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer renderbuffer);
|
||||
virtual void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture texture, GLint level);
|
||||
virtual void frontFace(GLenum mode);
|
||||
virtual void generateMipmap(GLenum target);
|
||||
virtual GLint getAttribLocation(WebGLProgram program,const std::string& name);
|
||||
virtual GLint getBufferParameter(GLenum target, GLenum pname);
|
||||
virtual GLint getParameter(GLenum pname,int fakeID);
|
||||
virtual GLenum getError();
|
||||
virtual GLint getFramebufferAttachmentParameter(GLenum target, GLenum attachment,GLenum pname);
|
||||
virtual GLint getProgramParameter(WebGLProgram program, GLenum pname);
|
||||
virtual std::string getProgramInfoLog(WebGLProgram program);
|
||||
virtual GLint getRenderbufferParameter(GLenum target, GLenum pname);
|
||||
virtual GLint getShaderParameter(WebGLShader shader, GLenum pname);
|
||||
virtual std::string getShaderInfoLog(WebGLShader shader);
|
||||
virtual std::string getShaderSource(WebGLShader shader);
|
||||
virtual GLint getTexParameter(GLenum target, GLenum pname);
|
||||
virtual GLint getUniform(WebGLProgram program, WebGLUniformLocation location);
|
||||
virtual WebGLUniformLocation getUniformLocation(WebGLProgram program, int fakeLoc,const std::string& name);
|
||||
virtual GLint getVertexAttrib(GLuint index, GLenum pname);
|
||||
virtual GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);
|
||||
virtual void hint(GLenum target, GLenum mode);
|
||||
virtual GLboolean isBuffer(WebGLBuffer buffer);
|
||||
virtual GLboolean isEnabled(GLenum cap);
|
||||
virtual GLboolean isFramebuffer(WebGLFramebuffer framebuffer);
|
||||
virtual GLboolean isProgram(WebGLProgram program);
|
||||
virtual GLboolean isRenderbuffer(WebGLRenderbuffer renderbuffer);
|
||||
virtual GLboolean isShader(WebGLShader shader);
|
||||
virtual GLboolean isTexture(WebGLTexture texture);
|
||||
virtual void lineWidth(GLfloat width);
|
||||
virtual void linkProgram(WebGLProgram program);
|
||||
virtual void pixelStorei(GLenum pname, GLint param);
|
||||
virtual void polygonOffset(GLfloat factor, GLfloat units);
|
||||
virtual void readPixelsAsync(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, int callbackObjID, int funcID);
|
||||
virtual void renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
|
||||
virtual void sampleCoverage(GLclampf value, GLboolean invert);
|
||||
virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
virtual void shaderSource(WebGLShader shader, const std::string& source);
|
||||
virtual void stencilFunc(GLenum func, GLint ref, GLuint mask);
|
||||
virtual void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
|
||||
virtual void stencilMask(GLuint mask);
|
||||
virtual void stencilMaskSeparate(GLenum face, GLuint mask);
|
||||
virtual void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);
|
||||
virtual void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
|
||||
virtual void texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, void* pixels);
|
||||
virtual void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
|
||||
virtual void texParameterf(GLenum target, GLenum pname, GLfloat param);
|
||||
virtual void texParameteri(GLenum target, GLenum pname, GLint param);
|
||||
virtual void uniform1f(WebGLUniformLocation location, GLfloat x);
|
||||
virtual void uniform1fv(WebGLUniformLocation location, int byteSize, const GLfloat* v );
|
||||
virtual void uniform1i(WebGLUniformLocation location, GLint x);
|
||||
virtual void uniform1iv(WebGLUniformLocation location, int byteSize, const GLint* v );
|
||||
virtual void uniform2f(WebGLUniformLocation location, GLfloat x, GLfloat y);
|
||||
virtual void uniform2fv(WebGLUniformLocation location, int byteSize, const GLfloat* v );
|
||||
virtual void uniform2i(WebGLUniformLocation location, GLint x, GLint y);
|
||||
virtual void uniform2iv(WebGLUniformLocation location, int byteSize, const GLint* v );
|
||||
virtual void uniform3f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z);
|
||||
virtual void uniform3fv(WebGLUniformLocation location, int byteSize, const GLfloat* v);
|
||||
virtual void uniform3i(WebGLUniformLocation location, GLint x, GLint y, GLint z);
|
||||
virtual void uniform3iv(WebGLUniformLocation location, int byteSize, const GLint* v );
|
||||
virtual void uniform4f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
||||
virtual void uniform4fv(WebGLUniformLocation location, int byteSize, const GLfloat* v );
|
||||
virtual void uniform4i(WebGLUniformLocation location, GLint x, GLint y, GLint z, GLint w);
|
||||
virtual void uniform4iv(WebGLUniformLocation location, int byteSize, const GLint* v);
|
||||
virtual void uniformMatrix2fv(WebGLUniformLocation location, int byteSize,GLboolean transpose,GLfloat* value);
|
||||
virtual void uniformMatrix3fv(WebGLUniformLocation location, int byteSize,GLboolean transpose,GLfloat* value);
|
||||
virtual void uniformMatrix4fv(WebGLUniformLocation location, int byteSize, GLboolean transpose,GLfloat* value);
|
||||
virtual void useProgram(WebGLProgram program);
|
||||
virtual void validateProgram(WebGLProgram program);
|
||||
virtual void vertexAttrib1f(GLuint index, GLfloat x);
|
||||
virtual void vertexAttrib1fv(GLuint index, GLfloat* values);
|
||||
virtual void vertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
|
||||
virtual void vertexAttrib2fv(GLuint index, GLfloat* values);
|
||||
virtual void vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
|
||||
virtual void vertexAttrib3fv(GLuint index, GLfloat* values);
|
||||
virtual void vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
||||
virtual void vertexAttrib4fv(GLuint index, GLfloat* values);
|
||||
virtual void vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
|
||||
virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
virtual void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
|
||||
virtual int createVertexArray(int fakeID);
|
||||
virtual void bindVertexArray(int fakeID);
|
||||
virtual void deleteVertexArray(int fakeID);
|
||||
virtual void vertexAttribDivisor(GLuint index, GLuint divisor);
|
||||
virtual void drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
|
||||
virtual void drawElementsInstanced(GLenum mode, GLsizei count, GLenum type, GLintptr indices, GLsizei primcount);
|
||||
virtual void texImage2DCanvas(GLsizei width, GLsizei height, int canvas);
|
||||
virtual void texStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
|
||||
//------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------
|
||||
virtual void useCommandEncoder(int nCmdSetID);
|
||||
//------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------
|
||||
public:
|
||||
virtual void deleteAllGLRes();
|
||||
virtual void removeTextureFromMap(GLuint texture);
|
||||
virtual void removeFrameBufferFromMap(GLuint frameBuffer);
|
||||
virtual void removeProgramFromMap(GLuint program);
|
||||
virtual void removeShaderFromMap(GLuint shader);
|
||||
virtual void removeRenderBufferFromMap(GLuint renderBuffer);
|
||||
virtual void removeBufferFromMap(GLuint buffer);
|
||||
virtual void removeVAOFromMap(GLuint VAO);
|
||||
public:
|
||||
void _readPixelsAsync(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, int callbackObjID, int funcID);
|
||||
private:
|
||||
void flipY(GLenum format, GLsizei width, GLsizei height, void* pixels);
|
||||
public:
|
||||
static char m_pDummyData[TEX_IMAGE2D_DUMMY_MAX_SIZE];
|
||||
public:
|
||||
JCWebGLPlus* m_pWebGLPlus;
|
||||
JCImageManager* m_pImageManager;
|
||||
JCArrayBufferManager* m_pArrayBufferManager;
|
||||
JCRegister* m_pRegister;
|
||||
protected:
|
||||
GLint m_nMainFrameBuffer;
|
||||
JCIDGenerator* m_pIDGenerator;
|
||||
JCIDGenerator* m_pProgramLocationTable;
|
||||
bool m_bFlipY;
|
||||
public:
|
||||
int m_nCurrentBuffer;
|
||||
int m_nCurrentProgram;
|
||||
static float s_fMainCanvasScaleX;
|
||||
static float s_fMainCanvasScaleY;
|
||||
static float s_fMainCanvasTX;
|
||||
static float s_fMainCanvasTY;
|
||||
int m_nMainCanvasWidth;
|
||||
int m_nMainCanvasHeight;
|
||||
private:
|
||||
std::unordered_map<GLuint, bool> m_vAllTexture;
|
||||
std::unordered_map<GLuint, bool> m_vAllFrameBuffer;;
|
||||
std::unordered_map<GLuint, bool> m_vAllProgram;
|
||||
std::unordered_map<GLuint, bool> m_vAllShader;
|
||||
std::unordered_map<GLuint, bool> m_vAllRenderBuffer;
|
||||
std::unordered_map<GLuint, bool> m_vAllBuffer;
|
||||
std::unordered_map<GLuint, bool> m_vAllVAO;
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCLayaGL_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,400 @@
|
||||
/**
|
||||
@file JCLayaGLDispatch.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2018_5_25
|
||||
*/
|
||||
|
||||
#ifndef __JCLayaGLDispatch_H__
|
||||
#define __JCLayaGLDispatch_H__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "JCLayaGL.h"
|
||||
#include <buffer/JCCommandEncoderBuffer.h>
|
||||
|
||||
//#define DEBUG_PARSE_STREAM 0
|
||||
|
||||
namespace laya
|
||||
{
|
||||
enum LAYA_FUNCTION_ID
|
||||
{
|
||||
LAYA_UNIFORMMATRIX2FVEX = 0,
|
||||
LAYA_UNIFORMMATRIX3FVEX,
|
||||
LAYA_UNIFORMMATRIX4FVEX,
|
||||
LAYA_ADDSHADERUNIFORM,
|
||||
LAYA_UPLOADSHADERUNIFORMS,
|
||||
LAYA_UPLOADSHADERUNIFORMS_BUFFER,
|
||||
LAYA_USECOMMANDENCODER,
|
||||
LAYA_LOADDATATOREG,
|
||||
LAYA_LOADDATATOREGEX,
|
||||
LAYA_IFLESS0,
|
||||
LAYA_IFEQUAL0,
|
||||
LAYA_IFGREATER0,
|
||||
LAYA_IFLEQUAL0,
|
||||
LAYA_IFGEQUAL0,
|
||||
LAYA_IFGNOTEQUAL0,
|
||||
LAYA_OPERATEREG,
|
||||
LAYA_STORE,
|
||||
LAYA_CREATE_IMAGE_ON_RENDER_THREAD = 64,
|
||||
LAYA_DELETE_IMAGE_ON_RENDER_THREAD,
|
||||
LAYA_RELEASE_IMAGE_ON_RENDER_THREAD,
|
||||
LAYA_SET_IMAGE_RELEASE_SPACE_TIME,
|
||||
LAYA_SET_PREMULTIPLY_ALPHA,
|
||||
LAYA_PERFADDDATA,
|
||||
LAYA_PERFUPDATEDT,
|
||||
LAYA_SET_MAIN_CONTEXT_SIZE,
|
||||
|
||||
//-------------------------------
|
||||
LAYA_GETCONTEXTATTRIBUTES = 128,
|
||||
LAYA_ISCONTEXTLOST,
|
||||
LAYA_GETSUPPORTEDEXTENSIONS,
|
||||
LAYA_GETEXTENSION,
|
||||
LAYA_ACTIVETEXTURE,
|
||||
LAYA_ATTACHSHADER,
|
||||
LAYA_BINDATTRIBLOCATION,
|
||||
LAYA_BINDBUFFER,
|
||||
LAYA_BINDFRAMEBUFFER,
|
||||
LAYA_BINDRENDERBUFFER,//第10个
|
||||
LAYA_BINDTEXTURE,
|
||||
LAYA_USETEXTURE,
|
||||
LAYA_BLENDCOLOR,
|
||||
LAYA_BLENDEQUATION,
|
||||
LAYA_BLENDEQUATIONSEPARATE,
|
||||
LAYA_BLENDFUNC,
|
||||
LAYA_BLENDFUNCSEPARATE,
|
||||
LAYA_BUFFERDATA_SIZE,
|
||||
LAYA_BUFFERDATA_ARRAYBUFFER,
|
||||
LAYA_BUFFERSUBDATA,//第20个
|
||||
LAYA_CHECKFRAMEBUFFERSTATUS,
|
||||
LAYA_CLEAR,
|
||||
LAYA_CLEARCOLOR,
|
||||
LAYA_CLEARDEPTH,
|
||||
LAYA_CLEARSTENCIL,
|
||||
LAYA_COLORMASK,
|
||||
LAYA_COMPILESHADER,
|
||||
LAYA_COPYTEXIMAGE2D,
|
||||
LAYA_COPYTEXSUBIMAGE2D,
|
||||
LAYA_CREATEBUFFER,//第30个
|
||||
LAYA_CREATEFRAMEBUFFER,
|
||||
LAYA_CREATEPROGRAM,
|
||||
LAYA_CREATERENDERBUFFER,
|
||||
LAYA_CREATESHADER,
|
||||
LAYA_CREATETEXTURE,
|
||||
LAYA_CULLFACE,
|
||||
LAYA_DELETEBUFFER,
|
||||
LAYA_DELETEFRAMEBUFFER,
|
||||
LAYA_DELETEPROGRAM,
|
||||
LAYA_DELETERENDERBUFFER,//第40个
|
||||
LAYA_DELETESHADER,
|
||||
LAYA_DELETETEXTURE,
|
||||
LAYA_DEPTHFUNC,
|
||||
LAYA_DEPTHMASK,
|
||||
LAYA_DEPTHRANGE,
|
||||
LAYA_DETACHSHADER,
|
||||
LAYA_DISABLE,
|
||||
LAYA_DISABLEVERTEXATTRIBARRAY,
|
||||
LAYA_DRAWARRAYS,
|
||||
LAYA_DRAWELEMENTS,//第50个
|
||||
LAYA_ENABLE,
|
||||
LAYA_ENABLEVERTEXATTRIBARRAY,
|
||||
LAYA_FINISH,
|
||||
LAYA_FLUSH,
|
||||
LAYA_FRAMEBUFFERRENDERBUFFER,
|
||||
LAYA_FRAMEBUFFERTEXTURE2D,
|
||||
LAYA_FRONTFACE,
|
||||
LAYA_GENERATEMIPMAP,
|
||||
LAYA_GETACTIVEATTRIB,
|
||||
LAYA_GETACTIVEUNIFORM,//第60个
|
||||
LAYA_GETATTRIBLOCATION,
|
||||
LAYA_GETPARAMETER,
|
||||
LAYA_GETBUFFERPARAMETER,
|
||||
LAYA_GETERROR,
|
||||
LAYA_GETFRAMEBUFFERATTACHMENTPARAMETER,
|
||||
LAYA_GETPROGRAMPARAMETER,
|
||||
LAYA_GETPROGRAMINFOLOG,
|
||||
LAYA_GETRENDERBUFFERPARAMETER,
|
||||
LAYA_GETSHADERPRECISIONFORMAT,
|
||||
LAYA_GETSHADERPARAMETER,//第70个
|
||||
LAYA_GETSHADERINFOLOG,
|
||||
LAYA_GETSHADERSOURCE,
|
||||
LAYA_GETTEXPARAMETER,
|
||||
LAYA_GETUNIFORM,
|
||||
LAYA_GETUNIFORMLOCATION,
|
||||
LAYA_GETVERTEXATTRIB,
|
||||
LAYA_GETVERTEXATTRIBOFFSET,
|
||||
LAYA_HINT,
|
||||
LAYA_ISBUFFER,
|
||||
LAYA_ISENABLED,//第80个
|
||||
LAYA_ISFRAMEBUFFER,
|
||||
LAYA_ISPROGRAM,
|
||||
LAYA_ISRENDERBUFFER,
|
||||
LAYA_ISSHADER,
|
||||
LAYA_ISTEXTURE,
|
||||
LAYA_LINEWIDTH,
|
||||
LAYA_LINKPROGRAM,
|
||||
LAYA_PIXELSTOREI,
|
||||
LAYA_POLYGONOFFSET,
|
||||
LAYA_READPIXELS,//第90个
|
||||
LAYA_RENDERBUFFERSTORAGE,
|
||||
LAYA_SAMPLECOVERAGE,
|
||||
LAYA_SCISSOR,
|
||||
LAYA_SHADERSOURCE,
|
||||
LAYA_STENCILFUNC,
|
||||
LAYA_STENCILFUNCSEPARATE,
|
||||
LAYA_STENCILMASK,
|
||||
LAYA_STENCILMASKSEPARATE,
|
||||
LAYA_STENCILOP,
|
||||
LAYA_STENCILOPSEPARATE,//第100个
|
||||
LAYA_TEXIMAGE2D,
|
||||
LAYA_TEXPARAMETERF,
|
||||
LAYA_TEXPARAMETERI,
|
||||
LAYA_TEXSUBIMAGE2D,
|
||||
LAYA_UNIFORM1F,
|
||||
LAYA_UNIFORM1FV,
|
||||
LAYA_UNIFORM1I,
|
||||
LAYA_UNIFORM1IV,
|
||||
LAYA_UNIFORM2F,
|
||||
LAYA_UNIFORM2FV,//第110个
|
||||
LAYA_UNIFORM2I,
|
||||
LAYA_UNIFORM2IV,
|
||||
LAYA_UNIFORM3F,
|
||||
LAYA_UNIFORM3FV,
|
||||
LAYA_UNIFORM3I,
|
||||
LAYA_UNIFORM3IV,
|
||||
LAYA_UNIFORM4F,
|
||||
LAYA_UNIFORM4FV,
|
||||
LAYA_UNIFORM4I,
|
||||
LAYA_UNIFORM4IV,//第120个
|
||||
LAYA_UNIFORMMATRIX2FV,
|
||||
LAYA_UNIFORMMATRIX3FV,
|
||||
LAYA_UNIFORMMATRIX4FV,
|
||||
LAYA_USEPROGRAM,
|
||||
LAYA_VALIDATEPROGRAM,
|
||||
LAYA_VERTEXATTRIB1F,
|
||||
LAYA_VERTEXATTRIB1FV,
|
||||
LAYA_VERTEXATTRIB2F,
|
||||
LAYA_VERTEXATTRIB2FV,
|
||||
LAYA_VERTEXATTRIB3F,//第130个
|
||||
LAYA_VERTEXATTRIB3FV,
|
||||
LAYA_VERTEXATTRIB4F,
|
||||
LAYA_VERTEXATTRIB4FV,
|
||||
LAYA_VERTEXATTRIBPOINTER,
|
||||
LAYA_VIEWPORT,
|
||||
LAYA_CONFIGUREBACKBUFFER,
|
||||
LAYA_COMPRESSEDTEXIMAGE2D,
|
||||
LAYA_TEXIMAGE2D_PIXEL,
|
||||
LAYA_TEXSUBIMAGE2D_PIXEL,
|
||||
LAYA_CREATEVERTEXARRAY,//第140个
|
||||
LAYA_BINDVERTEXARRAY,
|
||||
LAYA_DELETEVERTEXARRAYS,
|
||||
LAYA_READPIXELSASYNC,
|
||||
LAYA_COMPRESSEDTEXSUBIMAGE2D,
|
||||
LAYA_VERTEXATTRIBDIVISOR,
|
||||
LAYA_DRAWARRAYSINSTANCED,
|
||||
LAYA_DRAWELEMENTSINSTANCED,
|
||||
};
|
||||
class JCLayaGLDispatch
|
||||
{
|
||||
public:
|
||||
|
||||
typedef void(*ProcFunction)(JCCommandEncoderBuffer& layaGLCmd);
|
||||
|
||||
static bool dispatchScriptCmd(JCCommandEncoderBuffer& layaGLCmd);
|
||||
|
||||
static void dispatchAllCmds(JCCommandEncoderBuffer* pTemplateMem);
|
||||
|
||||
public:
|
||||
|
||||
static void _layaGL_empty(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getContextAttributes(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isContextLost(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getSupportedExtensions(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getExtension(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_activeTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_attachShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindAttribLocation(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindFramebuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindRenderbuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_useTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_blendColor(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_blendEquation(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_blendEquationSeparate(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_blendFunc(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_blendFuncSeparate(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bufferData_size(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bufferData_ArrayBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bufferSubData(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_checkFramebufferStatus(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_clear(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_clearColor(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_clearDepth(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_clearStencil(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_colorMask(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_compileShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_copyTexImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_copyTexSubImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createFramebuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createRenderbuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_cullFace(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteFramebuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteRenderbuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_depthFunc(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_depthMask(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_depthRange(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_detachShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_disable(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_disableVertexAttribArray(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_drawArrays(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_drawElements(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_enable(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_enableVertexAttribArray(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_finish(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_flush(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_framebufferRenderbuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_framebufferTexture2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_frontFace(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_generateMipmap(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getActiveAttrib(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getActiveUniform(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getAttribLocation(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getBufferParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getError(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getFramebufferAttachmentParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getProgramParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getProgramInfoLog(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getRenderbufferParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getShaderPrecisionFormat(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getShaderParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getShaderInfoLog(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getShaderSource(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getTexParameter(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getUniform(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getUniformLocation(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getVertexAttrib(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_getVertexAttribOffset(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_hint(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isEnabled(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isFramebuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isRenderbuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isShader(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_isTexture(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_lineWidth(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_linkProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_pixelStorei(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_polygonOffset(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_readPixels(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_renderbufferStorage(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_sampleCoverage(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_scissor(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_shaderSource(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilFunc(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilFuncSeparate(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilMask(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilMaskSeparate(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilOp(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_stencilOpSeparate(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texParameterf(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texParameteri(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texSubImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform1f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform1fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform1i(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform1iv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform2f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform2fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform2i(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform2iv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform3f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform3fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform3i(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform3iv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform4f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform4fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform4i(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniform4iv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniformMatrix2fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniformMatrix3fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniformMatrix4fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_useProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_validateProgram(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib1f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib1fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib2f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib2fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib3f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib3fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib4f(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttrib4fv(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttribPointer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_viewport(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_configureBackBuffer(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_compressedTexImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texImage2D_pixel(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texSubImage2D_pixel(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_createVertexArray(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_bindVertexArray(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteVertexArray(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_readPixelsAsync(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_compressedTexSubImage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_vertexAttribDivisor(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_drawArraysInstanced(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_drawElementsInstanced(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texImage2D_canvas(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_texStorage2D(JCCommandEncoderBuffer& layaGLCmd);
|
||||
//------------------------------------------------------------------------------
|
||||
//-------------------------webgl扩展函数-----------------------------------------
|
||||
//------------------------------------------------------------------------------
|
||||
static void _layaGL_uniformMatrix2fvEx(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniformMatrix3fvEx(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uniformMatrix4fvEx(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_addShaderUniform(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_useCommandEncoder(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uploadShaderUniforms(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_uploadShaderUniformsData(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_loadDataToReg(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_loadDataToRegEx(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifLess0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifEqual0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifGreater0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifLEqual0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifGEqual0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_ifGNotEqual0(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_operateReg(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_store(JCCommandEncoderBuffer& layaGLCmd);
|
||||
//------------------------------------------------------------------------------
|
||||
//-------------------------C++函数-----------------------------------------
|
||||
//------------------------------------------------------------------------------
|
||||
static void _layaGL_createImageOnRenderThread(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_deleteImageOnRenderThread(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_releaseImageOnRenderThread(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_setImageReleaseSpaceTime(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_setPremultiplyAlpha(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_PerfAddData(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_PerfUpdateDt(JCCommandEncoderBuffer& layaGLCmd);
|
||||
static void _layaGL_setMainContextSize(JCCommandEncoderBuffer& layaGLCmd);
|
||||
public:
|
||||
|
||||
static JCLayaGL* ms_pLayaGL; ///<全局的LayaGL
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCLayaGLDispatch_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,126 @@
|
||||
/**
|
||||
@file JCOrderResManager.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2017_12_1
|
||||
*/
|
||||
|
||||
#ifndef __JCOrderResManager_H__
|
||||
#define __JCOrderResManager_H__
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
#include <util/Log.h>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
template<class T>
|
||||
class JCOrderResManager
|
||||
{
|
||||
public:
|
||||
|
||||
/** @brief构造函数
|
||||
*/
|
||||
JCOrderResManager( bool bNeedDelRes )
|
||||
{
|
||||
m_bNeedDelRes = bNeedDelRes;
|
||||
m_nGlobalID = 0;
|
||||
}
|
||||
|
||||
/** @brief析构函数
|
||||
*/
|
||||
~JCOrderResManager()
|
||||
{
|
||||
clearAllRes();
|
||||
}
|
||||
|
||||
void setRes(int nID, T* pRes)
|
||||
{
|
||||
int nSize = (int)m_vRes.size();
|
||||
if (nID == nSize)
|
||||
{
|
||||
m_vRes.push_back(pRes);
|
||||
}
|
||||
else if (nID < nSize)
|
||||
{
|
||||
if (m_vRes[nID] == NULL)
|
||||
{
|
||||
m_vRes[nID] = pRes;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGE("JCOrderResManager::setRes error m_vRes[%d] != NULL", nID);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int nOldSize = m_vRes.size();
|
||||
m_vRes.resize(nID + 1);
|
||||
m_vRes[nID] = pRes;
|
||||
}
|
||||
}
|
||||
|
||||
T* getRes(int nID)
|
||||
{
|
||||
return m_vRes[nID];
|
||||
}
|
||||
|
||||
void deleteRes(int nID)
|
||||
{
|
||||
if (nID < m_vRes.size())
|
||||
{
|
||||
T* pRes = m_vRes[nID];
|
||||
if (pRes)
|
||||
{
|
||||
delete pRes;
|
||||
}
|
||||
m_vRes[nID] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void removeRes(int nID)
|
||||
{
|
||||
if (nID < m_vRes.size())
|
||||
{
|
||||
m_vRes[nID] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
int getGlobalID()
|
||||
{
|
||||
return m_nGlobalID++;
|
||||
}
|
||||
|
||||
void clearAllRes()
|
||||
{
|
||||
if (m_bNeedDelRes)
|
||||
{
|
||||
for (int i = 0, n = m_vRes.size(); i < n; i++)
|
||||
{
|
||||
T* pRes = m_vRes[i];
|
||||
if (pRes)delete pRes;
|
||||
}
|
||||
}
|
||||
m_vRes.clear();
|
||||
}
|
||||
|
||||
void resetGlobalID()
|
||||
{
|
||||
m_nGlobalID = 0;
|
||||
}
|
||||
|
||||
public:
|
||||
std::vector<T*> m_vRes;
|
||||
int m_nGlobalID;
|
||||
bool m_bNeedDelRes;
|
||||
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCOrderResManager_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,627 @@
|
||||
/**
|
||||
@file JCPerfHUD.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_18
|
||||
*/
|
||||
|
||||
#include "JCPerfHUD.h"
|
||||
#include <util/Log.h>
|
||||
#include <util/JCCommonMethod.h>
|
||||
#include "../LayaGL/JCLayaGL.h"
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES3/gl.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#endif
|
||||
namespace laya
|
||||
{
|
||||
//----------------------------------------------------------------------------
|
||||
int JCPerfHUD::m_nMaxData=100;
|
||||
double JCPerfHUD::m_tmCurRender =0;
|
||||
double JCPerfHUD::m_tmDelayTime = 0;
|
||||
PerfDataBase* JCPerfHUD::m_vDatas[MAXPERFDATA];
|
||||
std::vector<short> JCPerfHUD::m_vValidID;
|
||||
double JCPerfHUD::m_tmCurJs;
|
||||
double JCPerfHUD::m_tmVSYNC = 0.0;
|
||||
unsigned int JCPerfHUD::m_nCurVsyncFrm = 0;
|
||||
unsigned int JCPerfHUD::m_nCurDrawFrm = 0;
|
||||
float JCPerfHUD::m_fGlobalScale = 1.0;
|
||||
JCLayaGL* JCPerfHUD::m_pLayaGL = NULL;
|
||||
void PerfData::updateData( float dt)
|
||||
{
|
||||
m_DataLock.lock();
|
||||
m_vDatas.push_back(dt);
|
||||
if (m_vDatas.size()>m_nMaxData) {
|
||||
m_vDatas.pop_front();
|
||||
}
|
||||
m_DataLock.unlock();
|
||||
}
|
||||
|
||||
//假设是均匀时间
|
||||
void PerfData::drawData(JCPerfDataRender* pRender) {
|
||||
m_DataLock.lock();
|
||||
JCPerfDataRender::vertex cdata[100];
|
||||
JCPerfDataRender::vertex* pCurVert = (JCPerfDataRender::vertex*)cdata;
|
||||
|
||||
int nPanelW = pRender->m_nWidth;
|
||||
auto it = m_vDatas.begin();
|
||||
int nXOff = m_nMaxData - m_vDatas.size(); //必然>=0
|
||||
float dx = ((float)nPanelW)/m_nMaxData;
|
||||
float cx = nXOff*dx;
|
||||
int num = 0;
|
||||
for (; it != m_vDatas.end(); it++) {
|
||||
cx += dx;
|
||||
pCurVert->x = cx;
|
||||
pCurVert->y = (*it)*m_fScale;
|
||||
pCurVert++;
|
||||
num++;
|
||||
if (num > 100) {//超出上面的buffer的最大值了，先画一下。
|
||||
pRender->draw2DLines((float*)cdata, num, m_nColor);
|
||||
num = 0;
|
||||
pCurVert = (JCPerfDataRender::vertex*)cdata;
|
||||
}
|
||||
}
|
||||
if(num>0)
|
||||
pRender->draw2DLines((float*)cdata, num, m_nColor);
|
||||
m_DataLock.unlock();
|
||||
}
|
||||
|
||||
void perfBarData::addData(double tm, float st, float ed) {
|
||||
m_DataLock.lock();
|
||||
m_vDatas.push_back({ tm,st,ed });
|
||||
if (m_vDatas.size() > m_nMaxData) {
|
||||
m_vDatas.pop_front();
|
||||
}
|
||||
m_DataLock.unlock();
|
||||
}
|
||||
|
||||
void perfBarData::drawData(JCPerfDataRender* pRender) {
|
||||
static dataType datas[100];
|
||||
m_DataLock.lock();
|
||||
int datanum = m_vDatas.size();
|
||||
auto it = m_vDatas.begin();
|
||||
int di = 0;
|
||||
for (int i = 0; i < datanum; i++) {
|
||||
datas[di++] = *it++;
|
||||
if (di > 100) {
|
||||
pRender->drawAsBarGraph((float*)datas, di, m_fScale, m_nColor);
|
||||
di = 0;
|
||||
}
|
||||
}
|
||||
if (di > 0) {
|
||||
pRender->drawAsBarGraph((float*)datas, di, m_fScale, m_nColor);
|
||||
}
|
||||
m_DataLock.unlock();
|
||||
}
|
||||
|
||||
ScopePerf::ScopePerf(int id)
|
||||
{
|
||||
m_t0 = tmGetCurms();
|
||||
m_nid=id;
|
||||
}
|
||||
ScopePerf::~ScopePerf()
|
||||
{
|
||||
float dt = (float)(tmGetCurms()-m_t0);
|
||||
JCPerfHUD::updateData(m_nid, dt);
|
||||
}
|
||||
void JCPerfHUD::init()
|
||||
{
|
||||
m_nMaxData=100;
|
||||
memset(m_vDatas, 0, sizeof(m_vDatas));
|
||||
addData(PHUD_FRAME_DELAY,0xffffffff,"PHUD_FRAME_DELAY", 1);
|
||||
addData(PHUD_RENDER_DELAY,0xffff0000,"PHUD_RENDER_DELAY", 1);
|
||||
addData(PHUD_JS_DELAY,0xff00ff00,"PHUD_JS_DELAY", 1);
|
||||
/*
|
||||
addData(new perfBarData(PHUD_BAR_JS_ONDRAW, 0x6600ff00, "jsbar",10.0f));
|
||||
addData(new perfBarData(PHUD_BAR_RENDER, 0x66ff0000, "renderbar",10.0f));
|
||||
addData(new perfBarData(PHUD_BAR_JSWAIT, 0x66003300, "jswait", 10.0f));
|
||||
addData(new perfBarData(PHUD_BAR_GLWAIT, 0x66660000, "glwait", 10.0f));
|
||||
*/
|
||||
}
|
||||
void JCPerfHUD::deleteInstance()
|
||||
{
|
||||
int nValidSize = JCPerfHUD::m_vValidID.size();
|
||||
for( int i=0; i < nValidSize ; i++ )
|
||||
{
|
||||
PerfData* pData =(PerfData*)JCPerfHUD::m_vDatas[JCPerfHUD::m_vValidID[i]];
|
||||
if( pData == NULL )continue;
|
||||
delete pData;
|
||||
}
|
||||
m_vValidID.clear();
|
||||
}
|
||||
|
||||
void JCPerfHUD::addVSyncFrame() {
|
||||
m_nCurVsyncFrm++;
|
||||
}
|
||||
void JCPerfHUD::addOnDrawFrame() {
|
||||
m_nCurDrawFrm++;
|
||||
}
|
||||
|
||||
void JCPerfHUD::resetFrame() {
|
||||
m_nCurVsyncFrm = 0;
|
||||
m_nCurDrawFrm = 0;
|
||||
}
|
||||
|
||||
|
||||
PerfData* JCPerfHUD::addData( int p_nId, int p_nColor,float scale ,float p_fAlert)
|
||||
{
|
||||
return addData(p_nId, p_nColor, "", scale, p_fAlert);
|
||||
}
|
||||
PerfData* JCPerfHUD::addData( int p_nId, int p_nColor,const char* p_sDesc,float scale, float p_fAlert )
|
||||
{
|
||||
if( p_nId < 0 || p_nId >= MAXPERFDATA )
|
||||
{
|
||||
LOGE("CPerfHUD::AddData超出最大数量 max=%d,cur=%d", MAXPERFDATA, p_nId );
|
||||
return NULL;
|
||||
}
|
||||
PerfData* pData = (PerfData*)m_vDatas[p_nId];
|
||||
if( pData == NULL )
|
||||
{
|
||||
pData = new PerfData( p_nId,p_nColor,p_sDesc );
|
||||
m_vDatas[p_nId]=pData;
|
||||
m_vValidID.push_back( p_nId );
|
||||
}
|
||||
pData->m_fScale = scale*m_fGlobalScale;
|
||||
pData->m_nMaxData=m_nMaxData;
|
||||
pData->m_nColor=p_nColor;
|
||||
pData->m_fAlert = p_fAlert;
|
||||
return pData;
|
||||
}
|
||||
|
||||
PerfDataBase* JCPerfHUD::addData(PerfDataBase* pData) {
|
||||
if (!pData)
|
||||
return nullptr;
|
||||
int id = pData->m_nID;
|
||||
pData->m_nMaxData = m_nMaxData;
|
||||
if (id < 0 || id >= MAXPERFDATA){
|
||||
LOGE("CPerfHUD::AddData超出最大数量 max=%d,cur=%d", MAXPERFDATA, id);
|
||||
return nullptr;
|
||||
}
|
||||
PerfDataBase* pCurData = m_vDatas[id];
|
||||
if (pCurData == NULL){
|
||||
m_vDatas[id] = pData;
|
||||
m_vValidID.push_back(id);
|
||||
}
|
||||
else {
|
||||
LOGE("已经存在数据了 %d , %s",((int)pCurData->m_nID), (pCurData->m_strDesc.c_str()));
|
||||
return pCurData;
|
||||
}
|
||||
return pData;
|
||||
}
|
||||
|
||||
void JCPerfHUD::delData(int p_nId)
|
||||
{
|
||||
if( p_nId < 0 || p_nId >= MAXPERFDATA )
|
||||
{
|
||||
return ;
|
||||
}
|
||||
PerfDataBase* pData = m_vDatas[p_nId];
|
||||
if( pData != NULL )
|
||||
{
|
||||
delete m_vDatas[p_nId];
|
||||
m_vDatas[p_nId]=NULL;
|
||||
}
|
||||
std::vector<short>::iterator it = m_vValidID.begin();
|
||||
while( it!=m_vValidID.end() )
|
||||
{
|
||||
if(*it==p_nId)
|
||||
{
|
||||
it=m_vValidID.erase(it);
|
||||
}
|
||||
else
|
||||
{
|
||||
it++;
|
||||
}
|
||||
}
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
PerfDataBase* JCPerfHUD::getData( int id )
|
||||
{
|
||||
if( id<0 || id>=MAXPERFDATA){
|
||||
LOGE("JCPerfHUD::getData超出最大数量 max=%d,cur=%d", MAXPERFDATA, id );
|
||||
return NULL;
|
||||
}
|
||||
return m_vDatas[id];
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
void JCPerfHUD::updateData( int p_nDataID, float p_fData )
|
||||
{
|
||||
if( p_nDataID<0 || p_nDataID>=MAXPERFDATA)
|
||||
{
|
||||
LOGE("JCPerfHUD::updateData超出最大数量 max=%d,cur=%d", MAXPERFDATA, p_nDataID );
|
||||
return ;
|
||||
}
|
||||
if(m_vDatas[p_nDataID])
|
||||
{
|
||||
((PerfData*)m_vDatas[p_nDataID])->updateData(p_fData);
|
||||
}
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
JCPerfDataRender::JCPerfDataRender()
|
||||
{
|
||||
m_nOffY = 100;
|
||||
m_nOffX = 100;
|
||||
m_nWidth = 400;
|
||||
m_nHeight = 400;
|
||||
m_nProgram = 0;
|
||||
m_nVSShader = 0;
|
||||
m_nPSShader = 0;
|
||||
m_sVSShader = R"(
|
||||
attribute vec3 g_Position;
|
||||
void main(){
|
||||
gl_Position = vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);
|
||||
})";
|
||||
m_sPSShader = R"(
|
||||
precision mediump float;
|
||||
uniform vec4 color;
|
||||
void main(){
|
||||
gl_FragColor = color;
|
||||
})";
|
||||
|
||||
}
|
||||
JCPerfDataRender::~JCPerfDataRender()
|
||||
{
|
||||
m_kVBOManager.ReleaseVBO();
|
||||
releaseGPUShader();
|
||||
}
|
||||
void JCPerfDataRender::validateGPUShader()
|
||||
{
|
||||
if (m_nProgram <= 0)
|
||||
{
|
||||
m_nVSShader = glCreateShader(GL_VERTEX_SHADER);
|
||||
const GLchar* sVSSource = m_sVSShader.c_str();
|
||||
glShaderSource(m_nVSShader, 1, &sVSSource, NULL);
|
||||
glCompileShader(m_nVSShader);
|
||||
m_nPSShader = glCreateShader(GL_FRAGMENT_SHADER);
|
||||
const GLchar* sPSSource = m_sPSShader.c_str();
|
||||
glShaderSource(m_nPSShader, 1, &sPSSource, NULL);
|
||||
glCompileShader(m_nPSShader);
|
||||
m_nProgram = glCreateProgram();
|
||||
glAttachShader(m_nProgram, m_nVSShader);
|
||||
glAttachShader(m_nProgram, m_nPSShader);
|
||||
glLinkProgram(m_nProgram);
|
||||
}
|
||||
}
|
||||
void JCPerfDataRender::releaseGPUShader()
|
||||
{
|
||||
if (m_nProgram)glDeleteProgram(m_nProgram);
|
||||
if (m_nProgram)glDeleteShader(m_nVSShader);
|
||||
if (m_nProgram)glDeleteShader(m_nPSShader);
|
||||
m_nProgram = 0;
|
||||
m_nVSShader = 0;
|
||||
m_nPSShader = 0;
|
||||
}
|
||||
void JCPerfDataRender::drawData()
|
||||
{
|
||||
m_tmDrawTm = tmGetCurms();
|
||||
|
||||
GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
|
||||
GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
|
||||
GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
|
||||
GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
|
||||
//last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
|
||||
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
|
||||
GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
|
||||
GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
|
||||
GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
|
||||
GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
|
||||
GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
|
||||
GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
|
||||
GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
|
||||
GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
|
||||
GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
|
||||
GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
|
||||
GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
|
||||
GLboolean last_color_write_mask[4];
|
||||
glGetBooleanv(GL_COLOR_WRITEMASK, last_color_write_mask);
|
||||
|
||||
GLint vb0enabled = 0;
|
||||
GLint vb0size = 0;
|
||||
GLint vb0type = 0;
|
||||
GLint vb0normalized = 0;
|
||||
GLint vb0stride = 0;
|
||||
GLint vb0bufferbinding = 0;
|
||||
void *vb0pointer = 0;
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &vb0enabled);
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_SIZE, &vb0size);
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_TYPE, &vb0type);
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &vb0normalized);
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &vb0stride);
|
||||
glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &vb0bufferbinding);
|
||||
glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &vb0pointer);
|
||||
|
||||
glColorMask(true, true, true, true);
|
||||
JCLayaGL::_bindVertexArray(0);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendEquation(GL_FUNC_ADD);
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glDisable(GL_CULL_FACE);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
glViewport(0, 0, JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth, JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight);
|
||||
|
||||
validateGPUShader();
|
||||
glUseProgram(m_nProgram);
|
||||
glEnableVertexAttribArray(0);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
draw2DRect(0,0,(float)m_nWidth,(float)m_nHeight,0x66000000 );
|
||||
//刻度
|
||||
float maxx= (float)m_nWidth;
|
||||
float k[4];
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 0;
|
||||
k[2]=maxx;
|
||||
k[3] = 0;
|
||||
draw2DLines( k,2,0xff336633);
|
||||
k[0] = 0;
|
||||
k[1] = 10.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2]=maxx;
|
||||
k[3] = 10.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k,2, 0x55ffff00);
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 16.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2]=maxx;
|
||||
k[3] = 16.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k,2,0x55ff0000);
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 33.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2] = maxx;
|
||||
k[3] = 33.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k, 2, 0x55ffff00);
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 50.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2]=maxx;
|
||||
k[3] = 50.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k,2, 0x550000ff);
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 100.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2]=maxx;
|
||||
k[3] = 100.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k,2, 0x550000ff);
|
||||
|
||||
k[0] = 0;
|
||||
k[1] = 167.0f*JCPerfHUD::m_fGlobalScale;
|
||||
k[2] = maxx;
|
||||
k[3] = 167.0f*JCPerfHUD::m_fGlobalScale;
|
||||
draw2DLines(k, 2, 0x550000ff);
|
||||
|
||||
//数据
|
||||
int nValidSize = JCPerfHUD::m_vValidID.size();
|
||||
for( int i=0; i < nValidSize ; i++ ){
|
||||
PerfDataBase* pData =JCPerfHUD::m_vDatas[JCPerfHUD::m_vValidID[i]];
|
||||
if( pData == NULL )continue;
|
||||
pData->drawData(this);
|
||||
}
|
||||
// Restore
|
||||
glUseProgram(last_program);
|
||||
JCLayaGL::_bindVertexArray(last_vertex_array);
|
||||
|
||||
if (vb0enabled)
|
||||
{
|
||||
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
|
||||
glVertexAttribPointer(0, vb0size, vb0type, vb0normalized, vb0stride, vb0pointer);
|
||||
}
|
||||
else
|
||||
{
|
||||
glDisableVertexAttribArray(0);
|
||||
}
|
||||
glColorMask(last_color_write_mask[0], last_color_write_mask[1], last_color_write_mask[2], last_color_write_mask[3]);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
|
||||
glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
|
||||
glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
|
||||
if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
|
||||
if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
|
||||
if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
|
||||
if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
|
||||
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
|
||||
//glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
|
||||
|
||||
}
|
||||
void JCPerfDataRender::invalidGLRes()
|
||||
{
|
||||
m_kVBOManager.freeGLResource();
|
||||
releaseGPUShader();
|
||||
}
|
||||
|
||||
/*
|
||||
数据的x轴单位是帧
|
||||
*/
|
||||
void JCPerfDataRender::draw2DLines( float* p_pVerts, int vertnum, unsigned int p_nColor)
|
||||
{
|
||||
if (vertnum < 2)
|
||||
return;
|
||||
int nVBO = m_kVBOManager.GetVBO();
|
||||
if (nVBO <= 0)
|
||||
{
|
||||
LOGE("JCPerfDataRender::draw2DLines error, createvbo error!");
|
||||
return;
|
||||
}
|
||||
static vertex tmpvertex[1000];
|
||||
float color[4];
|
||||
color[3] = ((p_nColor & 0xff000000) >> 24) / 255.0f;;
|
||||
color[0] = ((p_nColor & 0x00ff0000) >> 16) / 255.0f; //r
|
||||
color[1] = ((p_nColor & 0x0000ff00) >> 8) / 255.0f; //g
|
||||
color[2] = (p_nColor & 0x000000ff) / 255.0f; //b
|
||||
int nVertNum = vertnum > 1000 ? 1000 : vertnum;
|
||||
for (int i = 0; i < nVertNum; i++)
|
||||
{
|
||||
float cx = *p_pVerts++;
|
||||
float cy = *p_pVerts++;
|
||||
cx = m_nOffX+cx;
|
||||
cy = m_nOffY + m_nHeight - cy;
|
||||
cx = (float)((cx*2.0 / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0);
|
||||
cy = (float)(-(cy*2.0 / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0);
|
||||
tmpvertex[i].x = cx;
|
||||
tmpvertex[i].y = cy;
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, nVBO);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, nVertNum*sizeof(vertex), tmpvertex);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glUniform4fv(0, 1, color);
|
||||
glDrawArrays(GL_LINE_STRIP, 0, vertnum);
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
void JCPerfDataRender::draw2DRect(float x, float y, float w, float h, unsigned int p_nColor)
|
||||
{
|
||||
int nVBO = m_kVBOManager.GetVBO();
|
||||
if (nVBO <= 0)
|
||||
{
|
||||
LOGE("JCPerfDataRender::draw2DRect error, createvbo error!");
|
||||
return;
|
||||
}
|
||||
float color[4];
|
||||
color[3] = ((p_nColor & 0xff000000)>>24)/ 255.0f;
|
||||
color[0] = ((p_nColor & 0x00ff0000) >> 16) / 255.0f; //r
|
||||
color[1] = ((p_nColor & 0x0000ff00) >> 8) / 255.0f; //g
|
||||
color[2] = (p_nColor & 0x000000ff) / 255.0f; //b
|
||||
|
||||
static vertex tmpvertex[4];
|
||||
int nVertNum = 4;
|
||||
|
||||
//下面的是错误的。可能会导致严重的丢失精度
|
||||
tmpvertex[0].x = x;
|
||||
tmpvertex[0].y = y;
|
||||
|
||||
tmpvertex[1].x = (x + w);
|
||||
tmpvertex[1].y = y;
|
||||
|
||||
tmpvertex[2].x = (x + w);
|
||||
tmpvertex[2].y = (y + h);
|
||||
|
||||
tmpvertex[3].x = x;
|
||||
tmpvertex[3].y = (y + h);
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
float cx = tmpvertex[i].x+m_nOffX;
|
||||
float cy = tmpvertex[i].y+m_nOffY;
|
||||
|
||||
cx = (float)((cx*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0f);
|
||||
cy = (float)(-(cy*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0f);
|
||||
|
||||
tmpvertex[i].x = cx;
|
||||
tmpvertex[i].y = cy;
|
||||
}
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, nVBO);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, nVertNum*sizeof(vertex), tmpvertex);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glUniform4fv(0, 1, color);
|
||||
|
||||
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
}
|
||||
|
||||
/*
|
||||
数据的x轴单位是时间，ms。
|
||||
*/
|
||||
void JCPerfDataRender::drawAsBarGraph(float* pData, int p_nDataNum, float scale, unsigned int p_nColor) {
|
||||
if (p_nDataNum <= 1)
|
||||
return;
|
||||
int nVBO = m_kVBOManager.GetVBO();
|
||||
if (nVBO <= 0){
|
||||
LOGE("JCPerfDataRender::draw2DLines error, createvbo error!");
|
||||
return;
|
||||
}
|
||||
static vertex tmpvertex[1000];
|
||||
vertex* pCurVert = tmpvertex;
|
||||
float color[4];
|
||||
color[3] = ((p_nColor & 0xff000000) >> 24) / 255.0f;
|
||||
color[0] = ((p_nColor & 0x00ff0000) >> 16) / 255.0f; //r
|
||||
color[1] = ((p_nColor & 0x0000ff00) >> 8) / 255.0f; //g
|
||||
color[2] = (p_nColor & 0x000000ff) / 255.0f; //b
|
||||
perfBarData::dataType* pBarData = (perfBarData::dataType*)pData;
|
||||
//从当前时间倒退displayDuration ms，整个图形的，左边是m_tmDrawTm - displayDuration， 右边是 m_tmDrawTm
|
||||
static double displayDuration = 4000.0;
|
||||
double sttm = m_tmDrawTm - displayDuration;// pBarData[0].tm;
|
||||
//float edtm = pBarData[p_nDataNum - 1].tm;
|
||||
float dataduration = (float)displayDuration;//固定4秒钟。 edtm - sttm + 16.667f; //左右各加半个
|
||||
float barwidth = m_nWidth/(dataduration/16.6667f);
|
||||
float foffx = (float)m_nOffX;
|
||||
float foffy = (float)m_nOffY;
|
||||
int nVertNum = 0;
|
||||
for (int i = 0; i < p_nDataNum; i++, pBarData++) {
|
||||
if (pBarData->tm < sttm)
|
||||
continue;
|
||||
float cx = foffx + ((float)(pBarData->tm - sttm))*m_nWidth/ dataduration;
|
||||
float ltx = cx;
|
||||
float lty = foffy + m_nHeight - (pBarData->start + pBarData->duration)*scale;
|
||||
float rbx = cx + barwidth;
|
||||
float rby = foffy + m_nHeight - pBarData->start*scale;
|
||||
if (rby - lty < 1.0f)//大小不要为0，否则看不到了
|
||||
rby = lty + 1.0f;
|
||||
|
||||
ltx = ((ltx*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0f);
|
||||
lty = (-(lty*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0f);
|
||||
rbx = ((rbx*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0f);
|
||||
rby = (-(rby*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0f);
|
||||
|
||||
pCurVert->x = ltx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = rby; pCurVert++;
|
||||
pCurVert->x = ltx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = rby; pCurVert++;
|
||||
pCurVert->x = ltx; pCurVert->y = rby; pCurVert++;
|
||||
nVertNum += 6;
|
||||
if (nVertNum >= 1000 - 6) {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, nVBO);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, nVertNum*sizeof(vertex), tmpvertex);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glUniform4fv(0, 1, color);
|
||||
glDrawArrays(GL_TRIANGLES, 0, nVertNum);
|
||||
nVertNum = 0;
|
||||
pCurVert = tmpvertex;
|
||||
}
|
||||
//再把下一段画到上面
|
||||
if (true) {
|
||||
perfBarData::dataType* pBarDataN =(i<p_nDataNum-1)?(pBarData + 1):pBarData;
|
||||
float cx = foffx + ((float)(pBarData->tm - sttm))*m_nWidth / dataduration;//这个时间要用当前的
|
||||
float ltx = cx;
|
||||
float lty = foffy + m_nHeight - (pBarDataN->start + pBarDataN->duration+16.6667f)*scale;
|
||||
float rbx = cx + barwidth;
|
||||
float rby = foffy + m_nHeight - (pBarDataN->start+(float)(pBarDataN->tm-pBarData->tm))*scale;
|
||||
if (rby - lty < 1.0f)//大小不要为0，否则看不到了
|
||||
rby = lty + 1.0f;
|
||||
|
||||
ltx = ((ltx*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0f);
|
||||
lty = (-(lty*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0f);
|
||||
rbx = ((rbx*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasWidth) - 1.0f);
|
||||
rby = (-(rby*2.0f / JCPerfHUD::m_pLayaGL->m_nMainCanvasHeight) + 1.0f);
|
||||
|
||||
pCurVert->x = ltx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = rby; pCurVert++;
|
||||
pCurVert->x = ltx; pCurVert->y = lty; pCurVert++;
|
||||
pCurVert->x = rbx; pCurVert->y = rby; pCurVert++;
|
||||
pCurVert->x = ltx; pCurVert->y = rby; pCurVert++;
|
||||
nVertNum += 6;
|
||||
if (nVertNum >= 1000 - 6) {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, nVBO);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, nVertNum*sizeof(vertex), tmpvertex);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glUniform4fv(0, 1, color);
|
||||
glDrawArrays(GL_TRIANGLES, 0, nVertNum);
|
||||
nVertNum = 0;
|
||||
pCurVert = tmpvertex;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (nVertNum > 0) {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, nVBO);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, nVertNum*sizeof(vertex), tmpvertex);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glUniform4fv(0, 1, color);
|
||||
glDrawArrays(GL_TRIANGLES, 0, nVertNum);
|
||||
}
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,206 @@
|
||||
/**
|
||||
@file JCPerfHUD.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_18
|
||||
*/
|
||||
#ifndef __JCPerfHUD_H__
|
||||
#define __JCPerfHUD_H__
|
||||
|
||||
#include <list>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <stdint.h>
|
||||
#include "JCVBOManager.h"
|
||||
#include <mutex>
|
||||
#include <util/Log.h>
|
||||
#define USEPERF
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCLayaGL;
|
||||
class JCPerfDataRender;
|
||||
struct PerfDataBase{
|
||||
short m_nID=0;
|
||||
int m_nColor=0xff000000;
|
||||
std::string m_strDesc;
|
||||
unsigned short m_nMaxData=100;
|
||||
float m_fScale=1.0f; //渲染时候用
|
||||
virtual void drawData(JCPerfDataRender*) {};
|
||||
};
|
||||
/*
|
||||
记录一些变量的一定个数的历史记录。并提供画出来的功能。
|
||||
需要效率尽量高，因此，没有足够的封装和保护
|
||||
用数组而没用map
|
||||
每次updatedata都是累加数据，渲染完了之后，就会清0
|
||||
*/
|
||||
#define MAXPERFDATA 256
|
||||
struct PerfData:public PerfDataBase{
|
||||
PerfData(int id,int color, const char* pdesc){
|
||||
m_nID=id;
|
||||
m_strDesc=pdesc;
|
||||
m_nColor = color;
|
||||
}
|
||||
//添加或者累加数据 如果是新的一帧就添加，如果本帧已经有数据了，就累加
|
||||
void updateData( float dt);
|
||||
|
||||
virtual void drawData(JCPerfDataRender* pRender);
|
||||
public:
|
||||
std::list<float> m_vDatas;
|
||||
float m_fAlert=0.0f;
|
||||
std::mutex m_DataLock;
|
||||
};
|
||||
|
||||
class perfBarData :public PerfDataBase {
|
||||
public:
|
||||
struct dataType{
|
||||
double tm;
|
||||
float start, duration;
|
||||
dataType() {
|
||||
tm = start = duration = 0.0f;
|
||||
}
|
||||
dataType(double t, float st, float ed) {
|
||||
tm = t;
|
||||
start = st;
|
||||
duration = ed - st;
|
||||
}
|
||||
};
|
||||
|
||||
perfBarData(int id, int color, const char* pdesc,float scale) {
|
||||
m_nID = id;
|
||||
m_strDesc = pdesc;
|
||||
m_nColor = color;
|
||||
m_fScale = scale;
|
||||
}
|
||||
|
||||
void addData(double tm, float st, float ed);
|
||||
virtual void drawData(JCPerfDataRender* pRender);
|
||||
private:
|
||||
std::list<dataType> m_vDatas;
|
||||
std::mutex m_DataLock;
|
||||
};
|
||||
|
||||
/** @brief RenderGroup组的定义
|
||||
*
|
||||
*/
|
||||
class ScopePerf
|
||||
{
|
||||
public:
|
||||
double m_t0;
|
||||
int m_nid;
|
||||
ScopePerf(int id);
|
||||
~ScopePerf();
|
||||
};
|
||||
|
||||
#ifdef USEPERF
|
||||
#define PERF_INITVAR(var) auto var = tmGetCurms();
|
||||
#define PERF_UPDATE_DTIME(dataid,var,dt) \
|
||||
{ auto curtm = tmGetCurms(); \
|
||||
if( var==0)var = curtm; \
|
||||
dt = (curtm-var); \
|
||||
JCPerfHUD::updateData(dataid,dt); \
|
||||
var = curtm;}
|
||||
#define PERF_UPDATE_DATA(dataid,val) {JCPerfHUD::updateData(dataid,val);}
|
||||
#define PERF_SCOPE(id) ScopePerf scopeperf(id);
|
||||
#else
|
||||
#define PERF_INITVAR(var)
|
||||
#define PERF_UPDATE_DTIME(dataid,var)
|
||||
#define PERF_UPDATE_DATA(dataid,val)
|
||||
#define PERF_SCOPE(id)
|
||||
#endif
|
||||
|
||||
class JCPerfHUD
|
||||
{
|
||||
public:
|
||||
enum PERFHUD_TYPE
|
||||
{
|
||||
PHUD_FRAME_DELAY=0,
|
||||
PHUD_RENDER_DELAY,
|
||||
PHUD_JS_DELAY,
|
||||
PHUD_BAR_JS_ONDRAW,
|
||||
PHUD_BAR_RENDER,
|
||||
PHUD_BAR_JSWAIT,
|
||||
PHUD_BAR_GLWAIT,
|
||||
//TODO 现在只是内部使用。导出给js以后，要注意id的冲突的问题。
|
||||
};
|
||||
public:
|
||||
|
||||
static void init();
|
||||
|
||||
static void deleteInstance();
|
||||
|
||||
static PerfData* addData(int id, int color,float scale, float p_fAlert=0);
|
||||
|
||||
static PerfData* addData(int id, int color,const char* pdesc, float scale, float p_fAlert=0);
|
||||
|
||||
static PerfDataBase* addData(PerfDataBase* pPerfData);
|
||||
|
||||
static void delData(int id);
|
||||
|
||||
static PerfDataBase* getData(int id);
|
||||
|
||||
static void updateData(int p_nDataID, float p_fData);
|
||||
|
||||
static void addOnDrawFrame();
|
||||
static void addVSyncFrame();
|
||||
static void resetFrame();
|
||||
public:
|
||||
|
||||
static PerfDataBase* m_vDatas[MAXPERFDATA];
|
||||
static std::vector<short> m_vValidID; //有效ID，避免遍历m_Datas
|
||||
static int m_nMaxData;
|
||||
static double m_tmCurRender;
|
||||
static double m_tmDelayTime;
|
||||
static double m_tmCurJs;
|
||||
static double m_tmVSYNC;
|
||||
static unsigned int m_nCurVsyncFrm; //vsync帧数
|
||||
static unsigned int m_nCurDrawFrm; //实际触发onDraw的帧数
|
||||
static float m_fGlobalScale;
|
||||
static JCLayaGL* m_pLayaGL;
|
||||
};
|
||||
|
||||
class JCPerfDataRender
|
||||
{
|
||||
public:
|
||||
struct vertex {
|
||||
float x, y;
|
||||
};
|
||||
JCPerfDataRender();
|
||||
~JCPerfDataRender();
|
||||
void drawData();
|
||||
void draw2DLines(float* p_pVerts, int vertnum, unsigned int p_nColor);
|
||||
void draw2DRect(float x, float y, float w, float h, unsigned int p_nColor );
|
||||
/*
|
||||
data:
|
||||
start,height 都是绝对值。与面板的大小同一单位
|
||||
*/
|
||||
void drawAsBarGraph(float* pData, int p_nDataNum, float scale, unsigned int p_nColor);
|
||||
void invalidGLRes();
|
||||
|
||||
private:
|
||||
|
||||
void validateGPUShader();
|
||||
|
||||
void releaseGPUShader();
|
||||
|
||||
private:
|
||||
|
||||
JCVBOManager m_kVBOManager;
|
||||
int m_nOffY;
|
||||
int m_nOffX;
|
||||
std::string m_sVSShader;
|
||||
std::string m_sPSShader;
|
||||
GLuint m_nVSShader;
|
||||
GLuint m_nPSShader;
|
||||
GLuint m_nProgram;
|
||||
double m_tmDrawTm; //当前渲染的时候的时间。用来处理跟时间相关的数据
|
||||
public:
|
||||
int m_nWidth; //面板的大小
|
||||
int m_nHeight; //面板的大小
|
||||
};
|
||||
|
||||
}
|
||||
#endif //__JCPerfHUD_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
@file JCVBOMgr.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_18
|
||||
*/
|
||||
|
||||
#include "JCVBOManager.h"
|
||||
|
||||
namespace laya
|
||||
{
|
||||
JCVBOManager::JCVBOManager()
|
||||
{
|
||||
m_nVBOSize = 10240;
|
||||
m_nCurVBOId = 0;
|
||||
m_vVBO.resize(20);
|
||||
m_bInited = false;
|
||||
}
|
||||
int JCVBOManager::GetVBO()
|
||||
{
|
||||
if (!m_bInited)
|
||||
{
|
||||
int nSize = m_vVBO.size();
|
||||
for (int i = 0; i < nSize; i++)
|
||||
{
|
||||
m_vVBO[i] = createVertexBuffer(m_nVBOSize);
|
||||
}
|
||||
m_bInited = true;
|
||||
}
|
||||
int vbo = m_vVBO[m_nCurVBOId];
|
||||
m_nCurVBOId++;
|
||||
if (m_vVBO.size())
|
||||
{
|
||||
m_nCurVBOId %= m_vVBO.size();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_nCurVBOId = 0;
|
||||
}
|
||||
return vbo;
|
||||
}
|
||||
void JCVBOManager::freeGLResource()
|
||||
{
|
||||
int nSize = m_vVBO.size();
|
||||
glDeleteBuffers(nSize, (const GLuint*)&m_vVBO[0]);
|
||||
m_bInited = false;
|
||||
}
|
||||
void JCVBOManager::ReleaseVBO()
|
||||
{
|
||||
m_bInited = false;
|
||||
m_nCurVBOId = 0;
|
||||
}
|
||||
unsigned int JCVBOManager::createVertexBuffer( int totalSize )
|
||||
{
|
||||
unsigned int vbo = 0;
|
||||
glGenBuffers(1, &vbo);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
||||
glBufferData(GL_ARRAY_BUFFER,totalSize,0,GL_DYNAMIC_DRAW);
|
||||
return vbo;
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
@file JCVBOMgr.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2016_5_18
|
||||
*/
|
||||
|
||||
#ifndef __JCVBOMgr_H__
|
||||
#define __JCVBOMgr_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES3/gl.h>
|
||||
#include <OpenGLES/ES3/glext.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#endif
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCVBOManager
|
||||
{
|
||||
public:
|
||||
|
||||
JCVBOManager();
|
||||
|
||||
int GetVBO();
|
||||
|
||||
void ReleaseVBO();
|
||||
|
||||
unsigned int createVertexBuffer( int totalSize );
|
||||
|
||||
void freeGLResource();
|
||||
public:
|
||||
|
||||
std::vector<int> m_vVBO; //VBO
|
||||
int m_nVBOSize; //VBO的大小
|
||||
int m_nCurVBOId; //当前VBO的ID
|
||||
bool m_bInited; //是否初始化
|
||||
|
||||
};
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCVBOMgr_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,308 @@
|
||||
/**
|
||||
@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--------------------------------
|
||||
@@ -0,0 +1,197 @@
|
||||
/**
|
||||
@file JCGlobalValue.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2018_5_30
|
||||
*/
|
||||
|
||||
#ifndef __JCGlobalValue_H__
|
||||
#define __JCGlobalValue_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
enum VALUE_TYPE
|
||||
{
|
||||
VALUE_TYPE_NORMAL,
|
||||
VALUE_TYPE_MAT32,
|
||||
VALUE_TYPE_MAT2,
|
||||
VALUE_TYPE_MAT3,
|
||||
VALUE_TYPE_MAT4,
|
||||
};
|
||||
enum EXECUTE_TYPE
|
||||
{
|
||||
EXECUTE_JS_TRHEAD_BUFFER = 0,
|
||||
EXECUTE_RENDER_THREAD_BUFFER,
|
||||
EXECUTE_COPY_TO_RENDER,
|
||||
EXECUTE_COPY_TO_RENDER3D
|
||||
};
|
||||
enum VALUE_OPERATE_TYPE
|
||||
{
|
||||
VALUE_OPERATE_ADD = 0,
|
||||
VALUE_OPERATE_SUB,
|
||||
VALUE_OPERATE_MUL,
|
||||
VALUE_OPERATE_DIV,
|
||||
VALUE_OPERATE_M2_MUL,
|
||||
VALUE_OPERATE_M3_MUL,
|
||||
VALUE_OPERATE_M4_MUL,
|
||||
VALUE_OPERATE_M32_MUL,
|
||||
VALUE_OPERATE_SET,
|
||||
VALUE_OPERATE_M32_TRANSLATE,
|
||||
VALUE_OPERATE_M32_SCALE,
|
||||
VALUE_OPERATE_M32_ROTATE,
|
||||
VALUE_OPERATE_M32_SCALE_PIVOT,
|
||||
VALUE_OPERATE_M32_ROTATE_PIVOT,
|
||||
VALUE_OPERATE_M32_TRANSFORM_PIVOT,
|
||||
VALUE_OPERATE_BYTE4_COLOR_MUL,
|
||||
};
|
||||
|
||||
enum VALUE_MODIFY_TYPE
|
||||
{
|
||||
VALUE_MODIFY_MESH, //修改mesh的
|
||||
VALUE_MODIFY_SHADER, //修改shader uniform的
|
||||
VALUE_MODIFY_DATA_LOCATION, //数据区的位置
|
||||
};
|
||||
|
||||
enum VALUE_INTERIOR_TYPE
|
||||
{
|
||||
VALUE_INTERIOR_TYPE_COUNT = 0,
|
||||
};
|
||||
|
||||
struct ValueDesc
|
||||
{
|
||||
/*
|
||||
* VALUE_MODIFY_MESH,VALUE_MODIFY_SHADER
|
||||
*/
|
||||
VALUE_MODIFY_TYPE m_nModifyType;
|
||||
|
||||
/*
|
||||
* 只能是4字节对其的，不支持short
|
||||
* GL_INT, GL_FLOAT
|
||||
*/
|
||||
int m_nDataType;
|
||||
|
||||
/*
|
||||
* size传入的size
|
||||
*/
|
||||
int m_nSize;
|
||||
|
||||
/*
|
||||
* dataSize，单位是byte
|
||||
*/
|
||||
int m_nDataSize;
|
||||
|
||||
/*
|
||||
* offsetSize 偏移值为byte
|
||||
*/
|
||||
int m_nOffset;
|
||||
|
||||
/*
|
||||
* offsetSize 偏移值为byte
|
||||
*/
|
||||
char* m_pDefaultValue;
|
||||
|
||||
/*
|
||||
* 数据类型
|
||||
*/
|
||||
VALUE_TYPE m_nValueType;
|
||||
|
||||
ValueDesc()
|
||||
{
|
||||
m_nModifyType = VALUE_MODIFY_MESH;
|
||||
m_nDataType = 0;
|
||||
m_nSize = 0;
|
||||
m_nDataSize = 0;
|
||||
m_nOffset = 0;
|
||||
m_pDefaultValue = NULL;
|
||||
m_nValueType = VALUE_TYPE_NORMAL;
|
||||
}
|
||||
|
||||
~ValueDesc()
|
||||
{
|
||||
if (m_pDefaultValue)
|
||||
{
|
||||
delete[] m_pDefaultValue;
|
||||
m_pDefaultValue = NULL;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief
|
||||
*/
|
||||
class JCGlobalValue
|
||||
{
|
||||
public:
|
||||
|
||||
struct Point
|
||||
{
|
||||
float x, y;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
/** @brief构造函数
|
||||
*/
|
||||
JCGlobalValue();
|
||||
|
||||
/** @brief析构函数
|
||||
*/
|
||||
~JCGlobalValue();
|
||||
|
||||
|
||||
bool reset();
|
||||
|
||||
|
||||
/** @brief save保存状态
|
||||
* @return 返回成功失败
|
||||
*/
|
||||
bool save();
|
||||
|
||||
|
||||
/** @brief 恢复函数
|
||||
* @return 返回成功失败
|
||||
*/
|
||||
bool restore();
|
||||
|
||||
public:
|
||||
|
||||
ValueDesc* getValueDesc(int nID);
|
||||
|
||||
int addValueDefine(VALUE_MODIFY_TYPE nModifyType, int nDataType, int nSize,char* pDefaultValue,int nDefaultValueSize);
|
||||
|
||||
void endValueDefine();
|
||||
|
||||
void clone( JCGlobalValue* pValueData );
|
||||
|
||||
ValueDesc* setValue(int nValueID, char* pData, VALUE_OPERATE_TYPE nOpreateType);
|
||||
|
||||
void copyValue(int nValueID, char* pData,int nDataLenght);
|
||||
|
||||
private:
|
||||
|
||||
void createDefaultValue();
|
||||
|
||||
public:
|
||||
|
||||
char* m_pCurrentValue; ///<当前的ValueData
|
||||
|
||||
public:
|
||||
|
||||
char* m_pBuffer; ///<保存的buffer
|
||||
int m_nCurrentBufferPos; ///<当前的bufferPos
|
||||
int m_nSaveDataSize; ///<存储的dataSize
|
||||
int m_nStrideSize; ///<单个save的数据长度
|
||||
std::vector<ValueDesc*> m_vValueDesc; ///<数据描述信息
|
||||
char* m_pDefaultValue; ///<数据默认值
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCGlobalValue_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,204 @@
|
||||
/**
|
||||
@file JCGpuProgram.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2017_11_28
|
||||
*/
|
||||
|
||||
#include "JCGpuProgram.h"
|
||||
#include <util/Log.h>
|
||||
#include <stdio.h>
|
||||
|
||||
namespace laya{
|
||||
|
||||
JCGpuProgramTemplate::JCGpuProgramTemplate(const char* sVS, const char* sPS, std::vector<std::string>& vBindAtrrib)
|
||||
{
|
||||
setSrc(sVS, sPS);
|
||||
m_vAttribBind = vBindAtrrib;
|
||||
}
|
||||
JCGpuProgramTemplate::~JCGpuProgramTemplate()
|
||||
{
|
||||
freeGLResource();
|
||||
for (auto& v : m_vShaderCache)
|
||||
{
|
||||
delete v.second;
|
||||
}
|
||||
m_vShaderCache.clear();
|
||||
}
|
||||
void JCGpuProgramTemplate::setSrc(const char* sVS, const char* sPS)
|
||||
{
|
||||
if (!sVS || !sPS)return;
|
||||
m_sVS = sVS;
|
||||
m_sPS = sPS;
|
||||
}
|
||||
JCGpuProgram* JCGpuProgramTemplate::getInstance(const char* sMacro)
|
||||
{
|
||||
std::map<std::string, JCGpuProgram*>::iterator iter = m_vShaderCache.find(sMacro);
|
||||
if (iter != m_vShaderCache.end())
|
||||
{
|
||||
return (*iter).second;
|
||||
}
|
||||
JCGpuProgram* pRet = new JCGpuProgram();
|
||||
pRet->m_sMacro = sMacro ? sMacro : "";
|
||||
m_vShaderCache[sMacro] = pRet;
|
||||
pRet->m_pTemplate = this;
|
||||
return pRet;
|
||||
}
|
||||
void JCGpuProgramTemplate::freeGLResource()
|
||||
{
|
||||
for (auto& v : m_vShaderCache)
|
||||
{
|
||||
(v.second)->freeGLResource();
|
||||
}
|
||||
}
|
||||
JCGpuProgram::JCGpuProgram()
|
||||
{
|
||||
m_nVS = m_nPS = m_nProgram = 0;
|
||||
m_pTemplate = NULL;
|
||||
m_pUniformDesc = NULL;
|
||||
}
|
||||
JCGpuProgram::~JCGpuProgram()
|
||||
{
|
||||
freeGLResource();
|
||||
if (m_pUniformDesc)
|
||||
{
|
||||
delete (void *)m_pUniformDesc;
|
||||
}
|
||||
}
|
||||
bool JCGpuProgram::checkCompile(int nShader, char* sDesc)
|
||||
{
|
||||
GLint compiled = 0;
|
||||
glGetShaderiv(nShader, GL_COMPILE_STATUS, &compiled);
|
||||
if (!compiled)
|
||||
{
|
||||
GLint infoLen = 0;
|
||||
glGetShaderiv(nShader, GL_INFO_LOG_LENGTH, &infoLen);
|
||||
if (infoLen)
|
||||
{
|
||||
char* buf = new char[infoLen];
|
||||
if (buf)
|
||||
{
|
||||
glGetShaderInfoLog(nShader, infoLen, NULL, buf);
|
||||
LOGE("JCGpuProgram::checkCompile Could not compile shader %s:\n%s\n", sDesc ? sDesc : "", buf);
|
||||
delete[] buf;
|
||||
}
|
||||
glDeleteShader(nShader);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void JCGpuProgram::useProgram()
|
||||
{
|
||||
if( m_nProgram <= 0 )
|
||||
{
|
||||
compile();
|
||||
if(m_nProgram<=0)return;
|
||||
}
|
||||
glUseProgram( m_nProgram );
|
||||
}
|
||||
void JCGpuProgram::freeGLResource()
|
||||
{
|
||||
if( m_nVS>0 )
|
||||
{
|
||||
glDeleteShader(m_nVS);
|
||||
m_nVS = 0;
|
||||
}
|
||||
if( m_nPS )
|
||||
{
|
||||
glDeleteShader( m_nPS);
|
||||
m_nPS = 0;
|
||||
}
|
||||
glDeleteProgram( m_nProgram );
|
||||
m_nProgram = 0;
|
||||
}
|
||||
bool JCGpuProgramTemplate::splitKeyValue(const char* pSems, std::map<std::string, std::string>& vOut)
|
||||
{
|
||||
char strVarName[64];
|
||||
const char* pCur = pSems;
|
||||
char* pDes = strVarName;
|
||||
std::string* pSemNameInMap = nullptr;
|
||||
while (true)
|
||||
{
|
||||
if (*pCur != ',' && *pCur != 0)
|
||||
{
|
||||
*pDes++ = *pCur;
|
||||
}
|
||||
else
|
||||
{
|
||||
*pDes = 0;
|
||||
if (pSemNameInMap == nullptr)
|
||||
pSemNameInMap = &(vOut[strVarName]);
|
||||
else
|
||||
{
|
||||
*pSemNameInMap = strVarName;
|
||||
pSemNameInMap = nullptr;
|
||||
}
|
||||
pDes = strVarName;
|
||||
if (*pCur == 0)
|
||||
break;
|
||||
}
|
||||
pCur++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool JCGpuProgram::compile()
|
||||
{
|
||||
int nGLVS, nGLPS;
|
||||
nGLVS = glCreateShader(GL_VERTEX_SHADER);
|
||||
const char* strShaders[2] = { m_sMacro.c_str(), m_pTemplate->m_sVS.c_str() };
|
||||
glShaderSource(nGLVS, 2, strShaders, NULL);
|
||||
glCompileShader(nGLVS);
|
||||
if (!checkCompile(nGLVS, "VS"))return false;
|
||||
nGLPS = glCreateShader(GL_FRAGMENT_SHADER);
|
||||
strShaders[1] = m_pTemplate->m_sPS.c_str();
|
||||
glShaderSource(nGLPS, 2, strShaders, NULL);
|
||||
glCompileShader(nGLPS);
|
||||
if (!checkCompile(nGLPS, "PS"))return false;
|
||||
int nProgram = glCreateProgram();
|
||||
glAttachShader(nProgram, nGLVS);
|
||||
glAttachShader(nProgram, nGLPS);
|
||||
|
||||
//bind attribute location
|
||||
for (size_t i = 0; i < m_pTemplate->m_vAttribBind.size(); i++)
|
||||
{
|
||||
glBindAttribLocation(nProgram, i, m_pTemplate->m_vAttribBind[i].c_str());
|
||||
}
|
||||
glLinkProgram(nProgram);
|
||||
GLint linkStatus = GL_FALSE;
|
||||
glGetProgramiv(nProgram, GL_LINK_STATUS, &linkStatus);
|
||||
if (linkStatus != GL_TRUE)
|
||||
{
|
||||
GLint bufLength = 0;
|
||||
glGetProgramiv(nProgram, GL_INFO_LOG_LENGTH, &bufLength);
|
||||
if (bufLength)
|
||||
{
|
||||
char* buf = new char[bufLength];
|
||||
if (buf)
|
||||
{
|
||||
glGetProgramInfoLog(nProgram, bufLength, NULL, buf);
|
||||
LOGE("JCGpuProgram::compile Could not link program:\n%s\n", buf);
|
||||
delete[] buf;
|
||||
}
|
||||
}
|
||||
glDeleteProgram(nProgram);
|
||||
nProgram = 0;
|
||||
}
|
||||
m_nVS = nGLVS;
|
||||
m_nPS = nGLPS;
|
||||
m_nProgram = nProgram;
|
||||
return true;
|
||||
}
|
||||
GLuint JCGpuProgram::getGpuProgram()
|
||||
{
|
||||
if (m_nProgram > 0)return m_nProgram;
|
||||
compile();
|
||||
return m_nProgram;
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
@file JCGpuProgram.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2017_11_28
|
||||
*/
|
||||
|
||||
#ifndef __JCGpuProgram_H__
|
||||
#define __JCGpuProgram_H__
|
||||
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES3/gl.h>
|
||||
#include <OpenGLES/ES3/glext.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#endif
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace laya
|
||||
{
|
||||
class JCNamedData;
|
||||
class JCGpuProgram;
|
||||
class JCGpuProgramTemplate
|
||||
{
|
||||
public:
|
||||
|
||||
JCGpuProgramTemplate(const char* sVS, const char* sPS, std::vector<std::string>& vBindAtrrib);
|
||||
|
||||
~JCGpuProgramTemplate();
|
||||
|
||||
void setSrc(const char* sVS, const char* sPS);
|
||||
|
||||
JCGpuProgram* getInstance(const char* sMacro);
|
||||
|
||||
void freeGLResource();
|
||||
|
||||
bool splitKeyValue(const char* sBuffer, std::map<std::string, std::string>& vOut);
|
||||
|
||||
public:
|
||||
std::string m_sVS;
|
||||
std::string m_sPS;
|
||||
std::map<std::string, JCGpuProgram*> m_vShaderCache;
|
||||
std::vector<std::string> m_vAttribBind;
|
||||
};
|
||||
|
||||
/*
|
||||
gpuProgram 是一种资源，为了恢复，需要保留源代码或者对应的文件
|
||||
*/
|
||||
class JCGpuProgram
|
||||
{
|
||||
public:
|
||||
|
||||
JCGpuProgram();
|
||||
|
||||
~JCGpuProgram();
|
||||
|
||||
bool checkCompile(int nShader, char* sDesc);
|
||||
|
||||
void freeGLResource();
|
||||
|
||||
void useProgram();
|
||||
|
||||
GLuint getGpuProgram();
|
||||
|
||||
bool compile();
|
||||
|
||||
public:
|
||||
int m_nVS;
|
||||
int m_nPS;
|
||||
JCGpuProgramTemplate* m_pTemplate;
|
||||
JCNamedData* m_pUniformDesc;
|
||||
std::string m_sMacro;
|
||||
private:
|
||||
GLuint m_nProgram;
|
||||
};
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCGpuProgram_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
@file JCRegister.cpp
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2018_6_25
|
||||
*/
|
||||
|
||||
#include "JCRegister.h"
|
||||
|
||||
namespace laya
|
||||
{
|
||||
JCRegister::JCRegister(int nRegNum)
|
||||
{
|
||||
m_nRegNum = nRegNum;
|
||||
m_vRegPool.resize(m_nRegNum);
|
||||
int nMaxSize = sizeof(float) * 16;
|
||||
for (int i = 0; i < m_nRegNum; i++)
|
||||
{
|
||||
m_vRegPool[i] = new char[nMaxSize];
|
||||
}
|
||||
}
|
||||
JCRegister::~JCRegister()
|
||||
{
|
||||
for (int i = 0; i < m_nRegNum; i++)
|
||||
{
|
||||
delete[] m_vRegPool[i];
|
||||
}
|
||||
m_vRegPool.clear();
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
@@ -0,0 +1,149 @@
|
||||
/**
|
||||
@file JCRegister.h
|
||||
@brief
|
||||
@author James
|
||||
@version 1.0
|
||||
@date 2018_6_25
|
||||
*/
|
||||
|
||||
#ifndef __JCRegister_H__
|
||||
#define __JCRegister_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <math/Matrix32.h>
|
||||
#include "JCGlobalValue.h"
|
||||
|
||||
#if __APPLE__
|
||||
#include <OpenGLES/ES2/gl.h>
|
||||
#include <OpenGLES/ES2/glext.h>
|
||||
#else
|
||||
#include <GLES3/gl3.h>
|
||||
#include <EGL/egl.h>
|
||||
#include <EGL/eglext.h>
|
||||
#endif
|
||||
|
||||
namespace laya
|
||||
{
|
||||
enum RELATION_ZERO
|
||||
{
|
||||
RZ_LESS = 0, //小于
|
||||
RZ_EQUAL, //等于
|
||||
RZ_GREATER, //大于
|
||||
RZ_LEQUAL, //小于等于
|
||||
RZ_GEQUAL, //大于等于
|
||||
RZ_NOTEQUAL //不等于
|
||||
};
|
||||
class JCRegister
|
||||
{
|
||||
public:
|
||||
|
||||
JCRegister(int nRegNum=32);
|
||||
|
||||
virtual ~JCRegister();
|
||||
|
||||
inline char* getReg(int nIndex)
|
||||
{
|
||||
return m_vRegPool[nIndex];
|
||||
}
|
||||
|
||||
inline bool loadData(int nIndex, char* pData, int nDataSize)
|
||||
{
|
||||
char* pReg = m_vRegPool[nIndex];
|
||||
memcpy(pReg, pData, nDataSize);
|
||||
return true;
|
||||
}
|
||||
inline bool storeData(int nIndex, char* pData, int nDataSize)
|
||||
{
|
||||
if (nIndex >= m_nRegNum) return false;
|
||||
char* pReg = m_vRegPool[nIndex];
|
||||
memcpy(pData, pReg, nDataSize);
|
||||
return true;
|
||||
}
|
||||
inline bool operateReg(int nRegOut, int nReg1, int nReg2, int nSize, VALUE_OPERATE_TYPE nOperateType, int nDataType)
|
||||
{
|
||||
if (nRegOut >= m_nRegNum || nReg1 >= m_nRegNum || nReg2 >= m_nRegNum) return false;
|
||||
char* pReg1 = m_vRegPool[nReg1];
|
||||
char* pReg2 = m_vRegPool[nReg2];
|
||||
char* pRegOut = m_vRegPool[nRegOut];
|
||||
if (nDataType == GL_INT)
|
||||
{
|
||||
int* iReg1 = (int*)pReg1;
|
||||
int* iReg2 = (int*)pReg2;
|
||||
int* iRegOut = (int*)pRegOut;
|
||||
int size = nSize / sizeof(int);
|
||||
switch (nOperateType)
|
||||
{
|
||||
case VALUE_OPERATE_ADD:
|
||||
for (int i = 0; i < size; i++)iRegOut[i] = iReg1[i] + iReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_SUB:
|
||||
for (int i = 0; i < size; i++)iRegOut[i] = iReg1[i] - iReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_MUL:
|
||||
for (int i = 0; i < size; i++)iRegOut[i] = iReg1[i] / iReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_DIV:
|
||||
for (int i = 0; i < size; i++)iRegOut[i] = iReg1[i] * iReg2[i];
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (nDataType == GL_FLOAT)
|
||||
{
|
||||
float* fReg1 = (float*)pReg1;
|
||||
float* fReg2 = (float*)pReg2;
|
||||
float* fRegOut = (float*)pRegOut;
|
||||
int size = nSize / sizeof(float);
|
||||
switch (nOperateType)
|
||||
{
|
||||
case VALUE_OPERATE_ADD:
|
||||
for (int i = 0; i < size; i++)fRegOut[i] = fReg1[i] + fReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_SUB:
|
||||
for (int i = 0; i < size; i++)fRegOut[i] = fReg1[i] - fReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_MUL:
|
||||
for (int i = 0; i < size; i++)fRegOut[i] = fReg1[i] * fReg2[i];
|
||||
break;
|
||||
case VALUE_OPERATE_DIV:
|
||||
for (int i = 0; i < size; i++)fRegOut[i] = fReg1[i] / fReg2[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(fRegOut, fReg1, fReg2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
int m_nRegNum; ///<寄存器的个数
|
||||
std::vector<char*> m_vRegPool; ///<寄存器的池子
|
||||
|
||||
};
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#endif //__JCRegister_H__
|
||||
|
||||
//-----------------------------END FILE--------------------------------
|
||||
Reference in New Issue
Block a user