lvfulong
1084 lines
39 KiB
C++
1084 lines
39 KiB
C++
#ifdef _TEST_
|
|
#include "../JCTestManager.h"
|
|
#include <3DRS/JCRenderer.h>
|
|
#include <3DRS/JCRenderGroupData.h>
|
|
#include <3DRS/JCGpuProgram.h>
|
|
#include <buffer/JCBuffer.h>
|
|
#include <fileSystem/JCFilesystem.h>
|
|
#include <imageLib/JCImageRW.h>
|
|
#include <3DRS/JCMaterial.h>
|
|
#include <3DRS/JCConchMesh.h>
|
|
#include <3DRS/JCVertexBuffer.h>
|
|
#include "../../WindowsEnv/winWindows.h"
|
|
#include "../../WindowsEnv/gles.h"
|
|
#include <misc/JCWorkerThread.h>
|
|
#include <JCIGLRender.h>
|
|
#include <3DRS/JCMeshBuilder.h>
|
|
#include <gl/GL.h>
|
|
#include <util/Log.h>
|
|
#include <Image/JCImage.h>
|
|
|
|
using namespace laya;
|
|
namespace laya {
|
|
extern JCWorkerThread* g_DecThread;
|
|
}
|
|
/*
|
|
0.基本函数的对象检查
|
|
1.vertexbuffer
|
|
|
|
1.rendersys正常
|
|
1.能渲染二维
|
|
1.
|
|
2.多层uv的情况
|
|
2.能渲染三维
|
|
1.自己创建的模型
|
|
2.加载模型文件
|
|
|
|
2.资源缩减
|
|
3.能渲染单张图片
|
|
1.原始大小渲染
|
|
2.节省模式渲染
|
|
1.image缩小
|
|
2.贴图缩小
|
|
4.能渲染大图集
|
|
*/
|
|
|
|
namespace renderTest {
|
|
const char* _2dvs = R"(
|
|
attribute vec2 position;
|
|
attribute vec2 texcoord;
|
|
attribute vec4 color;
|
|
uniform vec4 g_DevInfo;
|
|
uniform mat4 g_OffsetMatrix;
|
|
varying vec2 texCoord;
|
|
varying vec4 oColor;
|
|
void main()
|
|
{
|
|
float cx = (position.x*2.0/g_DevInfo.x)-1.0;
|
|
float cy = -(position.y*2.0/g_DevInfo.y)+1.0;
|
|
gl_Position = vec4(cx, cy, 0.5, 1.0);
|
|
texCoord.xy = texcoord;
|
|
oColor = color;
|
|
}
|
|
)";
|
|
const char* _2dps = R"(
|
|
#define PI 3.141593
|
|
precision mediump float;
|
|
|
|
uniform sampler2D g_Tex0;
|
|
uniform vec4 u_color; //rgb,strength
|
|
uniform vec4 u_blurInfo; //blurw,blurh,texw,texh
|
|
uniform vec4 u_blur_off; //blurx,blury,offx,offy
|
|
uniform float g_Alpha;
|
|
uniform vec4 g_TexRange; //r,g,b表示rgb的亮度调整，w表示饱和度的调整。w从-1到1（0到1？）.
|
|
//fillimage的时候是纹理范围
|
|
uniform vec4 g_Filter; //x alpha , y 1-饱和度 z 饱和度/3
|
|
|
|
varying vec2 texCoord;
|
|
varying vec4 oColor; //顶点输出的颜色
|
|
|
|
vec2 getFillImgTexcoord(){
|
|
vec2 newTexCoord;
|
|
newTexCoord.x = mod((texCoord.x-g_TexRange.x),g_TexRange.y)+g_TexRange.x;
|
|
newTexCoord.y = mod((texCoord.y-g_TexRange.z),g_TexRange.w)+g_TexRange.z;
|
|
return newTexCoord;
|
|
}
|
|
|
|
float sigma=u_blurInfo.x/3.0;//3σ以外影响很小。即当σ=1的时候，半径为3
|
|
float sig2 = sigma*sigma;
|
|
float _2sig2 = 2.0*sig2;
|
|
float gauss1 = 1.0/(2.0*PI*sig2);
|
|
|
|
float getGaussian(float x, float y){
|
|
return gauss1*exp(-(x*x+y*y)/_2sig2);
|
|
}
|
|
|
|
vec4 blur(vec2 texcoord){
|
|
const float blurw = 9.0;
|
|
vec4 vec4Color = vec4(0.0,0.0,0.0,0.0);
|
|
vec2 halfsz=vec2(blurw,blurw)/2.0/u_blurInfo.zw;
|
|
vec2 startpos=texcoord-halfsz-u_blur_off.zw;
|
|
vec2 ctexcoord = startpos;
|
|
vec2 step = 1.0/u_blurInfo.zw; //每个像素
|
|
|
|
for(float y = 0.0;y<=blurw; ++y){
|
|
ctexcoord.x=startpos.x;
|
|
for(float x = 0.0;x<=blurw; ++x){
|
|
//TODO 纹理坐标的固定偏移应该在vs中处理
|
|
vec4Color += texture2D(g_Tex0, ctexcoord)*getGaussian(x-blurw/2.0,y-blurw/2.0);
|
|
ctexcoord.x+=step.x;
|
|
}
|
|
ctexcoord.y+=step.y;
|
|
}
|
|
return vec4Color;
|
|
}
|
|
|
|
vec4 filter(vec4 color){
|
|
float avg = dot(color.xyz, g_Filter.zzz);
|
|
color.rgb = (avg + g_TexRange.xyz*color.rgb*g_Filter.y );
|
|
color.a *= g_Filter.x;
|
|
return color;
|
|
}
|
|
|
|
//TODO 测试这样写效率是不是降低了
|
|
void main(){
|
|
vec2 texc = texCoord;
|
|
#ifdef FILL_IMG_ADJ_TEXC
|
|
texc = getFillImgTexcoord();
|
|
#endif
|
|
|
|
#ifdef TYPE_FILLCOLOR
|
|
vec4 color = oColor;
|
|
#elif defined(TYPE_TEXTURE)
|
|
vec4 color =texture2D(g_Tex0, texc);
|
|
#elif defined(TYPE_GLOW)
|
|
vec4 color = blur(texc);
|
|
color = vec4(u_color.rgb,color.a*u_color.w);
|
|
#elif defined(TYPE_BLUR)
|
|
vec4 color = blur(texc);
|
|
#endif
|
|
|
|
#ifdef USE_FILTER
|
|
color = filter(color);
|
|
#endif
|
|
|
|
gl_FragColor=color;
|
|
#ifdef USE_G_ALPHA
|
|
gl_FragColor.w*=g_Alpha;
|
|
#endif
|
|
}
|
|
)";
|
|
|
|
/*
|
|
class CRender1{
|
|
public:
|
|
JCGpuProgram* m_pTestShader;
|
|
mesh* m_pTestMesh;
|
|
Material* m_pTestMaterial;
|
|
RenderGroupData m_RenderGroupData;
|
|
ShaderLinkInfo m_ShaderInfo;
|
|
float m_fV;
|
|
|
|
void setup(){
|
|
m_fV = 0;
|
|
m_pTestShader = new gpuProgram();
|
|
|
|
buffer bufvs;
|
|
char* pVSSrc="attribute vec3 g_Position;\
|
|
attribute vec2 g_TexCoord0;\
|
|
varying vec2 texCoord;\
|
|
void main(){\
|
|
gl_Position = vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);\
|
|
texCoord=g_TexCoord0;\
|
|
}";
|
|
char* pPSSrc="precision mediump float;"
|
|
"uniform sampler2D g_Tex0;"
|
|
"varying vec2 texCoord;"
|
|
"varying vec4 vertColor;"
|
|
"void main(){"
|
|
" gl_FragColor=texture2D(g_Tex0, texCoord);\n\
|
|
}";
|
|
m_pTestShader->setSrc(pVSSrc, pPSSrc);
|
|
int nProgram = m_pTestShader->compile();
|
|
|
|
//load jpeg
|
|
buffer buf;
|
|
readFileSync("d:/temp/gameicon.png",buf);
|
|
BitmapData bmp;
|
|
bool b = loadImageMemSync(buf.m_pPtr, buf.m_nLen, bmp);
|
|
|
|
LayaTexture* pLayaTexture = new LayaTexture(NULL,NULL, LayaTexture::TEXTURE_TYPE_NORMAL);
|
|
pLayaTexture->setTextureSize(bmp.m_nWidth, bmp.m_nHeight);
|
|
pLayaTexture->copyImageToTexture(&bmp,0,1,1);
|
|
|
|
m_pTestMaterial = new Material();
|
|
m_pTestMaterial->m_fAlpha = 1.0f;
|
|
m_pTestMaterial->setShaderProgram((Shader*)m_pTestShader);
|
|
m_pTestMaterial->m_nBlendType = Material::BLEND_TYPE_NORMAL;
|
|
m_pTestMaterial->m_fColor[0]=1;
|
|
m_pTestMaterial->m_fColor[1]=1;
|
|
m_pTestMaterial->m_fColor[2]=0;
|
|
m_pTestMaterial->m_fColor[3]=0;
|
|
|
|
m_pTestMaterial->m_pTexture[0] = pLayaTexture;
|
|
|
|
m_pTestMesh = new mesh();
|
|
|
|
//VB
|
|
m_pTestMesh->createVB(20,4);
|
|
JCMemClass* pMemBuffer = m_pTestMesh->getVB()->getMemBuffer(0);
|
|
pMemBuffer->clear();
|
|
|
|
vertex v[4]={{-0.5f,0.5f,0.5f,0,0}, {0.5f,0.5f,0.5f,1,0},
|
|
{0.5f,-0.5f,0.5f,1,1},{-0.5f,-0.5f,0.5f,0,1}};
|
|
pMemBuffer->append(v,sizeof(v));
|
|
|
|
//IB
|
|
m_pTestMesh->createIB(GL_UNSIGNED_SHORT, 6);
|
|
pMemBuffer = m_pTestMesh->getIB()->getMemBuffer(0);
|
|
pMemBuffer->clear();
|
|
unsigned short idx[6]={0,1,2,2,0,3};
|
|
pMemBuffer->append(idx,sizeof(idx));
|
|
|
|
VertexDesc* pVertDesc = m_pTestMesh->m_pVertDesc = new VertexDesc();
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribPostion, GL_FLOAT_VEC3,0,0));
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribTexCoord0,GL_FLOAT_VEC2,3*4,0));
|
|
|
|
namedData* pDefMaterialDesc = getDefaultMaterialNamedData();
|
|
renderer::bindShaderFetch(m_ShaderInfo,pVertDesc, nProgram, &pDefMaterialDesc,1);
|
|
m_RenderGroupData.m_pShaderInfo = &m_ShaderInfo;
|
|
m_RenderGroupData.m_pMaterial = m_pTestMaterial;
|
|
m_RenderGroupData.m_nBegin=0;
|
|
m_RenderGroupData.m_nEnd=6;
|
|
//m_pTestMesh->m_pShaderInfo = &sinfo;
|
|
}
|
|
*/
|
|
/*
|
|
void runLoop(){
|
|
glClearColor(0,0.2f,0,1);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
|
|
//TEST
|
|
JCMemClass* pMemBuffer = m_pTestMesh->getVB()->getMemBuffer(0);
|
|
float* pVertex = (float*)pMemBuffer->getBuf();
|
|
pVertex[0] = sinf(m_fV);
|
|
m_fV+=0.1f;
|
|
pMemBuffer->setChangedFlag(true);
|
|
|
|
m_pTestMaterial->m_fColor[2]=pVertex[0];
|
|
|
|
renderer::renderMesh(m_pTestMesh, &m_RenderGroupData, (char**)&m_pTestMaterial, 1);
|
|
}
|
|
};
|
|
|
|
void _1_1_1_test(){
|
|
class TestRender:public IGLRender{
|
|
public:
|
|
virtual void onGLReady(){
|
|
r.setup();
|
|
}
|
|
|
|
virtual void renderFrame(long,bool){
|
|
r.runLoop();
|
|
GLvoid* pix=new char[100];
|
|
glReadPixels(0,0,1,1,GL_RGBA,GL_UNSIGNED_BYTE,pix);
|
|
int a=0;
|
|
delete [] pix;
|
|
}
|
|
|
|
virtual void onGLDestory(){
|
|
int a=0;
|
|
}
|
|
virtual void invalidGLRes(){}
|
|
virtual void freeGLRes() {}
|
|
void setProcess(ProcessInterface*) {}
|
|
CRender1 r;
|
|
};
|
|
|
|
GLEnvThread gl;
|
|
TestRender render;
|
|
gl.init(&render,800,600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
|
|
void _1_1_2_test(){
|
|
class TestRender:public IGLRender{
|
|
public:
|
|
virtual void onGLReady(){
|
|
//编译shader
|
|
m_pTestShader = new gpuProgram();
|
|
char* pVSSrc="attribute vec3 g_Position;\
|
|
attribute vec2 g_TexCoord0;\
|
|
attribute vec2 g_TexCoord1;\
|
|
varying vec2 tex0;\
|
|
varying vec2 tex1;\
|
|
void main(){\
|
|
gl_Position = vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);\
|
|
tex0=g_TexCoord0;\
|
|
tex1=g_TexCoord0;\
|
|
}";
|
|
char* pPSSrc="precision mediump float;"
|
|
"uniform sampler2D g_Tex0;"
|
|
"uniform sampler2D g_Tex1;"
|
|
"varying vec2 tex0,tex1;"
|
|
"varying vec4 vertColor;"
|
|
"void main(){\
|
|
vec4 col1 = texture2D(g_Tex1,tex0);\n\
|
|
gl_FragColor=col1+texture2D(g_Tex0, tex0);\n\
|
|
}";
|
|
m_pTestShader->setSrc(pVSSrc, pPSSrc);
|
|
int nProgram = m_pTestShader->compile();
|
|
//创建mesh
|
|
m_pTestMesh = new mesh();
|
|
//VB
|
|
m_pTestMesh->createVB(20,4);
|
|
JCMemClass* pMemBuffer = m_pTestMesh->getVB()->getMemBuffer(0);
|
|
pMemBuffer->clear();
|
|
|
|
vertex v[4]={{-0.5f,0.5f,0.5f,0,0}, {0.5f,0.5f,0.5f,1,0},
|
|
{0.5f,-0.5f,0.5f,1,1},{-0.5f,-0.5f,0.5f,0,1}};
|
|
pMemBuffer->append(v,sizeof(v));
|
|
|
|
//IB
|
|
m_pTestMesh->createIB(GL_UNSIGNED_SHORT, 6);
|
|
pMemBuffer = m_pTestMesh->getIB()->getMemBuffer(0);
|
|
pMemBuffer->clear();
|
|
unsigned short idx[6]={0,1,2,2,0,3};
|
|
pMemBuffer->append(idx,sizeof(idx));
|
|
|
|
//Texture
|
|
buffer buf;
|
|
BitmapData bmp;
|
|
readFileSync("d:/temp/gameicon.png",buf);
|
|
bool b = loadImageMemSync(buf.m_pPtr, buf.m_nLen, bmp);
|
|
LayaTexture* pTex1=new LayaTexture(NULL,NULL,100,100,0);
|
|
pTex1->copyImageToTexture(&bmp,0,1,1);
|
|
|
|
readFileSync("d:/temp/test.jpg",buf);
|
|
b = loadImageMemSync(buf.m_pPtr, buf.m_nLen, bmp);
|
|
//createGridBmp(bmp,800,800,20);
|
|
LayaTexture* pTex2=new LayaTexture(NULL,NULL,100,100,0);
|
|
pTex2->copyImageToTexture(&bmp,0,1,1);
|
|
|
|
//创建材质
|
|
m_pTestMaterial = new Material();
|
|
m_pTestMaterial->m_fAlpha = 1.0f;
|
|
m_pTestMaterial->setShaderProgram((Shader*)m_pTestShader);
|
|
m_pTestMaterial->m_nBlendType = Material::BLEND_TYPE_NORMAL;
|
|
m_pTestMaterial->m_fColor[0]=1;
|
|
|
|
m_pTestMaterial->m_pTexture[0] = pTex1;
|
|
m_pTestMaterial->m_pTexture[1] = pTex2;
|
|
|
|
VertexDesc* pVertDesc = m_pTestMesh->m_pVertDesc = new VertexDesc();
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribPostion, GL_FLOAT_VEC3,0,0));
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribTexCoord0,GL_FLOAT_VEC2,3*4,0));
|
|
|
|
namedData* pDefMaterialDesc = getDefaultMaterialNamedData();
|
|
renderer::bindShaderFetch(m_ShaderInfo,pVertDesc, nProgram, &pDefMaterialDesc,1);
|
|
m_RenderGroupData.m_pShaderInfo = &m_ShaderInfo;
|
|
m_RenderGroupData.m_pMaterial = m_pTestMaterial;
|
|
m_RenderGroupData.m_nBegin=0;
|
|
m_RenderGroupData.m_nEnd=6;
|
|
}
|
|
|
|
virtual void renderFrame(long,bool){
|
|
glClearColor(0.4f,0.2f,0.2f,1);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
renderer::renderMesh(m_pTestMesh, &m_RenderGroupData, (char**)&m_pTestMaterial, 1);
|
|
}
|
|
|
|
virtual void invalidGLRes(){}
|
|
virtual void freeGLRes() {}
|
|
virtual void setProcess(ProcessInterface* p_pCurProcess) {}
|
|
|
|
protected:
|
|
gpuProgram* m_pTestShader;
|
|
mesh* m_pTestMesh;
|
|
ShaderLinkInfo m_ShaderInfo;
|
|
RenderGroupData m_RenderGroupData;
|
|
Material* m_pTestMaterial;
|
|
};
|
|
TestRender render;
|
|
GLEnvThread gl;
|
|
gl.init(&render,600,600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
*/
|
|
/*
|
|
void _1_2_1_test3d(){
|
|
struct vertex{
|
|
float x,y,z;
|
|
float u,v;
|
|
float nx,ny,nz;
|
|
//unsigned int color;
|
|
};
|
|
struct rundata{
|
|
Matrix44 matworld;
|
|
Matrix44 matpers;
|
|
};
|
|
|
|
class render3d_1:public IGLRender{
|
|
public:
|
|
void onGLReady(){
|
|
//shader
|
|
m_pShader = new gpuProgram();
|
|
char* pVSSrc="precision mediump float; \
|
|
attribute vec3 g_Position;\
|
|
attribute vec2 g_TexCoord0;\
|
|
attribute vec3 g_Normal; \
|
|
attribute float g_alpha; \
|
|
uniform mat4 g_worldmatrix; \
|
|
uniform mat4 g_persmat; \
|
|
varying vec2 tex0;\
|
|
varying vec3 norm; \
|
|
varying float alpha; \
|
|
void main(){\
|
|
vec4 vpos = vec4(g_Position.xyz,1.0); \
|
|
gl_Position = g_persmat*g_worldmatrix*vpos; \
|
|
norm = g_Normal; \
|
|
tex0=g_TexCoord0;\
|
|
alpha = g_alpha; \
|
|
}";
|
|
char* pPSSrc="precision mediump float;"
|
|
"uniform sampler2D g_Tex0;"
|
|
"uniform sampler2D g_Tex1;"
|
|
"varying vec2 tex0,tex1;"
|
|
"varying vec3 norm;"
|
|
"varying vec4 vertColor;"
|
|
"varying float alpha;"
|
|
"void main(){\
|
|
vec4 col1 = texture2D(g_Tex1,tex0);\n\
|
|
gl_FragColor=vec4(col1.xyz, 1.0);\
|
|
}";
|
|
m_pShader->setSrc(pVSSrc, pPSSrc);
|
|
int nProgram = m_pShader->compile();
|
|
int nVertNum=24;
|
|
//TODO 需要测试直接创建多流的情况
|
|
JCMeshBuilder::Geom geo;
|
|
JCMeshBuilder::BuildBoxGeo(true,.8f, .8f, .8f,geo);
|
|
VertexDesc* pVertDesc = m_mesh.m_pVertDesc = new VertexDesc();
|
|
//0
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribPostion, GL_FLOAT_VEC3,0,0));
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc(gpuProgram::shader_AtrribTexCoord0, GL_FLOAT_VEC2,3*4,0));
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc("g_Normal", GL_FLOAT_VEC3,5*4,0));
|
|
//1
|
|
pVertDesc->m_VertDescs.push_back(VertexDesc::Desc("g_alpha", GL_FLOAT,sizeof(vertex)*nVertNum,1));
|
|
|
|
int idxnum=36;
|
|
m_mesh.createVB(sizeof(vertex),nVertNum);
|
|
m_mesh.createIB(GL_UNSIGNED_SHORT,idxnum);
|
|
m_mesh.addStream(sizeof(float)); //alpha
|
|
JCMemClass* pgeo = m_mesh.getVBMem(0);
|
|
JCMemClass* palpha = m_mesh.getVBMem(1);
|
|
JCMemClass* pidx = m_mesh.getIB()->getMemBuffer(0);
|
|
|
|
//通知一下实际大小。
|
|
pgeo->appendEmpty(sizeof(vertex)*nVertNum);
|
|
palpha->appendEmpty(nVertNum*sizeof(float));
|
|
vertex* pS1 = (vertex*)pgeo->getBuf();
|
|
|
|
for( int i=0; i<nVertNum; i++){
|
|
pS1->x = *(geo.pVertex)++;
|
|
pS1->y = *geo.pVertex++;
|
|
pS1->z = *geo.pVertex++;
|
|
|
|
pS1->u = *geo.pUV++;
|
|
pS1->v = *geo.pUV++;
|
|
|
|
pS1->nx = *geo.pNorm++;
|
|
pS1->ny = *geo.pNorm++;
|
|
pS1->nz = *geo.pNorm++;
|
|
pS1++;
|
|
}
|
|
//memcpy(pS1,v,sizeof(v));
|
|
|
|
char* pS2 = palpha->getBuf();
|
|
//memset(pS2,0,palpha->size());
|
|
float* pA =(float*)pS2;
|
|
for(int i=0; i<nVertNum; i++)
|
|
pA[i]=1.0f;
|
|
pA[1]=0.5f;
|
|
|
|
//index
|
|
pidx->appendEmpty(geo.nIdxNum*sizeof(unsigned short));
|
|
char* pidxdt = pidx->getBuf();
|
|
memcpy(pidxdt, geo.pIdx,geo.nIdxNum*sizeof(unsigned short));
|
|
|
|
//Texture
|
|
BitmapData bmp = loadLocalImageSync("d:/temp/test.jpg");
|
|
LayaTexture* pTex1=new LayaTexture(NULL,NULL,200,200,0);
|
|
pTex1->copyImageToTexture(&bmp,0,1,1);
|
|
delete [] bmp.m_pImageData;
|
|
|
|
//创建材质
|
|
m_pMaterial = new Material();
|
|
m_pMaterial->m_fAlpha = 1.0f;
|
|
m_pMaterial->setShaderProgram((Shader*)m_pShader);
|
|
m_pMaterial->m_nBlendType = Material::BLEND_TYPE_NORMAL;
|
|
m_pMaterial->m_fColor[0]=1;
|
|
m_pMaterial->m_pTexture[0] = pTex1;
|
|
m_pMaterial->m_bEnableZ=true;
|
|
|
|
namedData* pDefMaterialDesc = getDefaultMaterialNamedData();
|
|
namedData* pRundata = new namedData();
|
|
pRundata->add("g_worldmatrix",0,namedData::tp_mat4,1);
|
|
pRundata->add("g_persmat",(int)(&((rundata*)0)->matpers), namedData::tp_mat4,1);
|
|
|
|
namedData* datadesc[2]={pDefMaterialDesc,pRundata};
|
|
renderer::bindShaderFetch(m_ShaderInfo,pVertDesc, nProgram, datadesc,2);
|
|
m_RenderGroupData.m_pShaderInfo = &m_ShaderInfo;
|
|
m_RenderGroupData.m_pMaterial = m_pMaterial;
|
|
m_RenderGroupData.m_nBegin=0;
|
|
m_RenderGroupData.m_nEnd=idxnum;
|
|
|
|
//TODO
|
|
glDisable(GL_CULL_FACE);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glEnable(GL_ALPHA_TEST);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_BLEND);
|
|
int a=0;
|
|
}
|
|
void renderFrame(long,bool){
|
|
glClearColor(0.4f,0.2f,0.2f,1);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
Matrix44 matw;
|
|
static float f=(Pi/4.0f);
|
|
f+=0.01f;
|
|
matw = Matrix44::CreateFromAxisAngle(float3(1,1.0f,0),f);
|
|
Matrix44 matper = Matrix44::CreatePerspective(800,600,1,10);
|
|
Matrix44& mat = m_RunData.matworld;
|
|
matw.M43 = -2;
|
|
mat = matw;
|
|
//mat.M41=sinf(f);
|
|
//mat.M43 = 0.6f;
|
|
Matrix44& persmat = m_RunData.matpers;
|
|
persmat =Matrix44::CreatePerspectiveFieldOfView(80.0f*Pi/180.0f,1.0f,0.1f,10.0f);
|
|
char* pdata[2];
|
|
pdata[0]=(char*)m_pMaterial;
|
|
pdata[1]=(char*)&m_RunData;
|
|
if(0)
|
|
renderer::renderMesh(&m_mesh, &m_RenderGroupData, (char**)pdata, 2);
|
|
else{
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_DEPTH_TEST);
|
|
GLuint texs[2]={m_pMaterial->m_pTexture[0]->m_pGpuTexture,m_pMaterial->m_pTexture[0]->m_pGpuTexture};
|
|
renderer::renderMesh1(&m_mesh,m_RenderGroupData.m_nBegin, m_RenderGroupData.m_nEnd, m_pMaterial->m_pShaderProgram->m_nProgram,
|
|
(ShaderLinkInfo*)m_RenderGroupData.m_pShaderInfo, (int*)texs,2,(int*)texs,2,pdata,2);
|
|
}
|
|
mat.M41=0.2f;
|
|
//renderer::renderMesh(&m_mesh, &m_RenderGroupData, (char**)pdata, 2);
|
|
}
|
|
virtual void invalidGLRes() {}
|
|
virtual void freeGLRes() {}
|
|
virtual void setProcess(ProcessInterface* p_pCurProcess) {}
|
|
|
|
mesh m_mesh;
|
|
gpuProgram* m_pShader;
|
|
Material* m_pMaterial;
|
|
rundata m_RunData;
|
|
ShaderLinkInfo m_ShaderInfo;
|
|
RenderGroupData m_RenderGroupData;
|
|
};
|
|
|
|
render3d_1 renderor;
|
|
GLEnvThread gl;
|
|
gl.init(&renderor,800,600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
|
|
void _1_2_1_test3dmodel(){
|
|
class Renderer:public IGLRender{
|
|
};
|
|
}
|
|
|
|
void _2_1_test(){
|
|
Process proc(NULL);
|
|
LayaTexture* pTex = new LayaTexture(NULL,NULL,2048,2048,0);
|
|
pTex->setScale( 2,3,2,3);
|
|
BitmapData bmpdata;
|
|
createGridBmp(bmpdata,20,20,4);
|
|
//
|
|
BitmapData downd;
|
|
int frac[]={1,2,1,2};
|
|
downsampleBmp(bmpdata,downd,frac,false);
|
|
ImageBaseInfo ifo={downd.m_nWidth,downd.m_nHeight,32};
|
|
saveAsJpeg(downd.m_pImageData, ifo,"d:/temp/ss.jpg");
|
|
int borderFlag = ResBase::BOARDER_TYPE_RIGHT|ResBase::BOARDER_TYPE_BOTTOM;
|
|
//这个函数会缩小贴图
|
|
//pTex->copyImageToTexture(&bmpdata,borderFlag,1,1);
|
|
//pTex->mergeTexture(&bmpdata,borderFlag,0,0,1,1);
|
|
int rssz = pTex->getResSize();
|
|
int width = pTex->getWidth();
|
|
}
|
|
|
|
void _3_1_testdrawImageCB(resStateDispatcher*, bool* bEnd){
|
|
*bEnd=true;
|
|
}
|
|
void _3_1_testOnUpdate(void* pParam){
|
|
if(pParam){
|
|
int* pPars=(int*)pParam;
|
|
RenderImg* pRImg = (RenderImg*)pPars[0];
|
|
LayaContext* pCtx = (LayaContext*)pPars[1];
|
|
//p_nPaintKey为0则不会引起重新更新mesh
|
|
//pRImg->render(pCtx,0,NULL,0,0,pRImg->m_pImage->getWidth(),pRImg->m_pImage->getHeight());
|
|
pRImg->render(pCtx,1,NULL,0.0f,0.0f,(float)pRImg->m_pImage->getWidth(),(float)pRImg->m_pImage->getHeight());
|
|
}
|
|
}
|
|
void _3_1_testdrawImage(){
|
|
ConchRender* pRender = new ConchRender();
|
|
Process* pProc = new Process(NULL);
|
|
pProc->m_onprocessupdate = _3_1_testOnUpdate;
|
|
pRender->setProcess(pProc);
|
|
pProc->setRunParam("not.exist.js","");
|
|
pProc->active();
|
|
Sleep(100);
|
|
//Node* n1 = new Node(pProc,0,NULL);
|
|
Image img("");
|
|
bool bLoadEnd=false;
|
|
img.setSrc(pProc,"d:/temp/test.jpg");// gameicon.png");
|
|
img.setOnReadyCB(boost::bind(_3_1_testdrawImageCB,_1,&bLoadEnd));
|
|
//img.rect(0,0,100,100);
|
|
{int i=0; while(!bLoadEnd && i<1000){i++;Sleep(10);}}
|
|
//LayaContext ctx(NULL, pProc);
|
|
//TODO 问题 process中会自动创建一个 rootcontext， 是不是有点不灵活
|
|
LayaContext* pRootCtx = pProc->getRootContext();
|
|
pRootCtx->transform(1,0,0,1,0,0);
|
|
pRootCtx->disableClip(true);
|
|
//下面的正常是在js线程中
|
|
RenderImg ri;
|
|
ri.setImg(&img);
|
|
ri.render(pRootCtx,0,NULL,0,0,100,100);
|
|
void* param[2];
|
|
param[0]=&ri;
|
|
param[1]=pRootCtx;
|
|
pProc->m_pOnProcessUpdateParam = param;
|
|
|
|
GLEnvThread gl;
|
|
gl.init(pRender,800,600);
|
|
winWindows::handleMessage(NULL);
|
|
//Sleep(10000);
|
|
//delete n1;
|
|
}
|
|
|
|
void init_3(){
|
|
}
|
|
|
|
void uninit_3(){
|
|
}
|
|
|
|
void _0_1_test(){
|
|
}
|
|
*/
|
|
|
|
void _1_testRender_GLTread_simp() {
|
|
class TestRender :public JCIGLRender {
|
|
public:
|
|
struct Vertex {
|
|
float pos[3];
|
|
int color;
|
|
Vertex(float x, float y, float z, int c) {
|
|
pos[0] = x; pos[1] = y; pos[2] = z;
|
|
color = c;
|
|
}
|
|
};
|
|
|
|
int nFrmNum = 0;
|
|
std::function<void()> funcExit;
|
|
JCConchMesh* m_pMesh = nullptr;
|
|
JCGpuProgramTemplate* m_pShaderTemp = nullptr;
|
|
JCGpuProgram* m_pProg = nullptr;
|
|
JCMaterial* m_pMaterial = nullptr;
|
|
JCShaderLink_Vertex m_LinkVertex;
|
|
JCShaderLink_Uniform m_LinkUniform;
|
|
JCRenderGroupData m_RenderGroup;
|
|
TestRender(std::function<void()> f) {
|
|
funcExit = f;
|
|
}
|
|
|
|
virtual void onGLReady() {
|
|
m_pMesh = new JCConchMesh();
|
|
m_pMesh->regVertexDesc({ { "g_Pos",GL_FLOAT_VEC3 },{ "color",GL_INT } }, 1);
|
|
|
|
m_pShaderTemp = new JCGpuProgramTemplate(
|
|
R"(
|
|
attribute vec3 g_Pos;
|
|
void main(){
|
|
gl_Position = vec4(g_Pos.x, g_Pos.y, g_Pos.z, 1.0);
|
|
}
|
|
)",
|
|
R"(
|
|
precision mediump float;
|
|
void main(){
|
|
gl_FragColor=vec4(1,1,0,1);
|
|
}
|
|
)");
|
|
m_pProg = m_pShaderTemp->getInst("", 0);
|
|
int nProg = m_pProg->getGpuProgram();
|
|
m_pMaterial = new JCMaterial();
|
|
m_pMaterial->setBlendType(JCMaterial::BLEND_TYPE_SOURCE_OVER);
|
|
m_pMaterial->setAlpha(1.0f);
|
|
m_pMaterial->setShaderProgram(m_pProg);
|
|
JCNamedData* pMaterialDesc = m_pMaterial->getNamedData();
|
|
JCVertexDesc& VDesc = m_pMesh->getVertexDesc(1);
|
|
JCRenderer::link_shader_vertex_uniformdata(m_LinkVertex, m_LinkUniform, &VDesc, m_pProg, &pMaterialDesc, 1,nullptr);
|
|
|
|
JCRenderGroupData* pGroup = m_pMesh->pushElements(1, m_pMaterial, 4, {
|
|
-0.05f,0.05f,0.5f,0 ,
|
|
0.05f,0.05f,0.5f,0 ,
|
|
0.05f,-0.05f,0.5f,0 ,
|
|
-0.05f,-0.05f,0.5f,0
|
|
},{
|
|
0,1,2,2,3,0
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkVertex;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkUniform;
|
|
}
|
|
|
|
virtual void renderFrame(long p_nCurrentFrame, bool) {
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glClearColor(0.7f, 0.7f,0.7f, 1.0f);
|
|
nFrmNum++;
|
|
if (nFrmNum > 100) {
|
|
funcExit();
|
|
}
|
|
|
|
auto sttm = tmGetCurms();
|
|
for (int i = 0; i < 100000; i++) {
|
|
JCRenderer::renderMesh(m_pMesh, &m_pMesh->m_vRenderGroupData[0], nullptr, 0);
|
|
}
|
|
int dt = tmGetCurms() - sttm;
|
|
LOGE("+++++ dt=%d",dt);
|
|
}
|
|
|
|
virtual void invalidGLRes() {
|
|
}
|
|
virtual void freeGLRes() {
|
|
}
|
|
};
|
|
|
|
GLEnvThread gl;
|
|
TestRender render([&gl]() { gl.m_pWindows->close(); });
|
|
gl.init(&render, 800, 600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
|
|
void _1_testRender_GLTread_multiGroups() {
|
|
//不同材质
|
|
//不同面类型
|
|
//不同顶点格式
|
|
class TestRender :public JCIGLRender {
|
|
public:
|
|
struct Vertex {
|
|
float pos[3];
|
|
int color;
|
|
Vertex(float x, float y, float z, int c) {
|
|
pos[0] = x; pos[1] = y; pos[2] = z;
|
|
color = c;
|
|
}
|
|
};
|
|
|
|
int nFrmNum = 0;
|
|
std::function<void()> funcExit;
|
|
JCConchMesh* m_pMesh = nullptr;
|
|
JCGpuProgramTemplate* m_pTemp1= nullptr;
|
|
JCGpuProgramTemplate* m_pTemp2 = nullptr;
|
|
JCGpuProgramTemplate* m_pTemp3 = nullptr;
|
|
JCGpuProgram* m_pProg = nullptr;
|
|
JCGpuProgram* m_pProg1 = nullptr;
|
|
JCGpuProgram* m_pProg2 = nullptr;
|
|
JCMaterial* m_pMtl = nullptr;
|
|
JCMaterial* m_pMtl1 = nullptr;
|
|
JCMaterial* m_pMtl2 = nullptr;
|
|
JCShaderLink_Vertex m_LinkV,m_LinkV1,m_LinkV2;
|
|
JCShaderLink_Uniform m_LinkU, m_LinkU1, m_LinkU2;
|
|
JCRenderGroupData m_RenderGroup;
|
|
TestRender(std::function<void()> f) {
|
|
funcExit = f;
|
|
}
|
|
|
|
virtual void onGLReady() {
|
|
m_pMesh = new JCConchMesh();
|
|
m_pMesh->regVertexDesc({ { "g_Pos",GL_FLOAT_VEC3 },{ "color",GL_INT } }, 1);
|
|
m_pMesh->regVertexDesc({ {"g_Pos",GL_FLOAT_VEC2} }, 2);
|
|
|
|
//mtl
|
|
m_pProg = (new JCGpuProgramTemplate(
|
|
R"(
|
|
attribute vec3 g_Pos;
|
|
void main(){
|
|
gl_Position = vec4(g_Pos.x, g_Pos.y, g_Pos.z, 1.0);
|
|
}
|
|
)", R"(
|
|
precision mediump float;
|
|
void main(){
|
|
gl_FragColor=vec4(1,1,0,1);
|
|
}
|
|
)"))->getInst("",0);
|
|
|
|
m_pMtl = new JCMaterial();
|
|
m_pMtl->setBlendType(JCMaterial::BLEND_TYPE_SOURCE_OVER);
|
|
m_pMtl->setAlpha(1.0f);
|
|
m_pMtl->setShaderProgram(m_pProg);
|
|
|
|
//mtl1
|
|
m_pProg1 = (new JCGpuProgramTemplate(R"(
|
|
attribute vec3 g_Pos;
|
|
void main(){
|
|
gl_Position = vec4(g_Pos.x, g_Pos.y, g_Pos.z, 1.0);
|
|
}
|
|
)", R"(
|
|
precision mediump float;
|
|
void main(){
|
|
gl_FragColor=vec4(1,0,0,1);
|
|
}
|
|
)"))->getInst("",0);
|
|
m_pMtl1 = new JCMaterial();
|
|
m_pMtl1->setBlendType(JCMaterial::BLEND_TYPE_SOURCE_OVER);
|
|
m_pMtl1->setAlpha(1.0f);
|
|
m_pMtl1->setShaderProgram(m_pProg1);
|
|
|
|
//mtl2
|
|
m_pProg2 = (new JCGpuProgramTemplate(R"(
|
|
attribute vec2 g_Pos;
|
|
void main(){
|
|
gl_Position = vec4(g_Pos.x, g_Pos.y, 0.5, 1.0);
|
|
}
|
|
)", R"(
|
|
precision mediump float;
|
|
void main(){
|
|
gl_FragColor=vec4(0,1.0,0,1.0);
|
|
}
|
|
)"))->getInst("",0);
|
|
m_pMtl2 = new JCMaterial();
|
|
m_pMtl2->setBlendType(JCMaterial::BLEND_TYPE_SOURCE_OVER);
|
|
m_pMtl2->setAlpha(1.0f);
|
|
m_pMtl2->setShaderProgram(m_pProg1);
|
|
|
|
//link
|
|
JCNamedData* pMaterialDesc = m_pMtl->getNamedData();
|
|
JCVertexDesc& VDesc = m_pMesh->getVertexDesc(1);
|
|
JCVertexDesc& VDesc1 = m_pMesh->getVertexDesc(2);
|
|
JCRenderer::link_shader_vertex_uniformdata(
|
|
m_LinkV, m_LinkU, &VDesc, m_pProg, &pMaterialDesc, 1,
|
|
nullptr
|
|
);
|
|
JCRenderer::link_shader_vertex_uniformdata(
|
|
m_LinkV1,m_LinkU1, &VDesc, m_pProg1, &pMaterialDesc, 1,nullptr);
|
|
JCRenderer::link_shader_vertex_uniformdata(
|
|
m_LinkV2, m_LinkU2, &VDesc1, m_pProg2, &pMaterialDesc, 1,nullptr);
|
|
|
|
float xoff = -0.7f, yoff = 0.0f;
|
|
JCRenderGroupData* pGroup = m_pMesh->pushElements(1, m_pMtl, 4, {
|
|
-0.05f+xoff,0.05f+yoff,0.5f,0 ,
|
|
0.05f+xoff,0.05f+yoff,0.5f,0 ,
|
|
0.05f+xoff,-0.05f+yoff,0.5f,0 ,
|
|
-0.05f+xoff,-0.05f+yoff,0.5f,0
|
|
}, {
|
|
0,1,2,2,3,0
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkV;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkU;
|
|
|
|
xoff = -0.59f;
|
|
m_pMesh->pushElements(1, m_pMtl, 4, {
|
|
-0.05f + xoff,0.05f + yoff,0.5f,0 ,
|
|
0.05f + xoff,0.05f + yoff,0.5f,0 ,
|
|
0.05f + xoff,-0.05f + yoff,0.5f,0 ,
|
|
-0.05f + xoff,-0.05f + yoff,0.5f,0
|
|
}, {
|
|
0,1,2,2,3,0
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkV1;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkU1;
|
|
|
|
xoff = -0.48f;
|
|
pGroup= m_pMesh->pushElements(1, m_pMtl1, 4, {
|
|
-0.05f + xoff,0.05f + yoff,0.5f,0 ,
|
|
0.05f + xoff,0.05f + yoff,0.5f,0 ,
|
|
0.05f + xoff,-0.05f + yoff,0.5f,0 ,
|
|
-0.05f + xoff,-0.05f + yoff,0.5f,0
|
|
}, {
|
|
0,1,2,2,3,0
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkV1;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkU1;
|
|
|
|
//画线
|
|
float w = 800;
|
|
float h = 600;
|
|
pGroup = m_pMesh->pushVertex(1, GL_LINE_STRIP, m_pMtl, 3, {
|
|
375.0f/w,117.0f/h,0.5f,0,
|
|
636.0f/w,405.0f/h,0.5f,0,
|
|
207.0f/w,405.0f/h,0.5f,0
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkV;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkU;
|
|
|
|
|
|
//不同的顶点格式
|
|
pGroup = m_pMesh->pushVertex(2, GL_TRIANGLE_FAN, m_pMtl2, 7, {
|
|
325.0f / w,329.0f / h,
|
|
320.0f / w,155.0f / h,
|
|
486.0f / w,240.0f / h,
|
|
488.0f / w,410.0f / h,
|
|
319.0f / w,493.0f / h,
|
|
155.0f / w,412.0f / h,
|
|
152.0f / w,241.0f / h
|
|
});
|
|
pGroup->m_pShaderVertexInfo = &m_LinkV2;
|
|
pGroup->m_pShaderUniformInfo = &m_LinkU2;
|
|
|
|
}
|
|
|
|
virtual void renderFrame(long p_nCurrentFrame, bool) {
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
|
|
nFrmNum++;
|
|
if (nFrmNum > 10000) {
|
|
funcExit();
|
|
}
|
|
|
|
for (auto& g : m_pMesh->m_vRenderGroupData) {
|
|
JCRenderer::renderMesh(m_pMesh, &g, nullptr, 0);
|
|
}
|
|
}
|
|
|
|
virtual void invalidGLRes() {
|
|
}
|
|
virtual void freeGLRes() {
|
|
}
|
|
};
|
|
|
|
GLEnvThread gl;
|
|
TestRender render([&gl]() { gl.m_pWindows->close(); });
|
|
gl.init(&render, 800, 600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
|
|
void testCanvas_1() {
|
|
|
|
}
|
|
|
|
void _1_testRender_GLTread_mask() {
|
|
class TestRender :public JCIGLRender {
|
|
public:
|
|
struct Vertex {
|
|
float _x,_y,_u1,_v1,_u2,_v2;
|
|
int color;
|
|
Vertex(float x, float y, float u1, float v1, float u2, float v2, int c) {
|
|
_x = x; _y = y; _u1 = u1; _v1 = v1; _u2 = u2; _v2 = v2;
|
|
color = c;
|
|
}
|
|
};
|
|
|
|
int nFrmNum = 0;
|
|
std::function<void()> funcExit;
|
|
JCConchMesh* m_pMesh = nullptr;
|
|
JCGpuProgram* m_pProg = nullptr;
|
|
JCMaterial* m_pMaterial = nullptr;
|
|
JCShaderLink_Vertex m_LinkInfoV;
|
|
JCShaderLink_Uniform m_LinkInfoU;
|
|
JCRenderGroupData m_RenderGroup;
|
|
//JCImage m_imgBk, m_imgMask;
|
|
JCTexture *m_pTex1, *m_pTex2;
|
|
TestRender(std::function<void()> f) {
|
|
funcExit = f;
|
|
}
|
|
|
|
virtual void onGLReady() {
|
|
m_pMesh = new JCConchMesh();
|
|
m_pMesh->regVertexDesc({ { "POSUV",GL_FLOAT_VEC4 },{ "uv2",GL_FLOAT_VEC2 } }, 1);
|
|
|
|
m_pProg = (new JCGpuProgramTemplate(R"(
|
|
attribute vec4 g_posuv;
|
|
attribute vec2 uv2;
|
|
varying vec2 texCoord1;
|
|
varying vec2 texCoord2;
|
|
void main(){
|
|
gl_Position = vec4(g_posuv.x, g_posuv.y, 0.5, 1.0);
|
|
texCoord1 = g_posuv.zw;
|
|
texCoord2 = uv2;
|
|
}
|
|
)",
|
|
R"(
|
|
precision mediump float;
|
|
varying vec2 texCoord1;
|
|
varying vec2 texCoord2;
|
|
uniform sampler2D g_Tex0;
|
|
uniform sampler2D g_Tex1;
|
|
void main(){
|
|
vec4 color1 = texture2D(g_Tex0, texCoord1.xy);
|
|
vec4 color2 = texture2D(g_Tex1, texCoord2.xy);//mask
|
|
gl_FragColor=vec4(color1.xyz,color1.w*color2.r);
|
|
}
|
|
)"))->getInst("",0);
|
|
int nProg = m_pProg->getGpuProgram();
|
|
m_pProg->m_pTemp->setSemantics("abc,ddd,g_posuv,POSUV");
|
|
m_pMaterial = new JCMaterial();
|
|
m_pMaterial->setBlendType(JCMaterial::BLEND_TYPE_SOURCE_OVER);
|
|
m_pMaterial->setAlpha(1.0f);
|
|
m_pMaterial->setShaderProgram(m_pProg);
|
|
JCNamedData* pMaterialDesc = m_pMaterial->getNamedData();
|
|
JCVertexDesc& VDesc = m_pMesh->getVertexDesc(1);
|
|
JCRenderer::link_shader_vertex_uniformdata(
|
|
m_LinkInfoV,m_LinkInfoU, &VDesc, m_pProg, &pMaterialDesc, 1,nullptr);
|
|
|
|
JCRenderGroupData* pGroup = m_pMesh->pushElements(1, m_pMaterial, 4, {
|
|
-0.5f,0.5f,0,0,0,0,
|
|
0.5f,0.5f,0.5,0,1,0,
|
|
0.5f,-0.5f,0.5,0.5,1,1,
|
|
-0.5f,-0.5f,0,0.5,0,1
|
|
}, {
|
|
0,1,2,2,3,0
|
|
});
|
|
pGroup->m_pShaderUniformInfo = &m_LinkInfoU;
|
|
pGroup->m_pShaderVertexInfo = &m_LinkInfoV;
|
|
//两张贴图，模拟遮罩
|
|
JCBuffer buf;
|
|
BitmapData bmp;
|
|
readFileSync("F:/work/conch5gitsvn/ScriptTest/images/bg2.png", buf);
|
|
bool b = loadImageMemSync(buf.m_pPtr, buf.m_nLen, bmp);
|
|
m_pTex1 = new JCTexture(nullptr, TEXTURE_TYPE_NORMAL, bmp.m_nWidth,
|
|
bmp.m_nHeight);
|
|
m_pTex1->mergeBitmapDataToTexture(&bmp, (BOARDER_TYPE)0, 0, 0);
|
|
m_pMaterial->setTexture(0, m_pTex1);
|
|
|
|
readFileSync("F:/work/conch5gitsvn/ScriptTest/images/mask.png", buf);
|
|
b = loadImageMemSync(buf.m_pPtr, buf.m_nLen, bmp);
|
|
m_pTex2 = new JCTexture(nullptr, TEXTURE_TYPE_NORMAL, bmp.m_nWidth,
|
|
bmp.m_nHeight);
|
|
m_pTex2->mergeBitmapDataToTexture(&bmp, (BOARDER_TYPE)0, 0, 0);
|
|
m_pMaterial->setTexture(1, m_pTex2);
|
|
|
|
}
|
|
|
|
virtual void renderFrame(long p_nCurrentFrame, bool) {
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
|
|
glEnable(GL_BLEND);
|
|
nFrmNum++;
|
|
if (nFrmNum > 10000) {
|
|
funcExit();
|
|
}
|
|
|
|
JCRenderer::renderMesh(m_pMesh, &m_pMesh->m_vRenderGroupData[0], nullptr, 0);
|
|
}
|
|
|
|
virtual void invalidGLRes() {
|
|
}
|
|
virtual void freeGLRes() {
|
|
}
|
|
};
|
|
|
|
GLEnvThread gl;
|
|
TestRender render([&gl]() { gl.m_pWindows->close(); });
|
|
gl.init(&render, 800, 600);
|
|
winWindows::handleMessage(NULL);
|
|
}
|
|
|
|
void testMain() {
|
|
//_1_testRender_GLTread_simp();
|
|
//_1_testRender_GLTread_multiGroups();
|
|
_1_testRender_GLTread_mask();
|
|
/*
|
|
//TODO 下面这个不太方便
|
|
g_DecThread = new workerThread(true);
|
|
g_DecThread->setThreadName("image decode");
|
|
_1_2_1_test3d();
|
|
_1_2_1_test3dmodel();
|
|
_1_1_2_test();
|
|
//_2_1_test();
|
|
init_3();
|
|
_3_1_testdrawImage();
|
|
uninit_3();
|
|
_1_1_1_test();
|
|
//testRender3D_1();
|
|
delete g_DecThread;
|
|
*/
|
|
}
|
|
ADDTESTCASE(testMain, "renderTest");
|
|
}
|
|
#endif
|