maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove old Linux texture test file

Browse Source
This commit is contained in:
Nick Fisher
2023-09-22 08:21:17 +08:00
parent dc324435aa
commit 504b1efda4
1 changed files with 0 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

356
linux/Untitled-1.cpp
View File

@@ -1,356 +0,0 @@
// static gboolean
// create_contextp (GtkGLArea *area, GdkGLContext *context)
// {
// std::cout << "CREATE CONTEXT" << std::endl;
// gdk_gl_context_set_debug_enabled(context, true);
// // gtk_gl_area_make_current (area);
// std::cout << "MADE CURENTR" << std::endl;
// return TRUE;
// }
/* position and color information for each vertex */
struct vertex_info {
float position[3];
float color[3];
};
/* the vertex data is constant */
static const struct vertex_info vertex_data[] = {
{ { 0.0f, 0.500f, 0.0f }, { 1.f, 0.f, 0.f } },
{ { 0.5f, -0.366f, 0.0f }, { 0.f, 1.f, 0.f } },
{ { -0.5f, -0.366f, 0.0f }, { 0.f, 0.f, 1.f } },
};
static void
init_buffers (guint position_index,
guint color_index,
guint *vao_out)
{
guint vao, buffer;
/* we need to create a VAO to store the other buffers */
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
/* this is the VBO that holds the vertex data */
glGenBuffers (1, &buffer);
glBindBuffer (GL_ARRAY_BUFFER, buffer);
glBufferData (GL_ARRAY_BUFFER, sizeof (vertex_data), vertex_data, GL_STATIC_DRAW);
/* enable and set the position attribute */
glEnableVertexAttribArray (position_index);
glVertexAttribPointer (position_index, 3, GL_FLOAT, GL_FALSE,
sizeof (struct vertex_info),
(GLvoid *) (G_STRUCT_OFFSET (struct vertex_info, position)));
/* enable and set the color attribute */
glEnableVertexAttribArray (color_index);
glVertexAttribPointer (color_index, 3, GL_FLOAT, GL_FALSE,
sizeof (struct vertex_info),
(GLvoid *) (G_STRUCT_OFFSET (struct vertex_info, color)));
/* reset the state; we will re-enable the VAO when needed */
glBindBuffer (GL_ARRAY_BUFFER, 0);
glBindVertexArray (0);
/* the VBO is referenced by the VAO */
glDeleteBuffers (1, &buffer);
if (vao_out != NULL)
*vao_out = vao;
}
static guint
create_shader (int shader_type,
const char *source,
GError **error,
guint *shader_out)
{
guint shader = glCreateShader (shader_type);
glShaderSource (shader, 1, &source, NULL);
glCompileShader (shader);
int status;
glGetShaderiv (shader, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
std::cout << "SHADER IV ERROR" << std::endl;
}
if (shader_out != NULL)
*shader_out = shader;
return shader != 0;
}
static gboolean
init_shaders (guint *program_out,
guint *position_location_out,
guint *color_location_out,
GError **error)
{
const char *vsource = R"POO(#version 130
in vec3 position;
in vec3 color;
uniform mat4 mvp;
smooth out vec4 vertexColor;
void main() {
gl_Position = vec4(position, 1.0);
vertexColor = vec4(color, 1.0);
})POO";
const char *fsource = R"POO(#version 130
smooth in vec4 vertexColor;
out vec4 outputColor;
void main() {
outputColor = vertexColor;
})POO";
guint program = 0;
guint vertex = 0, fragment = 0;
guint position_location = 0;
guint color_location = 0;
/* load the vertex shader */
// source = g_resources_lookup_data ("/io/bassi/glarea/glarea-vertex.glsl", 0, NULL);
create_shader (GL_VERTEX_SHADER, vsource, error, &vertex);
// g_bytes_unref (source);
if (vertex == 0) {
std::cout << "VERTEX ERROR" << std::endl;
}
/* load the fragment shader */
// source = g_resources_lookup_data ("/io/bassi/glarea/glarea-fragment.glsl", 0, NULL);
create_shader (GL_FRAGMENT_SHADER, fsource, error, &fragment);
if (fragment == 0)
std::cout << "FRAF ERROR" << std::endl;
/* link the vertex and fragment shaders together */
program = glCreateProgram ();
if(program == 0) {
std::cout << "PROG ZERO" << std::endl;
}
glAttachShader (program, vertex);
glAttachShader (program, fragment);
glLinkProgram (program);
int status = 0;
glGetProgramiv (program, GL_LINK_STATUS, &status);
if (status == GL_FALSE)
{
std::cout << "glGetProgramiv ERROR" << std::endl;
goto out;
}
position_location = glGetAttribLocation (program, "position");
/* get the location of the "position" and "color" attributes */
color_location = glGetAttribLocation (program, "color");
/* the individual shaders can be detached and destroyed */
glDetachShader (program, vertex);
glDetachShader (program, fragment);
out:
if (vertex != 0)
glDeleteShader (vertex);
if (fragment != 0)
glDeleteShader (fragment);
if (program_out != NULL)
*program_out = program;
if (position_location_out != NULL)
*position_location_out = position_location;
if (color_location_out != NULL)
*color_location_out = color_location;
return program != 0;
}
static void
gl_init (PolyvoxFilamentPlugin *self)
{
/* we need to ensure that the GdkGLContext is set before calling GL API */
gtk_gl_area_make_current (GTK_GL_AREA (self->gl_drawing_area));
/* if the GtkGLArea is in an error state we don't do anything */
if (gtk_gl_area_get_error (GTK_GL_AREA (self->gl_drawing_area)) != NULL)
return;
/* initialize the shaders and retrieve the program data */
GError *error = NULL;
if (!init_shaders (&self->program,
&self->position_index,
&self->color_index,
&error))
{
/* set the GtkGLArea in error state, so we'll see the error message
* rendered inside the viewport
*/
gtk_gl_area_set_error (GTK_GL_AREA (self->gl_drawing_area), error);
g_error_free (error);
return;
}
/* initialize the vertex buffers */
init_buffers (self->position_index, self->color_index, &self->vao);
}
// static void
// gl_fini (PolyvoxFilamentPlugin *self)
// {
// /* we need to ensure that the GdkGLContext is set before calling GL API */
// gtk_gl_area_make_current (GTK_GL_AREA (self->gl_drawing_area));
// /* skip everything if we're in error state */
// if (gtk_gl_area_get_error (GTK_GL_AREA (self->gl_drawing_area)) != NULL)
// return;
// /* destroy all the resources we created */
// if (self->vao != 0)
// glDeleteVertexArrays (1, &self->vao);
// if (self->program != 0)
// glDeleteProgram (self->program);
// }
static void
draw_triangle (PolyvoxFilamentPlugin *self)
{
if (self->program == 0 || self->vao == 0)
return;
/* load our program */
glUseProgram (self->program);
/* use the buffers in the VAO */
glBindVertexArray (self->vao);
/* draw the three vertices as a triangle */
glDrawArrays (GL_TRIANGLES, 0, 3);
/* we finished using the buffers and program */
glBindVertexArray (0);
glUseProgram (0);
}
static gboolean
gl_draw (PolyvoxFilamentPlugin *self)
{
/* clear the viewport; the viewport is automatically resized when
* the GtkGLArea gets a new size allocation
*/
glClearColor (0.5, 0.5, 0.5, 1.0);
glClear (GL_COLOR_BUFFER_BIT);
/* draw our object */
draw_triangle (self);
/* flush the contents of the pipeline */
glFlush ();
return FALSE;
}
// static void
// on_realize (GtkGLArea *area, PolyvoxFilamentPlugin* self)
// {
// std::cout << "REALIZE" << std::endl;
// // GdkGLContext* context = gtk_gl_area_get_context(area); // gdk_window_create_gl_context(window, &error);
// gtk_gl_area_make_current(area);
// if(gtk_gl_area_get_error (area)) {
// std::cout << "ERROR" << std::endl;
// }
// }
// static gboolean
// renderp (GtkGLArea *area, GdkGLContext *context)
// {
// glClearColor (0.0f, 1.0f, 0.0f, 1.0f);
// glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// GLuint vao;
// glGenVertexArrays(1, &vao);
// glBindVertexArray(vao);
// GLuint texture_id = 0;
// glGenTextures (1, &texture_id);
// glBindTexture (GL_TEXTURE_2D, texture_id);
// // further configuration here.
// int len = 2000 * 2000 * 3;
// auto buffer = new std::vector<uint8_t>(len);
// for (int i = 0; i < len; i++)
// {
// if(i % 3 == 0) {
// buffer->at(i) = (uint8_t)255;
// } else {
// buffer->at(i) = (uint8_t)0;
// }
// }
// glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB8, 2000, 2000, 0, GL_RGB,
// GL_UNSIGNED_BYTE, buffer->data());
// std::cout << "RENDER texture iD" << texture_id << std::endl;
// // create_filament_texture(400, 200, self->texture_registrar);
// glFinish();
// std::cout << "RENDER" << std::endl;
// // we completed our drawing; the draw commands will be
// // flushed at the end of the signal emission chain, and
// // the buffers will be drawn on the window
// return TRUE;
// }
// GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET(self->fl_view));
// if (gtk_widget_is_toplevel (toplevel))
// {
// std::cout << "TOPLEVLE" << std::endl;
// }
// gdk_gl_context_set_debug_enabled(context, true);
// GtkGLArea *gl_area = (GtkGLArea *) gtk_gl_area_new ();
// gtk_widget_show(GTK_WIDGET(gl_area));
// GtkBox* parent = GTK_BOX(gtk_widget_get_parent(GTK_WIDGET(self->fl_view)));
// gtk_box_pack_start(parent, GTK_WIDGET(gl_area), true, true,0);
// self->gl_drawing_area = GTK_WIDGET(gl_area);
// GdkGLContext* context = gtk_gl_area_get_context(gl_area);
// g_signal_connect_swapped(gl_area, "realize", G_CALLBACK (gl_init), self);
// g_signal_connect_swapped (gl_area, "render", G_CALLBACK (gl_draw), self);
// g_signal_connect (gl_area, "create-context", G_CALLBACK (create_contextp), NULL);