1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
#include "demo.hpp"
#include "gl_context.hpp"
#include "imgui_context.hpp"
#include "sdl_context.hpp"
#include "sdl_main_window.hpp"
#include "stb_image.h"
#include <SDL.h>
#include <SDL_opengl.h>
#include <cstdio>
#include <fud_c_file.hpp>
#include <fud_string.hpp>
#include <imgui/imgui.h>
#include <imgui/imgui_impl_opengl3.h>
#include <imgui/imgui_impl_sdl2.h>
#include <spdlog/spdlog.h>
#include <vector>
namespace bookmouse {
// Simple helper function to load an image into a OpenGL texture with common settings
bool LoadTextureFromMemory(const void* data, size_t data_size, GLuint* out_texture, int* out_width, int* out_height)
{
// Load from file
int width = 0;
int height = 0;
int channelsInFile = 4;
unsigned char*
image_data = stbi_load_from_memory((const unsigned char*)data, (int)data_size, &width, &height, nullptr, 4);
if (image_data == nullptr) {
spdlog::error("Failed to get data from");
return false;
}
spdlog::info("Got result: {} pixels per row of {} scanlines with {} channels", width, height, channelsInFile);
// Create a OpenGL texture identifier
GLuint image_texture;
glGenTextures(1, &image_texture);
glBindTexture(GL_TEXTURE_2D, image_texture);
// Setup filtering parameters for display
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Upload pixels into texture
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data);
stbi_image_free(image_data);
*out_texture = image_texture;
*out_width = width;
*out_height = height;
return true;
}
// Open and read a file, then forward to LoadTextureFromMemory()
bool LoadTextureFromFile(const fud::String& filename, GLuint* out_texture, int* out_width, int* out_height)
{
fud::CBinaryFile inFile{filename, fud::CFileMode::ReadOnly};
auto fileResult = inFile.open();
using fud::FileStatus;
if (fileResult == FileStatus::Error) {
spdlog::error("can't open {}", filename.c_str());
// return err(ImageError::FileError);
return false;
}
auto fileSizeResult = inFile.size();
if (fileSizeResult.isError()) {
spdlog::error("bad file size {} {}", filename.c_str(), FileStatusToString(fileSizeResult.getError()));
return false;
}
auto fileSize = fileSizeResult.getOkay();
auto* filePtr = inFile.file();
if (filePtr == nullptr) {
spdlog::error("File associated with {} returned nullptr", filename.c_str());
// return err(ImageError::FileError);
return false;
}
std::vector<char> fileData{};
fileData.resize(fileSize);
auto readResult = inFile.read(fileData.data(), fileSize, fileSize);
if (readResult.status != FileStatus::Success) {
spdlog::error("bad read {} {}", filename.c_str(), FileStatusToString(readResult.status));
return false;
}
bool ret = LoadTextureFromMemory(fileData.data(), fileSize, out_texture, out_width, out_height);
return ret;
}
int demo(const fud::String& m_filename)
{
SdlContext sdlContext{};
SdlMainWindow mainWindow{sdlContext};
GlContext glContext{mainWindow};
ImguiContext imguiContext{glContext, sdlContext, mainWindow};
// Setup Platform/Renderer backends
int my_image_width = 0;
int my_image_height = 0;
GLuint my_image_texture = 0;
bool ret = LoadTextureFromFile(m_filename, &my_image_texture, &my_image_width, &my_image_height);
IM_ASSERT(ret);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
// Main loop
bool done = false;
while (!done)
{
// Poll and handle events (inputs, window resize, etc.)
// 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, or
// clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or
// clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those
// two flags.
SDL_Event event;
while (SDL_PollEvent(&event)) {
ImGui_ImplSDL2_ProcessEvent(&event);
if (event.type == SDL_QUIT) {
done = true;
}
if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE &&
event.window.windowID == SDL_GetWindowID(mainWindow.window())) {
done = true;
}
}
if (SDL_GetWindowFlags(mainWindow.window()) & SDL_WINDOW_MINIMIZED) {
SDL_Delay(10);
continue;
}
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplSDL2_NewFrame();
ImGui::NewFrame();
// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code
// to learn more about Dear ImGui!).
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
{
ImGui::Begin("OpenGL Texture Text");
ImGui::Text("pointer = %x", my_image_texture);
ImGui::Text("size = %d x %d", my_image_width, my_image_height);
ImGui::Image(
(void*)(intptr_t)my_image_texture,
ImVec2(static_cast<float>(my_image_width), static_cast<float>(my_image_height)));
ImGui::End();
static float f = 0.0f;
static int counter = 0;
// Create a window called "Hello, world!" and append into it.
ImGui::Begin("Hello, world!");
// Display some text (you can use a format strings too)
ImGui::Text("This is some useful text.");
// Edit bools storing our window open/close state
ImGui::Checkbox("Demo Window", &show_demo_window);
ImGui::Checkbox("Another Window", &show_another_window);
// Edit 1 float using a slider from 0.0f to 1.0f
ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
// Edit 3 floats representing a color
ImGui::ColorEdit3("clear color", (float*)&clear_color);
// Buttons return true when clicked (most widgets return true when edited/activated)
if (ImGui::Button("Button"))
counter++;
ImGui::SameLine();
ImGui::Text("counter = %d", counter);
auto framerate = imguiContext.getIO().Framerate;
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / framerate, framerate);
ImGui::End();
}
// 3. Show another simple window.
if (show_another_window) {
// Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when
// clicked)
ImGui::Begin("Another Window", &show_another_window);
ImGui::Text("Hello from another window!");
if (ImGui::Button("Close Me"))
show_another_window = false;
ImGui::End();
}
// Rendering
ImGui::Render();
const auto& imguiIO = imguiContext.getIO();
glViewport(0, 0, static_cast<int>(imguiIO.DisplaySize.x), static_cast<int>(imguiIO.DisplaySize.y));
glClearColor(
clear_color.x * clear_color.w,
clear_color.y * clear_color.w,
clear_color.z * clear_color.w,
clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
SDL_GL_SwapWindow(mainWindow.window());
}
// return ImageResult::okay(image);
return 0;
}
} // namespace bookmouse
// (* 3840 2160) 8294400
// (* 2 2560 1440) 7372800
|
