/*------------------------------------------------------------------------------ Function name: af_set_type Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET af_set_type(isp_af_context_t *af, IM_UINT32 type) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(af != IM_NULL); IM_ASSERT(af->regVal != IM_NULL); IM_ASSERT(af->regOfst != IM_NULL); /*check af type*/ if(type > ISP_AF_TYPE_NINE_WINS) { IM_ERRMSG((IM_STR("Invalid type: type=%d"), type)); return IM_RET_INVALID_PARAMETER; } if(af->type == type) { IM_INFOMSG((IM_STR("af has already been this type"))); return IM_RET_OK; } if(af->enable == IM_TRUE) { SetIspRegister(af->regVal, ISP_AF_CNTL_TYPE, type); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_CNTL], af->regVal[rISP_AF_CNTL])); } af->type = type; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: af_get_result Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET af_get_result(isp_af_context_t *af, isp_af_result_t *rsut) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(af != IM_NULL); IM_ASSERT(af->regVal != IM_NULL); IM_ASSERT(af->regOfst != IM_NULL); IM_ASSERT(rsut != IM_NULL); IM_JIF(isppwl_read_reg(af->regOfst[rISP_AF_RSUT], &af->regVal[rISP_AF_RSUT])); af->rsut.value = GetIspRegister(af->regVal, ISP_AF_RSUT); rsut->value = af->rsut.value; for(i=0; i<9; i++) { IM_JIF(isppwl_read_reg(af->regOfst[rISP_AF_CNT0 + i], &af->regVal[rISP_AF_CNT0 + i])); af->rsut.cnt[i] = GetIspRegister(af->regVal, ISP_AF_CNT0+i); rsut->cnt[i] = af->rsut.cnt[i]; } return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: hist_set_hist_threshold_matrix Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_set_hist_threshold_matrix(isp_hist_context_t *hist, isp_hist_thr_matrix *thrMat) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); IM_ASSERT(thrMat != IM_NULL); /*check hist threshold*/ if((thrMat->th1 < 0) || (thrMat->th1 > 127) || (thrMat->th2 < 0) || (thrMat->th2 > 255)) { IM_ERRMSG((IM_STR("Invalid threshold: th1=%d, th2=%d"), thrMat->th1, thrMat->th2)); return IM_RET_INVALID_PARAMETER; } if(hist->enable == IM_TRUE) { /*set hist threshold*/ SetIspRegister(hist->regVal, ISP_HIST_TH_1, thrMat->th1); SetIspRegister(hist->regVal, ISP_HIST_TH_2, thrMat->th2); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_HIST_TH], hist->regVal[rISP_HIST_TH])); } isppwl_memcpy((void*)(&hist->thrMat), (void *)(thrMat), sizeof(isp_hist_thr_matrix)); return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: hist_set_enable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_set_enable(isp_hist_context_t *hist) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); if(hist->enable == IM_TRUE) { IM_INFOMSG((IM_STR("hist has been enabled"))); return IM_RET_OK; } //enable hist /*set hist and backlit threshold*/ SetIspRegister(hist->regVal, ISP_BLIT_TH1, hist->blitTh1); SetIspRegister(hist->regVal, ISP_HIST_TH_1, hist->thrMat.th1); SetIspRegister(hist->regVal, ISP_HIST_TH_2, hist->thrMat.th2); /*set hist enable*/ SetIspRegister(hist->regVal, ISP_GLB_CFG2_HISTBYPASS, 0); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_BLIT_TH], hist->regVal[rISP_BLIT_TH])); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_HIST_TH], hist->regVal[rISP_HIST_TH])); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_GLB_CFG2], hist->regVal[rISP_GLB_CFG2])); hist->enable = IM_TRUE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
IM_RET dmmupwl_free_linear_page_align_memory(IN IM_Buffer *buffer) { //ptable_mem_t *ptm; IM_INFOMSG((IM_STR("%s()"), IM_STR(_IM_FUNC_))); #if 0 ptm = (ptable_mem_t *)im_list_begin(gPwl->ptmlist); IM_ASSERT(ptm != IM_NULL); while(ptm != IM_NULL){ if(ptm->kVirAddrRemap == buffer->vir_addr){ break; } ptm = (ptable_mem_t *)im_list_next(gPwl->ptmlist); } IM_ASSERT(ptm != IM_NULL); IM_ASSERT(ptm->kVirAddrRemap != IM_NULL); IM_ASSERT(ptm->kVirAddr != IM_NULL); IM_INFOMSG((IM_STR("ptm->kVirAddr=0x%x"), (IM_INT32)ptm->kVirAddr)); IM_INFOMSG((IM_STR("ptm->kVirAddrRemap=0x%x"), (IM_INT32)ptm->kVirAddrRemap)); iounmap(ptm->kVirAddrRemap); //kfree(ptm->kVirAddr); free_page((IM_UINT32)ptm->kVirAddr); im_list_erase(gPwl->ptmlist, ptm); return IM_RET_OK; #else IM_INFOMSG((IM_STR("buffer vir_addr=0x%x, phy_addr=0x%x"), (IM_UINT32)buffer->vir_addr, buffer->phy_addr)); dma_unmap_page(NULL, buffer->phy_addr, PAGE_SIZE, DMA_BIDIRECTIONAL); __free_page(virt_to_page(buffer->vir_addr)); return IM_RET_OK; #endif }
/*------------------------------------------------------------------------------ Function name: ae_get_result Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET ae_get_result(isp_ae_context_t *ae, isp_ae_result_t *rsut) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(ae != IM_NULL); IM_ASSERT(ae->regVal != IM_NULL); IM_ASSERT(ae->regOfst != IM_NULL); IM_ASSERT(rsut != IM_NULL); IM_JIF(isppwl_read_reg(ae->regOfst[rISP_AE_YAVG], &ae->regVal[rISP_AE_YAVG])); rsut->avg = GetIspRegister(ae->regVal, ISP_AE_YAVG); //isppwl_read_regs(); for(i=0; i<25; i++) { IM_JIF(isppwl_read_reg(ae->regOfst[rISP_COUNTER00 + i], &ae->regVal[rISP_COUNTER00 + i])); rsut->cnt[i] = GetIspRegister(ae->regVal, ISP_COUNTER00+i); } return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: hist_set_hist_threshold_matrix Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_set_backlit_threshold(isp_hist_context_t *hist, IM_UINT32 blitTh1) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); /*check hist threshold*/ if((blitTh1 < 0) || (blitTh1 > 16777215)) { IM_ERRMSG((IM_STR("Invalid backlit threshold: blitTh1=%d"), blitTh1)); return IM_RET_INVALID_PARAMETER; } if(hist->enable == IM_TRUE) { /*set backlit threshold*/ SetIspRegister(hist->regVal, ISP_BLIT_TH1, blitTh1); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_BLIT_TH], hist->regVal[rISP_BLIT_TH])); } hist->blitTh1 = blitTh1; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: hist_get_result Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_get_result(isp_hist_context_t *hist, isp_hist_result_t *rsut) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); IM_ASSERT(rsut != IM_NULL); IM_JIF(isppwl_read_reg(hist->regOfst[rISP_BACK_LIT], &hist->regVal[rISP_BACK_LIT])); hist->rsut.bkLit = GetIspRegister(hist->regVal, ISP_BACK_LIT); rsut->bkLit = hist->rsut.bkLit; for(i=0; i<16; i++) { IM_JIF(isppwl_read_reg(hist->regOfst[rISP_HIST_COUNTER1 + i], &hist->regVal[rISP_HIST_COUNTER1 + i])); hist->rsut.hist[i] = GetIspRegister(hist->regVal, ISP_HIST_COUNTER1+i); rsut->hist[i] = hist->rsut.hist[i]; } return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: af_set_enable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET af_set_enable(isp_af_context_t *af) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(af != IM_NULL); IM_ASSERT(af->regVal != IM_NULL); IM_ASSERT(af->regOfst != IM_NULL); if(af->enable == IM_TRUE) { IM_INFOMSG((IM_STR("af has been enabled"))); return IM_RET_OK; } /*set af type*/ SetIspRegister(af->regVal, ISP_AF_CNTL_TYPE, af->type); /*set af block coordinate*/ for(i=0; i<9; i++) { SetIspRegister(af->regVal, ISP_AF_P0ST_X00+4*i, af->coordinate.blokPos[i].x0); SetIspRegister(af->regVal, ISP_AF_P0ST_Y00+4*i, af->coordinate.blokPos[i].y0); SetIspRegister(af->regVal, ISP_AF_P0ED_X01+4*i, af->coordinate.blokPos[i].x1); SetIspRegister(af->regVal, ISP_AF_P0ED_Y01+4*i, af->coordinate.blokPos[i].y1); } /*set af enable*/ SetIspRegister(af->regVal, ISP_GLB_CFG2_AFBYPASS, 0); //isppwl_write_regs(); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_CNTL], af->regVal[rISP_AF_CNTL])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P0ST], af->regVal[rISP_AF_P0ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P0ED], af->regVal[rISP_AF_P0ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P1ST], af->regVal[rISP_AF_P1ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P1ED], af->regVal[rISP_AF_P1ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P2ST], af->regVal[rISP_AF_P2ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P2ED], af->regVal[rISP_AF_P2ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P3ST], af->regVal[rISP_AF_P3ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P3ED], af->regVal[rISP_AF_P3ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P4ST], af->regVal[rISP_AF_P4ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P4ED], af->regVal[rISP_AF_P4ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P5ST], af->regVal[rISP_AF_P5ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P5ED], af->regVal[rISP_AF_P5ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P6ST], af->regVal[rISP_AF_P6ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P6ED], af->regVal[rISP_AF_P6ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P7ST], af->regVal[rISP_AF_P7ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P7ED], af->regVal[rISP_AF_P7ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P8ST], af->regVal[rISP_AF_P8ST])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_AF_P8ED], af->regVal[rISP_AF_P8ED])); IM_JIF(isppwl_write_reg(af->regOfst[rISP_GLB_CFG2], af->regVal[rISP_GLB_CFG2])); af->enable = IM_TRUE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: ae_set_enable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET ae_set_enable(isp_ae_context_t *ae) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(ae != IM_NULL); IM_ASSERT(ae->regVal != IM_NULL); IM_ASSERT(ae->regOfst != IM_NULL); if(ae->enable == IM_TRUE) { IM_INFOMSG((IM_STR("ae has been enabled"))); return IM_RET_OK; } /*set ae block num*/ if(ae->blokSelect.blokNum == 0) { SetIspRegister(ae->regVal, ISP_AE_CNTL_NUM_1, (1<<15)/25); } else { SetIspRegister(ae->regVal, ISP_AE_CNTL_NUM_1, (1<<15)/(ae->blokSelect.blokNum)); } /*set ae block enable*/ SetIspRegister(ae->regVal, ISP_AE_BEN, ae->blokSelect.blokEn); //set log2(block pixnum) SetIspRegister(ae->regVal, ISP_AE_CNTL_PNUM_N, ae->coordinate.log2_blokPixNum); //set block blokPosition for(i=0; i<25; i++) { SetIspRegister(ae->regVal, (ISP_AE_X00_1+i*4), ae->coordinate.blokPos[i].x1); SetIspRegister(ae->regVal, (ISP_AE_X00_0+i*4), ae->coordinate.blokPos[i].x0); SetIspRegister(ae->regVal, (ISP_AE_Y00_1+i*4), ae->coordinate.blokPos[i].y1); SetIspRegister(ae->regVal, (ISP_AE_Y00_0+i*4), ae->coordinate.blokPos[i].y0); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_X00+i*2], ae->regVal[rISP_AE_X00+i*2])); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_Y00+i*2], ae->regVal[rISP_AE_Y00+i*2])); } /*set ae bypass*/ SetIspRegister(ae->regVal, ISP_GLB_CFG2_AEBYPASS, 0); //isppwl_write_regs(); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_CNTL], ae->regVal[rISP_AE_CNTL])); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_BEN], ae->regVal[rISP_AE_BEN])); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_GLB_CFG2], ae->regVal[rISP_GLB_CFG2])); ae->enable = IM_TRUE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: ae_set_block_coordinate Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET ae_set_block_coordinate(isp_ae_context_t *ae, isp_ae_coordinate_t *coordinate) { IM_UINT32 i; IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(ae != IM_NULL); IM_ASSERT(ae->regVal != IM_NULL); IM_ASSERT(ae->regOfst != IM_NULL); IM_ASSERT(coordinate != IM_NULL); //check log2(block pixnum) if(coordinate->log2_blokPixNum > 31) { IM_ERRMSG((IM_STR("Invalid log2_blokPixNum=%d"), coordinate->log2_blokPixNum)); return IM_RET_INVALID_PARAMETER; } //check block blokPosition for(i=0; i<25; i++) { if((coordinate->blokPos[i].x0 < 0) || (coordinate->blokPos[i].x0 > 4095) || (coordinate->blokPos[i].y0 < 0) || (coordinate->blokPos[i].y0 > 4095) || (coordinate->blokPos[i].x1 < 0) || (coordinate->blokPos[i].x1 > 4095) || (coordinate->blokPos[i].y1 < 0) || (coordinate->blokPos[i].y1 > 4095)) { IM_ERRMSG((IM_STR("Invalid blokPosition[%d]: x0=%d, y0=%d, x1=%d, y1=%d"), i, coordinate->blokPos[i].x0, coordinate->blokPos[i].y0, coordinate->blokPos[i].x1, coordinate->blokPos[i].y1)); return IM_RET_INVALID_PARAMETER; } } if(ae->enable == IM_TRUE) { //set log2(block pixnum) SetIspRegister(ae->regVal, ISP_AE_CNTL_PNUM_N, coordinate->log2_blokPixNum); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_CNTL], ae->regVal[rISP_AE_CNTL])); //set block blokPosition for(i=0; i<25; i++) { SetIspRegister(ae->regVal, (ISP_AE_X00_1+i*4), coordinate->blokPos[i].x1); SetIspRegister(ae->regVal, (ISP_AE_X00_0+i*4), coordinate->blokPos[i].x0); SetIspRegister(ae->regVal, (ISP_AE_Y00_1+i*4), coordinate->blokPos[i].y1); SetIspRegister(ae->regVal, (ISP_AE_Y00_0+i*4), coordinate->blokPos[i].y0); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_X00+i*2], ae->regVal[rISP_AE_X00+i*2])); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_Y00+i*2], ae->regVal[rISP_AE_Y00+i*2])); } } isppwl_memcpy((void*)(&ae->coordinate), (void *)(coordinate), sizeof(isp_ae_coordinate_t)); return IM_RET_OK; Fail: return IM_RET_FAILED; }
void ImGui_ImplSDL2_NewFrame(SDL_Window* window) { ImGuiIO& io = ImGui::GetIO(); IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame()."); // Setup display size (every frame to accommodate for window resizing) int w, h; int display_w, display_h; SDL_GetWindowSize(window, &w, &h); SDL_GL_GetDrawableSize(window, &display_w, &display_h); io.DisplaySize = ImVec2((float)w, (float)h); if (w > 0 && h > 0) io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h); // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution) static Uint64 frequency = SDL_GetPerformanceFrequency(); Uint64 current_time = SDL_GetPerformanceCounter(); io.DeltaTime = g_Time > 0 ? (float)((double)(current_time - g_Time) / frequency) : (float)(1.0f / 60.0f); g_Time = current_time; ImGui_ImplSDL2_UpdateMousePosAndButtons(); ImGui_ImplSDL2_UpdateMouseCursor(); // Update game controllers (if enabled and available) ImGui_ImplSDL2_UpdateGamepads(); }
// Functions bool ImGui_ImplOpenGL3_Init(const char* glsl_version) { ImGuiIO& io = ImGui::GetIO(); io.BackendRendererName = "imgui_impl_opengl3"; // Store GLSL version string so we can refer to it later in case we recreate shaders. Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure. #if defined(IMGUI_IMPL_OPENGL_ES2) if (glsl_version == NULL) glsl_version = "#version 100"; #elif defined(IMGUI_IMPL_OPENGL_ES3) if (glsl_version == NULL) glsl_version = "#version 300 es"; #else if (glsl_version == NULL) glsl_version = "#version 130"; #endif IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(g_GlslVersionString)); strcpy(g_GlslVersionString, glsl_version); strcat(g_GlslVersionString, "\n"); // Make a dummy GL call (we don't actually need the result) // IF YOU GET A CRASH HERE: it probably means that you haven't initialized the OpenGL function loader used by this code. // Desktop OpenGL 3/4 need a function loader. See the IMGUI_IMPL_OPENGL_LOADER_xxx explanation above. GLint current_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, ¤t_texture); return true; }
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { if (ImGui_ImplDX9_WndProcHandler(hWnd, msg, wParam, lParam)) return true; switch (msg) { case WM_SIZE: if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED) { ImGui_ImplDX9_InvalidateDeviceObjects(); g_d3dpp.BackBufferWidth = LOWORD(lParam); g_d3dpp.BackBufferHeight = HIWORD(lParam); HRESULT hr = g_pd3dDevice->Reset(&g_d3dpp); if (hr == D3DERR_INVALIDCALL) IM_ASSERT(0); ImGui_ImplDX9_CreateDeviceObjects(); } return 0; case WM_SYSCOMMAND: if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu return 0; break; case WM_DESTROY: PostQuitMessage(0); return 0; } return DefWindowProc(hWnd, msg, wParam, lParam); }
// OpenGL code based on http://open.gl tutorials void InitGL() { glfwSetErrorCallback(glfw_error_callback); if (!glfwInit()) exit(1); //glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); //glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_REFRESH_RATE, 60); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); window = glfwCreateWindow(1280, 720, "ImGui OpenGL example", nullptr, nullptr); glfwMakeContextCurrent(window); glfwSetKeyCallback(window, glfw_key_callback); glfwSetScrollCallback(window, glfw_scroll_callback); glfwSetCharCallback(window, glfw_char_callback); glewExperimental = GL_TRUE; glewInit(); GLenum err = GL_NO_ERROR; err = glGetError(); IM_ASSERT(err == GL_NO_ERROR); }
bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window) { #if !SDL_HAS_VULKAN IM_ASSERT(0 && "Unsupported"); #endif return ImGui_ImplSDL2_Init(window); }
/*------------------------------------------------------------------------------ Function name: hist_init Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_init(isp_hist_context_t *hist, hist_config_t *cfg) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); IM_ASSERT(cfg != IM_NULL); /*check hist and backlit threshold*/ if((cfg->blitTh1 < 0) || (cfg->blitTh1 > 16777215) || (cfg->thrMat.th1 < 0) || (cfg->thrMat.th1 > 127) || (cfg->thrMat.th2 < 0) || (cfg->thrMat.th2 > 255)) { IM_ERRMSG((IM_STR("Invalid threshold: blitTh1=%d, th1=%d, th2=%d"), cfg->blitTh1, cfg->thrMat.th1, cfg->thrMat.th2)); return IM_RET_INVALID_PARAMETER; } if(cfg->enable == IM_TRUE) { /*set hist and backlit threshold*/ SetIspRegister(hist->regVal, ISP_BLIT_TH1, cfg->blitTh1); SetIspRegister(hist->regVal, ISP_HIST_TH_1, cfg->thrMat.th1); SetIspRegister(hist->regVal, ISP_HIST_TH_2, cfg->thrMat.th2); /*set hist enable*/ SetIspRegister(hist->regVal, ISP_GLB_CFG2_HISTBYPASS, 0); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_BLIT_TH], hist->regVal[rISP_BLIT_TH])); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_HIST_TH], hist->regVal[rISP_HIST_TH])); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_GLB_CFG2], hist->regVal[rISP_GLB_CFG2])); } else { /*set hist bypass*/ SetIspRegister(hist->regVal, ISP_GLB_CFG2_HISTBYPASS, 1); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_GLB_CFG2], hist->regVal[rISP_GLB_CFG2])); } hist->blitTh1 = cfg->blitTh1; isppwl_memcpy((void*)(&hist->thrMat), (void *)(&cfg->thrMat), sizeof(isp_hist_thr_matrix)); hist->enable = cfg->enable; return IM_RET_OK; Fail: return IM_RET_FAILED; }
void ImGui_ImplGlfw_NewFrame() { ImGuiIO& io = ImGui::GetIO(); IM_ASSERT(io.Fonts->IsBuilt()); // Font atlas needs to be built, call renderer _NewFrame() function e.g. ImGui_ImplOpenGL3_NewFrame() // Setup display size int w, h; int display_w, display_h; w = Global.iWindowWidth; h = Global.iWindowHeight; display_w = w; display_h = h; io.DisplaySize = ImVec2((float)w, (float)h); io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0); // Setup time step double current_time = glfwGetTime(); io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f); g_Time = current_time; ImGui_ImplGlfw_UpdateMousePosAndButtons(); ImGui_ImplGlfw_UpdateMouseCursor(); // Gamepad navigation mapping [BETA] memset(io.NavInputs, 0, sizeof(io.NavInputs)); if (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) { // Update gamepad inputs #define MAP_BUTTON(NAV_NO, BUTTON_NO) { if (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS) io.NavInputs[NAV_NO] = 1.0f; } #define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); if (v > 1.0f) v = 1.0f; if (io.NavInputs[NAV_NO] < v) io.NavInputs[NAV_NO] = v; } int axes_count = 0, buttons_count = 0; const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count); const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count); MAP_BUTTON(ImGuiNavInput_Activate, 0); // Cross / A MAP_BUTTON(ImGuiNavInput_Cancel, 1); // Circle / B MAP_BUTTON(ImGuiNavInput_Menu, 2); // Square / X MAP_BUTTON(ImGuiNavInput_Input, 3); // Triangle / Y MAP_BUTTON(ImGuiNavInput_DpadLeft, 13); // D-Pad Left MAP_BUTTON(ImGuiNavInput_DpadRight, 11); // D-Pad Right MAP_BUTTON(ImGuiNavInput_DpadUp, 10); // D-Pad Up MAP_BUTTON(ImGuiNavInput_DpadDown, 12); // D-Pad Down MAP_BUTTON(ImGuiNavInput_FocusPrev, 4); // L1 / LB MAP_BUTTON(ImGuiNavInput_FocusNext, 5); // R1 / RB MAP_BUTTON(ImGuiNavInput_TweakSlow, 4); // L1 / LB MAP_BUTTON(ImGuiNavInput_TweakFast, 5); // R1 / RB MAP_ANALOG(ImGuiNavInput_LStickLeft, 0, -0.3f, -0.9f); MAP_ANALOG(ImGuiNavInput_LStickRight,0, +0.3f, +0.9f); MAP_ANALOG(ImGuiNavInput_LStickUp, 1, +0.3f, +0.9f); MAP_ANALOG(ImGuiNavInput_LStickDown, 1, -0.3f, -0.9f); #undef MAP_BUTTON #undef MAP_ANALOG if (axes_count > 0 && buttons_count > 0) io.BackendFlags |= ImGuiBackendFlags_HasGamepad; else io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad; } }
bool ImGui_ImplGlfwGL3_Init(GLFWwindow* window, bool install_callbacks, const char* glsl_version) { // Store GL version string so we can refer to it later in case we recreate shaders. if (glsl_version == NULL) glsl_version = "#version 150"; IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(g_GlslVersion)); strcpy(g_GlslVersion, glsl_version); strcat(g_GlslVersion, "\n"); return true; }
/*------------------------------------------------------------------------------ Function name: ae_set_block_select Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET ae_set_block_select(isp_ae_context_t *ae, isp_ae_block_select *blokSelect) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(ae != IM_NULL); IM_ASSERT(ae->regVal != IM_NULL); IM_ASSERT(ae->regOfst != IM_NULL); IM_ASSERT(blokSelect != IM_NULL); //check block select params if((blokSelect->blokNum > 25) || (blokSelect->blokEn > 0x1ffffff)) { IM_ERRMSG((IM_STR("Invalid blokSelect: blokNum=%d, blokEn=0x%x"), blokSelect->blokNum, blokSelect->blokEn)); return IM_RET_INVALID_PARAMETER; } if(ae->enable == IM_TRUE) { /*set ae block num*/ if(blokSelect->blokNum == 0) { SetIspRegister(ae->regVal, ISP_AE_CNTL_NUM_1, (1<<15)/25); } else { SetIspRegister(ae->regVal, ISP_AE_CNTL_NUM_1, (1<<15)/blokSelect->blokNum); } /*set ae block enable*/ SetIspRegister(ae->regVal, ISP_AE_BEN, blokSelect->blokEn); //isppwl_write_regs(); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_CNTL], ae->regVal[rISP_AE_CNTL])); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_AE_BEN], ae->regVal[rISP_AE_BEN])); } ae->blokSelect.blokNum = blokSelect->blokNum; ae->blokSelect.blokEn = blokSelect->blokEn; return IM_RET_OK; Fail: return IM_RET_FAILED; }
bool ImGui::InputTextMultiline(const char* label, std::string* str, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) { IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0); flags |= ImGuiInputTextFlags_CallbackResize; InputTextCallback_UserData cb_user_data; cb_user_data.Str = str; cb_user_data.ChainCallback = callback; cb_user_data.ChainCallbackUserData = user_data; return InputTextMultiline(label, (char*)str->c_str(), str->capacity() + 1, size, flags, InputTextCallback, &cb_user_data); }
/*------------------------------------------------------------------------------ Function name: GetIspRegister Functional description: get uint32 value Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_UINT32 GetIspRegister(const IM_UINT32 * regBase, IM_UINT32 id) { IM_UINT32 tmp; IM_ASSERT(id <= ISP_LAST_REG_ID); tmp = regBase[ispRegSpec[id][0]]; tmp = tmp >> ispRegSpec[id][2]; tmp &= regMask[ispRegSpec[id][1]]; return (tmp); }
/*------------------------------------------------------------------------------ Function name: SetIspRegister Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ void SetIspRegister(IM_UINT32 * regBase, IM_UINT32 id, IM_INT32 value) { IM_UINT32 tmp; IM_ASSERT(id <= ISP_LAST_REG_ID); tmp = regBase[ispRegSpec[id][0]]; tmp &= ~(regMask[ispRegSpec[id][1]] << ispRegSpec[id][2]); tmp |= (value & regMask[ispRegSpec[id][1]]) << ispRegSpec[id][2]; regBase[ispRegSpec[id][0]] = tmp; }
/*------------------------------------------------------------------------------ Function name: hist_set_disable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET hist_set_disable(isp_hist_context_t *hist) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(hist != IM_NULL); IM_ASSERT(hist->regVal != IM_NULL); IM_ASSERT(hist->regOfst != IM_NULL); if(hist->enable != IM_TRUE) { IM_INFOMSG((IM_STR("hist has been disabled"))); return IM_RET_OK; } //disable hist SetIspRegister(hist->regVal, ISP_GLB_CFG2_HISTBYPASS, 1); IM_JIF(isppwl_write_reg(hist->regOfst[rISP_GLB_CFG2], hist->regVal[rISP_GLB_CFG2])); hist->enable = IM_FALSE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: ae_set_disable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET ae_set_disable(isp_ae_context_t *ae) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(ae != IM_NULL); IM_ASSERT(ae->regVal != IM_NULL); IM_ASSERT(ae->regOfst != IM_NULL); if(ae->enable != IM_TRUE) { IM_INFOMSG((IM_STR("ae has been disabled"))); return IM_RET_OK; } /*set ae bypass*/ SetIspRegister(ae->regVal, ISP_GLB_CFG2_AEBYPASS, 1); IM_JIF(isppwl_write_reg(ae->regOfst[rISP_GLB_CFG2], ae->regVal[rISP_GLB_CFG2])); ae->enable = IM_FALSE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
/*------------------------------------------------------------------------------ Function name: af_set_disable Functional description: Inputs: Outputs: Returns: ------------------------------------------------------------------------------*/ IM_RET af_set_disable(isp_af_context_t *af) { IM_INFOMSG((IM_STR("%s"), IM_STR(_IM_FUNC_))); IM_ASSERT(af != IM_NULL); IM_ASSERT(af->regVal != IM_NULL); IM_ASSERT(af->regOfst != IM_NULL); if(af->enable != IM_TRUE) { IM_INFOMSG((IM_STR("af has been disabled"))); return IM_RET_OK; } //disable af SetIspRegister(af->regVal, ISP_GLB_CFG2_AFBYPASS, 1); IM_JIF(isppwl_write_reg(af->regOfst[rISP_GLB_CFG2], af->regVal[rISP_GLB_CFG2])); af->enable = IM_FALSE; return IM_RET_OK; Fail: return IM_RET_FAILED; }
// Functions bool ImGui_ImplOpenGL3_Init(const char* glsl_version) { // Store GLSL version string so we can refer to it later in case we recreate shaders. Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure. #ifdef USE_GL_ES3 if (glsl_version == NULL) glsl_version = "#version 300 es"; #else if (glsl_version == NULL) glsl_version = "#version 130"; #endif IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(g_GlslVersionString)); strcpy(g_GlslVersionString, glsl_version); strcat(g_GlslVersionString, "\n"); return true; }
static int InputTextCallback(ImGuiInputTextCallbackData* data) { InputTextCallback_UserData* user_data = (InputTextCallback_UserData*)data->UserData; if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) { // Resize string callback // If for some reason we refuse the new length (BufTextLen) and/or capacity (BufSize) we need to set them back to what we want. std::string* str = user_data->Str; IM_ASSERT(data->Buf == str->c_str()); str->resize(data->BufTextLen); data->Buf = (char*)str->c_str(); } else if (user_data->ChainCallback) { // Forward to user callback, if any data->UserData = user_data->ChainCallbackUserData; return user_data->ChainCallback(data); } return 0; }
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs. // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application. // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application. // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags. bool ImGui_ImplSDL2_ProcessEvent(SDL_Event* event) { ImGuiIO& io = ImGui::GetIO(); switch (event->type) { case SDL_MOUSEWHEEL: { if (event->wheel.x > 0) io.MouseWheelH += 1; if (event->wheel.x < 0) io.MouseWheelH -= 1; if (event->wheel.y > 0) io.MouseWheel += 1; if (event->wheel.y < 0) io.MouseWheel -= 1; return true; } case SDL_MOUSEBUTTONDOWN: { if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true; if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true; if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true; return true; } case SDL_TEXTINPUT: { io.AddInputCharactersUTF8(event->text.text); return true; } case SDL_KEYDOWN: case SDL_KEYUP: { int key = event->key.keysym.scancode; IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown)); io.KeysDown[key] = (event->type == SDL_KEYDOWN); io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0); io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0); io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0); io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0); return true; } } return false; }
void ImGui_ImplSDL2_NewFrame(SDL_Window* window) { ImGuiIO& io = ImGui::GetIO(); IM_ASSERT(io.Fonts->IsBuilt()); // Font atlas needs to be built, call renderer _NewFrame() function e.g. ImGui_ImplOpenGL3_NewFrame() // Setup display size (every frame to accommodate for window resizing) int w, h; int display_w, display_h; SDL_GetWindowSize(window, &w, &h); SDL_GL_GetDrawableSize(window, &display_w, &display_h); io.DisplaySize = ImVec2((float)w, (float)h); io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0); // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution) static Uint64 frequency = SDL_GetPerformanceFrequency(); Uint64 current_time = SDL_GetPerformanceCounter(); io.DeltaTime = g_Time > 0 ? (float)((double)(current_time - g_Time) / frequency) : (float)(1.0f / 60.0f); g_Time = current_time; ImGui_ImplSDL2_UpdateMousePosAndButtons(); ImGui_ImplSDL2_UpdateMouseCursor(); }