| 1 |
/* |
| 2 |
* Copyright 2013 The Android Open Source Project |
| 3 |
* |
| 4 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 |
* you may not use this file except in compliance with the License. |
| 6 |
* You may obtain a copy of the License at |
| 7 |
* |
| 8 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 9 |
* |
| 10 |
* Unless required by applicable law or agreed to in writing, software |
| 11 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 12 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 |
* See the License for the specific language governing permissions and |
| 14 |
* limitations under the License. |
| 15 |
*/ |
| 16 |
|
| 17 |
//-------------------------------------------------------------------------------- |
| 18 |
// MoreTeapotsRenderer.cpp |
| 19 |
// Render teapots |
| 20 |
//-------------------------------------------------------------------------------- |
| 21 |
//-------------------------------------------------------------------------------- |
| 22 |
// Include files |
| 23 |
//-------------------------------------------------------------------------------- |
| 24 |
#include "MoreTeapotsRenderer.h" |
| 25 |
|
| 26 |
//-------------------------------------------------------------------------------- |
| 27 |
// Teapot model data |
| 28 |
//-------------------------------------------------------------------------------- |
| 29 |
#include "teapot.inl" |
| 30 |
|
| 31 |
//-------------------------------------------------------------------------------- |
| 32 |
// Ctor |
| 33 |
//-------------------------------------------------------------------------------- |
| 34 |
MoreTeapotsRenderer::MoreTeapotsRenderer() : |
| 35 |
geometry_instancing_support_( false ) |
| 36 |
{ |
| 37 |
|
| 38 |
} |
| 39 |
|
| 40 |
//-------------------------------------------------------------------------------- |
| 41 |
// Dtor |
| 42 |
//-------------------------------------------------------------------------------- |
| 43 |
MoreTeapotsRenderer::~MoreTeapotsRenderer() |
| 44 |
{ |
| 45 |
Unload(); |
| 46 |
} |
| 47 |
|
| 48 |
//-------------------------------------------------------------------------------- |
| 49 |
// Init |
| 50 |
//-------------------------------------------------------------------------------- |
| 51 |
void MoreTeapotsRenderer::Init( const int32_t numX, |
| 52 |
const int32_t numY, |
| 53 |
const int32_t numZ ) |
| 54 |
{ |
| 55 |
if( ndk_helper::GLContext::GetInstance()->GetGLVersion() >= 3.0 ) |
| 56 |
{ |
| 57 |
geometry_instancing_support_ = true; |
| 58 |
} |
| 59 |
else if( ndk_helper::GLContext::GetInstance()->CheckExtension( "GL_NV_draw_instanced" ) |
| 60 |
&& ndk_helper::GLContext::GetInstance()->CheckExtension( |
| 61 |
"GL_NV_uniform_buffer_object" ) ) |
| 62 |
{ |
| 63 |
LOGI( "Supported via extension!" ); |
| 64 |
//_bGeometryInstancingSupport = true; |
| 65 |
//_bARBSupport = true; //Need to patch shaders |
| 66 |
//Currently this has been disabled |
| 67 |
} |
| 68 |
|
| 69 |
//Settings |
| 70 |
glFrontFace( GL_CCW ); |
| 71 |
|
| 72 |
//Create Index buffer |
| 73 |
num_indices_ = sizeof(teapotIndices) / sizeof(teapotIndices[0]); |
| 74 |
glGenBuffers( 1, &ibo_ ); |
| 75 |
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ibo_ ); |
| 76 |
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(teapotIndices), teapotIndices, GL_STATIC_DRAW ); |
| 77 |
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); |
| 78 |
|
| 79 |
//Create VBO |
| 80 |
num_vertices_ = sizeof(teapotPositions) / sizeof(teapotPositions[0]) / 3; |
| 81 |
int32_t iStride = sizeof(TEAPOT_VERTEX); |
| 82 |
int32_t iIndex = 0; |
| 83 |
TEAPOT_VERTEX* p = new TEAPOT_VERTEX[num_vertices_]; |
| 84 |
for( int32_t i = 0; i < num_vertices_; ++i ) |
| 85 |
{ |
| 86 |
p[i].pos[0] = teapotPositions[iIndex]; |
| 87 |
p[i].pos[1] = teapotPositions[iIndex + 1]; |
| 88 |
p[i].pos[2] = teapotPositions[iIndex + 2]; |
| 89 |
|
| 90 |
p[i].normal[0] = teapotNormals[iIndex]; |
| 91 |
p[i].normal[1] = teapotNormals[iIndex + 1]; |
| 92 |
p[i].normal[2] = teapotNormals[iIndex + 2]; |
| 93 |
iIndex += 3; |
| 94 |
} |
| 95 |
glGenBuffers( 1, &vbo_ ); |
| 96 |
glBindBuffer( GL_ARRAY_BUFFER, vbo_ ); |
| 97 |
glBufferData( GL_ARRAY_BUFFER, iStride * num_vertices_, p, GL_STATIC_DRAW ); |
| 98 |
glBindBuffer( GL_ARRAY_BUFFER, 0 ); |
| 99 |
delete[] p; |
| 100 |
|
| 101 |
//Init Projection matrices |
| 102 |
teapot_x_ = numX; |
| 103 |
teapot_y_ = numY; |
| 104 |
teapot_z_ = numZ; |
| 105 |
vec_mat_models_.reserve( teapot_x_ * teapot_y_ * teapot_z_ ); |
| 106 |
|
| 107 |
UpdateViewport(); |
| 108 |
|
| 109 |
const float total_width = 500.f; |
| 110 |
float gap_x = total_width / (teapot_x_ - 1); |
| 111 |
float gap_y = total_width / (teapot_y_ - 1); |
| 112 |
float gap_z = total_width / (teapot_z_ - 1); |
| 113 |
float offset_x = -total_width / 2.f; |
| 114 |
float offset_y = -total_width / 2.f; |
| 115 |
float offset_z = -total_width / 2.f; |
| 116 |
|
| 117 |
for( int32_t iX = 0; iX < teapot_x_; ++iX ) |
| 118 |
for( int32_t iY = 0; iY < teapot_y_; ++iY ) |
| 119 |
for( int32_t iZ = 0; iZ < teapot_z_; ++iZ ) |
| 120 |
{ |
| 121 |
vec_mat_models_.push_back( |
| 122 |
ndk_helper::Mat4::Translation( iX * gap_x + offset_x, iY * gap_y + offset_y, |
| 123 |
iZ * gap_z + offset_z ) ); |
| 124 |
vec_colors_.push_back( |
| 125 |
ndk_helper::Vec3( random() / float( RAND_MAX * 1.1 ), |
| 126 |
random() / float( RAND_MAX * 1.1 ), |
| 127 |
random() / float( RAND_MAX * 1.1 ) ) ); |
| 128 |
|
| 129 |
float fX = random() / float( RAND_MAX ) - 0.5f; |
| 130 |
float fY = random() / float( RAND_MAX ) - 0.5f; |
| 131 |
vec_rotations_.push_back( ndk_helper::Vec2( fX * 0.05f, fY * 0.05f ) ); |
| 132 |
vec_current_rotations_.push_back( ndk_helper::Vec2( fX * M_PI, fY * M_PI ) ); |
| 133 |
} |
| 134 |
|
| 135 |
if( geometry_instancing_support_ ) |
| 136 |
{ |
| 137 |
// |
| 138 |
//Create parameter dictionary for shader patch |
| 139 |
std::map<std::string, std::string> param; |
| 140 |
param[std::string( "%NUM_TEAPOT%" )] = ToString( teapot_x_ * teapot_y_ * teapot_z_ ); |
| 141 |
param[std::string( "%LOCATION_VERTEX%" )] = ToString( ATTRIB_VERTEX ); |
| 142 |
param[std::string( "%LOCATION_NORMAL%" )] = ToString( ATTRIB_NORMAL ); |
| 143 |
if( arb_support_ ) |
| 144 |
param[std::string( "%ARB%" )] = std::string( "ARB" ); |
| 145 |
else |
| 146 |
param[std::string( "%ARB%" )] = std::string( "" ); |
| 147 |
|
| 148 |
//Load shader |
| 149 |
bool b = LoadShadersES3( &shader_param_, "Shaders/VS_ShaderPlainES3.vsh", |
| 150 |
"Shaders/ShaderPlainES3.fsh", param ); |
| 151 |
if( b ) |
| 152 |
{ |
| 153 |
// |
| 154 |
//Create uniform buffer |
| 155 |
// |
| 156 |
GLuint bindingPoint = 1; |
| 157 |
GLuint blockIndex; |
| 158 |
blockIndex = glGetUniformBlockIndex( shader_param_.program_, "ParamBlock" ); |
| 159 |
glUniformBlockBinding( shader_param_.program_, blockIndex, bindingPoint ); |
| 160 |
|
| 161 |
//Retrieve array stride value |
| 162 |
int32_t iNumIndices; |
| 163 |
glGetActiveUniformBlockiv( shader_param_.program_, blockIndex, |
| 164 |
GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &iNumIndices ); |
| 165 |
GLint i[iNumIndices]; |
| 166 |
GLint stride[iNumIndices]; |
| 167 |
glGetActiveUniformBlockiv( shader_param_.program_, blockIndex, |
| 168 |
GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, i ); |
| 169 |
glGetActiveUniformsiv( shader_param_.program_, iNumIndices, (GLuint*) i, |
| 170 |
GL_UNIFORM_ARRAY_STRIDE, stride ); |
| 171 |
|
| 172 |
ubo_matrix_stride_ = stride[0] / sizeof(float); |
| 173 |
ubo_vector_stride_ = stride[2] / sizeof(float); |
| 174 |
|
| 175 |
glGenBuffers( 1, &ubo_ ); |
| 176 |
glBindBuffer( GL_UNIFORM_BUFFER, ubo_ ); |
| 177 |
glBindBufferBase( GL_UNIFORM_BUFFER, bindingPoint, ubo_ ); |
| 178 |
|
| 179 |
//Store color value which wouldn't be updated every frame |
| 180 |
int32_t iSize = teapot_x_ * teapot_y_ * teapot_z_ |
| 181 |
* (ubo_matrix_stride_ + ubo_matrix_stride_ + ubo_vector_stride_); //Mat4 + Mat4 + Vec3 + 1 stride |
| 182 |
float* pBuffer = new float[iSize]; |
| 183 |
float* pColor = pBuffer + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_ * 2; |
| 184 |
for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i ) |
| 185 |
{ |
| 186 |
memcpy( pColor, &vec_colors_[i], 3 * sizeof(float) ); |
| 187 |
pColor += ubo_vector_stride_; //Assuming std140 layout which is 4 DWORD stride for vectors |
| 188 |
} |
| 189 |
|
| 190 |
glBufferData( GL_UNIFORM_BUFFER, iSize * sizeof(float), pBuffer, GL_DYNAMIC_DRAW ); |
| 191 |
delete[] pBuffer; |
| 192 |
} |
| 193 |
else |
| 194 |
{ |
| 195 |
LOGI( "Shader compilation failed!! Falls back to ES2.0 pass" ); |
| 196 |
//This happens some devices. |
| 197 |
geometry_instancing_support_ = false; |
| 198 |
//Load shader for GLES2.0 |
| 199 |
LoadShaders( &shader_param_, "Shaders/VS_ShaderPlain.vsh", "Shaders/ShaderPlain.fsh" ); |
| 200 |
} |
| 201 |
} |
| 202 |
else |
| 203 |
{ |
| 204 |
//Load shader for GLES2.0 |
| 205 |
LoadShaders( &shader_param_, "Shaders/VS_ShaderPlain.vsh", "Shaders/ShaderPlain.fsh" ); |
| 206 |
} |
| 207 |
} |
| 208 |
|
| 209 |
void MoreTeapotsRenderer::UpdateViewport() |
| 210 |
{ |
| 211 |
int32_t viewport[4]; |
| 212 |
glGetIntegerv( GL_VIEWPORT, viewport ); |
| 213 |
float fAspect = (float) viewport[2] / (float) viewport[3]; |
| 214 |
|
| 215 |
const float CAM_NEAR = 5.f; |
| 216 |
const float CAM_FAR = 10000.f; |
| 217 |
bool bRotate = false; |
| 218 |
mat_projection_ = ndk_helper::Mat4::Perspective( fAspect, 1.f, CAM_NEAR, CAM_FAR ); |
| 219 |
} |
| 220 |
|
| 221 |
//-------------------------------------------------------------------------------- |
| 222 |
// Unload |
| 223 |
//-------------------------------------------------------------------------------- |
| 224 |
void MoreTeapotsRenderer::Unload() |
| 225 |
{ |
| 226 |
if( vbo_ ) |
| 227 |
{ |
| 228 |
glDeleteBuffers( 1, &vbo_ ); |
| 229 |
vbo_ = 0; |
| 230 |
} |
| 231 |
if( ubo_ ) |
| 232 |
{ |
| 233 |
glDeleteBuffers( 1, &ubo_ ); |
| 234 |
ubo_ = 0; |
| 235 |
} |
| 236 |
if( ibo_ ) |
| 237 |
{ |
| 238 |
glDeleteBuffers( 1, &ibo_ ); |
| 239 |
ibo_ = 0; |
| 240 |
} |
| 241 |
if( shader_param_.program_ ) |
| 242 |
{ |
| 243 |
glDeleteProgram( shader_param_.program_ ); |
| 244 |
shader_param_.program_ = 0; |
| 245 |
} |
| 246 |
} |
| 247 |
|
| 248 |
//-------------------------------------------------------------------------------- |
| 249 |
// Update |
| 250 |
//-------------------------------------------------------------------------------- |
| 251 |
void MoreTeapotsRenderer::Update( float fTime ) |
| 252 |
{ |
| 253 |
const float CAM_X = 0.f; |
| 254 |
const float CAM_Y = 0.f; |
| 255 |
const float CAM_Z = 2000.f; |
| 256 |
|
| 257 |
mat_view_ = ndk_helper::Mat4::LookAt( ndk_helper::Vec3( CAM_X, CAM_Y, CAM_Z ), |
| 258 |
ndk_helper::Vec3( 0.f, 0.f, 0.f ), ndk_helper::Vec3( 0.f, 1.f, 0.f ) ); |
| 259 |
|
| 260 |
if( camera_ ) |
| 261 |
{ |
| 262 |
camera_->Update(); |
| 263 |
mat_view_ = camera_->GetTransformMatrix() * mat_view_ * camera_->GetRotationMatrix(); |
| 264 |
} |
| 265 |
} |
| 266 |
|
| 267 |
//-------------------------------------------------------------------------------- |
| 268 |
// Render |
| 269 |
//-------------------------------------------------------------------------------- |
| 270 |
void MoreTeapotsRenderer::Render() |
| 271 |
{ |
| 272 |
// Bind the VBO |
| 273 |
glBindBuffer( GL_ARRAY_BUFFER, vbo_ ); |
| 274 |
|
| 275 |
int32_t iStride = sizeof(TEAPOT_VERTEX); |
| 276 |
// Pass the vertex data |
| 277 |
glVertexAttribPointer( ATTRIB_VERTEX, 3, GL_FLOAT, GL_FALSE, iStride, BUFFER_OFFSET( 0 ) ); |
| 278 |
glEnableVertexAttribArray( ATTRIB_VERTEX ); |
| 279 |
|
| 280 |
glVertexAttribPointer( ATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, iStride, |
| 281 |
BUFFER_OFFSET( 3 * sizeof(GLfloat) ) ); |
| 282 |
glEnableVertexAttribArray( ATTRIB_NORMAL ); |
| 283 |
|
| 284 |
// Bind the IB |
| 285 |
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ibo_ ); |
| 286 |
|
| 287 |
glUseProgram( shader_param_.program_ ); |
| 288 |
|
| 289 |
TEAPOT_MATERIALS material = { { 1.0f, 1.0f, 1.0f, 10.f }, { 0.1f, 0.1f, 0.1f }, }; |
| 290 |
|
| 291 |
//Update uniforms |
| 292 |
// |
| 293 |
//using glUniform3fv here was troublesome.. |
| 294 |
// |
| 295 |
glUniform4f( shader_param_.material_specular_, material.specular_color[0], |
| 296 |
material.specular_color[1], material.specular_color[2], material.specular_color[3] ); |
| 297 |
glUniform3f( shader_param_.material_ambient_, material.ambient_color[0], |
| 298 |
material.ambient_color[1], material.ambient_color[2] ); |
| 299 |
|
| 300 |
glUniform3f( shader_param_.light0_, 100.f, -200.f, -600.f ); |
| 301 |
|
| 302 |
if( geometry_instancing_support_ ) |
| 303 |
{ |
| 304 |
// |
| 305 |
//Geometry instancing, new feature in GLES3.0 |
| 306 |
// |
| 307 |
|
| 308 |
//Update UBO |
| 309 |
glBindBuffer( GL_UNIFORM_BUFFER, ubo_ ); |
| 310 |
float* p = (float*) glMapBufferRange( GL_UNIFORM_BUFFER, 0, |
| 311 |
teapot_x_ * teapot_y_ * teapot_z_ * (ubo_matrix_stride_ * 2) * sizeof(float), |
| 312 |
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT ); |
| 313 |
float* pMVPMat = p; |
| 314 |
float* pMVMat = p + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_; |
| 315 |
for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i ) |
| 316 |
{ |
| 317 |
//Rotation |
| 318 |
float fX, fY; |
| 319 |
vec_current_rotations_[i] += vec_rotations_[i]; |
| 320 |
vec_current_rotations_[i].Value( fX, fY ); |
| 321 |
ndk_helper::Mat4 mat_rotation = ndk_helper::Mat4::RotationX( fX ) |
| 322 |
* ndk_helper::Mat4::RotationY( fY ); |
| 323 |
|
| 324 |
// Feed Projection and Model View matrices to the shaders |
| 325 |
ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation; |
| 326 |
ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v; |
| 327 |
|
| 328 |
memcpy( pMVPMat, mat_vp.Ptr(), sizeof(mat_v) ); |
| 329 |
pMVPMat += ubo_matrix_stride_; |
| 330 |
|
| 331 |
memcpy( pMVMat, mat_v.Ptr(), sizeof(mat_v) ); |
| 332 |
pMVMat += ubo_matrix_stride_; |
| 333 |
} |
| 334 |
glUnmapBuffer( GL_UNIFORM_BUFFER ); |
| 335 |
|
| 336 |
//Instanced rendering |
| 337 |
glDrawElementsInstanced( GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT, BUFFER_OFFSET(0), |
| 338 |
teapot_x_ * teapot_y_ * teapot_z_ ); |
| 339 |
|
| 340 |
} |
| 341 |
else |
| 342 |
{ |
| 343 |
//Regular rendering pass |
| 344 |
for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i ) |
| 345 |
{ |
| 346 |
//Set diffuse |
| 347 |
float x, y, z; |
| 348 |
vec_colors_[i].Value( x, y, z ); |
| 349 |
glUniform4f( shader_param_.material_diffuse_, x, y, z, 1.f ); |
| 350 |
|
| 351 |
//Rotation |
| 352 |
vec_current_rotations_[i] += vec_rotations_[i]; |
| 353 |
vec_current_rotations_[i].Value( x, y ); |
| 354 |
ndk_helper::Mat4 mat_rotation = ndk_helper::Mat4::RotationX( x ) |
| 355 |
* ndk_helper::Mat4::RotationY( y ); |
| 356 |
|
| 357 |
// Feed Projection and Model View matrices to the shaders |
| 358 |
ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation; |
| 359 |
ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v; |
| 360 |
glUniformMatrix4fv( shader_param_.matrix_projection_, 1, GL_FALSE, mat_vp.Ptr() ); |
| 361 |
glUniformMatrix4fv( shader_param_.matrix_view_, 1, GL_FALSE, mat_v.Ptr() ); |
| 362 |
|
| 363 |
glDrawElements( GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT, BUFFER_OFFSET(0) ); |
| 364 |
|
| 365 |
} |
| 366 |
} |
| 367 |
|
| 368 |
glBindBuffer( GL_ARRAY_BUFFER, 0 ); |
| 369 |
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); |
| 370 |
} |
| 371 |
|
| 372 |
//-------------------------------------------------------------------------------- |
| 373 |
// LoadShaders |
| 374 |
//-------------------------------------------------------------------------------- |
| 375 |
bool MoreTeapotsRenderer::LoadShaders( SHADER_PARAMS* params, |
| 376 |
const char* strVsh, |
| 377 |
const char* strFsh ) |
| 378 |
{ |
| 379 |
// |
| 380 |
//Shader load for GLES2 |
| 381 |
//In GLES2.0, shader attribute locations need to be explicitly specified before linking |
| 382 |
// |
| 383 |
GLuint program; |
| 384 |
GLuint vertShader, fragShader; |
| 385 |
char *vertShaderPathname, *fragShaderPathname; |
| 386 |
|
| 387 |
// Create shader program |
| 388 |
program = glCreateProgram(); |
| 389 |
LOGI( "Created Shader %d", program ); |
| 390 |
|
| 391 |
// Create and compile vertex shader |
| 392 |
if( !ndk_helper::shader::CompileShader( &vertShader, GL_VERTEX_SHADER, strVsh ) ) |
| 393 |
{ |
| 394 |
LOGI( "Failed to compile vertex shader" ); |
| 395 |
glDeleteProgram( program ); |
| 396 |
return false; |
| 397 |
} |
| 398 |
|
| 399 |
// Create and compile fragment shader |
| 400 |
if( !ndk_helper::shader::CompileShader( &fragShader, GL_FRAGMENT_SHADER, strFsh ) ) |
| 401 |
{ |
| 402 |
LOGI( "Failed to compile fragment shader" ); |
| 403 |
glDeleteProgram( program ); |
| 404 |
return false; |
| 405 |
} |
| 406 |
|
| 407 |
// Attach vertex shader to program |
| 408 |
glAttachShader( program, vertShader ); |
| 409 |
|
| 410 |
// Attach fragment shader to program |
| 411 |
glAttachShader( program, fragShader ); |
| 412 |
|
| 413 |
// Bind attribute locations |
| 414 |
// this needs to be done prior to linking |
| 415 |
glBindAttribLocation( program, ATTRIB_VERTEX, "myVertex" ); |
| 416 |
glBindAttribLocation( program, ATTRIB_NORMAL, "myNormal" ); |
| 417 |
|
| 418 |
// Link program |
| 419 |
if( !ndk_helper::shader::LinkProgram( program ) ) |
| 420 |
{ |
| 421 |
LOGI( "Failed to link program: %d", program ); |
| 422 |
|
| 423 |
if( vertShader ) |
| 424 |
{ |
| 425 |
glDeleteShader( vertShader ); |
| 426 |
vertShader = 0; |
| 427 |
} |
| 428 |
if( fragShader ) |
| 429 |
{ |
| 430 |
glDeleteShader( fragShader ); |
| 431 |
fragShader = 0; |
| 432 |
} |
| 433 |
if( program ) |
| 434 |
{ |
| 435 |
glDeleteProgram( program ); |
| 436 |
} |
| 437 |
return false; |
| 438 |
} |
| 439 |
|
| 440 |
// Get uniform locations |
| 441 |
params->matrix_projection_ = glGetUniformLocation( program, "uPMatrix" ); |
| 442 |
params->matrix_view_ = glGetUniformLocation( program, "uMVMatrix" ); |
| 443 |
|
| 444 |
params->light0_ = glGetUniformLocation( program, "vLight0" ); |
| 445 |
params->material_diffuse_ = glGetUniformLocation( program, "vMaterialDiffuse" ); |
| 446 |
params->material_ambient_ = glGetUniformLocation( program, "vMaterialAmbient" ); |
| 447 |
params->material_specular_ = glGetUniformLocation( program, "vMaterialSpecular" ); |
| 448 |
|
| 449 |
// Release vertex and fragment shaders |
| 450 |
if( vertShader ) |
| 451 |
glDeleteShader( vertShader ); |
| 452 |
if( fragShader ) |
| 453 |
glDeleteShader( fragShader ); |
| 454 |
|
| 455 |
params->program_ = program; |
| 456 |
return true; |
| 457 |
} |
| 458 |
|
| 459 |
bool MoreTeapotsRenderer::LoadShadersES3( SHADER_PARAMS* params, |
| 460 |
const char* strVsh, |
| 461 |
const char* strFsh, |
| 462 |
std::map<std::string, std::string>&shaderParams ) |
| 463 |
{ |
| 464 |
// |
| 465 |
//Shader load for GLES3 |
| 466 |
//In GLES3.0, shader attribute index can be described in a shader code directly with layout() attribute |
| 467 |
// |
| 468 |
GLuint program; |
| 469 |
GLuint vertShader, fragShader; |
| 470 |
char *vertShaderPathname, *fragShaderPathname; |
| 471 |
|
| 472 |
// Create shader program |
| 473 |
program = glCreateProgram(); |
| 474 |
LOGI( "Created Shader %d", program ); |
| 475 |
|
| 476 |
// Create and compile vertex shader |
| 477 |
if( !ndk_helper::shader::CompileShader( &vertShader, GL_VERTEX_SHADER, strVsh, shaderParams ) ) |
| 478 |
{ |
| 479 |
LOGI( "Failed to compile vertex shader" ); |
| 480 |
glDeleteProgram( program ); |
| 481 |
return false; |
| 482 |
} |
| 483 |
|
| 484 |
// Create and compile fragment shader |
| 485 |
if( !ndk_helper::shader::CompileShader( &fragShader, GL_FRAGMENT_SHADER, strFsh, |
| 486 |
shaderParams ) ) |
| 487 |
{ |
| 488 |
LOGI( "Failed to compile fragment shader" ); |
| 489 |
glDeleteProgram( program ); |
| 490 |
return false; |
| 491 |
} |
| 492 |
|
| 493 |
// Attach vertex shader to program |
| 494 |
glAttachShader( program, vertShader ); |
| 495 |
|
| 496 |
// Attach fragment shader to program |
| 497 |
glAttachShader( program, fragShader ); |
| 498 |
|
| 499 |
// Link program |
| 500 |
if( !ndk_helper::shader::LinkProgram( program ) ) |
| 501 |
{ |
| 502 |
LOGI( "Failed to link program: %d", program ); |
| 503 |
|
| 504 |
if( vertShader ) |
| 505 |
{ |
| 506 |
glDeleteShader( vertShader ); |
| 507 |
vertShader = 0; |
| 508 |
} |
| 509 |
if( fragShader ) |
| 510 |
{ |
| 511 |
glDeleteShader( fragShader ); |
| 512 |
fragShader = 0; |
| 513 |
} |
| 514 |
if( program ) |
| 515 |
{ |
| 516 |
glDeleteProgram( program ); |
| 517 |
} |
| 518 |
|
| 519 |
return false; |
| 520 |
} |
| 521 |
|
| 522 |
// Get uniform locations |
| 523 |
params->light0_ = glGetUniformLocation( program, "vLight0" ); |
| 524 |
params->material_ambient_ = glGetUniformLocation( program, "vMaterialAmbient" ); |
| 525 |
params->material_specular_ = glGetUniformLocation( program, "vMaterialSpecular" ); |
| 526 |
|
| 527 |
// Release vertex and fragment shaders |
| 528 |
if( vertShader ) |
| 529 |
glDeleteShader( vertShader ); |
| 530 |
if( fragShader ) |
| 531 |
glDeleteShader( fragShader ); |
| 532 |
|
| 533 |
params->program_ = program; |
| 534 |
return true; |
| 535 |
} |
| 536 |
|
| 537 |
//-------------------------------------------------------------------------------- |
| 538 |
// Bind |
| 539 |
//-------------------------------------------------------------------------------- |
| 540 |
bool MoreTeapotsRenderer::Bind( ndk_helper::TapCamera* camera ) |
| 541 |
{ |
| 542 |
camera_ = camera; |
| 543 |
return true; |
| 544 |
} |
| 545 |
|
| 546 |
//-------------------------------------------------------------------------------- |
| 547 |
// Helper functions |
| 548 |
//-------------------------------------------------------------------------------- |
| 549 |
std::string MoreTeapotsRenderer::ToString( const int32_t i ) |
| 550 |
{ |
| 551 |
char str[64]; |
| 552 |
snprintf( str, sizeof(str), "%d", i ); |
| 553 |
return std::string( str ); |
| 554 |
} |
| 555 |
|