void SceneManager::Update(ESContext *esContext)
{
//UserData *userData = (UserData*) esContext->userData;
float aspect;
// Compute the window aspect ratio
aspect = (GLfloat) esContext->width / (GLfloat) esContext->height;
// Generate a perspective matrix with a 60 degree FOV
esMatrixLoadIdentity( &perspectiveMatrix );
esPerspective( &perspectiveMatrix, 60.0f, aspect, 0.5f, 50.0f );
// Generate a model view matrix to rotate/translate the objects
for(int i=0;i<(int)objects.size();i++)
{
esMatrixLoadIdentity( &objects[i]->mvMatrix );
objects[i]->update();
esTranslate(&objects[i]->mvMatrix, vecCameraPos[0],vecCameraPos[1],vecCameraPos[2]);
esRotate(&objects[i]->mvMatrix, angle, 0.0f,1.0f,0.0f);
// Compute the final MVP by multiplying the
// modelview and perspective matrices together
esMatrixMultiply( &objects[i]->mvpMatrix, &objects[i]->mvMatrix, &perspectiveMatrix );
}
}
void draw(const float r, const float g, const float b)
{
#ifndef BT_NO_PROFILE
CProfileManager::Reset();
#endif //BT_NO_PROFILE
BT_PROFILE("draw()");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport ( 0, 0, m_glutScreenWidth, m_glutScreenHeight );
btScalar aspect = m_glutScreenWidth / (btScalar)m_glutScreenHeight;
m_fluidWorld->stepSimulation(btScalar(1.0/60.0) ,1, btScalar(1.0/60.0));
m_fluidWorld->setFluidSolver(m_fluidSolverCPU);
// if(m_fluidWorld) m_fluidWorld->debugDrawWorld(); //Optional but useful: debug drawing to detect problems
updateCamera();
esMatrixLoadIdentity(&projMat);
esMatrixLoadIdentity(&viewMat);
esFrustum(&projMat, -aspect, aspect, -1.0f, 1.0f, 1.0f, 1000.0f);
esMatrixLookAt(&viewMat,
0.0f, 100.0f, 20.0f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glDisable(GL_BLEND);
// plane->draw(plane_motion_x, -10, plane_motion_z, basicShader,&projMat,&viewMat);
renderShootBox(plane_motion_x, -10, plane_motion_z, basicShader,&projMat,&viewMat);
renderFluids(r, g, b);
glUseProgram(0);
}
///
// Update MVP matrix based on time
//
void Update ( ESContext *esContext, float deltaTime )
{
UserData *userData = (UserData*) esContext->userData;
ESMatrix perspective;
ESMatrix modelview;
float aspect;
// Compute a rotation angle based on time to rotate the cube
userData->angle += ( deltaTime * 40.0f );
if( userData->angle >= 360.0f )
userData->angle -= 360.0f;
// Compute the window aspect ratio
aspect = (GLfloat) esContext->width / (GLfloat) esContext->height;
// Generate a perspective matrix with a 60 degree FOV
esMatrixLoadIdentity( &perspective );
esPerspective( &perspective, 60.0f, aspect, 1.0f, 20.0f );
// Generate a model view matrix to rotate/translate the cube
esMatrixLoadIdentity( &modelview );
// Translate away from the viewer
esTranslate( &modelview, 0.0, 0.0, -2.0 );
// Rotate the cube
esRotate( &modelview, userData->angle, 1.0, 0.0, 1.0 );
// Compute the final MVP by multiplying the
// modevleiw and perspective matrices together
esMatrixMultiply( &userData->mvpMatrix, &modelview, &perspective );
}
///
// Update a triangle using the shader pair created in Init()
//
static void Update ( ESContext *esContext, float deltaTime)
{
UserData *userData = (UserData*) esContext->userData;
ESMatrix perspective;
ESMatrix modelview;
float aspect;
// Compute a rotation angle based on time to rotate the cube
userData->angle += 1;//( deltaTime * 40.0f );
if( userData->angle >= 360.0f )
userData->angle -= 360.0f;
// Compute the window aspect ratio
aspect = 1;//(GLfloat) esContext->width / (GLfloat) esContext->height;
// Generate a perspective matrix with a 60 degree FOV
esMatrixLoadIdentity( &perspective );
esPerspective( &perspective, 50.0f, aspect, 1.0f, 20.0f );
// Generate a model view matrix to rotate/translate the cube
esMatrixLoadIdentity( &modelview );
// Translate away from the viewer
esTranslate( &modelview, 0.0, 0.0, -2.0 );
esScale( &modelview,.2,.2,.2);
// Rotate the cube
esRotate( &modelview, userData->angle, .0, 1.0, .0 );
// Compute the final MVP by multiplying the modevleiw and perspective matrices together
esMatrixMultiply( &userData->mvpMatrix, &modelview, &perspective );
#if 1
userData->normalMatrix = processNormalMatrix(modelview);
#else
// Normal Matrix
// Transform normals from object-space to eye-space
bool invertible;
GLKMatrix3 normalMatrix = GLKMatrix4GetMatrix3(GLKMatrix4InvertAndTranspose(modelViewMatrix, &invertible));
if(!invertible)
NSLog(@"MV matrix is not invertible");
glUniformMatrix3fv(self.phongShader.uNormalMatrix, 1, 0, normalMatrix.m);
#endif
}
void touchTranslate(float dy)
{
static float translation = -1.3f;
esMatrixLoadIdentity( &translateMatrix );
esTranslate(&translateMatrix,0,0,translation);
}
void CScene::update(float deltaTime)
{
// cameraView * projection
esMatrixLoadIdentity(&m_viewProjectionMatrix);
esMatrixMultiply(&m_viewProjectionMatrix, camera->getViewMatrix(), &m_projectionMatrix);
for(int i = 0; i < m_sceneManager->getNumberOfObjects(); i++)
{
CObject *crtObject = m_sceneManager->getObjects()[i];
char *shaderName = crtObject->getShader()->getName();
if(!strncmp(shaderName, "PHONG", 5) || !strcmp(shaderName, "NORMALMAPPING") || !strcmp(shaderName, "OBJECT"))
crtObject->rotate(0.0, crtObject->getRotation().y + deltaTime * 40.0f, 0.0);
else if(!strcmp(crtObject->getName(), "UVDISP"))
{
float camRot = camera->getYRotation();
crtObject->rotate(0.0, camRot, 0.0);
}
else if(!strcmp(crtObject->getName(), "SKYBOX"))
crtObject->translate(camera->getPosition().x, camera->getPosition().y, camera->getPosition().z);
crtObject->update(m_viewProjectionMatrix, deltaTime);
}
}
//+-----------------------------------------------------------------------------
//| Renders the geoset
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::Render(CONST SEQUENCE_TIME& time, BOOL Animated)
{
BuildMesh();
glUseProgram(Graphics.Program());
ESMatrix modelviewMatrix;
ESMatrix perspectiveMatrix;
ESMatrix mvpMatrix;
int aspect;
aspect = (GLfloat) 600 / (GLfloat) 800;
esMatrixLoadIdentity(&perspectiveMatrix);
esPerspective(&perspectiveMatrix, 60.0f, aspect, 1.0f, 20.0f);
esMatrixLoadIdentity(&modelviewMatrix);
esScale(&modelviewMatrix, 1.0f, 1.0f, 1.0f);
esTranslate(&modelviewMatrix, 0.0f, 0.0f, 0.0f);
static float angle = 0.0f;
esRotate(&modelviewMatrix,angle, 1.0f, 0.0f, 0.0f);
angle += 0.2f;
esMatrixLoadIdentity(&mvpMatrix);
esMatrixMultiply(&mvpMatrix, &modelviewMatrix, &perspectiveMatrix);
glUniformMatrix4fv(Graphics.WVPMatrix(), 1, GL_FALSE, (GLfloat*) mvpMatrix.m);
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
glEnableVertexAttribArray(Graphics.Position());
glEnableVertexAttribArray(Graphics.TexturePosition());
glUniform1i(Graphics.Texture(), 0);
glVertexAttribPointer(Graphics.Position(), 3, GL_FLOAT, GL_FALSE, sizeof(FLOAT) * 3, vertices);
glVertexAttribPointer(Graphics.TexturePosition(), 2, GL_FLOAT, GL_FALSE, 2 * sizeof(FLOAT), TexturePositions);
glDrawElements(GL_TRIANGLES, GeosetData.FaceContainer.GetTotalSize() * 3, GL_UNSIGNED_INT, indices);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE0);
glDisableVertexAttribArray(Graphics.TexturePosition());
glDisableVertexAttribArray(Graphics.Texture());
}
void CScene::init()
{
m_totalTime = 0;
//float aspect = 1600.0f / 900;
esLogMessage("[CScene->init()] %i %i", s_windowWidth, s_windowHeight);
float aspect = ((float)s_windowWidth) / s_windowHeight;
esMatrixLoadIdentity(&m_projectionMatrix);
esPerspective(&m_projectionMatrix, 50.0f, aspect, 0.2f, 2500.0f);
}
void SetSphereMVP(GLContext *_context)
{
UserData *_user = (UserData*)_context->userObject;
ESMatrix identity;
////////////////////////球////////////////
esMatrixLoadIdentity(&_user->lightSphereMatrix);
esTranslate(&_user->lightSphereMatrix, 2.0f, 0.0f, 0.0f);
esRotate(&_user->lightSphereMatrix, _user->angleArc, 0.0f, 1.0f, 0.0f);
esTranslate(&_user->lightSphereMatrix, 0.0f, 0.0f, -4.0f);
esMatrixMultiply(&_user->lightSphereMatrix, &_user->lightSphereMatrix, &_user->viewMatrix);
//获取法线矩阵
esMatrixNormal(&_user->normalSphereMatrix, &_user->lightSphereMatrix);
esMatrixMultiply(&_user->lightSphereMatrix, &_user->lightSphereMatrix, &_user->projMatrix);
////////////////眼睛的的视野//////////////////
esMatrixLoadIdentity(&_user->eyeSphereMatrix);
esTranslate(&_user->eyeSphereMatrix, 2.0f, 0.0f, 0.0f);
esRotate(&_user->eyeSphereMatrix, _user->angleArc, 0.0f, 1.0f, 0.0f);
esTranslate(&_user->eyeSphereMatrix, 0.0f, 0.0f, -4.0f);
esMatrixMultiply(&_user->eyeSphereMatrix, &_user->eyeSphereMatrix, &_user->eyeViewMatrix);
esMatrixMultiply(&_user->eyeSphereMatrix, &_user->eyeSphereMatrix, &_user->projMatrix);
//球
}
void Origin::drawFrame(ESMatrix *perspective) {
ESMatrix modelview;
changingColour += 0.01f;
if (changingColour > 0.9f) changingColour = 0.25f;
GLfloat vVertices[] = {
0.0f, 0.0f, 0.0f,
0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f
};
GLfloat vColors[] = {
changingColour, 0.0f, 0.0f, 1.0f,
changingColour, 0.0f, 0.0f, 1.0f,
0.0f, changingColour, 0.0f, 1.0f,
0.0f, changingColour, 0.0f, 1.0f,
changingColour, changingColour, 0.0f, 1.0f,
changingColour, changingColour, 0.0f, 1.0f
};
// Generate a model view matrix to rotate/translate the cube
esMatrixLoadIdentity(&modelview);
userData.angle = 0.0f;
// Compute the final MVP by multiplying the
// modevleiw and perspective matrices together
esMatrixMultiply(&userData.mvpMatrix, &modelview, perspective);
// use the program object
glUseProgram(userData.programObject);
// Load the vertex position
glVertexAttribPointer(userData.positionLoc, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(GLfloat), vVertices);
glEnableVertexAttribArray(userData.positionLoc);
// load colors
glVertexAttribPointer(userData.colorLoc, 4, GL_FLOAT, GL_FALSE,
4 * sizeof(GLfloat), vColors);
glEnableVertexAttribArray(userData.colorLoc);
// Load the MVP matrix
glUniformMatrix4fv(userData.mvpLoc, 1, GL_FALSE,
(GLfloat*) &userData.mvpMatrix.m[0][0]);
glDrawArrays(GL_LINES, 0, 6);
}
JNIEXPORT void JNICALL Java_org_nzdis_example03_GLESView_mySurfaceChanged
(JNIEnv *env, jclass c, jint width, jint height)
{
glViewport(0, 0, width, height);
aspect = (float)width / (float)height;
// Generate a perspective matrix with a 60 degree FOV
esMatrixLoadIdentity(&perspective);
//LOGI("%f %d %d", aspect, width, height);
esPerspective(&perspective, 60.0f, aspect, 1.0f, 30.0f);
esTranslate(&perspective, 0.0f, 0.0f, -5.0f);
//esRotate(&perspective, 45.0f, 1.0f, 0.0f, 0.0f);
//esRotate(&perspective, -5.0f, 0.0f, 1.0f, 0.0f);
origin.init(width, height);
sphere.init(width, height);
terrain.init(width, height);
}
void screen_overview(ESContext *esContext) {
#ifndef SDLGL
ESMatrix modelview;
UserData *userData = esContext->userData;
#endif
char tmp_str[1024];
uint8_t n = 0;
#ifndef SDLGL
esMatrixLoadIdentity(&modelview);
esMatrixMultiply(&userData->mvpMatrix, &modelview, &userData->perspective);
#endif
reset_buttons();
draw_text_button(esContext, "Screens", setup.view_mode, "Screens", FONT_PINK, -0.8, -0.6 + -2 * 0.1, 0.002, 0.08, ALIGN_CENTER, ALIGN_TOP, overview_set, (float)0);
for (n = 0; n < VIEW_MODE_LAST; n++) {
sprintf(tmp_str, "%s", view_names[n]);
if (setup.view_mode == n) {
draw_text_button(esContext, tmp_str, setup.view_mode, tmp_str, FONT_GREEN, -0.8, -0.6 + n * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, overview_set, (float)n);
} else {
draw_text_button(esContext, tmp_str, setup.view_mode, tmp_str, FONT_WHITE, -0.8, -0.6 + n * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, overview_set, (float)n);
}
}
draw_text_button(esContext, "Options", setup.view_mode, "Options", FONT_PINK, 0.8, -0.6 + -2 * 0.1, 0.002, 0.08, ALIGN_CENTER, ALIGN_TOP, overview_set, (float)0);
n = 0;
if (setup.speak == 1) {
draw_text_button(esContext, "SPEAK", setup.view_mode, "SPEAK", FONT_GREEN, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
} else {
draw_text_button(esContext, "SPEAK", setup.view_mode, "SPEAK", FONT_WHITE, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
}
if (logmode == 1) {
draw_text_button(esContext, "LOGGING", setup.view_mode, "LOGGING", FONT_GREEN, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
} else {
draw_text_button(esContext, "LOGGING", setup.view_mode, "LOGGING", FONT_WHITE, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
}
#ifndef OSX
if (logplay == 1) {
draw_text_button(esContext, "LOGPLAYER", setup.view_mode, "LOGPLAYER", FONT_GREEN, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
} else {
draw_text_button(esContext, "LOGPLAYER", setup.view_mode, "LOGPLAYER", FONT_WHITE, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
}
#endif
n++;
n++;
n++;
draw_text_button(esContext, "EXIT", setup.view_mode, "EXIT", FONT_WHITE, 0.8, -0.6 + n++ * 0.1, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, option_cmd, 0.0);
}
void ESUTIL_API
esOrtho(ESMatrix *result, float left, float right, float bottom, float top, float nearZ, float farZ) {
float deltaX = right - left;
float deltaY = top - bottom;
float deltaZ = farZ - nearZ;
ESMatrix ortho;
if ((deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f)) {
return;
}
esMatrixLoadIdentity(&ortho);
ortho.m[0][0] = 2.0f / deltaX;
ortho.m[3][0] = -(right + left) / deltaX;
ortho.m[1][1] = 2.0f / deltaY;
ortho.m[3][1] = -(top + bottom) / deltaY;
ortho.m[2][2] = -2.0f / deltaZ;
ortho.m[3][2] = -(nearZ + farZ) / deltaZ;
esMatrixMultiply(result, &ortho, result);
}
void esLookAt(ESMatrix *result,
float eyex, float eyey, float eyez, float centerx,
float centery, float centerz, float upx, float upy,
float upz)
{
float forward[3], side[3], up[3];
ESMatrix tr;
forward[0] = centerx - eyex;
forward[1] = centery - eyey;
forward[2] = centerz - eyez;
up[0] = upx;
up[1] = upy;
up[2] = upz;
normalize(forward);
/* Side = forward x up */
cross(forward, up, side);
normalize(side);
/* Recompute up as: up = side x forward */
cross(side, forward, up);
esMatrixLoadIdentity(&tr);
tr.m[0][0] = side[0];
tr.m[1][0] = side[1];
tr.m[2][0] = side[2];
tr.m[0][1] = up[0];
tr.m[1][1] = up[1];
tr.m[2][1] = up[2];
tr.m[0][2] = -forward[0];
tr.m[1][2] = -forward[1];
tr.m[2][2] = -forward[2];
esMatrixMultiply(result, result, &tr);
esTranslate(result, -eyex, -eyey, -eyez);
}
void Sphere::drawFrame(ESMatrix* perspective) {
GLfloat vColor[] = { 1.0f, 0.0f, 0.0f, 1.0f };
GLfloat vLightPos[] = { 0.0f, 0.0f, 2.3f };
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
// Compute the final MVP by multiplying the
// modelview and perspective matrices together
esMatrixMultiply(&userData.mvpMatrix, &modelview, perspective);
// use the program object
glUseProgram(userData.programObject);
// Load the vertex position
#if TARGET_OS_IPHONE
#elif __ANDROID__
#else
glEnableClientState(GL_VERTEX_ARRAY);
#endif
glVertexAttribPointer(userData.positionLoc, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(GLfloat), userData.vertices);
glEnableVertexAttribArray(userData.positionLoc);
// Load the normals
glVertexAttribPointer(userData.normalsLoc, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(GLfloat), userData.normals);
glEnableVertexAttribArray(userData.normalsLoc);
// load color
glUniform4fv(userData.colorLoc, 1, (GLfloat *) vColor);
glUniform3fv(userData.lightPosLoc, 1, (GLfloat*) vLightPos);
// Load the MVP matrix
glUniformMatrix4fv(userData.mvpLoc, 1, GL_FALSE,
(GLfloat*) &userData.mvpMatrix.m[0][0]);
// Load the MV matrix
glUniformMatrix4fv(userData.mvLoc, 1, GL_FALSE,
(GLfloat*) &modelview.m[0][0]);
//printf("drawFrame drawing, number of indices: %d", userData.numIndices);
// Draw a sphere
glDrawElements(GL_TRIANGLE_STRIP, userData.numIndices, GL_UNSIGNED_INT, userData.indices);
}
void cCamera::Update(float deltaTime)
{
UpdateInput(deltaTime);
esMatrixLoadIdentity( & Camera );
if(m_enabled)
{
cVector2di mousePos=INPUT->getMousePos();
float rotatex=(float)(mousePos.x-m_prevMouseX);
float rotatey=(float)(mousePos.y-m_prevMouseY);
m_currentRot.x+=rotatex;
m_currentRot.z+=rotatey;
m_prevMouseX=mousePos.x;
m_prevMouseY=mousePos.y;
}
esTranslate(&Camera,m_currentPos.x,m_currentPos.y,m_currentPos.z);
esRotate(&Camera,m_currentRot.x,0,1,0);
esRotate(&Camera,m_currentRot.z,1,0,0);
InverseMatrix(Camera,View);
}
int
main(int argc, char *argv[])
{
struct limare_state *state;
int ret;
const char *vertex_shader_source =
"uniform mat4 modelviewMatrix;\n"
"uniform mat4 modelviewprojectionMatrix;\n"
"uniform mat3 normalMatrix;\n"
"\n"
"attribute vec4 in_position; \n"
"attribute vec3 in_normal; \n"
"attribute vec2 in_coord; \n"
"\n"
"vec4 lightSource = vec4(10.0, 20.0, 40.0, 0.0);\n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"void main() \n"
"{ \n"
" gl_Position = modelviewprojectionMatrix * in_position;\n"
" vec3 vEyeNormal = normalMatrix * in_normal;\n"
" vec4 vPosition4 = modelviewMatrix * in_position;\n"
" vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
" vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
" float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
" vVaryingColor = vec4(diff * vec3(1.0, 1.0, 1.0), 1.0);\n"
" coord = in_coord; \n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"uniform sampler2D in_texture; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = vVaryingColor * texture2D(in_texture, coord);\n"
"} \n";
float *vertices_array = companion_vertices_array();
float *texture_coordinates_array =
companion_texture_coordinates_array();
float *normals_array = companion_normals_array();
state = limare_init();
if (!state)
return -1;
limare_buffer_clear(state);
ret = limare_state_setup(state, 0, 0, 0xFF505050);
if (ret)
return ret;
int width, height;
limare_buffer_size(state, &width, &height);
float aspect = (float) height / width;
limare_enable(state, GL_DEPTH_TEST);
limare_enable(state, GL_CULL_FACE);
limare_depth_mask(state, 1);
int program = limare_program_new(state);
vertex_shader_attach(state, program, vertex_shader_source);
fragment_shader_attach(state, program, fragment_shader_source);
limare_link(state);
int vertices_buffer =
limare_attribute_buffer_upload(state, LIMARE_ATTRIB_FLOAT,
3, 0, COMPANION_ARRAY_COUNT,
vertices_array);
int texture_coordinates_buffer =
limare_attribute_buffer_upload(state, LIMARE_ATTRIB_FLOAT,
2, 0, COMPANION_ARRAY_COUNT,
texture_coordinates_array);
int normals_buffer =
limare_attribute_buffer_upload(state, LIMARE_ATTRIB_FLOAT,
3, 0, COMPANION_ARRAY_COUNT,
normals_array);
limare_attribute_buffer_attach(state, "in_position", vertices_buffer);
limare_attribute_buffer_attach(state, "in_coord",
texture_coordinates_buffer);
limare_attribute_buffer_attach(state, "in_normal", normals_buffer);
int texture = limare_texture_upload(state, companion_texture,
COMPANION_TEXTURE_WIDTH,
COMPANION_TEXTURE_HEIGHT,
COMPANION_TEXTURE_FORMAT, 0);
limare_texture_attach(state, "in_texture", texture);
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0, 0.0, -4.0);
esRotate(&modelview, -30.0, 1.0, 0.0, 0.0);
esRotate(&modelview, -45.0, 0.0, 1.0, 0.0);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -1.0, +1.0, -1.0 * aspect, +1.0 * aspect,
1.0, 10.0);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
limare_uniform_attach(state, "modelviewMatrix", 16,
&modelview.m[0][0]);
limare_uniform_attach(state, "modelviewprojectionMatrix", 16,
&modelviewprojection.m[0][0]);
limare_uniform_attach(state, "normalMatrix", 9, normal);
limare_frame_new(state);
ret = limare_draw_arrays(state, GL_TRIANGLES, 0, COMPANION_ARRAY_COUNT);
if (ret)
return ret;
ret = limare_frame_flush(state);
if (ret)
return ret;
limare_buffer_swap(state);
limare_finish(state);
return 0;
}
int main(int argc, char *argv[])
{
EGLDisplay display;
EGLint egl_major, egl_minor;
EGLConfig config;
EGLint num_config;
EGLContext context;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
#ifdef HOOK
the_hook("/mnt/sdcard/egl2.fdr");
#endif
const char *vertex_shader_source =
"uniform mat4 modelviewMatrix;\n"
"uniform mat4 modelviewprojectionMatrix;\n"
"uniform mat3 normalMatrix;\n"
"\n"
"attribute vec4 in_position; \n"
"attribute vec3 in_normal; \n"
"attribute vec2 in_texcoord; \n"
"\n"
"vec4 lightSource = vec4(2.0, 2.0, 20.0, 0.0);\n"
" \n"
"varying vec4 vColor; \n"
"varying vec2 vTexCoord; \n"
"uniform sampler2D s_texture; \n"
" \n"
"void main() \n"
"{ \n"
" float texvalue = texture2D(s_texture, in_texcoord).x;\n"
" gl_Position = modelviewprojectionMatrix * (in_position + vec4(0.2 * texvalue * in_normal, 0));\n"
" vec3 vEyeNormal = normalMatrix * in_normal;\n"
" vec4 vPosition4 = modelviewMatrix * in_position;\n"
" vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
" vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
" float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
" vColor = vec4(diff, 0.0, 0.0, 1.0);\n"
" vTexCoord = in_texcoord;\n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"varying vec4 vColor; \n"
"varying vec2 vTexCoord; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = vColor;// * texture2D(s_texture, vTexCoord); \n"
"} \n";
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (display == EGL_NO_DISPLAY) {
printf("Error: No display found!\n");
return -1;
}
if (!eglInitialize(display, &egl_major, &egl_minor)) {
printf("Error: eglInitialise failed!\n");
return -1;
}
printf("Using display %p with EGL version %d.%d\n",
display, egl_major, egl_minor);
printf("EGL Version \"%s\"\n", eglQueryString(display, EGL_VERSION));
printf("EGL Vendor \"%s\"\n", eglQueryString(display, EGL_VENDOR));
printf("EGL Extensions \"%s\"\n", eglQueryString(display, EGL_EXTENSIONS));
/* get an appropriate EGL frame buffer configuration */
eglChooseConfig(display, config_attribute_list, &config, 1, &num_config);
/* create an EGL rendering context */
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list);
if (context == EGL_NO_CONTEXT) {
printf("Error: eglCreateContext failed: %d\n", eglGetError());
return -1;
}
surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list);
if (surface == EGL_NO_SURFACE) {
printf("Error: eglCreatePbufferSurface failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
if (!eglQuerySurface(display, surface, EGL_WIDTH, &width) ||
!eglQuerySurface(display, surface, EGL_HEIGHT, &height)) {
printf("Error: eglQuerySurface failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
printf("PBuffer: %dx%d\n", width, height);
printf("GL Extensions \"%s\"\n", glGetString(GL_EXTENSIONS));
/* connect the context to the surface */
if (!eglMakeCurrent(display, surface, surface, context)) {
printf("Error: eglMakeCurrent() failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
if (!vertex_shader) {
printf("Error: glCreateShader(GL_VERTEX_SHADER) failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: vertex shader compilation failed!:\n");
glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetShaderInfoLog(vertex_shader, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("Vertex shader compilation succeeded!\n");
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
if (!fragment_shader) {
printf("Error: glCreateShader(GL_FRAGMENT_SHADER) failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: fragment shader compilation failed!:\n");
glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetShaderInfoLog(fragment_shader, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("Fragment shader compilation succeeded!\n");
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
GLfloat *vVertices;
GLfloat *vNormals;
GLfloat *vTexCoords;
GLushort *vIndices;
int numIndices = esGenSphere(40, 1.0f, &vVertices, &vNormals,
&vTexCoords, &vIndices, NULL);
GLuint texId = createSimpleTexture();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "in_position");
glBindAttribLocation(program, 1, "in_normal");
glBindAttribLocation(program, 2, "in_texcoord");
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: program linking failed!:\n");
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetProgramInfoLog(program, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("program linking succeeded!\n");
glUseProgram(program);
glViewport(0, 0, width, height);
/* clear the color buffer */
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals);
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords);
glEnableVertexAttribArray(2);
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f);
GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -1.8f, +1.8f, -1.8f * aspect, +1.8f * aspect, 6.0f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
GLint modelviewmatrix_handle = glGetUniformLocation(program, "modelviewMatrix");
GLint modelviewprojectionmatrix_handle = glGetUniformLocation(program, "modelviewprojectionMatrix");
GLint normalmatrix_handle = glGetUniformLocation(program, "normalMatrix");
GLint sampler_handle = glGetUniformLocation(program, "s_texture");
glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]);
glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]);
glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texId);
glUniform1i(sampler_handle, 0);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, vIndices);
glFlush();
fflush(stdout);
dump_gl_screen("/sdcard/egl2.bmp", width, height);
#ifdef HOOK
close_hook();
#endif
return 0;
}
int
main(int argc, char *argv[])
{
EGLDisplay display;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
GLuint texture;
const char *vertex_shader_source =
"uniform mat4 modelviewMatrix;\n"
"uniform mat4 modelviewprojectionMatrix;\n"
"uniform mat3 normalMatrix;\n"
"\n"
"attribute vec4 in_position; \n"
"attribute vec3 in_normal; \n"
"attribute vec2 in_coord; \n"
"\n"
"vec4 lightSource = vec4(10.0, 20.0, 40.0, 0.0);\n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"void main() \n"
"{ \n"
" gl_Position = modelviewprojectionMatrix * in_position;\n"
" vec3 vEyeNormal = normalMatrix * in_normal;\n"
" vec4 vPosition4 = modelviewMatrix * in_position;\n"
" vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
" vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
" float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
" vVaryingColor = vec4(diff * vec3(1.0, 1.0, 1.0), 1.0);\n"
" coord = in_coord; \n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"uniform sampler2D in_texture; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = vVaryingColor * texture2D(in_texture, coord);\n"
"} \n";
buffer_size(&width, &height);
printf("Buffer dimensions %dx%d\n", width, height);
float aspect = (float) height / width;
display = egl_display_init();
surface = egl_surface_init(display, 2, width, height);
glViewport(0, 0, width, height);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
vertex_shader = vertex_shader_compile(vertex_shader_source);
fragment_shader = fragment_shader_compile(fragment_shader_source);
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "in_position");
glBindAttribLocation(program, 1, "in_normal");
glBindAttribLocation(program, 2, "in_coord");
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: program linking failed!:\n");
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetProgramInfoLog(program, ret, NULL, log);
printf("%s", log);
}
return -1;
}
glUseProgram(program);
unsigned int vertices_buffer;
glGenBuffers(1, &vertices_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int normals_buffer;
glGenBuffers(1, &normals_buffer);
glBindBuffer(GL_ARRAY_BUFFER, normals_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_normals, GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int texture_coordinates_buffer;
glGenBuffers(1, &texture_coordinates_buffer);
glBindBuffer(GL_ARRAY_BUFFER, texture_coordinates_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_texture_coordinates, GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int elements_buffer;
glGenBuffers(1, &elements_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elements_buffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * COMPANION_INDEX_COUNT,
companion_triangles, GL_STATIC_DRAW);
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
COMPANION_TEXTURE_WIDTH, COMPANION_TEXTURE_HEIGHT, 0,
GL_RGB, GL_UNSIGNED_BYTE, companion_texture);
GLint texture_loc = glGetUniformLocation(program, "in_texture");
glUniform1i(texture_loc, 0); // 0 -> GL_TEXTURE0 in glActiveTexture
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0, 0.0, -4.0);
esRotate(&modelview, -30.0, 1.0, 0.0, 0.0);
esRotate(&modelview, -45.0, 0.0, 1.0, 0.0);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -1.0, +1.0, -1.0 * aspect, +1.0 * aspect,
1.0, 10.0);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
GLint modelviewmatrix_handle =
glGetUniformLocation(program, "modelviewMatrix");
GLint modelviewprojectionmatrix_handle =
glGetUniformLocation(program, "modelviewprojectionMatrix");
GLint normalmatrix_handle =
glGetUniformLocation(program, "normalMatrix");
glUniformMatrix4fv(modelviewmatrix_handle,
1, GL_FALSE, &modelview.m[0][0]);
glUniformMatrix4fv(modelviewprojectionmatrix_handle,
1, GL_FALSE, &modelviewprojection.m[0][0]);
glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal);
glDrawElements(GL_TRIANGLES, COMPANION_INDEX_COUNT,
GL_UNSIGNED_SHORT, NULL);
eglSwapBuffers(display, surface);
usleep(1000000);
fflush(stdout);
return 0;
}
void Draw ( ESContext *esContext )
{
UserData *userData = esContext->userData;
glViewport(0, 0, esContext->width, esContext->height);
/* clear the color buffer */
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals);
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, vColors);
glEnableVertexAttribArray(2);
glUseProgram(userData->program);
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f);
GLfloat aspect = (GLfloat)(esContext->height) / (GLfloat)(esContext->width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -2.8f, +2.8f, -2.8f * aspect, +2.8f * aspect, 6.0f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
GLint modelviewmatrix_handle = glGetUniformLocation(userData->program, "modelviewMatrix");
GLint modelviewprojectionmatrix_handle = glGetUniformLocation(userData->program, "modelviewprojectionMatrix");
GLint normalmatrix_handle = glGetUniformLocation(userData->program, "normalMatrix");
glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]);
glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]);
glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal);
glEnable(GL_CULL_FACE);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 8, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 12, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 16, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 20, 4);
userData->frames ++;
#ifdef HOOK
// If logging, exit mainloop after a few frames
if(userData->frames == 5)
{
esContext->terminate = TRUE;
}
#endif
}
int main(int argc, char **argv)
{
int rv;
int width, height;
int width_s, height_s;
int padded_width, padded_height;
int backbuffer = 0;
int supersample_x = 2; // 1 or 2
int supersample_y = 2; // 1 or 2
int extra_ps_inputs = 0;
fb_info fb;
rv = fb_open(0, &fb);
if(rv!=0)
{
exit(1);
}
width = fb.fb_var.xres;
height = fb.fb_var.yres;
width_s = width * supersample_x;
height_s = height * supersample_y;
padded_width = etna_align_up(width_s, 64);
padded_height = etna_align_up(height_s, 64);
extra_ps_inputs = (supersample_x > 1 || supersample_y > 1); // in case of supersample, there is an extra input to PS
printf("padded_width %i padded_height %i\n", padded_width, padded_height);
rv = viv_open();
if(rv!=0)
{
fprintf(stderr, "Error opening device\n");
exit(1);
}
printf("Succesfully opened device\n");
etna_vidmem *rt = 0; /* main render target */
etna_vidmem *rt_ts = 0; /* tile status for main render target */
etna_vidmem *z = 0; /* depth for main render target */
etna_vidmem *z_ts = 0; /* depth ts for main render target */
etna_vidmem *vtx = 0; /* vertex buffer */
etna_vidmem *idx = 0; /* index buffer */
etna_vidmem *aux_rt = 0; /* auxilary render target */
etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
etna_vidmem *tex = 0; /* texture */
etna_vidmem *bmp = 0; /* bitmap */
/* TODO: anti aliasing (doubles width/height) */
size_t rt_size = padded_width * padded_height * 4;
size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)/0x100, 0x100);
size_t z_size = padded_width * padded_height * 2;
size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)/0x100, 0x100);
size_t bmp_size = width * height * 4;
if(etna_vidmem_alloc_linear(&rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&idx, INDEX_BUFFER_SIZE, gcvSURF_INDEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&aux_rt_ts, 0x100, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&tex, 0x100000, gcvSURF_TEXTURE, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
)
{
fprintf(stderr, "Error allocating video memory\n");
exit(1);
}
/* Phew, now we got all the memory we need.
* Write interleaved attribute vertex stream.
* Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
* from GL by using a vertex buffer object.
*/
memset(vtx->logical, 0, 0x5ef80);
#ifndef INDEXED
printf("Interleaving vertices...\n");
float *vertices_array = companion_vertices_array();
float *texture_coordinates_array =
companion_texture_coordinates_array();
float *normals_array = companion_normals_array();
assert(COMPANION_ARRAY_COUNT*(3+3+2)*sizeof(float) < VERTEX_BUFFER_SIZE);
for(int vert=0; vert<COMPANION_ARRAY_COUNT; ++vert)
{
int dest_idx = vert * (3 + 3 + 2);
for(int comp=0; comp<3; ++comp)
((float*)vtx->logical)[dest_idx+comp+0] = vertices_array[vert*3 + comp]; /* 0 */
for(int comp=0; comp<3; ++comp)
((float*)vtx->logical)[dest_idx+comp+3] = normals_array[vert*3 + comp]; /* 1 */
for(int comp=0; comp<2; ++comp)
((float*)vtx->logical)[dest_idx+comp+6] = texture_coordinates_array[vert*2 + comp]; /* 2 */
}
#else
printf("Interleaving vertices and copying index buffer...\n");
assert(COMPANION_VERTEX_COUNT*(3+3+2)*sizeof(float) < VERTEX_BUFFER_SIZE);
for(int vert=0; vert<COMPANION_VERTEX_COUNT; ++vert)
{
int dest_idx = vert * (3 + 3 + 2);
for(int comp=0; comp<3; ++comp)
((float*)vtx->logical)[dest_idx+comp+0] = companion_vertices[vert][comp]; /* 0 */
for(int comp=0; comp<3; ++comp)
((float*)vtx->logical)[dest_idx+comp+3] = companion_normals[vert][comp]; /* 1 */
for(int comp=0; comp<2; ++comp)
((float*)vtx->logical)[dest_idx+comp+6] = companion_texture_coordinates[vert][comp]; /* 2 */
}
assert(COMPANION_TRIANGLE_COUNT*3*sizeof(unsigned short) < INDEX_BUFFER_SIZE);
memcpy(idx->logical, &companion_triangles[0][0], COMPANION_TRIANGLE_COUNT*3*sizeof(unsigned short));
#endif
/* Fill in texture (convert from RGB linear to tiled) */
#define TILE_WIDTH (4)
#define TILE_HEIGHT (4)
#define TILE_WORDS (TILE_WIDTH*TILE_HEIGHT)
unsigned ytiles = COMPANION_TEXTURE_HEIGHT / TILE_HEIGHT;
unsigned xtiles = COMPANION_TEXTURE_WIDTH / TILE_WIDTH;
unsigned dst_stride = xtiles * TILE_WORDS;
for(unsigned ty=0; ty<ytiles; ++ty)
{
for(unsigned tx=0; tx<xtiles; ++tx)
{
unsigned ofs = ty * dst_stride + tx * TILE_WORDS;
for(unsigned y=0; y<TILE_HEIGHT; ++y)
{
for(unsigned x=0; x<TILE_WIDTH; ++x)
{
unsigned srcy = ty*TILE_HEIGHT + y;
unsigned srcx = tx*TILE_WIDTH + x;
unsigned src_ofs = (srcy*COMPANION_TEXTURE_WIDTH+srcx)*3;
unsigned r,g,b,a;
#ifndef TEST_PATTERN /* actual texture */
r = ((uint8_t*)companion_texture)[src_ofs+0];
g = ((uint8_t*)companion_texture)[src_ofs+1];
b = ((uint8_t*)companion_texture)[src_ofs+2];
#else /* test pattern */
r = srcx; g = srcy; b = 0;
#endif
a = 255;
((uint32_t*)tex->logical)[ofs] = ((a&0xFF) << 24) | ((b&0xFF) << 16) | ((g&0xFF) << 8) | (r&0xFF);
ofs += 1;
}
}
}
}
etna_ctx *ctx = 0;
if(etna_create(&ctx) != ETNA_OK)
{
printf("Unable to create context\n");
exit(1);
}
for(int frame=0; frame<1000; ++frame)
{
printf("*** FRAME %i ****\n", frame);
/* XXX part of this can be put outside the loop, but until we have usable context management
* this is safest.
*/
etna_set_state(ctx, VIVS_GL_VERTEX_ELEMENT_CONFIG, 0x1);
etna_set_state(ctx, VIVS_RA_CONTROL, 0x1);
etna_set_state(ctx, VIVS_PA_W_CLIP_LIMIT, 0x34000001);
etna_set_state(ctx, VIVS_PA_SYSTEM_MODE, 0x11);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_UNK22, 0));
etna_set_state(ctx, VIVS_SE_CONFIG, 0x0);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_PE_ALPHA_CONFIG,
ETNA_MASKED_BIT(VIVS_PE_ALPHA_CONFIG_BLEND_ENABLE_COLOR, 0) &
ETNA_MASKED_BIT(VIVS_PE_ALPHA_CONFIG_BLEND_ENABLE_ALPHA, 0) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_SRC_FUNC_COLOR, BLEND_FUNC_ONE) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_SRC_FUNC_ALPHA, BLEND_FUNC_ONE) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_DST_FUNC_COLOR, BLEND_FUNC_ZERO) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_DST_FUNC_ALPHA, BLEND_FUNC_ZERO) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_EQ_COLOR, BLEND_EQ_ADD) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_EQ_ALPHA, BLEND_EQ_ADD));
etna_set_state(ctx, VIVS_PE_ALPHA_BLEND_COLOR,
VIVS_PE_ALPHA_BLEND_COLOR_B(0) |
VIVS_PE_ALPHA_BLEND_COLOR_G(0) |
VIVS_PE_ALPHA_BLEND_COLOR_R(0) |
VIVS_PE_ALPHA_BLEND_COLOR_A(0));
etna_set_state(ctx, VIVS_PE_ALPHA_OP, ETNA_MASKED_BIT(VIVS_PE_ALPHA_OP_ALPHA_TEST, 0));
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_CULL_FACE_MODE, CCW));
etna_set_state(ctx, VIVS_PE_STENCIL_CONFIG, ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_REF_FRONT, 0) &
ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_MASK_FRONT, 0xff) &
ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_WRITE_MASK, 0xff) &
ETNA_MASKED_INL(VIVS_PE_STENCIL_CONFIG_MODE, DISABLED));
etna_set_state(ctx, VIVS_PE_STENCIL_OP, ETNA_MASKED(VIVS_PE_STENCIL_OP_FUNC_FRONT, COMPARE_FUNC_ALWAYS) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FUNC_BACK, COMPARE_FUNC_ALWAYS) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FAIL_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FAIL_BACK, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_DEPTH_FAIL_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_DEPTH_FAIL_BACK, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_PASS_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_PASS_BACK, STENCIL_OP_KEEP));
etna_set_state(ctx, VIVS_SE_DEPTH_SCALE, 0x0);
etna_set_state(ctx, VIVS_SE_DEPTH_BIAS, 0x0);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_FILL_MODE, SOLID) &
ETNA_MASKED_INL(VIVS_PA_CONFIG_SHADE_MODEL, SMOOTH));
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT,
ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_PARTIAL, 0) &
ETNA_MASKED(VIVS_PE_COLOR_FORMAT_COMPONENTS, 0xf) &
ETNA_MASKED(VIVS_PE_COLOR_FORMAT_FORMAT, RS_FORMAT_X8R8G8B8) &
ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_SUPER_TILED, 1));
etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address);
etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4);
uint32_t ts_msaa_config;
if(supersample_x == 2 && supersample_y == 2)
{
// 4X MSAA
etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG,
ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, 4X) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_ENABLES, 0xf) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK12, 0x0) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK16, 0x0)
);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E04, 0x0);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E10(2), 0xaaa22a22);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(8), 0x262a2288);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(9), 0x886688a2);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(10), 0x888866aa);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(11), 0x668888a6);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E10(1), 0xe6ae622a);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(4), 0x46622a88);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(5), 0x888888ae);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(6), 0x888888e6);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(7), 0x888888ca);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E10(0), 0xeaa26e26);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(0), 0x4a6e2688);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(1), 0x888888a2);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(2), 0x888888ea);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(3), 0x888888c6);
ts_msaa_config = VIVS_TS_MEM_CONFIG_MSAA | VIVS_TS_MEM_CONFIG_MSAA_FORMAT_A8R8G8B8;
} else if(supersample_x == 2 && supersample_y == 1)
{
// 2X MSAA
etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG,
ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, 2X) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_ENABLES, 0xf) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK12, 0x0) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK16, 0x0)
);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E04, 0x0);
etna_set_state(ctx, VIVS_RA_MULTISAMPLE_UNK00E10(0), 0xaa22);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(0), 0x66aa2288);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(1), 0x88558800);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(2), 0x88881100);
etna_set_state(ctx, VIVS_RA_CENTROID_TABLE(3), 0x33888800);
ts_msaa_config = VIVS_TS_MEM_CONFIG_MSAA | VIVS_TS_MEM_CONFIG_MSAA_FORMAT_A8R8G8B8;
} else { // No multisampling
etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG,
ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, NONE) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_ENABLES, 0xf) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK12, 0x0) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK16, 0x0)
);
ts_msaa_config = 0;
}
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG,
ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 0) &
ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_FORMAT, D16) &
ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_SUPER_TILED, 1) &
ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_EARLY_Z, 1));
etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address);
etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address);
etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address);
etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_DEPTH_16BPP |
VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION |
ts_msaa_config);
#ifdef EXTRA_DELAYS
/* Warm up RS on aux render target (is this needed?) */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts_physical);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt_physical);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt_physical, aux_rt_ts_physical);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts_physical);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt_physical);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt_physical, aux_rt_ts_physical);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts_physical);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt_physical);
#endif
/* sync rasterizer to pixel engine after changes to PE config */
etna_stall(ctx, SYNC_RECIPIENT_RA, SYNC_RECIPIENT_PE);
/* Set up the resolve to clear tile status for main render target and depth
* Regard the TS as an image of width 16 with 4 bytes per pixel (64 bytes per row)
* */
etna_set_state(ctx, VIVS_RS_CONFIG,
VIVS_RS_CONFIG_SOURCE_FORMAT(RS_FORMAT_A8R8G8B8) |
VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_A8R8G8B8)
);
etna_set_state_multi(ctx, VIVS_RS_DITHER(0), 2, (uint32_t[]){0xffffffff, 0xffffffff});
etna_set_state(ctx, VIVS_RS_FILL_VALUE(0), 0x55555555);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL,
VIVS_RS_CLEAR_CONTROL_MODE_ENABLED1 |
(0xffff << VIVS_RS_CLEAR_CONTROL_BITS__SHIFT));
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
/* clear color ts */
etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address);
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
((rt_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
(16 << VIVS_RS_WINDOW_SIZE_WIDTH__SHIFT));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
/* clear depth ts */
etna_set_state(ctx, VIVS_RS_DEST_ADDR, z_ts->address);
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
((z_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
(16 << VIVS_RS_WINDOW_SIZE_WIDTH__SHIFT));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
/** Done */
etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
/* depth setup */
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 1) &
ETNA_MASKED(VIVS_PE_DEPTH_CONFIG_DEPTH_FUNC, COMPARE_FUNC_LESS) &
ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_MODE, Z) &
ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_ONLY_DEPTH, 0));
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NEAR, 0.0);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_FAR, 1.0);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
/* set up primitive assembly and setup engine */
etna_set_state_f32(ctx, VIVS_PA_VIEWPORT_OFFSET_Z, 0.0);
etna_set_state_f32(ctx, VIVS_PA_VIEWPORT_SCALE_Z, 1.0);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_OFFSET_X, width << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_OFFSET_Y, height << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_SCALE_X, width << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_SCALE_Y, height << 15);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_LEFT, 0);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_TOP, 0);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_RIGHT, (width << 16) | 5);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_BOTTOM, (height << 16) | 5);
/* set up texture unit */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_TEXTURE);
etna_set_state(ctx, VIVS_TE_SAMPLER_SIZE(0),
VIVS_TE_SAMPLER_SIZE_WIDTH(512)|VIVS_TE_SAMPLER_SIZE_HEIGHT(512));
etna_set_state(ctx, VIVS_TE_SAMPLER_LOG_SIZE(0),
VIVS_TE_SAMPLER_LOG_SIZE_WIDTH(9<<5) |
VIVS_TE_SAMPLER_LOG_SIZE_HEIGHT(9<<5));
etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_ADDR(0,0), tex->address);
etna_set_state(ctx, VIVS_TE_SAMPLER_CONFIG0(0),
VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_2D)|
VIVS_TE_SAMPLER_CONFIG0_UWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE)|
VIVS_TE_SAMPLER_CONFIG0_VWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE)|
VIVS_TE_SAMPLER_CONFIG0_MIN(TEXTURE_FILTER_LINEAR)|
VIVS_TE_SAMPLER_CONFIG0_MIP(TEXTURE_FILTER_NONE)|
VIVS_TE_SAMPLER_CONFIG0_MAG(TEXTURE_FILTER_LINEAR)|
VIVS_TE_SAMPLER_CONFIG0_FORMAT(TEXTURE_FORMAT_X8R8G8B8));
etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_CONFIG(0), 0x00000000); /* TE.SAMPLER[0].LOD_CONFIG := 0x0 */
/* shader setup */
etna_set_state(ctx, VIVS_VS_END_PC, vs_size/16);
etna_set_state_multi(ctx, VIVS_VS_INPUT_COUNT, 3, (uint32_t[]){
/* VIVS_VS_INPUT_COUNT */ VIVS_VS_INPUT_COUNT_UNK8(1) | VIVS_VS_INPUT_COUNT_COUNT(3),
/* VIVS_VS_TEMP_REGISTER_CONTROL */ VIVS_VS_TEMP_REGISTER_CONTROL_NUM_TEMPS(6),
/* VIVS_VS_OUTPUT(0) */ 0x10004});
etna_set_state(ctx, VIVS_VS_START_PC, 0x0);
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(45), 0.5); /* u11.y */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(44), 1.0); /* u11.x */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(27), 0.0); /* u6.w */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(23), 20.0); /* u5.w */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(19), 2.0); /* u4.w */
/* Now load the shader itself */
etna_set_state_multi(ctx, VIVS_VS_INST_MEM(0), vs_size/4, vs);
etna_set_state(ctx, VIVS_RA_CONTROL, 0x3);
etna_set_state_f32(ctx, VIVS_PS_UNIFORMS(0), 1.0); /* u0.x */
etna_set_state_multi(ctx, VIVS_PS_END_PC, 2, (uint32_t[]){
/* VIVS_PS_END_PC */ ps_size/16,
/* VIVS_PS_OUTPUT_REG */ 0x1});
etna_set_state(ctx, VIVS_PS_START_PC, 0x0);
etna_set_state(ctx, VIVS_PA_ATTRIBUTE_ELEMENT_COUNT, 0x200);
etna_set_state(ctx, VIVS_PA_SHADER_ATTRIBUTES(0), 0x200);
etna_set_state(ctx, VIVS_PA_SHADER_ATTRIBUTES(1), 0x200);
etna_set_state(ctx, VIVS_GL_VARYING_NUM_COMPONENTS,
VIVS_GL_VARYING_NUM_COMPONENTS_VAR0(4)| /* position */
VIVS_GL_VARYING_NUM_COMPONENTS_VAR1(2) /* texture coordinate */
);
etna_set_state_multi(ctx, VIVS_GL_VARYING_COMPONENT_USE(0), 2, (uint32_t[]){
VIVS_GL_VARYING_COMPONENT_USE_COMP0(VARYING_COMPONENT_USE_USED) |
VIVS_GL_VARYING_COMPONENT_USE_COMP1(VARYING_COMPONENT_USE_USED) |
VIVS_GL_VARYING_COMPONENT_USE_COMP2(VARYING_COMPONENT_USE_USED) |
VIVS_GL_VARYING_COMPONENT_USE_COMP3(VARYING_COMPONENT_USE_USED) |
VIVS_GL_VARYING_COMPONENT_USE_COMP4(VARYING_COMPONENT_USE_USED) |
VIVS_GL_VARYING_COMPONENT_USE_COMP5(VARYING_COMPONENT_USE_USED)
, 0
});
etna_set_state_multi(ctx, VIVS_PS_INST_MEM(0), ps_size/4, ps);
etna_set_state(ctx, VIVS_PS_INPUT_COUNT,
VIVS_PS_INPUT_COUNT_UNK8(31)| VIVS_PS_INPUT_COUNT_COUNT(3 + extra_ps_inputs));
etna_set_state(ctx, VIVS_PS_TEMP_REGISTER_CONTROL,
VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS(3 + extra_ps_inputs));
etna_set_state(ctx, VIVS_PS_CONTROL, VIVS_PS_CONTROL_UNK1);
etna_set_state(ctx, VIVS_GL_VARYING_TOTAL_COMPONENTS,
VIVS_GL_VARYING_TOTAL_COMPONENTS_NUM(6)); /* 4+2=6 total varying components */
etna_set_state(ctx, VIVS_VS_LOAD_BALANCING, 0xf3f0542); /* depends on number of inputs/outputs/varyings? XXX how exactly */
etna_set_state(ctx, VIVS_VS_OUTPUT_COUNT, 3);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_POINT_SIZE_ENABLE, 0));
/* Compute transform matrices in the same way as cube egl demo */
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -9.0f);
esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
esRotate(&modelview, frame*0.5f, 0.0f, 0.0f, 1.0f);
esScale(&modelview, 0.475f, 0.475f, 0.475f);
GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -2.8f, +2.8f, -2.8f * aspect, +2.8f * aspect, 6.0f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
ESMatrix inverse, normal; /* compute inverse transpose normal transformation matrix */
esMatrixInverse3x3(&inverse, &modelview);
esMatrixTranspose(&normal, &inverse);
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(0), 16, (uint32_t*)&modelviewprojection.m[0][0]);
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(16), 3, (uint32_t*)&normal.m[0][0]); /* u4.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(20), 3, (uint32_t*)&normal.m[1][0]); /* u5.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(24), 3, (uint32_t*)&normal.m[2][0]); /* u6.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(28), 16, (uint32_t*)&modelview.m[0][0]);
#ifdef INDEXED
etna_set_state(ctx, VIVS_FE_INDEX_STREAM_BASE_ADDR, idx->address);
etna_set_state(ctx, VIVS_FE_INDEX_STREAM_CONTROL, VIVS_FE_INDEX_STREAM_CONTROL_TYPE_UNSIGNED_SHORT);
#endif
etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address);
etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL,
VIVS_FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE((3 + 3 + 2)*4));
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM(0) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM_3 |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
VIVS_FE_VERTEX_ELEMENT_CONFIG_START(0x0) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_END(0xc));
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(1),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM(0) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM_3 |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
VIVS_FE_VERTEX_ELEMENT_CONFIG_START(0xc) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_END(0x18));
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(2),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NONCONSECUTIVE |
VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM(0) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM_2 |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
VIVS_FE_VERTEX_ELEMENT_CONFIG_START(0x18) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_END(0x20));
etna_set_state(ctx, VIVS_VS_INPUT(0), 0x20100);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_POINT_SPRITE_ENABLE, 0));
#ifdef INDEXED
etna_draw_indexed_primitives(ctx, PRIMITIVE_TYPE_TRIANGLES, 0, COMPANION_TRIANGLE_COUNT, 0);
#else
etna_draw_primitives(ctx, PRIMITIVE_TYPE_TRIANGLES, 0, COMPANION_TRIANGLE_COUNT);
#endif
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
#ifdef EXTRA_DELAYS
etna_flush(ctx);
#endif
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_RS_CONFIG,
VIVS_RS_CONFIG_SOURCE_FORMAT(RS_FORMAT_A8R8G8B8) |
VIVS_RS_CONFIG_SOURCE_TILED |
VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_A8R8G8B8) |
VIVS_RS_CONFIG_DEST_TILED);
etna_set_state(ctx, VIVS_RS_SOURCE_STRIDE, (padded_width * 4 * 4) | VIVS_RS_SOURCE_STRIDE_TILING);
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, (padded_width * 4 * 4) | VIVS_RS_DEST_STRIDE_TILING);
etna_set_state(ctx, VIVS_RS_DITHER(0), 0xffffffff);
etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address);
etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
#ifdef EXTRA_DELAYS
etna_flush(ctx);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
#endif
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_DEPTH_16BPP |
VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
/* Wait for pixel engine to finish */
#ifdef EXTRA_DELAYS
etna_finish(ctx);
#else
etna_stall(ctx, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
#endif
/* Copy result to framebuffer */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_RS_CONFIG,
VIVS_RS_CONFIG_SOURCE_FORMAT(RS_FORMAT_A8R8G8B8) |
VIVS_RS_CONFIG_SOURCE_TILED |
((supersample_x>1)?VIVS_RS_CONFIG_DOWNSAMPLE_X:0) |
((supersample_y>1)?VIVS_RS_CONFIG_DOWNSAMPLE_Y:0) |
VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_A8R8G8B8) |
VIVS_RS_CONFIG_SWAP_RB);
etna_set_state(ctx, VIVS_RS_SOURCE_STRIDE, (padded_width * 4 * 4) | VIVS_RS_SOURCE_STRIDE_TILING);
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, fb.fb_fix.line_length);
etna_set_state(ctx, VIVS_RS_DITHER(0), 0xffffffff);
etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address);
etna_set_state(ctx, VIVS_RS_DEST_ADDR, fb.physical[backbuffer]);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
VIVS_RS_WINDOW_SIZE_HEIGHT(height * supersample_y) |
VIVS_RS_WINDOW_SIZE_WIDTH(width * supersample_x));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
etna_finish(ctx);
/* switch buffers */
fb_set_buffer(&fb, backbuffer);
backbuffer = 1-backbuffer;
}
etna_free(ctx);
viv_close();
return 0;
}
void *gpu_copy_thread(void *data)
{
workload_t *w = (workload_t *)data;
struct limare_state *state;
int ret, width, height, x, y;
#include "shader_v.h"
#include "shader_f.h"
load_mali_kernel_module();
state = limare_init();
assert(state);
ret = limare_state_setup(state, 0, 0, 0xFF505050);
assert(state);
limare_buffer_size(state, &width, &height);
int program = limare_program_new(state);
vertex_shader_attach_mbs_stream(state, program, vertex_shader_binary,
sizeof(vertex_shader_binary));
fragment_shader_attach_mbs_stream(state, program, fragment_shader_binary,
sizeof(fragment_shader_binary));
limare_link(state);
limare_attribute_pointer(state, "in_position", LIMARE_ATTRIB_FLOAT,
3, 0, COPYTEST_VERTEX_COUNT, copytest_vertices);
limare_attribute_pointer(state, "in_coord", LIMARE_ATTRIB_FLOAT,
2, 0, COPYTEST_VERTEX_COUNT,
copytest_texture_coordinates);
/* Generate a texture */
uint32_t *checkerboard_texture = malloc(width * height * sizeof(uint32_t));
assert(checkerboard_texture);
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
uint32_t color;
if (((x * 8 / width) % 2 == 0) ^ ((y * 8 / height) % 2 == 0))
color = (x % 2) ? 0xFFFFFFFF : 0;
else
color = (y % 2) ? 0xFFFFFFFF : 0;
checkerboard_texture[y * width + x] = color;
}
}
int texture = limare_texture_upload(state, checkerboard_texture,
width, height,
LIMA_TEXEL_FORMAT_RGBA_8888, 0);
limare_texture_attach(state, "in_texture", texture);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esTranslate(&modelviewprojection, 0.0, 0.0, -0.5);
while (1) {
limare_uniform_attach(state, "modelviewprojectionMatrix", 16,
&modelviewprojection.m[0][0]);
limare_frame_new(state);
ret = limare_draw_elements(state, GL_TRIANGLES,
COPYTEST_INDEX_COUNT,
©test_indices,
GL_UNSIGNED_BYTE);
assert(!ret);
ret = limare_frame_flush(state);
assert(!ret);
limare_buffer_swap(state);
pthread_mutex_lock(&bandwidth_counters_mutex);
w->bytes_counter += width * height * (state->fb->bpp / 8) +
width * height * 4;
pthread_mutex_unlock(&bandwidth_counters_mutex);
}
limare_finish(state);
free(checkerboard_texture);
return 0;
}
void test_cat(void)
{
GLint width, height;
GLint modelviewmatrix_handle, modelviewprojectionmatrix_handle, normalmatrix_handle;
GLuint position_vbo, normal_vbo;
EGLSurface surface;
float scale = 1.3;
DEBUG_MSG("----------------------------------------------------------------");
RD_START("cat", "");
display = get_display();
/* get an appropriate EGL frame buffer configuration */
ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config));
DEBUG_MSG("num_config: %d", num_config);
/* create an EGL rendering context */
ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list));
surface = make_window(display, config, 400, 240);
ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width));
ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height));
DEBUG_MSG("Buffer: %dx%d", width, height);
/* connect the context to the surface */
ECHK(eglMakeCurrent(display, surface, surface, context));
program = get_program(vertex_shader_source, fragment_shader_source);
GCHK(glBindAttribLocation(program, 0, "normal"));
GCHK(glBindAttribLocation(program, 1, "position"));
/* upload the attribute vbo's, only done once: */
GCHK(glGenBuffers(1, &normal_vbo));
GCHK(glBindBuffer(GL_ARRAY_BUFFER, normal_vbo));
GCHK(glBufferData(GL_ARRAY_BUFFER, sizeof(cat_normal), cat_normal, GL_STATIC_DRAW));
GCHK(glGenBuffers(1, &position_vbo));
GCHK(glBindBuffer(GL_ARRAY_BUFFER, position_vbo));
GCHK(glBufferData(GL_ARRAY_BUFFER, sizeof(cat_position), cat_position, GL_STATIC_DRAW));
link_program(program);
GCHK(glViewport(0, 0, width, height));
/* clear the color buffer */
GCHK(glClearColor(0.5, 0.5, 0.5, 1.0));
GCHK(glEnable(GL_DEPTH_TEST));
GCHK(glDepthFunc(GL_LEQUAL));
GCHK(glEnable(GL_CULL_FACE));
GCHK(glCullFace(GL_BACK));
GCHK(glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT));
GCHK(glEnableVertexAttribArray(0));
GCHK(glBindBuffer(GL_ARRAY_BUFFER, normal_vbo));
GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL));
GCHK(glEnableVertexAttribArray(1));
GCHK(glBindBuffer(GL_ARRAY_BUFFER, position_vbo));
GCHK(glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL));
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection,
-scale, +scale,
-scale * aspect, +scale * aspect,
5.5f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
GCHK(modelviewmatrix_handle = glGetUniformLocation(program, "ModelViewMatrix"));
GCHK(modelviewprojectionmatrix_handle = glGetUniformLocation(program, "ModelViewProjectionMatrix"));
GCHK(normalmatrix_handle = glGetUniformLocation(program, "NormalMatrix"));
GCHK(glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]));
GCHK(glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]));
GCHK(glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal));
GCHK(glDrawArrays(GL_TRIANGLES, 0, cat_vertices));
ECHK(eglSwapBuffers(display, surface));
GCHK(glFlush());
ECHK(eglDestroySurface(display, surface));
ECHK(eglTerminate(display));
RD_END();
}
PhysicalObject::PhysicalObject(): gravity(true) {
esMatrixLoadIdentity(&transform);
velocity[0] = 0.0; velocity[2] = 0.0; velocity[2] = 0.0;
}
int main(int argc, char **argv)
{
struct fd_state *state;
struct fd_surface *surface, *lolstex1, *lolstex2;
struct fd_program *cat_program, *tex_program;
struct fd_bo *position_vbo, *normal_vbo;
const char *cat_vertex_shader_asm =
"@varying(R0) vertex_normal \n"
"@varying(R1) vertex_position \n"
"@attribute(R1) normal \n"
"@attribute(R2) position \n"
"@uniform(C0-C3) ModelViewMatrix \n"
"@uniform(C4-C7) ModelViewProjectionMatrix \n"
"@uniform(C8-C10) NormalMatrix \n"
"@const(C11) 1.000000, 0.000000, 0.000000, 0.000000 \n"
"EXEC \n"
" FETCH: VERTEX R1.xyz_ = R0.x FMT_32_32_32_FLOAT SIGNED STRIDE(12) CONST(20, 0)\n"
" FETCH: VERTEX R2.xyz_ = R0.x FMT_32_32_32_FLOAT SIGNED STRIDE(12) CONST(20, 1)\n"
" (S)ALU: MULADDv R0 = C7, R2.zzzz, C6 \n"
" ALU: MULADDv R0 = R0, R2.yyyy, C5 \n"
"ALLOC POSITION SIZE(0x0) \n"
"EXEC \n"
" ALU: MULADDv export62 = R0, R2.xxxx, C4 ; gl_Position \n"
" ALU: MULv R0.xyz_ = R1.zzzw, C10 \n"
" ALU: MULADDv R0.xyz_ = R0, R1.yyyw, C9 \n"
" ALU: MULADDv R0.xyz_ = R0, R1.xxxw, C8 \n"
" ALU: DOT3v R1.x___ = R0, R0 \n"
" ALU: MULADDv R3 = C3, R2.zzzz, C2 \n"
"EXEC \n"
" ALU: MULADDv R3 = R3, R2.yyyy, C1 \n"
" ALU: MAXv R0.____ = R0, R0 \n"
" RECIPSQ_IEEE R0.___w = R1.xyzx \n"
"ALLOC PARAM/PIXEL SIZE(0x1) \n"
"EXEC_END \n"
" ALU: MULADDv export1 = R3, R2.xxxx, C0 \n"
" ALU: MULv export0.xyz_ = R0, R0.wwww \n";
const char *cat_fragment_shader_asm =
/*
precision mediump float;
const vec4 MaterialDiffuse = vec4(0.000000, 0.000000, 1.000000, 1.000000);
const vec4 LightColor0 = vec4(0.800000, 0.800000, 0.800000, 1.000000);
const vec4 light_position = vec4(0.000000, 1.000000, 0.000000, 1.000000);
varying vec3 vertex_normal;
varying vec4 vertex_position;
void main(void)
{
const vec4 diffuse_light_color = LightColor0;
const vec4 lightAmbient = vec4(0.1, 0.1, 0.1, 1.0);
const vec4 lightSpecular = vec4(0.8, 0.8, 0.8, 1.0);
const vec4 matAmbient = vec4(0.2, 0.2, 0.2, 1.0);
const vec4 matSpecular = vec4(1.0, 1.0, 1.0, 1.0);
const float matShininess = 100.0; // C4.x
vec3 eye_direction = normalize(-vertex_position.xyz);
vec3 light_direction = normalize(light_position.xyz/light_position.w -
vertex_position.xyz/vertex_position.w);
vec3 normalized_normal = normalize(vertex_normal);
// reflect(i,n) -> i - 2 * dot(n,i) * n
vec3 reflection = reflect(-light_direction, normalized_normal);
float specularTerm = pow(max(0.0, dot(reflection, eye_direction)), matShininess);
float diffuseTerm = max(0.0, dot(normalized_normal, light_direction));
vec4 specular = (lightSpecular * matSpecular);
vec4 ambient = (lightAmbient * matAmbient);
vec4 diffuse = (diffuse_light_color * MaterialDiffuse);
vec4 result = (specular * specularTerm) + ambient + (diffuse * diffuseTerm);
gl_FragColor = result;
}
*/
"@varying(R0) vertex_normal \n"
"@varying(R1) vertex_position \n"
"@const(C0) 0.000000, 1.000000, 0.000000, 0.000000 \n"
"@const(C1) 0.800000, 0.800000, 0.800000, 1.000000 \n"
"@const(C2) 0.020000, 0.020000, 0.020000, 1.000000 \n"
"@const(C3) 0.000000, 0.000000, 0.800000, 1.000000 \n"
"@const(C4) 100.000000, 0.000000, 0.000000, 0.000000 \n"
"EXEC \n"
" (S)ALU: DOT3v R2.x___ = R0, R0 ; normalize(vertex_normal) \n"
" RECIP_IEEE R3.x___ = R1 ; 1/vertex_position.x ? R1.wyzw? \n"
" ALU: MULADDv R3.xyz_ = C0.xyxw, -R1, R3.xxxw ; light_position.xyz/1.0 - \n"
" ; vertex_position.xyz/vertex_position.w \n"
" ALU: DOT3v R2.x___ = R3, R3 ; normalize(light_position...) \n"
" RECIPSQ_IEEE R0.___w = R2.xyzx ; normalize(vertex_normal) \n"
"; here the RSQ sees the R2 value written in first instruction, rather than \n"
"; the R2 dst being calculated as part of the same VLIW instruction \n"
" ALU: MULv R0.xyz_ = R0, R0.wwww ; normalized_normal = normalize(vertex_normal) \n"
" RECIPSQ_IEEE R0.___w = R2.xyzx ; normalize(light_position...) \n"
" ALU: MULv R2.xyz_ = R3, R0.wwww ; light_direction = normalize(light_position...) \n"
" ALU: DOT3v R3.x___ = -R1, -R1 ; normalize(-vertex_position.xyz) \n"
"EXEC \n"
"; reflect(i,n) -> i - 2 * dot(n,i) * n \n"
" ALU: DOT3v R3.x___ = -R2, R0 ; reflect(-light_direction, normalized_normal) \n"
" RECIPSQ_IEEE R0.___w = R3.xyzx ; normalize(-vertex_position.xyz); \n"
" ALU: MULv R1.xyz_ = -R1, R0.wwww ; eye_direction = normalize(-vertex_position.xyz) \n"
" ADDs R3.x___ = R3.xyzx ; 2 * dot(n, i) \n"
" ALU: MULADDv R3.xyz_ = -R2, R0, -R3.xxxw ; reflect(..) -> i + (n * (2 * dot(n, i)) \n"
" ALU: DOT3v R1.x___ = R1, R3 ; dot(reflection, eye_direction) \n"
" ALU: MAXv R1.x___ = R1, C0 ; max(0.0, dot(reflection, eye_direction) \n"
" ALU: DOT3v R0.x___ = R2, R0 ; dot(normalized_normal, light_direction) \n"
" LOG_CLAMP R0.___w = R1.xyzx ; pow(max(0.0, dot(...)), matShininess) \n"
"EXEC \n"
" ALU: MAXv R0.x___ = R0, C0 ; diffuseTerm = max(0.0, dot(...)) \n"
" MUL_CONST_0 R0.___w = C4.wyzx ; specularTerm = pow(..., matShininess) \n"
" ALU: MAXv R0.____ = R0, R0 \n"
" EXP_IEEE R1.x___ = R0 ; specularTerm = pow(..) \n"
"; C2 is ambient = (lightAmbient * matAmbient) = vec4(0.1,0.1,0.1,1.0) * vec4(0.2,0.2,0.2,1.0) \n"
"; C1 is specular = (lightSpecular * matSpecular) = vec4(0.8,0.8,0.8,1.0) * vec4(1.0,1.0,1.0,1.0) \n"
" ALU: MULADDv R1.x__w = C2, R1.xyzx, C1 ; ambient + (specularTerm * specular) \n"
"ALLOC PARAM/PIXEL SIZE(0x0) \n"
"EXEC_END ADDR(0x12) CNT(0x1) \n"
" ALU: MULADDv export0 = R1.xxxw, R0.xxxx, C3.xxzw ; gl_FragColor \n"
"NOP \n";
static const GLfloat texcoords[] = {
0.0f, 1.0f,
1.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
};
static const GLfloat tex1_vertices[] = {
-0.95, +0.45, -1.0,
+0.45, +0.45, -1.0,
-0.95, +0.95, -1.0,
+0.45, +0.95, -1.0
};
static const GLfloat tex2_vertices[] = {
-0.45, -0.95, -1.0,
+0.95, -0.95, -1.0,
-0.45, -0.45, -1.0,
+0.95, -0.45, -1.0
};
const char *tex_vertex_shader_asm =
"@attribute(R1) aPosition \n"
"@attribute(R2) aTexCoord \n"
"@varying(R0) vTexCoord \n"
"EXEC \n"
" FETCH: VERTEX R2.xy11 = R0.x FMT_32_32_FLOAT SIGNED \n"
" STRIDE(8) CONST(20, 1) \n"
" (S)FETCH: VERTEX R1.xyz1 = R0.x FMT_32_32_32_FLOAT SIGNED \n"
" STRIDE(12) CONST(20, 0) \n"
"ALLOC POSITION SIZE(0x0) \n"
"EXEC \n"
" ALU: MAXv export62 = R1, R1 ; gl_Position \n"
"ALLOC PARAM/PIXEL SIZE(0x0) \n"
"EXEC_END \n"
" ALU: MAXv export0 = R2, R2 ; vTexCoord \n"
"NOP \n";
const char *tex_fragment_shader_asm =
"@varying(R0) vTexCoord \n"
"@sampler(0) uTexture \n"
"EXEC \n"
" (S)FETCH: SAMPLE R0.xyzw = R0.xyx CONST(0) \n"
"ALLOC PARAM/PIXEL SIZE(0x0) \n"
"EXEC_END \n"
" ALU: MAXv export0 = R0, R0 ; gl_FragColor \n"
"NOP \n";
uint32_t width = 0, height = 0;
int i, n = 1;
if (argc == 2)
n = atoi(argv[1]);
DEBUG_MSG("----------------------------------------------------------------");
RD_START("fd-cat", "");
state = fd_init();
if (!state)
return -1;
surface = fd_surface_screen(state, &width, &height);
if (!surface)
return -1;
/* load textures: */
lolstex1 = fd_surface_new_fmt(state, lolstex1_image.width, lolstex1_image.height,
COLORX_8_8_8_8);
fd_surface_upload(lolstex1, lolstex1_image.pixel_data);
lolstex2 = fd_surface_new_fmt(state, lolstex2_image.width, lolstex2_image.height,
COLORX_8_8_8_8);
fd_surface_upload(lolstex2, lolstex2_image.pixel_data);
fd_enable(state, GL_CULL_FACE);
fd_depth_func(state, GL_LEQUAL);
fd_enable(state, GL_DEPTH_TEST);
fd_tex_param(state, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fd_tex_param(state, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
fd_blend_func(state, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* this needs to come after enabling depth test as enabling depth test
* effects bin sizes:
*/
fd_make_current(state, surface);
/* construct the two shader programs: */
cat_program = fd_program_new();
fd_program_attach_asm(cat_program, FD_SHADER_VERTEX, cat_vertex_shader_asm);
fd_program_attach_asm(cat_program, FD_SHADER_FRAGMENT, cat_fragment_shader_asm);
tex_program = fd_program_new();
fd_program_attach_asm(tex_program, FD_SHADER_VERTEX, tex_vertex_shader_asm);
fd_program_attach_asm(tex_program, FD_SHADER_FRAGMENT, tex_fragment_shader_asm);
fd_link(state);
position_vbo = fd_attribute_bo_new(state, cat_position_sz, cat_position);
normal_vbo = fd_attribute_bo_new(state, cat_normal_sz, cat_normal);
for (i = 0; i < n; i++) {
GLfloat aspect = (GLfloat)height / (GLfloat)width;
ESMatrix modelview;
ESMatrix projection;
ESMatrix modelviewprojection;
float normal[9];
float scale = 1.8;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f - (0.5f * i), 0.0f, 1.0f, 0.0f);
esMatrixLoadIdentity(&projection);
esFrustum(&projection,
-scale, +scale,
-scale * aspect, +scale * aspect,
5.5f, 10.0f);
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
fd_clear_color(state, 0xff000000);
fd_clear(state, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
fd_attribute_bo(state, "normal", normal_vbo);
fd_attribute_bo(state, "position", position_vbo);
fd_uniform_attach(state, "ModelViewMatrix",
4, 4, &modelview.m[0][0]);
fd_uniform_attach(state, "ModelViewProjectionMatrix",
4, 4, &modelviewprojection.m[0][0]);
fd_uniform_attach(state, "NormalMatrix",
3, 3, normal);
/* draw cat: */
fd_disable(state, GL_BLEND);
fd_set_program(state, cat_program);
fd_draw_arrays(state, GL_TRIANGLES, 0, cat_vertices);
/* setup to draw text (common to tex1 and tex2): */
fd_enable(state, GL_BLEND);
fd_set_program(state, tex_program);
fd_attribute_pointer(state, "aTexCoord", 2, 4, texcoords);
/* draw tex1: */
fd_set_texture(state, "uTexture", lolstex1);
fd_attribute_pointer(state, "aPosition", 3, 4, tex1_vertices);
fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4);
/* draw tex2: */
fd_set_texture(state, "uTexture", lolstex2);
fd_attribute_pointer(state, "aPosition", 3, 4, tex2_vertices);
fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4);
fd_swap_buffers(state);
}
fd_flush(state);
fd_dump_bmp(surface, "lolscat.bmp");
fd_fini(state);
RD_END();
return 0;
}
PhysicalObject::PhysicalObject(Mesh mesh, OBBBoundingBox bb, BoundingSphere bs): mesh(mesh), bb(bb), gravity(true), boundingSphere(bs) {
esMatrixLoadIdentity(&transform); // Initiate the transform matrix as the identity matrix
velocity[0] = 0.0; velocity[2] = 0.0; velocity[2] = 0.0;
}
int main(int argc, char **argv)
{
int rv;
int width = 256;
int height = 256;
int padded_width = etna_align_up(width, 64);
int padded_height = etna_align_up(height, 64);
printf("padded_width %i padded_height %i\n", padded_width, padded_height);
rv = viv_open();
if(rv!=0)
{
fprintf(stderr, "Error opening device\n");
exit(1);
}
printf("Succesfully opened device\n");
bool supertiled = VIV_FEATURE(chipMinorFeatures0,SUPER_TILED);
unsigned bits_per_tile = VIV_FEATURE(chipMinorFeatures0,2BITPERTILE)?2:4;
printf("Supertile: %i, bits per tile: %i\n", supertiled, bits_per_tile);
etna_vidmem *rt = 0; /* main render target */
etna_vidmem *rt_ts = 0; /* tile status for main render target */
etna_vidmem *z = 0; /* depth for main render target */
etna_vidmem *z_ts = 0; /* depth ts for main render target */
etna_vidmem *vtx = 0; /* vertex buffer */
etna_vidmem *aux_rt = 0; /* auxilary render target */
etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
etna_vidmem *bmp = 0; /* bitmap */
size_t rt_size = padded_width * padded_height * 4;
size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)*bits_per_tile/0x80, 0x100);
size_t z_size = padded_width * padded_height * 2;
size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)*bits_per_tile/0x80, 0x100);
size_t bmp_size = width * height * 4;
if(etna_vidmem_alloc_linear(&rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&aux_rt_ts, 0x80*bits_per_tile, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
etna_vidmem_alloc_linear(&bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
)
{
fprintf(stderr, "Error allocating video memory\n");
exit(1);
}
/* Phew, now we got all the memory we need.
* Write interleaved attribute vertex stream.
* Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
* from GL by using a vertex buffer object.
*/
for(int vert=0; vert<NUM_VERTICES; ++vert)
{
int src_idx = vert * COMPONENTS_PER_VERTEX;
int dest_idx = vert * COMPONENTS_PER_VERTEX * 3;
for(int comp=0; comp<COMPONENTS_PER_VERTEX; ++comp)
{
((float*)vtx->logical)[dest_idx+comp+0] = vVertices[src_idx + comp]; /* 0 */
((float*)vtx->logical)[dest_idx+comp+3] = vNormals[src_idx + comp]; /* 1 */
((float*)vtx->logical)[dest_idx+comp+6] = vColors[src_idx + comp]; /* 2 */
}
}
etna_ctx *ctx = 0;
if(etna_create(&ctx) != ETNA_OK)
{
printf("Unable to create context\n");
exit(1);
}
/* XXX how important is the ordering? I suppose we could group states (except the flushes, kickers, semaphores etc)
* and simply submit them at once. Especially for consecutive states and masked stated this could be a big win
* in DMA command buffer size. */
for(int frame=0; frame<1; ++frame)
{
printf("*** FRAME %i ****\n", frame);
/* XXX part of this can be put outside the loop, but until we have usable context management
* this is safest.
*/
etna_set_state(ctx, VIVS_GL_VERTEX_ELEMENT_CONFIG, 0x1);
etna_set_state(ctx, VIVS_RA_CONTROL, 0x1);
etna_set_state(ctx, VIVS_PA_W_CLIP_LIMIT, 0x34000001);
etna_set_state(ctx, VIVS_PA_SYSTEM_MODE, 0x11);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_UNK22, 0));
etna_set_state(ctx, VIVS_SE_CONFIG, 0x0);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT,
ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_PARTIAL, 0));
etna_set_state(ctx, VIVS_PE_ALPHA_CONFIG,
ETNA_MASKED_BIT(VIVS_PE_ALPHA_CONFIG_BLEND_ENABLE_COLOR, 0) &
ETNA_MASKED_BIT(VIVS_PE_ALPHA_CONFIG_BLEND_ENABLE_ALPHA, 0) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_SRC_FUNC_COLOR, BLEND_FUNC_ONE) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_SRC_FUNC_ALPHA, BLEND_FUNC_ONE) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_DST_FUNC_COLOR, BLEND_FUNC_ZERO) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_DST_FUNC_ALPHA, BLEND_FUNC_ZERO) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_EQ_COLOR, BLEND_EQ_ADD) &
ETNA_MASKED(VIVS_PE_ALPHA_CONFIG_EQ_ALPHA, BLEND_EQ_ADD));
etna_set_state(ctx, VIVS_PE_ALPHA_BLEND_COLOR,
VIVS_PE_ALPHA_BLEND_COLOR_B(0) |
VIVS_PE_ALPHA_BLEND_COLOR_G(0) |
VIVS_PE_ALPHA_BLEND_COLOR_R(0) |
VIVS_PE_ALPHA_BLEND_COLOR_A(0));
etna_set_state(ctx, VIVS_PE_ALPHA_OP, ETNA_MASKED_BIT(VIVS_PE_ALPHA_OP_ALPHA_TEST, 0));
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_CULL_FACE_MODE, OFF));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 0));
etna_set_state(ctx, VIVS_PE_STENCIL_CONFIG, ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_REF_FRONT, 0) &
ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_MASK_FRONT, 0xff) &
ETNA_MASKED(VIVS_PE_STENCIL_CONFIG_WRITE_MASK, 0xff) &
ETNA_MASKED_INL(VIVS_PE_STENCIL_CONFIG_MODE, DISABLED));
etna_set_state(ctx, VIVS_PE_STENCIL_OP, ETNA_MASKED(VIVS_PE_STENCIL_OP_FUNC_FRONT, COMPARE_FUNC_ALWAYS) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FUNC_BACK, COMPARE_FUNC_ALWAYS) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FAIL_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_FAIL_BACK, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_DEPTH_FAIL_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_DEPTH_FAIL_BACK, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_PASS_FRONT, STENCIL_OP_KEEP) &
ETNA_MASKED(VIVS_PE_STENCIL_OP_PASS_BACK, STENCIL_OP_KEEP));
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT, ETNA_MASKED(VIVS_PE_COLOR_FORMAT_COMPONENTS, 0xf));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_EARLY_Z, 0));
etna_set_state(ctx, VIVS_SE_DEPTH_SCALE, 0x0);
etna_set_state(ctx, VIVS_SE_DEPTH_BIAS, 0x0);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_FILL_MODE, SOLID));
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_SHADE_MODEL, SMOOTH));
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT,
ETNA_MASKED(VIVS_PE_COLOR_FORMAT_FORMAT, RS_FORMAT_X8R8G8B8) &
ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_SUPER_TILED, supertiled));
etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4);
etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG,
ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, NONE) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_ENABLES, 0xf) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK12, 0x0) &
ETNA_MASKED(VIVS_GL_MULTI_SAMPLE_CONFIG_UNK16, 0x0)
);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT, ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_PARTIAL, 1));
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_TS_MEM_CONFIG, VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG,
ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_FORMAT, D16) &
ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_SUPER_TILED, supertiled)
);
etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address); /* ADDR_C */
etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_EARLY_Z, 0));
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address); /* ADDR_D */
etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address); /* ADDR_C */
etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_DEPTH_16BPP |
VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_EARLY_Z, 1)); /* flip-flopping once again */
/* Warm up RS on aux render target */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_stall(ctx, SYNC_RECIPIENT_RA, SYNC_RECIPIENT_PE);
/* Set up the resolve to clear tile status for main render target
* Regard the TS as an image of width 16 with 4 bytes per pixel (64 bytes per row)
* XXX need to clear the depth ts too.
* */
etna_set_state(ctx, VIVS_RS_CONFIG,
(RS_FORMAT_X8R8G8B8 << VIVS_RS_CONFIG_SOURCE_FORMAT__SHIFT) |
(RS_FORMAT_X8R8G8B8 << VIVS_RS_CONFIG_DEST_FORMAT__SHIFT)
);
etna_set_state_multi(ctx, VIVS_RS_DITHER(0), 2, (uint32_t[]) {
0xffffffff, 0xffffffff
});
etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
((rt_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
(16 << VIVS_RS_WINDOW_SIZE_WIDTH__SHIFT));
etna_set_state(ctx, VIVS_RS_FILL_VALUE(0), (bits_per_tile==4)?0x11111111:0x55555555);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL,
VIVS_RS_CLEAR_CONTROL_MODE_ENABLED1 |
(0xffff << VIVS_RS_CLEAR_CONTROL_BITS__SHIFT));
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG,
0); /* no AA, no endian switch */
etna_set_state(ctx, VIVS_RS_KICKER,
0xbeebbeeb);
/** Done */
etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_DEPTH_16BPP |
VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_INL(VIVS_PA_CONFIG_CULL_FACE_MODE, CCW));
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 0));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_MODE, NONE));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 0));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED(VIVS_PE_DEPTH_CONFIG_DEPTH_FUNC, COMPARE_FUNC_ALWAYS));
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_MODE, Z));
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NEAR, 0.0);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_FAR, 1.0);
etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
/* set up primitive assembly */
etna_set_state_f32(ctx, VIVS_PA_VIEWPORT_OFFSET_Z, 0.0);
etna_set_state_f32(ctx, VIVS_PA_VIEWPORT_SCALE_Z, 1.0);
etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_ONLY_DEPTH, 0));
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_OFFSET_X, width << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_OFFSET_Y, height << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_SCALE_X, width << 15);
etna_set_state_fixp(ctx, VIVS_PA_VIEWPORT_SCALE_Y, height << 15);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_LEFT, 0);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_TOP, 0);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_RIGHT, (width << 16) | 5);
etna_set_state_fixp(ctx, VIVS_SE_SCISSOR_BOTTOM, (height << 16) | 5);
/* shader setup */
etna_set_state(ctx, VIVS_VS_END_PC, vs_size/16);
etna_set_state_multi(ctx, VIVS_VS_INPUT_COUNT, 3, (uint32_t[]) {
/* VIVS_VS_INPUT_COUNT */ (1<<8) | 3,
/* VIVS_VS_TEMP_REGISTER_CONTROL */ 6 << VIVS_VS_TEMP_REGISTER_CONTROL_NUM_TEMPS__SHIFT,
/* VIVS_VS_OUTPUT(0) */ 4
});
etna_set_state(ctx, VIVS_VS_START_PC, 0x0);
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(45), 0.5); /* u11.y */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(44), 1.0); /* u11.x */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(27), 0.0); /* u6.w */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(23), 20.0); /* u5.w */
etna_set_state_f32(ctx, VIVS_VS_UNIFORMS(19), 2.0); /* u4.w */
/* Now load the shader itself */
etna_set_state_multi(ctx, VIVS_VS_INST_MEM(0), vs_size/4, vs);
etna_set_state(ctx, VIVS_RA_CONTROL, 0x1);
etna_set_state_multi(ctx, VIVS_PS_END_PC, 2, (uint32_t[]) {
/* VIVS_PS_END_PC */ ps_size/16,
/* VIVS_PS_OUTPUT_REG */ 0x1
});
etna_set_state(ctx, VIVS_PS_START_PC, 0x0);
etna_set_state(ctx, VIVS_PA_SHADER_ATTRIBUTES(0), 0x200);
etna_set_state(ctx, VIVS_GL_VARYING_NUM_COMPONENTS, /* one varying, with four components */
(4 << VIVS_GL_VARYING_NUM_COMPONENTS_VAR0__SHIFT)
);
etna_set_state_multi(ctx, VIVS_GL_VARYING_COMPONENT_USE(0), 2, (uint32_t[]) { /* one varying, with four components */
(VARYING_COMPONENT_USE_USED << VIVS_GL_VARYING_COMPONENT_USE_COMP0__SHIFT) |
(VARYING_COMPONENT_USE_USED << VIVS_GL_VARYING_COMPONENT_USE_COMP1__SHIFT) |
(VARYING_COMPONENT_USE_USED << VIVS_GL_VARYING_COMPONENT_USE_COMP2__SHIFT) |
(VARYING_COMPONENT_USE_USED << VIVS_GL_VARYING_COMPONENT_USE_COMP3__SHIFT)
, 0
});
etna_set_state_multi(ctx, VIVS_PS_INST_MEM(0), ps_size/4, ps);
etna_set_state(ctx, VIVS_PS_INPUT_COUNT, (31<<8)|2);
etna_set_state(ctx, VIVS_PS_TEMP_REGISTER_CONTROL,
(2 << VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS__SHIFT));
etna_set_state(ctx, VIVS_PS_CONTROL,
VIVS_PS_CONTROL_UNK1
);
etna_set_state(ctx, VIVS_PA_ATTRIBUTE_ELEMENT_COUNT, 0x100);
etna_set_state(ctx, VIVS_GL_VARYING_TOTAL_COMPONENTS, /* one varying, with four components */
VIVS_GL_VARYING_TOTAL_COMPONENTS_NUM(4)
);
etna_set_state(ctx, VIVS_VS_LOAD_BALANCING, 0xf3f0582);
etna_set_state(ctx, VIVS_VS_OUTPUT_COUNT, 2);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_POINT_SIZE_ENABLE, 0));
/* Compute transform matrices in the same way as cube egl demo */
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
esRotate(&modelview, frame*0.5f, 0.0f, 0.0f, 1.0f);
GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -2.8f, +2.8f, -2.8f * aspect, +2.8f * aspect, 6.0f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
ESMatrix inverse, normal; /* compute inverse transpose normal transformation matrix */
esMatrixInverse3x3(&inverse, &modelview);
esMatrixTranspose(&normal, &inverse);
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(0), 16, (uint32_t*)&modelviewprojection.m[0][0]);
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(16), 3, (uint32_t*)&normal.m[0][0]); /* u4.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(20), 3, (uint32_t*)&normal.m[1][0]); /* u5.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(24), 3, (uint32_t*)&normal.m[2][0]); /* u6.xyz */
etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(28), 16, (uint32_t*)&modelview.m[0][0]);
etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address); /* ADDR_E */
etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL,
0x24 << VIVS_FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE__SHIFT);
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
(0 << VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM__SHIFT) |
(3 <<VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
(0x0 << VIVS_FE_VERTEX_ELEMENT_CONFIG_START__SHIFT) |
(0xc << VIVS_FE_VERTEX_ELEMENT_CONFIG_END__SHIFT));
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(1),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
(0 << VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM__SHIFT) |
(3 <<VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
(0xc << VIVS_FE_VERTEX_ELEMENT_CONFIG_START__SHIFT) |
(0x18 << VIVS_FE_VERTEX_ELEMENT_CONFIG_END__SHIFT));
etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(2),
VIVS_FE_VERTEX_ELEMENT_CONFIG_TYPE_FLOAT |
(ENDIAN_MODE_NO_SWAP << VIVS_FE_VERTEX_ELEMENT_CONFIG_ENDIAN__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NONCONSECUTIVE |
(0 << VIVS_FE_VERTEX_ELEMENT_CONFIG_STREAM__SHIFT) |
(3 <<VIVS_FE_VERTEX_ELEMENT_CONFIG_NUM__SHIFT) |
VIVS_FE_VERTEX_ELEMENT_CONFIG_NORMALIZE_OFF |
(0x18 << VIVS_FE_VERTEX_ELEMENT_CONFIG_START__SHIFT) |
(0x24 << VIVS_FE_VERTEX_ELEMENT_CONFIG_END__SHIFT));
etna_set_state(ctx, VIVS_VS_INPUT(0), 0x20100);
etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_POINT_SPRITE_ENABLE, 0));
for(int prim=0; prim<6; ++prim)
{
etna_draw_primitives(ctx, PRIMITIVE_TYPE_TRIANGLE_STRIP, prim*4, 2);
}
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_flush(ctx);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_RS_CONFIG,
VIVS_RS_CONFIG_SOURCE_FORMAT(RS_FORMAT_X8R8G8B8) |
VIVS_RS_CONFIG_SOURCE_TILED |
VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_X8R8G8B8) |
VIVS_RS_CONFIG_DEST_TILED);
etna_set_state(ctx, VIVS_RS_SOURCE_STRIDE, (padded_width * 4 * 4) | (supertiled?VIVS_RS_SOURCE_STRIDE_TILING:0));
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, (padded_width * 4 * 4) | (supertiled?VIVS_RS_DEST_STRIDE_TILING:0));
etna_set_state(ctx, VIVS_RS_DITHER(0), 0xffffffff);
etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
/* Submit second command buffer */
etna_flush(ctx);
etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
VIVS_TS_MEM_CONFIG_DEPTH_16BPP |
VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
etna_set_state(ctx, VIVS_PE_COLOR_FORMAT,
ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_PARTIAL, 0));
/* Submit third command buffer, wait for pixel engine to finish */
etna_finish(ctx);
etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
etna_set_state(ctx, VIVS_RS_CONFIG,
VIVS_RS_CONFIG_SOURCE_FORMAT(RS_FORMAT_X8R8G8B8) |
VIVS_RS_CONFIG_SOURCE_TILED |
VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_X8R8G8B8) /*|
VIVS_RS_CONFIG_SWAP_RB*/);
etna_set_state(ctx, VIVS_RS_SOURCE_STRIDE, (padded_width * 4 * 4) | (supertiled?VIVS_RS_SOURCE_STRIDE_TILING:0));
etna_set_state(ctx, VIVS_RS_DEST_STRIDE, width * 4);
etna_set_state(ctx, VIVS_RS_DITHER(0), 0xffffffff);
etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address);
etna_set_state(ctx, VIVS_RS_DEST_ADDR, bmp->address);
etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
VIVS_RS_WINDOW_SIZE_HEIGHT(height) |
VIVS_RS_WINDOW_SIZE_WIDTH(width));
etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
etna_finish(ctx);
}
bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
printf("Dump complete\n");
/* Unlock video memory */
if(etna_vidmem_unlock(bmp) != 0)
{
fprintf(stderr, "Cannot unlock vidmem\n");
exit(1);
}
etna_free(ctx);
viv_close();
return 0;
}
int
main(int argc, char *argv[])
{
EGLDisplay display;
EGLint egl_major, egl_minor;
EGLConfig config;
EGLint num_config;
EGLContext context;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
const char *vertex_shader_source =
"uniform mat4 modelviewMatrix;\n"
"uniform mat4 modelviewprojectionMatrix;\n"
"uniform mat3 normalMatrix;\n"
"\n"
"attribute vec4 in_position; \n"
"attribute vec3 in_normal; \n"
"attribute vec4 in_color; \n"
"\n"
"vec4 lightSource = vec4(2.0, 2.0, 20.0, 0.0);\n"
" \n"
"varying vec4 vVaryingColor; \n"
" \n"
"void main() \n"
"{ \n"
" gl_Position = modelviewprojectionMatrix * in_position;\n"
" vec3 vEyeNormal = normalMatrix * in_normal;\n"
" vec4 vPosition4 = modelviewMatrix * in_position;\n"
" vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
" vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
" float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
" vVaryingColor = vec4(diff * in_color.rgb, 1.0);\n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"varying vec4 vVaryingColor; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = vVaryingColor; \n"
"} \n";
GLfloat vVertices[] = {
// front
-1.0f, -1.0f, +1.0f, // point blue
+1.0f, -1.0f, +1.0f, // point magenta
-1.0f, +1.0f, +1.0f, // point cyan
+1.0f, +1.0f, +1.0f, // point white
// back
+1.0f, -1.0f, -1.0f, // point red
-1.0f, -1.0f, -1.0f, // point black
+1.0f, +1.0f, -1.0f, // point yellow
-1.0f, +1.0f, -1.0f, // point green
// right
+1.0f, -1.0f, +1.0f, // point magenta
+1.0f, -1.0f, -1.0f, // point red
+1.0f, +1.0f, +1.0f, // point white
+1.0f, +1.0f, -1.0f, // point yellow
// left
-1.0f, -1.0f, -1.0f, // point black
-1.0f, -1.0f, +1.0f, // point blue
-1.0f, +1.0f, -1.0f, // point green
-1.0f, +1.0f, +1.0f, // point cyan
// top
-1.0f, +1.0f, +1.0f, // point cyan
+1.0f, +1.0f, +1.0f, // point white
-1.0f, +1.0f, -1.0f, // point green
+1.0f, +1.0f, -1.0f, // point yellow
// bottom
-1.0f, -1.0f, -1.0f, // point black
+1.0f, -1.0f, -1.0f, // point red
-1.0f, -1.0f, +1.0f, // point blue
+1.0f, -1.0f, +1.0f // point magenta
};
GLfloat vColors[] = {
// front
0.0f, 0.0f, 1.0f, // blue
1.0f, 0.0f, 1.0f, // magenta
0.0f, 1.0f, 1.0f, // cyan
1.0f, 1.0f, 1.0f, // white
// back
1.0f, 0.0f, 0.0f, // red
0.0f, 0.0f, 0.0f, // black
1.0f, 1.0f, 0.0f, // yellow
0.0f, 1.0f, 0.0f, // green
// right
1.0f, 0.0f, 1.0f, // magenta
1.0f, 0.0f, 0.0f, // red
1.0f, 1.0f, 1.0f, // white
1.0f, 1.0f, 0.0f, // yellow
// left
0.0f, 0.0f, 0.0f, // black
0.0f, 0.0f, 1.0f, // blue
0.0f, 1.0f, 0.0f, // green
0.0f, 1.0f, 1.0f, // cyan
// top
0.0f, 1.0f, 1.0f, // cyan
1.0f, 1.0f, 1.0f, // white
0.0f, 1.0f, 0.0f, // green
1.0f, 1.0f, 0.0f, // yellow
// bottom
0.0f, 0.0f, 0.0f, // black
1.0f, 0.0f, 0.0f, // red
0.0f, 0.0f, 1.0f, // blue
1.0f, 0.0f, 1.0f // magenta
};
GLfloat vNormals[] = {
// front
+0.0f, +0.0f, +1.0f, // forward
+0.0f, +0.0f, +1.0f, // forward
+0.0f, +0.0f, +1.0f, // forward
+0.0f, +0.0f, +1.0f, // forward
// back
+0.0f, +0.0f, -1.0f, // backbard
+0.0f, +0.0f, -1.0f, // backbard
+0.0f, +0.0f, -1.0f, // backbard
+0.0f, +0.0f, -1.0f, // backbard
// right
+1.0f, +0.0f, +0.0f, // right
+1.0f, +0.0f, +0.0f, // right
+1.0f, +0.0f, +0.0f, // right
+1.0f, +0.0f, +0.0f, // right
// left
-1.0f, +0.0f, +0.0f, // left
-1.0f, +0.0f, +0.0f, // left
-1.0f, +0.0f, +0.0f, // left
-1.0f, +0.0f, +0.0f, // left
// top
+0.0f, +1.0f, +0.0f, // up
+0.0f, +1.0f, +0.0f, // up
+0.0f, +1.0f, +0.0f, // up
+0.0f, +1.0f, +0.0f, // up
// bottom
+0.0f, -1.0f, +0.0f, // down
+0.0f, -1.0f, +0.0f, // down
+0.0f, -1.0f, +0.0f, // down
+0.0f, -1.0f, +0.0f // down
};
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (display == EGL_NO_DISPLAY) {
printf("Error: No display found!\n");
return -1;
}
if (!eglInitialize(display, &egl_major, &egl_minor)) {
printf("Error: eglInitialise failed!\n");
return -1;
}
printf("Using display %p with EGL version %d.%d\n",
display, egl_major, egl_minor);
printf("EGL Version \"%s\"\n", eglQueryString(display, EGL_VERSION));
printf("EGL Vendor \"%s\"\n", eglQueryString(display, EGL_VENDOR));
printf("EGL Extensions \"%s\"\n", eglQueryString(display, EGL_EXTENSIONS));
/* get an appropriate EGL frame buffer configuration */
eglChooseConfig(display, config_attribute_list, &config, 1, &num_config);
/* create an EGL rendering context */
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list);
if (context == EGL_NO_CONTEXT) {
printf("Error: eglCreateContext failed: %d\n", eglGetError());
return -1;
}
surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list);
if (surface == EGL_NO_SURFACE) {
printf("Error: eglCreatePbufferSurface failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
if (!eglQuerySurface(display, surface, EGL_WIDTH, &width) ||
!eglQuerySurface(display, surface, EGL_HEIGHT, &height)) {
printf("Error: eglQuerySurface failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
printf("PBuffer: %dx%d\n", width, height);
/* connect the context to the surface */
if (!eglMakeCurrent(display, surface, surface, context)) {
printf("Error: eglMakeCurrent() failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
if (!vertex_shader) {
printf("Error: glCreateShader(GL_VERTEX_SHADER) failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: vertex shader compilation failed!:\n");
glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetShaderInfoLog(vertex_shader, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("Vertex shader compilation succeeded!\n");
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
if (!fragment_shader) {
printf("Error: glCreateShader(GL_FRAGMENT_SHADER) failed: %d (%s)\n",
eglGetError(), eglStrError(eglGetError()));
return -1;
}
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: fragment shader compilation failed!:\n");
glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetShaderInfoLog(fragment_shader, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("Fragment shader compilation succeeded!\n");
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "in_position");
glBindAttribLocation(program, 1, "in_normal");
glBindAttribLocation(program, 2, "in_color");
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &ret);
if (!ret) {
char *log;
printf("Error: program linking failed!:\n");
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret);
if (ret > 1) {
log = malloc(ret);
glGetProgramInfoLog(program, ret, NULL, log);
printf("%s", log);
}
return -1;
} else
printf("program linking succeeded!\n");
glUseProgram(program);
glViewport(0, 0, width, height);
/* clear the color buffer */
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals);
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, vColors);
glEnableVertexAttribArray(2);
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f);
GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -2.8f, +2.8f, -2.8f * aspect, +2.8f * aspect, 6.0f, 10.0f);
ESMatrix modelviewprojection;
esMatrixLoadIdentity(&modelviewprojection);
esMatrixMultiply(&modelviewprojection, &modelview, &projection);
float normal[9];
normal[0] = modelview.m[0][0];
normal[1] = modelview.m[0][1];
normal[2] = modelview.m[0][2];
normal[3] = modelview.m[1][0];
normal[4] = modelview.m[1][1];
normal[5] = modelview.m[1][2];
normal[6] = modelview.m[2][0];
normal[7] = modelview.m[2][1];
normal[8] = modelview.m[2][2];
GLint modelviewmatrix_handle = glGetUniformLocation(program, "modelviewMatrix");
GLint modelviewprojectionmatrix_handle = glGetUniformLocation(program, "modelviewprojectionMatrix");
GLint normalmatrix_handle = glGetUniformLocation(program, "normalMatrix");
glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]);
glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]);
glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal);
glEnable(GL_CULL_FACE);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 8, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 12, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 16, 4);
glDrawArrays(GL_TRIANGLE_STRIP, 20, 4);
glFlush();
usleep(1000000);
fflush(stdout);
return 0;
}
SceneManager::SceneManager(){
esMatrixLoadIdentity( &mvMatrix );
esMatrixLoadIdentity( &mvpMatrix );
esMatrixLoadIdentity( &perspectiveMatrix );
angle = 0.0f;
}
void screen_model (ESContext *esContext) {
#ifndef SDLGL
ESMatrix modelview;
UserData *userData = esContext->userData;
#endif
draw_title(esContext, "Model");
char tmp_str[100];
int n = 0;
#ifndef SDLGL
esMatrixLoadIdentity(&modelview);
esMatrixMultiply(&userData->mvpMatrix, &modelview, &userData->perspective);
esMatrixMultiply(&userData->mvpMatrix2, &modelview, &userData->perspective);
#endif
if (clientmode == 1) {
draw_text_button(esContext, "clientmode", VIEW_MODE_MODEL, "Client-Mode / No Config", FONT_PINK, 0.0, 0.0, 0.002, 0.1, ALIGN_CENTER, ALIGN_TOP, model_null, (float)n);
return;
}
if (select_teletype == 1) {
for (n = 0; n < TELETYPE_LAST; n++) {
draw_text_button(esContext, teletypes[n], VIEW_MODE_MODEL, teletypes[n], FONT_WHITE, -1.25, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_teletype_set, (float)n);
}
return;
}
draw_text_button(esContext, "Model", VIEW_MODE_MODEL, "Model", FONT_WHITE, -1.25, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_null, (float)n);
draw_line_f3(esContext, -1.3, -0.8 + n * 0.12 + 0.1, 0.002, 1.25, -0.8 + n * 0.12 + 0.1, 0.002, 255, 255, 0, 128);
n++;
draw_text_button(esContext, "model_load", VIEW_MODE_MODEL, "[LOAD]", FONT_WHITE, 1.1, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_RIGHT, ALIGN_TOP, model_load, 0);
draw_text_button(esContext, "model_load2", VIEW_MODE_MODEL, "NAME:", FONT_WHITE, -1.1, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_name_edit, 0);
if (ModelData[ModelActive].name[0] == 0) {
strcpy(ModelData[ModelActive].name, "model1");
}
sprintf(tmp_str, "%s", ModelData[ModelActive].name);
draw_text_button(esContext, "model_name_edit", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_name_edit, 0);
n++;
draw_text_button(esContext, "model_type", VIEW_MODE_MODEL, "TYPE:", FONT_WHITE, -1.1, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_dronetype_change, 0);
if (ModelData[ModelActive].dronetype > 26) {
sprintf(tmp_str, "UNKNOWN: %i", ModelData[ModelActive].dronetype);
draw_text_button(esContext, "dronetype_change", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_dronetype_change, 0);
} else {
draw_text_button(esContext, "dronetype_change", VIEW_MODE_MODEL, dronetypes[ModelData[ModelActive].dronetype], FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_dronetype_change, 0);
}
#ifdef SDLGL
// get_background_model(ModelActive, tmp_str);
if (ModelData[ModelActive].dronetype > 26) {
sprintf(tmp_str, "%s/obj3d/_.obj", BASE_DIR);
} else {
sprintf(tmp_str, "%s/obj3d/%s.obj", BASE_DIR, dronetypes[ModelData[ModelActive].dronetype]);
}
if (file_exists(tmp_str) != 0) {
static uint8_t startup = 0;
static float rotate = 0.0;
rotate += 0.5;
if (startup == 0 || strcmp(obj3d_dronetype.name, tmp_str) != 0) {
startup = 1;
if (obj3d_dronetype.faces_num != 0) {
object3d_free(&obj3d_dronetype);
}
object3d_load(&obj3d_dronetype, tmp_str);
}
glPushMatrix();
glTranslatef(0.5, (-0.8 + n * 0.12 + 0.2) * -1.0, -2.0);
if (ModelData[ModelActive].heartbeat == 0) {
glRotatef(rotate, 0.2, 1.0, 0.3);
} else {
glRotatef(-90.0, 1.0, 0.0, 0.0);
// glRotatef(ModelData[ModelActive].yaw, 0.0, 0.0, -1.0);
glRotatef(ModelData[ModelActive].pitch, 1.0, 0.0, 0.0);
glRotatef(ModelData[ModelActive].roll, 0.0, 1.0, 0.0);
}
glScalef(0.25, 0.25, 0.25);
object3d_draw(&obj3d_dronetype, 255, 255, 255, 100);
glPopMatrix();
} else {
sprintf(tmp_str, "%s/textures/%s.png", BASE_DIR, dronetypes[ModelData[ModelActive].dronetype]);
draw_image_f3(esContext, -1.1 + 1.0, -0.8 + n * 0.12 - 0.02, -1.1 + 1.0 + 0.1, -0.8 + n * 0.12 + 0.1 - 0.02, 0.002, tmp_str);
}
#else
sprintf(tmp_str, "%s/textures/%s.png", BASE_DIR, dronetypes[ModelData[ModelActive].dronetype]);
draw_image_f3(esContext, -1.1 + 1.0, -0.8 + n * 0.12 - 0.02, -1.1 + 1.0 + 0.1, -0.8 + n * 0.12 + 0.1 - 0.02, 0.002, tmp_str);
#endif
n++;
draw_text_button(esContext, "model_image_change", VIEW_MODE_MODEL, "IMAGE:", FONT_WHITE, -1.1, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_image_change, 0);
draw_image_f3(esContext, -1.1 + 0.3, -0.8 + n * 0.12 - 0.02, -1.2 + 0.3 + 0.4, -0.8 + n * 0.12 + 0.3 - 0.02, 0.002, ModelData[ModelActive].image);
n++;
n++;
draw_text_button(esContext, "Telemetry", VIEW_MODE_MODEL, "Telemetry", FONT_WHITE, -1.25, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_null, (float)n);
draw_line_f3(esContext, -1.3, -0.8 + n * 0.12 + 0.1, 0.002, 1.25, -0.8 + n * 0.12 + 0.1, 0.002, 255, 255, 0, 128);
n++;
draw_text_button(esContext, "model_load3", VIEW_MODE_MODEL, "TYPE:", FONT_WHITE, -1.1, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_teletype_change, 0);
draw_text_button(esContext, "model_teletype_change", VIEW_MODE_MODEL, teletypes[ModelData[ModelActive].teletype], FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_teletype_change, 0);
n++;
#ifdef SDLGL
if (ModelData[ModelActive].pilottype == MAV_AUTOPILOT_PIXHAWK) {
sprintf(tmp_str, "%s/obj3d/%s.obj", BASE_DIR, "PIXHAWK");
} else {
sprintf(tmp_str, "%s/obj3d/%s.obj", BASE_DIR, teletypes[ModelData[ModelActive].teletype]);
}
if (file_exists(tmp_str) != 0) {
static uint8_t startup = 0;
static float rotate = 0.0;
rotate += 0.4;
if (startup == 0 || strcmp(obj3d_teletype.name, tmp_str) != 0) {
startup = 1;
if (obj3d_teletype.faces_num != 0) {
object3d_free(&obj3d_teletype);
}
object3d_load(&obj3d_teletype, tmp_str);
}
glTranslatef(0.5, -0.15, -2.0);
glRotatef(rotate, -1.0, -1.0, 0.2);
glScalef(0.25, 0.25, 0.25);
object3d_draw(&obj3d_teletype, 255, 255, 255, 100);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
#endif
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "DEVICE:");
if (ModelData[ModelActive].telemetry_port[0] == 0) {
// strcpy(ModelData[ModelActive].telemetry_port, "/dev/rfcomm0");
}
sprintf(tmp_str, "%s [SELECT]", ModelData[ModelActive].telemetry_port);
draw_text_button(esContext, "device_select", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_device_change, 0);
n++;
if (strcmp(ModelData[ModelActive].telemetry_port, "TCP") == 0) {
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "IP:");
sprintf(tmp_str, "%s [CHANGE]", ModelData[ModelActive].netip);
draw_text_button(esContext, "model_ip_edit", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_ip_edit, n);
n++;
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "PORT:");
sprintf(tmp_str, "%i [CHANGE]", ModelData[ModelActive].netport);
draw_text_button(esContext, "model_port_edit", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_port_edit, n);
n++;
} else if (strcmp(ModelData[ModelActive].telemetry_port, "UDP") == 0) {
if (ModelData[ModelActive].teletype == TELETYPE_ARDUPILOT) {
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "USEID:");
sprintf(tmp_str, "%i [CHANGE]", ModelData[ModelActive].use_deviceid);
if (ModelData[ModelActive].use_deviceid == 1) {
draw_text_button(esContext, "rc_useid", VIEW_MODE_MODEL, tmp_str, FONT_GREEN, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_use_deviceid_change, n);
n++;
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "SysID:");
sprintf(tmp_str, "%i [CHANGE]", ModelData[ModelActive].mavlink_sysid);
draw_text_button(esContext, "rc_mavlink_sysid", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_mavlink_sysid_change, n);
} else {
draw_text_button(esContext, "rc_useid", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_use_deviceid_change, n);
}
}
n++;
} else {
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "BAUD:");
sprintf(tmp_str, "%i [CHANGE]", ModelData[ModelActive].telemetry_baud);
draw_text_button(esContext, "rc_baud", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_baud_change, n);
n++;
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "USEID:");
sprintf(tmp_str, "%i [CHANGE]", ModelData[ModelActive].use_deviceid);
if (ModelData[ModelActive].use_deviceid == 1) {
draw_text_button(esContext, "rc_useid", VIEW_MODE_MODEL, tmp_str, FONT_GREEN, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_use_deviceid_change, n);
n++;
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "ID:");
draw_text_button(esContext, "rc_deviceid", VIEW_MODE_MODEL, ModelData[ModelActive].deviceid, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_null, n);
} else {
draw_text_button(esContext, "rc_useid", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_use_deviceid_change, n);
}
n++;
}
draw_text_f3(esContext, -1.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "FORWARD:");
if (ModelData[ModelActive].mavlink_forward == 0) {
sprintf(tmp_str, "NO [CHANGE]");
} else if (ModelData[ModelActive].mavlink_forward == 1) {
sprintf(tmp_str, "READ/WRITE [CHANGE]");
} else if (ModelData[ModelActive].mavlink_forward == 2) {
sprintf(tmp_str, "WRITE PROTECT [CHANGE]");
}
draw_text_button(esContext, "mavlink_forward_change", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.3, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_mavlink_forward_change, n);
n++;
if (strstr(ModelData[ModelActive].telemetry_port, "rfcomm") > 0) {
n++;
draw_text_f3(esContext, -1.1 + 0.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "BLUETOOTH_DEVICE:");
if (ModelData[ModelActive].telebtaddr[0] == 0) {
strcpy(ModelData[ModelActive].telebtaddr, "00:00:00:00:00:00");
}
sprintf(tmp_str, "%s [RESCAN]", ModelData[ModelActive].telebtaddr);
draw_text_button(esContext, "bt_scan", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.8, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_null, n);
n++;
draw_text_f3(esContext, -1.1 + 0.1, -0.8 + n * 0.12, 0.002, 0.06, 0.06, FONT_WHITE, "BLUETOOTH_PIN:");
if (ModelData[ModelActive].telebtpin[0] == 0) {
strcpy(ModelData[ModelActive].telebtpin, "1234");
}
sprintf(tmp_str, "%s [CHANGE]", ModelData[ModelActive].telebtpin);
draw_text_button(esContext, "bt_pin", VIEW_MODE_MODEL, tmp_str, FONT_WHITE, -1.1 + 0.8, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_LEFT, ALIGN_TOP, model_null, n);
} else {
n++;
n++;
}
n = 13;
draw_text_button(esContext, "model_reconnect", VIEW_MODE_MODEL, "[RECONNECT]", FONT_WHITE, 0.0, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, model_reconnect, n);
n++;
draw_text_button(esContext, "model_save", VIEW_MODE_MODEL, "[SAVE]", FONT_WHITE, 0.0, -0.8 + n * 0.12, 0.002, 0.06, ALIGN_CENTER, ALIGN_TOP, model_save, n);
screen_keyboard(esContext);
screen_filesystem(esContext);
screen_device(esContext);
screen_baud(esContext);
}