lvfulong
922 lines
30 KiB
C++
922 lines
30 KiB
C++
/**
|
|
@file JSLayaGL.cpp
|
|
@brief
|
|
@author James
|
|
@version 1.0
|
|
@date 2018_5_25
|
|
*/
|
|
|
|
#include "JSLayaGL.h"
|
|
#include "../../JCScriptRuntime.h"
|
|
#include "../../JCConchRender.h"
|
|
#include "../../JCConch.h"
|
|
#include <math/Matrix32.h>
|
|
#include "JSShaderActiveInfo.h"
|
|
#include "JSShaderPrecisionFormat.h"
|
|
#include "../../JCSystemConfig.h"
|
|
#include <LayaGL/JCLayaGLDispatch.h>
|
|
#include <set>
|
|
#include "JCWebGLPlus.h"
|
|
#ifdef __APPLE__
|
|
#include "jsc/JSArrayBufferRef.h"
|
|
#include "jsc/JSKeyframeNodeList.h"
|
|
#else
|
|
#include "v8/JSArrayBufferRef.h"
|
|
#include "v8/JSKeyframeNodeList.h"
|
|
#endif
|
|
|
|
extern int g_nInnerWidth;
|
|
extern int g_nInnerHeight;
|
|
//------------------------------------------------------------------------------
|
|
namespace laya
|
|
{
|
|
JSLayaGL* JSLayaGL::s_pLayaGL = NULL;
|
|
ADDJSCLSINFO(JSLayaGL, JSObjNode);
|
|
JSLayaGL::JSLayaGL()
|
|
{
|
|
AdjustAmountOfExternalAllocatedMemory(8192);
|
|
JCMemorySurvey::GetInstance()->newClass("layagl", 8192, this);
|
|
m_nSyncToRenderABListID = -1;
|
|
m_nFrameAndSyncCountABListID = -1;
|
|
m_nRootCommandEncoderID = -1;
|
|
m_pValueTemplate = new JCGlobalValue();
|
|
m_nProgramParameter = 0;
|
|
m_nAttribLocation = 0;
|
|
m_pShaderActiveInfo = new WebGLActiveInfo();
|
|
m_pShaderPrecisionFormat = new ShaderPrecisionFormat();
|
|
m_pShaderTemplate = NULL;
|
|
m_pGpuProgram = NULL;
|
|
m_nSyncArrayBufferCount = 0;
|
|
m_nFrameCount = 0;
|
|
m_nParameterResult = 0;
|
|
m_pRootCommandEncoder = NULL;
|
|
}
|
|
JSLayaGL::~JSLayaGL()
|
|
{
|
|
if (m_pValueTemplate)
|
|
{
|
|
delete m_pValueTemplate;
|
|
m_pValueTemplate = NULL;
|
|
}
|
|
if (m_pShaderActiveInfo)
|
|
{
|
|
delete m_pShaderActiveInfo;
|
|
m_pShaderActiveInfo = NULL;
|
|
}
|
|
if (m_pShaderTemplate)
|
|
{
|
|
delete m_pShaderTemplate;
|
|
m_pShaderTemplate = NULL;
|
|
m_pGpuProgram = NULL;
|
|
}
|
|
if (m_pShaderPrecisionFormat)
|
|
{
|
|
delete m_pShaderPrecisionFormat;
|
|
m_pShaderPrecisionFormat = NULL;
|
|
}
|
|
JCMemorySurvey::GetInstance()->releaseClass("layagl", this);
|
|
s_pLayaGL = NULL;
|
|
}
|
|
JSLayaGL* JSLayaGL::getInstance()
|
|
{
|
|
if (s_pLayaGL == NULL)
|
|
{
|
|
s_pLayaGL = new JSLayaGL();
|
|
}
|
|
return s_pLayaGL;
|
|
}
|
|
void JSLayaGL::setSyncArrayBufferID(int nSyncArrayBufferID)
|
|
{
|
|
m_nSyncToRenderABListID = nSyncArrayBufferID;
|
|
}
|
|
void JSLayaGL::setFrameAndSyncCountArrayBufferID(int nBufferID)
|
|
{
|
|
m_nFrameAndSyncCountABListID = nBufferID;
|
|
}
|
|
void JSLayaGL::setRootCommandEncoder(int nCommandEncoderID)
|
|
{
|
|
m_nRootCommandEncoderID = nCommandEncoderID;
|
|
m_pRootCommandEncoder = JCScriptRuntime::s_JSRT->m_pArrayBufferManager->getArrayBuffer(m_nRootCommandEncoderID);
|
|
}
|
|
int JSLayaGL::getThreadMode()
|
|
{
|
|
return (int)g_kSystemConfig.m_nThreadMODE;
|
|
}
|
|
int JSLayaGL::getProgramParameterEx(const char* vs, const char* ps, const char* define, int type)
|
|
{
|
|
std::string str_vs = vs;
|
|
std::string str_ps = ps;
|
|
std::string str_define = define;
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getProgramParameterEx, this, str_vs, str_ps, str_define, type));
|
|
return m_nProgramParameter;
|
|
}
|
|
JsValue JSLayaGL::getActiveAttribEx(const char* vs, const char* ps, const char* define, int nIndex)
|
|
{
|
|
std::string str_vs = vs;
|
|
std::string str_ps = ps;
|
|
std::string str_define = define;
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getActiveAttribEx, this, str_vs, str_ps, str_define, nIndex));
|
|
JSShaderActiveInfo * pActiveInfo = new JSShaderActiveInfo();
|
|
pActiveInfo->m_sName = m_pShaderActiveInfo->name;
|
|
pActiveInfo->m_nType = m_pShaderActiveInfo->type;
|
|
pActiveInfo->m_nSize = m_pShaderActiveInfo->size;
|
|
return JSP_TO_JS(JSShaderActiveInfo, pActiveInfo);
|
|
}
|
|
JsValue JSLayaGL::getActiveUniformEx(const char* vs, const char* ps, const char* define, int nIndex)
|
|
{
|
|
std::string str_vs = vs;
|
|
std::string str_ps = ps;
|
|
std::string str_define = define;
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getActiveUniformEx, this, str_vs, str_ps, str_define, nIndex));
|
|
JSShaderActiveInfo * pActiveInfo = new JSShaderActiveInfo();
|
|
pActiveInfo->m_sName = m_pShaderActiveInfo->name;
|
|
pActiveInfo->m_nType = m_pShaderActiveInfo->type;
|
|
pActiveInfo->m_nSize = m_pShaderActiveInfo->size;
|
|
return JSP_TO_JS(JSShaderActiveInfo, pActiveInfo);
|
|
}
|
|
JsValue JSLayaGL::getShaderPrecisionFormat(int shaderType, int precisionType)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getShaderPrecisionFormat, this, shaderType, precisionType));
|
|
JSShaderPrecisionFormat* pShaderPrecision = new JSShaderPrecisionFormat();
|
|
pShaderPrecision->m_nPrecision = m_pShaderPrecisionFormat->precision[0];
|
|
pShaderPrecision->m_nRangeMin = m_pShaderPrecisionFormat->range[0];
|
|
pShaderPrecision->m_nRangeMax = m_pShaderPrecisionFormat->range[1];
|
|
return JSP_TO_JS(JSShaderPrecisionFormat, pShaderPrecision);
|
|
}
|
|
|
|
JsValue JSLayaGL::getUniformEx(const char* locationName)
|
|
{
|
|
std::string strLocName = locationName;
|
|
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getUniformEx, this, strLocName));
|
|
return __JsArray<float>::ToJsArray(m_nParameterResultArray);
|
|
}
|
|
|
|
int JSLayaGL::getParameter(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getParameter, this, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
|
|
bool JSLayaGL::getBooleanv(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getBooleanv, this, pname));
|
|
return m_nParameterResultBool;
|
|
}
|
|
|
|
int JSLayaGL::getIntegerv(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getIntegerv, this, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
|
|
JsValue JSLayaGL::getIntegerArrayv(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getIntegerArrayv, this, pname));
|
|
return __JsArray<float>::ToJsArray(m_nParameterResultArray);
|
|
}
|
|
|
|
|
|
float JSLayaGL::getFloatv(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getFloatv, this, pname));
|
|
return m_nParameterResultFloat;
|
|
}
|
|
|
|
JsValue JSLayaGL::getFloatArrayv(int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getFloatArrayv, this, pname));
|
|
return __JsArray<float>::ToJsArray(m_nParameterResultArray);
|
|
}
|
|
|
|
JsValue JSLayaGL::readPixels(int x, int y, int width, int height, int format, int type)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_readPixels, this, x, y, width, height, format, type));
|
|
return createJSAB((char*)m_nParameterResultByteArray.data(), m_nParameterResultByteArray.size());
|
|
}
|
|
|
|
|
|
int JSLayaGL::getAttribLocationEx(const char* vs, const char* ps, const char* define, const char* sName)
|
|
{
|
|
std::string str_vs = vs;
|
|
std::string str_ps = ps;
|
|
std::string str_define = define;
|
|
std::string str_name = sName;
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getAttribLocationEx, this, str_vs, str_ps,str_define,str_name));
|
|
return m_nAttribLocation;
|
|
}
|
|
|
|
const char* JSLayaGL::getStringEx(unsigned int name)
|
|
{
|
|
m_sGLString = "";
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getStringEx, this, name));
|
|
return m_sGLString.c_str();
|
|
}
|
|
|
|
void JSLayaGL::_getStringEx(unsigned int name)
|
|
{
|
|
m_sGLString = (char*)glGetString(name);
|
|
}
|
|
|
|
void JSLayaGL::_getProgramParameterEx(const std::string& vs, const std::string& ps, const std::string& define, int type)
|
|
{
|
|
_createShader(vs, ps, define);
|
|
::glGetProgramiv(m_pGpuProgram->getGpuProgram(), type, &m_nProgramParameter);
|
|
}
|
|
void JSLayaGL::_getActiveAttribEx(const std::string& vs, const std::string& ps, const std::string& define, int nIndex)
|
|
{
|
|
_createShader(vs, ps, define);
|
|
::glGetActiveAttrib(m_pGpuProgram->getGpuProgram(), nIndex, m_pShaderActiveInfo->bufsize, &m_pShaderActiveInfo->length, &m_pShaderActiveInfo->size, &m_pShaderActiveInfo->type, m_pShaderActiveInfo->name);
|
|
}
|
|
void JSLayaGL::_getActiveUniformEx(const std::string& vs, const std::string& ps, const std::string& define, int nIndex)
|
|
{
|
|
_createShader(vs, ps, define);
|
|
::glGetActiveUniform(m_pGpuProgram->getGpuProgram(), nIndex, m_pShaderActiveInfo->bufsize, &m_pShaderActiveInfo->length, &m_pShaderActiveInfo->size, &m_pShaderActiveInfo->type, m_pShaderActiveInfo->name);
|
|
}
|
|
void JSLayaGL::_getAttribLocationEx(const std::string& vs, const std::string& ps, const std::string& define, const std::string& name)
|
|
{
|
|
_createShader(vs, ps, define);
|
|
m_nAttribLocation = ::glGetAttribLocation(m_pGpuProgram->getGpuProgram(), name.c_str());
|
|
}
|
|
void JSLayaGL::_getShaderPrecisionFormat(int shaderType, int precisionType)
|
|
{
|
|
::glGetShaderPrecisionFormat(shaderType, precisionType, m_pShaderPrecisionFormat->range, m_pShaderPrecisionFormat->precision);
|
|
}
|
|
|
|
struct TypeDesc {
|
|
GLenum category;
|
|
int size;
|
|
};
|
|
|
|
void JSLayaGL::_getUniformEx(const std::string& locationName)
|
|
{
|
|
static int iRet[16];
|
|
static float fRet[16];
|
|
|
|
static std::map<GLenum, TypeDesc> typeMap =
|
|
{
|
|
// float
|
|
{ GL_FLOAT, { GL_FLOAT, 1 } },
|
|
{ GL_FLOAT_VEC2, { GL_FLOAT, 2 } },
|
|
{ GL_FLOAT_VEC3, { GL_FLOAT, 3 } },
|
|
{ GL_FLOAT_VEC4, { GL_FLOAT, 4 } },
|
|
{ GL_FLOAT_MAT2, { GL_FLOAT, 4 } },
|
|
{ GL_FLOAT_MAT3, { GL_FLOAT, 9 } },
|
|
{ GL_FLOAT_MAT4, { GL_FLOAT, 16 } },
|
|
|
|
// int
|
|
{ GL_INT, { GL_INT, 1 } },
|
|
{ GL_INT_VEC2,{ GL_INT, 2 } },
|
|
{ GL_INT_VEC3,{ GL_INT, 3 } },
|
|
{ GL_INT_VEC4,{ GL_INT, 4 } },
|
|
|
|
// sampler
|
|
{ GL_SAMPLER_2D, {GL_INT, 1 } },
|
|
{ GL_SAMPLER_CUBE, {GL_INT, 1}},
|
|
|
|
// bool
|
|
{ GL_BOOL, { GL_BOOL, 1 } },
|
|
{ GL_BOOL_VEC2, { GL_BOOL, 2 } },
|
|
{ GL_BOOL_VEC3, { GL_BOOL, 3 } },
|
|
{ GL_BOOL_VEC4, { GL_BOOL, 4 } },
|
|
};
|
|
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
m_nParameterResultArray.clear();
|
|
GLint gpuProgram = 0;
|
|
::glGetIntegerv(GL_CURRENT_PROGRAM, &gpuProgram);
|
|
if (!gpuProgram)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
GLint location = ::glGetUniformLocation(gpuProgram, locationName.c_str());
|
|
|
|
GLenum type = 0;
|
|
GLsizei size = 0;
|
|
|
|
::glGetActiveUniform(gpuProgram, location, 0, nullptr, &size, &type, nullptr);
|
|
|
|
auto it = typeMap.find(type);
|
|
if (it == typeMap.end())
|
|
{
|
|
return;
|
|
}
|
|
const TypeDesc& typeDesc = it->second;
|
|
|
|
m_nParameterResultArray.push_back((float)(typeDesc.category));
|
|
|
|
if (typeDesc.category == GL_FLOAT)
|
|
{
|
|
::glGetUniformfv(gpuProgram, location, fRet);
|
|
for (int i = 0; i < typeDesc.size; i++)
|
|
{
|
|
m_nParameterResultArray.push_back(fRet[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
::glGetUniformiv(gpuProgram, location, iRet);
|
|
for (int i = 0; i < typeDesc.size; i++)
|
|
{
|
|
m_nParameterResultArray.push_back((float)iRet[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGI("getUniformEx is not supported");
|
|
}
|
|
}
|
|
|
|
|
|
void JSLayaGL::_getParameter(int pname)
|
|
{
|
|
::glGetIntegerv(pname, &m_nParameterResult);
|
|
}
|
|
|
|
void JSLayaGL::_getBooleanv(int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
if (pname == GL_BLEND || pname == GL_CULL_FACE ||
|
|
pname == GL_DEPTH_TEST || pname == GL_DEPTH_WRITEMASK ||
|
|
pname == GL_DITHER || pname == GL_SAMPLE_COVERAGE_INVERT ||
|
|
pname == GL_SCISSOR_TEST || pname == GL_STENCIL_TEST)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
|
|
::glGetBooleanv(pname, &m_nParameterResultBool);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getBooleanv not supported");
|
|
m_nParameterResultBool = GL_FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
void JSLayaGL::_getIntegerv(int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
if(pname == GL_ACTIVE_TEXTURE || pname == GL_BLEND_DST_ALPHA ||
|
|
pname == GL_BLEND_DST_RGB || pname == GL_BLEND_EQUATION ||
|
|
pname == GL_BLEND_EQUATION_ALPHA || pname == GL_BLEND_EQUATION_RGB ||
|
|
pname == GL_BLEND_SRC_ALPHA || pname == GL_BLEND_SRC_RGB ||
|
|
pname == GL_CULL_FACE_MODE || pname == GL_DEPTH_FUNC ||
|
|
pname == GL_FRONT_FACE || pname == GL_GENERATE_MIPMAP_HINT ||
|
|
pname == GL_STENCIL_BACK_FAIL || pname == GL_STENCIL_BACK_FUNC ||
|
|
pname == GL_STENCIL_BACK_PASS_DEPTH_FAIL || pname == GL_STENCIL_BACK_PASS_DEPTH_PASS || pname == GL_STENCIL_BACK_REF ||
|
|
pname == GL_STENCIL_BACK_VALUE_MASK || pname == GL_STENCIL_BACK_WRITEMASK || pname == GL_STENCIL_CLEAR_VALUE || pname == GL_STENCIL_FAIL || pname == GL_STENCIL_FUNC || pname == GL_STENCIL_PASS_DEPTH_FAIL || pname == GL_STENCIL_PASS_DEPTH_PASS || pname == GL_STENCIL_REF || pname == GL_STENCIL_VALUE_MASK || pname == GL_STENCIL_WRITEMASK || pname == GL_UNPACK_ALIGNMENT ||
|
|
pname == GL_CURRENT_PROGRAM || pname == GL_ELEMENT_ARRAY_BUFFER_BINDING ||
|
|
pname == GL_RENDERBUFFER_BINDING || pname == GL_TEXTURE_BINDING_2D ||
|
|
pname == GL_TEXTURE_CUBE_MAP || pname == GL_ARRAY_BUFFER_BINDING)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
::glGetIntegerv(pname, &m_nParameterResult);
|
|
}
|
|
else
|
|
{
|
|
static set<unsigned int> supportedNameSet = {
|
|
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, GL_MAX_CUBE_MAP_TEXTURE_SIZE,
|
|
GL_MAX_FRAGMENT_UNIFORM_VECTORS, GL_MAX_RENDERBUFFER_SIZE, GL_MAX_TEXTURE_IMAGE_UNITS,
|
|
GL_MAX_TEXTURE_SIZE, GL_MAX_VARYING_VECTORS, GL_MAX_VERTEX_ATTRIBS, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
|
|
GL_MAX_VERTEX_UNIFORM_VECTORS, GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_NUM_SHADER_BINARY_FORMATS
|
|
};
|
|
|
|
if (supportedNameSet.find(pname) != supportedNameSet.end())
|
|
{
|
|
::glGetIntegerv(pname, &m_nParameterResult);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getIntegerv not supported this type=%d", pname);
|
|
m_nParameterResult = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void JSLayaGL::_getIntegerArrayv(int pname)
|
|
{
|
|
int size = 0;
|
|
int* pRet = nullptr;
|
|
|
|
if (pname == GL_MAX_VIEWPORT_DIMS)
|
|
{
|
|
size = 2;
|
|
int ret[2] = { 0 };
|
|
pRet = ret;
|
|
}
|
|
else if (pname == GL_SCISSOR_BOX || pname == GL_VIEWPORT)
|
|
{
|
|
size = 4;
|
|
int ret[4] = { 0 };
|
|
pRet = ret;
|
|
}
|
|
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
if (pname == GL_SCISSOR_BOX || pname == GL_VIEWPORT)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
|
|
::glGetIntegerv(pname, pRet);
|
|
}
|
|
else
|
|
{
|
|
if (pname == GL_MAX_VIEWPORT_DIMS)
|
|
{
|
|
::glGetIntegerv(pname, pRet);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getIntegerv not supported");
|
|
}
|
|
}
|
|
|
|
m_nParameterResultArray.clear();
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
m_nParameterResultArray.push_back(pRet[i]);
|
|
}
|
|
}
|
|
|
|
void JSLayaGL::_getFloatv(int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
if (pname == GL_DEPTH_CLEAR_VALUE || pname == GL_SAMPLE_COVERAGE_VALUE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
::glGetFloatv(pname, &m_nParameterResultFloat);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getIntegerv not supported");
|
|
m_nParameterResultFloat = 0;
|
|
}
|
|
}
|
|
|
|
void JSLayaGL::_getFloatArrayv(int pname)
|
|
{
|
|
int size = 0;
|
|
float* pRet = nullptr;
|
|
|
|
if (pname == GL_ALIASED_LINE_WIDTH_RANGE || pname == GL_ALIASED_POINT_SIZE_RANGE ||
|
|
pname == GL_DEPTH_RANGE)
|
|
{
|
|
size = 2;
|
|
float ret[2] = { 0.0 };
|
|
pRet = ret;
|
|
}
|
|
else if (pname == GL_BLEND_COLOR || pname == GL_COLOR_CLEAR_VALUE)
|
|
{
|
|
size = 4;
|
|
float ret[4] = { 0.0 };
|
|
pRet = ret;
|
|
}
|
|
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
if (pname == GL_BLEND_COLOR || pname == GL_COLOR_CLEAR_VALUE ||
|
|
pname == GL_DEPTH_RANGE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
|
|
::glGetFloatv(pname, pRet);
|
|
}
|
|
else
|
|
{
|
|
if (pname == GL_ALIASED_LINE_WIDTH_RANGE || pname == GL_ALIASED_POINT_SIZE_RANGE ||
|
|
pname == GL_DEPTH_RANGE)
|
|
{
|
|
::glGetFloatv(pname, pRet);
|
|
}
|
|
else
|
|
{
|
|
LOGI("glGetFloatv not supported");
|
|
}
|
|
}
|
|
|
|
m_nParameterResultArray.clear();
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
m_nParameterResultArray.push_back(pRet[i]);
|
|
}
|
|
}
|
|
|
|
void JSLayaGL::_createShader(const std::string& vs, const std::string& ps, const std::string& define)
|
|
{
|
|
if (m_sShaderVS != vs || m_sShaderPS != ps || m_sShaderDefine != define)
|
|
{
|
|
if (m_pShaderTemplate)
|
|
{
|
|
delete m_pShaderTemplate;
|
|
m_pShaderTemplate = NULL;
|
|
m_pGpuProgram = NULL;
|
|
}
|
|
m_sShaderVS = vs;
|
|
m_sShaderPS = ps;
|
|
m_sShaderDefine = define;
|
|
|
|
//重新new新的shader
|
|
std::vector<std::string> vString;
|
|
m_pShaderTemplate = new JCGpuProgramTemplate(vs.c_str(), ps.c_str(),vString);
|
|
m_pGpuProgram = m_pShaderTemplate->getInstance(define.c_str());
|
|
}
|
|
}
|
|
const char* JSLayaGL::getShaderInfoLogEx(const char* source,int type)
|
|
{
|
|
std::string str_source = source;
|
|
m_sErrorInfo = "";
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getShaderInfoLog, this, str_source,type));
|
|
return m_sErrorInfo.c_str();
|
|
}
|
|
const char* JSLayaGL::getProgramInfoLogEx(const char* vs, const char* ps, const char* define)
|
|
{
|
|
std::string str_vs = vs;
|
|
std::string str_ps = ps;
|
|
std::string str_define = define;
|
|
m_sErrorInfo = "";
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getProgramInfoLog, this, str_vs, str_ps, str_define));
|
|
return m_sErrorInfo.c_str();
|
|
}
|
|
void JSLayaGL::_getShaderInfoLog(const std::string& source,int type)
|
|
{
|
|
GLuint nShader = glCreateShader(type);
|
|
const char* strShaders[1] = {source.c_str()};
|
|
glShaderSource(nShader, 1, strShaders, NULL);
|
|
glCompileShader(nShader);
|
|
//看错误
|
|
GLint nInfoLen = 0;
|
|
glGetShaderiv(nShader, GL_INFO_LOG_LENGTH, &nInfoLen);
|
|
if (nInfoLen)
|
|
{
|
|
char* buf = new char[nInfoLen];
|
|
glGetShaderInfoLog(nShader, nInfoLen, NULL, buf);
|
|
m_sErrorInfo = "";
|
|
m_sErrorInfo = buf;
|
|
delete buf;
|
|
}
|
|
glDeleteShader(nShader);
|
|
}
|
|
void JSLayaGL::_getProgramInfoLog(const std::string& vs, const std::string& ps, const std::string& define)
|
|
{
|
|
_createShader(vs, ps, define);
|
|
GLint nInfoLen = 0;
|
|
|
|
int gpuProgram = m_pGpuProgram->getGpuProgram();
|
|
if (!gpuProgram)
|
|
{
|
|
m_sErrorInfo = "invalid shaders";
|
|
}
|
|
else
|
|
{
|
|
glGetShaderiv(gpuProgram, GL_INFO_LOG_LENGTH, &nInfoLen);
|
|
if (nInfoLen)
|
|
{
|
|
char* buf = new char[nInfoLen];
|
|
glGetProgramInfoLog(m_pGpuProgram->getGpuProgram(), nInfoLen, NULL, buf);
|
|
m_sErrorInfo = "";
|
|
m_sErrorInfo = buf;
|
|
delete buf;
|
|
}
|
|
}
|
|
}
|
|
/*int JSLayaGL::getBufferParameter(int target, int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getBufferParameter, this, target,pname));
|
|
return m_nParameterResult;
|
|
}
|
|
void JSLayaGL::_getBufferParameter(int target, int pname)
|
|
{
|
|
::glGetBufferParameteriv(target, pname, &m_nParameterResult);
|
|
}*/
|
|
int JSLayaGL::getFramebufferAttachmentParameter(int target, int attachment, int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getFramebufferAttachmentParameter, this, target, attachment, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
void JSLayaGL::_getFramebufferAttachmentParameter(int target, int attachment, int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
::glGetFramebufferAttachmentParameteriv(target, attachment, pname, &m_nParameterResult);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getFramebufferAttachmentParameter not supported");
|
|
}
|
|
}
|
|
/*int JSLayaGL::getRenderbufferParameter(int target, int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getRenderbufferParameter, this, target, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
void JSLayaGL::_getRenderbufferParameter(int target, int pname)
|
|
{
|
|
::glGetRenderbufferParameteriv(target, pname, &m_nParameterResult);
|
|
}
|
|
int JSLayaGL::getTexParameter(int target, int pname)
|
|
{
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getTexParameter, this, target, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
void JSLayaGL::_getTexParameter(int target, int pname)
|
|
{
|
|
::glGetTexParameteriv(target, pname, &m_nParameterResult);
|
|
}*/
|
|
int JSLayaGL::getShaderParameter(const char* src,int type,int pname)
|
|
{
|
|
std::string str_source = src;
|
|
JCConch::s_pConchRender->setInterruptFunc(std::bind(&JSLayaGL::_getShaderParameter, this, str_source, type, pname));
|
|
return m_nParameterResult;
|
|
}
|
|
void JSLayaGL::_getShaderParameter(const std::string& source,int type, int pname)
|
|
{
|
|
GLuint nShader = glCreateShader(type);
|
|
const char* strShaders[1] = { source.c_str() };
|
|
glShaderSource(nShader, 1, strShaders, NULL);
|
|
glCompileShader(nShader);
|
|
::glGetShaderiv(nShader, pname, &m_nParameterResult);
|
|
glDeleteShader(nShader);
|
|
}
|
|
|
|
void JSLayaGL::_readPixels(int x, int y, int width, int height, int format, int type)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
|
|
m_nParameterResultByteArray.clear();
|
|
int bytes = 0;
|
|
int bytesPerRow = 0;
|
|
int comp = 0;
|
|
switch (format)
|
|
{
|
|
case GL_ALPHA:
|
|
comp = 1;
|
|
break;
|
|
case GL_RGB:
|
|
comp = 3;
|
|
break;
|
|
case GL_RGBA:
|
|
comp = 4;
|
|
break;
|
|
default:
|
|
LOGE("LayaGL Invalid parameter");
|
|
return;
|
|
break;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case GL_UNSIGNED_BYTE:
|
|
bytesPerRow = width * comp;
|
|
bytes = bytesPerRow * height;
|
|
break;
|
|
case GL_UNSIGNED_SHORT_5_6_5:
|
|
if (format != GL_RGB)
|
|
{
|
|
LOGE("LayaGL Invalid operation");
|
|
return;
|
|
}
|
|
bytesPerRow = width * 2;
|
|
bytes = bytesPerRow * height;
|
|
break;
|
|
case GL_UNSIGNED_SHORT_4_4_4_4:
|
|
case GL_UNSIGNED_SHORT_5_5_5_1:
|
|
if (format != GL_RGBA)
|
|
{
|
|
LOGE("LayaGL Invalid operation");
|
|
return;
|
|
}
|
|
bytesPerRow = width * 2;
|
|
bytes = bytesPerRow * height;
|
|
break;
|
|
case GL_FLOAT:
|
|
bytesPerRow = width * 4 * comp;;
|
|
bytes = bytesPerRow * height;
|
|
break;
|
|
default:
|
|
LOGE("LayaGL Invalid parameter");
|
|
return;
|
|
break;
|
|
}
|
|
|
|
m_nParameterResultByteArray.resize(bytes);
|
|
::glReadPixels(x, y, width, height, format, type, (void*)m_nParameterResultByteArray.data());
|
|
}
|
|
else
|
|
{
|
|
LOGI("readPixels not supported");
|
|
}
|
|
}
|
|
|
|
|
|
int JSLayaGL::checkFramebufferStatusEx(int target)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
return ::glCheckFramebufferStatus(target);
|
|
}
|
|
else
|
|
{
|
|
LOGI("checkFramebufferStatus not supported");
|
|
return 0;
|
|
}
|
|
}
|
|
int JSLayaGL::getVertexAttribEx(int index, int target)
|
|
{
|
|
int result = 0;
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
glGetVertexAttribiv(index, target, &result);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getVertexAttrib not supported");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
JsValue JSLayaGL::getVertexAttribExfv(int index, int target)
|
|
{
|
|
static float ret[4] = { 0.0 };
|
|
m_nParameterResultArray.clear();
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
glGetVertexAttribfv(index, target, ret);
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
m_nParameterResultArray.push_back(ret[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGI("getVertexAttrib not supported");
|
|
}
|
|
return __JsArray<float>::ToJsArray(m_nParameterResultArray);
|
|
}
|
|
|
|
int JSLayaGL::getVertexAttribOffset(int index, int pname)
|
|
{
|
|
void* result = nullptr;
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
::glGetVertexAttribPointerv(index, pname, &result);
|
|
}
|
|
else
|
|
{
|
|
LOGI("getVertexAttribOffset not supported");
|
|
}
|
|
|
|
return reinterpret_cast<intptr_t>(result);
|
|
}
|
|
|
|
int JSLayaGL::getBufferParameterEx(int target, int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
GLint params;
|
|
::glGetBufferParameteriv(target, pname, ¶ms);
|
|
return params;
|
|
}
|
|
else
|
|
{
|
|
LOGI("getBufferParameter not supported");
|
|
return 0;
|
|
}
|
|
}
|
|
int JSLayaGL::getRenderbufferParameterEx(int target, int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
GLint params;
|
|
::glGetRenderbufferParameteriv(target, pname, ¶ms);
|
|
return params;
|
|
}
|
|
else
|
|
{
|
|
LOGI("getRenderbufferParameter not supported");
|
|
return 0;
|
|
}
|
|
}
|
|
int JSLayaGL::getTexParameterEx(int target, int pname)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
GLint params;
|
|
::glGetTexParameteriv(target, pname, ¶ms);
|
|
return params;
|
|
}
|
|
else
|
|
{
|
|
LOGI("getTexParameter not supported");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int JSLayaGL::isEnabled(unsigned int cap)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
|
|
int ret = (int) ::glIsEnabled(cap);
|
|
|
|
return ::glIsEnabled(cap);
|
|
}
|
|
|
|
void JSLayaGL::flushCommand()
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCScriptRuntime::s_JSRT->dispatchLayaGLBuffer(false);
|
|
}
|
|
else
|
|
{
|
|
LOGI("flushCommand is not supported");
|
|
}
|
|
}
|
|
void JSLayaGL::setMainContextSize(int width,int height)
|
|
{
|
|
if (g_kSystemConfig.m_nThreadMODE == THREAD_MODE_SINGLE)
|
|
{
|
|
JCConch::s_pConchRender->m_pLayaGL->m_nMainCanvasWidth = width;
|
|
JCConch::s_pConchRender->m_pLayaGL->m_nMainCanvasHeight = height;
|
|
}
|
|
else
|
|
{
|
|
JCScriptRuntime::s_JSRT->flushSharedCmdBuffer();
|
|
JCCommandEncoderBuffer* pCmd = JCScriptRuntime::s_JSRT->m_pRenderCmd;
|
|
pCmd->append(LAYA_SET_MAIN_CONTEXT_SIZE);
|
|
pCmd->append(width);
|
|
pCmd->append(height);
|
|
}
|
|
}
|
|
void JSLayaGL::exportJS()
|
|
{
|
|
JSP_GLOBAL_CLASS("layagl", JSLayaGL);
|
|
JSP_ADD_METHOD("setFrameAndSyncCountArrayBufferID", JSLayaGL::setFrameAndSyncCountArrayBufferID);
|
|
JSP_ADD_METHOD("setSyncArrayBufferID", JSLayaGL::setSyncArrayBufferID);
|
|
JSP_ADD_METHOD("setRootCommandEncoder", JSLayaGL::setRootCommandEncoder);
|
|
JSP_ADD_METHOD("getProgramParameterEx", JSLayaGL::getProgramParameterEx);
|
|
JSP_ADD_METHOD("getStringEx", JSLayaGL::getStringEx);
|
|
JSP_ADD_METHOD("getActiveAttribEx", JSLayaGL::getActiveAttribEx);
|
|
JSP_ADD_METHOD("getActiveUniformEx", JSLayaGL::getActiveUniformEx);
|
|
JSP_ADD_METHOD("getAttribLocationEx", JSLayaGL::getAttribLocationEx);
|
|
JSP_ADD_METHOD("getShaderInfoLogEx", JSLayaGL::getShaderInfoLogEx);
|
|
JSP_ADD_METHOD("getProgramInfoLogEx", JSLayaGL::getProgramInfoLogEx);
|
|
JSP_ADD_METHOD("getShaderPrecisionFormat", JSLayaGL::getShaderPrecisionFormat);
|
|
JSP_ADD_METHOD("getUniformEx", JSLayaGL::getUniformEx);
|
|
JSP_ADD_METHOD("getParameter", JSLayaGL::getParameter);
|
|
JSP_ADD_METHOD("getBooleanv", JSLayaGL::getBooleanv);
|
|
JSP_ADD_METHOD("getIntegerv", JSLayaGL::getIntegerv);
|
|
JSP_ADD_METHOD("getIntegerArrayv", JSLayaGL::getIntegerArrayv);
|
|
JSP_ADD_METHOD("getFloatv", JSLayaGL::getFloatv);
|
|
JSP_ADD_METHOD("getFloatArrayv", JSLayaGL::getFloatArrayv);
|
|
//JSP_ADD_METHOD("getBufferParameter", JSLayaGL::getBufferParameter);
|
|
JSP_ADD_METHOD("getFramebufferAttachmentParameter", JSLayaGL::getFramebufferAttachmentParameter);
|
|
//JSP_ADD_METHOD("getRenderbufferParameter", JSLayaGL::getRenderbufferParameter);
|
|
//JSP_ADD_METHOD("getTexParameter", JSLayaGL::getTexParameter);
|
|
JSP_ADD_METHOD("getShaderParameter", JSLayaGL::getShaderParameter);
|
|
JSP_ADD_METHOD("getThreadMode", JSLayaGL::getThreadMode);
|
|
JSP_ADD_METHOD("checkFramebufferStatusEx", JSLayaGL::checkFramebufferStatusEx);
|
|
JSP_ADD_METHOD("getBufferParameterEx", JSLayaGL::getBufferParameterEx);
|
|
JSP_ADD_METHOD("getRenderbufferParameterEx", JSLayaGL::getRenderbufferParameterEx);
|
|
JSP_ADD_METHOD("getTexParameterEx", JSLayaGL::getTexParameterEx);
|
|
JSP_ADD_METHOD("isEnabled", JSLayaGL::isEnabled);
|
|
JSP_ADD_METHOD("getVertexAttribEx", JSLayaGL::getVertexAttribEx);
|
|
JSP_ADD_METHOD("getVertexAttribExfv", JSLayaGL::getVertexAttribExfv);
|
|
JSP_ADD_METHOD("getVertexAttribOffset", JSLayaGL::getVertexAttribOffset);
|
|
JSP_ADD_METHOD("flushCommand", JSLayaGL::flushCommand);
|
|
JSP_ADD_METHOD("readPixels", JSLayaGL::readPixels);
|
|
JSP_ADD_METHOD("setMainContextSize", JSLayaGL::setMainContextSize);
|
|
JSP_INSTALL_GLOBAL_CLASS("layagl", JSLayaGL,this);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------END FILE--------------------------------
|