void QuadRenderer::initializeGraphicsResources() { LOOM_PROFILE_SCOPE(quadInit); lmLogInfo(gGFXQuadRendererLogGroup, "Initializing Graphics Resources"); GL_Context* ctx = Graphics::context(); // create the single initial vertex buffer ctx->glGenBuffers(1, &vertexBufferId); ctx->glBindBuffer(GL_ARRAY_BUFFER, vertexBufferId); ctx->glBufferData(GL_ARRAY_BUFFER, MAXBATCHQUADS * 4 * sizeof(VertexPosColorTex), 0, GL_STREAM_DRAW); ctx->glBindBuffer(GL_ARRAY_BUFFER, 0); // create the single, reused index buffer ctx->glGenBuffers(1, &indexBufferId); ctx->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferId); uint16_t *pIndex = (uint16_t*)lmAlloc(gQuadMemoryAllocator, sizeof(unsigned short) * 6 * MAXBATCHQUADS); uint16_t *pStart = pIndex; int j = 0; for (int i = 0; i < 6 * MAXBATCHQUADS; i += 6, j += 4, pIndex += 6) { pIndex[0] = j; pIndex[1] = j + 2; pIndex[2] = j + 1; pIndex[3] = j + 1; pIndex[4] = j + 2; pIndex[5] = j + 3; } ctx->glBufferData(GL_ELEMENT_ARRAY_BUFFER, MAXBATCHQUADS * 6 * sizeof(uint16_t), pStart, GL_STREAM_DRAW); ctx->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); lmFree(gQuadMemoryAllocator, pStart); // Create the system memory buffer for quads. batchedVertices = static_cast<VertexPosColorTex*>(lmAlloc(gQuadMemoryAllocator, MAXBATCHQUADS * 4 * sizeof(VertexPosColorTex))); }
static void Render() { static float color[8][3] = { {1.0, 1.0, 0.0}, {1.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {1.0, 0.0, 1.0}, {0.0, 0.0, 1.0} }; static float cube[8][3] = { {0.5, 0.5, -0.5}, {0.5, -0.5, -0.5}, {-0.5, -0.5, -0.5}, {-0.5, 0.5, -0.5}, {-0.5, 0.5, 0.5}, {0.5, 0.5, 0.5}, {0.5, -0.5, 0.5}, {-0.5, -0.5, 0.5} }; /* Do our drawing, too. */ ctx.glClearColor(0.0, 0.0, 0.0, 1.0); ctx.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); ctx.glBegin(GL_QUADS); #ifdef SHADED_CUBE ctx.glColor3fv(color[0]); ctx.glVertex3fv(cube[0]); ctx.glColor3fv(color[1]); ctx.glVertex3fv(cube[1]); ctx.glColor3fv(color[2]); ctx.glVertex3fv(cube[2]); ctx.glColor3fv(color[3]); ctx.glVertex3fv(cube[3]); ctx.glColor3fv(color[3]); ctx.glVertex3fv(cube[3]); ctx.glColor3fv(color[4]); ctx.glVertex3fv(cube[4]); ctx.glColor3fv(color[7]); ctx.glVertex3fv(cube[7]); ctx.glColor3fv(color[2]); ctx.glVertex3fv(cube[2]); ctx.glColor3fv(color[0]); ctx.glVertex3fv(cube[0]); ctx.glColor3fv(color[5]); ctx.glVertex3fv(cube[5]); ctx.glColor3fv(color[6]); ctx.glVertex3fv(cube[6]); ctx.glColor3fv(color[1]); ctx.glVertex3fv(cube[1]); ctx.glColor3fv(color[5]); ctx.glVertex3fv(cube[5]); ctx.glColor3fv(color[4]); ctx.glVertex3fv(cube[4]); ctx.glColor3fv(color[7]); ctx.glVertex3fv(cube[7]); ctx.glColor3fv(color[6]); ctx.glVertex3fv(cube[6]); ctx.glColor3fv(color[5]); ctx.glVertex3fv(cube[5]); ctx.glColor3fv(color[0]); ctx.glVertex3fv(cube[0]); ctx.glColor3fv(color[3]); ctx.glVertex3fv(cube[3]); ctx.glColor3fv(color[4]); ctx.glVertex3fv(cube[4]); ctx.glColor3fv(color[6]); ctx.glVertex3fv(cube[6]); ctx.glColor3fv(color[1]); ctx.glVertex3fv(cube[1]); ctx.glColor3fv(color[2]); ctx.glVertex3fv(cube[2]); ctx.glColor3fv(color[7]); ctx.glVertex3fv(cube[7]); #else /* flat cube */ ctx.glColor3f(1.0, 0.0, 0.0); ctx.glVertex3fv(cube[0]); ctx.glVertex3fv(cube[1]); ctx.glVertex3fv(cube[2]); ctx.glVertex3fv(cube[3]); ctx.glColor3f(0.0, 1.0, 0.0); ctx.glVertex3fv(cube[3]); ctx.glVertex3fv(cube[4]); ctx.glVertex3fv(cube[7]); ctx.glVertex3fv(cube[2]); ctx.glColor3f(0.0, 0.0, 1.0); ctx.glVertex3fv(cube[0]); ctx.glVertex3fv(cube[5]); ctx.glVertex3fv(cube[6]); ctx.glVertex3fv(cube[1]); ctx.glColor3f(0.0, 1.0, 1.0); ctx.glVertex3fv(cube[5]); ctx.glVertex3fv(cube[4]); ctx.glVertex3fv(cube[7]); ctx.glVertex3fv(cube[6]); ctx.glColor3f(1.0, 1.0, 0.0); ctx.glVertex3fv(cube[5]); ctx.glVertex3fv(cube[0]); ctx.glVertex3fv(cube[3]); ctx.glVertex3fv(cube[4]); ctx.glColor3f(1.0, 0.0, 1.0); ctx.glVertex3fv(cube[6]); ctx.glVertex3fv(cube[1]); ctx.glVertex3fv(cube[2]); ctx.glVertex3fv(cube[7]); #endif /* SHADED_CUBE */ ctx.glEnd(); ctx.glMatrixMode(GL_MODELVIEW); ctx.glRotatef(5.0, 1.0, 1.0, 1.0); }
int main(int argc, char *argv[]) { int fsaa, accel; int value; int i, done; SDL_DisplayMode mode; SDL_Event event; Uint32 then, now, frames; int status; int dw, dh; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Initialize parameters */ fsaa = 0; accel = -1; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { if (SDL_strcasecmp(argv[i], "--fsaa") == 0 && i+1 < argc) { fsaa = atoi(argv[i+1]); consumed = 2; } else if (SDL_strcasecmp(argv[i], "--accel") == 0 && i+1 < argc) { accel = atoi(argv[i+1]); consumed = 2; } else { consumed = -1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--fsaa n] [--accel n]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } /* Set OpenGL parameters */ state->window_flags |= SDL_WINDOW_OPENGL; state->gl_red_size = 5; state->gl_green_size = 5; state->gl_blue_size = 5; state->gl_depth_size = 16; state->gl_double_buffer = 1; if (fsaa) { state->gl_multisamplebuffers = 1; state->gl_multisamplesamples = fsaa; } if (accel >= 0) { state->gl_accelerated = accel; } if (!SDLTest_CommonInit(state)) { quit(2); } /* Create OpenGL context */ context = SDL_GL_CreateContext(state->windows[0]); if (!context) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GL_CreateContext(): %s\n", SDL_GetError()); quit(2); } /* Important: call this *after* creating the context */ if (LoadContext(&ctx) < 0) { SDL_Log("Could not load GL functions\n"); quit(2); return 0; } if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { /* try late-swap-tearing first. If not supported, try normal vsync. */ if (SDL_GL_SetSwapInterval(-1) == -1) { SDL_GL_SetSwapInterval(1); } } else { SDL_GL_SetSwapInterval(0); /* disable vsync. */ } SDL_GetCurrentDisplayMode(0, &mode); SDL_Log("Screen BPP : %d\n", SDL_BITSPERPIXEL(mode.format)); SDL_Log("Swap Interval : %d\n", SDL_GL_GetSwapInterval()); SDL_GetWindowSize(state->windows[0], &dw, &dh); SDL_Log("Window Size : %d,%d\n", dw, dh); SDL_GL_GetDrawableSize(state->windows[0], &dw, &dh); SDL_Log("Draw Size : %d,%d\n", dw, dh); SDL_Log("\n"); SDL_Log("Vendor : %s\n", ctx.glGetString(GL_VENDOR)); SDL_Log("Renderer : %s\n", ctx.glGetString(GL_RENDERER)); SDL_Log("Version : %s\n", ctx.glGetString(GL_VERSION)); SDL_Log("Extensions : %s\n", ctx.glGetString(GL_EXTENSIONS)); SDL_Log("\n"); status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); if (!status) { SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); if (!status) { SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); if (!status) { SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); if (!status) { SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", 16, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError()); } if (fsaa) { status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError()); } } if (accel >= 0) { status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); if (!status) { SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested %d, got %d\n", accel, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError()); } } /* Set rendering settings */ ctx.glMatrixMode(GL_PROJECTION); ctx.glLoadIdentity(); ctx.glOrtho(-2.0, 2.0, -2.0, 2.0, -20.0, 20.0); ctx.glMatrixMode(GL_MODELVIEW); ctx.glLoadIdentity(); ctx.glEnable(GL_DEPTH_TEST); ctx.glDepthFunc(GL_LESS); ctx.glShadeModel(GL_SMOOTH); /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { SDLTest_CommonEvent(state, &event, &done); } for (i = 0; i < state->num_windows; ++i) { int w, h; if (state->windows[i] == NULL) continue; SDL_GL_MakeCurrent(state->windows[i], context); SDL_GL_GetDrawableSize(state->windows[i], &w, &h); ctx.glViewport(0, 0, w, h); Render(); SDL_GL_SwapWindow(state->windows[i]); } } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { SDL_Log("%2.2f frames per second\n", ((double) frames * 1000) / (now - then)); } quit(0); return 0; }
void QuadRenderer::submit() { LOOM_PROFILE_SCOPE(quadSubmit); if (batchedVertexCount <= 0) { return; } numFrameSubmit++; TextureInfo &tinfo = *Texture::getTextureInfo(currentTexture); if (tinfo.handle != -1) { if (tinfo.visible) { GL_Context* ctx = Graphics::context(); // On iPad 1, the PosColorTex shader, which multiplies texture color with // vertex color, is 5x slower than PosTex, which just draws the texture // unmodified. So we select the shader to use appropriately. //lmLogInfo(gGFXQuadRendererLogGroup, "Handle > %u", tinfo.handle); if (!Graphics_IsGLStateValid(GFX_OPENGL_STATE_QUAD)) { sShaderStateValid = false; sTextureStateValid = false; sBlendStateValid = false; } ctx->glBindBuffer(GL_ARRAY_BUFFER, vertexBufferId); if (!sShaderStateValid) { Loom2D::Matrix mvp; mvp.copyFromMatrix4(Graphics::getMVP()); sCurrentShader->setMVP(mvp); sCurrentShader->setTextureId(0); sCurrentShader->bind(); sShaderStateValid = true; } if (!sTextureStateValid) { // Set up texture state. ctx->glActiveTexture(GL_TEXTURE0); ctx->glBindTexture(GL_TEXTURE_2D, tinfo.handle); if (tinfo.clampOnly) { tinfo.wrapU = TEXTUREINFO_WRAP_CLAMP; tinfo.wrapV = TEXTUREINFO_WRAP_CLAMP; } switch (tinfo.wrapU) { case TEXTUREINFO_WRAP_CLAMP: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); break; case TEXTUREINFO_WRAP_MIRROR: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); break; case TEXTUREINFO_WRAP_REPEAT: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); break; default: lmAssert(false, "Unsupported wrapU: %d", tinfo.wrapU); } switch (tinfo.wrapV) { case TEXTUREINFO_WRAP_CLAMP: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); break; case TEXTUREINFO_WRAP_MIRROR: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); break; case TEXTUREINFO_WRAP_REPEAT: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); break; default: lmAssert(false, "Unsupported wrapV: %d", tinfo.wrapV); } //*/ switch (tinfo.smoothing) { case TEXTUREINFO_SMOOTHING_NONE: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tinfo.mipmaps ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST); ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); break; case TEXTUREINFO_SMOOTHING_BILINEAR: ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tinfo.mipmaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); ctx->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); break; default: lmAssert(false, "Unsupported smoothing: %d", tinfo.smoothing); } sTextureStateValid = true; } if (!sBlendStateValid) { if (sBlendEnabled) { ctx->glEnable(GL_BLEND); ctx->glBlendFuncSeparate(sSrcBlend, sDstBlend, sSrcBlend, sDstBlend); } else { ctx->glDisable(GL_BLEND); } sBlendStateValid = true; } Graphics_SetCurrentGLState(GFX_OPENGL_STATE_QUAD); // Setting the buffer to null supposedly enables better performance because it enables the driver to do some optimizations. ctx->glBufferData(GL_ARRAY_BUFFER, batchedVertexCount*sizeof(VertexPosColorTex), NULL, GL_STREAM_DRAW); ctx->glBufferData(GL_ARRAY_BUFFER, batchedVertexCount*sizeof(VertexPosColorTex), batchedVertices, GL_STREAM_DRAW); // And bind indices and draw. ctx->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferId); ctx->glDrawElements(GL_TRIANGLES, (GLsizei)(batchedVertexCount / 4 * 6), GL_UNSIGNED_SHORT, nullptr); } } batchedVertexCount = 0; }